{"version":3,"sources":["webpack:///(webpack)/buildin/amd-options.js","webpack:///./src/views/coursebuilder/jquery.js"],"names":["module","exports","__webpack_amd_options__","window","undefined","readyList","rootjQuery","core_strundefined","document","location","_jQuery","jQuery","_$","$","class2type","core_deletedIds","core_version","core_concat","concat","core_push","push","core_slice","slice","core_indexOf","indexOf","core_toString","toString","core_hasOwn","hasOwnProperty","core_trim","trim","selector","context","fn","init","core_pnum","source","core_rnotwhite","rtrim","rquickExpr","rsingleTag","rvalidchars","rvalidbraces","rvalidescape","rvalidtokens","rmsPrefix","rdashAlpha","fcamelCase","all","letter","toUpperCase","completed","event","addEventListener","type","readyState","detach","ready","removeEventListener","detachEvent","isArraylike","obj","length","isWindow","nodeType","prototype","jquery","constructor","match","elem","this","charAt","exec","find","merge","parseHTML","ownerDocument","test","isPlainObject","isFunction","attr","getElementById","parentNode","id","makeArray","size","toArray","call","get","num","pushStack","elems","ret","prevObject","each","callback","args","promise","done","apply","arguments","first","eq","last","i","len","j","map","end","sort","splice","extend","src","copyIsArray","copy","name","options","clone","target","deep","isArray","noConflict","isReady","readyWait","holdReady","hold","wait","body","setTimeout","resolveWith","trigger","off","Array","isNumeric","isNaN","parseFloat","isFinite","String","e","key","isEmptyObject","error","msg","Error","data","keepScripts","parsed","scripts","createElement","buildFragment","remove","childNodes","parseJSON","JSON","parse","replace","Function","parseXML","xml","tmp","DOMParser","parseFromString","ActiveXObject","async","loadXML","documentElement","getElementsByTagName","noop","globalEval","execScript","camelCase","string","nodeName","toLowerCase","value","text","arr","results","Object","inArray","Math","max","second","l","grep","inv","retVal","arg","guid","proxy","access","chainable","emptyGet","raw","bulk","now","Date","getTime","Deferred","attachEvent","top","frameElement","doScroll","doScrollCheck","split","optionsCache","createOptions","object","_","flag","Callbacks","firing","memory","fired","firingLength","firingIndex","firingStart","list","stack","once","fire","stopOnFalse","shift","self","disable","add","start","unique","has","index","empty","disabled","lock","locked","fireWith","func","tuples","state","always","deferred","fail","then","fns","newDefer","tuple","action","returned","resolve","reject","progress","notify","pipe","stateString","when","subordinate","progressValues","progressContexts","resolveContexts","resolveValues","remaining","updateFunc","contexts","values","notifyWith","support","a","input","select","fragment","opt","eventName","isSupported","div","setAttribute","innerHTML","appendChild","style","cssText","getSetAttribute","className","leadingWhitespace","firstChild","tbody","htmlSerialize","getAttribute","hrefNormalized","opacity","cssFloat","checkOn","optSelected","selected","enctype","html5Clone","cloneNode","outerHTML","boxModel","compatMode","deleteExpando","noCloneEvent","inlineBlockNeedsLayout","shrinkWrapBlocks","reliableMarginRight","boxSizingReliable","pixelPosition","checked","noCloneChecked","optDisabled","radioValue","createDocumentFragment","appendChecked","checkClone","lastChild","click","submit","change","focusin","attributes","expando","backgroundClip","clearCloneStyle","container","marginDiv","tds","divReset","offsetHeight","display","reliableHiddenOffsets","boxSizing","offsetWidth","doesNotIncludeMarginInBodyOffset","offsetTop","getComputedStyle","width","marginRight","zoom","removeChild","rbrace","rmultiDash","internalData","pvt","acceptData","thisCache","internalKey","getByName","isNode","cache","pop","toJSON","internalRemoveData","isEmptyDataObject","cleanData","dataAttr","random","noData","hasData","removeData","_data","_removeData","attrs","queue","dequeue","startLength","hooks","_queueHooks","next","cur","unshift","stop","setter","delay","time","fx","speeds","timeout","clearTimeout","clearQueue","count","defer","elements","nodeHook","boolHook","rclass","rreturn","rfocusable","rclickable","rboolean","ruseDefault","getSetInput","removeAttr","prop","removeProp","propFix","addClass","classes","clazz","proceed","removeClass","toggleClass","stateVal","isBool","classNames","hasClass","val","valHooks","set","option","specified","selectedIndex","one","notxml","nType","isXMLDoc","attrHooks","propName","attrNames","removeAttribute","tabindex","readonly","maxlength","cellspacing","cellpadding","rowspan","colspan","usemap","frameborder","contenteditable","propHooks","tabIndex","attributeNode","getAttributeNode","parseInt","href","detail","defaultValue","button","setAttributeNode","createAttribute","parent","rformElems","rkeyEvent","rmouseEvent","rfocusMorph","rtypenamespace","returnTrue","returnFalse","global","types","handler","events","t","handleObjIn","special","eventHandle","handleObj","handlers","namespaces","origType","elemData","handle","triggered","dispatch","delegateType","bindType","needsContext","expr","namespace","join","delegateCount","setup","mappedTypes","origCount","RegExp","teardown","removeEvent","onlyHandlers","ontype","bubbleType","eventPath","Event","isTrigger","namespace_re","result","noBubble","defaultView","parentWindow","isPropagationStopped","preventDefault","isDefaultPrevented","_default","fix","matched","handlerQueue","delegateTarget","preDispatch","currentTarget","isImmediatePropagationStopped","stopPropagation","postDispatch","sel","matches","originalEvent","fixHook","fixHooks","mouseHooks","keyHooks","props","srcElement","metaKey","filter","original","which","charCode","keyCode","eventDoc","doc","fromElement","pageX","clientX","scrollLeft","clientLeft","pageY","clientY","scrollTop","clientTop","relatedTarget","toElement","load","focus","activeElement","blur","beforeunload","returnValue","simulate","bubble","isSimulated","defaultPrevented","getPreventDefault","timeStamp","cancelBubble","stopImmediatePropagation","mouseenter","mouseleave","orig","related","contains","submitBubbles","form","_submit_bubble","changeBubbles","propertyName","_just_changed","focusinBubbles","attaches","on","origFn","bind","unbind","delegate","undelegate","triggerHandler","cachedruns","Expr","getText","isXML","compile","hasDuplicate","outermostContext","setDocument","docElem","documentIsXML","rbuggyQSA","rbuggyMatches","sortOrder","preferredDoc","dirruns","classCache","createCache","tokenCache","compilerCache","strundefined","MAX_NEGATIVE","whitespace","characterEncoding","identifier","operators","pseudos","rcomma","rcombinators","rpseudo","ridentifier","matchExpr","rsibling","rnative","rinputs","rheader","rescape","rattributeQuotes","runescape","funescape","escaped","high","fromCharCode","isNative","keys","cacheLength","markFunction","assert","Sizzle","seed","m","groups","old","nid","newContext","newSelector","getByClassName","getElementsByClassName","qsa","tokenize","toSelector","querySelectorAll","qsaError","siblingCheck","b","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createPositionalPseudo","argument","matchIndexes","node","tagNameNoComments","createComment","insertBefore","pass","getElementsByName","getIdNotName","attrHandle","attrId","tag","matchesSelector","mozMatchesSelector","webkitMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","aup","ap","bp","detectDuplicates","uniqueSort","duplicates","textContent","nodeValue","selectors","createPseudo","relative","dir","preFilter","excess","unquoted","pattern","operator","check","what","simple","forward","ofType","outerCache","nodeIndex","useCache","pseudo","setFilters","idx","matcher","unmatched","innerText","lang","elemLang","hash","hasFocus","radio","checkbox","file","password","image","reset","parseOnly","tokens","soFar","preFilters","cached","addCombinator","combinator","base","checkNonElements","doneName","dirkey","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","matcherFromGroupMatchers","elementMatchers","setMatchers","matcherCachedRuns","bySet","byElement","superMatcher","expandContext","setMatched","matchedCount","outermost","contextBackup","dirrunsUnique","token","group","filters","runtil","rparentsprev","isSimple","rneedsContext","guaranteedUnique","children","contents","prev","sibling","winnow","qualifier","keep","filtered","createSafeFragment","nodeNames","safeFrag","targets","not","is","closest","pos","prevAll","addBack","andSelf","parents","parentsUntil","until","nextAll","nextUntil","prevUntil","siblings","contentDocument","contentWindow","reverse","n","r","rinlinejQuery","rnoshimcache","rleadingWhitespace","rxhtmlTag","rtagName","rtbody","rhtml","rnoInnerhtml","manipulation_rcheckableType","rchecked","rscriptType","rscriptTypeMasked","rcleanScript","wrapMap","legend","area","param","thead","tr","col","td","safeFragment","fragmentDiv","findOrAppend","disableScript","restoreScript","setGlobalEval","refElements","cloneCopyEvent","dest","oldData","curData","fixCloneNodeIssues","defaultChecked","defaultSelected","getAll","found","fixDefaultChecked","optgroup","tfoot","colgroup","caption","th","append","createTextNode","wrapAll","html","wrap","wrapInner","unwrap","replaceWith","domManip","prepend","before","after","keepData","dataAndEvents","deepDataAndEvents","isFunc","table","hasScripts","iNoClone","ajax","url","dataType","appendTo","prependTo","insertAfter","replaceAll","insert","destElements","srcElements","inPage","selection","safe","nodes","iframe","getStyles","curCSS","ralpha","ropacity","rposition","rdisplayswap","rmargin","rnumsplit","rnumnonpx","rrelNum","elemdisplay","BODY","cssShow","position","visibility","cssNormalTransform","letterSpacing","fontWeight","cssExpand","cssPrefixes","vendorPropName","capName","origName","isHidden","el","css","showHide","show","hidden","css_defaultDisplay","setPositiveNumber","subtract","augmentWidthOrHeight","extra","isBorderBox","styles","getWidthOrHeight","valueIsBorderBox","actualDisplay","write","close","hide","toggle","bool","cssHooks","computed","cssNumber","cssProps","swap","_computed","minWidth","maxWidth","getPropertyValue","currentStyle","left","rs","rsLeft","runtimeStyle","pixelLeft","$1","visible","margin","padding","border","prefix","suffix","expand","expanded","parts","r20","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","v","serialize","serializeArray","s","encodeURIComponent","ajaxSettings","hover","fnOver","fnOut","ajaxLocParts","ajaxLocation","ajax_nonce","ajax_rquery","rhash","rts","rheaders","rlocalProtocol","rnoContent","rprotocol","rurl","_load","prefilters","transports","allTypes","addToPrefiltersOrTransports","structure","dataTypeExpression","dataTypes","inspectPrefiltersOrTransports","originalOptions","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxHandleResponses","responses","firstDataType","ct","finalDataType","responseFields","mimeType","getResponseHeader","converters","ajaxConvert","response","conv2","current","conv","dataFilter","params","responseText","complete","status","method","success","active","lastModified","etag","isLocal","processData","contentType","accepts","json","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","cacheURL","responseHeadersString","timeoutTimer","fireGlobals","transport","responseHeaders","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getAllResponseHeaders","setRequestHeader","lname","overrideMimeType","code","abort","statusText","finalText","crossDomain","hasContent","ifModified","headers","beforeSend","send","nativeStatusText","isSuccess","modified","rejectWith","getScript","getJSON","script","head","scriptCharset","charset","onload","onreadystatechange","isAbort","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","xhrCallbacks","xhrSupported","xhrId","xhrOnUnloadAbort","createStandardXHR","XMLHttpRequest","createActiveXHR","xhr","cors","username","open","xhrFields","err","firefoxAccessException","unload","fxNow","timerId","rfxtypes","rfxnum","rrun","animationPrefilters","defaultPrefilter","tweeners","unit","tween","createTween","scale","maxIterations","createFxNow","createTweens","animation","collection","Animation","properties","stopped","tick","currentTime","startTime","duration","percent","tweens","run","opts","specialEasing","originalProperties","Tween","easing","gotoEnd","propFilter","timer","anim","dataShow","oldfire","handled","unqueued","overflow","overflowX","overflowY","genFx","includeWidth","height","getWindow","tweener","prefilter","eased","step","cssFn","speed","animate","fadeTo","to","optall","doAnimation","finish","stopQueue","timers","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","linear","p","swing","cos","PI","interval","setInterval","clearInterval","slow","fast","animated","offset","setOffset","win","box","getBoundingClientRect","pageYOffset","pageXOffset","curTop","curLeft","curElem","curOffset","curCSSTop","curCSSLeft","calculatePosition","curPosition","using","offsetParent","parentOffset","scrollTo","Height","Width","content","defaultExtra","funcName"],"mappings":"oGAAA,YACAA,EAAOC,QAAUC,I,oCCDjB;;;;;;;;;;;;;IAaA,SAAWC,EAAQC,GAOjB,IAEEC,EAGAC,EAIAC,SAA2BH,EAG3BI,EAAWL,EAAOK,SAClBC,EAAWN,EAAOM,SAGlBC,EAAUP,EAAOQ,OAGjBC,EAAKT,EAAOU,EAGZC,EAAa,GAGbC,EAAkB,GAElBC,EAAe,QAGfC,EAAcF,EAAgBG,OAC9BC,EAAYJ,EAAgBK,KAC5BC,EAAaN,EAAgBO,MAC7BC,EAAeR,EAAgBS,QAC/BC,EAAgBX,EAAWY,SAC3BC,EAAcb,EAAWc,eACzBC,EAAYb,EAAac,KAGzBnB,EAAS,SAAUoB,EAAUC,GAE3B,OAAO,IAAIrB,EAAOsB,GAAGC,KAAKH,EAAUC,EAAS1B,IAI/C6B,EAAY,sCAAsCC,OAGlDC,EAAiB,OAGjBC,EAAQ,qCAKRC,EAAa,mCAGbC,EAAa,6BAGbC,EAAc,gBACdC,EAAe,uBACfC,EAAe,qCACfC,EAAe,kEAGfC,EAAY,QACZC,EAAa,eAGbC,EAAa,SAAUC,EAAKC,GAC1B,OAAOA,EAAOC,eAIhBC,EAAY,SAAUC,IAGhB5C,EAAS6C,kBAAmC,SAAfD,EAAME,MAA2C,aAAxB9C,EAAS+C,cACjEC,IACA7C,EAAO8C,UAIXD,EAAS,WACHhD,EAAS6C,kBACX7C,EAASkD,oBAAoB,mBAAoBP,GAAW,GAC5DhD,EAAOuD,oBAAoB,OAAQP,GAAW,KAG9C3C,EAASmD,YAAY,qBAAsBR,GAC3ChD,EAAOwD,YAAY,SAAUR,KAq0BnC,SAASS,EAAYC,GACnB,IAAIC,EAASD,EAAIC,OACfR,EAAO3C,EAAO2C,KAAKO,GAErB,OAAIlD,EAAOoD,SAASF,OAIC,IAAjBA,EAAIG,WAAkBF,KAIV,UAATR,GAA6B,aAATA,IACb,IAAXQ,GACmB,kBAAXA,GAAuBA,EAAS,GAAMA,EAAS,KAAMD,KA/0BlElD,EAAOsB,GAAKtB,EAAOsD,UAAY,CAE7BC,OAAQlD,EAERmD,YAAaxD,EACbuB,KAAM,SAAUH,EAAUC,EAAS1B,GACjC,IAAI8D,EAAOC,EAGX,IAAKtC,EACH,OAAOuC,KAIT,GAAwB,kBAAbvC,EAAuB,CAUhC,GAPEqC,EAFyB,MAAvBrC,EAASwC,OAAO,IAAuD,MAAzCxC,EAASwC,OAAOxC,EAAS+B,OAAS,IAAc/B,EAAS+B,QAAU,EAE3F,CAAC,KAAM/B,EAAU,MAGjBQ,EAAWiC,KAAKzC,IAItBqC,IAAUA,EAAM,IAAOpC,EAqDpB,OAAKA,GAAWA,EAAQkC,QACrBlC,GAAW1B,GAAYmE,KAAK1C,GAK7BuC,KAAKH,YAAYnC,GAASyC,KAAK1C,GAxDtC,GAAIqC,EAAM,GAAI,CAWZ,GAVApC,EAAUA,aAAmBrB,EAASqB,EAAQ,GAAKA,EAGnDrB,EAAO+D,MAAMJ,KAAM3D,EAAOgE,UACxBP,EAAM,GACNpC,GAAWA,EAAQgC,SAAWhC,EAAQ4C,eAAiB5C,EAAUxB,GACjE,IAIEgC,EAAWqC,KAAKT,EAAM,KAAOzD,EAAOmE,cAAc9C,GACpD,IAAKoC,KAASpC,EAERrB,EAAOoE,WAAWT,KAAKF,IACzBE,KAAKF,GAAOpC,EAAQoC,IAIpBE,KAAKU,KAAKZ,EAAOpC,EAAQoC,IAK/B,OAAOE,KAQP,GAJAD,EAAO7D,EAASyE,eAAeb,EAAM,IAIjCC,GAAQA,EAAKa,WAAY,CAG3B,GAAIb,EAAKc,KAAOf,EAAM,GACpB,OAAO9D,EAAWmE,KAAK1C,GAIzBuC,KAAKR,OAAS,EACdQ,KAAK,GAAKD,EAKZ,OAFAC,KAAKtC,QAAUxB,EACf8D,KAAKvC,SAAWA,EACTuC,KAcN,OAAIvC,EAASiC,UAClBM,KAAKtC,QAAUsC,KAAK,GAAKvC,EACzBuC,KAAKR,OAAS,EACPQ,MAIE3D,EAAOoE,WAAWhD,GACpBzB,EAAWmD,MAAM1B,IAGtBA,EAASA,WAAa3B,IACxBkE,KAAKvC,SAAWA,EAASA,SACzBuC,KAAKtC,QAAUD,EAASC,SAGnBrB,EAAOyE,UAAUrD,EAAUuC,QAIpCvC,SAAU,GAGV+B,OAAQ,EAGRuB,KAAM,WACJ,OAAOf,KAAKR,QAGdwB,QAAS,WACP,OAAOjE,EAAWkE,KAAKjB,OAKzBkB,IAAK,SAAUC,GACb,OAAc,MAAPA,EAGLnB,KAAKgB,UAGJG,EAAM,EAAInB,KAAKA,KAAKR,OAAS2B,GAAOnB,KAAKmB,IAK9CC,UAAW,SAAUC,GAGnB,IAAIC,EAAMjF,EAAO+D,MAAMJ,KAAKH,cAAewB,GAO3C,OAJAC,EAAIC,WAAavB,KACjBsB,EAAI5D,QAAUsC,KAAKtC,QAGZ4D,GAMTE,KAAM,SAAUC,EAAUC,GACxB,OAAOrF,EAAOmF,KAAKxB,KAAMyB,EAAUC,IAGrCvC,MAAO,SAAUxB,GAIf,OAFAtB,EAAO8C,MAAMwC,UAAUC,KAAKjE,GAErBqC,MAGThD,MAAO,WACL,OAAOgD,KAAKoB,UAAUrE,EAAW8E,MAAM7B,KAAM8B,aAG/CC,MAAO,WACL,OAAO/B,KAAKgC,GAAG,IAGjBC,KAAM,WACJ,OAAOjC,KAAKgC,IAAI,IAGlBA,GAAI,SAAUE,GACZ,IAAIC,EAAMnC,KAAKR,OACb4C,GAAKF,GAAKA,EAAI,EAAIC,EAAM,GAC1B,OAAOnC,KAAKoB,UAAUgB,GAAK,GAAKA,EAAID,EAAM,CAACnC,KAAKoC,IAAM,KAGxDC,IAAK,SAAUZ,GACb,OAAOzB,KAAKoB,UAAU/E,EAAOgG,IAAIrC,MAAM,SAAUD,EAAMmC,GACrD,OAAOT,EAASR,KAAKlB,EAAMmC,EAAGnC,QAIlCuC,IAAK,WACH,OAAOtC,KAAKuB,YAAcvB,KAAKH,YAAY,OAK7C/C,KAAMD,EACN0F,KAAM,GAAGA,KACTC,OAAQ,GAAGA,QAIbnG,EAAOsB,GAAGC,KAAK+B,UAAYtD,EAAOsB,GAElCtB,EAAOoG,OAASpG,EAAOsB,GAAG8E,OAAS,WACjC,IAAIC,EAAKC,EAAaC,EAAMC,EAAMC,EAASC,EACzCC,EAASlB,UAAU,IAAM,GACzBI,EAAI,EACJ1C,EAASsC,UAAUtC,OACnByD,GAAO,EAqBT,IAlBsB,mBAAXD,IACTC,EAAOD,EACPA,EAASlB,UAAU,IAAM,GAEzBI,EAAI,GAIgB,kBAAXc,GAAwB3G,EAAOoE,WAAWuC,KACnDA,EAAS,IAIPxD,IAAW0C,IACbc,EAAShD,OACPkC,GAGGA,EAAI1C,EAAQ0C,IAEjB,GAAgC,OAA3BY,EAAUhB,UAAUI,IAEvB,IAAKW,KAAQC,EACXJ,EAAMM,EAAOH,GACbD,EAAOE,EAAQD,GAGXG,IAAWJ,IAKXK,GAAQL,IAASvG,EAAOmE,cAAcoC,KAAUD,EAActG,EAAO6G,QAAQN,MAC3ED,GACFA,GAAc,EACdI,EAAQL,GAAOrG,EAAO6G,QAAQR,GAAOA,EAAM,IAG3CK,EAAQL,GAAOrG,EAAOmE,cAAckC,GAAOA,EAAM,GAInDM,EAAOH,GAAQxG,EAAOoG,OAAOQ,EAAMF,EAAOH,IAGjCA,IAAS9G,IAClBkH,EAAOH,GAAQD,IAOvB,OAAOI,GAGT3G,EAAOoG,OAAO,CACZU,WAAY,SAAUF,GASpB,OARIpH,EAAOU,IAAMF,IACfR,EAAOU,EAAID,GAGT2G,GAAQpH,EAAOQ,SAAWA,IAC5BR,EAAOQ,OAASD,GAGXC,GAIT+G,SAAS,EAITC,UAAW,EAGXC,UAAW,SAAUC,GACfA,EACFlH,EAAOgH,YAEPhH,EAAO8C,OAAM,IAKjBA,MAAO,SAAUqE,GAGf,MAAa,IAATA,IAAkBnH,EAAOgH,UAAYhH,EAAO+G,SAAhD,CAKA,IAAKlH,EAASuH,KACZ,OAAOC,WAAWrH,EAAO8C,OAI3B9C,EAAO+G,SAAU,GAGJ,IAATI,KAAmBnH,EAAOgH,UAAY,IAK1CtH,EAAU4H,YAAYzH,EAAU,CAACG,IAG7BA,EAAOsB,GAAGiG,SACZvH,EAAOH,GAAU0H,QAAQ,SAASC,IAAI,YAO1CpD,WAAY,SAAUlB,GACpB,MAA4B,aAArBlD,EAAO2C,KAAKO,IAGrB2D,QAASY,MAAMZ,SAAW,SAAU3D,GAClC,MAA4B,UAArBlD,EAAO2C,KAAKO,IAGrBE,SAAU,SAAUF,GAClB,OAAc,MAAPA,GAAeA,GAAOA,EAAI1D,QAGnCkI,UAAW,SAAUxE,GACnB,OAAQyE,MAAMC,WAAW1E,KAAS2E,SAAS3E,IAG7CP,KAAM,SAAUO,GACd,OAAW,MAAPA,EACK4E,OAAO5E,GAEM,kBAARA,GAAmC,oBAARA,EACvC/C,EAAWW,EAAc8D,KAAK1B,KAAS,gBAChCA,GAGXiB,cAAe,SAAUjB,GAIvB,IAAKA,GAA4B,WAArBlD,EAAO2C,KAAKO,IAAqBA,EAAIG,UAAYrD,EAAOoD,SAASF,GAC3E,OAAO,EAGT,IAEE,GAAIA,EAAIM,cACLxC,EAAY4D,KAAK1B,EAAK,iBACtBlC,EAAY4D,KAAK1B,EAAIM,YAAYF,UAAW,iBAC7C,OAAO,EAET,MAAOyE,GAEP,OAAO,EAMT,IAAIC,EACJ,IAAKA,KAAO9E,GAEZ,OAAO8E,IAAQvI,GAAauB,EAAY4D,KAAK1B,EAAK8E,IAGpDC,cAAe,SAAU/E,GACvB,IAAIsD,EACJ,IAAKA,KAAQtD,EACX,OAAO,EAET,OAAO,GAGTgF,MAAO,SAAUC,GACf,MAAM,IAAIC,MAAMD,IAMlBnE,UAAW,SAAUqE,EAAMhH,EAASiH,GAClC,IAAKD,GAAwB,kBAATA,EAClB,OAAO,KAEc,mBAAZhH,IACTiH,EAAcjH,EACdA,GAAU,GAEZA,EAAUA,GAAWxB,EAErB,IAAI0I,EAAS1G,EAAWgC,KAAKwE,GAC3BG,GAAWF,GAAe,GAG5B,OAAIC,EACK,CAAClH,EAAQoH,cAAcF,EAAO,MAGvCA,EAASvI,EAAO0I,cAAc,CAACL,GAAOhH,EAASmH,GAC3CA,GACFxI,EAAOwI,GAASG,SAEX3I,EAAO+D,MAAM,GAAIwE,EAAOK,cAGjCC,UAAW,SAAUR,GAEnB,OAAI7I,EAAOsJ,MAAQtJ,EAAOsJ,KAAKC,MACtBvJ,EAAOsJ,KAAKC,MAAMV,GAGd,OAATA,EACKA,EAGW,kBAATA,IAGTA,EAAOrI,EAAOmB,KAAKkH,GAEfA,GAGEvG,EAAYoC,KAAKmE,EAAKW,QAAQhH,EAAc,KAC7CgH,QAAQ/G,EAAc,KACtB+G,QAAQjH,EAAc,MAEhB,IAAKkH,SAAS,UAAYZ,EAA1B,QAKbrI,EAAOkI,MAAM,iBAAmBG,IAIlCa,SAAU,SAAUb,GAClB,IAAIc,EAAKC,EACT,IAAKf,GAAwB,kBAATA,EAClB,OAAO,KAET,IACM7I,EAAO6J,WACTD,EAAM,IAAIC,UACVF,EAAMC,EAAIE,gBAAgBjB,EAAM,cAEhCc,EAAM,IAAII,cAAc,oBACxBJ,EAAIK,MAAQ,QACZL,EAAIM,QAAQpB,IAEd,MAAON,GACPoB,EAAM1J,EAKR,OAHK0J,GAAQA,EAAIO,kBAAmBP,EAAIQ,qBAAqB,eAAexG,QAC1EnD,EAAOkI,MAAM,gBAAkBG,GAE1Bc,GAGTS,KAAM,aAKNC,WAAY,SAAUxB,GAChBA,GAAQrI,EAAOmB,KAAKkH,KAIrB7I,EAAOsK,YAAc,SAAUzB,GAC9B7I,EAAO,QAAQoF,KAAKpF,EAAQ6I,KAC3BA,IAMP0B,UAAW,SAAUC,GACnB,OAAOA,EAAOhB,QAAQ9G,EAAW,OAAO8G,QAAQ7G,EAAYC,IAG9D6H,SAAU,SAAUvG,EAAM8C,GACxB,OAAO9C,EAAKuG,UAAYvG,EAAKuG,SAASC,gBAAkB1D,EAAK0D,eAI/D/E,KAAM,SAAUjC,EAAKkC,EAAUC,GAC7B,IAAI8E,EACFtE,EAAI,EACJ1C,EAASD,EAAIC,OACb0D,EAAU5D,EAAYC,GAExB,GAAImC,GACF,GAAIwB,GACF,KAAOhB,EAAI1C,EAAQ0C,IAGjB,GAFAsE,EAAQ/E,EAASI,MAAMtC,EAAI2C,GAAIR,IAEjB,IAAV8E,EACF,WAIJ,IAAKtE,KAAK3C,EAGR,GAFAiH,EAAQ/E,EAASI,MAAMtC,EAAI2C,GAAIR,IAEjB,IAAV8E,EACF,WAON,GAAItD,GACF,KAAOhB,EAAI1C,EAAQ0C,IAGjB,GAFAsE,EAAQ/E,EAASR,KAAK1B,EAAI2C,GAAIA,EAAG3C,EAAI2C,KAEvB,IAAVsE,EACF,WAIJ,IAAKtE,KAAK3C,EAGR,GAFAiH,EAAQ/E,EAASR,KAAK1B,EAAI2C,GAAIA,EAAG3C,EAAI2C,KAEvB,IAAVsE,EACF,MAMR,OAAOjH,GAIT/B,KAAMD,IAAcA,EAAU0D,KAAK,WACjC,SAAUwF,GACR,OAAe,MAARA,EACL,GACAlJ,EAAU0D,KAAKwF,IAInB,SAAUA,GACR,OAAe,MAARA,EACL,IACCA,EAAO,IAAIpB,QAAQrH,EAAO,KAIjC8C,UAAW,SAAU4F,EAAKC,GACxB,IAAIrF,EAAMqF,GAAW,GAarB,OAXW,MAAPD,IACEpH,EAAYsH,OAAOF,IACrBrK,EAAO+D,MAAMkB,EACI,kBAARoF,EACL,CAACA,GAAOA,GAGZ7J,EAAUoE,KAAKK,EAAKoF,IAIjBpF,GAGTuF,QAAS,SAAU9G,EAAM2G,EAAKxE,GAC5B,IAAIC,EAEJ,GAAIuE,EAAK,CACP,GAAIzJ,EACF,OAAOA,EAAagE,KAAKyF,EAAK3G,EAAMmC,GAMtC,IAHAC,EAAMuE,EAAIlH,OACV0C,EAAIA,EAAIA,EAAI,EAAI4E,KAAKC,IAAI,EAAG5E,EAAMD,GAAKA,EAAI,EAEpCA,EAAIC,EAAKD,IAEd,GAAIA,KAAKwE,GAAOA,EAAIxE,KAAOnC,EACzB,OAAOmC,EAKb,OAAQ,GAGV9B,MAAO,SAAU2B,EAAOiF,GACtB,IAAIC,EAAID,EAAOxH,OACb0C,EAAIH,EAAMvC,OACV4C,EAAI,EAEN,GAAiB,kBAAN6E,EACT,KAAO7E,EAAI6E,EAAG7E,IACZL,EAAMG,KAAO8E,EAAO5E,QAGtB,MAAO4E,EAAO5E,KAAOtG,EACnBiG,EAAMG,KAAO8E,EAAO5E,KAMxB,OAFAL,EAAMvC,OAAS0C,EAERH,GAGTmF,KAAM,SAAU7F,EAAOI,EAAU0F,GAC/B,IAAIC,EACF9F,EAAM,GACNY,EAAI,EACJ1C,EAAS6B,EAAM7B,OAKjB,IAJA2H,IAAQA,EAIDjF,EAAI1C,EAAQ0C,IACjBkF,IAAW3F,EAASJ,EAAMa,GAAIA,GAC1BiF,IAAQC,GACV9F,EAAIxE,KAAKuE,EAAMa,IAInB,OAAOZ,GAITe,IAAK,SAAUhB,EAAOI,EAAU4F,GAC9B,IAAIb,EACFtE,EAAI,EACJ1C,EAAS6B,EAAM7B,OACf0D,EAAU5D,EAAY+B,GACtBC,EAAM,GAGR,GAAI4B,EACF,KAAOhB,EAAI1C,EAAQ0C,IACjBsE,EAAQ/E,EAASJ,EAAMa,GAAIA,EAAGmF,GAEjB,MAATb,IACFlF,EAAIA,EAAI9B,QAAUgH,QAMtB,IAAKtE,KAAKb,EACRmF,EAAQ/E,EAASJ,EAAMa,GAAIA,EAAGmF,GAEjB,MAATb,IACFlF,EAAIA,EAAI9B,QAAUgH,GAMxB,OAAO7J,EAAYkF,MAAM,GAAIP,IAI/BgG,KAAM,EAINC,MAAO,SAAU5J,EAAID,GACnB,IAAIgE,EAAM6F,EAAO9B,EAUjB,MARuB,kBAAZ/H,IACT+H,EAAM9H,EAAGD,GACTA,EAAUC,EACVA,EAAK8H,GAKFpJ,EAAOoE,WAAW9C,IAKvB+D,EAAO3E,EAAWkE,KAAKa,UAAW,GAClCyF,EAAQ,WACN,OAAO5J,EAAGkE,MAAMnE,GAAWsC,KAAM0B,EAAK9E,OAAOG,EAAWkE,KAAKa,cAI/DyF,EAAMD,KAAO3J,EAAG2J,KAAO3J,EAAG2J,MAAQjL,EAAOiL,OAElCC,GAZEzL,GAiBX0L,OAAQ,SAAUnG,EAAO1D,EAAI0G,EAAKmC,EAAOiB,EAAWC,EAAUC,GAC5D,IAAIzF,EAAI,EACN1C,EAAS6B,EAAM7B,OACfoI,EAAc,MAAPvD,EAGT,GAAyB,WAArBhI,EAAO2C,KAAKqF,GAEd,IAAKnC,KADLuF,GAAY,EACFpD,EACRhI,EAAOmL,OAAOnG,EAAO1D,EAAIuE,EAAGmC,EAAInC,IAAI,EAAMwF,EAAUC,QAIjD,GAAInB,IAAU1K,IACnB2L,GAAY,EAEPpL,EAAOoE,WAAW+F,KACrBmB,GAAM,GAGJC,IAEED,GACFhK,EAAGsD,KAAKI,EAAOmF,GACf7I,EAAK,OAILiK,EAAOjK,EACPA,EAAK,SAAUoC,EAAMsE,EAAKmC,GACxB,OAAOoB,EAAK3G,KAAK5E,EAAO0D,GAAOyG,MAKjC7I,GACF,KAAOuE,EAAI1C,EAAQ0C,IACjBvE,EAAG0D,EAAMa,GAAImC,EAAKsD,EAAMnB,EAAQA,EAAMvF,KAAKI,EAAMa,GAAIA,EAAGvE,EAAG0D,EAAMa,GAAImC,KAK3E,OAAOoD,EACLpG,EAGAuG,EACEjK,EAAGsD,KAAKI,GACR7B,EAAS7B,EAAG0D,EAAM,GAAIgD,GAAOqD,GAGnCG,IAAK,WACH,OAAO,IAAKC,MAAQC,aAIxB1L,EAAO8C,MAAMwC,QAAU,SAAUpC,GAC/B,IAAKxD,EAOH,GALAA,EAAYM,EAAO2L,WAKS,aAAxB9L,EAAS+C,WAEXyE,WAAWrH,EAAO8C,YAGb,GAAIjD,EAAS6C,iBAElB7C,EAAS6C,iBAAiB,mBAAoBF,GAAW,GAGzDhD,EAAOkD,iBAAiB,OAAQF,GAAW,OAGtC,CAEL3C,EAAS+L,YAAY,qBAAsBpJ,GAG3ChD,EAAOoM,YAAY,SAAUpJ,GAI7B,IAAIqJ,GAAM,EAEV,IACEA,EAA6B,MAAvBrM,EAAOsM,cAAwBjM,EAAS6J,gBAC9C,MAAO3B,IAEL8D,GAAOA,EAAIE,UACb,SAAUC,IACR,IAAKhM,EAAO+G,QAAS,CAEnB,IAGE8E,EAAIE,SAAS,QACb,MAAOhE,GACP,OAAOV,WAAW2E,EAAe,IAInCnJ,IAGA7C,EAAO8C,SAfX,GAqBN,OAAOpD,EAAU4F,QAAQpC,IAI3BlD,EAAOmF,KAAK,gEAAgE8G,MAAM,MAAM,SAAUpG,EAAGW,GACnGrG,EAAW,WAAaqG,EAAO,KAAOA,EAAK0D,iBAqB7CvK,EAAaK,EAAOH,GAEpB,IAAIqM,EAAe,GAGnB,SAASC,EAAc1F,GACrB,IAAI2F,EAASF,EAAazF,GAAW,GAIrC,OAHAzG,EAAOmF,KAAKsB,EAAQhD,MAAM/B,IAAmB,IAAI,SAAU2K,EAAGC,GAC5DF,EAAOE,IAAQ,KAEVF,EAyBTpM,EAAOuM,UAAY,SAAU9F,GAI3BA,EAA6B,kBAAZA,EACdyF,EAAazF,IAAY0F,EAAc1F,GACxCzG,EAAOoG,OAAO,GAAIK,GAEpB,IACE+F,EAEAC,EAEAC,EAEAC,EAEAC,EAEAC,EAEAC,EAAO,GAEPC,GAAStG,EAAQuG,MAAQ,GAEzBC,EAAO,SAAU5E,GAOf,IANAoE,EAAShG,EAAQgG,QAAUpE,EAC3BqE,GAAQ,EACRE,EAAcC,GAAe,EAC7BA,EAAc,EACdF,EAAeG,EAAK3J,OACpBqJ,GAAS,EACFM,GAAQF,EAAcD,EAAcC,IACzC,IAAkD,IAA9CE,EAAKF,GAAapH,MAAM6C,EAAK,GAAIA,EAAK,KAAiB5B,EAAQyG,YAAa,CAC9ET,GAAS,EACT,MAGJD,GAAS,EACLM,IACEC,EACEA,EAAM5J,QACR8J,EAAKF,EAAMI,SAEJV,EACTK,EAAO,GAEPM,EAAKC,YAKXD,EAAO,CAELE,IAAK,WACH,GAAIR,EAAM,CAER,IAAIS,EAAQT,EAAK3J,QACjB,SAAUmK,EAAIjI,GACZrF,EAAOmF,KAAKE,GAAM,SAAUgH,EAAGrB,GAC7B,IAAIrI,EAAO3C,EAAO2C,KAAKqI,GACV,aAATrI,EACG8D,EAAQ+G,QAAWJ,EAAKK,IAAIzC,IAC/B8B,EAAKrM,KAAKuK,GAEHA,GAAOA,EAAI7H,QAAmB,WAATR,GAE9B2K,EAAItC,OATV,CAYGvF,WAGC+G,EACFG,EAAeG,EAAK3J,OAGXsJ,IACTI,EAAcU,EACdN,EAAKR,IAGT,OAAO9I,MAGTgF,OAAQ,WAkBN,OAjBImE,GACF9M,EAAOmF,KAAKM,WAAW,SAAU4G,EAAGrB,GAClC,IAAI0C,EACJ,OAAQA,EAAQ1N,EAAOwK,QAAQQ,EAAK8B,EAAMY,KAAW,EACnDZ,EAAK3G,OAAOuH,EAAO,GAEflB,IACEkB,GAASf,GACXA,IAEEe,GAASd,GACXA,QAMHjJ,MAIT8J,IAAK,SAAUnM,GACb,OAAOA,EAAKtB,EAAOwK,QAAQlJ,EAAIwL,IAAS,KAAOA,IAAQA,EAAK3J,SAG9DwK,MAAO,WAEL,OADAb,EAAO,GACAnJ,MAGT0J,QAAS,WAEP,OADAP,EAAOC,EAAQN,EAAShN,EACjBkE,MAGTiK,SAAU,WACR,OAAQd,GAGVe,KAAM,WAKJ,OAJAd,EAAQtN,EACHgN,GACHW,EAAKC,UAEA1J,MAGTmK,OAAQ,WACN,OAAQf,GAGVgB,SAAU,SAAU1M,EAASgE,GAU3B,OATAA,EAAOA,GAAQ,GACfA,EAAO,CAAChE,EAASgE,EAAK1E,MAAQ0E,EAAK1E,QAAU0E,IACzCyH,GAAUJ,IAASK,IACjBP,EACFO,EAAMtM,KAAK4E,GAEX4H,EAAK5H,IAGF1B,MAGTsJ,KAAM,WAEJ,OADAG,EAAKW,SAASpK,KAAM8B,WACb9B,MAGT+I,MAAO,WACL,QAASA,IAIf,OAAOU,GAETpN,EAAOoG,OAAO,CAEZuF,SAAU,SAAUqC,GAClB,IAAIC,EAAS,CAEX,CAAC,UAAW,OAAQjO,EAAOuM,UAAU,eAAgB,YACrD,CAAC,SAAU,OAAQvM,EAAOuM,UAAU,eAAgB,YACpD,CAAC,SAAU,WAAYvM,EAAOuM,UAAU,YAExC2B,EAAQ,UACR5I,EAAU,CACR4I,MAAO,WACL,OAAOA,GAETC,OAAQ,WAEN,OADAC,EAAS7I,KAAKE,WAAW4I,KAAK5I,WACvB9B,MAET2K,KAAM,WACJ,IAAIC,EAAM9I,UACV,OAAOzF,EAAO2L,UAAS,SAAU6C,GAC/BxO,EAAOmF,KAAK8I,GAAQ,SAAUpI,EAAG4I,GAC/B,IAAIC,EAASD,EAAM,GACjBnN,EAAKtB,EAAOoE,WAAWmK,EAAI1I,KAAO0I,EAAI1I,GAExCuI,EAASK,EAAM,KAAI,WACjB,IAAIE,EAAWrN,GAAMA,EAAGkE,MAAM7B,KAAM8B,WAChCkJ,GAAY3O,EAAOoE,WAAWuK,EAASrJ,SACzCqJ,EAASrJ,UACNC,KAAKiJ,EAASI,SACdP,KAAKG,EAASK,QACdC,SAASN,EAASO,QAErBP,EAASE,EAAS,QAAQ/K,OAAS2B,EAAUkJ,EAASlJ,UAAY3B,KAAMrC,EAAK,CAACqN,GAAYlJ,iBAIhG8I,EAAM,QACLjJ,WAILA,QAAS,SAAUpC,GACjB,OAAc,MAAPA,EAAclD,EAAOoG,OAAOlD,EAAKoC,GAAWA,IAGvD8I,EAAW,GAwCb,OArCA9I,EAAQ0J,KAAO1J,EAAQgJ,KAGvBtO,EAAOmF,KAAK8I,GAAQ,SAAUpI,EAAG4I,GAC/B,IAAI3B,EAAO2B,EAAM,GACfQ,EAAcR,EAAM,GAGtBnJ,EAAQmJ,EAAM,IAAM3B,EAAKQ,IAGrB2B,GACFnC,EAAKQ,KAAI,WAEPY,EAAQe,IAGPhB,EAAW,EAAJpI,GAAO,GAAGwH,QAASY,EAAO,GAAG,GAAGJ,MAI5CO,EAASK,EAAM,IAAM,WAEnB,OADAL,EAASK,EAAM,GAAK,QAAQ9K,OAASyK,EAAW9I,EAAU3B,KAAM8B,WACzD9B,MAETyK,EAASK,EAAM,GAAK,QAAU3B,EAAKiB,YAIrCzI,EAAQA,QAAQ8I,GAGZJ,GACFA,EAAKpJ,KAAKwJ,EAAUA,GAIfA,GAITc,KAAM,SAAUC,GACd,IAuBEC,EAAgBC,EAAkBC,EAvBhCzJ,EAAI,EACN0J,EAAgB7O,EAAWkE,KAAKa,WAChCtC,EAASoM,EAAcpM,OAGvBqM,EAAuB,IAAXrM,GAAiBgM,GAAenP,EAAOoE,WAAW+K,EAAY7J,SAAYnC,EAAS,EAG/FiL,EAAyB,IAAdoB,EAAkBL,EAAcnP,EAAO2L,WAGlD8D,EAAa,SAAU5J,EAAG6J,EAAUC,GAClC,OAAO,SAAUxF,GACfuF,EAAS7J,GAAKlC,KACdgM,EAAO9J,GAAKJ,UAAUtC,OAAS,EAAIzC,EAAWkE,KAAKa,WAAa0E,EAC5DwF,IAAWP,EACbhB,EAASwB,WAAWF,EAAUC,KACjBH,GACbpB,EAAS9G,YAAYoI,EAAUC,KAQvC,GAAIxM,EAAS,EAIX,IAHAiM,EAAiB,IAAI3H,MAAMtE,GAC3BkM,EAAmB,IAAI5H,MAAMtE,GAC7BmM,EAAkB,IAAI7H,MAAMtE,GACrB0C,EAAI1C,EAAQ0C,IACb0J,EAAc1J,IAAM7F,EAAOoE,WAAWmL,EAAc1J,GAAGP,SACzDiK,EAAc1J,GAAGP,UACdC,KAAKkK,EAAW5J,EAAGyJ,EAAiBC,IACpClB,KAAKD,EAASS,QACdC,SAASW,EAAW5J,EAAGwJ,EAAkBD,MAE1CI,EAUR,OAJKA,GACHpB,EAAS9G,YAAYgI,EAAiBC,GAGjCnB,EAAS9I,aAGpBtF,EAAO6P,QAAU,WAEf,IAAIA,EAASxN,EAAKyN,EAChBC,EAAOC,EAAQC,EACfC,EAAKC,EAAWC,EAAavK,EAC7BwK,EAAMxQ,EAAS4I,cAAc,OAS/B,GANA4H,EAAIC,aAAa,YAAa,KAC9BD,EAAIE,UAAY,qEAGhBlO,EAAMgO,EAAI1G,qBAAqB,KAC/BmG,EAAIO,EAAI1G,qBAAqB,KAAK,IAC7BtH,IAAQyN,IAAMzN,EAAIc,OACrB,MAAO,GAIT6M,EAASnQ,EAAS4I,cAAc,UAChCyH,EAAMF,EAAOQ,YAAY3Q,EAAS4I,cAAc,WAChDsH,EAAQM,EAAI1G,qBAAqB,SAAS,GAE1CmG,EAAEW,MAAMC,QAAU,gCAClBb,EAAU,CAERc,gBAAmC,MAAlBN,EAAIO,UAGrBC,kBAA+C,IAA5BR,EAAIS,WAAWzN,SAIlC0N,OAAQV,EAAI1G,qBAAqB,SAASxG,OAI1C6N,gBAAiBX,EAAI1G,qBAAqB,QAAQxG,OAIlDsN,MAAO,MAAMvM,KAAK4L,EAAEmB,aAAa,UAIjCC,eAA2C,OAA3BpB,EAAEmB,aAAa,QAK/BE,QAAS,OAAOjN,KAAK4L,EAAEW,MAAMU,SAI7BC,WAAYtB,EAAEW,MAAMW,SAGpBC,UAAWtB,EAAM5F,MAIjBmH,YAAapB,EAAIqB,SAGjBC,UAAW3R,EAAS4I,cAAc,QAAQ+I,QAI1CC,WAAwE,kBAA5D5R,EAAS4I,cAAc,OAAOiJ,WAAU,GAAMC,UAG1DC,SAAkC,eAAxB/R,EAASgS,WAGnBC,eAAe,EACfC,cAAc,EACdC,wBAAwB,EACxBC,kBAAkB,EAClBC,qBAAqB,EACrBC,mBAAmB,EACnBC,eAAe,GAIjBrC,EAAMsC,SAAU,EAChBxC,EAAQyC,eAAiBvC,EAAM2B,WAAU,GAAMW,QAI/CrC,EAAOpC,UAAW,EAClBiC,EAAQ0C,aAAerC,EAAItC,SAG3B,WACSyC,EAAInM,KACX,MAAO6D,GACP8H,EAAQiC,eAAgB,EAwC1B,IAAKjM,KApCLkK,EAAQlQ,EAAS4I,cAAc,SAC/BsH,EAAMO,aAAa,QAAS,IAC5BT,EAAQE,MAAwC,KAAhCA,EAAMkB,aAAa,SAGnClB,EAAM5F,MAAQ,IACd4F,EAAMO,aAAa,OAAQ,SAC3BT,EAAQ2C,WAA6B,MAAhBzC,EAAM5F,MAG3B4F,EAAMO,aAAa,UAAW,KAC9BP,EAAMO,aAAa,OAAQ,KAE3BL,EAAWpQ,EAAS4S,yBACpBxC,EAASO,YAAYT,GAIrBF,EAAQ6C,cAAgB3C,EAAMsC,QAG9BxC,EAAQ8C,WAAa1C,EAASyB,WAAU,GAAMA,WAAU,GAAMkB,UAAUP,QAKpEhC,EAAIzE,cACNyE,EAAIzE,YAAY,WAAW,WACzBiE,EAAQkC,cAAe,KAGzB1B,EAAIqB,WAAU,GAAMmB,SAKZ,CAAEC,QAAQ,EAAMC,QAAQ,EAAMC,SAAS,GAC/C3C,EAAIC,aAAaH,EAAY,KAAOtK,EAAG,KAEvCgK,EAAQhK,EAAI,WAAasK,KAAa3Q,IAAgD,IAAtC6Q,EAAI4C,WAAW9C,GAAW+C,QAmG5E,OAhGA7C,EAAII,MAAM0C,eAAiB,cAC3B9C,EAAIqB,WAAU,GAAMjB,MAAM0C,eAAiB,GAC3CtD,EAAQuD,gBAA+C,gBAA7B/C,EAAII,MAAM0C,eAGpCnT,GAAO,WACL,IAAIqT,EAAWC,EAAWC,EACxBC,EAAW,+HACXpM,EAAOvH,EAAS8J,qBAAqB,QAAQ,GAE1CvC,IAKLiM,EAAYxT,EAAS4I,cAAc,OACnC4K,EAAU5C,MAAMC,QAAU,gFAE1BtJ,EAAKoJ,YAAY6C,GAAW7C,YAAYH,GASxCA,EAAIE,UAAY,8CAChBgD,EAAMlD,EAAI1G,qBAAqB,MAC/B4J,EAAI,GAAG9C,MAAMC,QAAU,2CACvBN,EAAuC,IAAxBmD,EAAI,GAAGE,aAEtBF,EAAI,GAAG9C,MAAMiD,QAAU,GACvBH,EAAI,GAAG9C,MAAMiD,QAAU,OAIvB7D,EAAQ8D,sBAAwBvD,GAAwC,IAAxBmD,EAAI,GAAGE,aAGvDpD,EAAIE,UAAY,GAChBF,EAAII,MAAMC,QAAU,wKACpBb,EAAQ+D,UAAiC,IAApBvD,EAAIwD,YACzBhE,EAAQiE,iCAAuD,IAAnB1M,EAAK2M,UAG7CvU,EAAOwU,mBACTnE,EAAQuC,cAAmE,QAAlD5S,EAAOwU,iBAAiB3D,EAAK,OAAS,IAAIxE,IACnEgE,EAAQsC,kBAAuF,SAAlE3S,EAAOwU,iBAAiB3D,EAAK,OAAS,CAAE4D,MAAO,QAASA,MAMrFX,EAAYjD,EAAIG,YAAY3Q,EAAS4I,cAAc,QACnD6K,EAAU7C,MAAMC,QAAUL,EAAII,MAAMC,QAAU8C,EAC9CF,EAAU7C,MAAMyD,YAAcZ,EAAU7C,MAAMwD,MAAQ,IACtD5D,EAAII,MAAMwD,MAAQ,MAElBpE,EAAQqC,qBACLtK,YAAYpI,EAAOwU,iBAAiBV,EAAW,OAAS,IAAIY,qBAGtD7D,EAAII,MAAM0D,OAASvU,IAK5ByQ,EAAIE,UAAY,GAChBF,EAAII,MAAMC,QAAU8C,EAAW,8CAC/B3D,EAAQmC,uBAA8C,IAApB3B,EAAIwD,YAItCxD,EAAII,MAAMiD,QAAU,QACpBrD,EAAIE,UAAY,cAChBF,EAAIS,WAAWL,MAAMwD,MAAQ,MAC7BpE,EAAQoC,iBAAwC,IAApB5B,EAAIwD,YAE5BhE,EAAQmC,yBAIV5K,EAAKqJ,MAAM0D,KAAO,IAItB/M,EAAKgN,YAAYf,GAGjBA,EAAYhD,EAAMkD,EAAMD,EAAY,SAItCjR,EAAM2N,EAASC,EAAWC,EAAMJ,EAAIC,EAAQ,KAErCF,EA9OQ,GAiPjB,IAAIwE,EAAS,+BACXC,EAAa,WAEf,SAASC,EAAa7Q,EAAM8C,EAAM6B,EAAMmM,GACtC,GAAKxU,EAAOyU,WAAW/Q,GAAvB,CAIA,IAAIgR,EAAWzP,EACb0P,EAAc3U,EAAOkT,QACrB0B,EAA4B,kBAATpO,EAInBqO,EAASnR,EAAKL,SAIdyR,EAAQD,EAAS7U,EAAO8U,MAAQpR,EAIhCc,EAAKqQ,EAASnR,EAAKiR,GAAejR,EAAKiR,IAAgBA,EAIzD,GAAMnQ,GAAOsQ,EAAMtQ,KAASgQ,GAAQM,EAAMtQ,GAAI6D,QAAUuM,GAAavM,IAAS5I,EAoE9E,OAhEK+E,IAGCqQ,EACFnR,EAAKiR,GAAenQ,EAAKpE,EAAgB2U,OAAS/U,EAAOiL,OAEzDzG,EAAKmQ,GAIJG,EAAMtQ,KACTsQ,EAAMtQ,GAAM,GAIPqQ,IACHC,EAAMtQ,GAAIwQ,OAAShV,EAAO4J,OAMV,kBAATpD,GAAqC,oBAATA,IACjCgO,EACFM,EAAMtQ,GAAMxE,EAAOoG,OAAO0O,EAAMtQ,GAAKgC,GAErCsO,EAAMtQ,GAAI6D,KAAOrI,EAAOoG,OAAO0O,EAAMtQ,GAAI6D,KAAM7B,IAInDkO,EAAYI,EAAMtQ,GAKbgQ,IACEE,EAAUrM,OACbqM,EAAUrM,KAAO,IAGnBqM,EAAYA,EAAUrM,MAGpBA,IAAS5I,IACXiV,EAAU1U,EAAO+J,UAAUvD,IAAS6B,GAKlCuM,GAGF3P,EAAMyP,EAAUlO,GAGL,MAAPvB,IAGFA,EAAMyP,EAAU1U,EAAO+J,UAAUvD,MAGnCvB,EAAMyP,EAGDzP,GAGT,SAASgQ,EAAmBvR,EAAM8C,EAAMgO,GACtC,GAAKxU,EAAOyU,WAAW/Q,GAAvB,CAIA,IAAImC,EAAG+E,EAAG8J,EACRG,EAASnR,EAAKL,SAGdyR,EAAQD,EAAS7U,EAAO8U,MAAQpR,EAChCc,EAAKqQ,EAASnR,EAAK1D,EAAOkT,SAAWlT,EAAOkT,QAI9C,GAAK4B,EAAMtQ,GAAX,CAIA,GAAIgC,IAEFkO,EAAYF,EAAMM,EAAMtQ,GAAMsQ,EAAMtQ,GAAI6D,KAEpCqM,GAAW,CAGR1U,EAAO6G,QAAQL,GAsBlBA,EAAOA,EAAKjG,OAAOP,EAAOgG,IAAIQ,EAAMxG,EAAO+J,YAnBvCvD,KAAQkO,EACVlO,EAAO,CAACA,IAIRA,EAAOxG,EAAO+J,UAAUvD,GAEtBA,EADEA,KAAQkO,EACH,CAAClO,GAEDA,EAAKyF,MAAM,MAaxB,IAAKpG,EAAI,EAAG+E,EAAIpE,EAAKrD,OAAQ0C,EAAI+E,EAAG/E,WAC3B6O,EAAUlO,EAAKX,IAKxB,KAAM2O,EAAMU,EAAoBlV,EAAOiI,eAAeyM,GACpD,QAMDF,WACIM,EAAMtQ,GAAI6D,KAIZ6M,EAAkBJ,EAAMtQ,QAM3BqQ,EACF7U,EAAOmV,UAAU,CAACzR,IAAO,GAGhB1D,EAAO6P,QAAQiC,eAAiBgD,GAASA,EAAMtV,cACjDsV,EAAMtQ,GAIbsQ,EAAMtQ,GAAM,QAiHhB,SAAS4Q,EAAS1R,EAAMsE,EAAKK,GAG3B,GAAIA,IAAS5I,GAA+B,IAAlBiE,EAAKL,SAAgB,CAE7C,IAAImD,EAAO,QAAUwB,EAAIgB,QAAQsL,EAAY,OAAOpK,cAIpD,GAFA7B,EAAO3E,EAAKuN,aAAazK,GAEL,kBAAT6B,EAAmB,CAC5B,IACEA,EAAgB,SAATA,GACI,UAATA,IACW,SAATA,EAAkB,MAEfA,EAAO,KAAOA,GAAQA,EACrBgM,EAAOnQ,KAAKmE,GAAQrI,EAAO6I,UAAUR,GACnCA,GACV,MAAON,IAGT/H,EAAOqI,KAAK3E,EAAMsE,EAAKK,QAGvBA,EAAO5I,EAIX,OAAO4I,EAIT,SAAS6M,EAAkBhS,GACzB,IAAIsD,EACJ,IAAKA,KAAQtD,EAGX,IAAa,SAATsD,IAAmBxG,EAAOiI,cAAc/E,EAAIsD,MAGnC,WAATA,EACF,OAAO,EAIX,OAAO,EA1JTxG,EAAOoG,OAAO,CACZ0O,MAAO,GAIP5B,QAAS,UAAY7S,EAAeoK,KAAK4K,UAAUrM,QAAQ,MAAO,IAIlEsM,OAAQ,CACN,OAAS,EAET,OAAU,6CACV,QAAU,GAGZC,QAAS,SAAU7R,GAEjB,OADAA,EAAOA,EAAKL,SAAWrD,EAAO8U,MAAMpR,EAAK1D,EAAOkT,UAAYxP,EAAK1D,EAAOkT,WAC/DxP,IAASwR,EAAkBxR,IAGtC2E,KAAM,SAAU3E,EAAM8C,EAAM6B,GAC1B,OAAOkM,EAAa7Q,EAAM8C,EAAM6B,IAGlCmN,WAAY,SAAU9R,EAAM8C,GAC1B,OAAOyO,EAAmBvR,EAAM8C,IAIlCiP,MAAO,SAAU/R,EAAM8C,EAAM6B,GAC3B,OAAOkM,EAAa7Q,EAAM8C,EAAM6B,GAAM,IAGxCqN,YAAa,SAAUhS,EAAM8C,GAC3B,OAAOyO,EAAmBvR,EAAM8C,GAAM,IAIxCiO,WAAY,SAAU/Q,GAEpB,GAAIA,EAAKL,UAA8B,IAAlBK,EAAKL,UAAoC,IAAlBK,EAAKL,SAC/C,OAAO,EAGT,IAAIiS,EAAS5R,EAAKuG,UAAYjK,EAAOsV,OAAO5R,EAAKuG,SAASC,eAG1D,OAAQoL,IAAqB,IAAXA,GAAmB5R,EAAKuN,aAAa,aAAeqE,KAI1EtV,EAAOsB,GAAG8E,OAAO,CACfiC,KAAM,SAAUL,EAAKmC,GACnB,IAAIwL,EAAOnP,EACT9C,EAAOC,KAAK,GACZkC,EAAI,EACJwC,EAAO,KAGT,GAAIL,IAAQvI,EAAW,CACrB,GAAIkE,KAAKR,SACPkF,EAAOrI,EAAOqI,KAAK3E,GAEG,IAAlBA,EAAKL,WAAmBrD,EAAOyV,MAAM/R,EAAM,gBAAgB,CAE7D,IADAiS,EAAQjS,EAAKuP,WACNpN,EAAI8P,EAAMxS,OAAQ0C,IACvBW,EAAOmP,EAAM9P,GAAGW,KAEXA,EAAK3F,QAAQ,WAChB2F,EAAOxG,EAAO+J,UAAUvD,EAAK7F,MAAM,IAEnCyU,EAAS1R,EAAM8C,EAAM6B,EAAK7B,KAG9BxG,EAAOyV,MAAM/R,EAAM,eAAe,GAItC,OAAO2E,EAIT,MAAmB,kBAARL,EACFrE,KAAKwB,MAAK,WACfnF,EAAOqI,KAAK1E,KAAMqE,MAIfhI,EAAOmL,OAAOxH,MAAM,SAAUwG,GAEnC,GAAIA,IAAU1K,EAEZ,OAAOiE,EAAO0R,EAAS1R,EAAMsE,EAAKhI,EAAOqI,KAAK3E,EAAMsE,IAAQ,KAG9DrE,KAAKwB,MAAK,WACRnF,EAAOqI,KAAK1E,KAAMqE,EAAKmC,QAExB,KAAMA,EAAO1E,UAAUtC,OAAS,EAAG,MAAM,IAG9CqS,WAAY,SAAUxN,GACpB,OAAOrE,KAAKwB,MAAK,WACfnF,EAAOwV,WAAW7R,KAAMqE,SAoD9BhI,EAAOoG,OAAO,CACZwP,MAAO,SAAUlS,EAAMf,EAAM0F,GAC3B,IAAIuN,EAEJ,GAAIlS,EAYF,OAXAf,GAAQA,GAAQ,MAAQ,QACxBiT,EAAQ5V,EAAOyV,MAAM/R,EAAMf,GAGvB0F,KACGuN,GAAS5V,EAAO6G,QAAQwB,GAC3BuN,EAAQ5V,EAAOyV,MAAM/R,EAAMf,EAAM3C,EAAOyE,UAAU4D,IAElDuN,EAAMnV,KAAK4H,IAGRuN,GAAS,IAIpBC,QAAS,SAAUnS,EAAMf,GACvBA,EAAOA,GAAQ,KAEf,IAAIiT,EAAQ5V,EAAO4V,MAAMlS,EAAMf,GAC7BmT,EAAcF,EAAMzS,OACpB7B,EAAKsU,EAAMzI,QACX4I,EAAQ/V,EAAOgW,YAAYtS,EAAMf,GACjCsT,EAAO,WACLjW,EAAO6V,QAAQnS,EAAMf,IAId,eAAPrB,IACFA,EAAKsU,EAAMzI,QACX2I,KAGFC,EAAMG,IAAM5U,EACRA,IAIW,OAATqB,GACFiT,EAAMO,QAAQ,qBAITJ,EAAMK,KACb9U,EAAGsD,KAAKlB,EAAMuS,EAAMF,KAGjBD,GAAeC,GAClBA,EAAMpI,MAAMV,QAKhB+I,YAAa,SAAUtS,EAAMf,GAC3B,IAAIqF,EAAMrF,EAAO,aACjB,OAAO3C,EAAOyV,MAAM/R,EAAMsE,IAAQhI,EAAOyV,MAAM/R,EAAMsE,EAAK,CACxD2F,MAAO3N,EAAOuM,UAAU,eAAee,KAAI,WACzCtN,EAAO0V,YAAYhS,EAAMf,EAAO,SAChC3C,EAAO0V,YAAYhS,EAAMsE,WAMjChI,EAAOsB,GAAG8E,OAAO,CACfwP,MAAO,SAAUjT,EAAM0F,GACrB,IAAIgO,EAAS,EAQb,MANoB,kBAAT1T,IACT0F,EAAO1F,EACPA,EAAO,KACP0T,KAGE5Q,UAAUtC,OAASkT,EACdrW,EAAO4V,MAAMjS,KAAK,GAAIhB,GAGxB0F,IAAS5I,EACdkE,KACAA,KAAKwB,MAAK,WACR,IAAIyQ,EAAQ5V,EAAO4V,MAAMjS,KAAMhB,EAAM0F,GAGrCrI,EAAOgW,YAAYrS,KAAMhB,GAEZ,OAATA,GAA8B,eAAbiT,EAAM,IACzB5V,EAAO6V,QAAQlS,KAAMhB,OAI7BkT,QAAS,SAAUlT,GACjB,OAAOgB,KAAKwB,MAAK,WACfnF,EAAO6V,QAAQlS,KAAMhB,OAKzB2T,MAAO,SAAUC,EAAM5T,GAIrB,OAHA4T,EAAOvW,EAAOwW,IAAKxW,EAAOwW,GAAGC,OAAOF,IAAgBA,EACpD5T,EAAOA,GAAQ,KAERgB,KAAKiS,MAAMjT,GAAM,SAAUsT,EAAMF,GACtC,IAAIW,EAAUrP,WAAW4O,EAAMM,GAC/BR,EAAMK,KAAO,WACXO,aAAaD,QAInBE,WAAY,SAAUjU,GACpB,OAAOgB,KAAKiS,MAAMjT,GAAQ,KAAM,KAIlC2C,QAAS,SAAU3C,EAAMO,GACvB,IAAIkG,EACFyN,EAAQ,EACRC,EAAQ9W,EAAO2L,WACfoL,EAAWpT,KACXkC,EAAIlC,KAAKR,OACTyL,EAAU,aACAiI,GACNC,EAAMxP,YAAYyP,EAAU,CAACA,KAIf,kBAATpU,IACTO,EAAMP,EACNA,EAAOlD,GAETkD,EAAOA,GAAQ,KAEf,MAAOkD,IACLuD,EAAMpJ,EAAOyV,MAAMsB,EAASlR,GAAIlD,EAAO,cACnCyG,GAAOA,EAAIuE,QACbkJ,IACAzN,EAAIuE,MAAML,IAAIsB,IAIlB,OADAA,IACOkI,EAAMxR,QAAQpC,MAGzB,IAAI8T,EAAUC,EACZC,EAAS,YACTC,EAAU,MACVC,EAAa,6CACbC,EAAa,gBACbC,GAAW,8HACXC,GAAc,0BACd5G,GAAkB3Q,EAAO6P,QAAQc,gBACjC6G,GAAcxX,EAAO6P,QAAQE,MAE/B/P,EAAOsB,GAAG8E,OAAO,CACf/B,KAAM,SAAUmC,EAAM2D,GACpB,OAAOnK,EAAOmL,OAAOxH,KAAM3D,EAAOqE,KAAMmC,EAAM2D,EAAO1E,UAAUtC,OAAS,IAG1EsU,WAAY,SAAUjR,GACpB,OAAO7C,KAAKwB,MAAK,WACfnF,EAAOyX,WAAW9T,KAAM6C,OAI5BkR,KAAM,SAAUlR,EAAM2D,GACpB,OAAOnK,EAAOmL,OAAOxH,KAAM3D,EAAO0X,KAAMlR,EAAM2D,EAAO1E,UAAUtC,OAAS,IAG1EwU,WAAY,SAAUnR,GAEpB,OADAA,EAAOxG,EAAO4X,QAAQpR,IAASA,EACxB7C,KAAKwB,MAAK,WAEf,IACExB,KAAK6C,GAAQ/G,SACNkE,KAAK6C,GACZ,MAAOuB,SAIb8P,SAAU,SAAU1N,GAClB,IAAI2N,EAASpU,EAAMwS,EAAK6B,EAAOhS,EAC7BF,EAAI,EACJC,EAAMnC,KAAKR,OACX6U,EAA2B,kBAAV7N,GAAsBA,EAEzC,GAAInK,EAAOoE,WAAW+F,GACpB,OAAOxG,KAAKwB,MAAK,SAAUY,GACzB/F,EAAO2D,MAAMkU,SAAS1N,EAAMvF,KAAKjB,KAAMoC,EAAGpC,KAAKiN,eAInD,GAAIoH,EAIF,IAFAF,GAAW3N,GAAS,IAAI1G,MAAM/B,IAAmB,GAE1CmE,EAAIC,EAAKD,IAOd,GANAnC,EAAOC,KAAKkC,GACZqQ,EAAwB,IAAlBxS,EAAKL,WAAmBK,EAAKkN,WAChC,IAAMlN,EAAKkN,UAAY,KAAK5H,QAAQkO,EAAQ,KAC7C,KAGEhB,EAAK,CACPnQ,EAAI,EACJ,MAAQgS,EAAQD,EAAQ/R,KAClBmQ,EAAIrV,QAAQ,IAAMkX,EAAQ,KAAO,IACnC7B,GAAO6B,EAAQ,KAGnBrU,EAAKkN,UAAY5Q,EAAOmB,KAAK+U,GAMnC,OAAOvS,MAGTsU,YAAa,SAAU9N,GACrB,IAAI2N,EAASpU,EAAMwS,EAAK6B,EAAOhS,EAC7BF,EAAI,EACJC,EAAMnC,KAAKR,OACX6U,EAA+B,IAArBvS,UAAUtC,QAAiC,kBAAVgH,GAAsBA,EAEnE,GAAInK,EAAOoE,WAAW+F,GACpB,OAAOxG,KAAKwB,MAAK,SAAUY,GACzB/F,EAAO2D,MAAMsU,YAAY9N,EAAMvF,KAAKjB,KAAMoC,EAAGpC,KAAKiN,eAGtD,GAAIoH,EAGF,IAFAF,GAAW3N,GAAS,IAAI1G,MAAM/B,IAAmB,GAE1CmE,EAAIC,EAAKD,IAQd,GAPAnC,EAAOC,KAAKkC,GAEZqQ,EAAwB,IAAlBxS,EAAKL,WAAmBK,EAAKkN,WAChC,IAAMlN,EAAKkN,UAAY,KAAK5H,QAAQkO,EAAQ,KAC7C,IAGEhB,EAAK,CACPnQ,EAAI,EACJ,MAAQgS,EAAQD,EAAQ/R,KAEtB,MAAOmQ,EAAIrV,QAAQ,IAAMkX,EAAQ,MAAQ,EACvC7B,EAAMA,EAAIlN,QAAQ,IAAM+O,EAAQ,IAAK,KAGzCrU,EAAKkN,UAAYzG,EAAQnK,EAAOmB,KAAK+U,GAAO,GAKlD,OAAOvS,MAGTuU,YAAa,SAAU/N,EAAOgO,GAC5B,IAAIxV,SAAcwH,EAChBiO,EAA6B,mBAAbD,EAElB,OAAInY,EAAOoE,WAAW+F,GACbxG,KAAKwB,MAAK,SAAUU,GACzB7F,EAAO2D,MAAMuU,YAAY/N,EAAMvF,KAAKjB,KAAMkC,EAAGlC,KAAKiN,UAAWuH,GAAWA,MAIrExU,KAAKwB,MAAK,WACf,GAAa,WAATxC,EAAmB,CAErB,IAAIiO,EACF/K,EAAI,EACJuH,EAAOpN,EAAO2D,MACduK,EAAQiK,EACRE,EAAalO,EAAM1G,MAAM/B,IAAmB,GAE9C,MAAQkP,EAAYyH,EAAWxS,KAE7BqI,EAAQkK,EAASlK,GAASd,EAAKkL,SAAS1H,GACxCxD,EAAKc,EAAQ,WAAa,eAAe0C,QAIlCjO,IAAS/C,GAA8B,YAAT+C,IACnCgB,KAAKiN,WAEP5Q,EAAOyV,MAAM9R,KAAM,gBAAiBA,KAAKiN,WAO3CjN,KAAKiN,UAAYjN,KAAKiN,YAAuB,IAAVzG,EAAkB,GAAKnK,EAAOyV,MAAM9R,KAAM,kBAAoB,QAKvG2U,SAAU,SAAUlX,GAIlB,IAHA,IAAIwP,EAAY,IAAMxP,EAAW,IAC/ByE,EAAI,EACJ+E,EAAIjH,KAAKR,OACJ0C,EAAI+E,EAAG/E,IACZ,GAAyB,IAArBlC,KAAKkC,GAAGxC,WAAmB,IAAMM,KAAKkC,GAAG+K,UAAY,KAAK5H,QAAQkO,EAAQ,KAAKrW,QAAQ+P,IAAc,EACvG,OAAO,EAIX,OAAO,GAGT2H,IAAK,SAAUpO,GACb,IAAIlF,EAAK8Q,EAAO3R,EACdV,EAAOC,KAAK,GAEd,OAAK8B,UAAUtC,QAoBfiB,EAAapE,EAAOoE,WAAW+F,GAExBxG,KAAKwB,MAAK,SAAUU,GACzB,IAAI0S,EACFnL,EAAOpN,EAAO2D,MAEM,IAAlBA,KAAKN,WAKPkV,EADEnU,EACI+F,EAAMvF,KAAKjB,KAAMkC,EAAGuH,EAAKmL,OAEzBpO,EAIG,MAAPoO,EACFA,EAAM,GACkB,kBAARA,EAChBA,GAAO,GACEvY,EAAO6G,QAAQ0R,KACxBA,EAAMvY,EAAOgG,IAAIuS,GAAK,SAAUpO,GAC9B,OAAgB,MAATA,EAAgB,GAAKA,EAAQ,OAIxC4L,EAAQ/V,EAAOwY,SAAS7U,KAAKhB,OAAS3C,EAAOwY,SAAS7U,KAAKsG,SAASC,eAG/D6L,GAAW,QAASA,GAAUA,EAAM0C,IAAI9U,KAAM4U,EAAK,WAAa9Y,IACnEkE,KAAKwG,MAAQoO,QAlDX7U,GACFqS,EAAQ/V,EAAOwY,SAAS9U,EAAKf,OAAS3C,EAAOwY,SAAS9U,EAAKuG,SAASC,eAEhE6L,GAAS,QAASA,IAAU9Q,EAAM8Q,EAAMlR,IAAInB,EAAM,YAAcjE,EAC3DwF,GAGTA,EAAMvB,EAAKyG,MAEW,kBAARlF,EAEZA,EAAI+D,QAAQmO,EAAS,IAEd,MAAPlS,EAAc,GAAKA,SAGvB,KAwCNjF,EAAOoG,OAAO,CACZoS,SAAU,CACRE,OAAQ,CACN7T,IAAK,SAAUnB,GAGb,IAAI6U,EAAM7U,EAAKuP,WAAW9I,MAC1B,OAAQoO,GAAOA,EAAII,UAAYjV,EAAKyG,MAAQzG,EAAK0G,OAGrD4F,OAAQ,CACNnL,IAAK,SAAUnB,GAYb,IAXA,IAAIyG,EAAOuO,EACTjS,EAAU/C,EAAK+C,QACfiH,EAAQhK,EAAKkV,cACbC,EAAoB,eAAdnV,EAAKf,MAAyB+K,EAAQ,EAC5CiC,EAASkJ,EAAM,KAAO,GACtBnO,EAAMmO,EAAMnL,EAAQ,EAAIjH,EAAQtD,OAChC0C,EAAI6H,EAAQ,EACVhD,EACAmO,EAAMnL,EAAQ,EAGX7H,EAAI6E,EAAK7E,IAId,GAHA6S,EAASjS,EAAQZ,IAGZ6S,EAAOnH,UAAY1L,IAAM6H,KAE3B1N,EAAO6P,QAAQ0C,aAAemG,EAAO9K,SAA+C,OAApC8K,EAAOzH,aAAa,gBACnEyH,EAAOnU,WAAWqJ,WAAa5N,EAAOiK,SAASyO,EAAOnU,WAAY,aAAc,CAMlF,GAHA4F,EAAQnK,EAAO0Y,GAAQH,MAGnBM,EACF,OAAO1O,EAITwF,EAAOlP,KAAK0J,GAIhB,OAAOwF,GAGT8I,IAAK,SAAU/U,EAAMyG,GACnB,IAAIwF,EAAS3P,EAAOyE,UAAU0F,GAS9B,OAPAnK,EAAO0D,GAAMI,KAAK,UAAUqB,MAAK,WAC/BxB,KAAK4N,SAAWvR,EAAOwK,QAAQxK,EAAO2D,MAAM4U,MAAO5I,IAAW,KAG3DA,EAAOxM,SACVO,EAAKkV,eAAiB,GAEjBjJ,KAKbtL,KAAM,SAAUX,EAAM8C,EAAM2D,GAC1B,IAAI4L,EAAO+C,EAAQ7T,EACjB8T,EAAQrV,EAAKL,SAGf,GAAKK,GAAkB,IAAVqV,GAAyB,IAAVA,GAAyB,IAAVA,EAK3C,cAAWrV,EAAKuN,eAAiBrR,EACxBI,EAAO0X,KAAKhU,EAAM8C,EAAM2D,IAGjC2O,EAAmB,IAAVC,IAAgB/Y,EAAOgZ,SAAStV,GAIrCoV,IACFtS,EAAOA,EAAK0D,cACZ6L,EAAQ/V,EAAOiZ,UAAUzS,KAAU8Q,GAASpT,KAAKsC,GAAQyQ,EAAWD,IAGlE7M,IAAU1K,EAaHsW,GAAS+C,GAAU,QAAS/C,GAA2C,QAAjC9Q,EAAM8Q,EAAMlR,IAAInB,EAAM8C,IAC9DvB,UAMIvB,EAAKuN,eAAiBrR,IAC/BqF,EAAMvB,EAAKuN,aAAazK,IAIZ,MAAPvB,EACLxF,EACAwF,GAzBY,OAAVkF,EAGO4L,GAAS+C,GAAU,QAAS/C,IAAU9Q,EAAM8Q,EAAM0C,IAAI/U,EAAMyG,EAAO3D,MAAW/G,EAChFwF,GAGPvB,EAAK4M,aAAa9J,EAAM2D,EAAQ,IACzBA,QAPPnK,EAAOyX,WAAW/T,EAAM8C,KA4B9BiR,WAAY,SAAU/T,EAAMyG,GAC1B,IAAI3D,EAAM0S,EACRrT,EAAI,EACJsT,EAAYhP,GAASA,EAAM1G,MAAM/B,GAEnC,GAAIyX,GAA+B,IAAlBzV,EAAKL,SACpB,MAAQmD,EAAO2S,EAAUtT,KACvBqT,EAAWlZ,EAAO4X,QAAQpR,IAASA,EAG/B8Q,GAASpT,KAAKsC,IAGXmK,IAAmB4G,GAAYrT,KAAKsC,GACvC9C,EAAK1D,EAAO+J,UAAU,WAAavD,IACjC9C,EAAKwV,IAAY,EAEnBxV,EAAKwV,IAAY,EAKnBlZ,EAAOqE,KAAKX,EAAM8C,EAAM,IAG1B9C,EAAK0V,gBAAgBzI,GAAkBnK,EAAO0S,IAKpDD,UAAW,CACTtW,KAAM,CACJ8V,IAAK,SAAU/U,EAAMyG,GACnB,IAAKnK,EAAO6P,QAAQ2C,YAAwB,UAAVrI,GAAqBnK,EAAOiK,SAASvG,EAAM,SAAU,CAGrF,IAAI6U,EAAM7U,EAAKyG,MAKf,OAJAzG,EAAK4M,aAAa,OAAQnG,GACtBoO,IACF7U,EAAKyG,MAAQoO,GAERpO,MAMfyN,QAAS,CACPyB,SAAU,WACVC,SAAU,WACV,IAAO,UACP,MAAS,YACTC,UAAW,YACXC,YAAa,cACbC,YAAa,cACbC,QAAS,UACTC,QAAS,UACTC,OAAQ,SACRC,YAAa,cACbC,gBAAiB,mBAGnBpC,KAAM,SAAUhU,EAAM8C,EAAM2D,GAC1B,IAAIlF,EAAK8Q,EAAO+C,EACdC,EAAQrV,EAAKL,SAGf,GAAKK,GAAkB,IAAVqV,GAAyB,IAAVA,GAAyB,IAAVA,EAY3C,OARAD,EAAmB,IAAVC,IAAgB/Y,EAAOgZ,SAAStV,GAErCoV,IAEFtS,EAAOxG,EAAO4X,QAAQpR,IAASA,EAC/BuP,EAAQ/V,EAAO+Z,UAAUvT,IAGvB2D,IAAU1K,EACRsW,GAAS,QAASA,IAAU9Q,EAAM8Q,EAAM0C,IAAI/U,EAAMyG,EAAO3D,MAAW/G,EAC/DwF,EAGCvB,EAAK8C,GAAQ2D,EAInB4L,GAAS,QAASA,GAA2C,QAAjC9Q,EAAM8Q,EAAMlR,IAAInB,EAAM8C,IAC7CvB,EAGAvB,EAAK8C,IAKlBuT,UAAW,CACTC,SAAU,CACRnV,IAAK,SAAUnB,GAGb,IAAIuW,EAAgBvW,EAAKwW,iBAAiB,YAE1C,OAAOD,GAAiBA,EAActB,UACpCwB,SAASF,EAAc9P,MAAO,IAC9BiN,EAAWlT,KAAKR,EAAKuG,WAAaoN,EAAWnT,KAAKR,EAAKuG,WAAavG,EAAK0W,KACvE,EACA3a,OAOZwX,EAAW,CACTpS,IAAK,SAAUnB,EAAM8C,GACnB,IAEEkR,EAAO1X,EAAO0X,KAAKhU,EAAM8C,GAGzBnC,EAAuB,mBAATqT,GAAsBhU,EAAKuN,aAAazK,GACtD6T,EAAyB,mBAAT3C,EAEdF,IAAe7G,GACL,MAARtM,EAGAkT,GAAYrT,KAAKsC,GACf9C,EAAK1D,EAAO+J,UAAU,WAAavD,MACjCnC,EAGNX,EAAKwW,iBAAiB1T,GAE1B,OAAO6T,IAA2B,IAAjBA,EAAOlQ,MACtB3D,EAAK0D,cACLzK,GAEJgZ,IAAK,SAAU/U,EAAMyG,EAAO3D,GAa1B,OAZc,IAAV2D,EAEFnK,EAAOyX,WAAW/T,EAAM8C,GACfgR,IAAe7G,KAAoB4G,GAAYrT,KAAKsC,GAE7D9C,EAAK4M,cAAcK,IAAmB3Q,EAAO4X,QAAQpR,IAASA,EAAMA,GAIpE9C,EAAK1D,EAAO+J,UAAU,WAAavD,IAAS9C,EAAK8C,IAAQ,EAGpDA,IAKNgR,IAAgB7G,KACnB3Q,EAAOiZ,UAAU9O,MAAQ,CACvBtF,IAAK,SAAUnB,EAAM8C,GACnB,IAAIvB,EAAMvB,EAAKwW,iBAAiB1T,GAChC,OAAOxG,EAAOiK,SAASvG,EAAM,SAG3BA,EAAK4W,aAELrV,GAAOA,EAAI0T,UAAY1T,EAAIkF,MAAQ1K,GAEvCgZ,IAAK,SAAU/U,EAAMyG,EAAO3D,GAC1B,IAAIxG,EAAOiK,SAASvG,EAAM,SAKxB,OAAOsT,GAAYA,EAASyB,IAAI/U,EAAMyG,EAAO3D,GAH7C9C,EAAK4W,aAAenQ,KAUvBwG,KAIHqG,EAAWhX,EAAOwY,SAAS+B,OAAS,CAClC1V,IAAK,SAAUnB,EAAM8C,GACnB,IAAIvB,EAAMvB,EAAKwW,iBAAiB1T,GAChC,OAAOvB,IAAiB,OAATuB,GAA0B,SAATA,GAA4B,WAATA,EAAkC,KAAdvB,EAAIkF,MAAelF,EAAI0T,WAC5F1T,EAAIkF,MACJ1K,GAEJgZ,IAAK,SAAU/U,EAAMyG,EAAO3D,GAE1B,IAAIvB,EAAMvB,EAAKwW,iBAAiB1T,GAUhC,OATKvB,GACHvB,EAAK8W,iBACFvV,EAAMvB,EAAKO,cAAcwW,gBAAgBjU,IAI9CvB,EAAIkF,MAAQA,GAAS,GAGL,UAAT3D,GAAoB2D,IAAUzG,EAAKuN,aAAazK,GACrD2D,EACA1K,IAMNO,EAAOiZ,UAAUa,gBAAkB,CACjCjV,IAAKmS,EAASnS,IACd4T,IAAK,SAAU/U,EAAMyG,EAAO3D,GAC1BwQ,EAASyB,IAAI/U,EAAgB,KAAVyG,GAAuBA,EAAO3D,KAMrDxG,EAAOmF,KAAK,CAAC,QAAS,WAAW,SAAUU,EAAGW,GAC5CxG,EAAOiZ,UAAUzS,GAAQxG,EAAOoG,OAAOpG,EAAOiZ,UAAUzS,GAAO,CAC7DiS,IAAK,SAAU/U,EAAMyG,GACnB,GAAc,KAAVA,EAEF,OADAzG,EAAK4M,aAAa9J,EAAM,QACjB2D,SAUZnK,EAAO6P,QAAQqB,iBAClBlR,EAAOmF,KAAK,CAAC,OAAQ,MAAO,QAAS,WAAW,SAAUU,EAAGW,GAC3DxG,EAAOiZ,UAAUzS,GAAQxG,EAAOoG,OAAOpG,EAAOiZ,UAAUzS,GAAO,CAC7D3B,IAAK,SAAUnB,GACb,IAAIuB,EAAMvB,EAAKuN,aAAazK,EAAM,GAClC,OAAc,MAAPvB,EAAcxF,EAAYwF,QAMvCjF,EAAOmF,KAAK,CAAC,OAAQ,QAAQ,SAAUU,EAAGW,GACxCxG,EAAO+Z,UAAUvT,GAAQ,CACvB3B,IAAK,SAAUnB,GACb,OAAOA,EAAKuN,aAAazK,EAAM,SAMlCxG,EAAO6P,QAAQY,QAClBzQ,EAAOiZ,UAAUxI,MAAQ,CACvB5L,IAAK,SAAUnB,GAIb,OAAOA,EAAK+M,MAAMC,SAAWjR,GAE/BgZ,IAAK,SAAU/U,EAAMyG,GACnB,OAAQzG,EAAK+M,MAAMC,QAAUvG,EAAQ,MAOtCnK,EAAO6P,QAAQyB,cAClBtR,EAAO+Z,UAAUxI,SAAWvR,EAAOoG,OAAOpG,EAAO+Z,UAAUxI,SAAU,CACnE1M,IAAK,SAAUnB,GACb,IAAIgX,EAAShX,EAAKa,WAUlB,OARImW,IACFA,EAAO9B,cAGH8B,EAAOnW,YACTmW,EAAOnW,WAAWqU,eAGf,SAMR5Y,EAAO6P,QAAQ2B,UAClBxR,EAAO4X,QAAQpG,QAAU,YAItBxR,EAAO6P,QAAQwB,SAClBrR,EAAOmF,KAAK,CAAC,QAAS,aAAa,WACjCnF,EAAOwY,SAAS7U,MAAQ,CACtBkB,IAAK,SAAUnB,GAEb,OAAsC,OAA/BA,EAAKuN,aAAa,SAAoB,KAAOvN,EAAKyG,WAKjEnK,EAAOmF,KAAK,CAAC,QAAS,aAAa,WACjCnF,EAAOwY,SAAS7U,MAAQ3D,EAAOoG,OAAOpG,EAAOwY,SAAS7U,MAAO,CAC3D8U,IAAK,SAAU/U,EAAMyG,GACnB,GAAInK,EAAO6G,QAAQsD,GACjB,OAAQzG,EAAK2O,QAAUrS,EAAOwK,QAAQxK,EAAO0D,GAAM6U,MAAOpO,IAAU,QAK5E,IAAIwQ,GAAa,+BACfC,GAAY,OACZC,GAAc,+BACdC,GAAc,kCACdC,GAAiB,uBAEnB,SAASC,KACP,OAAO,EAGT,SAASC,KACP,OAAO,EAOTjb,EAAOyC,MAAQ,CAEbyY,OAAQ,GAER5N,IAAK,SAAU5J,EAAMyX,EAAOC,EAAS/S,EAAMjH,GACzC,IAAIgI,EAAKiS,EAAQC,EAAGC,EAClBC,EAASC,EAAaC,EACtBC,EAAUhZ,EAAMiZ,EAAYC,EAC5BC,EAAW9b,EAAOyV,MAAM/R,GAG1B,GAAKoY,EAAL,CAKIV,EAAQA,UACVG,EAAcH,EACdA,EAAUG,EAAYH,QACtBha,EAAWma,EAAYna,UAIpBga,EAAQnQ,OACXmQ,EAAQnQ,KAAOjL,EAAOiL,SAIlBoQ,EAASS,EAAST,UACtBA,EAASS,EAAST,OAAS,KAEvBI,EAAcK,EAASC,UAC3BN,EAAcK,EAASC,OAAS,SAAUhU,GAGxC,cAAc/H,IAAWJ,GAAuBmI,GAAK/H,EAAOyC,MAAMuZ,YAAcjU,EAAEpF,KAEhFlD,EADAO,EAAOyC,MAAMwZ,SAASzW,MAAMiW,EAAY/X,KAAM+B,YAIlDgW,EAAY/X,KAAOA,GAKrByX,GAASA,GAAS,IAAI1X,MAAM/B,IAAmB,CAAC,IAChD4Z,EAAIH,EAAMhY,OACV,MAAOmY,IACLlS,EAAM2R,GAAelX,KAAKsX,EAAMG,KAAO,GACvC3Y,EAAOkZ,EAAWzS,EAAI,GACtBwS,GAAcxS,EAAI,IAAM,IAAI6C,MAAM,KAAK/F,OAGvCsV,EAAUxb,EAAOyC,MAAM+Y,QAAQ7Y,IAAS,GAGxCA,GAAQvB,EAAWoa,EAAQU,aAAeV,EAAQW,WAAaxZ,EAG/D6Y,EAAUxb,EAAOyC,MAAM+Y,QAAQ7Y,IAAS,GAGxC+Y,EAAY1b,EAAOoG,OAAO,CACxBzD,KAAMA,EACNkZ,SAAUA,EACVxT,KAAMA,EACN+S,QAASA,EACTnQ,KAAMmQ,EAAQnQ,KACd7J,SAAUA,EACVgb,aAAchb,GAAYpB,EAAOqc,KAAK5Y,MAAM2Y,aAAalY,KAAK9C,GAC9Dkb,UAAWV,EAAWW,KAAK,MAC1BhB,IAGGI,EAAWN,EAAO1Y,MACtBgZ,EAAWN,EAAO1Y,GAAQ,GAC1BgZ,EAASa,cAAgB,EAGpBhB,EAAQiB,QAAqE,IAA5DjB,EAAQiB,MAAM7X,KAAKlB,EAAM2E,EAAMuT,EAAYH,KAE3D/X,EAAKhB,iBACPgB,EAAKhB,iBAAiBC,EAAM8Y,GAAa,GAEhC/X,EAAKkI,aACdlI,EAAKkI,YAAY,KAAOjJ,EAAM8Y,KAKhCD,EAAQlO,MACVkO,EAAQlO,IAAI1I,KAAKlB,EAAMgY,GAElBA,EAAUN,QAAQnQ,OACrByQ,EAAUN,QAAQnQ,KAAOmQ,EAAQnQ,OAKjC7J,EACFua,EAASxV,OAAOwV,EAASa,gBAAiB,EAAGd,GAE7CC,EAASlb,KAAKib,GAIhB1b,EAAOyC,MAAMyY,OAAOvY,IAAQ,EAI9Be,EAAO,OAITiF,OAAQ,SAAUjF,EAAMyX,EAAOC,EAASha,EAAUsb,GAChD,IAAI3W,EAAG2V,EAAWtS,EAChBuT,EAAWrB,EAAGD,EACdG,EAASG,EAAUhZ,EACnBiZ,EAAYC,EACZC,EAAW9b,EAAOuV,QAAQ7R,IAAS1D,EAAOyV,MAAM/R,GAElD,GAAKoY,IAAcT,EAASS,EAAST,QAArC,CAKAF,GAASA,GAAS,IAAI1X,MAAM/B,IAAmB,CAAC,IAChD4Z,EAAIH,EAAMhY,OACV,MAAOmY,IAML,GALAlS,EAAM2R,GAAelX,KAAKsX,EAAMG,KAAO,GACvC3Y,EAAOkZ,EAAWzS,EAAI,GACtBwS,GAAcxS,EAAI,IAAM,IAAI6C,MAAM,KAAK/F,OAGlCvD,EAAL,CAOA6Y,EAAUxb,EAAOyC,MAAM+Y,QAAQ7Y,IAAS,GACxCA,GAAQvB,EAAWoa,EAAQU,aAAeV,EAAQW,WAAaxZ,EAC/DgZ,EAAWN,EAAO1Y,IAAS,GAC3ByG,EAAMA,EAAI,IAAM,IAAIwT,OAAO,UAAYhB,EAAWW,KAAK,iBAAmB,WAG1EI,EAAY5W,EAAI4V,EAASxY,OACzB,MAAO4C,IACL2V,EAAYC,EAAS5V,IAEhB2W,GAAeb,IAAaH,EAAUG,UACvCT,GAAWA,EAAQnQ,OAASyQ,EAAUzQ,MACtC7B,IAAOA,EAAIlF,KAAKwX,EAAUY,YAC1Blb,GAAYA,IAAasa,EAAUta,WAAyB,OAAbA,IAAqBsa,EAAUta,YAChFua,EAASxV,OAAOJ,EAAG,GAEf2V,EAAUta,UACZua,EAASa,gBAEPhB,EAAQ7S,QACV6S,EAAQ7S,OAAO/D,KAAKlB,EAAMgY,IAO5BiB,IAAchB,EAASxY,SACpBqY,EAAQqB,WAAyE,IAA7DrB,EAAQqB,SAASjY,KAAKlB,EAAMkY,EAAYE,EAASC,SACxE/b,EAAO8c,YAAYpZ,EAAMf,EAAMmZ,EAASC,eAGnCV,EAAO1Y,SAtCd,IAAKA,KAAQ0Y,EACXrb,EAAOyC,MAAMkG,OAAOjF,EAAMf,EAAOwY,EAAMG,GAAIF,EAASha,GAAU,GA0ChEpB,EAAOiI,cAAcoT,YAChBS,EAASC,OAIhB/b,EAAO0V,YAAYhS,EAAM,aAI7B6D,QAAS,SAAU9E,EAAO4F,EAAM3E,EAAMqZ,GACpC,IAAIhB,EAAQiB,EAAQ9G,EAClB+G,EAAYzB,EAASpS,EAAKvD,EAC1BqX,EAAY,CAACxZ,GAAQ7D,GACrB8C,EAAO3B,EAAY4D,KAAKnC,EAAO,QAAUA,EAAME,KAAOF,EACtDmZ,EAAa5a,EAAY4D,KAAKnC,EAAO,aAAeA,EAAM6Z,UAAUrQ,MAAM,KAAO,GAKnF,GAHAiK,EAAM9M,EAAM1F,EAAOA,GAAQ7D,EAGL,IAAlB6D,EAAKL,UAAoC,IAAlBK,EAAKL,WAK5ByX,GAAY5W,KAAKvB,EAAO3C,EAAOyC,MAAMuZ,aAIrCrZ,EAAK9B,QAAQ,MAAQ,IAEvB+a,EAAajZ,EAAKsJ,MAAM,KACxBtJ,EAAOiZ,EAAWzO,QAClByO,EAAW1V,QAEb8W,EAASra,EAAK9B,QAAQ,KAAO,GAAK,KAAO8B,EAGzCF,EAAQA,EAAMzC,EAAOkT,SACnBzQ,EACA,IAAIzC,EAAOmd,MAAMxa,EAAuB,kBAAVF,GAAsBA,GAEtDA,EAAM2a,WAAY,EAClB3a,EAAM6Z,UAAYV,EAAWW,KAAK,KAClC9Z,EAAM4a,aAAe5a,EAAM6Z,UACzB,IAAIM,OAAO,UAAYhB,EAAWW,KAAK,iBAAmB,WAC1D,KAGF9Z,EAAM6a,OAAS7d,EACVgD,EAAMkE,SACTlE,EAAMkE,OAASjD,GAIjB2E,EAAe,MAARA,EACL,CAAC5F,GACDzC,EAAOyE,UAAU4D,EAAM,CAAC5F,IAG1B+Y,EAAUxb,EAAOyC,MAAM+Y,QAAQ7Y,IAAS,GACnCoa,IAAgBvB,EAAQjU,UAAiD,IAAtCiU,EAAQjU,QAAQ/B,MAAM9B,EAAM2E,IAApE,CAMA,IAAK0U,IAAiBvB,EAAQ+B,WAAavd,EAAOoD,SAASM,GAAO,CAMhE,IAJAuZ,EAAazB,EAAQU,cAAgBvZ,EAChCmY,GAAY5W,KAAK+Y,EAAata,KACjCuT,EAAMA,EAAI3R,YAEL2R,EAAKA,EAAMA,EAAI3R,WACpB2Y,EAAUzc,KAAKyV,GACf9M,EAAM8M,EAIJ9M,KAAS1F,EAAKO,eAAiBpE,IACjCqd,EAAUzc,KAAK2I,EAAIoU,aAAepU,EAAIqU,cAAgBje,GAK1DqG,EAAI,EACJ,OAAQqQ,EAAMgH,EAAUrX,QAAUpD,EAAMib,uBAEtCjb,EAAME,KAAOkD,EAAI,EACfoX,EACAzB,EAAQW,UAAYxZ,EAGtBoZ,GAAU/b,EAAOyV,MAAMS,EAAK,WAAa,IAAIzT,EAAME,OAAS3C,EAAOyV,MAAMS,EAAK,UAC1E6F,GACFA,EAAOvW,MAAM0Q,EAAK7N,GAIpB0T,EAASiB,GAAU9G,EAAI8G,GACnBjB,GAAU/b,EAAOyU,WAAWyB,IAAQ6F,EAAOvW,QAAqC,IAA5BuW,EAAOvW,MAAM0Q,EAAK7N,IACxE5F,EAAMkb,iBAMV,GAHAlb,EAAME,KAAOA,GAGRoa,IAAiBta,EAAMmb,wBAEpBpC,EAAQqC,WAAiE,IAArDrC,EAAQqC,SAASrY,MAAM9B,EAAKO,cAAeoE,MACxD,UAAT1F,IAAoB3C,EAAOiK,SAASvG,EAAM,OAAS1D,EAAOyU,WAAW/Q,IAKnEsZ,GAAUtZ,EAAKf,KAAU3C,EAAOoD,SAASM,GAAO,CAGlD0F,EAAM1F,EAAKsZ,GAEP5T,IACF1F,EAAKsZ,GAAU,MAIjBhd,EAAOyC,MAAMuZ,UAAYrZ,EACzB,IACEe,EAAKf,KACL,MAAOoF,IAIT/H,EAAOyC,MAAMuZ,UAAYvc,EAErB2J,IACF1F,EAAKsZ,GAAU5T,GAMvB,OAAO3G,EAAM6a,SAGfrB,SAAU,SAAUxZ,GAGlBA,EAAQzC,EAAOyC,MAAMqb,IAAIrb,GAEzB,IAAIoD,EAAGZ,EAAKyW,EAAWqC,EAAShY,EAC9BiY,EAAe,GACf3Y,EAAO3E,EAAWkE,KAAKa,WACvBkW,GAAY3b,EAAOyV,MAAM9R,KAAM,WAAa,IAAIlB,EAAME,OAAS,GAC/D6Y,EAAUxb,EAAOyC,MAAM+Y,QAAQ/Y,EAAME,OAAS,GAOhD,GAJA0C,EAAK,GAAK5C,EACVA,EAAMwb,eAAiBta,MAGnB6X,EAAQ0C,cAAyD,IAA1C1C,EAAQ0C,YAAYtZ,KAAKjB,KAAMlB,GAA1D,CAKAub,EAAehe,EAAOyC,MAAMkZ,SAAS/W,KAAKjB,KAAMlB,EAAOkZ,GAGvD9V,EAAI,EACJ,OAAQkY,EAAUC,EAAanY,QAAUpD,EAAMib,uBAAwB,CACrEjb,EAAM0b,cAAgBJ,EAAQra,KAE9BqC,EAAI,EACJ,OAAQ2V,EAAYqC,EAAQpC,SAAS5V,QAAUtD,EAAM2b,gCAI9C3b,EAAM4a,eAAgB5a,EAAM4a,aAAanZ,KAAKwX,EAAUY,aAE3D7Z,EAAMiZ,UAAYA,EAClBjZ,EAAM4F,KAAOqT,EAAUrT,KAEvBpD,IAAQjF,EAAOyC,MAAM+Y,QAAQE,EAAUG,WAAa,IAAIE,QAAUL,EAAUN,SACzE5V,MAAMuY,EAAQra,KAAM2B,GAEnBJ,IAAQxF,IACmB,KAAxBgD,EAAM6a,OAASrY,KAClBxC,EAAMkb,iBACNlb,EAAM4b,oBAYhB,OAJI7C,EAAQ8C,cACV9C,EAAQ8C,aAAa1Z,KAAKjB,KAAMlB,GAG3BA,EAAM6a,SAGf3B,SAAU,SAAUlZ,EAAOkZ,GACzB,IAAI4C,EAAK7C,EAAW8C,EAAS3Y,EAC3BmY,EAAe,GACfxB,EAAgBb,EAASa,cACzBtG,EAAMzT,EAAMkE,OAKd,GAAI6V,GAAiBtG,EAAI7S,YAAcZ,EAAM8X,QAAyB,UAAf9X,EAAME,MAE3D,KAAOuT,GAAOvS,KAAMuS,EAAMA,EAAI3R,YAAcZ,KAI1C,GAAqB,IAAjBuS,EAAI7S,YAAoC,IAAjB6S,EAAItI,UAAoC,UAAfnL,EAAME,MAAmB,CAE3E,IADA6b,EAAU,GACL3Y,EAAI,EAAGA,EAAI2W,EAAe3W,IAC7B6V,EAAYC,EAAS9V,GAGrB0Y,EAAM7C,EAAUta,SAAW,IAEvBod,EAAQD,KAAS9e,IACnB+e,EAAQD,GAAO7C,EAAUU,aACvBpc,EAAOue,EAAK5a,MAAM+J,MAAMwI,IAAQ,EAChClW,EAAO8D,KAAKya,EAAK5a,KAAM,KAAM,CAACuS,IAAM/S,QAEpCqb,EAAQD,IACVC,EAAQ/d,KAAKib,GAGb8C,EAAQrb,QACV6a,EAAavd,KAAK,CAAEiD,KAAMwS,EAAKyF,SAAU6C,IAWjD,OAJIhC,EAAgBb,EAASxY,QAC3B6a,EAAavd,KAAK,CAAEiD,KAAMC,KAAMgY,SAAUA,EAAShb,MAAM6b,KAGpDwB,GAGTF,IAAK,SAAUrb,GACb,GAAIA,EAAMzC,EAAOkT,SACf,OAAOzQ,EAIT,IAAIoD,EAAG6R,EAAMnR,EACX5D,EAAOF,EAAME,KACb8b,EAAgBhc,EAChBic,EAAU/a,KAAKgb,SAAShc,GAErB+b,IACH/a,KAAKgb,SAAShc,GAAQ+b,EACpB7D,GAAY3W,KAAKvB,GAAQgB,KAAKib,WAC5BhE,GAAU1W,KAAKvB,GAAQgB,KAAKkb,SAC1B,IAERtY,EAAOmY,EAAQI,MAAQnb,KAAKmb,MAAMve,OAAOme,EAAQI,OAASnb,KAAKmb,MAE/Drc,EAAQ,IAAIzC,EAAOmd,MAAMsB,GAEzB5Y,EAAIU,EAAKpD,OACT,MAAO0C,IACL6R,EAAOnR,EAAKV,GACZpD,EAAMiV,GAAQ+G,EAAc/G,GAmB9B,OAdKjV,EAAMkE,SACTlE,EAAMkE,OAAS8X,EAAcM,YAAclf,GAKf,IAA1B4C,EAAMkE,OAAOtD,WACfZ,EAAMkE,OAASlE,EAAMkE,OAAOpC,YAK9B9B,EAAMuc,UAAYvc,EAAMuc,QAEjBN,EAAQO,OAASP,EAAQO,OAAOxc,EAAOgc,GAAiBhc,GAIjEqc,MAAO,wHAAwH7S,MAAM,KAErI0S,SAAU,GAEVE,SAAU,CACRC,MAAO,4BAA4B7S,MAAM,KACzCgT,OAAQ,SAAUxc,EAAOyc,GAOvB,OAJmB,MAAfzc,EAAM0c,QACR1c,EAAM0c,MAA6B,MAArBD,EAASE,SAAmBF,EAASE,SAAWF,EAASG,SAGlE5c,IAIXmc,WAAY,CACVE,MAAO,mGAAmG7S,MAAM,KAChHgT,OAAQ,SAAUxc,EAAOyc,GACvB,IAAI9X,EAAMkY,EAAUC,EAClBhF,EAAS2E,EAAS3E,OAClBiF,EAAcN,EAASM,YAuBzB,OApBmB,MAAf/c,EAAMgd,OAAqC,MAApBP,EAASQ,UAClCJ,EAAW7c,EAAMkE,OAAO1C,eAAiBpE,EACzC0f,EAAMD,EAAS5V,gBACftC,EAAOkY,EAASlY,KAEhB3E,EAAMgd,MAAQP,EAASQ,SAAWH,GAAOA,EAAII,YAAcvY,GAAQA,EAAKuY,YAAc,IAAMJ,GAAOA,EAAIK,YAAcxY,GAAQA,EAAKwY,YAAc,GAChJnd,EAAMod,MAAQX,EAASY,SAAWP,GAAOA,EAAIQ,WAAa3Y,GAAQA,EAAK2Y,WAAa,IAAMR,GAAOA,EAAIS,WAAa5Y,GAAQA,EAAK4Y,WAAa,KAIzIvd,EAAMwd,eAAiBT,IAC1B/c,EAAMwd,cAAgBT,IAAgB/c,EAAMkE,OAASuY,EAASgB,UAAYV,GAKvE/c,EAAM0c,OAAS5E,IAAW9a,IAC7BgD,EAAM0c,MAAkB,EAAT5E,EAAa,EAAc,EAATA,EAAa,EAAc,EAATA,EAAa,EAAI,GAG/D9X,IAIX+Y,QAAS,CACP2E,KAAM,CAEJ5C,UAAU,GAEZ1K,MAAO,CAELtL,QAAS,WACP,GAAIvH,EAAOiK,SAAStG,KAAM,UAA0B,aAAdA,KAAKhB,MAAuBgB,KAAKkP,MAErE,OADAlP,KAAKkP,SACE,IAIbuN,MAAO,CAEL7Y,QAAS,WACP,GAAI5D,OAAS9D,EAASwgB,eAAiB1c,KAAKyc,MAC1C,IAEE,OADAzc,KAAKyc,SACE,EACP,MAAOrY,MAObmU,aAAc,WAEhBoE,KAAM,CACJ/Y,QAAS,WACP,GAAI5D,OAAS9D,EAASwgB,eAAiB1c,KAAK2c,KAE1C,OADA3c,KAAK2c,QACE,GAGXpE,aAAc,YAGhBqE,aAAc,CACZjC,aAAc,SAAU7b,GAGlBA,EAAM6a,SAAW7d,IACnBgD,EAAMgc,cAAc+B,YAAc/d,EAAM6a,WAMhDmD,SAAU,SAAU9d,EAAMe,EAAMjB,EAAOie,GAIrC,IAAI3Y,EAAI/H,EAAOoG,OACb,IAAIpG,EAAOmd,MACX1a,EACA,CACEE,KAAMA,EACNge,aAAa,EACblC,cAAe,KAGfiC,EACF1gB,EAAOyC,MAAM8E,QAAQQ,EAAG,KAAMrE,GAE9B1D,EAAOyC,MAAMwZ,SAASrX,KAAKlB,EAAMqE,GAE/BA,EAAE6V,sBACJnb,EAAMkb,mBAKZ3d,EAAO8c,YAAcjd,EAASkD,oBAC5B,SAAUW,EAAMf,EAAMoZ,GAChBrY,EAAKX,qBACPW,EAAKX,oBAAoBJ,EAAMoZ,GAAQ,IAG3C,SAAUrY,EAAMf,EAAMoZ,GACpB,IAAIvV,EAAO,KAAO7D,EAEde,EAAKV,qBAIIU,EAAK8C,KAAU5G,IACxB8D,EAAK8C,GAAQ,MAGf9C,EAAKV,YAAYwD,EAAMuV,KAI7B/b,EAAOmd,MAAQ,SAAU9W,EAAKyY,GAE5B,KAAMnb,gBAAgB3D,EAAOmd,OAC3B,OAAO,IAAInd,EAAOmd,MAAM9W,EAAKyY,GAI3BzY,GAAOA,EAAI1D,MACbgB,KAAK8a,cAAgBpY,EACrB1C,KAAKhB,KAAO0D,EAAI1D,KAIhBgB,KAAKia,mBAAsBvX,EAAIua,mBAAwC,IAApBva,EAAIma,aACrDna,EAAIwa,mBAAqBxa,EAAIwa,oBAAuB7F,GAAaC,IAInEtX,KAAKhB,KAAO0D,EAIVyY,GACF9e,EAAOoG,OAAOzC,KAAMmb,GAItBnb,KAAKmd,UAAYza,GAAOA,EAAIya,WAAa9gB,EAAOwL,MAGhD7H,KAAK3D,EAAOkT,UAAW,GAKzBlT,EAAOmd,MAAM7Z,UAAY,CACvBsa,mBAAoB3C,GACpByC,qBAAsBzC,GACtBmD,8BAA+BnD,GAE/B0C,eAAgB,WACd,IAAI5V,EAAIpE,KAAK8a,cAEb9a,KAAKia,mBAAqB5C,GACrBjT,IAKDA,EAAE4V,eACJ5V,EAAE4V,iBAKF5V,EAAEyY,aAAc,IAGpBnC,gBAAiB,WACf,IAAItW,EAAIpE,KAAK8a,cAEb9a,KAAK+Z,qBAAuB1C,GACvBjT,IAIDA,EAAEsW,iBACJtW,EAAEsW,kBAKJtW,EAAEgZ,cAAe,IAEnBC,yBAA0B,WACxBrd,KAAKya,8BAAgCpD,GACrCrX,KAAK0a,oBAKTre,EAAOmF,KAAK,CACV8b,WAAY,YACZC,WAAY,aACX,SAAUC,EAAMrD,GACjB9d,EAAOyC,MAAM+Y,QAAQ2F,GAAQ,CAC3BjF,aAAc4B,EACd3B,SAAU2B,EAEV/B,OAAQ,SAAUtZ,GAChB,IAAIwC,EACF0B,EAAShD,KACTyd,EAAU3e,EAAMwd,cAChBvE,EAAYjZ,EAAMiZ,UASpB,OALK0F,IAAYA,IAAYza,GAAW3G,EAAOqhB,SAAS1a,EAAQya,MAC9D3e,EAAME,KAAO+Y,EAAUG,SACvB5W,EAAMyW,EAAUN,QAAQ5V,MAAM7B,KAAM8B,WACpChD,EAAME,KAAOmb,GAER7Y,OAMRjF,EAAO6P,QAAQyR,gBAElBthB,EAAOyC,MAAM+Y,QAAQ1I,OAAS,CAC5B2J,MAAO,WAEL,GAAIzc,EAAOiK,SAAStG,KAAM,QACxB,OAAO,EAIT3D,EAAOyC,MAAM6K,IAAI3J,KAAM,kCAAkC,SAAUoE,GAEjE,IAAIrE,EAAOqE,EAAEpB,OACX4a,EAAOvhB,EAAOiK,SAASvG,EAAM,UAAY1D,EAAOiK,SAASvG,EAAM,UAAYA,EAAK6d,KAAO9hB,EACrF8hB,IAASvhB,EAAOyV,MAAM8L,EAAM,mBAC9BvhB,EAAOyC,MAAM6K,IAAIiU,EAAM,kBAAkB,SAAU9e,GACjDA,EAAM+e,gBAAiB,KAEzBxhB,EAAOyV,MAAM8L,EAAM,iBAAiB,QAM1CjD,aAAc,SAAU7b,GAElBA,EAAM+e,wBACD/e,EAAM+e,eACT7d,KAAKY,aAAe9B,EAAM2a,WAC5Bpd,EAAOyC,MAAMge,SAAS,SAAU9c,KAAKY,WAAY9B,GAAO,KAK9Doa,SAAU,WAER,GAAI7c,EAAOiK,SAAStG,KAAM,QACxB,OAAO,EAIT3D,EAAOyC,MAAMkG,OAAOhF,KAAM,eAM3B3D,EAAO6P,QAAQ4R,gBAElBzhB,EAAOyC,MAAM+Y,QAAQzI,OAAS,CAE5B0J,MAAO,WAEL,GAAI9B,GAAWzW,KAAKP,KAAKsG,UAkBvB,MAdkB,aAAdtG,KAAKhB,MAAqC,UAAdgB,KAAKhB,OACnC3C,EAAOyC,MAAM6K,IAAI3J,KAAM,0BAA0B,SAAUlB,GAChB,YAArCA,EAAMgc,cAAciD,eACtB/d,KAAKge,eAAgB,MAGzB3hB,EAAOyC,MAAM6K,IAAI3J,KAAM,iBAAiB,SAAUlB,GAC5CkB,KAAKge,gBAAkBlf,EAAM2a,YAC/BzZ,KAAKge,eAAgB,GAGvB3hB,EAAOyC,MAAMge,SAAS,SAAU9c,KAAMlB,GAAO,QAG1C,EAGTzC,EAAOyC,MAAM6K,IAAI3J,KAAM,0BAA0B,SAAUoE,GACzD,IAAIrE,EAAOqE,EAAEpB,OAETgU,GAAWzW,KAAKR,EAAKuG,YAAcjK,EAAOyV,MAAM/R,EAAM,mBACxD1D,EAAOyC,MAAM6K,IAAI5J,EAAM,kBAAkB,SAAUjB,IAC7CkB,KAAKY,YAAe9B,EAAMke,aAAgBle,EAAM2a,WAClDpd,EAAOyC,MAAMge,SAAS,SAAU9c,KAAKY,WAAY9B,GAAO,MAG5DzC,EAAOyV,MAAM/R,EAAM,iBAAiB,QAK1CqY,OAAQ,SAAUtZ,GAChB,IAAIiB,EAAOjB,EAAMkE,OAGjB,GAAIhD,OAASD,GAAQjB,EAAMke,aAAele,EAAM2a,WAA4B,UAAd1Z,EAAKf,MAAkC,aAAde,EAAKf,KAC1F,OAAOF,EAAMiZ,UAAUN,QAAQ5V,MAAM7B,KAAM8B,YAI/CoX,SAAU,WAGR,OAFA7c,EAAOyC,MAAMkG,OAAOhF,KAAM,aAElBgX,GAAWzW,KAAKP,KAAKsG,aAM9BjK,EAAO6P,QAAQ+R,gBAClB5hB,EAAOmF,KAAK,CAAEib,MAAO,UAAWE,KAAM,aAAc,SAAUa,EAAMrD,GAGlE,IAAI+D,EAAW,EACbzG,EAAU,SAAU3Y,GAClBzC,EAAOyC,MAAMge,SAAS3C,EAAKrb,EAAMkE,OAAQ3G,EAAOyC,MAAMqb,IAAIrb,IAAQ,IAGtEzC,EAAOyC,MAAM+Y,QAAQsC,GAAO,CAC1BrB,MAAO,WACc,IAAfoF,KACFhiB,EAAS6C,iBAAiBye,EAAM/F,GAAS,IAG7CyB,SAAU,WACW,MAAbgF,GACJhiB,EAASkD,oBAAoBoe,EAAM/F,GAAS,QAOtDpb,EAAOsB,GAAG8E,OAAO,CAEf0b,GAAI,SAAU3G,EAAO/Z,EAAUiH,EAAM/G,EAAiBuX,GACpD,IAAIlW,EAAMof,EAGV,GAAqB,kBAAV5G,EAAoB,CAO7B,IAAKxY,IALmB,kBAAbvB,IAETiH,EAAOA,GAAQjH,EACfA,EAAW3B,GAEA0b,EACXxX,KAAKme,GAAGnf,EAAMvB,EAAUiH,EAAM8S,EAAMxY,GAAOkW,GAE7C,OAAOlV,KAmBT,GAhBY,MAAR0E,GAAsB,MAAN/G,GAElBA,EAAKF,EACLiH,EAAOjH,EAAW3B,GACH,MAAN6B,IACe,kBAAbF,GAETE,EAAK+G,EACLA,EAAO5I,IAGP6B,EAAK+G,EACLA,EAAOjH,EACPA,EAAW3B,KAGJ,IAAP6B,EACFA,EAAK2Z,QACA,IAAK3Z,EACV,OAAOqC,KAaT,OAVY,IAARkV,IACFkJ,EAASzgB,EACTA,EAAK,SAAUmB,GAGb,OADAzC,IAASwH,IAAI/E,GACNsf,EAAOvc,MAAM7B,KAAM8B,YAG5BnE,EAAG2J,KAAO8W,EAAO9W,OAAS8W,EAAO9W,KAAOjL,EAAOiL,SAE1CtH,KAAKwB,MAAK,WACfnF,EAAOyC,MAAM6K,IAAI3J,KAAMwX,EAAO7Z,EAAI+G,EAAMjH,OAG5CyX,IAAK,SAAUsC,EAAO/Z,EAAUiH,EAAM/G,GACpC,OAAOqC,KAAKme,GAAG3G,EAAO/Z,EAAUiH,EAAM/G,EAAI,IAE5CkG,IAAK,SAAU2T,EAAO/Z,EAAUE,GAC9B,IAAIoa,EAAW/Y,EACf,GAAIwY,GAASA,EAAMwC,gBAAkBxC,EAAMO,UAQzC,OANAA,EAAYP,EAAMO,UAClB1b,EAAOmb,EAAM8C,gBAAgBzW,IAC3BkU,EAAUY,UAAYZ,EAAUG,SAAW,IAAMH,EAAUY,UAAYZ,EAAUG,SACjFH,EAAUta,SACVsa,EAAUN,SAELzX,KAET,GAAqB,kBAAVwX,EAAoB,CAE7B,IAAKxY,KAAQwY,EACXxX,KAAK6D,IAAI7E,EAAMvB,EAAU+Z,EAAMxY,IAEjC,OAAOgB,KAUT,OARiB,IAAbvC,GAA0C,oBAAbA,IAE/BE,EAAKF,EACLA,EAAW3B,IAEF,IAAP6B,IACFA,EAAK2Z,IAEAtX,KAAKwB,MAAK,WACfnF,EAAOyC,MAAMkG,OAAOhF,KAAMwX,EAAO7Z,EAAIF,OAIzC4gB,KAAM,SAAU7G,EAAO9S,EAAM/G,GAC3B,OAAOqC,KAAKme,GAAG3G,EAAO,KAAM9S,EAAM/G,IAEpC2gB,OAAQ,SAAU9G,EAAO7Z,GACvB,OAAOqC,KAAK6D,IAAI2T,EAAO,KAAM7Z,IAG/B4gB,SAAU,SAAU9gB,EAAU+Z,EAAO9S,EAAM/G,GACzC,OAAOqC,KAAKme,GAAG3G,EAAO/Z,EAAUiH,EAAM/G,IAExC6gB,WAAY,SAAU/gB,EAAU+Z,EAAO7Z,GAErC,OAA4B,IAArBmE,UAAUtC,OAAeQ,KAAK6D,IAAIpG,EAAU,MAAQuC,KAAK6D,IAAI2T,EAAO/Z,GAAY,KAAME,IAG/FiG,QAAS,SAAU5E,EAAM0F,GACvB,OAAO1E,KAAKwB,MAAK,WACfnF,EAAOyC,MAAM8E,QAAQ5E,EAAM0F,EAAM1E,UAGrCye,eAAgB,SAAUzf,EAAM0F,GAC9B,IAAI3E,EAAOC,KAAK,GAChB,GAAID,EACF,OAAO1D,EAAOyC,MAAM8E,QAAQ5E,EAAM0F,EAAM3E,GAAM;;;;;;;AAUpD,SAAWlE,EAAQC,GAEjB,IAAIoG,EACFwc,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAGAC,EACA/iB,EACAgjB,EACAC,EACAC,EACAC,EACAxE,EACA6C,EACA4B,EAGA/P,EAAU,UAAY,IAAKzH,KAC3ByX,EAAe1jB,EAAOK,SACtBgQ,EAAU,GACVsT,EAAU,EACV5d,EAAO,EACP6d,EAAaC,KACbC,EAAaD,KACbE,EAAgBF,KAGhBG,SAAsB/jB,EACtBgkB,EAAe,GAAK,GAGpBpZ,EAAM,GACN0K,EAAM1K,EAAI0K,IACVtU,EAAO4J,EAAI5J,KACXE,EAAQ0J,EAAI1J,MAEZE,EAAUwJ,EAAIxJ,SAAW,SAAU6C,GAGjC,IAFA,IAAImC,EAAI,EACNC,EAAMnC,KAAKR,OACN0C,EAAIC,EAAKD,IACd,GAAIlC,KAAKkC,KAAOnC,EACd,OAAOmC,EAGX,OAAQ,GAOV6d,EAAa,sBAEbC,EAAoB,mCAKpBC,EAAaD,EAAkB3a,QAAQ,IAAK,MAG5C6a,EAAY,eACZ5Q,EAAa,MAAQyQ,EAAa,KAAOC,EAAoB,IAAMD,EACjE,OAASG,EAAYH,EAAa,wCAA0CE,EAAa,QAAUF,EAAa,OAQlHI,EAAU,KAAOH,EAAoB,mEAAqE1Q,EAAWjK,QAAQ,EAAG,GAAK,eAGrIrH,EAAQ,IAAIib,OAAO,IAAM8G,EAAa,8BAAgCA,EAAa,KAAM,KAEzFK,EAAS,IAAInH,OAAO,IAAM8G,EAAa,KAAOA,EAAa,KAC3DM,EAAe,IAAIpH,OAAO,IAAM8G,EAAa,4BAA8BA,EAAa,KACxFO,EAAU,IAAIrH,OAAOkH,GACrBI,EAAc,IAAItH,OAAO,IAAMgH,EAAa,KAE5CO,EAAY,CACV,GAAM,IAAIvH,OAAO,MAAQ+G,EAAoB,KAC7C,MAAS,IAAI/G,OAAO,QAAU+G,EAAoB,KAClD,KAAQ,IAAI/G,OAAO,mBAAqB+G,EAAoB,cAC5D,IAAO,IAAI/G,OAAO,KAAO+G,EAAkB3a,QAAQ,IAAK,MAAQ,KAChE,KAAQ,IAAI4T,OAAO,IAAM3J,GACzB,OAAU,IAAI2J,OAAO,IAAMkH,GAC3B,MAAS,IAAIlH,OAAO,yDAA2D8G,EAC7E,+BAAiCA,EAAa,cAAgBA,EAC9D,aAAeA,EAAa,SAAU,KAGxC,aAAgB,IAAI9G,OAAO,IAAM8G,EAAa,mDAC5CA,EAAa,mBAAqBA,EAAa,mBAAoB,MAGvEU,EAAW,sBAEXC,EAAU,2BAGVziB,EAAa,mCAEb0iB,EAAU,sCACVC,EAAU,SAEVC,EAAU,QACVC,EAAmB,gDAGnBC,GAAY,wCACZC,GAAY,SAAUtY,EAAGuY,GACvB,IAAIC,EAAO,KAAOD,EAAU,MAE5B,OAAOC,IAASA,EACdD,EAEAC,EAAO,EACL/c,OAAOgd,aAAaD,EAAO,OAE3B/c,OAAOgd,aAAaD,GAAQ,GAAK,MAAe,KAAPA,EAAe,QAIhE,IACElkB,EAAMiE,KAAKse,EAAaxZ,gBAAgBd,WAAY,GAAG,GAAGvF,SAC1D,MAAO0E,IACPpH,EAAQ,SAAUkF,GAChB,IAAInC,EACF4G,EAAU,GACZ,MAAQ5G,EAAOC,KAAKkC,KAClByE,EAAQ7J,KAAKiD,GAEf,OAAO4G,GAQX,SAASya,GAASzjB,GAChB,OAAO+iB,EAAQngB,KAAK5C,EAAK,IAS3B,SAAS+hB,KACP,IAAIvO,EACFkQ,EAAO,GAET,OAAQlQ,EAAQ,SAAU9M,EAAKmC,GAM7B,OAJI6a,EAAKvkB,KAAKuH,GAAO,KAAOsa,EAAK2C,oBAExBnQ,EAAMkQ,EAAK7X,SAEZ2H,EAAM9M,GAAOmC,GAQzB,SAAS+a,GAAa5jB,GAEpB,OADAA,EAAG4R,IAAW,EACP5R,EAOT,SAAS6jB,GAAO7jB,GACd,IAAI+O,EAAMxQ,EAAS4I,cAAc,OAEjC,IACE,OAAOnH,EAAG+O,GACV,MAAOtI,IACP,OAAO,EACP,QAEAsI,EAAM,MAIV,SAAS+U,GAAOhkB,EAAUC,EAASiJ,EAAS+a,GAC1C,IAAI5hB,EAAOC,EAAM4hB,EAAGjiB,EAElBwC,EAAG0f,EAAQC,EAAKC,EAAKC,EAAYC,EASnC,IAPKtkB,EAAUA,EAAQ4C,eAAiB5C,EAAU6hB,KAAkBrjB,GAClE+iB,EAAYvhB,GAGdA,EAAUA,GAAWxB,EACrByK,EAAUA,GAAW,IAEhBlJ,GAAgC,kBAAbA,EACtB,OAAOkJ,EAGT,GAAsC,KAAjCjH,EAAWhC,EAAQgC,WAAgC,IAAbA,EACzC,MAAO,GAGT,IAAKyf,IAAkBuC,EAAM,CAG3B,GAAK5hB,EAAQ7B,EAAWiC,KAAKzC,GAE3B,GAAKkkB,EAAI7hB,EAAM,IACb,GAAiB,IAAbJ,EAAgB,CAIlB,GAHAK,EAAOrC,EAAQiD,eAAeghB,IAG1B5hB,IAAQA,EAAKa,WAQf,OAAO+F,EALP,GAAI5G,EAAKc,KAAO8gB,EAEd,OADAhb,EAAQ7J,KAAKiD,GACN4G,OAOX,GAAIjJ,EAAQ4C,gBAAkBP,EAAOrC,EAAQ4C,cAAcK,eAAeghB,KACxEjE,EAAShgB,EAASqC,IAASA,EAAKc,KAAO8gB,EAEvC,OADAhb,EAAQ7J,KAAKiD,GACN4G,MAKN,IAAI7G,EAAM,GAEf,OADAhD,EAAK+E,MAAM8E,EAAS3J,EAAMiE,KAAKvD,EAAQsI,qBAAqBvI,GAAW,IAChEkJ,EAGF,IAAKgb,EAAI7hB,EAAM,KAAOoM,EAAQ+V,gBAAkBvkB,EAAQwkB,uBAE7D,OADAplB,EAAK+E,MAAM8E,EAAS3J,EAAMiE,KAAKvD,EAAQwkB,uBAAuBP,GAAI,IAC3Dhb,EAKX,GAAIuF,EAAQiW,MAAQ/C,EAAU7e,KAAK9C,GAAW,CAU5C,GATAokB,GAAM,EACNC,EAAMvS,EACNwS,EAAarkB,EACbskB,EAA2B,IAAbtiB,GAAkBjC,EAMf,IAAbiC,GAAqD,WAAnChC,EAAQ4I,SAASC,cAA4B,CACjEqb,EAASQ,GAAS3kB,IAEbokB,EAAMnkB,EAAQ4P,aAAa,OAC9BwU,EAAMD,EAAIxc,QAAQwb,EAAS,QAE3BnjB,EAAQiP,aAAa,KAAMmV,GAE7BA,EAAM,QAAUA,EAAM,MAEtB5f,EAAI0f,EAAOpiB,OACX,MAAO0C,IACL0f,EAAO1f,GAAK4f,EAAMO,GAAWT,EAAO1f,IAEtC6f,EAAatB,EAASlgB,KAAK9C,IAAaC,EAAQkD,YAAclD,EAC9DskB,EAAcJ,EAAOhJ,KAAK,KAG5B,GAAIoJ,EACF,IAIE,OAHAllB,EAAK+E,MAAM8E,EAAS3J,EAAMiE,KAAK8gB,EAAWO,iBACxCN,GACC,IACIrb,EACP,MAAO4b,IACP,QACKV,GACHnkB,EAAQ+X,gBAAgB,QAQlC,OAAOpJ,GAAO5O,EAAS4H,QAAQrH,EAAO,MAAON,EAASiJ,EAAS+a,GAmcjE,SAASc,GAAarW,EAAGsW,GACvB,IAAIlQ,EAAMkQ,GAAKtW,EACbuW,EAAOnQ,KAASkQ,EAAEE,aAAe7C,KAAkB3T,EAAEwW,aAAe7C,GAGtE,GAAI4C,EACF,OAAOA,EAIT,GAAInQ,EACF,MAAQA,EAAMA,EAAIqQ,YAChB,GAAIrQ,IAAQkQ,EACV,OAAQ,EAKd,OAAOtW,EAAI,GAAK,EAIlB,SAAS0W,GAAkB7jB,GACzB,OAAO,SAAUe,GACf,IAAI8C,EAAO9C,EAAKuG,SAASC,cACzB,MAAgB,UAAT1D,GAAoB9C,EAAKf,OAASA,GAK7C,SAAS8jB,GAAmB9jB,GAC1B,OAAO,SAAUe,GACf,IAAI8C,EAAO9C,EAAKuG,SAASC,cACzB,OAAiB,UAAT1D,GAA6B,WAATA,IAAsB9C,EAAKf,OAASA,GAKpE,SAAS+jB,GAAuBplB,GAC9B,OAAO4jB,IAAa,SAAUyB,GAE5B,OADAA,GAAYA,EACLzB,IAAa,SAAUG,EAAM7G,GAClC,IAAIzY,EACF6gB,EAAetlB,EAAG,GAAI+jB,EAAKliB,OAAQwjB,GACnC9gB,EAAI+gB,EAAazjB,OAGnB,MAAO0C,IACDwf,EAAMtf,EAAI6gB,EAAa/gB,MACzBwf,EAAKtf,KAAOyY,EAAQzY,GAAKsf,EAAKtf,WA6fxC,IAAKF,KA1+BL2c,EAAQ4C,GAAO5C,MAAQ,SAAU9e,GAG/B,IAAIgG,EAAkBhG,IAASA,EAAKO,eAAiBP,GAAMgG,gBAC3D,QAAOA,GAA+C,SAA7BA,EAAgBO,UAQ3C2Y,EAAcwC,GAAOxC,YAAc,SAAUiE,GAC3C,IAAItH,EAAMsH,EAAOA,EAAK5iB,eAAiB4iB,EAAO3D,EAG9C,OAAI3D,IAAQ1f,GAA6B,IAAjB0f,EAAIlc,UAAmBkc,EAAI7V,iBAKnD7J,EAAW0f,EACXsD,EAAUtD,EAAI7V,gBAGdoZ,EAAgBN,EAAMjD,GAGtB1P,EAAQiX,kBAAoB3B,IAAO,SAAU9U,GAE3C,OADAA,EAAIG,YAAY+O,EAAIwH,cAAc,MAC1B1W,EAAI1G,qBAAqB,KAAKxG,UAIxC0M,EAAQoD,WAAakS,IAAO,SAAU9U,GACpCA,EAAIE,UAAY,oBAChB,IAAI5N,SAAc0N,EAAIuC,UAAU3B,aAAa,YAE7C,MAAgB,YAATtO,GAA+B,WAATA,KAI/BkN,EAAQ+V,eAAiBT,IAAO,SAAU9U,GAGxC,OADAA,EAAIE,UAAY,4DACXF,EAAIwV,yBAA2BxV,EAAIwV,uBAAuB,KAAK1iB,UAKpEkN,EAAIuC,UAAUhC,UAAY,IACwB,IAA3CP,EAAIwV,uBAAuB,KAAK1iB,WAKzC0M,EAAQ+E,UAAYuQ,IAAO,SAAU9U,GAEnCA,EAAI7L,GAAK0O,EAAU,EACnB7C,EAAIE,UAAY,YAAc2C,EAAU,oBAAsBA,EAAU,WACxE2P,EAAQmE,aAAa3W,EAAKwS,EAAQ/R,YAGlC,IAAImW,EAAO1H,EAAI2H,mBAEb3H,EAAI2H,kBAAkBhU,GAAS/P,SAAW,EAE1Coc,EAAI2H,kBAAkBhU,EAAU,GAAG/P,OAMrC,OALA0M,EAAQsX,cAAgB5H,EAAIjb,eAAe4O,GAG3C2P,EAAQzO,YAAY/D,GAEb4W,KAIT3E,EAAK8E,WAAajC,IAAO,SAAU9U,GAEjC,OADAA,EAAIE,UAAY,mBACTF,EAAIS,mBAAqBT,EAAIS,WAAWG,eAAiBuS,GACtB,MAAxCnT,EAAIS,WAAWG,aAAa,WAE9B,GACA,CACE,KAAQ,SAAUvN,GAChB,OAAOA,EAAKuN,aAAa,OAAQ,IAEnC,KAAQ,SAAUvN,GAChB,OAAOA,EAAKuN,aAAa,UAK3BpB,EAAQsX,cACV7E,EAAKxe,KAAK,MAAQ,SAAUU,EAAInD,GAC9B,UAAWA,EAAQiD,iBAAmBkf,IAAiBV,EAAe,CACpE,IAAIwC,EAAIjkB,EAAQiD,eAAeE,GAG/B,OAAO8gB,GAAKA,EAAE/gB,WAAa,CAAC+gB,GAAK,KAGrChD,EAAKrD,OAAO,MAAQ,SAAUza,GAC5B,IAAI6iB,EAAS7iB,EAAGwE,QAAQ0b,GAAWC,IACnC,OAAO,SAAUjhB,GACf,OAAOA,EAAKuN,aAAa,QAAUoW,MAIvC/E,EAAKxe,KAAK,MAAQ,SAAUU,EAAInD,GAC9B,UAAWA,EAAQiD,iBAAmBkf,IAAiBV,EAAe,CACpE,IAAIwC,EAAIjkB,EAAQiD,eAAeE,GAE/B,OAAO8gB,EACLA,EAAE9gB,KAAOA,UAAa8gB,EAAEpL,mBAAqBsJ,GAAgB8B,EAAEpL,iBAAiB,MAAM/P,QAAU3F,EAC9F,CAAC8gB,GACD7lB,EACF,KAGN6iB,EAAKrD,OAAO,MAAQ,SAAUza,GAC5B,IAAI6iB,EAAS7iB,EAAGwE,QAAQ0b,GAAWC,IACnC,OAAO,SAAUjhB,GACf,IAAImjB,SAAcnjB,EAAKwW,mBAAqBsJ,GAAgB9f,EAAKwW,iBAAiB,MAClF,OAAO2M,GAAQA,EAAK1c,QAAUkd,KAMpC/E,EAAKxe,KAAK,OAAS+L,EAAQiX,kBACzB,SAAUQ,EAAKjmB,GACb,UAAWA,EAAQsI,uBAAyB6Z,EAC1C,OAAOniB,EAAQsI,qBAAqB2d,IAGxC,SAAUA,EAAKjmB,GACb,IAAIqC,EACF0F,EAAM,GACNvD,EAAI,EACJyE,EAAUjJ,EAAQsI,qBAAqB2d,GAGzC,GAAY,MAARA,EAAa,CACf,MAAQ5jB,EAAO4G,EAAQzE,KACC,IAAlBnC,EAAKL,UACP+F,EAAI3I,KAAKiD,GAIb,OAAO0F,EAET,OAAOkB,GAIXgY,EAAKxe,KAAK,QAAU+L,EAAQ+E,WAAa,SAAU0S,EAAKjmB,GACtD,UAAWA,EAAQ6lB,oBAAsB1D,EACvC,OAAOniB,EAAQ6lB,kBAAkB1gB,OAKrC8b,EAAKxe,KAAK,SAAW+L,EAAQ+V,gBAAkB,SAAUhV,EAAWvP,GAClE,UAAWA,EAAQwkB,yBAA2BrC,IAAiBV,EAC7D,OAAOzhB,EAAQwkB,uBAAuBjV,IAO1CoS,EAAgB,GAKhBD,EAAY,CAAC,WAERlT,EAAQiW,IAAMf,GAASxF,EAAI0G,qBAG9Bd,IAAO,SAAU9U,GAMfA,EAAIE,UAAY,iDAGXF,EAAI4V,iBAAiB,cAAc9iB,QACtC4f,EAAUtiB,KAAK,MAAQijB,EAAa,gEAMjCrT,EAAI4V,iBAAiB,YAAY9iB,QACpC4f,EAAUtiB,KAAK,eAInB0kB,IAAO,SAAU9U,GAIfA,EAAIE,UAAY,8BACZF,EAAI4V,iBAAiB,WAAW9iB,QAClC4f,EAAUtiB,KAAK,SAAWijB,EAAa,gBAKpCrT,EAAI4V,iBAAiB,YAAY9iB,QACpC4f,EAAUtiB,KAAK,WAAY,aAI7B4P,EAAI4V,iBAAiB,QACrBlD,EAAUtiB,KAAK,aAIdoP,EAAQ0X,gBAAkBxC,GAAUvG,EAAUqE,EAAQ0E,iBACzD1E,EAAQ2E,oBACR3E,EAAQ4E,uBACR5E,EAAQ6E,kBACR7E,EAAQ8E,qBAERxC,IAAO,SAAU9U,GAGfR,EAAQ+X,kBAAoBpJ,EAAQ5Z,KAAKyL,EAAK,OAI9CmO,EAAQ5Z,KAAKyL,EAAK,aAClB2S,EAAcviB,KAAK,KAAMqjB,MAI7Bf,EAAY,IAAInG,OAAOmG,EAAUxG,KAAK,MACtCyG,EAAgB,IAAIpG,OAAOoG,EAAczG,KAAK,MAK9C8E,EAAW0D,GAASlC,EAAQxB,WAAawB,EAAQgF,wBAC/C,SAAU/X,EAAGsW,GACX,IAAI0B,EAAuB,IAAfhY,EAAEzM,SAAiByM,EAAEpG,gBAAkBoG,EACjDiY,EAAM3B,GAAKA,EAAE7hB,WACf,OAAOuL,IAAMiY,MAAUA,GAAwB,IAAjBA,EAAI1kB,YAChCykB,EAAMzG,SACJyG,EAAMzG,SAAS0G,GACfjY,EAAE+X,yBAA4D,GAAjC/X,EAAE+X,wBAAwBE,MAG7D,SAAUjY,EAAGsW,GACX,GAAIA,EACF,MAAQA,EAAIA,EAAE7hB,WACZ,GAAI6hB,IAAMtW,EACR,OAAO,EAIb,OAAO,GAIXmT,EAAYJ,EAAQgF,wBAClB,SAAU/X,EAAGsW,GACX,IAAI4B,EAEJ,OAAIlY,IAAMsW,GACR1D,GAAe,EACR,IAGJsF,EAAU5B,EAAEyB,yBAA2B/X,EAAE+X,yBAA2B/X,EAAE+X,wBAAwBzB,IACnF,EAAV4B,GAAelY,EAAEvL,YAAwC,KAA1BuL,EAAEvL,WAAWlB,SAC1CyM,IAAMyP,GAAO8B,EAAS6B,EAAcpT,IAC9B,EAENsW,IAAM7G,GAAO8B,EAAS6B,EAAckD,GAC/B,EAEF,EAEQ,EAAV4B,GAAe,EAAI,EAGrBlY,EAAE+X,yBAA2B,EAAI,GAE1C,SAAU/X,EAAGsW,GACX,IAAIlQ,EACFrQ,EAAI,EACJoiB,EAAMnY,EAAEvL,WACRwjB,EAAM3B,EAAE7hB,WACR2jB,EAAK,CAACpY,GACNqY,EAAK,CAAC/B,GAGR,GAAItW,IAAMsW,EAER,OADA1D,GAAe,EACR,EAGF,IAAKuF,IAAQF,EAClB,OAAOjY,IAAMyP,GAAO,EAClB6G,IAAM7G,EAAM,EACV0I,GAAO,EACLF,EAAM,EACJ,EAGH,GAAIE,IAAQF,EACjB,OAAO5B,GAAarW,EAAGsW,GAIzBlQ,EAAMpG,EACN,MAAQoG,EAAMA,EAAI3R,WAChB2jB,EAAG/R,QAAQD,GAEbA,EAAMkQ,EACN,MAAQlQ,EAAMA,EAAI3R,WAChB4jB,EAAGhS,QAAQD,GAIb,MAAOgS,EAAGriB,KAAOsiB,EAAGtiB,GAClBA,IAGF,OAAOA,EAELsgB,GAAa+B,EAAGriB,GAAIsiB,EAAGtiB,IAGvBqiB,EAAGriB,KAAOqd,GAAgB,EACxBiF,EAAGtiB,KAAOqd,EAAe,EACvB,GAKVR,GAAe,EACf,CAAC,EAAG,GAAGxc,KAAK+c,GACZpT,EAAQuY,iBAAmB1F,EAEpB7iB,GA9UEA,GAiVXulB,GAAO5G,QAAU,SAAUnC,EAAMtF,GAC/B,OAAOqO,GAAO/I,EAAM,KAAM,KAAMtF,IAGlCqO,GAAOmC,gBAAkB,SAAU7jB,EAAM2Y,GAUvC,IARK3Y,EAAKO,eAAiBP,KAAU7D,GACnC+iB,EAAYlf,GAId2Y,EAAOA,EAAKrT,QAAQyb,EAAkB,UAGlC5U,EAAQ0X,kBAAoBzE,KAAmBE,IAAkBA,EAAc9e,KAAKmY,MAAW0G,EAAU7e,KAAKmY,GAChH,IACE,IAAIpX,EAAMuZ,EAAQ5Z,KAAKlB,EAAM2Y,GAG7B,GAAIpX,GAAO4K,EAAQ+X,mBAGjBlkB,EAAK7D,UAAuC,KAA3B6D,EAAK7D,SAASwD,SAC/B,OAAO4B,EAET,MAAO8C,KAGX,OAAOqd,GAAO/I,EAAMxc,EAAU,KAAM,CAAC6D,IAAOP,OAAS,GAGvDiiB,GAAO/D,SAAW,SAAUhgB,EAASqC,GAKnC,OAHKrC,EAAQ4C,eAAiB5C,KAAaxB,GACzC+iB,EAAYvhB,GAEPggB,EAAShgB,EAASqC,IAG3B0hB,GAAO/gB,KAAO,SAAUX,EAAM8C,GAC5B,IAAI+R,EAUJ,OAPK7U,EAAKO,eAAiBP,KAAU7D,GACnC+iB,EAAYlf,GAGTof,IACHtc,EAAOA,EAAK0D,gBAETqO,EAAM+J,EAAK8E,WAAW5gB,IAClB+R,EAAI7U,GAETof,GAAiBjT,EAAQoD,WACpBvP,EAAKuN,aAAazK,KAElB+R,EAAM7U,EAAKwW,iBAAiB1T,KAAU9C,EAAKuN,aAAazK,MAAyB,IAAf9C,EAAK8C,GAC9EA,EACA+R,GAAOA,EAAII,UAAYJ,EAAIpO,MAAQ,MAGvCib,GAAOld,MAAQ,SAAUC,GACvB,MAAM,IAAIC,MAAM,0CAA4CD,IAI9Did,GAAOiD,WAAa,SAAU/d,GAC5B,IAAI5G,EACF4kB,EAAa,GACbziB,EAAI,EACJE,EAAI,EAMN,GAHA2c,GAAgB7S,EAAQuY,iBACxB9d,EAAQpE,KAAK+c,GAETP,EAAc,CAChB,KAAQhf,EAAO4G,EAAQzE,GAAKA,IACtBnC,IAAS4G,EAAQzE,EAAI,KACvBE,EAAIuiB,EAAW7nB,KAAKoF,IAGxB,MAAOE,IACLuE,EAAQnE,OAAOmiB,EAAWviB,GAAI,GAIlC,OAAOuE,GA+DTiY,EAAU6C,GAAO7C,QAAU,SAAU7e,GACnC,IAAImjB,EACF5hB,EAAM,GACNY,EAAI,EACJxC,EAAWK,EAAKL,SAElB,GAAKA,GAME,GAAiB,IAAbA,GAA+B,IAAbA,GAA+B,KAAbA,EAAiB,CAG9D,GAAgC,kBAArBK,EAAK6kB,YACd,OAAO7kB,EAAK6kB,YAGZ,IAAK7kB,EAAOA,EAAKoN,WAAYpN,EAAMA,EAAOA,EAAK6iB,YAC7CthB,GAAOsd,EAAQ7e,QAGd,GAAiB,IAAbL,GAA+B,IAAbA,EAC3B,OAAOK,EAAK8kB,eAhBZ,KAAQ3B,EAAOnjB,EAAKmC,GAAKA,IAEvBZ,GAAOsd,EAAQsE,GAkBnB,OAAO5hB,GAGTqd,EAAO8C,GAAOqD,UAAY,CAGxBxD,YAAa,GAEbyD,aAAcxD,GAEdzhB,MAAO0gB,EAEPrgB,KAAM,GAEN6kB,SAAU,CACR,IAAK,CAAEC,IAAK,aAAcljB,OAAO,GACjC,IAAK,CAAEkjB,IAAK,cACZ,IAAK,CAAEA,IAAK,kBAAmBljB,OAAO,GACtC,IAAK,CAAEkjB,IAAK,oBAGdC,UAAW,CACT,KAAQ,SAAUplB,GAUhB,OATAA,EAAM,GAAKA,EAAM,GAAGuF,QAAQ0b,GAAWC,IAGvClhB,EAAM,IAAMA,EAAM,IAAMA,EAAM,IAAM,IAAIuF,QAAQ0b,GAAWC,IAE1C,OAAblhB,EAAM,KACRA,EAAM,GAAK,IAAMA,EAAM,GAAK,KAGvBA,EAAM9C,MAAM,EAAG,IAGxB,MAAS,SAAU8C,GA6BjB,OAlBAA,EAAM,GAAKA,EAAM,GAAGyG,cAES,QAAzBzG,EAAM,GAAG9C,MAAM,EAAG,IAEf8C,EAAM,IACT2hB,GAAOld,MAAMzE,EAAM,IAKrBA,EAAM,KAAOA,EAAM,GAAKA,EAAM,IAAMA,EAAM,IAAM,GAAK,GAAkB,SAAbA,EAAM,IAA8B,QAAbA,EAAM,KACvFA,EAAM,KAAQA,EAAM,GAAKA,EAAM,IAAoB,QAAbA,EAAM,KAGnCA,EAAM,IACf2hB,GAAOld,MAAMzE,EAAM,IAGdA,GAGT,OAAU,SAAUA,GAClB,IAAIqlB,EACFC,GAAYtlB,EAAM,IAAMA,EAAM,GAEhC,OAAI0gB,EAAU,SAASjgB,KAAKT,EAAM,IACzB,MAILA,EAAM,GACRA,EAAM,GAAKA,EAAM,GAGRslB,GAAY9E,EAAQ/f,KAAK6kB,KAEjCD,EAAS/C,GAASgD,GAAU,MAE5BD,EAASC,EAASloB,QAAQ,IAAKkoB,EAAS5lB,OAAS2lB,GAAUC,EAAS5lB,UAGrEM,EAAM,GAAKA,EAAM,GAAG9C,MAAM,EAAGmoB,GAC7BrlB,EAAM,GAAKslB,EAASpoB,MAAM,EAAGmoB,IAIxBrlB,EAAM9C,MAAM,EAAG,MAI1Bse,OAAQ,CAEN,IAAO,SAAUhV,GACf,MAAiB,MAAbA,EACK,WAAc,OAAO,IAG9BA,EAAWA,EAASjB,QAAQ0b,GAAWC,IAAWza,cAC3C,SAAUxG,GACf,OAAOA,EAAKuG,UAAYvG,EAAKuG,SAASC,gBAAkBD,KAI5D,MAAS,SAAU2G,GACjB,IAAIoY,EAAU5F,EAAWxS,EAAY,KAErC,OAAOoY,IACJA,EAAU,IAAIpM,OAAO,MAAQ8G,EAAa,IAAM9S,EAAY,IAAM8S,EAAa,SAChFN,EAAWxS,GAAW,SAAUlN,GAC9B,OAAOslB,EAAQ9kB,KAAKR,EAAKkN,kBAAqBlN,EAAKuN,eAAiBuS,GAAgB9f,EAAKuN,aAAa,UAAa,QAIzH,KAAQ,SAAUzK,EAAMyiB,EAAUC,GAChC,OAAO,SAAUxlB,GACf,IAAI4Z,EAAS8H,GAAO/gB,KAAKX,EAAM8C,GAE/B,OAAc,MAAV8W,EACkB,OAAb2L,GAEJA,IAIL3L,GAAU,GAEU,MAAb2L,EAAmB3L,IAAW4L,EACtB,OAAbD,EAAoB3L,IAAW4L,EAChB,OAAbD,EAAoBC,GAAmC,IAA1B5L,EAAOzc,QAAQqoB,GAC7B,OAAbD,EAAoBC,GAAS5L,EAAOzc,QAAQqoB,IAAU,EACvC,OAAbD,EAAoBC,GAAS5L,EAAO3c,OAAOuoB,EAAM/lB,UAAY+lB,EAC9C,OAAbD,GAAqB,IAAM3L,EAAS,KAAKzc,QAAQqoB,IAAU,EAC5C,OAAbD,IAAoB3L,IAAW4L,GAAS5L,EAAO3c,MAAM,EAAGuoB,EAAM/lB,OAAS,KAAO+lB,EAAQ,QAKtG,MAAS,SAAUvmB,EAAMwmB,EAAMxC,EAAUjhB,EAAOE,GAC9C,IAAIwjB,EAA8B,QAArBzmB,EAAKhC,MAAM,EAAG,GACzB0oB,EAA6B,SAAnB1mB,EAAKhC,OAAO,GACtB2oB,EAAkB,YAATH,EAEX,OAAiB,IAAVzjB,GAAwB,IAATE,EAGpB,SAAUlC,GACR,QAASA,EAAKa,YAGhB,SAAUb,EAAMrC,EAAS8H,GACvB,IAAI2L,EAAOyU,EAAY1C,EAAMR,EAAMmD,EAAWjc,EAC5Cqb,EAAMQ,IAAWC,EAAU,cAAgB,kBAC3C3O,EAAShX,EAAKa,WACdiC,EAAO8iB,GAAU5lB,EAAKuG,SAASC,cAC/Buf,GAAYtgB,IAAQmgB,EAEtB,GAAI5O,EAAQ,CAGV,GAAI0O,EAAQ,CACV,MAAOR,EAAK,CACV/B,EAAOnjB,EACP,MAAQmjB,EAAOA,EAAK+B,GAClB,GAAIU,EAASzC,EAAK5c,SAASC,gBAAkB1D,EAAyB,IAAlBqgB,EAAKxjB,SACvD,OAAO,EAIXkK,EAAQqb,EAAe,SAATjmB,IAAoB4K,GAAS,cAE7C,OAAO,EAMT,GAHAA,EAAQ,CAAC8b,EAAU3O,EAAO5J,WAAa4J,EAAO9H,WAG1CyW,GAAWI,EAAU,CAEvBF,EAAa7O,EAAOxH,KAAawH,EAAOxH,GAAW,IACnD4B,EAAQyU,EAAW5mB,IAAS,GAC5B6mB,EAAY1U,EAAM,KAAOqO,GAAWrO,EAAM,GAC1CuR,EAAOvR,EAAM,KAAOqO,GAAWrO,EAAM,GACrC+R,EAAO2C,GAAa9O,EAAO9R,WAAW4gB,GAEtC,MAAQ3C,IAAS2C,GAAa3C,GAAQA,EAAK+B,KAGxCvC,EAAOmD,EAAY,IAAMjc,EAAMwH,MAGhC,GAAsB,IAAlB8R,EAAKxjB,YAAoBgjB,GAAQQ,IAASnjB,EAAM,CAClD6lB,EAAW5mB,GAAQ,CAACwgB,EAASqG,EAAWnD,GACxC,YAKC,GAAIoD,IAAa3U,GAASpR,EAAKwP,KAAaxP,EAAKwP,GAAW,KAAKvQ,KAAUmS,EAAM,KAAOqO,EAC7FkD,EAAOvR,EAAM,QAKb,MAAQ+R,IAAS2C,GAAa3C,GAAQA,EAAK+B,KACxCvC,EAAOmD,EAAY,IAAMjc,EAAMwH,MAEhC,IAAKuU,EAASzC,EAAK5c,SAASC,gBAAkB1D,EAAyB,IAAlBqgB,EAAKxjB,aAAqBgjB,IAEzEoD,KACD5C,EAAK3T,KAAa2T,EAAK3T,GAAW,KAAKvQ,GAAQ,CAACwgB,EAASkD,IAGxDQ,IAASnjB,GACX,MAQR,OADA2iB,GAAQzgB,EACDygB,IAAS3gB,GAAU2gB,EAAO3gB,IAAU,GAAK2gB,EAAO3gB,GAAS,KAKxE,OAAU,SAAUgkB,EAAQ/C,GAK1B,IAAIthB,EACF/D,EAAKghB,EAAKwB,QAAQ4F,IAAWpH,EAAKqH,WAAWD,EAAOxf,gBAClDkb,GAAOld,MAAM,uBAAyBwhB,GAK1C,OAAIpoB,EAAG4R,GACE5R,EAAGqlB,GAIRrlB,EAAG6B,OAAS,GACdkC,EAAO,CAACqkB,EAAQA,EAAQ,GAAI/C,GACrBrE,EAAKqH,WAAW1oB,eAAeyoB,EAAOxf,eAC3Cgb,IAAa,SAAUG,EAAM7G,GAC3B,IAAIoL,EACF7L,EAAUzc,EAAG+jB,EAAMsB,GACnB9gB,EAAIkY,EAAQ5a,OACd,MAAO0C,IACL+jB,EAAM/oB,EAAQ+D,KAAKygB,EAAMtH,EAAQlY,IACjCwf,EAAKuE,KAASpL,EAAQoL,GAAO7L,EAAQlY,OAGzC,SAAUnC,GACR,OAAOpC,EAAGoC,EAAM,EAAG2B,KAIlB/D,IAIXwiB,QAAS,CAEP,IAAOoB,IAAa,SAAU9jB,GAI5B,IAAI2O,EAAQ,GACVzF,EAAU,GACVuf,EAAUpH,EAAQrhB,EAAS4H,QAAQrH,EAAO,OAE5C,OAAOkoB,EAAQ3W,GACbgS,IAAa,SAAUG,EAAM7G,EAASnd,EAAS8H,GAC7C,IAAIzF,EACFomB,EAAYD,EAAQxE,EAAM,KAAMlc,EAAK,IACrCtD,EAAIwf,EAAKliB,OAGX,MAAO0C,KACAnC,EAAOomB,EAAUjkB,MACpBwf,EAAKxf,KAAO2Y,EAAQ3Y,GAAKnC,OAI/B,SAAUA,EAAMrC,EAAS8H,GAGvB,OAFA4G,EAAM,GAAKrM,EACXmmB,EAAQ9Z,EAAO,KAAM5G,EAAKmB,IAClBA,EAAQyK,UAItB,IAAOmQ,IAAa,SAAU9jB,GAC5B,OAAO,SAAUsC,GACf,OAAO0hB,GAAOhkB,EAAUsC,GAAMP,OAAS,MAI3C,SAAY+hB,IAAa,SAAU9a,GACjC,OAAO,SAAU1G,GACf,OAAQA,EAAK6kB,aAAe7kB,EAAKqmB,WAAaxH,EAAQ7e,IAAO7C,QAAQuJ,IAAS,MAWlF,KAAQ8a,IAAa,SAAU8E,GAM7B,OAJK9F,EAAYhgB,KAAK8lB,GAAQ,KAC5B5E,GAAOld,MAAM,qBAAuB8hB,GAEtCA,EAAOA,EAAKhhB,QAAQ0b,GAAWC,IAAWza,cACnC,SAAUxG,GACf,IAAIumB,EACJ,GACE,GAAKA,EAAWnH,EACdpf,EAAKuN,aAAa,aAAevN,EAAKuN,aAAa,QACnDvN,EAAKsmB,KAGL,OADAC,EAAWA,EAAS/f,cACb+f,IAAaD,GAAyC,IAAjCC,EAASppB,QAAQmpB,EAAO,YAE9CtmB,EAAOA,EAAKa,aAAiC,IAAlBb,EAAKL,UAC1C,OAAO,MAKX,OAAU,SAAUK,GAClB,IAAIwmB,EAAO1qB,EAAOM,UAAYN,EAAOM,SAASoqB,KAC9C,OAAOA,GAAQA,EAAKvpB,MAAM,KAAO+C,EAAKc,IAGxC,KAAQ,SAAUd,GAChB,OAAOA,IAASmf,GAGlB,MAAS,SAAUnf,GACjB,OAAOA,IAAS7D,EAASwgB,iBAAmBxgB,EAASsqB,UAAYtqB,EAASsqB,gBAAkBzmB,EAAKf,MAAQe,EAAK0W,OAAS1W,EAAKsW,WAI9H,QAAW,SAAUtW,GACnB,OAAyB,IAAlBA,EAAKkK,UAGd,SAAY,SAAUlK,GACpB,OAAyB,IAAlBA,EAAKkK,UAGd,QAAW,SAAUlK,GAGnB,IAAIuG,EAAWvG,EAAKuG,SAASC,cAC7B,MAAqB,UAAbD,KAA0BvG,EAAK2O,SAA0B,WAAbpI,KAA2BvG,EAAK6N,UAGtF,SAAY,SAAU7N,GAOpB,OAJIA,EAAKa,YACPb,EAAKa,WAAWqU,eAGO,IAAlBlV,EAAK6N,UAId,MAAS,SAAU7N,GAMjB,IAAKA,EAAOA,EAAKoN,WAAYpN,EAAMA,EAAOA,EAAK6iB,YAC7C,GAAI7iB,EAAKuG,SAAW,KAAyB,IAAlBvG,EAAKL,UAAoC,IAAlBK,EAAKL,SACrD,OAAO,EAGX,OAAO,GAGT,OAAU,SAAUK,GAClB,OAAQ4e,EAAKwB,QAAQ,SAASpgB,IAIhC,OAAU,SAAUA,GAClB,OAAO6gB,EAAQrgB,KAAKR,EAAKuG,WAG3B,MAAS,SAAUvG,GACjB,OAAO4gB,EAAQpgB,KAAKR,EAAKuG,WAG3B,OAAU,SAAUvG,GAClB,IAAI8C,EAAO9C,EAAKuG,SAASC,cACzB,MAAgB,UAAT1D,GAAkC,WAAd9C,EAAKf,MAA8B,WAAT6D,GAGvD,KAAQ,SAAU9C,GAChB,IAAIW,EAGJ,MAAuC,UAAhCX,EAAKuG,SAASC,eACL,SAAdxG,EAAKf,OACkC,OAArC0B,EAAOX,EAAKuN,aAAa,UAAoB5M,EAAK6F,gBAAkBxG,EAAKf,OAI/E,MAAS+jB,IAAuB,WAC9B,MAAO,CAAC,MAGV,KAAQA,IAAuB,SAAUE,EAAczjB,GACrD,MAAO,CAACA,EAAS,MAGnB,GAAMujB,IAAuB,SAAUE,EAAczjB,EAAQwjB,GAC3D,MAAO,CAACA,EAAW,EAAIA,EAAWxjB,EAASwjB,MAG7C,KAAQD,IAAuB,SAAUE,EAAczjB,GAErD,IADA,IAAI0C,EAAI,EACDA,EAAI1C,EAAQ0C,GAAK,EACtB+gB,EAAanmB,KAAKoF,GAEpB,OAAO+gB,KAGT,IAAOF,IAAuB,SAAUE,EAAczjB,GAEpD,IADA,IAAI0C,EAAI,EACDA,EAAI1C,EAAQ0C,GAAK,EACtB+gB,EAAanmB,KAAKoF,GAEpB,OAAO+gB,KAGT,GAAMF,IAAuB,SAAUE,EAAczjB,EAAQwjB,GAE3D,IADA,IAAI9gB,EAAI8gB,EAAW,EAAIA,EAAWxjB,EAASwjB,IAClC9gB,GAAK,GACZ+gB,EAAanmB,KAAKoF,GAEpB,OAAO+gB,KAGT,GAAMF,IAAuB,SAAUE,EAAczjB,EAAQwjB,GAE3D,IADA,IAAI9gB,EAAI8gB,EAAW,EAAIA,EAAWxjB,EAASwjB,IAClC9gB,EAAI1C,GACXyjB,EAAanmB,KAAKoF,GAEpB,OAAO+gB,OAMH,CAAEwD,OAAO,EAAMC,UAAU,EAAMC,MAAM,EAAMC,UAAU,EAAMC,OAAO,GAC1ElI,EAAKwB,QAAQje,GAAK2gB,GAAkB3gB,GAEtC,IAAKA,IAAK,CAAEiN,QAAQ,EAAM2X,OAAO,GAC/BnI,EAAKwB,QAAQje,GAAK4gB,GAAmB5gB,GAGvC,SAASkgB,GAAS3kB,EAAUspB,GAC1B,IAAI3M,EAASta,EAAOknB,EAAQhoB,EAC1BioB,EAAOrF,EAAQsF,EACfC,EAASxH,EAAWliB,EAAW,KAEjC,GAAI0pB,EACF,OAAOJ,EAAY,EAAII,EAAOnqB,MAAM,GAGtCiqB,EAAQxpB,EACRmkB,EAAS,GACTsF,EAAavI,EAAKuG,UAElB,MAAO+B,EAAO,CAyBZ,IAAKjoB,KAtBAob,KAAYta,EAAQsgB,EAAOlgB,KAAK+mB,MAC/BnnB,IAEFmnB,EAAQA,EAAMjqB,MAAM8C,EAAM,GAAGN,SAAWynB,GAE1CrF,EAAO9kB,KAAKkqB,EAAS,KAGvB5M,GAAU,GAGLta,EAAQugB,EAAangB,KAAK+mB,MAC7B7M,EAAUta,EAAM0J,QAChBwd,EAAOlqB,KAAK,CACV0J,MAAO4T,EAEPpb,KAAMc,EAAM,GAAGuF,QAAQrH,EAAO,OAEhCipB,EAAQA,EAAMjqB,MAAMod,EAAQ5a,SAIjBmf,EAAKrD,SACXxb,EAAQ0gB,EAAUxhB,GAAMkB,KAAK+mB,KAAaC,EAAWloB,MACvDc,EAAQonB,EAAWloB,GAAMc,MAC1Bsa,EAAUta,EAAM0J,QAChBwd,EAAOlqB,KAAK,CACV0J,MAAO4T,EACPpb,KAAMA,EACN6b,QAAS/a,IAEXmnB,EAAQA,EAAMjqB,MAAMod,EAAQ5a,SAIhC,IAAK4a,EACH,MAOJ,OAAO2M,EACLE,EAAMznB,OACNynB,EACExF,GAAOld,MAAM9G,GAEbkiB,EAAWliB,EAAUmkB,GAAQ5kB,MAAM,GAGzC,SAASqlB,GAAW2E,GAIlB,IAHA,IAAI9kB,EAAI,EACNC,EAAM6kB,EAAOxnB,OACb/B,EAAW,GACNyE,EAAIC,EAAKD,IACdzE,GAAYupB,EAAO9kB,GAAGsE,MAExB,OAAO/I,EAGT,SAAS2pB,GAAclB,EAASmB,EAAYC,GAC1C,IAAIrC,EAAMoC,EAAWpC,IACnBsC,EAAmBD,GAAgB,eAARrC,EAC3BuC,EAAW5lB,IAEb,OAAOylB,EAAWtlB,MAEhB,SAAUhC,EAAMrC,EAAS8H,GACvB,MAAQzF,EAAOA,EAAKklB,GAClB,GAAsB,IAAlBllB,EAAKL,UAAkB6nB,EACzB,OAAOrB,EAAQnmB,EAAMrC,EAAS8H,IAMpC,SAAUzF,EAAMrC,EAAS8H,GACvB,IAAId,EAAMyM,EAAOyU,EACf6B,EAASjI,EAAU,IAAMgI,EAG3B,GAAIhiB,GACF,MAAQzF,EAAOA,EAAKklB,GAClB,IAAsB,IAAlBllB,EAAKL,UAAkB6nB,IACrBrB,EAAQnmB,EAAMrC,EAAS8H,GACzB,OAAO,OAKb,MAAQzF,EAAOA,EAAKklB,GAClB,GAAsB,IAAlBllB,EAAKL,UAAkB6nB,EAEzB,GADA3B,EAAa7lB,EAAKwP,KAAaxP,EAAKwP,GAAW,KAC1C4B,EAAQyU,EAAWX,KAAS9T,EAAM,KAAOsW,GAC5C,IAA0B,KAArB/iB,EAAOyM,EAAM,KAAgBzM,IAASga,EACzC,OAAgB,IAATha,OAKT,GAFAyM,EAAQyU,EAAWX,GAAO,CAACwC,GAC3BtW,EAAM,GAAK+U,EAAQnmB,EAAMrC,EAAS8H,IAAQkZ,GACzB,IAAbvN,EAAM,GACR,OAAO,GASvB,SAASuW,GAAeC,GACtB,OAAOA,EAASnoB,OAAS,EACvB,SAAUO,EAAMrC,EAAS8H,GACvB,IAAItD,EAAIylB,EAASnoB,OACjB,MAAO0C,IACL,IAAKylB,EAASzlB,GAAGnC,EAAMrC,EAAS8H,GAC9B,OAAO,EAGX,OAAO,GAETmiB,EAAS,GAGb,SAASC,GAASzB,EAAW9jB,EAAKiZ,EAAQ5d,EAAS8H,GAOjD,IANA,IAAIzF,EACF8nB,EAAe,GACf3lB,EAAI,EACJC,EAAMgkB,EAAU3mB,OAChBsoB,EAAgB,MAAPzlB,EAEJH,EAAIC,EAAKD,KACTnC,EAAOomB,EAAUjkB,MACfoZ,IAAUA,EAAOvb,EAAMrC,EAAS8H,KACnCqiB,EAAa/qB,KAAKiD,GACd+nB,GACFzlB,EAAIvF,KAAKoF,KAMjB,OAAO2lB,EAGT,SAASE,GAAW7C,EAAWznB,EAAUyoB,EAAS8B,EAAYC,EAAYC,GAOxE,OANIF,IAAeA,EAAWzY,KAC5ByY,EAAaD,GAAWC,IAEtBC,IAAeA,EAAW1Y,KAC5B0Y,EAAaF,GAAWE,EAAYC,IAE/B3G,IAAa,SAAUG,EAAM/a,EAASjJ,EAAS8H,GACpD,IAAI2iB,EAAMjmB,EAAGnC,EACXqoB,EAAS,GACTC,EAAU,GACVC,EAAc3hB,EAAQnH,OAGtB6B,EAAQqgB,GAAQ6G,GAAiB9qB,GAAY,IAAKC,EAAQgC,SAAW,CAAChC,GAAWA,EAAS,IAG1F8qB,GAAYtD,IAAcxD,GAASjkB,EAEjC4D,EADAumB,GAASvmB,EAAO+mB,EAAQlD,EAAWxnB,EAAS8H,GAG9CijB,EAAavC,EAEX+B,IAAevG,EAAOwD,EAAYoD,GAAeN,GAG/C,GAGArhB,EACF6hB,EAQJ,GALItC,GACFA,EAAQsC,EAAWC,EAAY/qB,EAAS8H,GAItCwiB,EAAY,CACdG,EAAOP,GAASa,EAAYJ,GAC5BL,EAAWG,EAAM,GAAIzqB,EAAS8H,GAG9BtD,EAAIimB,EAAK3oB,OACT,MAAO0C,KACAnC,EAAOooB,EAAKjmB,MACfumB,EAAWJ,EAAQnmB,MAAQsmB,EAAUH,EAAQnmB,IAAMnC,IAKzD,GAAI2hB,GACF,GAAIuG,GAAc/C,EAAW,CAC3B,GAAI+C,EAAY,CAEdE,EAAO,GACPjmB,EAAIumB,EAAWjpB,OACf,MAAO0C,KACAnC,EAAO0oB,EAAWvmB,KAErBimB,EAAKrrB,KAAM0rB,EAAUtmB,GAAKnC,GAG9BkoB,EAAW,KAAOQ,EAAa,GAAKN,EAAM3iB,GAI5CtD,EAAIumB,EAAWjpB,OACf,MAAO0C,KACAnC,EAAO0oB,EAAWvmB,MACpBimB,EAAOF,EAAa/qB,EAAQ+D,KAAKygB,EAAM3hB,GAAQqoB,EAAOlmB,KAAO,IAE9Dwf,EAAKyG,KAAUxhB,EAAQwhB,GAAQpoB,UAOrC0oB,EAAab,GACXa,IAAe9hB,EACb8hB,EAAWjmB,OAAO8lB,EAAaG,EAAWjpB,QAC1CipB,GAEAR,EACFA,EAAW,KAAMthB,EAAS8hB,EAAYjjB,GAEtC1I,EAAK+E,MAAM8E,EAAS8hB,MAM5B,SAASC,GAAkB1B,GAqBzB,IApBA,IAAI2B,EAAczC,EAAS9jB,EACzBD,EAAM6kB,EAAOxnB,OACbopB,EAAkBjK,EAAKqG,SAASgC,EAAO,GAAGhoB,MAC1C6pB,EAAmBD,GAAmBjK,EAAKqG,SAAS,KACpD9iB,EAAI0mB,EAAkB,EAAI,EAG1BE,EAAe1B,IAAc,SAAUrnB,GACrC,OAAOA,IAAS4oB,IACfE,GAAkB,GACrBE,EAAkB3B,IAAc,SAAUrnB,GACxC,OAAO7C,EAAQ+D,KAAK0nB,EAAc5oB,IAAS,IAC1C8oB,GAAkB,GACrBlB,EAAW,CAAC,SAAU5nB,EAAMrC,EAAS8H,GACnC,OAASojB,IAAoBpjB,GAAO9H,IAAYshB,MAC7C2J,EAAejrB,GAASgC,SACvBopB,EAAa/oB,EAAMrC,EAAS8H,GAC5BujB,EAAgBhpB,EAAMrC,EAAS8H,MAGhCtD,EAAIC,EAAKD,IACd,GAAKgkB,EAAUvH,EAAKqG,SAASgC,EAAO9kB,GAAGlD,MACrC2oB,EAAW,CAACP,GAAcM,GAAeC,GAAWzB,QAC/C,CAIL,GAHAA,EAAUvH,EAAKrD,OAAO0L,EAAO9kB,GAAGlD,MAAM6C,MAAM,KAAMmlB,EAAO9kB,GAAG2Y,SAGxDqL,EAAQ3W,GAAU,CAGpB,IADAnN,IAAMF,EACCE,EAAID,EAAKC,IACd,GAAIuc,EAAKqG,SAASgC,EAAO5kB,GAAGpD,MAC1B,MAGJ,OAAO+oB,GACL7lB,EAAI,GAAKwlB,GAAeC,GACxBzlB,EAAI,GAAKmgB,GAAW2E,EAAOhqB,MAAM,EAAGkF,EAAI,IAAImD,QAAQrH,EAAO,MAC3DkoB,EACAhkB,EAAIE,GAAKsmB,GAAkB1B,EAAOhqB,MAAMkF,EAAGE,IAC3CA,EAAID,GAAOumB,GAAmB1B,EAASA,EAAOhqB,MAAMoF,IACpDA,EAAID,GAAOkgB,GAAW2E,IAG1BW,EAAS7qB,KAAKopB,GAIlB,OAAOwB,GAAeC,GAGxB,SAASqB,GAAyBC,EAAiBC,GAEjD,IAAIC,EAAoB,EACtBC,EAAQF,EAAY1pB,OAAS,EAC7B6pB,EAAYJ,EAAgBzpB,OAAS,EACrC8pB,EAAe,SAAU5H,EAAMhkB,EAAS8H,EAAKmB,EAAS4iB,GACpD,IAAIxpB,EAAMqC,EAAG8jB,EACXsD,EAAa,GACbC,EAAe,EACfvnB,EAAI,IACJikB,EAAYzE,GAAQ,GACpBgI,EAA6B,MAAjBH,EACZI,EAAgB3K,EAEhB3d,EAAQqgB,GAAQ2H,GAAa1K,EAAKxe,KAAK,OAAO,IAAKopB,GAAiB7rB,EAAQkD,YAAclD,GAE1FksB,EAAiBpK,GAA4B,MAAjBmK,EAAwB,EAAI7iB,KAAK4K,UAAY,GAS3E,IAPIgY,IACF1K,EAAmBthB,IAAYxB,GAAYwB,EAC3CghB,EAAayK,GAKa,OAApBppB,EAAOsB,EAAMa,IAAaA,IAAK,CACrC,GAAImnB,GAAatpB,EAAM,CACrBqC,EAAI,EACJ,MAAQ8jB,EAAU+C,EAAgB7mB,KAChC,GAAI8jB,EAAQnmB,EAAMrC,EAAS8H,GAAM,CAC/BmB,EAAQ7J,KAAKiD,GACb,MAGA2pB,IACFlK,EAAUoK,EACVlL,IAAeyK,GAKfC,KAEGrpB,GAAQmmB,GAAWnmB,IACtB0pB,IAIE/H,GACFyE,EAAUrpB,KAAKiD,IAOrB,GADA0pB,GAAgBvnB,EACZknB,GAASlnB,IAAMunB,EAAc,CAC/BrnB,EAAI,EACJ,MAAQ8jB,EAAUgD,EAAY9mB,KAC5B8jB,EAAQC,EAAWqD,EAAY9rB,EAAS8H,GAG1C,GAAIkc,EAAM,CAER,GAAI+H,EAAe,EACjB,MAAOvnB,IACCikB,EAAUjkB,IAAMsnB,EAAWtnB,KAC/BsnB,EAAWtnB,GAAKkP,EAAInQ,KAAK0F,IAM/B6iB,EAAa5B,GAAS4B,GAIxB1sB,EAAK+E,MAAM8E,EAAS6iB,GAGhBE,IAAchI,GAAQ8H,EAAWhqB,OAAS,GAC3CiqB,EAAeP,EAAY1pB,OAAU,GAEtCiiB,GAAOiD,WAAW/d,GAUtB,OALI+iB,IACFlK,EAAUoK,EACV5K,EAAmB2K,GAGdxD,GAGX,OAAOiD,EACL7H,GAAa+H,GACbA,EA8BJ,SAASf,GAAiB9qB,EAAUsO,EAAUpF,GAG5C,IAFA,IAAIzE,EAAI,EACNC,EAAM4J,EAASvM,OACV0C,EAAIC,EAAKD,IACduf,GAAOhkB,EAAUsO,EAAS7J,GAAIyE,GAEhC,OAAOA,EAGT,SAAS0F,GAAO5O,EAAUC,EAASiJ,EAAS+a,GAC1C,IAAIxf,EAAG8kB,EAAQ6C,EAAO7qB,EAAMmB,EAC1BL,EAAQsiB,GAAS3kB,GAEnB,IAAKikB,GAEkB,IAAjB5hB,EAAMN,OAAc,CAItB,GADAwnB,EAASlnB,EAAM,GAAKA,EAAM,GAAG9C,MAAM,GAC/BgqB,EAAOxnB,OAAS,GAAkC,QAA5BqqB,EAAQ7C,EAAO,IAAIhoB,MACtB,IAArBtB,EAAQgC,WAAmByf,GAC3BR,EAAKqG,SAASgC,EAAO,GAAGhoB,MAAO,CAG/B,GADAtB,EAAUihB,EAAKxe,KAAK,MAAM0pB,EAAMhP,QAAQ,GAAGxV,QAAQ0b,GAAWC,IAAYtjB,GAAS,IAC9EA,EACH,OAAOiJ,EAGTlJ,EAAWA,EAAST,MAAMgqB,EAAOxd,QAAQhD,MAAMhH,QAIjD0C,EAAIse,EAAU,gBAAgBjgB,KAAK9C,GAAY,EAAIupB,EAAOxnB,OAC1D,MAAO0C,IAAK,CAIV,GAHA2nB,EAAQ7C,EAAO9kB,GAGXyc,EAAKqG,SAAUhmB,EAAO6qB,EAAM7qB,MAC9B,MAEF,IAAKmB,EAAOwe,EAAKxe,KAAKnB,MAEf0iB,EAAOvhB,EACV0pB,EAAMhP,QAAQ,GAAGxV,QAAQ0b,GAAWC,IACpCP,EAASlgB,KAAKymB,EAAO,GAAGhoB,OAAStB,EAAQkD,YAAclD,IACrD,CAKF,GAFAspB,EAAOxkB,OAAON,EAAG,GACjBzE,EAAWikB,EAAKliB,QAAU6iB,GAAW2E,IAChCvpB,EAEH,OADAX,EAAK+E,MAAM8E,EAAS3J,EAAMiE,KAAKygB,EAAM,IAC9B/a,EAGT,QAgBV,OAPAmY,EAAQrhB,EAAUqC,EAAlBgf,CACE4C,EACAhkB,EACAyhB,EACAxY,EACA8Z,EAASlgB,KAAK9C,IAETkJ,EAOT,SAASqf,MAzGTlH,EAAU2C,GAAO3C,QAAU,SAAUrhB,EAAUqsB,GAC7C,IAAI5nB,EACFgnB,EAAc,GACdD,EAAkB,GAClB9B,EAASvH,EAAcniB,EAAW,KAEpC,IAAK0pB,EAAQ,CAEN2C,IACHA,EAAQ1H,GAAS3kB,IAEnByE,EAAI4nB,EAAMtqB,OACV,MAAO0C,IACLilB,EAASuB,GAAkBoB,EAAM5nB,IAC7BilB,EAAO5X,GACT2Z,EAAYpsB,KAAKqqB,GAEjB8B,EAAgBnsB,KAAKqqB,GAKzBA,EAASvH,EAAcniB,EAAUurB,GAAyBC,EAAiBC,IAE7E,OAAO/B,GA8ETxI,EAAKwB,QAAQ,OAASxB,EAAKwB,QAAQ,MAInCxB,EAAKoL,QAAU/D,GAAWrmB,UAAYgf,EAAKwB,QAC3CxB,EAAKqH,WAAa,IAAIA,GAGtB/G,IAGAwC,GAAO/gB,KAAOrE,EAAOqE,KACrBrE,EAAO8D,KAAOshB,GACdplB,EAAOqc,KAAO+I,GAAOqD,UACrBzoB,EAAOqc,KAAK,KAAOrc,EAAOqc,KAAKyH,QAC/B9jB,EAAOwN,OAAS4X,GAAOiD,WACvBroB,EAAOoK,KAAOgb,GAAO7C,QACrBviB,EAAOgZ,SAAWoM,GAAO5C,MACzBxiB,EAAOqhB,SAAW+D,GAAO/D,SAzzD3B,CA4zDG7hB,GACH,IAAImuB,GAAS,SACXC,GAAe,iCACfC,GAAW,iBACXC,GAAgB9tB,EAAOqc,KAAK5Y,MAAM2Y,aAElC2R,GAAmB,CACjBC,UAAU,EACVC,UAAU,EACVhY,MAAM,EACNiY,MAAM,GA6HV,SAASC,GAAQjY,EAAK0S,GACpB,GACE1S,EAAMA,EAAI0S,SACH1S,GAAwB,IAAjBA,EAAI7S,UAEpB,OAAO6S,EAuGT,SAASkY,GAAOrX,EAAUsX,EAAWC,GAMnC,GAFAD,EAAYA,GAAa,EAErBruB,EAAOoE,WAAWiqB,GACpB,OAAOruB,EAAO6K,KAAKkM,GAAU,SAAUrT,EAAMmC,GAC3C,IAAIkF,IAAWsjB,EAAUzpB,KAAKlB,EAAMmC,EAAGnC,GACvC,OAAOqH,IAAWujB,KAGf,GAAID,EAAUhrB,SACnB,OAAOrD,EAAO6K,KAAKkM,GAAU,SAAUrT,GACrC,OAAQA,IAAS2qB,IAAeC,KAG7B,GAAyB,kBAAdD,EAAwB,CACxC,IAAIE,EAAWvuB,EAAO6K,KAAKkM,GAAU,SAAUrT,GAC7C,OAAyB,IAAlBA,EAAKL,YAGd,GAAIwqB,GAAS3pB,KAAKmqB,GAChB,OAAOruB,EAAOif,OAAOoP,EAAWE,GAAWD,GAE3CD,EAAYruB,EAAOif,OAAOoP,EAAWE,GAIzC,OAAOvuB,EAAO6K,KAAKkM,GAAU,SAAUrT,GACrC,OAAQ1D,EAAOwK,QAAQ9G,EAAM2qB,IAAc,IAAOC,KAGtD,SAASE,GAAmB3uB,GAC1B,IAAIiN,EAAO2hB,GAAUxiB,MAAM,KACzByiB,EAAW7uB,EAAS4S,yBAEtB,GAAIic,EAASjmB,cACX,MAAOqE,EAAK3J,OACVurB,EAASjmB,cACPqE,EAAKiI,OAIX,OAAO2Z,EAlRT1uB,EAAOsB,GAAG8E,OAAO,CACftC,KAAM,SAAU1C,GACd,IAAIyE,EAAGZ,EAAKmI,EACVtH,EAAMnC,KAAKR,OAEb,GAAwB,kBAAb/B,EAET,OADAgM,EAAOzJ,KACAA,KAAKoB,UAAU/E,EAAOoB,GAAU6d,QAAO,WAC5C,IAAKpZ,EAAI,EAAGA,EAAIC,EAAKD,IACnB,GAAI7F,EAAOqhB,SAASjU,EAAKvH,GAAIlC,MAC3B,OAAO,MAOf,IADAsB,EAAM,GACDY,EAAI,EAAGA,EAAIC,EAAKD,IACnB7F,EAAO8D,KAAK1C,EAAUuC,KAAKkC,GAAIZ,GAMjC,OAFAA,EAAMtB,KAAKoB,UAAUe,EAAM,EAAI9F,EAAOwN,OAAOvI,GAAOA,GACpDA,EAAI7D,UAAYuC,KAAKvC,SAAWuC,KAAKvC,SAAW,IAAM,IAAMA,EACrD6D,GAGTwI,IAAK,SAAU9G,GACb,IAAId,EACF8oB,EAAU3uB,EAAO2G,EAAQhD,MACzBmC,EAAM6oB,EAAQxrB,OAEhB,OAAOQ,KAAKsb,QAAO,WACjB,IAAKpZ,EAAI,EAAGA,EAAIC,EAAKD,IACnB,GAAI7F,EAAOqhB,SAAS1d,KAAMgrB,EAAQ9oB,IAChC,OAAO,MAMf+oB,IAAK,SAAUxtB,GACb,OAAOuC,KAAKoB,UAAUqpB,GAAOzqB,KAAMvC,GAAU,KAG/C6d,OAAQ,SAAU7d,GAChB,OAAOuC,KAAKoB,UAAUqpB,GAAOzqB,KAAMvC,GAAU,KAG/CytB,GAAI,SAAUztB,GACZ,QAASA,IACa,kBAAbA,EAGL0sB,GAAc5pB,KAAK9C,GACjBpB,EAAOoB,EAAUuC,KAAKtC,SAASqM,MAAM/J,KAAK,KAAO,EACjD3D,EAAOif,OAAO7d,EAAUuC,MAAMR,OAAS,EACzCQ,KAAKsb,OAAO7d,GAAU+B,OAAS,IAGrC2rB,QAAS,SAAUrG,EAAWpnB,GAS5B,IARA,IAAI6U,EACFrQ,EAAI,EACJ+E,EAAIjH,KAAKR,OACT8B,EAAM,GACN8pB,EAAMjB,GAAc5pB,KAAKukB,IAAmC,kBAAdA,EAC5CzoB,EAAOyoB,EAAWpnB,GAAWsC,KAAKtC,SAClC,EAEGwE,EAAI+E,EAAG/E,IAAK,CACjBqQ,EAAMvS,KAAKkC,GAEX,MAAOqQ,GAAOA,EAAIjS,eAAiBiS,IAAQ7U,GAA4B,KAAjB6U,EAAI7S,SAAiB,CACzE,GAAI0rB,EAAMA,EAAIrhB,MAAMwI,IAAQ,EAAIlW,EAAO8D,KAAKyjB,gBAAgBrR,EAAKuS,GAAY,CAC3ExjB,EAAIxE,KAAKyV,GACT,MAEFA,EAAMA,EAAI3R,YAId,OAAOZ,KAAKoB,UAAUE,EAAI9B,OAAS,EAAInD,EAAOwN,OAAOvI,GAAOA,IAK9DyI,MAAO,SAAUhK,GAGf,OAAKA,EAKe,kBAATA,EACF1D,EAAOwK,QAAQ7G,KAAK,GAAI3D,EAAO0D,IAIjC1D,EAAOwK,QAEZ9G,EAAKH,OAASG,EAAK,GAAKA,EAAMC,MAXtBA,KAAK,IAAMA,KAAK,GAAGY,WAAcZ,KAAK+B,QAAQspB,UAAU7rB,QAAU,GAc9EmK,IAAK,SAAUlM,EAAUC,GACvB,IAAIoX,EAA0B,kBAAbrX,EACfpB,EAAOoB,EAAUC,GACjBrB,EAAOyE,UAAUrD,GAAYA,EAASiC,SAAW,CAACjC,GAAYA,GAC9DiB,EAAMrC,EAAO+D,MAAMJ,KAAKkB,MAAO4T,GAEjC,OAAO9U,KAAKoB,UAAU/E,EAAOwN,OAAOnL,KAGtC4sB,QAAS,SAAU7tB,GACjB,OAAOuC,KAAK2J,IAAgB,MAAZlM,EACduC,KAAKuB,WAAavB,KAAKuB,WAAW+Z,OAAO7d,OAK/CpB,EAAOsB,GAAG4tB,QAAUlvB,EAAOsB,GAAG2tB,QAU9BjvB,EAAOmF,KAAK,CACVuV,OAAQ,SAAUhX,GAChB,IAAIgX,EAAShX,EAAKa,WAClB,OAAOmW,GAA8B,KAApBA,EAAOrX,SAAkBqX,EAAS,MAErDyU,QAAS,SAAUzrB,GACjB,OAAO1D,EAAO4oB,IAAIllB,EAAM,eAE1B0rB,aAAc,SAAU1rB,EAAMmC,EAAGwpB,GAC/B,OAAOrvB,EAAO4oB,IAAIllB,EAAM,aAAc2rB,IAExCpZ,KAAM,SAAUvS,GACd,OAAOyqB,GAAQzqB,EAAM,gBAEvBwqB,KAAM,SAAUxqB,GACd,OAAOyqB,GAAQzqB,EAAM,oBAEvB4rB,QAAS,SAAU5rB,GACjB,OAAO1D,EAAO4oB,IAAIllB,EAAM,gBAE1BsrB,QAAS,SAAUtrB,GACjB,OAAO1D,EAAO4oB,IAAIllB,EAAM,oBAE1B6rB,UAAW,SAAU7rB,EAAMmC,EAAGwpB,GAC5B,OAAOrvB,EAAO4oB,IAAIllB,EAAM,cAAe2rB,IAEzCG,UAAW,SAAU9rB,EAAMmC,EAAGwpB,GAC5B,OAAOrvB,EAAO4oB,IAAIllB,EAAM,kBAAmB2rB,IAE7CI,SAAU,SAAU/rB,GAClB,OAAO1D,EAAOmuB,SAASzqB,EAAKa,YAAc,IAAIuM,WAAYpN,IAE5DsqB,SAAU,SAAUtqB,GAClB,OAAO1D,EAAOmuB,QAAQzqB,EAAKoN,aAE7Bmd,SAAU,SAAUvqB,GAClB,OAAO1D,EAAOiK,SAASvG,EAAM,UAC3BA,EAAKgsB,iBAAmBhsB,EAAKisB,cAAc9vB,SAC3CG,EAAO+D,MAAM,GAAIL,EAAKkF,eAEzB,SAAUpC,EAAMlF,GACjBtB,EAAOsB,GAAGkF,GAAQ,SAAU6oB,EAAOjuB,GACjC,IAAI6D,EAAMjF,EAAOgG,IAAIrC,KAAMrC,EAAI+tB,GAgB/B,OAdK1B,GAAOzpB,KAAKsC,KACfpF,EAAWiuB,GAGTjuB,GAAgC,kBAAbA,IACrB6D,EAAMjF,EAAOif,OAAO7d,EAAU6D,IAGhCA,EAAMtB,KAAKR,OAAS,IAAM4qB,GAAiBvnB,GAAQxG,EAAOwN,OAAOvI,GAAOA,EAEpEtB,KAAKR,OAAS,GAAKyqB,GAAa1pB,KAAKsC,KACvCvB,EAAMA,EAAI2qB,WAGLjsB,KAAKoB,UAAUE,OAI1BjF,EAAOoG,OAAO,CACZ6Y,OAAQ,SAAU5C,EAAMrX,EAAO4pB,GAK7B,OAJIA,IACFvS,EAAO,QAAUA,EAAO,KAGF,IAAjBrX,EAAM7B,OACXnD,EAAO8D,KAAKyjB,gBAAgBviB,EAAM,GAAIqX,GAAQ,CAACrX,EAAM,IAAM,GAC3DhF,EAAO8D,KAAK0a,QAAQnC,EAAMrX,IAG9B4jB,IAAK,SAAUllB,EAAMklB,EAAKyG,GACxB,IAAItR,EAAU,GACZ7H,EAAMxS,EAAKklB,GAEb,MAAO1S,GAAwB,IAAjBA,EAAI7S,WAAmBgsB,IAAU5vB,GAA8B,IAAjByW,EAAI7S,WAAmBrD,EAAOkW,GAAK2Y,GAAGQ,IAC3E,IAAjBnZ,EAAI7S,UACN0a,EAAQtd,KAAKyV,GAEfA,EAAMA,EAAI0S,GAEZ,OAAO7K,GAGToQ,QAAS,SAAU0B,EAAGnsB,GAGpB,IAFA,IAAIosB,EAAI,GAEDD,EAAGA,EAAIA,EAAEtJ,YACK,IAAfsJ,EAAExsB,UAAkBwsB,IAAMnsB,GAC5BosB,EAAErvB,KAAKovB,GAIX,OAAOC,KAoDX,IAAIrB,GAAY,6JAEdsB,GAAgB,6BAChBC,GAAe,IAAIpT,OAAO,OAAS6R,GAAY,WAAY,KAC3DwB,GAAqB,OACrBC,GAAY,0EACZC,GAAW,YACXC,GAAS,UACTC,GAAQ,YACRC,GAAe,0BACfC,GAA8B,wBAE9BC,GAAW,oCACXC,GAAc,4BACdC,GAAoB,cACpBC,GAAe,2CAGfC,GAAU,CACRlY,OAAQ,CAAC,EAAG,+BAAgC,aAC5CmY,OAAQ,CAAC,EAAG,aAAc,eAC1BC,KAAM,CAAC,EAAG,QAAS,UACnBC,MAAO,CAAC,EAAG,WAAY,aACvBC,MAAO,CAAC,EAAG,UAAW,YACtBC,GAAI,CAAC,EAAG,iBAAkB,oBAC1BC,IAAK,CAAC,EAAG,mCAAoC,uBAC7CC,GAAI,CAAC,EAAG,qBAAsB,yBAI9BtT,SAAU7d,EAAO6P,QAAQmB,cAAgB,CAAC,EAAG,GAAI,IAAM,CAAC,EAAG,SAAU,WAEvEogB,GAAe5C,GAAmB3uB,GAClCwxB,GAAcD,GAAa5gB,YAAY3Q,EAAS4I,cAAc,QA8UhE,SAAS6oB,GAAa5tB,EAAM4jB,GAC1B,OAAO5jB,EAAKiG,qBAAqB2d,GAAK,IAAM5jB,EAAK8M,YAAY9M,EAAKO,cAAcwE,cAAc6e,IAIhG,SAASiK,GAAc7tB,GACrB,IAAIW,EAAOX,EAAKwW,iBAAiB,QAEjC,OADAxW,EAAKf,MAAQ0B,GAAQA,EAAKsU,WAAa,IAAMjV,EAAKf,KAC3Ce,EAET,SAAS8tB,GAAc9tB,GACrB,IAAID,EAAQitB,GAAkB7sB,KAAKH,EAAKf,MAMxC,OALIc,EACFC,EAAKf,KAAOc,EAAM,GAElBC,EAAK0V,gBAAgB,QAEhB1V,EAIT,SAAS+tB,GAAczsB,EAAO0sB,GAG5B,IAFA,IAAIhuB,EACFmC,EAAI,EACsB,OAApBnC,EAAOsB,EAAMa,IAAaA,IAChC7F,EAAOyV,MAAM/R,EAAM,cAAeguB,GAAe1xB,EAAOyV,MAAMic,EAAY7rB,GAAI,eAIlF,SAAS8rB,GAAetrB,EAAKurB,GAE3B,GAAsB,IAAlBA,EAAKvuB,UAAmBrD,EAAOuV,QAAQlP,GAA3C,CAIA,IAAI1D,EAAMkD,EAAG+E,EACXinB,EAAU7xB,EAAOyV,MAAMpP,GACvByrB,EAAU9xB,EAAOyV,MAAMmc,EAAMC,GAC7BxW,EAASwW,EAAQxW,OAEnB,GAAIA,EAIF,IAAK1Y,YAHEmvB,EAAQ/V,OACf+V,EAAQzW,OAAS,GAEJA,EACX,IAAKxV,EAAI,EAAG+E,EAAIyQ,EAAO1Y,GAAMQ,OAAQ0C,EAAI+E,EAAG/E,IAC1C7F,EAAOyC,MAAM6K,IAAIskB,EAAMjvB,EAAM0Y,EAAO1Y,GAAMkD,IAM5CisB,EAAQzpB,OACVypB,EAAQzpB,KAAOrI,EAAOoG,OAAO,GAAI0rB,EAAQzpB,QAI7C,SAAS0pB,GAAmB1rB,EAAKurB,GAC/B,IAAI3nB,EAAUlC,EAAGM,EAGjB,GAAsB,IAAlBupB,EAAKvuB,SAAT,CAOA,GAHA4G,EAAW2nB,EAAK3nB,SAASC,eAGpBlK,EAAO6P,QAAQkC,cAAgB6f,EAAK5xB,EAAOkT,SAAU,CAGxD,IAAKnL,KAFLM,EAAOrI,EAAOyV,MAAMmc,GAEVvpB,EAAKgT,OACbrb,EAAO8c,YAAY8U,EAAM7pB,EAAGM,EAAK0T,QAInC6V,EAAKxY,gBAAgBpZ,EAAOkT,SAIb,WAAbjJ,GAAyB2nB,EAAKxnB,OAAS/D,EAAI+D,MAC7CmnB,GAAcK,GAAMxnB,KAAO/D,EAAI+D,KAC/BonB,GAAcI,IAIQ,WAAb3nB,GACL2nB,EAAKrtB,aACPqtB,EAAKjgB,UAAYtL,EAAIsL,WAOnB3R,EAAO6P,QAAQ4B,YAAepL,EAAIkK,YAAcvQ,EAAOmB,KAAKywB,EAAKrhB,aACnEqhB,EAAKrhB,UAAYlK,EAAIkK,YAGD,UAAbtG,GAAwBsmB,GAA4BrsB,KAAKmC,EAAI1D,OAKtEivB,EAAKI,eAAiBJ,EAAKvf,QAAUhM,EAAIgM,QAIrCuf,EAAKznB,QAAU9D,EAAI8D,QACrBynB,EAAKznB,MAAQ9D,EAAI8D,QAKG,WAAbF,EACT2nB,EAAKK,gBAAkBL,EAAKrgB,SAAWlL,EAAI4rB,gBAIrB,UAAbhoB,GAAqC,aAAbA,IACjC2nB,EAAKtX,aAAejU,EAAIiU,eA8B5B,SAAS4X,GAAO7wB,EAASimB,GACvB,IAAItiB,EAAOtB,EACTmC,EAAI,EACJssB,SAAe9wB,EAAQsI,uBAAyB/J,EAAoByB,EAAQsI,qBAAqB2d,GAAO,YAC/FjmB,EAAQ4kB,mBAAqBrmB,EAAoByB,EAAQ4kB,iBAAiBqB,GAAO,KACtF7nB,EAEN,IAAK0yB,EACH,IAAKA,EAAQ,GAAIntB,EAAQ3D,EAAQuH,YAAcvH,EAA8B,OAApBqC,EAAOsB,EAAMa,IAAaA,KAC5EyhB,GAAOtnB,EAAOiK,SAASvG,EAAM4jB,GAChC6K,EAAM1xB,KAAKiD,GAEX1D,EAAO+D,MAAMouB,EAAOD,GAAOxuB,EAAM4jB,IAKvC,OAAOA,IAAQ7nB,GAAa6nB,GAAOtnB,EAAOiK,SAAS5I,EAASimB,GAC1DtnB,EAAO+D,MAAM,CAAC1C,GAAU8wB,GACxBA,EAIJ,SAASC,GAAkB1uB,GACrB6sB,GAA4BrsB,KAAKR,EAAKf,QACxCe,EAAKsuB,eAAiBtuB,EAAK2O,SA3f/Bue,GAAQyB,SAAWzB,GAAQlY,OAC3BkY,GAAQ7f,MAAQ6f,GAAQ0B,MAAQ1B,GAAQ2B,SAAW3B,GAAQ4B,QAAU5B,GAAQI,MAC7EJ,GAAQ6B,GAAK7B,GAAQO,GAErBnxB,EAAOsB,GAAG8E,OAAO,CACfgE,KAAM,SAAUD,GACd,OAAOnK,EAAOmL,OAAOxH,MAAM,SAAUwG,GACnC,OAAOA,IAAU1K,EACfO,EAAOoK,KAAKzG,MACZA,KAAKgK,QAAQ+kB,QAAQ/uB,KAAK,IAAMA,KAAK,GAAGM,eAAiBpE,GAAU8yB,eAAexoB,MACnF,KAAMA,EAAO1E,UAAUtC,SAG5ByvB,QAAS,SAAUC,GACjB,GAAI7yB,EAAOoE,WAAWyuB,GACpB,OAAOlvB,KAAKwB,MAAK,SAAUU,GACzB7F,EAAO2D,MAAMivB,QAAQC,EAAKjuB,KAAKjB,KAAMkC,OAIzC,GAAIlC,KAAK,GAAI,CAEX,IAAImvB,EAAO9yB,EAAO6yB,EAAMlvB,KAAK,GAAGM,eAAe0B,GAAG,GAAGe,OAAM,GAEvD/C,KAAK,GAAGY,YACVuuB,EAAK9L,aAAarjB,KAAK,IAGzBmvB,EAAK9sB,KAAI,WACP,IAAItC,EAAOC,KAEX,MAAOD,EAAKoN,YAA2C,IAA7BpN,EAAKoN,WAAWzN,SACxCK,EAAOA,EAAKoN,WAGd,OAAOpN,KACNgvB,OAAO/uB,MAGZ,OAAOA,MAGTovB,UAAW,SAAUF,GACnB,OAAI7yB,EAAOoE,WAAWyuB,GACblvB,KAAKwB,MAAK,SAAUU,GACzB7F,EAAO2D,MAAMovB,UAAUF,EAAKjuB,KAAKjB,KAAMkC,OAIpClC,KAAKwB,MAAK,WACf,IAAIiI,EAAOpN,EAAO2D,MAChBsqB,EAAW7gB,EAAK6gB,WAEdA,EAAS9qB,OACX8qB,EAAS2E,QAAQC,GAGjBzlB,EAAKslB,OAAOG,OAKlBC,KAAM,SAAUD,GACd,IAAIzuB,EAAapE,EAAOoE,WAAWyuB,GAEnC,OAAOlvB,KAAKwB,MAAK,SAAUU,GACzB7F,EAAO2D,MAAMivB,QAAQxuB,EAAayuB,EAAKjuB,KAAKjB,KAAMkC,GAAKgtB,OAI3DG,OAAQ,WACN,OAAOrvB,KAAK+W,SAASvV,MAAK,WACnBnF,EAAOiK,SAAStG,KAAM,SACzB3D,EAAO2D,MAAMsvB,YAAYtvB,KAAKiF,eAE/B3C,OAGLysB,OAAQ,WACN,OAAO/uB,KAAKuvB,SAASztB,WAAW,GAAM,SAAU/B,GACxB,IAAlBC,KAAKN,UAAoC,KAAlBM,KAAKN,UAAqC,IAAlBM,KAAKN,UACtDM,KAAK6M,YAAY9M,OAKvByvB,QAAS,WACP,OAAOxvB,KAAKuvB,SAASztB,WAAW,GAAM,SAAU/B,GACxB,IAAlBC,KAAKN,UAAoC,KAAlBM,KAAKN,UAAqC,IAAlBM,KAAKN,UACtDM,KAAKqjB,aAAatjB,EAAMC,KAAKmN,gBAKnCsiB,OAAQ,WACN,OAAOzvB,KAAKuvB,SAASztB,WAAW,GAAO,SAAU/B,GAC3CC,KAAKY,YACPZ,KAAKY,WAAWyiB,aAAatjB,EAAMC,UAKzC0vB,MAAO,WACL,OAAO1vB,KAAKuvB,SAASztB,WAAW,GAAO,SAAU/B,GAC3CC,KAAKY,YACPZ,KAAKY,WAAWyiB,aAAatjB,EAAMC,KAAK4iB,iBAM9C5d,OAAQ,SAAUvH,EAAUkyB,GAI1B,IAHA,IAAI5vB,EACFmC,EAAI,EAEqB,OAAnBnC,EAAOC,KAAKkC,IAAaA,MAC1BzE,GAAYpB,EAAOif,OAAO7d,EAAU,CAACsC,IAAOP,OAAS,KACnDmwB,GAA8B,IAAlB5vB,EAAKL,UACpBrD,EAAOmV,UAAU+c,GAAOxuB,IAGtBA,EAAKa,aACH+uB,GAAYtzB,EAAOqhB,SAAS3d,EAAKO,cAAeP,IAClD+tB,GAAcS,GAAOxuB,EAAM,WAE7BA,EAAKa,WAAW6P,YAAY1Q,KAKlC,OAAOC,MAGTgK,MAAO,WAIL,IAHA,IAAIjK,EACFmC,EAAI,EAEqB,OAAnBnC,EAAOC,KAAKkC,IAAaA,IAAK,CAEd,IAAlBnC,EAAKL,UACPrD,EAAOmV,UAAU+c,GAAOxuB,GAAM,IAIhC,MAAOA,EAAKoN,WACVpN,EAAK0Q,YAAY1Q,EAAKoN,YAKpBpN,EAAK+C,SAAWzG,EAAOiK,SAASvG,EAAM,YACxCA,EAAK+C,QAAQtD,OAAS,GAI1B,OAAOQ,MAGT+C,MAAO,SAAU6sB,EAAeC,GAI9B,OAHAD,EAAiC,MAAjBA,GAAgCA,EAChDC,EAAyC,MAArBA,EAA4BD,EAAgBC,EAEzD7vB,KAAKqC,KAAI,WACd,OAAOhG,EAAO0G,MAAM/C,KAAM4vB,EAAeC,OAI7CX,KAAM,SAAU1oB,GACd,OAAOnK,EAAOmL,OAAOxH,MAAM,SAAUwG,GACnC,IAAIzG,EAAOC,KAAK,IAAM,GACpBkC,EAAI,EACJ+E,EAAIjH,KAAKR,OAEX,GAAIgH,IAAU1K,EACZ,OAAyB,IAAlBiE,EAAKL,SACVK,EAAK6M,UAAUvH,QAAQ+mB,GAAe,IACtCtwB,EAIJ,GAAqB,kBAAV0K,IAAuBmmB,GAAapsB,KAAKiG,KACjDnK,EAAO6P,QAAQmB,gBAAkBgf,GAAa9rB,KAAKiG,MACnDnK,EAAO6P,QAAQgB,oBAAsBof,GAAmB/rB,KAAKiG,MAC7DymB,IAAST,GAAStsB,KAAKsG,IAAU,CAAC,GAAI,KAAK,GAAGD,eAAgB,CAE/DC,EAAQA,EAAMnB,QAAQknB,GAAW,aAEjC,IACE,KAAOrqB,EAAI+E,EAAG/E,IAEZnC,EAAOC,KAAKkC,IAAM,GACI,IAAlBnC,EAAKL,WACPrD,EAAOmV,UAAU+c,GAAOxuB,GAAM,IAC9BA,EAAK6M,UAAYpG,GAIrBzG,EAAO,EAGP,MAAOqE,KAGPrE,GACFC,KAAKgK,QAAQ+kB,OAAOvoB,KAErB,KAAMA,EAAO1E,UAAUtC,SAG5B8vB,YAAa,SAAU9oB,GACrB,IAAIspB,EAASzzB,EAAOoE,WAAW+F,GAQ/B,OAJKspB,GAA2B,kBAAVtpB,IACpBA,EAAQnK,EAAOmK,GAAOykB,IAAIjrB,MAAMd,UAG3Bc,KAAKuvB,SAAS,CAAC/oB,IAAQ,GAAM,SAAUzG,GAC5C,IAAIuS,EAAOtS,KAAK4iB,YACd7L,EAAS/W,KAAKY,WAEZmW,IACF1a,EAAO2D,MAAMgF,SACb+R,EAAOsM,aAAatjB,EAAMuS,QAKhCpT,OAAQ,SAAUzB,GAChB,OAAOuC,KAAKgF,OAAOvH,GAAU,IAG/B8xB,SAAU,SAAU7tB,EAAMquB,EAAOtuB,GAG/BC,EAAO/E,EAAYkF,MAAM,GAAIH,GAE7B,IAAIK,EAAOmhB,EAAM8M,EACfnrB,EAAS+W,EAAKtP,EACdpK,EAAI,EACJ+E,EAAIjH,KAAKR,OACTsV,EAAM9U,KACNiwB,EAAWhpB,EAAI,EACfT,EAAQ9E,EAAK,GACbjB,EAAapE,EAAOoE,WAAW+F,GAGjC,GAAI/F,KAAgBwG,GAAK,GAAsB,kBAAVT,GAAsBnK,EAAO6P,QAAQ8C,aAAe6d,GAAStsB,KAAKiG,GACrG,OAAOxG,KAAKwB,MAAK,SAAUuI,GACzB,IAAIN,EAAOqL,EAAI9S,GAAG+H,GACdtJ,IACFiB,EAAK,GAAK8E,EAAMvF,KAAKjB,KAAM+J,EAAOgmB,EAAQtmB,EAAKylB,OAASpzB,IAE1D2N,EAAK8lB,SAAS7tB,EAAMquB,EAAOtuB,MAI/B,GAAIwF,IACFqF,EAAWjQ,EAAO0I,cAAcrD,EAAM1B,KAAK,GAAGM,eAAe,EAAON,MACpE+B,EAAQuK,EAASa,WAEkB,IAA/Bb,EAASrH,WAAWzF,SACtB8M,EAAWvK,GAGTA,GAAO,CAOT,IANAguB,EAAQA,GAAS1zB,EAAOiK,SAASvE,EAAO,MACxC8C,EAAUxI,EAAOgG,IAAIksB,GAAOjiB,EAAU,UAAWshB,IACjDoC,EAAanrB,EAAQrF,OAId0C,EAAI+E,EAAG/E,IACZghB,EAAO5W,EAEHpK,IAAM+tB,IACR/M,EAAO7mB,EAAO0G,MAAMmgB,GAAM,GAAM,GAG5B8M,GACF3zB,EAAO+D,MAAMyE,EAAS0pB,GAAOrL,EAAM,YAIvCzhB,EAASR,KACP8uB,GAAS1zB,EAAOiK,SAAStG,KAAKkC,GAAI,SAChCyrB,GAAa3tB,KAAKkC,GAAI,SACtBlC,KAAKkC,GACPghB,EACAhhB,GAIJ,GAAI8tB,EAOF,IANApU,EAAM/W,EAAQA,EAAQrF,OAAS,GAAGc,cAGlCjE,EAAOgG,IAAIwC,EAASgpB,IAGf3rB,EAAI,EAAGA,EAAI8tB,EAAY9tB,IAC1BghB,EAAOre,EAAQ3C,GACX4qB,GAAYvsB,KAAK2iB,EAAKlkB,MAAQ,MAC/B3C,EAAOyV,MAAMoR,EAAM,eAAiB7mB,EAAOqhB,SAAS9B,EAAKsH,KAEtDA,EAAKxgB,IAEPrG,EAAO6zB,KAAK,CACVC,IAAKjN,EAAKxgB,IACV1D,KAAM,MACNoxB,SAAU,SACVvqB,OAAO,EACP0R,QAAQ,EACR,QAAU,IAGZlb,EAAO6J,YAAYgd,EAAKzc,MAAQyc,EAAK0B,aAAe1B,EAAKtW,WAAa,IAAIvH,QAAQ2nB,GAAc,MAOxG1gB,EAAWvK,EAAQ,KAIvB,OAAO/B,QAgIX3D,EAAOmF,KAAK,CACV6uB,SAAU,SACVC,UAAW,UACXjN,aAAc,SACdkN,YAAa,QACbC,WAAY,gBACX,SAAU3tB,EAAM0Y,GACjBlf,EAAOsB,GAAGkF,GAAQ,SAAUpF,GAO1B,IANA,IAAI4D,EACFa,EAAI,EACJZ,EAAM,GACNmvB,EAASp0B,EAAOoB,GAChBwE,EAAOwuB,EAAOjxB,OAAS,EAElB0C,GAAKD,EAAMC,IAChBb,EAAQa,IAAMD,EAAOjC,KAAOA,KAAK+C,OAAM,GACvC1G,EAAOo0B,EAAOvuB,IAAIqZ,GAAUla,GAG5BxE,EAAUgF,MAAMP,EAAKD,EAAMH,OAG7B,OAAOlB,KAAKoB,UAAUE,OAiC1BjF,EAAOoG,OAAO,CACZM,MAAO,SAAUhD,EAAM6vB,EAAeC,GACpC,IAAIa,EAAcxN,EAAMngB,EAAOb,EAAGyuB,EAChCC,EAASv0B,EAAOqhB,SAAS3d,EAAKO,cAAeP,GAW/C,GATI1D,EAAO6P,QAAQ4B,YAAczR,EAAOgZ,SAAStV,KAAUssB,GAAa9rB,KAAK,IAAMR,EAAKuG,SAAW,KACjGvD,EAAQhD,EAAKgO,WAAU,IAIvB2f,GAAY9gB,UAAY7M,EAAKiO,UAC7B0f,GAAYjd,YAAY1N,EAAQ2qB,GAAYvgB,eAGxC9Q,EAAO6P,QAAQkC,eAAiB/R,EAAO6P,QAAQyC,kBAChC,IAAlB5O,EAAKL,UAAoC,KAAlBK,EAAKL,YAAqBrD,EAAOgZ,SAAStV,GAOlE,IAJA2wB,EAAenC,GAAOxrB,GACtB4tB,EAAcpC,GAAOxuB,GAGhBmC,EAAI,EAA8B,OAA1BghB,EAAOyN,EAAYzuB,MAAeA,EAEzCwuB,EAAaxuB,IACfksB,GAAmBlL,EAAMwN,EAAaxuB,IAM5C,GAAI0tB,EACF,GAAIC,EAIF,IAHAc,EAAcA,GAAepC,GAAOxuB,GACpC2wB,EAAeA,GAAgBnC,GAAOxrB,GAEjCb,EAAI,EAA8B,OAA1BghB,EAAOyN,EAAYzuB,IAAaA,IAC3C8rB,GAAe9K,EAAMwN,EAAaxuB,SAGpC8rB,GAAejuB,EAAMgD,GAazB,OARA2tB,EAAenC,GAAOxrB,EAAO,UACzB2tB,EAAalxB,OAAS,GACxBsuB,GAAc4C,GAAeE,GAAUrC,GAAOxuB,EAAM,WAGtD2wB,EAAeC,EAAczN,EAAO,KAG7BngB,GAGTgC,cAAe,SAAU1D,EAAO3D,EAASmH,EAASgsB,GAWhD,IAVA,IAAIzuB,EAAGrC,EAAM2d,EACXjY,EAAKke,EAAKvW,EAAO+hB,EACjBloB,EAAI5F,EAAM7B,OAGVsxB,EAAOjG,GAAmBntB,GAE1BqzB,EAAQ,GACR7uB,EAAI,EAECA,EAAI+E,EAAG/E,IAGZ,GAFAnC,EAAOsB,EAAMa,GAETnC,GAAiB,IAATA,EAGV,GAA0B,WAAtB1D,EAAO2C,KAAKe,GACd1D,EAAO+D,MAAM2wB,EAAOhxB,EAAKL,SAAW,CAACK,GAAQA,QAGxC,GAAK2sB,GAAMnsB,KAAKR,GAIhB,CACL0F,EAAMA,GAAOqrB,EAAKjkB,YAAYnP,EAAQoH,cAAc,QAGpD6e,GAAO6I,GAAStsB,KAAKH,IAAS,CAAC,GAAI,KAAK,GAAGwG,cAC3C4oB,EAAOlC,GAAQtJ,IAAQsJ,GAAQ/S,SAE/BzU,EAAImH,UAAYuiB,EAAK,GAAKpvB,EAAKsF,QAAQknB,GAAW,aAAe4C,EAAK,GAGtE/sB,EAAI+sB,EAAK,GACT,MAAO/sB,IACLqD,EAAMA,EAAIwJ,UASZ,IALK5S,EAAO6P,QAAQgB,mBAAqBof,GAAmB/rB,KAAKR,IAC/DgxB,EAAMj0B,KAAKY,EAAQsxB,eAAe1C,GAAmBpsB,KAAKH,GAAM,MAI7D1D,EAAO6P,QAAQkB,MAAO,CAGzBrN,EAAe,UAAR4jB,GAAoB8I,GAAOlsB,KAAKR,GAIzB,YAAZovB,EAAK,IAAqB1C,GAAOlsB,KAAKR,GAEpC,EADA0F,EAJFA,EAAI0H,WAON/K,EAAIrC,GAAQA,EAAKkF,WAAWzF,OAC5B,MAAO4C,IACD/F,EAAOiK,SAAU8G,EAAQrN,EAAKkF,WAAW7C,GAAK,WAAagL,EAAMnI,WAAWzF,QAC9EO,EAAK0Q,YAAYrD,GAKvB/Q,EAAO+D,MAAM2wB,EAAOtrB,EAAIR,YAGxBQ,EAAImf,YAAc,GAGlB,MAAOnf,EAAI0H,WACT1H,EAAIgL,YAAYhL,EAAI0H,YAItB1H,EAAMqrB,EAAK7hB,eAtDX8hB,EAAMj0B,KAAKY,EAAQsxB,eAAejvB,IA4DpC0F,GACFqrB,EAAKrgB,YAAYhL,GAKdpJ,EAAO6P,QAAQ6C,eAClB1S,EAAO6K,KAAKqnB,GAAOwC,EAAO,SAAUtC,IAGtCvsB,EAAI,EACJ,MAAQnC,EAAOgxB,EAAM7uB,KAInB,KAAI2uB,IAAkD,IAArCx0B,EAAOwK,QAAQ9G,EAAM8wB,MAItCnT,EAAWrhB,EAAOqhB,SAAS3d,EAAKO,cAAeP,GAG/C0F,EAAM8oB,GAAOuC,EAAKjkB,YAAY9M,GAAO,UAGjC2d,GACFoQ,GAAcroB,GAIZZ,GAAS,CACXzC,EAAI,EACJ,MAAQrC,EAAO0F,EAAIrD,KACb0qB,GAAYvsB,KAAKR,EAAKf,MAAQ,KAChC6F,EAAQ/H,KAAKiD,GAQrB,OAFA0F,EAAM,KAECqrB,GAGTtf,UAAW,SAAUnQ,EAAsByP,GAQzC,IAPA,IAAI/Q,EAAMf,EAAM6B,EAAI6D,EAClBxC,EAAI,EACJ8O,EAAc3U,EAAOkT,QACrB4B,EAAQ9U,EAAO8U,MACfhD,EAAgB9R,EAAO6P,QAAQiC,cAC/B0J,EAAUxb,EAAOyC,MAAM+Y,QAEG,OAApB9X,EAAOsB,EAAMa,IAAaA,IAEhC,IAAI4O,GAAczU,EAAOyU,WAAW/Q,MAElCc,EAAKd,EAAKiR,GACVtM,EAAO7D,GAAMsQ,EAAMtQ,GAEf6D,GAAM,CACR,GAAIA,EAAKgT,OACP,IAAK1Y,KAAQ0F,EAAKgT,OACZG,EAAQ7Y,GACV3C,EAAOyC,MAAMkG,OAAOjF,EAAMf,GAI1B3C,EAAO8c,YAAYpZ,EAAMf,EAAM0F,EAAK0T,QAMtCjH,EAAMtQ,YAEDsQ,EAAMtQ,GAKTsN,SACKpO,EAAKiR,UAEIjR,EAAK0V,kBAAoBxZ,EACzC8D,EAAK0V,gBAAgBzE,GAGrBjR,EAAKiR,GAAe,KAGtBvU,EAAgBK,KAAK+D,QAOjC,IAAImwB,GAAQC,GAAWC,GACrBC,GAAS,kBACTC,GAAW,wBACXC,GAAY,4BAGZC,GAAe,4BACfC,GAAU,UACVC,GAAY,IAAIvY,OAAO,KAAOpb,EAAY,SAAU,KACpD4zB,GAAY,IAAIxY,OAAO,KAAOpb,EAAY,kBAAmB,KAC7D6zB,GAAU,IAAIzY,OAAO,YAAcpb,EAAY,IAAK,KACpD8zB,GAAc,CAAEC,KAAM,SAEtBC,GAAU,CAAEC,SAAU,WAAYC,WAAY,SAAUhiB,QAAS,SACjEiiB,GAAqB,CACnBC,cAAe,EACfC,WAAY,KAGdC,GAAY,CAAC,MAAO,QAAS,SAAU,QACvCC,GAAc,CAAC,SAAU,IAAK,MAAO,MAGvC,SAASC,GAAevlB,EAAOjK,GAG7B,GAAIA,KAAQiK,EACV,OAAOjK,EAIT,IAAIyvB,EAAUzvB,EAAK5C,OAAO,GAAGrB,cAAgBiE,EAAK7F,MAAM,GACtDu1B,EAAW1vB,EACXX,EAAIkwB,GAAY5yB,OAElB,MAAO0C,IAEL,GADAW,EAAOuvB,GAAYlwB,GAAKowB,EACpBzvB,KAAQiK,EACV,OAAOjK,EAIX,OAAO0vB,EAGT,SAASC,GAASzyB,EAAM0yB,GAItB,OADA1yB,EAAO0yB,GAAM1yB,EAC0B,SAAhC1D,EAAOq2B,IAAI3yB,EAAM,aAA0B1D,EAAOqhB,SAAS3d,EAAKO,cAAeP,GAGxF,SAAS4yB,GAASvf,EAAUwf,GAM1B,IALA,IAAI7iB,EAAShQ,EAAM8yB,EACjB7mB,EAAS,GACTjC,EAAQ,EACRvK,EAAS4T,EAAS5T,OAEbuK,EAAQvK,EAAQuK,IACrBhK,EAAOqT,EAASrJ,GACXhK,EAAK+M,QAIVd,EAAOjC,GAAS1N,EAAOyV,MAAM/R,EAAM,cACnCgQ,EAAUhQ,EAAK+M,MAAMiD,QACjB6iB,GAGG5mB,EAAOjC,IAAsB,SAAZgG,IACpBhQ,EAAK+M,MAAMiD,QAAU,IAMI,KAAvBhQ,EAAK+M,MAAMiD,SAAkByiB,GAASzyB,KACxCiM,EAAOjC,GAAS1N,EAAOyV,MAAM/R,EAAM,aAAc+yB,GAAmB/yB,EAAKuG,aAItE0F,EAAOjC,KACV8oB,EAASL,GAASzyB,IAEdgQ,GAAuB,SAAZA,IAAuB8iB,IACpCx2B,EAAOyV,MAAM/R,EAAM,aAAc8yB,EAAS9iB,EAAU1T,EAAOq2B,IAAI3yB,EAAM,cAQ7E,IAAKgK,EAAQ,EAAGA,EAAQvK,EAAQuK,IAC9BhK,EAAOqT,EAASrJ,GACXhK,EAAK+M,QAGL8lB,GAA+B,SAAvB7yB,EAAK+M,MAAMiD,SAA6C,KAAvBhQ,EAAK+M,MAAMiD,UACvDhQ,EAAK+M,MAAMiD,QAAU6iB,EAAO5mB,EAAOjC,IAAU,GAAK,SAItD,OAAOqJ,EAwST,SAAS2f,GAAkBhzB,EAAMyG,EAAOwsB,GACtC,IAAInY,EAAU2W,GAAUtxB,KAAKsG,GAC7B,OAAOqU,EAEL/T,KAAKC,IAAI,EAAG8T,EAAQ,IAAMmY,GAAY,KAAOnY,EAAQ,IAAM,MAC3DrU,EAGJ,SAASysB,GAAqBlzB,EAAM8C,EAAMqwB,EAAOC,EAAaC,GAS5D,IARA,IAAIlxB,EAAIgxB,KAAWC,EAAc,SAAW,WAE1C,EAES,UAATtwB,EAAmB,EAAI,EAEvB+R,EAAM,EAED1S,EAAI,EAAGA,GAAK,EAEH,WAAVgxB,IACFte,GAAOvY,EAAOq2B,IAAI3yB,EAAMmzB,EAAQf,GAAUjwB,IAAI,EAAMkxB,IAGlDD,GAEY,YAAVD,IACFte,GAAOvY,EAAOq2B,IAAI3yB,EAAM,UAAYoyB,GAAUjwB,IAAI,EAAMkxB,IAI5C,WAAVF,IACFte,GAAOvY,EAAOq2B,IAAI3yB,EAAM,SAAWoyB,GAAUjwB,GAAK,SAAS,EAAMkxB,MAInExe,GAAOvY,EAAOq2B,IAAI3yB,EAAM,UAAYoyB,GAAUjwB,IAAI,EAAMkxB,GAG1C,YAAVF,IACFte,GAAOvY,EAAOq2B,IAAI3yB,EAAM,SAAWoyB,GAAUjwB,GAAK,SAAS,EAAMkxB,KAKvE,OAAOxe,EAGT,SAASye,GAAiBtzB,EAAM8C,EAAMqwB,GAGpC,IAAII,GAAmB,EACrB1e,EAAe,UAAT/R,EAAmB9C,EAAKmQ,YAAcnQ,EAAK+P,aACjDsjB,EAASnC,GAAUlxB,GACnBozB,EAAc92B,EAAO6P,QAAQ+D,WAA8D,eAAjD5T,EAAOq2B,IAAI3yB,EAAM,aAAa,EAAOqzB,GAKjF,GAAIxe,GAAO,GAAY,MAAPA,EAAa,CAQ3B,GANAA,EAAMsc,GAAOnxB,EAAM8C,EAAMuwB,IACrBxe,EAAM,GAAY,MAAPA,KACbA,EAAM7U,EAAK+M,MAAMjK,IAIf4uB,GAAUlxB,KAAKqU,GACjB,OAAOA,EAKT0e,EAAmBH,IAAgB92B,EAAO6P,QAAQsC,mBAAqBoG,IAAQ7U,EAAK+M,MAAMjK,IAG1F+R,EAAM3Q,WAAW2Q,IAAQ,EAI3B,OAAQA,EACNqe,GACElzB,EACA8C,EACAqwB,IAAUC,EAAc,SAAW,WACnCG,EACAF,GAEA,KAIN,SAASN,GAAmBxsB,GAC1B,IAAIsV,EAAM1f,EACR6T,EAAU4hB,GAAYrrB,GA0BxB,OAxBKyJ,IACHA,EAAUwjB,GAAcjtB,EAAUsV,GAGlB,SAAZ7L,GAAuBA,IAEzBihB,IAAUA,IACR30B,EAAO,kDACJq2B,IAAI,UAAW,6BAClBrC,SAASzU,EAAI7V,iBAGf6V,GAAOoV,GAAO,GAAGhF,eAAiBgF,GAAO,GAAGjF,iBAAiB7vB,SAC7D0f,EAAI4X,MAAM,+BACV5X,EAAI6X,QAEJ1jB,EAAUwjB,GAAcjtB,EAAUsV,GAClCoV,GAAO9xB,UAITyyB,GAAYrrB,GAAYyJ,GAGnBA,EAIT,SAASwjB,GAAc1wB,EAAM+Y,GAC3B,IAAI7b,EAAO1D,EAAOuf,EAAI9W,cAAcjC,IAAOwtB,SAASzU,EAAInY,MACtDsM,EAAU1T,EAAOq2B,IAAI3yB,EAAK,GAAI,WAEhC,OADAA,EAAKiF,SACE+K,EApaT1T,EAAOsB,GAAG8E,OAAO,CACfiwB,IAAK,SAAU7vB,EAAM2D,GACnB,OAAOnK,EAAOmL,OAAOxH,MAAM,SAAUD,EAAM8C,EAAM2D,GAC/C,IAAIrE,EAAKixB,EACP/wB,EAAM,GACNH,EAAI,EAEN,GAAI7F,EAAO6G,QAAQL,GAAO,CAIxB,IAHAuwB,EAASnC,GAAUlxB,GACnBoC,EAAMU,EAAKrD,OAEJ0C,EAAIC,EAAKD,IACdG,EAAIQ,EAAKX,IAAM7F,EAAOq2B,IAAI3yB,EAAM8C,EAAKX,IAAI,EAAOkxB,GAGlD,OAAO/wB,EAGT,OAAOmE,IAAU1K,EACfO,EAAOyQ,MAAM/M,EAAM8C,EAAM2D,GACzBnK,EAAOq2B,IAAI3yB,EAAM8C,KAClBA,EAAM2D,EAAO1E,UAAUtC,OAAS,IAErCozB,KAAM,WACJ,OAAOD,GAAS3yB,MAAM,IAExB0zB,KAAM,WACJ,OAAOf,GAAS3yB,OAElB2zB,OAAQ,SAAUppB,GAChB,IAAIqpB,EAAwB,mBAAVrpB,EAElB,OAAOvK,KAAKwB,MAAK,YACXoyB,EAAOrpB,EAAQioB,GAASxyB,OAC1B3D,EAAO2D,MAAM4yB,OAEbv2B,EAAO2D,MAAM0zB,aAMrBr3B,EAAOoG,OAAO,CAGZoxB,SAAU,CACRrmB,QAAS,CACPtM,IAAK,SAAUnB,EAAM+zB,GACnB,GAAIA,EAAU,CAEZ,IAAIxyB,EAAM4vB,GAAOnxB,EAAM,WACvB,MAAe,KAARuB,EAAa,IAAMA,MAOlCyyB,UAAW,CACT,aAAe,EACf,aAAe,EACf,YAAc,EACd,YAAc,EACd,SAAW,EACX,SAAW,EACX,QAAU,EACV,QAAU,EACV,MAAQ,GAKVC,SAAU,CAER,MAAS33B,EAAO6P,QAAQuB,SAAW,WAAa,cAIlDX,MAAO,SAAU/M,EAAM8C,EAAM2D,EAAO0sB,GAElC,GAAKnzB,GAA0B,IAAlBA,EAAKL,UAAoC,IAAlBK,EAAKL,UAAmBK,EAAK+M,MAAjE,CAKA,IAAIxL,EAAKtC,EAAMoT,EACbmgB,EAAWl2B,EAAO+J,UAAUvD,GAC5BiK,EAAQ/M,EAAK+M,MASf,GAPAjK,EAAOxG,EAAO23B,SAASzB,KAAcl2B,EAAO23B,SAASzB,GAAYF,GAAevlB,EAAOylB,IAIvFngB,EAAQ/V,EAAOw3B,SAAShxB,IAASxG,EAAOw3B,SAAStB,GAG7C/rB,IAAU1K,EAsCZ,OAAIsW,GAAS,QAASA,IAAU9Q,EAAM8Q,EAAMlR,IAAInB,GAAM,EAAOmzB,MAAYp3B,EAChEwF,EAIFwL,EAAMjK,GAhCb,GAVA7D,SAAcwH,EAGD,WAATxH,IAAsBsC,EAAMowB,GAAQxxB,KAAKsG,MAC3CA,GAASlF,EAAI,GAAK,GAAKA,EAAI,GAAK2C,WAAW5H,EAAOq2B,IAAI3yB,EAAM8C,IAE5D7D,EAAO,YAII,MAATwH,GAA0B,WAATxH,GAAqBgF,MAAMwC,MAKnC,WAATxH,GAAsB3C,EAAO03B,UAAUxB,KACzC/rB,GAAS,MAKNnK,EAAO6P,QAAQuD,iBAA6B,KAAVjJ,GAA+C,IAA/B3D,EAAK3F,QAAQ,gBAClE4P,EAAMjK,GAAQ,YAIXuP,KAAW,QAASA,KAAW5L,EAAQ4L,EAAM0C,IAAI/U,EAAMyG,EAAO0sB,MAAYp3B,GAI7E,IACEgR,EAAMjK,GAAQ2D,EACd,MAAOpC,OAcfsuB,IAAK,SAAU3yB,EAAM8C,EAAMqwB,EAAOE,GAChC,IAAIjyB,EAAKyT,EAAKxC,EACZmgB,EAAWl2B,EAAO+J,UAAUvD,GAyB9B,OAtBAA,EAAOxG,EAAO23B,SAASzB,KAAcl2B,EAAO23B,SAASzB,GAAYF,GAAetyB,EAAK+M,MAAOylB,IAI5FngB,EAAQ/V,EAAOw3B,SAAShxB,IAASxG,EAAOw3B,SAAStB,GAG7CngB,GAAS,QAASA,IACpBwC,EAAMxC,EAAMlR,IAAInB,GAAM,EAAMmzB,IAI1Bte,IAAQ9Y,IACV8Y,EAAMsc,GAAOnxB,EAAM8C,EAAMuwB,IAIf,WAARxe,GAAoB/R,KAAQmvB,KAC9Bpd,EAAMod,GAAmBnvB,IAIb,KAAVqwB,GAAgBA,GAClB/xB,EAAM8C,WAAW2Q,IACA,IAAVse,GAAkB72B,EAAO0H,UAAU5C,GAAOA,GAAO,EAAIyT,GAEvDA,GAITqf,KAAM,SAAUl0B,EAAM+C,EAASrB,EAAUC,GACvC,IAAIJ,EAAKuB,EACPgf,EAAM,GAGR,IAAKhf,KAAQC,EACX+e,EAAIhf,GAAQ9C,EAAK+M,MAAMjK,GACvB9C,EAAK+M,MAAMjK,GAAQC,EAAQD,GAM7B,IAAKA,KAHLvB,EAAMG,EAASI,MAAM9B,EAAM2B,GAAQ,IAGtBoB,EACX/C,EAAK+M,MAAMjK,GAAQgf,EAAIhf,GAGzB,OAAOvB,KAMPzF,EAAOwU,kBACT4gB,GAAY,SAAUlxB,GACpB,OAAOlE,EAAOwU,iBAAiBtQ,EAAM,OAGvCmxB,GAAS,SAAUnxB,EAAM8C,EAAMqxB,GAC7B,IAAI5jB,EAAO6jB,EAAUC,EACnBN,EAAWI,GAAajD,GAAUlxB,GAGlCuB,EAAMwyB,EAAWA,EAASO,iBAAiBxxB,IAASixB,EAASjxB,GAAQ/G,EACrEgR,EAAQ/M,EAAK+M,MA8Bf,OA5BIgnB,IAEU,KAARxyB,GAAejF,EAAOqhB,SAAS3d,EAAKO,cAAeP,KACrDuB,EAAMjF,EAAOyQ,MAAM/M,EAAM8C,IAOvB4uB,GAAUlxB,KAAKe,IAAQiwB,GAAQhxB,KAAKsC,KAGtCyN,EAAQxD,EAAMwD,MACd6jB,EAAWrnB,EAAMqnB,SACjBC,EAAWtnB,EAAMsnB,SAGjBtnB,EAAMqnB,SAAWrnB,EAAMsnB,SAAWtnB,EAAMwD,MAAQhP,EAChDA,EAAMwyB,EAASxjB,MAGfxD,EAAMwD,MAAQA,EACdxD,EAAMqnB,SAAWA,EACjBrnB,EAAMsnB,SAAWA,IAId9yB,IAEApF,EAAS6J,gBAAgBuuB,eAClCrD,GAAY,SAAUlxB,GACpB,OAAOA,EAAKu0B,cAGdpD,GAAS,SAAUnxB,EAAM8C,EAAMqxB,GAC7B,IAAIK,EAAMC,EAAIC,EACZX,EAAWI,GAAajD,GAAUlxB,GAClCuB,EAAMwyB,EAAWA,EAASjxB,GAAQ/G,EAClCgR,EAAQ/M,EAAK+M,MAoCf,OAhCW,MAAPxL,GAAewL,GAASA,EAAMjK,KAChCvB,EAAMwL,EAAMjK,IAUV4uB,GAAUlxB,KAAKe,KAAS+vB,GAAU9wB,KAAKsC,KAGzC0xB,EAAOznB,EAAMynB,KACbC,EAAKz0B,EAAK20B,aACVD,EAASD,GAAMA,EAAGD,KAGdE,IACFD,EAAGD,KAAOx0B,EAAKu0B,aAAaC,MAE9BznB,EAAMynB,KAAgB,aAAT1xB,EAAsB,MAAQvB,EAC3CA,EAAMwL,EAAM6nB,UAAY,KAGxB7nB,EAAMynB,KAAOA,EACTE,IACFD,EAAGD,KAAOE,IAIC,KAARnzB,EAAa,OAASA,IAsIjCjF,EAAOmF,KAAK,CAAC,SAAU,UAAU,SAAUU,EAAGW,GAC5CxG,EAAOw3B,SAAShxB,GAAQ,CACtB3B,IAAK,SAAUnB,EAAM+zB,EAAUZ,GAC7B,GAAIY,EAGF,OAA4B,IAArB/zB,EAAKmQ,aAAqBohB,GAAa/wB,KAAKlE,EAAOq2B,IAAI3yB,EAAM,YAClE1D,EAAO43B,KAAKl0B,EAAM8xB,IAAS,WACzB,OAAOwB,GAAiBtzB,EAAM8C,EAAMqwB,MAEtCG,GAAiBtzB,EAAM8C,EAAMqwB,IAInCpe,IAAK,SAAU/U,EAAMyG,EAAO0sB,GAC1B,IAAIE,EAASF,GAASjC,GAAUlxB,GAChC,OAAOgzB,GAAkBhzB,EAAMyG,EAAO0sB,EACpCD,GACElzB,EACA8C,EACAqwB,EACA72B,EAAO6P,QAAQ+D,WAA8D,eAAjD5T,EAAOq2B,IAAI3yB,EAAM,aAAa,EAAOqzB,GACjEA,GACE,QAMP/2B,EAAO6P,QAAQsB,UAClBnR,EAAOw3B,SAASrmB,QAAU,CACxBtM,IAAK,SAAUnB,EAAM+zB,GAEnB,OAAO1C,GAAS7wB,MAAMuzB,GAAY/zB,EAAKu0B,aAAev0B,EAAKu0B,aAAahZ,OAASvb,EAAK+M,MAAMwO,SAAW,IACpG,IAAOrX,WAAWgV,OAAO2b,IAAO,GACjCd,EAAW,IAAM,IAGrBhf,IAAK,SAAU/U,EAAMyG,GACnB,IAAIsG,EAAQ/M,EAAK+M,MACfwnB,EAAev0B,EAAKu0B,aACpB9mB,EAAUnR,EAAO0H,UAAUyC,GAAS,iBAA2B,IAARA,EAAc,IAAM,GAC3E8U,EAASgZ,GAAgBA,EAAahZ,QAAUxO,EAAMwO,QAAU,GAIlExO,EAAM0D,KAAO,GAIRhK,GAAS,GAAe,KAAVA,IAC2B,KAA5CnK,EAAOmB,KAAK8d,EAAOjW,QAAQ8rB,GAAQ,MACnCrkB,EAAM2I,kBAKN3I,EAAM2I,gBAAgB,UAGR,KAAVjP,GAAgB8tB,IAAiBA,EAAahZ,UAMpDxO,EAAMwO,OAAS6V,GAAO5wB,KAAK+a,GACzBA,EAAOjW,QAAQ8rB,GAAQ3jB,GACvB8N,EAAS,IAAM9N,MAOvBnR,GAAO,WACAA,EAAO6P,QAAQqC,sBAClBlS,EAAOw3B,SAAStjB,YAAc,CAC5BrP,IAAK,SAAUnB,EAAM+zB,GACnB,GAAIA,EAGF,OAAOz3B,EAAO43B,KAAKl0B,EAAM,CAAE,QAAW,gBACpCmxB,GAAQ,CAACnxB,EAAM,oBASpB1D,EAAO6P,QAAQuC,eAAiBpS,EAAOsB,GAAGm0B,UAC7Cz1B,EAAOmF,KAAK,CAAC,MAAO,SAAS,SAAUU,EAAG6R,GACxC1X,EAAOw3B,SAAS9f,GAAQ,CACtB7S,IAAK,SAAUnB,EAAM+zB,GACnB,GAAIA,EAGF,OAFAA,EAAW5C,GAAOnxB,EAAMgU,GAEjB0d,GAAUlxB,KAAKuzB,GACpBz3B,EAAO0D,GAAM+xB,WAAW/d,GAAQ,KAChC+f,UASVz3B,EAAOqc,MAAQrc,EAAOqc,KAAKqR,UAC7B1tB,EAAOqc,KAAKqR,QAAQ8I,OAAS,SAAU9yB,GAGrC,OAAOA,EAAKmQ,aAAe,GAAKnQ,EAAK+P,cAAgB,IACjDzT,EAAO6P,QAAQ8D,uBAAiG,UAAtEjQ,EAAK+M,OAAS/M,EAAK+M,MAAMiD,SAAY1T,EAAOq2B,IAAI3yB,EAAM,aAGtG1D,EAAOqc,KAAKqR,QAAQ8K,QAAU,SAAU90B,GACtC,OAAQ1D,EAAOqc,KAAKqR,QAAQ8I,OAAO9yB,KAKvC1D,EAAOmF,KAAK,CACVszB,OAAQ,GACRC,QAAS,GACTC,OAAQ,UACP,SAAUC,EAAQC,GACnB74B,EAAOw3B,SAASoB,EAASC,GAAU,CACjCC,OAAQ,SAAU3uB,GAOhB,IANA,IAAItE,EAAI,EACNkzB,EAAW,GAGXC,EAAyB,kBAAV7uB,EAAqBA,EAAM8B,MAAM,KAAO,CAAC9B,GAEnDtE,EAAI,EAAGA,IACZkzB,EAASH,EAAS9C,GAAUjwB,GAAKgzB,GAC/BG,EAAMnzB,IAAMmzB,EAAMnzB,EAAI,IAAMmzB,EAAM,GAGtC,OAAOD,IAIN7D,GAAQhxB,KAAK00B,KAChB54B,EAAOw3B,SAASoB,EAASC,GAAQpgB,IAAMie,OAG3C,IAAIuC,GAAM,OACRC,GAAW,QACXC,GAAQ,SACRC,GAAkB,wCAClBC,GAAe,qCAoEjB,SAASC,GAAYV,EAAQ11B,EAAKq2B,EAAajsB,GAC7C,IAAI9G,EAEJ,GAAIxG,EAAO6G,QAAQ3D,GAEjBlD,EAAOmF,KAAKjC,GAAK,SAAU2C,EAAG2zB,GACxBD,GAAeL,GAASh1B,KAAK00B,GAE/BtrB,EAAIsrB,EAAQY,GAIZF,GAAYV,EAAS,KAAoB,kBAANY,EAAiB3zB,EAAI,IAAM,IAAK2zB,EAAGD,EAAajsB,WAIlF,GAAKisB,GAAoC,WAArBv5B,EAAO2C,KAAKO,GAQrCoK,EAAIsrB,EAAQ11B,QANZ,IAAKsD,KAAQtD,EACXo2B,GAAYV,EAAS,IAAMpyB,EAAO,IAAKtD,EAAIsD,GAAO+yB,EAAajsB,GArFrEtN,EAAOsB,GAAG8E,OAAO,CACfqzB,UAAW,WACT,OAAOz5B,EAAO+wB,MAAMptB,KAAK+1B,mBAE3BA,eAAgB,WACd,OAAO/1B,KAAKqC,KAAI,WAEd,IAAI+Q,EAAW/W,EAAO0X,KAAK/T,KAAM,YACjC,OAAOoT,EAAW/W,EAAOyE,UAAUsS,GAAYpT,QAE9Csb,QAAO,WACN,IAAItc,EAAOgB,KAAKhB,KAEhB,OAAOgB,KAAK6C,OAASxG,EAAO2D,MAAMkrB,GAAG,cACnCwK,GAAan1B,KAAKP,KAAKsG,YAAcmvB,GAAgBl1B,KAAKvB,KACzDgB,KAAK0O,UAAYke,GAA4BrsB,KAAKvB,OAEtDqD,KAAI,SAAUH,EAAGnC,GAChB,IAAI6U,EAAMvY,EAAO2D,MAAM4U,MAEvB,OAAc,MAAPA,EACL,KACAvY,EAAO6G,QAAQ0R,GACbvY,EAAOgG,IAAIuS,GAAK,SAAUA,GACxB,MAAO,CAAE/R,KAAM9C,EAAK8C,KAAM2D,MAAOoO,EAAIvP,QAAQmwB,GAAO,YAEtD,CAAE3yB,KAAM9C,EAAK8C,KAAM2D,MAAOoO,EAAIvP,QAAQmwB,GAAO,YAChDt0B,SAMT7E,EAAO+wB,MAAQ,SAAUjhB,EAAGypB,GAC1B,IAAIX,EACFe,EAAI,GACJrsB,EAAM,SAAUtF,EAAKmC,GAEnBA,EAAQnK,EAAOoE,WAAW+F,GAASA,IAAoB,MAATA,EAAgB,GAAKA,EACnEwvB,EAAEA,EAAEx2B,QAAUy2B,mBAAmB5xB,GAAO,IAAM4xB,mBAAmBzvB,IASrE,GALIovB,IAAgB95B,IAClB85B,EAAcv5B,EAAO65B,cAAgB75B,EAAO65B,aAAaN,aAIvDv5B,EAAO6G,QAAQiJ,IAAOA,EAAEvM,SAAWvD,EAAOmE,cAAc2L,GAE1D9P,EAAOmF,KAAK2K,GAAG,WACbxC,EAAI3J,KAAK6C,KAAM7C,KAAKwG,eAMtB,IAAKyuB,KAAU9oB,EACbwpB,GAAYV,EAAQ9oB,EAAE8oB,GAASW,EAAajsB,GAKhD,OAAOqsB,EAAEpd,KAAK,KAAKvT,QAAQiwB,GAAK,MA8BlCj5B,EAAOmF,KAAK,0MAEuD8G,MAAM,MAAM,SAAUpG,EAAGW,GAGxFxG,EAAOsB,GAAGkF,GAAQ,SAAU6B,EAAM/G,GAChC,OAAOmE,UAAUtC,OAAS,EACxBQ,KAAKme,GAAGtb,EAAM,KAAM6B,EAAM/G,GAC1BqC,KAAK4D,QAAQf,OAIrBxG,EAAOsB,GAAGw4B,MAAQ,SAAUC,EAAQC,GAClC,OAAOr2B,KAAKsd,WAAW8Y,GAAQ7Y,WAAW8Y,GAASD,IAErD,IAEEE,GACAC,GACAC,GAAan6B,EAAOwL,MAEpB4uB,GAAc,KACdC,GAAQ,OACRC,GAAM,gBACNC,GAAW,gCAEXC,GAAiB,4DACjBC,GAAa,iBACbC,GAAY,QACZC,GAAO,8CAGPC,GAAQ56B,EAAOsB,GAAG6e,KAWlB0a,GAAa,GAObC,GAAa,GAGbC,GAAW,KAAKx6B,OAAO,KAIzB,IACE25B,GAAep6B,EAASsa,KACxB,MAAOrS,IAGPmyB,GAAer6B,EAAS4I,cAAc,KACtCyxB,GAAa9f,KAAO,GACpB8f,GAAeA,GAAa9f,KAO9B,SAAS4gB,GAA4BC,GAGnC,OAAO,SAAUC,EAAoBltB,GAED,kBAAvBktB,IACTltB,EAAOktB,EACPA,EAAqB,KAGvB,IAAInH,EACFluB,EAAI,EACJs1B,EAAYD,EAAmBhxB,cAAczG,MAAM/B,IAAmB,GAExE,GAAI1B,EAAOoE,WAAW4J,GAEpB,MAAQ+lB,EAAWoH,EAAUt1B,KAEP,MAAhBkuB,EAAS,IACXA,EAAWA,EAASpzB,MAAM,IAAM,KAC/Bs6B,EAAUlH,GAAYkH,EAAUlH,IAAa,IAAI5d,QAAQnI,KAIzDitB,EAAUlH,GAAYkH,EAAUlH,IAAa,IAAItzB,KAAKuN,IAQjE,SAASotB,GAA8BH,EAAWx0B,EAAS40B,EAAiBC,GAE1E,IAAIC,EAAY,GACdC,EAAoBP,IAAcH,GAEpC,SAASW,EAAQ1H,GACf,IAAIxiB,EAYJ,OAXAgqB,EAAUxH,IAAY,EACtB/zB,EAAOmF,KAAK81B,EAAUlH,IAAa,IAAI,SAAU1nB,EAAGqvB,GAClD,IAAIC,EAAsBD,EAAmBj1B,EAAS40B,EAAiBC,GACvE,MAAmC,kBAAxBK,GAAqCH,GAAqBD,EAAUI,GAIpEH,IACAjqB,EAAWoqB,QADf,GAHLl1B,EAAQ00B,UAAUhlB,QAAQwlB,GAC1BF,EAAQE,IACD,MAKJpqB,EAGT,OAAOkqB,EAAQh1B,EAAQ00B,UAAU,MAAQI,EAAU,MAAQE,EAAQ,KAMrE,SAASG,GAAWj1B,EAAQN,GAC1B,IAAIO,EAAMoB,EACR6zB,EAAc77B,EAAO65B,aAAagC,aAAe,GAEnD,IAAK7zB,KAAO3B,EACNA,EAAI2B,KAASvI,KACdo8B,EAAY7zB,GAAOrB,EAAUC,IAASA,EAAO,KAAMoB,GAAO3B,EAAI2B,IAOnE,OAJIpB,GACF5G,EAAOoG,QAAO,EAAMO,EAAQC,GAGvBD,EAmkBT,SAASm1B,GAAoBnC,EAAG2B,EAAOS,GACrC,IAAIC,EAAeC,EAAIC,EAAev5B,EACpCsrB,EAAW0L,EAAE1L,SACbkN,EAAYxB,EAAEwB,UACdgB,EAAiBxC,EAAEwC,eAGrB,IAAKx5B,KAAQw5B,EACPx5B,KAAQo5B,IACVT,EAAMa,EAAex5B,IAASo5B,EAAUp5B,IAK5C,MAAwB,MAAjBw4B,EAAU,GACfA,EAAUhuB,QACN8uB,IAAOx8B,IACTw8B,EAAKtC,EAAEyC,UAAYd,EAAMe,kBAAkB,iBAK/C,GAAIJ,EACF,IAAKt5B,KAAQsrB,EACX,GAAIA,EAAStrB,IAASsrB,EAAStrB,GAAMuB,KAAK+3B,GAAK,CAC7Cd,EAAUhlB,QAAQxT,GAClB,MAMN,GAAIw4B,EAAU,KAAMY,EAClBG,EAAgBf,EAAU,OACrB,CAEL,IAAKx4B,KAAQo5B,EAAW,CACtB,IAAKZ,EAAU,IAAMxB,EAAE2C,WAAW35B,EAAO,IAAMw4B,EAAU,IAAK,CAC5De,EAAgBv5B,EAChB,MAEGq5B,IACHA,EAAgBr5B,GAIpBu5B,EAAgBA,GAAiBF,EAMnC,GAAIE,EAIF,OAHIA,IAAkBf,EAAU,IAC9BA,EAAUhlB,QAAQ+lB,GAEbH,EAAUG,GAKrB,SAASK,GAAY5C,EAAG6C,GACtB,IAAIC,EAAOC,EAASC,EAAMvzB,EACxBkzB,EAAa,GACbz2B,EAAI,EAEJs1B,EAAYxB,EAAEwB,UAAUx6B,QACxButB,EAAOiN,EAAU,GAQnB,GALIxB,EAAEiD,aACJJ,EAAW7C,EAAEiD,WAAWJ,EAAU7C,EAAE5F,WAIlCoH,EAAU,GACZ,IAAKwB,KAAQhD,EAAE2C,WACbA,EAAWK,EAAKzyB,eAAiByvB,EAAE2C,WAAWK,GAKlD,KAAQD,EAAUvB,IAAYt1B,IAG5B,GAAgB,MAAZ62B,EAAiB,CAGnB,GAAa,MAATxO,GAAgBA,IAASwO,EAAS,CAMpC,GAHAC,EAAOL,EAAWpO,EAAO,IAAMwO,IAAYJ,EAAW,KAAOI,IAGxDC,EACH,IAAKF,KAASH,EAIZ,GADAlzB,EAAMqzB,EAAMxwB,MAAM,KACd7C,EAAI,KAAOszB,IAGbC,EAAOL,EAAWpO,EAAO,IAAM9kB,EAAI,KACjCkzB,EAAW,KAAOlzB,EAAI,IACpBuzB,GAAM,EAEK,IAATA,EACFA,EAAOL,EAAWG,IAGa,IAAtBH,EAAWG,KACpBC,EAAUtzB,EAAI,GACd+xB,EAAUh1B,OAAON,IAAK,EAAG62B,IAG3B,MAOR,IAAa,IAATC,EAGF,GAAIA,GAAQhD,EAAE,UACZ6C,EAAWG,EAAKH,QAEhB,IACEA,EAAWG,EAAKH,GAChB,MAAOz0B,IACP,MAAO,CAAEmG,MAAO,cAAehG,MAAOy0B,EAAO50B,GAAI,sBAAwBmmB,EAAO,OAASwO,IAOjGxO,EAAOwO,EAIX,MAAO,CAAExuB,MAAO,UAAW7F,KAAMm0B,GA5xBnCvC,GAAeU,GAAK92B,KAAKq2B,GAAahwB,gBAAkB,GA8ExDlK,EAAOsB,GAAG6e,KAAO,SAAU2T,EAAK+I,EAAQz3B,GACtC,GAAmB,kBAAR0uB,GAAoB8G,GAC7B,OAAOA,GAAMp1B,MAAM7B,KAAM8B,WAG3B,IAAIrE,EAAUo7B,EAAU75B,EACtByK,EAAOzJ,KACP6D,EAAMssB,EAAIjzB,QAAQ,KA+CpB,OA7CI2G,GAAO,IACTpG,EAAW0yB,EAAInzB,MAAM6G,EAAKssB,EAAI3wB,QAC9B2wB,EAAMA,EAAInzB,MAAM,EAAG6G,IAIjBxH,EAAOoE,WAAWy4B,IAGpBz3B,EAAWy3B,EACXA,EAASp9B,GAGAo9B,GAA4B,kBAAXA,IAC1Bl6B,EAAO,QAILyK,EAAKjK,OAAS,GAChBnD,EAAO6zB,KAAK,CACVC,IAAKA,EAGLnxB,KAAMA,EACNoxB,SAAU,OACV1rB,KAAMw0B,IACLt3B,MAAK,SAAUu3B,GAGhBN,EAAW/2B,UAEX2H,EAAKylB,KAAKzxB,EAIRpB,EAAO,SAAS0yB,OAAO1yB,EAAOgE,UAAU84B,IAAeh5B,KAAK1C,GAG5D07B,MAEDC,SAAS33B,GAAY,SAAUk2B,EAAO0B,GACvC5vB,EAAKjI,KAAKC,EAAUo3B,GAAY,CAAClB,EAAMwB,aAAcE,EAAQ1B,MAI1D33B,MAIT3D,EAAOmF,KAAK,CAAC,YAAa,WAAY,eAAgB,YAAa,cAAe,aAAa,SAAUU,EAAGlD,GAC1G3C,EAAOsB,GAAGqB,GAAQ,SAAUrB,GAC1B,OAAOqC,KAAKme,GAAGnf,EAAMrB,OAIzBtB,EAAOmF,KAAK,CAAC,MAAO,SAAS,SAAUU,EAAGo3B,GACxCj9B,EAAOi9B,GAAU,SAAUnJ,EAAKzrB,EAAMjD,EAAUzC,GAQ9C,OANI3C,EAAOoE,WAAWiE,KACpB1F,EAAOA,GAAQyC,EACfA,EAAWiD,EACXA,EAAO5I,GAGFO,EAAO6zB,KAAK,CACjBC,IAAKA,EACLnxB,KAAMs6B,EACNlJ,SAAUpxB,EACV0F,KAAMA,EACN60B,QAAS93B,QAKfpF,EAAOoG,OAAO,CAGZ+2B,OAAQ,EAGRC,aAAc,GACdC,KAAM,GAENxD,aAAc,CACZ/F,IAAKoG,GACLv3B,KAAM,MACN26B,QAAS9C,GAAet2B,KAAK+1B,GAAa,IAC1C/e,QAAQ,EACRqiB,aAAa,EACb/zB,OAAO,EACPg0B,YAAa,mDAabC,QAAS,CACP,IAAK1C,GACL3wB,KAAM,aACNyoB,KAAM,YACN1pB,IAAK,4BACLu0B,KAAM,qCAGRzP,SAAU,CACR9kB,IAAK,MACL0pB,KAAM,OACN6K,KAAM,QAGRvB,eAAgB,CACdhzB,IAAK,cACLiB,KAAM,gBAKRkyB,WAAY,CAGV,SAAU98B,EAAOsI,OAGjB,aAAa,EAGb,YAAa9H,EAAO6I,UAGpB,WAAY7I,EAAOkJ,UAOrB2yB,YAAa,CACX/H,KAAK,EACLzyB,SAAS,IAObs8B,UAAW,SAAUh3B,EAAQi3B,GAC3B,OAAOA,EAGLhC,GAAWA,GAAWj1B,EAAQ3G,EAAO65B,cAAe+D,GAGpDhC,GAAW57B,EAAO65B,aAAclzB,IAGpCk3B,cAAe7C,GAA4BH,IAC3CiD,cAAe9C,GAA4BF,IAG3CjH,KAAM,SAAUC,EAAKrtB,GAGA,kBAARqtB,IACTrtB,EAAUqtB,EACVA,EAAMr0B,GAIRgH,EAAUA,GAAW,GAErB,IACEuyB,EAEAnzB,EAEAk4B,EAEAC,EAEAC,EAGAC,EAEAC,EAEAC,EAEAzE,EAAI35B,EAAO29B,UAAU,GAAIl3B,GAEzB43B,EAAkB1E,EAAEt4B,SAAWs4B,EAE/B2E,EAAqB3E,EAAEt4B,UAAYg9B,EAAgBh7B,UAAYg7B,EAAgB96B,QAC7EvD,EAAOq+B,GACPr+B,EAAOyC,MAET2L,EAAWpO,EAAO2L,WAClB4yB,EAAmBv+B,EAAOuM,UAAU,eAEpCiyB,EAAa7E,EAAE6E,YAAc,GAE7BC,EAAiB,GACjBC,EAAsB,GAEtBxwB,EAAQ,EAERywB,EAAW,WAEXrD,EAAQ,CACN14B,WAAY,EAGZy5B,kBAAmB,SAAUr0B,GAC3B,IAAIvE,EACJ,GAAc,IAAVyK,EAAa,CACf,IAAKkwB,EAAiB,CACpBA,EAAkB,GAClB,MAAQ36B,EAAQ82B,GAAS12B,KAAKm6B,GAC5BI,EAAgB36B,EAAM,GAAGyG,eAAiBzG,EAAM,GAGpDA,EAAQ26B,EAAgBp2B,EAAIkC,eAE9B,OAAgB,MAATzG,EAAgB,KAAOA,GAIhCm7B,sBAAuB,WACrB,OAAiB,IAAV1wB,EAAc8vB,EAAwB,MAI/Ca,iBAAkB,SAAUr4B,EAAM2D,GAChC,IAAI20B,EAAQt4B,EAAK0D,cAKjB,OAJKgE,IACH1H,EAAOk4B,EAAoBI,GAASJ,EAAoBI,IAAUt4B,EAClEi4B,EAAej4B,GAAQ2D,GAElBxG,MAITo7B,iBAAkB,SAAUp8B,GAI1B,OAHKuL,IACHyrB,EAAEyC,SAAWz5B,GAERgB,MAIT66B,WAAY,SAAUx4B,GACpB,IAAIg5B,EACJ,GAAIh5B,EACF,GAAIkI,EAAQ,EACV,IAAK8wB,KAAQh5B,EAEXw4B,EAAWQ,GAAQ,CAACR,EAAWQ,GAAOh5B,EAAIg5B,SAI5C1D,EAAMntB,OAAOnI,EAAIs1B,EAAM0B,SAG3B,OAAOr5B,MAITs7B,MAAO,SAAUC,GACf,IAAIC,EAAYD,GAAcP,EAK9B,OAJIR,GACFA,EAAUc,MAAME,GAElB55B,EAAK,EAAG45B,GACDx7B,OAwCb,GAnCAyK,EAAS9I,QAAQg2B,GAAOyB,SAAWwB,EAAiBjxB,IACpDguB,EAAM4B,QAAU5B,EAAM/1B,KACtB+1B,EAAMpzB,MAAQozB,EAAMjtB,KAMpBsrB,EAAE7F,MAAQA,GAAO6F,EAAE7F,KAAOoG,IAAgB,IAAIlxB,QAAQqxB,GAAO,IAAIrxB,QAAQ0xB,GAAWT,GAAa,GAAK,MAGtGN,EAAEh3B,KAAO8D,EAAQw2B,QAAUx2B,EAAQ9D,MAAQg3B,EAAEsD,QAAUtD,EAAEh3B,KAGzDg3B,EAAEwB,UAAYn7B,EAAOmB,KAAKw4B,EAAE5F,UAAY,KAAK7pB,cAAczG,MAAM/B,IAAmB,CAAC,IAGhE,MAAjBi4B,EAAEyF,cACJpG,EAAQ2B,GAAK92B,KAAK81B,EAAE7F,IAAI5pB,eACxByvB,EAAEyF,eAAiBpG,GAChBA,EAAM,KAAOiB,GAAa,IAAMjB,EAAM,KAAOiB,GAAa,KACxDjB,EAAM,KAAoB,UAAbA,EAAM,GAAiB,GAAK,QACzCiB,GAAa,KAA2B,UAApBA,GAAa,GAAiB,GAAK,QAK1DN,EAAEtxB,MAAQsxB,EAAE4D,aAAiC,kBAAX5D,EAAEtxB,OACtCsxB,EAAEtxB,KAAOrI,EAAO+wB,MAAM4I,EAAEtxB,KAAMsxB,EAAEJ,cAIlC6B,GAA8BP,GAAYlB,EAAGlzB,EAAS60B,GAGxC,IAAVptB,EACF,OAAOotB,EAmET,IAAKz1B,KA/DLq4B,EAAcvE,EAAEze,OAGZgjB,GAAmC,IAApBl+B,EAAOm9B,UACxBn9B,EAAOyC,MAAM8E,QAAQ,aAIvBoyB,EAAEh3B,KAAOg3B,EAAEh3B,KAAKJ,cAGhBo3B,EAAE0F,YAAc5E,GAAWv2B,KAAKy1B,EAAEh3B,MAIlCo7B,EAAWpE,EAAE7F,IAGR6F,EAAE0F,aAGD1F,EAAEtxB,OACJ01B,EAAYpE,EAAE7F,MAAQsG,GAAYl2B,KAAK65B,GAAY,IAAM,KAAOpE,EAAEtxB,YAE3DsxB,EAAEtxB,OAIK,IAAZsxB,EAAE7kB,QACJ6kB,EAAE7F,IAAMwG,GAAIp2B,KAAK65B,GAGfA,EAAS/0B,QAAQsxB,GAAK,OAASH,MAG/B4D,GAAY3D,GAAYl2B,KAAK65B,GAAY,IAAM,KAAO,KAAO5D,OAK/DR,EAAE2F,aACAt/B,EAAOo9B,aAAaW,IACtBzC,EAAMuD,iBAAiB,oBAAqB7+B,EAAOo9B,aAAaW,IAE9D/9B,EAAOq9B,KAAKU,IACdzC,EAAMuD,iBAAiB,gBAAiB7+B,EAAOq9B,KAAKU,MAKpDpE,EAAEtxB,MAAQsxB,EAAE0F,aAAgC,IAAlB1F,EAAE6D,aAAyB/2B,EAAQ+2B,cAC/DlC,EAAMuD,iBAAiB,eAAgBlF,EAAE6D,aAI3ClC,EAAMuD,iBACJ,SACAlF,EAAEwB,UAAU,IAAMxB,EAAE8D,QAAQ9D,EAAEwB,UAAU,IACtCxB,EAAE8D,QAAQ9D,EAAEwB,UAAU,KAA0B,MAAnBxB,EAAEwB,UAAU,GAAa,KAAOJ,GAAW,WAAa,IACrFpB,EAAE8D,QAAQ,MAIJ9D,EAAE4F,QACVjE,EAAMuD,iBAAiBh5B,EAAG8zB,EAAE4F,QAAQ15B,IAItC,GAAI8zB,EAAE6F,cAAgE,IAAjD7F,EAAE6F,WAAW56B,KAAKy5B,EAAiB/C,EAAO3B,IAA0B,IAAVzrB,GAE7E,OAAOotB,EAAM2D,QAOf,IAAKp5B,KAHL84B,EAAW,QAGD,CAAEzB,QAAS,EAAGh1B,MAAO,EAAG60B,SAAU,GAC1CzB,EAAMz1B,GAAG8zB,EAAE9zB,IAOb,GAHAs4B,EAAY/C,GAA8BN,GAAYnB,EAAGlzB,EAAS60B,GAG7D6C,EAEE,CACL7C,EAAM14B,WAAa,EAGfs7B,GACFI,EAAmB/2B,QAAQ,WAAY,CAAC+zB,EAAO3B,IAG7CA,EAAEnwB,OAASmwB,EAAEjjB,QAAU,IACzBunB,EAAe52B,YAAW,WACxBi0B,EAAM2D,MAAM,aACXtF,EAAEjjB,UAGP,IACExI,EAAQ,EACRiwB,EAAUsB,KAAKhB,EAAgBl5B,GAC/B,MAAOwC,IAEP,KAAImG,EAAQ,GAIV,MAAMnG,GAHNxC,GAAM,EAAGwC,UArBbxC,GAAM,EAAG,gBA8BX,SAASA,EAAKy3B,EAAQ0C,EAAkB3D,EAAWwD,GACjD,IAAII,EAAWzC,EAASh1B,EAAOs0B,EAAUoD,EACvCV,EAAaQ,EAGD,IAAVxxB,IAKJA,EAAQ,EAGJ+vB,GACFtnB,aAAasnB,GAKfE,EAAY1+B,EAGZu+B,EAAwBuB,GAAW,GAGnCjE,EAAM14B,WAAao6B,EAAS,EAAI,EAAI,EAGhCjB,IACFS,EAAWV,GAAoBnC,EAAG2B,EAAOS,IAIvCiB,GAAU,KAAOA,EAAS,KAAkB,MAAXA,GAG/BrD,EAAE2F,aACJM,EAAWtE,EAAMe,kBAAkB,iBAC/BuD,IACF5/B,EAAOo9B,aAAaW,GAAY6B,GAElCA,EAAWtE,EAAMe,kBAAkB,QAC/BuD,IACF5/B,EAAOq9B,KAAKU,GAAY6B,IAKb,MAAX5C,GACF2C,GAAY,EACZT,EAAa,aAGO,MAAXlC,GACT2C,GAAY,EACZT,EAAa,gBAIbS,EAAYpD,GAAY5C,EAAG6C,GAC3B0C,EAAaS,EAAUzxB,MACvBgvB,EAAUyC,EAAUt3B,KACpBH,EAAQy3B,EAAUz3B,MAClBy3B,GAAaz3B,KAKfA,EAAQg3B,GACJlC,GAAWkC,IACbA,EAAa,QACTlC,EAAS,IACXA,EAAS,KAMf1B,EAAM0B,OAASA,EACf1B,EAAM4D,YAAcQ,GAAoBR,GAAc,GAGlDS,EACFvxB,EAAS9G,YAAY+2B,EAAiB,CAACnB,EAASgC,EAAY5D,IAE5DltB,EAASyxB,WAAWxB,EAAiB,CAAC/C,EAAO4D,EAAYh3B,IAI3DozB,EAAMkD,WAAWA,GACjBA,EAAa/+B,EAETy+B,GACFI,EAAmB/2B,QAAQo4B,EAAY,cAAgB,YACrD,CAACrE,EAAO3B,EAAGgG,EAAYzC,EAAUh1B,IAIrCq2B,EAAiBxwB,SAASswB,EAAiB,CAAC/C,EAAO4D,IAE/ChB,IACFI,EAAmB/2B,QAAQ,eAAgB,CAAC+zB,EAAO3B,MAE3C35B,EAAOm9B,QACbn9B,EAAOyC,MAAM8E,QAAQ,cAK3B,OAAO+zB,GAGTwE,UAAW,SAAUhM,EAAK1uB,GACxB,OAAOpF,EAAO6E,IAAIivB,EAAKr0B,EAAW2F,EAAU,WAG9C26B,QAAS,SAAUjM,EAAKzrB,EAAMjD,GAC5B,OAAOpF,EAAO6E,IAAIivB,EAAKzrB,EAAMjD,EAAU,WA0J3CpF,EAAO29B,UAAU,CACfF,QAAS,CACPuC,OAAQ,6FAEV/R,SAAU,CACR+R,OAAQ,uBAEV1D,WAAY,CACV,cAAe,SAAUlyB,GAEvB,OADApK,EAAO6J,WAAWO,GACXA,MAMbpK,EAAO69B,cAAc,UAAU,SAAUlE,GACnCA,EAAE7kB,QAAUrV,IACdk6B,EAAE7kB,OAAQ,GAER6kB,EAAEyF,cACJzF,EAAEh3B,KAAO,MACTg3B,EAAEze,QAAS,MAKflb,EAAO89B,cAAc,UAAU,SAAUnE,GAGvC,GAAIA,EAAEyF,YAAa,CAEjB,IAAIY,EACFC,EAAOpgC,EAASogC,MAAQjgC,EAAO,QAAQ,IAAMH,EAAS6J,gBAExD,MAAO,CAEL+1B,KAAM,SAAUpzB,EAAGjH,GAEjB46B,EAASngC,EAAS4I,cAAc,UAEhCu3B,EAAOx2B,OAAQ,EAEXmwB,EAAEuG,gBACJF,EAAOG,QAAUxG,EAAEuG,eAGrBF,EAAO35B,IAAMszB,EAAE7F,IAGfkM,EAAOI,OAASJ,EAAOK,mBAAqB,SAAUh0B,EAAGi0B,IAEnDA,IAAYN,EAAOp9B,YAAc,kBAAkBsB,KAAK87B,EAAOp9B,eAGjEo9B,EAAOI,OAASJ,EAAOK,mBAAqB,KAGxCL,EAAOz7B,YACTy7B,EAAOz7B,WAAW6P,YAAY4rB,GAIhCA,EAAS,KAGJM,GACHl7B,EAAS,IAAK,aAOpB66B,EAAKjZ,aAAagZ,EAAQC,EAAKnvB,aAGjCmuB,MAAO,WACDe,GACFA,EAAOI,OAAO3gC,GAAW,SAMnC,IAAI8gC,GAAe,GACjBC,GAAS,oBAGXxgC,EAAO29B,UAAU,CACf8C,MAAO,WACPC,cAAe,WACb,IAAIt7B,EAAWm7B,GAAaxrB,OAAU/U,EAAOkT,QAAU,IAAOinB,KAE9D,OADAx2B,KAAKyB,IAAY,EACVA,KAKXpF,EAAO69B,cAAc,cAAc,SAAUlE,EAAGgH,EAAkBrF,GAEhE,IAAIsF,EAAcC,EAAaC,EAC7BC,GAAuB,IAAZpH,EAAE8G,QAAoBD,GAAOt8B,KAAKy1B,EAAE7F,KAC7C,MACkB,kBAAX6F,EAAEtxB,QAAuBsxB,EAAE6D,aAAe,IAAI38B,QAAQ,sCAAwC2/B,GAAOt8B,KAAKy1B,EAAEtxB,OAAS,QAIhI,GAAI04B,GAA+B,UAAnBpH,EAAEwB,UAAU,GAsD1B,OAnDAyF,EAAejH,EAAE+G,cAAgB1gC,EAAOoE,WAAWu1B,EAAE+G,eACnD/G,EAAE+G,gBACF/G,EAAE+G,cAGAK,EACFpH,EAAEoH,GAAYpH,EAAEoH,GAAU/3B,QAAQw3B,GAAQ,KAAOI,IAC5B,IAAZjH,EAAE8G,QACX9G,EAAE7F,MAAQsG,GAAYl2B,KAAKy1B,EAAE7F,KAAO,IAAM,KAAO6F,EAAE8G,MAAQ,IAAMG,GAInEjH,EAAE2C,WAAW,eAAiB,WAI5B,OAHKwE,GACH9gC,EAAOkI,MAAM04B,EAAe,mBAEvBE,EAAkB,IAI3BnH,EAAEwB,UAAU,GAAK,OAGjB0F,EAAcrhC,EAAOohC,GACrBphC,EAAOohC,GAAgB,WACrBE,EAAoBr7B,WAItB61B,EAAMntB,QAAO,WAEX3O,EAAOohC,GAAgBC,EAGnBlH,EAAEiH,KAEJjH,EAAE+G,cAAgBC,EAAiBD,cAGnCH,GAAa9/B,KAAKmgC,IAIhBE,GAAqB9gC,EAAOoE,WAAWy8B,IACzCA,EAAYC,EAAkB,IAGhCA,EAAoBD,EAAcphC,KAI7B,YAGX,IAAIuhC,GAAcC,GAChBC,GAAQ,EAERC,GAAmB3hC,EAAO+J,eAAiB,WAEzC,IAAIvB,EACJ,IAAKA,KAAOg5B,GACVA,GAAah5B,GAAKvI,GAAW,IAKnC,SAAS2hC,KACP,IACE,OAAO,IAAI5hC,EAAO6hC,eAClB,MAAOt5B,MAGX,SAASu5B,KACP,IACE,OAAO,IAAI9hC,EAAO+J,cAAc,qBAChC,MAAOxB,MAKX/H,EAAO65B,aAAa0H,IAAM/hC,EAAO+J,cAO/B,WACE,OAAQ5F,KAAK25B,SAAW8D,MAAuBE,MAGjDF,GAGFH,GAAejhC,EAAO65B,aAAa0H,MACnCvhC,EAAO6P,QAAQ2xB,OAASP,IAAiB,oBAAqBA,GAC9DA,GAAejhC,EAAO6P,QAAQgkB,OAASoN,GAGnCA,IAEFjhC,EAAO89B,eAAc,SAAUnE,GAI3B,IAAIv0B,EAFN,IAAKu0B,EAAEyF,aAAep/B,EAAO6P,QAAQ2xB,KAInC,MAAO,CACL/B,KAAM,SAAUF,EAASxC,GAGvB,IAAIhhB,EAAQlW,EACV07B,EAAM5H,EAAE4H,MAWV,GAPI5H,EAAE8H,SACJF,EAAIG,KAAK/H,EAAEh3B,KAAMg3B,EAAE7F,IAAK6F,EAAEnwB,MAAOmwB,EAAE8H,SAAU9H,EAAEpP,UAE/CgX,EAAIG,KAAK/H,EAAEh3B,KAAMg3B,EAAE7F,IAAK6F,EAAEnwB,OAIxBmwB,EAAEgI,UACJ,IAAK97B,KAAK8zB,EAAEgI,UACVJ,EAAI17B,GAAK8zB,EAAEgI,UAAU97B,GAKrB8zB,EAAEyC,UAAYmF,EAAIxC,kBACpBwC,EAAIxC,iBAAiBpF,EAAEyC,UAQpBzC,EAAEyF,aAAgBG,EAAQ,sBAC7BA,EAAQ,oBAAsB,kBAIhC,IACE,IAAK15B,KAAK05B,EACRgC,EAAI1C,iBAAiBh5B,EAAG05B,EAAQ15B,IAElC,MAAO+7B,IAKTL,EAAI9B,KAAM9F,EAAE0F,YAAc1F,EAAEtxB,MAAS,MAGrCjD,EAAW,SAAUiH,EAAGi0B,GACtB,IAAItD,EAAQoB,EAAiBc,EAAYnD,EAKzC,IAGE,GAAI32B,IAAak7B,GAA8B,IAAnBiB,EAAI3+B,YAc9B,GAXAwC,EAAW3F,EAGPsc,IACFwlB,EAAIlB,mBAAqBrgC,EAAO4J,KAC5Bu3B,WACKH,GAAajlB,IAKpBukB,EAEqB,IAAnBiB,EAAI3+B,YACN2+B,EAAItC,YAED,CACLlD,EAAY,GACZiB,EAASuE,EAAIvE,OACboB,EAAkBmD,EAAI3C,wBAIU,kBAArB2C,EAAIzE,eACbf,EAAU3xB,KAAOm3B,EAAIzE,cAKvB,IACEoC,EAAaqC,EAAIrC,WACjB,MAAOn3B,IAEPm3B,EAAa,GAQVlC,IAAUrD,EAAE2D,SAAY3D,EAAEyF,YAGT,OAAXpC,IACTA,EAAS,KAHTA,EAASjB,EAAU3xB,KAAO,IAAM,KAOtC,MAAOy3B,GACFvB,GACHvD,GAAU,EAAG8E,GAKb9F,GACFgB,EAASC,EAAQkC,EAAYnD,EAAWqC,IAIvCzE,EAAEnwB,MAGuB,IAAnB+3B,EAAI3+B,WAGbyE,WAAWjC,IAEX2W,IAAWmlB,GACPC,KAGGH,KACHA,GAAe,GACfhhC,EAAOR,GAAQsiC,OAAOX,KAGxBH,GAAajlB,GAAU3W,GAEzBm8B,EAAIlB,mBAAqBj7B,GAjBzBA,KAqBJ65B,MAAO,WACD75B,GACFA,EAAS3F,GAAW,QAOhC,IAAIsiC,GAAOC,GACTC,GAAW,yBACXC,GAAS,IAAItlB,OAAO,iBAAmBpb,EAAY,cAAe,KAClE2gC,GAAO,cACPC,GAAsB,CAACC,IACvBC,GAAW,CACT,IAAK,CAAC,SAAU5qB,EAAMvN,GACpB,IAAIlE,EAAKs8B,EACPC,EAAQ7+B,KAAK8+B,YAAY/qB,EAAMvN,GAC/B6uB,EAAQkJ,GAAOr+B,KAAKsG,GACpBxD,EAAS67B,EAAMtsB,MACf3I,GAAS5G,GAAU,EACnB+7B,EAAQ,EACRC,EAAgB,GAElB,GAAI3J,EAAO,CAKT,GAJA/yB,GAAO+yB,EAAM,GACbuJ,EAAOvJ,EAAM,KAAOh5B,EAAO03B,UAAUhgB,GAAQ,GAAK,MAGrC,OAAT6qB,GAAiBh1B,EAAO,CAI1BA,EAAQvN,EAAOq2B,IAAImM,EAAM9+B,KAAMgU,GAAM,IAASzR,GAAO,EAErD,GAGEy8B,EAAQA,GAAS,KAGjBn1B,GAAgBm1B,EAChB1iC,EAAOyQ,MAAM+xB,EAAM9+B,KAAMgU,EAAMnK,EAAQg1B,SAIhCG,KAAWA,EAAQF,EAAMtsB,MAAQvP,IAAqB,IAAV+7B,KAAiBC,GAGxEH,EAAMD,KAAOA,EACbC,EAAMj1B,MAAQA,EAEdi1B,EAAMv8B,IAAM+yB,EAAM,GAAKzrB,GAASyrB,EAAM,GAAK,GAAK/yB,EAAMA,EAExD,OAAOu8B,KAKb,SAASI,KAIP,OAHAv7B,YAAW,WACT06B,GAAQtiC,KAEFsiC,GAAQ/hC,EAAOwL,MAGzB,SAASq3B,GAAaC,EAAWhkB,GAC/B9e,EAAOmF,KAAK2Z,GAAO,SAAUpH,EAAMvN,GAIjC,IAHA,IAAI44B,GAAcT,GAAS5qB,IAAS,IAAInX,OAAO+hC,GAAS,MACtD50B,EAAQ,EACRvK,EAAS4/B,EAAW5/B,OACfuK,EAAQvK,EAAQuK,IACrB,GAAIq1B,EAAWr1B,GAAO9I,KAAKk+B,EAAWprB,EAAMvN,GAG1C,UAMR,SAAS64B,GAAUt/B,EAAMu/B,EAAYx8B,GACnC,IAAI6W,EACF4lB,EACAx1B,EAAQ,EACRvK,EAASi/B,GAAoBj/B,OAC7BiL,EAAWpO,EAAO2L,WAAWwC,QAAO,kBAE3Bg1B,EAAKz/B,QAEdy/B,EAAO,WACL,GAAID,EACF,OAAO,EAUT,IARA,IAAIE,EAAcrB,IAASa,KACzBpzB,EAAY/E,KAAKC,IAAI,EAAGo4B,EAAUO,UAAYP,EAAUQ,SAAWF,GAEnEtX,EAAOtc,EAAYszB,EAAUQ,UAAY,EACzCC,EAAU,EAAIzX,EACdpe,EAAQ,EACRvK,EAAS2/B,EAAUU,OAAOrgC,OAErBuK,EAAQvK,EAAQuK,IACrBo1B,EAAUU,OAAO91B,GAAO+1B,IAAIF,GAK9B,OAFAn1B,EAASwB,WAAWlM,EAAM,CAACo/B,EAAWS,EAAS/zB,IAE3C+zB,EAAU,GAAKpgC,EACVqM,GAEPpB,EAAS9G,YAAY5D,EAAM,CAACo/B,KACrB,IAGXA,EAAY10B,EAAS9I,QAAQ,CAC3B5B,KAAMA,EACNob,MAAO9e,EAAOoG,OAAO,GAAI68B,GACzBS,KAAM1jC,EAAOoG,QAAO,EAAM,CAAEu9B,cAAe,IAAMl9B,GACjDm9B,mBAAoBX,EACpB5H,gBAAiB50B,EACjB48B,UAAWtB,IAASa,KACpBU,SAAU78B,EAAQ68B,SAClBE,OAAQ,GACRf,YAAa,SAAU/qB,EAAMzR,GAC3B,IAAIu8B,EAAQxiC,EAAO6jC,MAAMngC,EAAMo/B,EAAUY,KAAMhsB,EAAMzR,EACnD68B,EAAUY,KAAKC,cAAcjsB,IAASorB,EAAUY,KAAKI,QAEvD,OADAhB,EAAUU,OAAO/iC,KAAK+hC,GACfA,GAETpsB,KAAM,SAAU2tB,GACd,IAAIr2B,EAAQ,EAGVvK,EAAS4gC,EAAUjB,EAAUU,OAAOrgC,OAAS,EAC/C,GAAI+/B,EACF,OAAOv/B,KAGT,IADAu/B,GAAU,EACHx1B,EAAQvK,EAAQuK,IACrBo1B,EAAUU,OAAO91B,GAAO+1B,IAAI,GAU9B,OALIM,EACF31B,EAAS9G,YAAY5D,EAAM,CAACo/B,EAAWiB,IAEvC31B,EAASyxB,WAAWn8B,EAAM,CAACo/B,EAAWiB,IAEjCpgC,QAGXmb,EAAQgkB,EAAUhkB,MAIpB,IAFAklB,GAAWllB,EAAOgkB,EAAUY,KAAKC,eAE1Bj2B,EAAQvK,EAAQuK,IAErB,GADA4P,EAAS8kB,GAAoB10B,GAAO9I,KAAKk+B,EAAWp/B,EAAMob,EAAOgkB,EAAUY,MACvEpmB,EACF,OAAOA,EAmBX,OAfAulB,GAAaC,EAAWhkB,GAEpB9e,EAAOoE,WAAW0+B,EAAUY,KAAKn2B,QACnCu1B,EAAUY,KAAKn2B,MAAM3I,KAAKlB,EAAMo/B,GAGlC9iC,EAAOwW,GAAGytB,MACRjkC,EAAOoG,OAAO+8B,EAAM,CAClBz/B,KAAMA,EACNwgC,KAAMpB,EACNltB,MAAOktB,EAAUY,KAAK9tB,SAKnBktB,EAAUh0B,SAASg0B,EAAUY,KAAK50B,UACtCvJ,KAAKu9B,EAAUY,KAAKn+B,KAAMu9B,EAAUY,KAAK3G,UACzC1uB,KAAKy0B,EAAUY,KAAKr1B,MACpBF,OAAO20B,EAAUY,KAAKv1B,QAG3B,SAAS61B,GAAWllB,EAAO6kB,GACzB,IAAIx5B,EAAO3D,EAAMkH,EAAOo2B,EAAQ/tB,EAGhC,IAAKrI,KAASoR,EAeZ,GAdAtY,EAAOxG,EAAO+J,UAAU2D,GACxBo2B,EAASH,EAAcn9B,GACvB2D,EAAQ2U,EAAMpR,GACV1N,EAAO6G,QAAQsD,KACjB25B,EAAS35B,EAAM,GACfA,EAAQ2U,EAAMpR,GAASvD,EAAM,IAG3BuD,IAAUlH,IACZsY,EAAMtY,GAAQ2D,SACP2U,EAAMpR,IAGfqI,EAAQ/V,EAAOw3B,SAAShxB,GACpBuP,GAAS,WAAYA,EAMvB,IAAKrI,KALLvD,EAAQ4L,EAAM+iB,OAAO3uB,UACd2U,EAAMtY,GAIC2D,EACNuD,KAASoR,IACbA,EAAMpR,GAASvD,EAAMuD,GACrBi2B,EAAcj2B,GAASo2B,QAI3BH,EAAcn9B,GAAQs9B,EAmC5B,SAASzB,GAAiB3+B,EAAMob,EAAO4kB,GAErC,IAAIhsB,EAAMhK,EAAOvK,EACfgH,EAAOg6B,EAAU7M,EACjBkL,EAAOzsB,EAAOquB,EACdF,EAAOvgC,KACP8M,EAAQ/M,EAAK+M,MACb0Q,EAAO,GACPkjB,EAAU,GACV7N,EAAS9yB,EAAKL,UAAY8yB,GAASzyB,GAiErC,IAAKgK,KA9DAg2B,EAAK9tB,QACRG,EAAQ/V,EAAOgW,YAAYtS,EAAM,MACX,MAAlBqS,EAAMuuB,WACRvuB,EAAMuuB,SAAW,EACjBF,EAAUruB,EAAMpI,MAAMV,KACtB8I,EAAMpI,MAAMV,KAAO,WACZ8I,EAAMuuB,UACTF,MAINruB,EAAMuuB,WAENJ,EAAK/1B,QAAO,WAGV+1B,EAAK/1B,QAAO,WACV4H,EAAMuuB,WACDtkC,EAAO4V,MAAMlS,EAAM,MAAMP,QAC5B4S,EAAMpI,MAAMV,cAOE,IAAlBvJ,EAAKL,WAAmB,WAAYyb,GAAS,UAAWA,KAK1D4kB,EAAKa,SAAW,CAAC9zB,EAAM8zB,SAAU9zB,EAAM+zB,UAAW/zB,EAAMg0B,WAIpB,WAAhCzkC,EAAOq2B,IAAI3yB,EAAM,YACW,SAA9B1D,EAAOq2B,IAAI3yB,EAAM,WAIZ1D,EAAO6P,QAAQmC,wBAAgE,WAAtCykB,GAAmB/yB,EAAKuG,UAIpEwG,EAAM0D,KAAO,EAHb1D,EAAMiD,QAAU,iBAQlBgwB,EAAKa,WACP9zB,EAAM8zB,SAAW,SACZvkC,EAAO6P,QAAQoC,kBAClBiyB,EAAK/1B,QAAO,WACVsC,EAAM8zB,SAAWb,EAAKa,SAAS,GAC/B9zB,EAAM+zB,UAAYd,EAAKa,SAAS,GAChC9zB,EAAMg0B,UAAYf,EAAKa,SAAS,OAOxBzlB,EAEZ,GADA3U,EAAQ2U,EAAMpR,GACVu0B,GAASp+B,KAAKsG,GAAQ,CAGxB,UAFO2U,EAAMpR,GACb4pB,EAASA,GAAoB,WAAVntB,EACfA,KAAWqsB,EAAS,OAAS,QAC/B,SAEF6N,EAAQ5jC,KAAKiN,GAKjB,GADAvK,EAASkhC,EAAQlhC,OACbA,EAAQ,CACVghC,EAAWnkC,EAAOyV,MAAM/R,EAAM,WAAa1D,EAAOyV,MAAM/R,EAAM,SAAU,IACpE,WAAYygC,IACd3N,EAAS2N,EAAS3N,QAIhBc,IACF6M,EAAS3N,QAAUA,GAEjBA,EACFx2B,EAAO0D,GAAM6yB,OAEb2N,EAAK3+B,MAAK,WACRvF,EAAO0D,GAAM2zB,UAGjB6M,EAAK3+B,MAAK,WACR,IAAImS,EAEJ,IAAKA,KADL1X,EAAO0V,YAAYhS,EAAM,UACZyd,EACXnhB,EAAOyQ,MAAM/M,EAAMgU,EAAMyJ,EAAKzJ,OAGlC,IAAKhK,EAAQ,EAAGA,EAAQvK,EAAQuK,IAC9BgK,EAAO2sB,EAAQ32B,GACf80B,EAAQ0B,EAAKzB,YAAY/qB,EAAM8e,EAAS2N,EAASzsB,GAAQ,GACzDyJ,EAAKzJ,GAAQysB,EAASzsB,IAAS1X,EAAOyQ,MAAM/M,EAAMgU,GAE5CA,KAAQysB,IACZA,EAASzsB,GAAQ8qB,EAAMj1B,MACnBipB,IACFgM,EAAMv8B,IAAMu8B,EAAMj1B,MAClBi1B,EAAMj1B,MAAiB,UAATmK,GAA6B,WAATA,EAAoB,EAAI,KAOpE,SAASmsB,GAAMngC,EAAM+C,EAASiR,EAAMzR,EAAK69B,GACvC,OAAO,IAAID,GAAMvgC,UAAU/B,KAAKmC,EAAM+C,EAASiR,EAAMzR,EAAK69B,GAiO5D,SAASY,GAAM/hC,EAAMgiC,GACnB,IAAIxlB,EACFxJ,EAAQ,CAAEivB,OAAQjiC,GAClBkD,EAAI,EAKN,IADA8+B,EAAeA,EAAe,EAAI,EAC3B9+B,EAAI,EAAGA,GAAK,EAAI8+B,EACrBxlB,EAAQ2W,GAAUjwB,GAClB8P,EAAM,SAAWwJ,GAASxJ,EAAM,UAAYwJ,GAASxc,EAOvD,OAJIgiC,IACFhvB,EAAMxE,QAAUwE,EAAM1B,MAAQtR,GAGzBgT,EAuRT,SAASkvB,GAAUnhC,GACjB,OAAO1D,EAAOoD,SAASM,GACrBA,EACkB,IAAlBA,EAAKL,WACHK,EAAK8Z,aAAe9Z,EAAK+Z,cA3qB/Bzd,EAAOgjC,UAAYhjC,EAAOoG,OAAO48B,GAAW,CAE1C8B,QAAS,SAAUhmB,EAAO1Z,GACpBpF,EAAOoE,WAAW0a,IACpB1Z,EAAW0Z,EACXA,EAAQ,CAAC,MAETA,EAAQA,EAAM7S,MAAM,KAOtB,IAJA,IAAIyL,EACFhK,EAAQ,EACRvK,EAAS2b,EAAM3b,OAEVuK,EAAQvK,EAAQuK,IACrBgK,EAAOoH,EAAMpR,GACb40B,GAAS5qB,GAAQ4qB,GAAS5qB,IAAS,GACnC4qB,GAAS5qB,GAAMvB,QAAQ/Q,IAI3B2/B,UAAW,SAAU3/B,EAAU+tB,GACzBA,EACFiP,GAAoBjsB,QAAQ/Q,GAE5Bg9B,GAAoB3hC,KAAK2E,MAuI/BpF,EAAO6jC,MAAQA,GAEfA,GAAMvgC,UAAY,CAChBE,YAAaqgC,GACbtiC,KAAM,SAAUmC,EAAM+C,EAASiR,EAAMzR,EAAK69B,EAAQvB,GAChD5+B,KAAKD,KAAOA,EACZC,KAAK+T,KAAOA,EACZ/T,KAAKmgC,OAASA,GAAU,QACxBngC,KAAK8C,QAAUA,EACf9C,KAAK4J,MAAQ5J,KAAK6H,IAAM7H,KAAKuS,MAC7BvS,KAAKsC,IAAMA,EACXtC,KAAK4+B,KAAOA,IAASviC,EAAO03B,UAAUhgB,GAAQ,GAAK,OAErDxB,IAAK,WACH,IAAIH,EAAQ8tB,GAAM9pB,UAAUpW,KAAK+T,MAEjC,OAAO3B,GAASA,EAAMlR,IACpBkR,EAAMlR,IAAIlB,MACVkgC,GAAM9pB,UAAU8D,SAAShZ,IAAIlB,OAEjC8/B,IAAK,SAAUF,GACb,IAAIyB,EACFjvB,EAAQ8tB,GAAM9pB,UAAUpW,KAAK+T,MAoB/B,OAlBI/T,KAAK8C,QAAQ68B,SACf3/B,KAAKorB,IAAMiW,EAAQhlC,EAAO8jC,OAAOngC,KAAKmgC,QACpCP,EAAS5/B,KAAK8C,QAAQ68B,SAAWC,EAAS,EAAG,EAAG5/B,KAAK8C,QAAQ68B,UAG/D3/B,KAAKorB,IAAMiW,EAAQzB,EAErB5/B,KAAK6H,KAAO7H,KAAKsC,IAAMtC,KAAK4J,OAASy3B,EAAQrhC,KAAK4J,MAE9C5J,KAAK8C,QAAQw+B,MACfthC,KAAK8C,QAAQw+B,KAAKrgC,KAAKjB,KAAKD,KAAMC,KAAK6H,IAAK7H,MAG1CoS,GAASA,EAAM0C,IACjB1C,EAAM0C,IAAI9U,MAEVkgC,GAAM9pB,UAAU8D,SAASpF,IAAI9U,MAExBA,OAIXkgC,GAAMvgC,UAAU/B,KAAK+B,UAAYugC,GAAMvgC,UAEvCugC,GAAM9pB,UAAY,CAChB8D,SAAU,CACRhZ,IAAK,SAAU29B,GACb,IAAIllB,EAEJ,OAA8B,MAA1BklB,EAAM9+B,KAAK8+B,EAAM9qB,OACjB8qB,EAAM9+B,KAAK+M,OAAyC,MAAhC+xB,EAAM9+B,KAAK+M,MAAM+xB,EAAM9qB,OAQ/C4F,EAAStd,EAAOq2B,IAAImM,EAAM9+B,KAAM8+B,EAAM9qB,KAAM,IAEpC4F,GAAqB,SAAXA,EAAwBA,EAAJ,GAT7BklB,EAAM9+B,KAAK8+B,EAAM9qB,OAW5Be,IAAK,SAAU+pB,GAGTxiC,EAAOwW,GAAGyuB,KAAKzC,EAAM9qB,MACvB1X,EAAOwW,GAAGyuB,KAAKzC,EAAM9qB,MAAM8qB,GAClBA,EAAM9+B,KAAK+M,QAA2D,MAAjD+xB,EAAM9+B,KAAK+M,MAAMzQ,EAAO23B,SAAS6K,EAAM9qB,QAAkB1X,EAAOw3B,SAASgL,EAAM9qB,OAC7G1X,EAAOyQ,MAAM+xB,EAAM9+B,KAAM8+B,EAAM9qB,KAAM8qB,EAAMh3B,IAAMg3B,EAAMD,MAEvDC,EAAM9+B,KAAK8+B,EAAM9qB,MAAQ8qB,EAAMh3B,OASvCq4B,GAAM9pB,UAAUgG,UAAY8jB,GAAM9pB,UAAU4F,WAAa,CACvDlH,IAAK,SAAU+pB,GACTA,EAAM9+B,KAAKL,UAAYm/B,EAAM9+B,KAAKa,aACpCi+B,EAAM9+B,KAAK8+B,EAAM9qB,MAAQ8qB,EAAMh3B,OAKrCxL,EAAOmF,KAAK,CAAC,SAAU,OAAQ,SAAS,SAAUU,EAAGW,GACnD,IAAI0+B,EAAQllC,EAAOsB,GAAGkF,GACtBxG,EAAOsB,GAAGkF,GAAQ,SAAU2+B,EAAOrB,EAAQ1+B,GACzC,OAAgB,MAAT+/B,GAAkC,mBAAVA,EAC7BD,EAAM1/B,MAAM7B,KAAM8B,WAClB9B,KAAKyhC,QAAQV,GAAMl+B,GAAM,GAAO2+B,EAAOrB,EAAQ1+B,OAIrDpF,EAAOsB,GAAG8E,OAAO,CACfi/B,OAAQ,SAAUF,EAAOG,EAAIxB,EAAQ1+B,GAGnC,OAAOzB,KAAKsb,OAAOkX,IAAUE,IAAI,UAAW,GAAGE,OAG5CtwB,MAAMm/B,QAAQ,CAAEj0B,QAASm0B,GAAMH,EAAOrB,EAAQ1+B,IAEnDggC,QAAS,SAAU1tB,EAAMytB,EAAOrB,EAAQ1+B,GACtC,IAAIuI,EAAQ3N,EAAOiI,cAAcyP,GAC/B6tB,EAASvlC,EAAOmlC,MAAMA,EAAOrB,EAAQ1+B,GACrCogC,EAAc,WAEZ,IAAItB,EAAOlB,GAAUr/B,KAAM3D,EAAOoG,OAAO,GAAIsR,GAAO6tB,GACpDC,EAAYC,OAAS,WACnBvB,EAAK9tB,MAAK,KAGRzI,GAAS3N,EAAOyV,MAAM9R,KAAM,YAC9BugC,EAAK9tB,MAAK,IAKhB,OAFAovB,EAAYC,OAASD,EAEd73B,IAA0B,IAAjB43B,EAAO3vB,MACrBjS,KAAKwB,KAAKqgC,GACV7hC,KAAKiS,MAAM2vB,EAAO3vB,MAAO4vB,IAE7BpvB,KAAM,SAAUzT,EAAMiU,EAAYmtB,GAChC,IAAI2B,EAAY,SAAU3vB,GACxB,IAAIK,EAAOL,EAAMK,YACVL,EAAMK,KACbA,EAAK2tB,IAYP,MAToB,kBAATphC,IACTohC,EAAUntB,EACVA,EAAajU,EACbA,EAAOlD,GAELmX,IAAuB,IAATjU,GAChBgB,KAAKiS,MAAMjT,GAAQ,KAAM,IAGpBgB,KAAKwB,MAAK,WACf,IAAI0Q,GAAU,EACZnI,EAAgB,MAAR/K,GAAgBA,EAAO,aAC/BgjC,EAAS3lC,EAAO2lC,OAChBt9B,EAAOrI,EAAOyV,MAAM9R,MAEtB,GAAI+J,EACErF,EAAKqF,IAAUrF,EAAKqF,GAAO0I,MAC7BsvB,EAAUr9B,EAAKqF,SAGjB,IAAKA,KAASrF,EACRA,EAAKqF,IAAUrF,EAAKqF,GAAO0I,MAAQ+rB,GAAKj+B,KAAKwJ,IAC/Cg4B,EAAUr9B,EAAKqF,IAKrB,IAAKA,EAAQi4B,EAAOxiC,OAAQuK,KACtBi4B,EAAOj4B,GAAOhK,OAASC,MAAiB,MAARhB,GAAgBgjC,EAAOj4B,GAAOkI,QAAUjT,IAC1EgjC,EAAOj4B,GAAOw2B,KAAK9tB,KAAK2tB,GACxBluB,GAAU,EACV8vB,EAAOx/B,OAAOuH,EAAO,KAOrBmI,GAAYkuB,GACd/jC,EAAO6V,QAAQlS,KAAMhB,OAI3B8iC,OAAQ,SAAU9iC,GAIhB,OAHa,IAATA,IACFA,EAAOA,GAAQ,MAEVgB,KAAKwB,MAAK,WACf,IAAIuI,EACFrF,EAAOrI,EAAOyV,MAAM9R,MACpBiS,EAAQvN,EAAK1F,EAAO,SACpBoT,EAAQ1N,EAAK1F,EAAO,cACpBgjC,EAAS3lC,EAAO2lC,OAChBxiC,EAASyS,EAAQA,EAAMzS,OAAS,EAalC,IAVAkF,EAAKo9B,QAAS,EAGdzlC,EAAO4V,MAAMjS,KAAMhB,EAAM,IAErBoT,GAASA,EAAMG,KAAOH,EAAMG,IAAIuvB,QAClC1vB,EAAMG,IAAIuvB,OAAO7gC,KAAKjB,MAInB+J,EAAQi4B,EAAOxiC,OAAQuK,KACtBi4B,EAAOj4B,GAAOhK,OAASC,MAAQgiC,EAAOj4B,GAAOkI,QAAUjT,IACzDgjC,EAAOj4B,GAAOw2B,KAAK9tB,MAAK,GACxBuvB,EAAOx/B,OAAOuH,EAAO,IAKzB,IAAKA,EAAQ,EAAGA,EAAQvK,EAAQuK,IAC1BkI,EAAMlI,IAAUkI,EAAMlI,GAAO+3B,QAC/B7vB,EAAMlI,GAAO+3B,OAAO7gC,KAAKjB,aAKtB0E,EAAKo9B,aA2BlBzlC,EAAOmF,KAAK,CACVygC,UAAWlB,GAAM,QACjBmB,QAASnB,GAAM,QACfoB,YAAapB,GAAM,UACnBqB,OAAQ,CAAE50B,QAAS,QACnB60B,QAAS,CAAE70B,QAAS,QACpB80B,WAAY,CAAE90B,QAAS,YACtB,SAAU3K,EAAMsY,GACjB9e,EAAOsB,GAAGkF,GAAQ,SAAU2+B,EAAOrB,EAAQ1+B,GACzC,OAAOzB,KAAKyhC,QAAQtmB,EAAOqmB,EAAOrB,EAAQ1+B,OAI9CpF,EAAOmlC,MAAQ,SAAUA,EAAOrB,EAAQxiC,GACtC,IAAI4O,EAAMi1B,GAA0B,kBAAVA,EAAqBnlC,EAAOoG,OAAO,GAAI++B,GAAS,CACxEpI,SAAUz7B,IAAOA,GAAMwiC,GACrB9jC,EAAOoE,WAAW+gC,IAAUA,EAC9B7B,SAAU6B,EACVrB,OAAQxiC,GAAMwiC,GAAUA,IAAW9jC,EAAOoE,WAAW0/B,IAAWA,GAwBlE,OArBA5zB,EAAIozB,SAAWtjC,EAAOwW,GAAGhP,IAAM,EAA4B,kBAAjB0I,EAAIozB,SAAwBpzB,EAAIozB,SACxEpzB,EAAIozB,YAAYtjC,EAAOwW,GAAGC,OAASzW,EAAOwW,GAAGC,OAAOvG,EAAIozB,UAAYtjC,EAAOwW,GAAGC,OAAOoH,SAGtE,MAAb3N,EAAI0F,QAA+B,IAAd1F,EAAI0F,QAC3B1F,EAAI0F,MAAQ,MAId1F,EAAIsV,IAAMtV,EAAI6sB,SAEd7sB,EAAI6sB,SAAW,WACT/8B,EAAOoE,WAAW8L,EAAIsV,MACxBtV,EAAIsV,IAAI5gB,KAAKjB,MAGXuM,EAAI0F,OACN5V,EAAO6V,QAAQlS,KAAMuM,EAAI0F,QAItB1F,GAGTlQ,EAAO8jC,OAAS,CACdoC,OAAQ,SAAUC,GAChB,OAAOA,GAETC,MAAO,SAAUD,GACf,MAAO,GAAM17B,KAAK47B,IAAIF,EAAI17B,KAAK67B,IAAM,IAIzCtmC,EAAO2lC,OAAS,GAChB3lC,EAAOwW,GAAKqtB,GAAMvgC,UAAU/B,KAC5BvB,EAAOwW,GAAG2sB,KAAO,WACf,IAAIc,EACF0B,EAAS3lC,EAAO2lC,OAChB9/B,EAAI,EAIN,IAFAk8B,GAAQ/hC,EAAOwL,MAER3F,EAAI8/B,EAAOxiC,OAAQ0C,IACxBo+B,EAAQ0B,EAAO9/B,GAEVo+B,KAAW0B,EAAO9/B,KAAOo+B,GAC5B0B,EAAOx/B,OAAON,IAAK,GAIlB8/B,EAAOxiC,QACVnD,EAAOwW,GAAGJ,OAEZ2rB,GAAQtiC,GAGVO,EAAOwW,GAAGytB,MAAQ,SAAUA,GACtBA,KAAWjkC,EAAO2lC,OAAOllC,KAAKwjC,IAChCjkC,EAAOwW,GAAGjJ,SAIdvN,EAAOwW,GAAG+vB,SAAW,GAErBvmC,EAAOwW,GAAGjJ,MAAQ,WACXy0B,KACHA,GAAUwE,YAAYxmC,EAAOwW,GAAG2sB,KAAMnjC,EAAOwW,GAAG+vB,YAIpDvmC,EAAOwW,GAAGJ,KAAO,WACfqwB,cAAczE,IACdA,GAAU,MAGZhiC,EAAOwW,GAAGC,OAAS,CACjBiwB,KAAM,IACNC,KAAM,IAEN9oB,SAAU,KAIZ7d,EAAOwW,GAAGyuB,KAAO,GAEbjlC,EAAOqc,MAAQrc,EAAOqc,KAAKqR,UAC7B1tB,EAAOqc,KAAKqR,QAAQkZ,SAAW,SAAUljC,GACvC,OAAO1D,EAAO6K,KAAK7K,EAAO2lC,QAAQ,SAAUrkC,GAC1C,OAAOoC,IAASpC,EAAGoC,QAClBP,SAGPnD,EAAOsB,GAAGulC,OAAS,SAAUpgC,GAC3B,GAAIhB,UAAUtC,OACZ,OAAOsD,IAAYhH,EACjBkE,KACAA,KAAKwB,MAAK,SAAUU,GAClB7F,EAAO6mC,OAAOC,UAAUnjC,KAAM8C,EAASZ,MAI7C,IAAIgd,EAASkkB,EACXC,EAAM,CAAEn7B,IAAK,EAAGqsB,KAAM,GACtBx0B,EAAOC,KAAK,GACZ4b,EAAM7b,GAAQA,EAAKO,cAErB,OAAKsb,GAILsD,EAAUtD,EAAI7V,gBAGT1J,EAAOqhB,SAASwB,EAASnf,WAMnBA,EAAKujC,wBAA0BrnC,IACxConC,EAAMtjC,EAAKujC,yBAEbF,EAAMlC,GAAUtlB,GACT,CACL1T,IAAKm7B,EAAIn7B,KAAOk7B,EAAIG,aAAerkB,EAAQ9C,YAAc8C,EAAQ7C,WAAa,GAC9EkY,KAAM8O,EAAI9O,MAAQ6O,EAAII,aAAetkB,EAAQlD,aAAekD,EAAQjD,YAAc,KAX3EonB,QART,GAuBFhnC,EAAO6mC,OAAS,CAEdC,UAAW,SAAUpjC,EAAM+C,EAASZ,GAClC,IAAI4vB,EAAWz1B,EAAOq2B,IAAI3yB,EAAM,YAGf,WAAb+xB,IACF/xB,EAAK+M,MAAMglB,SAAW,YAGxB,IAKgC2R,EAAQC,EALpCC,EAAUtnC,EAAO0D,GACnB6jC,EAAYD,EAAQT,SACpBW,EAAYxnC,EAAOq2B,IAAI3yB,EAAM,OAC7B+jC,EAAaznC,EAAOq2B,IAAI3yB,EAAM,QAC9BgkC,GAAkC,aAAbjS,GAAwC,UAAbA,IAAyBz1B,EAAOwK,QAAQ,OAAQ,CAACg9B,EAAWC,KAAgB,EAC5H3oB,EAAQ,GAAI6oB,EAAc,GAGxBD,GACFC,EAAcL,EAAQ7R,WACtB2R,EAASO,EAAY97B,IACrBw7B,EAAUM,EAAYzP,OAEtBkP,EAASx/B,WAAW4/B,IAAc,EAClCH,EAAUz/B,WAAW6/B,IAAe,GAGlCznC,EAAOoE,WAAWqC,KACpBA,EAAUA,EAAQ7B,KAAKlB,EAAMmC,EAAG0hC,IAGf,MAAf9gC,EAAQoF,MACViT,EAAMjT,IAAOpF,EAAQoF,IAAM07B,EAAU17B,IAAOu7B,GAE1B,MAAhB3gC,EAAQyxB,OACVpZ,EAAMoZ,KAAQzxB,EAAQyxB,KAAOqP,EAAUrP,KAAQmP,GAG7C,UAAW5gC,EACbA,EAAQmhC,MAAMhjC,KAAKlB,EAAMob,GAEzBwoB,EAAQjR,IAAIvX,KAMlB9e,EAAOsB,GAAG8E,OAAO,CAEfqvB,SAAU,WACR,GAAK9xB,KAAK,GAAV,CAIA,IAAIkkC,EAAchB,EAChBiB,EAAe,CAAEj8B,IAAK,EAAGqsB,KAAM,GAC/Bx0B,EAAOC,KAAK,GAwBd,MArBqC,UAAjC3D,EAAOq2B,IAAI3yB,EAAM,YAEnBmjC,EAASnjC,EAAKujC,yBAGdY,EAAelkC,KAAKkkC,eAGpBhB,EAASljC,KAAKkjC,SACT7mC,EAAOiK,SAAS49B,EAAa,GAAI,UACpCC,EAAeD,EAAahB,UAI9BiB,EAAaj8B,KAAO7L,EAAOq2B,IAAIwR,EAAa,GAAI,kBAAkB,GAClEC,EAAa5P,MAAQl4B,EAAOq2B,IAAIwR,EAAa,GAAI,mBAAmB,IAM/D,CACLh8B,IAAKg7B,EAAOh7B,IAAMi8B,EAAaj8B,IAAM7L,EAAOq2B,IAAI3yB,EAAM,aAAa,GACnEw0B,KAAM2O,EAAO3O,KAAO4P,EAAa5P,KAAOl4B,EAAOq2B,IAAI3yB,EAAM,cAAc,MAI3EmkC,aAAc,WACZ,OAAOlkC,KAAKqC,KAAI,WACd,IAAI6hC,EAAelkC,KAAKkkC,cAAgBhoC,EAAS6J,gBACjD,MAAOm+B,IAAkB7nC,EAAOiK,SAAS49B,EAAc,SAAoD,WAAzC7nC,EAAOq2B,IAAIwR,EAAc,YACzFA,EAAeA,EAAaA,aAE9B,OAAOA,GAAgBhoC,EAAS6J,sBAOtC1J,EAAOmF,KAAK,CAAEwa,WAAY,cAAeI,UAAW,gBAAiB,SAAUkd,EAAQvlB,GACrF,IAAI7L,EAAM,IAAI3H,KAAKwT,GAEnB1X,EAAOsB,GAAG27B,GAAU,SAAU1kB,GAC5B,OAAOvY,EAAOmL,OAAOxH,MAAM,SAAUD,EAAMu5B,EAAQ1kB,GACjD,IAAIwuB,EAAMlC,GAAUnhC,GAEpB,GAAI6U,IAAQ9Y,EACV,OAAOsnC,EAAOrvB,KAAQqvB,EAAOA,EAAIrvB,GAC/BqvB,EAAIlnC,SAAS6J,gBAAgBuzB,GAC7Bv5B,EAAKu5B,GAGL8J,EACFA,EAAIgB,SACDl8B,EAAY7L,EAAO+mC,GAAKpnB,aAAlBpH,EACP1M,EAAM0M,EAAMvY,EAAO+mC,GAAKhnB,aAI1Brc,EAAKu5B,GAAU1kB,IAEhB0kB,EAAQ1kB,EAAK9S,UAAUtC,OAAQ,UAYtCnD,EAAOmF,KAAK,CAAE6iC,OAAQ,SAAUC,MAAO,UAAW,SAAUzhC,EAAM7D,GAChE3C,EAAOmF,KAAK,CAAEuzB,QAAS,QAAUlyB,EAAM0hC,QAASvlC,EAAM,GAAI,QAAU6D,IAAQ,SAAU2hC,EAAcC,GAElGpoC,EAAOsB,GAAG8mC,GAAY,SAAU3P,EAAQtuB,GACtC,IAAIiB,EAAY3F,UAAUtC,SAAWglC,GAAkC,mBAAX1P,GAC1D5B,EAAQsR,KAA4B,IAAX1P,IAA6B,IAAVtuB,EAAiB,SAAW,UAE1E,OAAOnK,EAAOmL,OAAOxH,MAAM,SAAUD,EAAMf,EAAMwH,GAC/C,IAAIoV,EAEJ,OAAIvf,EAAOoD,SAASM,GAIXA,EAAK7D,SAAS6J,gBAAgB,SAAWlD,GAI5B,IAAlB9C,EAAKL,UACPkc,EAAM7b,EAAKgG,gBAIJe,KAAKC,IACVhH,EAAK0D,KAAK,SAAWZ,GAAO+Y,EAAI,SAAW/Y,GAC3C9C,EAAK0D,KAAK,SAAWZ,GAAO+Y,EAAI,SAAW/Y,GAC3C+Y,EAAI,SAAW/Y,KAIZ2D,IAAU1K,EAEfO,EAAOq2B,IAAI3yB,EAAMf,EAAMk0B,GAGvB72B,EAAOyQ,MAAM/M,EAAMf,EAAMwH,EAAO0sB,KACjCl0B,EAAMyI,EAAYqtB,EAASh5B,EAAW2L,EAAW,aAS1D5L,EAAOQ,OAASR,EAAOU,EAAIF,EAcuB,UAAWA,SAC3D,EAAiB,GAAI,EAAF,WAAgB,OAAOA,GAAS,kCA72SvD,CAg3SGR","file":"js/chunk-3d862751.044bd18b.js","sourcesContent":["/* globals __webpack_amd_options__ */\nmodule.exports = __webpack_amd_options__;\n","/*!\r\n * jQuery JavaScript Library v1.9.1\r\n * http://jquery.com/\r\n *\r\n * Includes Sizzle.js\r\n * http://sizzlejs.com/\r\n *\r\n * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors\r\n * Released under the MIT license\r\n * http://jquery.org/license\r\n *\r\n * Date: 2013-2-4\r\n */\r\n(function (window, undefined) {\r\n\r\n  // Can't do this because several apps including ASP.NET trace\r\n  // the stack via arguments.caller.callee and Firefox dies if\r\n  // you try to trace through \"use strict\" call chains. (#13335)\r\n  // Support: Firefox 18+\r\n  //\"use strict\";\r\n  var\r\n    // The deferred used on DOM ready\r\n    readyList,\r\n\r\n    // A central reference to the root jQuery(document)\r\n    rootjQuery,\r\n\r\n    // Support: IE<9\r\n    // For `typeof node.method` instead of `node.method !== undefined`\r\n    core_strundefined = typeof undefined,\r\n\r\n    // Use the correct document accordingly with window argument (sandbox)\r\n    document = window.document,\r\n    location = window.location,\r\n\r\n    // Map over jQuery in case of overwrite\r\n    _jQuery = window.jQuery,\r\n\r\n    // Map over the $ in case of overwrite\r\n    _$ = window.$,\r\n\r\n    // [[Class]] -> type pairs\r\n    class2type = {},\r\n\r\n    // List of deleted data cache ids, so we can reuse them\r\n    core_deletedIds = [],\r\n\r\n    core_version = \"1.9.1\",\r\n\r\n    // Save a reference to some core methods\r\n    core_concat = core_deletedIds.concat,\r\n    core_push = core_deletedIds.push,\r\n    core_slice = core_deletedIds.slice,\r\n    core_indexOf = core_deletedIds.indexOf,\r\n    core_toString = class2type.toString,\r\n    core_hasOwn = class2type.hasOwnProperty,\r\n    core_trim = core_version.trim,\r\n\r\n    // Define a local copy of jQuery\r\n    jQuery = function (selector, context) {\r\n      // The jQuery object is actually just the init constructor 'enhanced'\r\n      return new jQuery.fn.init(selector, context, rootjQuery);\r\n    },\r\n\r\n    // Used for matching numbers\r\n    core_pnum = /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/.source,\r\n\r\n    // Used for splitting on whitespace\r\n    core_rnotwhite = /\\S+/g,\r\n\r\n    // Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)\r\n    rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,\r\n\r\n    // A simple way to check for HTML strings\r\n    // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\r\n    // Strict HTML recognition (#11290: must start with <)\r\n    rquickExpr = /^(?:(<[\\w\\W]+>)[^>]*|#([\\w-]*))$/,\r\n\r\n    // Match a standalone tag\r\n    rsingleTag = /^<(\\w+)\\s*\\/?>(?:<\\/\\1>|)$/,\r\n\r\n    // JSON RegExp\r\n    rvalidchars = /^[\\],:{}\\s]*$/,\r\n    rvalidbraces = /(?:^|:|,)(?:\\s*\\[)+/g,\r\n    rvalidescape = /\\\\(?:[\"\\\\\\/bfnrt]|u[\\da-fA-F]{4})/g,\r\n    rvalidtokens = /\"[^\"\\\\\\r\\n]*\"|true|false|null|-?(?:\\d+\\.|)\\d+(?:[eE][+-]?\\d+|)/g,\r\n\r\n    // Matches dashed string for camelizing\r\n    rmsPrefix = /^-ms-/,\r\n    rdashAlpha = /-([\\da-z])/gi,\r\n\r\n    // Used by jQuery.camelCase as callback to replace()\r\n    fcamelCase = function (all, letter) {\r\n      return letter.toUpperCase();\r\n    },\r\n\r\n    // The ready event handler\r\n    completed = function (event) {\r\n\r\n      // readyState === \"complete\" is good enough for us to call the dom ready in oldIE\r\n      if (document.addEventListener || event.type === \"load\" || document.readyState === \"complete\") {\r\n        detach();\r\n        jQuery.ready();\r\n      }\r\n    },\r\n    // Clean-up method for dom ready events\r\n    detach = function () {\r\n      if (document.addEventListener) {\r\n        document.removeEventListener(\"DOMContentLoaded\", completed, false);\r\n        window.removeEventListener(\"load\", completed, false);\r\n\r\n      } else {\r\n        document.detachEvent(\"onreadystatechange\", completed);\r\n        window.detachEvent(\"onload\", completed);\r\n      }\r\n    };\r\n\r\n  jQuery.fn = jQuery.prototype = {\r\n    // The current version of jQuery being used\r\n    jquery: core_version,\r\n\r\n    constructor: jQuery,\r\n    init: function (selector, context, rootjQuery) {\r\n      var match, elem;\r\n\r\n      // HANDLE: $(\"\"), $(null), $(undefined), $(false)\r\n      if (!selector) {\r\n        return this;\r\n      }\r\n\r\n      // Handle HTML strings\r\n      if (typeof selector === \"string\") {\r\n        if (selector.charAt(0) === \"<\" && selector.charAt(selector.length - 1) === \">\" && selector.length >= 3) {\r\n          // Assume that strings that start and end with <> are HTML and skip the regex check\r\n          match = [null, selector, null];\r\n\r\n        } else {\r\n          match = rquickExpr.exec(selector);\r\n        }\r\n\r\n        // Match html or make sure no context is specified for #id\r\n        if (match && (match[1] || !context)) {\r\n\r\n          // HANDLE: $(html) -> $(array)\r\n          if (match[1]) {\r\n            context = context instanceof jQuery ? context[0] : context;\r\n\r\n            // scripts is true for back-compat\r\n            jQuery.merge(this, jQuery.parseHTML(\r\n              match[1],\r\n              context && context.nodeType ? context.ownerDocument || context : document,\r\n              true\r\n            ));\r\n\r\n            // HANDLE: $(html, props)\r\n            if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {\r\n              for (match in context) {\r\n                // Properties of context are called as methods if possible\r\n                if (jQuery.isFunction(this[match])) {\r\n                  this[match](context[match]);\r\n\r\n                  // ...and otherwise set as attributes\r\n                } else {\r\n                  this.attr(match, context[match]);\r\n                }\r\n              }\r\n            }\r\n\r\n            return this;\r\n\r\n            // HANDLE: $(#id)\r\n          } else {\r\n            elem = document.getElementById(match[2]);\r\n\r\n            // Check parentNode to catch when Blackberry 4.6 returns\r\n            // nodes that are no longer in the document #6963\r\n            if (elem && elem.parentNode) {\r\n              // Handle the case where IE and Opera return items\r\n              // by name instead of ID\r\n              if (elem.id !== match[2]) {\r\n                return rootjQuery.find(selector);\r\n              }\r\n\r\n              // Otherwise, we inject the element directly into the jQuery object\r\n              this.length = 1;\r\n              this[0] = elem;\r\n            }\r\n\r\n            this.context = document;\r\n            this.selector = selector;\r\n            return this;\r\n          }\r\n\r\n          // HANDLE: $(expr, $(...))\r\n        } else if (!context || context.jquery) {\r\n          return (context || rootjQuery).find(selector);\r\n\r\n          // HANDLE: $(expr, context)\r\n          // (which is just equivalent to: $(context).find(expr)\r\n        } else {\r\n          return this.constructor(context).find(selector);\r\n        }\r\n\r\n        // HANDLE: $(DOMElement)\r\n      } else if (selector.nodeType) {\r\n        this.context = this[0] = selector;\r\n        this.length = 1;\r\n        return this;\r\n\r\n        // HANDLE: $(function)\r\n        // Shortcut for document ready\r\n      } else if (jQuery.isFunction(selector)) {\r\n        return rootjQuery.ready(selector);\r\n      }\r\n\r\n      if (selector.selector !== undefined) {\r\n        this.selector = selector.selector;\r\n        this.context = selector.context;\r\n      }\r\n\r\n      return jQuery.makeArray(selector, this);\r\n    },\r\n\r\n    // Start with an empty selector\r\n    selector: \"\",\r\n\r\n    // The default length of a jQuery object is 0\r\n    length: 0,\r\n\r\n    // The number of elements contained in the matched element set\r\n    size: function () {\r\n      return this.length;\r\n    },\r\n\r\n    toArray: function () {\r\n      return core_slice.call(this);\r\n    },\r\n\r\n    // Get the Nth element in the matched element set OR\r\n    // Get the whole matched element set as a clean array\r\n    get: function (num) {\r\n      return num == null ?\r\n\r\n        // Return a 'clean' array\r\n        this.toArray() :\r\n\r\n        // Return just the object\r\n        (num < 0 ? this[this.length + num] : this[num]);\r\n    },\r\n\r\n    // Take an array of elements and push it onto the stack\r\n    // (returning the new matched element set)\r\n    pushStack: function (elems) {\r\n\r\n      // Build a new jQuery matched element set\r\n      var ret = jQuery.merge(this.constructor(), elems);\r\n\r\n      // Add the old object onto the stack (as a reference)\r\n      ret.prevObject = this;\r\n      ret.context = this.context;\r\n\r\n      // Return the newly-formed element set\r\n      return ret;\r\n    },\r\n\r\n    // Execute a callback for every element in the matched set.\r\n    // (You can seed the arguments with an array of args, but this is\r\n    // only used internally.)\r\n    each: function (callback, args) {\r\n      return jQuery.each(this, callback, args);\r\n    },\r\n\r\n    ready: function (fn) {\r\n      // Add the callback\r\n      jQuery.ready.promise().done(fn);\r\n\r\n      return this;\r\n    },\r\n\r\n    slice: function () {\r\n      return this.pushStack(core_slice.apply(this, arguments));\r\n    },\r\n\r\n    first: function () {\r\n      return this.eq(0);\r\n    },\r\n\r\n    last: function () {\r\n      return this.eq(-1);\r\n    },\r\n\r\n    eq: function (i) {\r\n      var len = this.length,\r\n        j = +i + (i < 0 ? len : 0);\r\n      return this.pushStack(j >= 0 && j < len ? [this[j]] : []);\r\n    },\r\n\r\n    map: function (callback) {\r\n      return this.pushStack(jQuery.map(this, function (elem, i) {\r\n        return callback.call(elem, i, elem);\r\n      }));\r\n    },\r\n\r\n    end: function () {\r\n      return this.prevObject || this.constructor(null);\r\n    },\r\n\r\n    // For internal use only.\r\n    // Behaves like an Array's method, not like a jQuery method.\r\n    push: core_push,\r\n    sort: [].sort,\r\n    splice: [].splice\r\n  };\r\n\r\n  // Give the init function the jQuery prototype for later instantiation\r\n  jQuery.fn.init.prototype = jQuery.fn;\r\n\r\n  jQuery.extend = jQuery.fn.extend = function () {\r\n    var src, copyIsArray, copy, name, options, clone,\r\n      target = arguments[0] || {},\r\n      i = 1,\r\n      length = arguments.length,\r\n      deep = false;\r\n\r\n    // Handle a deep copy situation\r\n    if (typeof target === \"boolean\") {\r\n      deep = target;\r\n      target = arguments[1] || {};\r\n      // skip the boolean and the target\r\n      i = 2;\r\n    }\r\n\r\n    // Handle case when target is a string or something (possible in deep copy)\r\n    if (typeof target !== \"object\" && !jQuery.isFunction(target)) {\r\n      target = {};\r\n    }\r\n\r\n    // extend jQuery itself if only one argument is passed\r\n    if (length === i) {\r\n      target = this;\r\n      --i;\r\n    }\r\n\r\n    for (; i < length; i++) {\r\n      // Only deal with non-null/undefined values\r\n      if ((options = arguments[i]) != null) {\r\n        // Extend the base object\r\n        for (name in options) {\r\n          src = target[name];\r\n          copy = options[name];\r\n\r\n          // Prevent never-ending loop\r\n          if (target === copy) {\r\n            continue;\r\n          }\r\n\r\n          // Recurse if we're merging plain objects or arrays\r\n          if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {\r\n            if (copyIsArray) {\r\n              copyIsArray = false;\r\n              clone = src && jQuery.isArray(src) ? src : [];\r\n\r\n            } else {\r\n              clone = src && jQuery.isPlainObject(src) ? src : {};\r\n            }\r\n\r\n            // Never move original objects, clone them\r\n            target[name] = jQuery.extend(deep, clone, copy);\r\n\r\n            // Don't bring in undefined values\r\n          } else if (copy !== undefined) {\r\n            target[name] = copy;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // Return the modified object\r\n    return target;\r\n  };\r\n\r\n  jQuery.extend({\r\n    noConflict: function (deep) {\r\n      if (window.$ === jQuery) {\r\n        window.$ = _$;\r\n      }\r\n\r\n      if (deep && window.jQuery === jQuery) {\r\n        window.jQuery = _jQuery;\r\n      }\r\n\r\n      return jQuery;\r\n    },\r\n\r\n    // Is the DOM ready to be used? Set to true once it occurs.\r\n    isReady: false,\r\n\r\n    // A counter to track how many items to wait for before\r\n    // the ready event fires. See #6781\r\n    readyWait: 1,\r\n\r\n    // Hold (or release) the ready event\r\n    holdReady: function (hold) {\r\n      if (hold) {\r\n        jQuery.readyWait++;\r\n      } else {\r\n        jQuery.ready(true);\r\n      }\r\n    },\r\n\r\n    // Handle when the DOM is ready\r\n    ready: function (wait) {\r\n\r\n      // Abort if there are pending holds or we're already ready\r\n      if (wait === true ? --jQuery.readyWait : jQuery.isReady) {\r\n        return;\r\n      }\r\n\r\n      // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).\r\n      if (!document.body) {\r\n        return setTimeout(jQuery.ready);\r\n      }\r\n\r\n      // Remember that the DOM is ready\r\n      jQuery.isReady = true;\r\n\r\n      // If a normal DOM Ready event fired, decrement, and wait if need be\r\n      if (wait !== true && --jQuery.readyWait > 0) {\r\n        return;\r\n      }\r\n\r\n      // If there are functions bound, to execute\r\n      readyList.resolveWith(document, [jQuery]);\r\n\r\n      // Trigger any bound ready events\r\n      if (jQuery.fn.trigger) {\r\n        jQuery(document).trigger(\"ready\").off(\"ready\");\r\n      }\r\n    },\r\n\r\n    // See test/unit/core.js for details concerning isFunction.\r\n    // Since version 1.3, DOM methods and functions like alert\r\n    // aren't supported. They return false on IE (#2968).\r\n    isFunction: function (obj) {\r\n      return jQuery.type(obj) === \"function\";\r\n    },\r\n\r\n    isArray: Array.isArray || function (obj) {\r\n      return jQuery.type(obj) === \"array\";\r\n    },\r\n\r\n    isWindow: function (obj) {\r\n      return obj != null && obj == obj.window;\r\n    },\r\n\r\n    isNumeric: function (obj) {\r\n      return !isNaN(parseFloat(obj)) && isFinite(obj);\r\n    },\r\n\r\n    type: function (obj) {\r\n      if (obj == null) {\r\n        return String(obj);\r\n      }\r\n      return typeof obj === \"object\" || typeof obj === \"function\" ?\r\n        class2type[core_toString.call(obj)] || \"object\" :\r\n        typeof obj;\r\n    },\r\n\r\n    isPlainObject: function (obj) {\r\n      // Must be an Object.\r\n      // Because of IE, we also have to check the presence of the constructor property.\r\n      // Make sure that DOM nodes and window objects don't pass through, as well\r\n      if (!obj || jQuery.type(obj) !== \"object\" || obj.nodeType || jQuery.isWindow(obj)) {\r\n        return false;\r\n      }\r\n\r\n      try {\r\n        // Not own constructor property must be Object\r\n        if (obj.constructor &&\r\n          !core_hasOwn.call(obj, \"constructor\") &&\r\n          !core_hasOwn.call(obj.constructor.prototype, \"isPrototypeOf\")) {\r\n          return false;\r\n        }\r\n      } catch (e) {\r\n        // IE8,9 Will throw exceptions on certain host objects #9897\r\n        return false;\r\n      }\r\n\r\n      // Own properties are enumerated firstly, so to speed up,\r\n      // if last one is own, then all properties are own.\r\n\r\n      var key;\r\n      for (key in obj) { }\r\n\r\n      return key === undefined || core_hasOwn.call(obj, key);\r\n    },\r\n\r\n    isEmptyObject: function (obj) {\r\n      var name;\r\n      for (name in obj) {\r\n        return false;\r\n      }\r\n      return true;\r\n    },\r\n\r\n    error: function (msg) {\r\n      throw new Error(msg);\r\n    },\r\n\r\n    // data: string of html\r\n    // context (optional): If specified, the fragment will be created in this context, defaults to document\r\n    // keepScripts (optional): If true, will include scripts passed in the html string\r\n    parseHTML: function (data, context, keepScripts) {\r\n      if (!data || typeof data !== \"string\") {\r\n        return null;\r\n      }\r\n      if (typeof context === \"boolean\") {\r\n        keepScripts = context;\r\n        context = false;\r\n      }\r\n      context = context || document;\r\n\r\n      var parsed = rsingleTag.exec(data),\r\n        scripts = !keepScripts && [];\r\n\r\n      // Single tag\r\n      if (parsed) {\r\n        return [context.createElement(parsed[1])];\r\n      }\r\n\r\n      parsed = jQuery.buildFragment([data], context, scripts);\r\n      if (scripts) {\r\n        jQuery(scripts).remove();\r\n      }\r\n      return jQuery.merge([], parsed.childNodes);\r\n    },\r\n\r\n    parseJSON: function (data) {\r\n      // Attempt to parse using the native JSON parser first\r\n      if (window.JSON && window.JSON.parse) {\r\n        return window.JSON.parse(data);\r\n      }\r\n\r\n      if (data === null) {\r\n        return data;\r\n      }\r\n\r\n      if (typeof data === \"string\") {\r\n\r\n        // Make sure leading/trailing whitespace is removed (IE can't handle it)\r\n        data = jQuery.trim(data);\r\n\r\n        if (data) {\r\n          // Make sure the incoming data is actual JSON\r\n          // Logic borrowed from http://json.org/json2.js\r\n          if (rvalidchars.test(data.replace(rvalidescape, \"@\")\r\n            .replace(rvalidtokens, \"]\")\r\n            .replace(rvalidbraces, \"\"))) {\r\n\r\n            return (new Function(\"return \" + data))();\r\n          }\r\n        }\r\n      }\r\n\r\n      jQuery.error(\"Invalid JSON: \" + data);\r\n    },\r\n\r\n    // Cross-browser xml parsing\r\n    parseXML: function (data) {\r\n      var xml, tmp;\r\n      if (!data || typeof data !== \"string\") {\r\n        return null;\r\n      }\r\n      try {\r\n        if (window.DOMParser) { // Standard\r\n          tmp = new DOMParser();\r\n          xml = tmp.parseFromString(data, \"text/xml\");\r\n        } else { // IE\r\n          xml = new ActiveXObject(\"Microsoft.XMLDOM\");\r\n          xml.async = \"false\";\r\n          xml.loadXML(data);\r\n        }\r\n      } catch (e) {\r\n        xml = undefined;\r\n      }\r\n      if (!xml || !xml.documentElement || xml.getElementsByTagName(\"parsererror\").length) {\r\n        jQuery.error(\"Invalid XML: \" + data);\r\n      }\r\n      return xml;\r\n    },\r\n\r\n    noop: function () { },\r\n\r\n    // Evaluates a script in a global context\r\n    // Workarounds based on findings by Jim Driscoll\r\n    // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context\r\n    globalEval: function (data) {\r\n      if (data && jQuery.trim(data)) {\r\n        // We use execScript on Internet Explorer\r\n        // We use an anonymous function so that context is window\r\n        // rather than jQuery in Firefox\r\n        (window.execScript || function (data) {\r\n          window[\"eval\"].call(window, data);\r\n        })(data);\r\n      }\r\n    },\r\n\r\n    // Convert dashed to camelCase; used by the css and data modules\r\n    // Microsoft forgot to hump their vendor prefix (#9572)\r\n    camelCase: function (string) {\r\n      return string.replace(rmsPrefix, \"ms-\").replace(rdashAlpha, fcamelCase);\r\n    },\r\n\r\n    nodeName: function (elem, name) {\r\n      return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\r\n    },\r\n\r\n    // args is for internal usage only\r\n    each: function (obj, callback, args) {\r\n      var value,\r\n        i = 0,\r\n        length = obj.length,\r\n        isArray = isArraylike(obj);\r\n\r\n      if (args) {\r\n        if (isArray) {\r\n          for (; i < length; i++) {\r\n            value = callback.apply(obj[i], args);\r\n\r\n            if (value === false) {\r\n              break;\r\n            }\r\n          }\r\n        } else {\r\n          for (i in obj) {\r\n            value = callback.apply(obj[i], args);\r\n\r\n            if (value === false) {\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        // A special, fast, case for the most common use of each\r\n      } else {\r\n        if (isArray) {\r\n          for (; i < length; i++) {\r\n            value = callback.call(obj[i], i, obj[i]);\r\n\r\n            if (value === false) {\r\n              break;\r\n            }\r\n          }\r\n        } else {\r\n          for (i in obj) {\r\n            value = callback.call(obj[i], i, obj[i]);\r\n\r\n            if (value === false) {\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return obj;\r\n    },\r\n\r\n    // Use native String.trim function wherever possible\r\n    trim: core_trim && !core_trim.call(\"\\uFEFF\\xA0\") ?\r\n      function (text) {\r\n        return text == null ?\r\n          \"\" :\r\n          core_trim.call(text);\r\n      } :\r\n\r\n      // Otherwise use our own trimming functionality\r\n      function (text) {\r\n        return text == null ?\r\n          \"\" :\r\n          (text + \"\").replace(rtrim, \"\");\r\n      },\r\n\r\n    // results is for internal usage only\r\n    makeArray: function (arr, results) {\r\n      var ret = results || [];\r\n\r\n      if (arr != null) {\r\n        if (isArraylike(Object(arr))) {\r\n          jQuery.merge(ret,\r\n            typeof arr === \"string\" ?\r\n              [arr] : arr\r\n          );\r\n        } else {\r\n          core_push.call(ret, arr);\r\n        }\r\n      }\r\n\r\n      return ret;\r\n    },\r\n\r\n    inArray: function (elem, arr, i) {\r\n      var len;\r\n\r\n      if (arr) {\r\n        if (core_indexOf) {\r\n          return core_indexOf.call(arr, elem, i);\r\n        }\r\n\r\n        len = arr.length;\r\n        i = i ? i < 0 ? Math.max(0, len + i) : i : 0;\r\n\r\n        for (; i < len; i++) {\r\n          // Skip accessing in sparse arrays\r\n          if (i in arr && arr[i] === elem) {\r\n            return i;\r\n          }\r\n        }\r\n      }\r\n\r\n      return -1;\r\n    },\r\n\r\n    merge: function (first, second) {\r\n      var l = second.length,\r\n        i = first.length,\r\n        j = 0;\r\n\r\n      if (typeof l === \"number\") {\r\n        for (; j < l; j++) {\r\n          first[i++] = second[j];\r\n        }\r\n      } else {\r\n        while (second[j] !== undefined) {\r\n          first[i++] = second[j++];\r\n        }\r\n      }\r\n\r\n      first.length = i;\r\n\r\n      return first;\r\n    },\r\n\r\n    grep: function (elems, callback, inv) {\r\n      var retVal,\r\n        ret = [],\r\n        i = 0,\r\n        length = elems.length;\r\n      inv = !!inv;\r\n\r\n      // Go through the array, only saving the items\r\n      // that pass the validator function\r\n      for (; i < length; i++) {\r\n        retVal = !!callback(elems[i], i);\r\n        if (inv !== retVal) {\r\n          ret.push(elems[i]);\r\n        }\r\n      }\r\n\r\n      return ret;\r\n    },\r\n\r\n    // arg is for internal usage only\r\n    map: function (elems, callback, arg) {\r\n      var value,\r\n        i = 0,\r\n        length = elems.length,\r\n        isArray = isArraylike(elems),\r\n        ret = [];\r\n\r\n      // Go through the array, translating each of the items to their\r\n      if (isArray) {\r\n        for (; i < length; i++) {\r\n          value = callback(elems[i], i, arg);\r\n\r\n          if (value != null) {\r\n            ret[ret.length] = value;\r\n          }\r\n        }\r\n\r\n        // Go through every key on the object,\r\n      } else {\r\n        for (i in elems) {\r\n          value = callback(elems[i], i, arg);\r\n\r\n          if (value != null) {\r\n            ret[ret.length] = value;\r\n          }\r\n        }\r\n      }\r\n\r\n      // Flatten any nested arrays\r\n      return core_concat.apply([], ret);\r\n    },\r\n\r\n    // A global GUID counter for objects\r\n    guid: 1,\r\n\r\n    // Bind a function to a context, optionally partially applying any\r\n    // arguments.\r\n    proxy: function (fn, context) {\r\n      var args, proxy, tmp;\r\n\r\n      if (typeof context === \"string\") {\r\n        tmp = fn[context];\r\n        context = fn;\r\n        fn = tmp;\r\n      }\r\n\r\n      // Quick check to determine if target is callable, in the spec\r\n      // this throws a TypeError, but we will just return undefined.\r\n      if (!jQuery.isFunction(fn)) {\r\n        return undefined;\r\n      }\r\n\r\n      // Simulated bind\r\n      args = core_slice.call(arguments, 2);\r\n      proxy = function () {\r\n        return fn.apply(context || this, args.concat(core_slice.call(arguments)));\r\n      };\r\n\r\n      // Set the guid of unique handler to the same of original handler, so it can be removed\r\n      proxy.guid = fn.guid = fn.guid || jQuery.guid++;\r\n\r\n      return proxy;\r\n    },\r\n\r\n    // Multifunctional method to get and set values of a collection\r\n    // The value/s can optionally be executed if it's a function\r\n    access: function (elems, fn, key, value, chainable, emptyGet, raw) {\r\n      var i = 0,\r\n        length = elems.length,\r\n        bulk = key == null;\r\n\r\n      // Sets many values\r\n      if (jQuery.type(key) === \"object\") {\r\n        chainable = true;\r\n        for (i in key) {\r\n          jQuery.access(elems, fn, i, key[i], true, emptyGet, raw);\r\n        }\r\n\r\n        // Sets one value\r\n      } else if (value !== undefined) {\r\n        chainable = true;\r\n\r\n        if (!jQuery.isFunction(value)) {\r\n          raw = true;\r\n        }\r\n\r\n        if (bulk) {\r\n          // Bulk operations run against the entire set\r\n          if (raw) {\r\n            fn.call(elems, value);\r\n            fn = null;\r\n\r\n            // ...except when executing function values\r\n          } else {\r\n            bulk = fn;\r\n            fn = function (elem, key, value) {\r\n              return bulk.call(jQuery(elem), value);\r\n            };\r\n          }\r\n        }\r\n\r\n        if (fn) {\r\n          for (; i < length; i++) {\r\n            fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));\r\n          }\r\n        }\r\n      }\r\n\r\n      return chainable ?\r\n        elems :\r\n\r\n        // Gets\r\n        bulk ?\r\n          fn.call(elems) :\r\n          length ? fn(elems[0], key) : emptyGet;\r\n    },\r\n\r\n    now: function () {\r\n      return (new Date()).getTime();\r\n    }\r\n  });\r\n\r\n  jQuery.ready.promise = function (obj) {\r\n    if (!readyList) {\r\n\r\n      readyList = jQuery.Deferred();\r\n\r\n      // Catch cases where $(document).ready() is called after the browser event has already occurred.\r\n      // we once tried to use readyState \"interactive\" here, but it caused issues like the one\r\n      // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15\r\n      if (document.readyState === \"complete\") {\r\n        // Handle it asynchronously to allow scripts the opportunity to delay ready\r\n        setTimeout(jQuery.ready);\r\n\r\n        // Standards-based browsers support DOMContentLoaded\r\n      } else if (document.addEventListener) {\r\n        // Use the handy event callback\r\n        document.addEventListener(\"DOMContentLoaded\", completed, false);\r\n\r\n        // A fallback to window.onload, that will always work\r\n        window.addEventListener(\"load\", completed, false);\r\n\r\n        // If IE event model is used\r\n      } else {\r\n        // Ensure firing before onload, maybe late but safe also for iframes\r\n        document.attachEvent(\"onreadystatechange\", completed);\r\n\r\n        // A fallback to window.onload, that will always work\r\n        window.attachEvent(\"onload\", completed);\r\n\r\n        // If IE and not a frame\r\n        // continually check to see if the document is ready\r\n        var top = false;\r\n\r\n        try {\r\n          top = window.frameElement == null && document.documentElement;\r\n        } catch (e) { }\r\n\r\n        if (top && top.doScroll) {\r\n          (function doScrollCheck() {\r\n            if (!jQuery.isReady) {\r\n\r\n              try {\r\n                // Use the trick by Diego Perini\r\n                // http://javascript.nwbox.com/IEContentLoaded/\r\n                top.doScroll(\"left\");\r\n              } catch (e) {\r\n                return setTimeout(doScrollCheck, 50);\r\n              }\r\n\r\n              // detach all dom ready events\r\n              detach();\r\n\r\n              // and execute any waiting functions\r\n              jQuery.ready();\r\n            }\r\n          })();\r\n        }\r\n      }\r\n    }\r\n    return readyList.promise(obj);\r\n  };\r\n\r\n  // Populate the class2type map\r\n  jQuery.each(\"Boolean Number String Function Array Date RegExp Object Error\".split(\" \"), function (i, name) {\r\n    class2type[\"[object \" + name + \"]\"] = name.toLowerCase();\r\n  });\r\n\r\n  function isArraylike(obj) {\r\n    var length = obj.length,\r\n      type = jQuery.type(obj);\r\n\r\n    if (jQuery.isWindow(obj)) {\r\n      return false;\r\n    }\r\n\r\n    if (obj.nodeType === 1 && length) {\r\n      return true;\r\n    }\r\n\r\n    return type === \"array\" || type !== \"function\" &&\r\n      (length === 0 ||\r\n        typeof length === \"number\" && length > 0 && (length - 1) in obj);\r\n  }\r\n\r\n  // All jQuery objects should point back to these\r\n  rootjQuery = jQuery(document);\r\n  // String to Object options format cache\r\n  var optionsCache = {};\r\n\r\n  // Convert String-formatted options into Object-formatted ones and store in cache\r\n  function createOptions(options) {\r\n    var object = optionsCache[options] = {};\r\n    jQuery.each(options.match(core_rnotwhite) || [], function (_, flag) {\r\n      object[flag] = true;\r\n    });\r\n    return object;\r\n  }\r\n\r\n  /*\r\n   * Create a callback list using the following parameters:\r\n   *\r\n   *\toptions: an optional list of space-separated options that will change how\r\n   *\t\t\tthe callback list behaves or a more traditional option object\r\n   *\r\n   * By default a callback list will act like an event callback list and can be\r\n   * \"fired\" multiple times.\r\n   *\r\n   * Possible options:\r\n   *\r\n   *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\r\n   *\r\n   *\tmemory:\t\t\twill keep track of previous values and will call any callback added\r\n   *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\r\n   *\t\t\t\t\tvalues (like a Deferred)\r\n   *\r\n   *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\r\n   *\r\n   *\tstopOnFalse:\tinterrupt callings when a callback returns false\r\n   *\r\n   */\r\n  jQuery.Callbacks = function (options) {\r\n\r\n    // Convert options from String-formatted to Object-formatted if needed\r\n    // (we check in cache first)\r\n    options = typeof options === \"string\" ?\r\n      (optionsCache[options] || createOptions(options)) :\r\n      jQuery.extend({}, options);\r\n\r\n    var // Flag to know if list is currently firing\r\n      firing,\r\n      // Last fire value (for non-forgettable lists)\r\n      memory,\r\n      // Flag to know if list was already fired\r\n      fired,\r\n      // End of the loop when firing\r\n      firingLength,\r\n      // Index of currently firing callback (modified by remove if needed)\r\n      firingIndex,\r\n      // First callback to fire (used internally by add and fireWith)\r\n      firingStart,\r\n      // Actual callback list\r\n      list = [],\r\n      // Stack of fire calls for repeatable lists\r\n      stack = !options.once && [],\r\n      // Fire callbacks\r\n      fire = function (data) {\r\n        memory = options.memory && data;\r\n        fired = true;\r\n        firingIndex = firingStart || 0;\r\n        firingStart = 0;\r\n        firingLength = list.length;\r\n        firing = true;\r\n        for (; list && firingIndex < firingLength; firingIndex++) {\r\n          if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {\r\n            memory = false; // To prevent further calls using add\r\n            break;\r\n          }\r\n        }\r\n        firing = false;\r\n        if (list) {\r\n          if (stack) {\r\n            if (stack.length) {\r\n              fire(stack.shift());\r\n            }\r\n          } else if (memory) {\r\n            list = [];\r\n          } else {\r\n            self.disable();\r\n          }\r\n        }\r\n      },\r\n      // Actual Callbacks object\r\n      self = {\r\n        // Add a callback or a collection of callbacks to the list\r\n        add: function () {\r\n          if (list) {\r\n            // First, we save the current length\r\n            var start = list.length;\r\n            (function add(args) {\r\n              jQuery.each(args, function (_, arg) {\r\n                var type = jQuery.type(arg);\r\n                if (type === \"function\") {\r\n                  if (!options.unique || !self.has(arg)) {\r\n                    list.push(arg);\r\n                  }\r\n                } else if (arg && arg.length && type !== \"string\") {\r\n                  // Inspect recursively\r\n                  add(arg);\r\n                }\r\n              });\r\n            })(arguments);\r\n            // Do we need to add the callbacks to the\r\n            // current firing batch?\r\n            if (firing) {\r\n              firingLength = list.length;\r\n              // With memory, if we're not firing then\r\n              // we should call right away\r\n            } else if (memory) {\r\n              firingStart = start;\r\n              fire(memory);\r\n            }\r\n          }\r\n          return this;\r\n        },\r\n        // Remove a callback from the list\r\n        remove: function () {\r\n          if (list) {\r\n            jQuery.each(arguments, function (_, arg) {\r\n              var index;\r\n              while ((index = jQuery.inArray(arg, list, index)) > -1) {\r\n                list.splice(index, 1);\r\n                // Handle firing indexes\r\n                if (firing) {\r\n                  if (index <= firingLength) {\r\n                    firingLength--;\r\n                  }\r\n                  if (index <= firingIndex) {\r\n                    firingIndex--;\r\n                  }\r\n                }\r\n              }\r\n            });\r\n          }\r\n          return this;\r\n        },\r\n        // Check if a given callback is in the list.\r\n        // If no argument is given, return whether or not list has callbacks attached.\r\n        has: function (fn) {\r\n          return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length);\r\n        },\r\n        // Remove all callbacks from the list\r\n        empty: function () {\r\n          list = [];\r\n          return this;\r\n        },\r\n        // Have the list do nothing anymore\r\n        disable: function () {\r\n          list = stack = memory = undefined;\r\n          return this;\r\n        },\r\n        // Is it disabled?\r\n        disabled: function () {\r\n          return !list;\r\n        },\r\n        // Lock the list in its current state\r\n        lock: function () {\r\n          stack = undefined;\r\n          if (!memory) {\r\n            self.disable();\r\n          }\r\n          return this;\r\n        },\r\n        // Is it locked?\r\n        locked: function () {\r\n          return !stack;\r\n        },\r\n        // Call all callbacks with the given context and arguments\r\n        fireWith: function (context, args) {\r\n          args = args || [];\r\n          args = [context, args.slice ? args.slice() : args];\r\n          if (list && (!fired || stack)) {\r\n            if (firing) {\r\n              stack.push(args);\r\n            } else {\r\n              fire(args);\r\n            }\r\n          }\r\n          return this;\r\n        },\r\n        // Call all the callbacks with the given arguments\r\n        fire: function () {\r\n          self.fireWith(this, arguments);\r\n          return this;\r\n        },\r\n        // To know if the callbacks have already been called at least once\r\n        fired: function () {\r\n          return !!fired;\r\n        }\r\n      };\r\n\r\n    return self;\r\n  };\r\n  jQuery.extend({\r\n\r\n    Deferred: function (func) {\r\n      var tuples = [\r\n        // action, add listener, listener list, final state\r\n        [\"resolve\", \"done\", jQuery.Callbacks(\"once memory\"), \"resolved\"],\r\n        [\"reject\", \"fail\", jQuery.Callbacks(\"once memory\"), \"rejected\"],\r\n        [\"notify\", \"progress\", jQuery.Callbacks(\"memory\")]\r\n      ],\r\n        state = \"pending\",\r\n        promise = {\r\n          state: function () {\r\n            return state;\r\n          },\r\n          always: function () {\r\n            deferred.done(arguments).fail(arguments);\r\n            return this;\r\n          },\r\n          then: function ( /* fnDone, fnFail, fnProgress */) {\r\n            var fns = arguments;\r\n            return jQuery.Deferred(function (newDefer) {\r\n              jQuery.each(tuples, function (i, tuple) {\r\n                var action = tuple[0],\r\n                  fn = jQuery.isFunction(fns[i]) && fns[i];\r\n                // deferred[ done | fail | progress ] for forwarding actions to newDefer\r\n                deferred[tuple[1]](function () {\r\n                  var returned = fn && fn.apply(this, arguments);\r\n                  if (returned && jQuery.isFunction(returned.promise)) {\r\n                    returned.promise()\r\n                      .done(newDefer.resolve)\r\n                      .fail(newDefer.reject)\r\n                      .progress(newDefer.notify);\r\n                  } else {\r\n                    newDefer[action + \"With\"](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);\r\n                  }\r\n                });\r\n              });\r\n              fns = null;\r\n            }).promise();\r\n          },\r\n          // Get a promise for this deferred\r\n          // If obj is provided, the promise aspect is added to the object\r\n          promise: function (obj) {\r\n            return obj != null ? jQuery.extend(obj, promise) : promise;\r\n          }\r\n        },\r\n        deferred = {};\r\n\r\n      // Keep pipe for back-compat\r\n      promise.pipe = promise.then;\r\n\r\n      // Add list-specific methods\r\n      jQuery.each(tuples, function (i, tuple) {\r\n        var list = tuple[2],\r\n          stateString = tuple[3];\r\n\r\n        // promise[ done | fail | progress ] = list.add\r\n        promise[tuple[1]] = list.add;\r\n\r\n        // Handle state\r\n        if (stateString) {\r\n          list.add(function () {\r\n            // state = [ resolved | rejected ]\r\n            state = stateString;\r\n\r\n            // [ reject_list | resolve_list ].disable; progress_list.lock\r\n          }, tuples[i ^ 1][2].disable, tuples[2][2].lock);\r\n        }\r\n\r\n        // deferred[ resolve | reject | notify ]\r\n        deferred[tuple[0]] = function () {\r\n          deferred[tuple[0] + \"With\"](this === deferred ? promise : this, arguments);\r\n          return this;\r\n        };\r\n        deferred[tuple[0] + \"With\"] = list.fireWith;\r\n      });\r\n\r\n      // Make the deferred a promise\r\n      promise.promise(deferred);\r\n\r\n      // Call given func if any\r\n      if (func) {\r\n        func.call(deferred, deferred);\r\n      }\r\n\r\n      // All done!\r\n      return deferred;\r\n    },\r\n\r\n    // Deferred helper\r\n    when: function (subordinate /* , ..., subordinateN */) {\r\n      var i = 0,\r\n        resolveValues = core_slice.call(arguments),\r\n        length = resolveValues.length,\r\n\r\n        // the count of uncompleted subordinates\r\n        remaining = length !== 1 || (subordinate && jQuery.isFunction(subordinate.promise)) ? length : 0,\r\n\r\n        // the master Deferred. If resolveValues consist of only a single Deferred, just use that.\r\n        deferred = remaining === 1 ? subordinate : jQuery.Deferred(),\r\n\r\n        // Update function for both resolve and progress values\r\n        updateFunc = function (i, contexts, values) {\r\n          return function (value) {\r\n            contexts[i] = this;\r\n            values[i] = arguments.length > 1 ? core_slice.call(arguments) : value;\r\n            if (values === progressValues) {\r\n              deferred.notifyWith(contexts, values);\r\n            } else if (!(--remaining)) {\r\n              deferred.resolveWith(contexts, values);\r\n            }\r\n          };\r\n        },\r\n\r\n        progressValues, progressContexts, resolveContexts;\r\n\r\n      // add listeners to Deferred subordinates; treat others as resolved\r\n      if (length > 1) {\r\n        progressValues = new Array(length);\r\n        progressContexts = new Array(length);\r\n        resolveContexts = new Array(length);\r\n        for (; i < length; i++) {\r\n          if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {\r\n            resolveValues[i].promise()\r\n              .done(updateFunc(i, resolveContexts, resolveValues))\r\n              .fail(deferred.reject)\r\n              .progress(updateFunc(i, progressContexts, progressValues));\r\n          } else {\r\n            --remaining;\r\n          }\r\n        }\r\n      }\r\n\r\n      // if we're not waiting on anything, resolve the master\r\n      if (!remaining) {\r\n        deferred.resolveWith(resolveContexts, resolveValues);\r\n      }\r\n\r\n      return deferred.promise();\r\n    }\r\n  });\r\n  jQuery.support = (function () {\r\n\r\n    var support, all, a,\r\n      input, select, fragment,\r\n      opt, eventName, isSupported, i,\r\n      div = document.createElement(\"div\");\r\n\r\n    // Setup\r\n    div.setAttribute(\"className\", \"t\");\r\n    div.innerHTML = \"  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>\";\r\n\r\n    // Support tests won't run in some limited or non-browser environments\r\n    all = div.getElementsByTagName(\"*\");\r\n    a = div.getElementsByTagName(\"a\")[0];\r\n    if (!all || !a || !all.length) {\r\n      return {};\r\n    }\r\n\r\n    // First batch of tests\r\n    select = document.createElement(\"select\");\r\n    opt = select.appendChild(document.createElement(\"option\"));\r\n    input = div.getElementsByTagName(\"input\")[0];\r\n\r\n    a.style.cssText = \"top:1px;float:left;opacity:.5\";\r\n    support = {\r\n      // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)\r\n      getSetAttribute: div.className !== \"t\",\r\n\r\n      // IE strips leading whitespace when .innerHTML is used\r\n      leadingWhitespace: div.firstChild.nodeType === 3,\r\n\r\n      // Make sure that tbody elements aren't automatically inserted\r\n      // IE will insert them into empty tables\r\n      tbody: !div.getElementsByTagName(\"tbody\").length,\r\n\r\n      // Make sure that link elements get serialized correctly by innerHTML\r\n      // This requires a wrapper element in IE\r\n      htmlSerialize: !!div.getElementsByTagName(\"link\").length,\r\n\r\n      // Get the style information from getAttribute\r\n      // (IE uses .cssText instead)\r\n      style: /top/.test(a.getAttribute(\"style\")),\r\n\r\n      // Make sure that URLs aren't manipulated\r\n      // (IE normalizes it by default)\r\n      hrefNormalized: a.getAttribute(\"href\") === \"/a\",\r\n\r\n      // Make sure that element opacity exists\r\n      // (IE uses filter instead)\r\n      // Use a regex to work around a WebKit issue. See #5145\r\n      opacity: /^0.5/.test(a.style.opacity),\r\n\r\n      // Verify style float existence\r\n      // (IE uses styleFloat instead of cssFloat)\r\n      cssFloat: !!a.style.cssFloat,\r\n\r\n      // Check the default checkbox/radio value (\"\" on WebKit; \"on\" elsewhere)\r\n      checkOn: !!input.value,\r\n\r\n      // Make sure that a selected-by-default option has a working selected property.\r\n      // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)\r\n      optSelected: opt.selected,\r\n\r\n      // Tests for enctype support on a form (#6743)\r\n      enctype: !!document.createElement(\"form\").enctype,\r\n\r\n      // Makes sure cloning an html5 element does not cause problems\r\n      // Where outerHTML is undefined, this still works\r\n      html5Clone: document.createElement(\"nav\").cloneNode(true).outerHTML !== \"<:nav></:nav>\",\r\n\r\n      // jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode\r\n      boxModel: document.compatMode === \"CSS1Compat\",\r\n\r\n      // Will be defined later\r\n      deleteExpando: true,\r\n      noCloneEvent: true,\r\n      inlineBlockNeedsLayout: false,\r\n      shrinkWrapBlocks: false,\r\n      reliableMarginRight: true,\r\n      boxSizingReliable: true,\r\n      pixelPosition: false\r\n    };\r\n\r\n    // Make sure checked status is properly cloned\r\n    input.checked = true;\r\n    support.noCloneChecked = input.cloneNode(true).checked;\r\n\r\n    // Make sure that the options inside disabled selects aren't marked as disabled\r\n    // (WebKit marks them as disabled)\r\n    select.disabled = true;\r\n    support.optDisabled = !opt.disabled;\r\n\r\n    // Support: IE<9\r\n    try {\r\n      delete div.test;\r\n    } catch (e) {\r\n      support.deleteExpando = false;\r\n    }\r\n\r\n    // Check if we can trust getAttribute(\"value\")\r\n    input = document.createElement(\"input\");\r\n    input.setAttribute(\"value\", \"\");\r\n    support.input = input.getAttribute(\"value\") === \"\";\r\n\r\n    // Check if an input maintains its value after becoming a radio\r\n    input.value = \"t\";\r\n    input.setAttribute(\"type\", \"radio\");\r\n    support.radioValue = input.value === \"t\";\r\n\r\n    // #11217 - WebKit loses check when the name is after the checked attribute\r\n    input.setAttribute(\"checked\", \"t\");\r\n    input.setAttribute(\"name\", \"t\");\r\n\r\n    fragment = document.createDocumentFragment();\r\n    fragment.appendChild(input);\r\n\r\n    // Check if a disconnected checkbox will retain its checked\r\n    // value of true after appended to the DOM (IE6/7)\r\n    support.appendChecked = input.checked;\r\n\r\n    // WebKit doesn't clone checked state correctly in fragments\r\n    support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;\r\n\r\n    // Support: IE<9\r\n    // Opera does not clone events (and typeof div.attachEvent === undefined).\r\n    // IE9-10 clones events bound via attachEvent, but they don't trigger with .click()\r\n    if (div.attachEvent) {\r\n      div.attachEvent(\"onclick\", function () {\r\n        support.noCloneEvent = false;\r\n      });\r\n\r\n      div.cloneNode(true).click();\r\n    }\r\n\r\n    // Support: IE<9 (lack submit/change bubble), Firefox 17+ (lack focusin event)\r\n    // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP), test/csp.php\r\n    for (i in { submit: true, change: true, focusin: true }) {\r\n      div.setAttribute(eventName = \"on\" + i, \"t\");\r\n\r\n      support[i + \"Bubbles\"] = eventName in window || div.attributes[eventName].expando === false;\r\n    }\r\n\r\n    div.style.backgroundClip = \"content-box\";\r\n    div.cloneNode(true).style.backgroundClip = \"\";\r\n    support.clearCloneStyle = div.style.backgroundClip === \"content-box\";\r\n\r\n    // Run tests that need a body at doc ready\r\n    jQuery(function () {\r\n      var container, marginDiv, tds,\r\n        divReset = \"padding:0;margin:0;border:0;display:block;box-sizing:content-box;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;\",\r\n        body = document.getElementsByTagName(\"body\")[0];\r\n\r\n      if (!body) {\r\n        // Return for frameset docs that don't have a body\r\n        return;\r\n      }\r\n\r\n      container = document.createElement(\"div\");\r\n      container.style.cssText = \"border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px\";\r\n\r\n      body.appendChild(container).appendChild(div);\r\n\r\n      // Support: IE8\r\n      // Check if table cells still have offsetWidth/Height when they are set\r\n      // to display:none and there are still other visible table cells in a\r\n      // table row; if so, offsetWidth/Height are not reliable for use when\r\n      // determining if an element has been hidden directly using\r\n      // display:none (it is still safe to use offsets if a parent element is\r\n      // hidden; don safety goggles and see bug #4512 for more information).\r\n      div.innerHTML = \"<table><tr><td></td><td>t</td></tr></table>\";\r\n      tds = div.getElementsByTagName(\"td\");\r\n      tds[0].style.cssText = \"padding:0;margin:0;border:0;display:none\";\r\n      isSupported = (tds[0].offsetHeight === 0);\r\n\r\n      tds[0].style.display = \"\";\r\n      tds[1].style.display = \"none\";\r\n\r\n      // Support: IE8\r\n      // Check if empty table cells still have offsetWidth/Height\r\n      support.reliableHiddenOffsets = isSupported && (tds[0].offsetHeight === 0);\r\n\r\n      // Check box-sizing and margin behavior\r\n      div.innerHTML = \"\";\r\n      div.style.cssText = \"box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;\";\r\n      support.boxSizing = (div.offsetWidth === 4);\r\n      support.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== 1);\r\n\r\n      // Use window.getComputedStyle because jsdom on node.js will break without it.\r\n      if (window.getComputedStyle) {\r\n        support.pixelPosition = (window.getComputedStyle(div, null) || {}).top !== \"1%\";\r\n        support.boxSizingReliable = (window.getComputedStyle(div, null) || { width: \"4px\" }).width === \"4px\";\r\n\r\n        // Check if div with explicit width and no margin-right incorrectly\r\n        // gets computed margin-right based on width of container. (#3333)\r\n        // Fails in WebKit before Feb 2011 nightlies\r\n        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right\r\n        marginDiv = div.appendChild(document.createElement(\"div\"));\r\n        marginDiv.style.cssText = div.style.cssText = divReset;\r\n        marginDiv.style.marginRight = marginDiv.style.width = \"0\";\r\n        div.style.width = \"1px\";\r\n\r\n        support.reliableMarginRight =\r\n          !parseFloat((window.getComputedStyle(marginDiv, null) || {}).marginRight);\r\n      }\r\n\r\n      if (typeof div.style.zoom !== core_strundefined) {\r\n        // Support: IE<8\r\n        // Check if natively block-level elements act like inline-block\r\n        // elements when setting their display to 'inline' and giving\r\n        // them layout\r\n        div.innerHTML = \"\";\r\n        div.style.cssText = divReset + \"width:1px;padding:1px;display:inline;zoom:1\";\r\n        support.inlineBlockNeedsLayout = (div.offsetWidth === 3);\r\n\r\n        // Support: IE6\r\n        // Check if elements with layout shrink-wrap their children\r\n        div.style.display = \"block\";\r\n        div.innerHTML = \"<div></div>\";\r\n        div.firstChild.style.width = \"5px\";\r\n        support.shrinkWrapBlocks = (div.offsetWidth !== 3);\r\n\r\n        if (support.inlineBlockNeedsLayout) {\r\n          // Prevent IE 6 from affecting layout for positioned elements #11048\r\n          // Prevent IE from shrinking the body in IE 7 mode #12869\r\n          // Support: IE<8\r\n          body.style.zoom = 1;\r\n        }\r\n      }\r\n\r\n      body.removeChild(container);\r\n\r\n      // Null elements to avoid leaks in IE\r\n      container = div = tds = marginDiv = null;\r\n    });\r\n\r\n    // Null elements to avoid leaks in IE\r\n    all = select = fragment = opt = a = input = null;\r\n\r\n    return support;\r\n  })();\r\n\r\n  var rbrace = /(?:\\{[\\s\\S]*\\}|\\[[\\s\\S]*\\])$/,\r\n    rmultiDash = /([A-Z])/g;\r\n\r\n  function internalData(elem, name, data, pvt /* Internal Use Only */) {\r\n    if (!jQuery.acceptData(elem)) {\r\n      return;\r\n    }\r\n\r\n    var thisCache, ret,\r\n      internalKey = jQuery.expando,\r\n      getByName = typeof name === \"string\",\r\n\r\n      // We have to handle DOM nodes and JS objects differently because IE6-7\r\n      // can't GC object references properly across the DOM-JS boundary\r\n      isNode = elem.nodeType,\r\n\r\n      // Only DOM nodes need the global jQuery cache; JS object data is\r\n      // attached directly to the object so GC can occur automatically\r\n      cache = isNode ? jQuery.cache : elem,\r\n\r\n      // Only defining an ID for JS objects if its cache already exists allows\r\n      // the code to shortcut on the same path as a DOM node with no cache\r\n      id = isNode ? elem[internalKey] : elem[internalKey] && internalKey;\r\n\r\n    // Avoid doing any more work than we need to when trying to get data on an\r\n    // object that has no data at all\r\n    if ((!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined) {\r\n      return;\r\n    }\r\n\r\n    if (!id) {\r\n      // Only DOM nodes need a new unique ID for each element since their data\r\n      // ends up in the global cache\r\n      if (isNode) {\r\n        elem[internalKey] = id = core_deletedIds.pop() || jQuery.guid++;\r\n      } else {\r\n        id = internalKey;\r\n      }\r\n    }\r\n\r\n    if (!cache[id]) {\r\n      cache[id] = {};\r\n\r\n      // Avoids exposing jQuery metadata on plain JS objects when the object\r\n      // is serialized using JSON.stringify\r\n      if (!isNode) {\r\n        cache[id].toJSON = jQuery.noop;\r\n      }\r\n    }\r\n\r\n    // An object can be passed to jQuery.data instead of a key/value pair; this gets\r\n    // shallow copied over onto the existing cache\r\n    if (typeof name === \"object\" || typeof name === \"function\") {\r\n      if (pvt) {\r\n        cache[id] = jQuery.extend(cache[id], name);\r\n      } else {\r\n        cache[id].data = jQuery.extend(cache[id].data, name);\r\n      }\r\n    }\r\n\r\n    thisCache = cache[id];\r\n\r\n    // jQuery data() is stored in a separate object inside the object's internal data\r\n    // cache in order to avoid key collisions between internal data and user-defined\r\n    // data.\r\n    if (!pvt) {\r\n      if (!thisCache.data) {\r\n        thisCache.data = {};\r\n      }\r\n\r\n      thisCache = thisCache.data;\r\n    }\r\n\r\n    if (data !== undefined) {\r\n      thisCache[jQuery.camelCase(name)] = data;\r\n    }\r\n\r\n    // Check for both converted-to-camel and non-converted data property names\r\n    // If a data property was specified\r\n    if (getByName) {\r\n\r\n      // First Try to find as-is property data\r\n      ret = thisCache[name];\r\n\r\n      // Test for null|undefined property data\r\n      if (ret == null) {\r\n\r\n        // Try to find the camelCased property\r\n        ret = thisCache[jQuery.camelCase(name)];\r\n      }\r\n    } else {\r\n      ret = thisCache;\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  function internalRemoveData(elem, name, pvt) {\r\n    if (!jQuery.acceptData(elem)) {\r\n      return;\r\n    }\r\n\r\n    var i, l, thisCache,\r\n      isNode = elem.nodeType,\r\n\r\n      // See jQuery.data for more information\r\n      cache = isNode ? jQuery.cache : elem,\r\n      id = isNode ? elem[jQuery.expando] : jQuery.expando;\r\n\r\n    // If there is already no cache entry for this object, there is no\r\n    // purpose in continuing\r\n    if (!cache[id]) {\r\n      return;\r\n    }\r\n\r\n    if (name) {\r\n\r\n      thisCache = pvt ? cache[id] : cache[id].data;\r\n\r\n      if (thisCache) {\r\n\r\n        // Support array or space separated string names for data keys\r\n        if (!jQuery.isArray(name)) {\r\n\r\n          // try the string as a key before any manipulation\r\n          if (name in thisCache) {\r\n            name = [name];\r\n          } else {\r\n\r\n            // split the camel cased version by spaces unless a key with the spaces exists\r\n            name = jQuery.camelCase(name);\r\n            if (name in thisCache) {\r\n              name = [name];\r\n            } else {\r\n              name = name.split(\" \");\r\n            }\r\n          }\r\n        } else {\r\n          // If \"name\" is an array of keys...\r\n          // When data is initially created, via (\"key\", \"val\") signature,\r\n          // keys will be converted to camelCase.\r\n          // Since there is no way to tell _how_ a key was added, remove\r\n          // both plain key and camelCase key. #12786\r\n          // This will only penalize the array argument path.\r\n          name = name.concat(jQuery.map(name, jQuery.camelCase));\r\n        }\r\n\r\n        for (i = 0, l = name.length; i < l; i++) {\r\n          delete thisCache[name[i]];\r\n        }\r\n\r\n        // If there is no data left in the cache, we want to continue\r\n        // and let the cache object itself get destroyed\r\n        if (!(pvt ? isEmptyDataObject : jQuery.isEmptyObject)(thisCache)) {\r\n          return;\r\n        }\r\n      }\r\n    }\r\n\r\n    // See jQuery.data for more information\r\n    if (!pvt) {\r\n      delete cache[id].data;\r\n\r\n      // Don't destroy the parent cache unless the internal data object\r\n      // had been the only thing left in it\r\n      if (!isEmptyDataObject(cache[id])) {\r\n        return;\r\n      }\r\n    }\r\n\r\n    // Destroy the cache\r\n    if (isNode) {\r\n      jQuery.cleanData([elem], true);\r\n\r\n      // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)\r\n    } else if (jQuery.support.deleteExpando || cache != cache.window) {\r\n      delete cache[id];\r\n\r\n      // When all else fails, null\r\n    } else {\r\n      cache[id] = null;\r\n    }\r\n  }\r\n\r\n  jQuery.extend({\r\n    cache: {},\r\n\r\n    // Unique for each copy of jQuery on the page\r\n    // Non-digits removed to match rinlinejQuery\r\n    expando: \"jQuery\" + (core_version + Math.random()).replace(/\\D/g, \"\"),\r\n\r\n    // The following elements throw uncatchable exceptions if you\r\n    // attempt to add expando properties to them.\r\n    noData: {\r\n      \"embed\": true,\r\n      // Ban all objects except for Flash (which handle expandos)\r\n      \"object\": \"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\",\r\n      \"applet\": true\r\n    },\r\n\r\n    hasData: function (elem) {\r\n      elem = elem.nodeType ? jQuery.cache[elem[jQuery.expando]] : elem[jQuery.expando];\r\n      return !!elem && !isEmptyDataObject(elem);\r\n    },\r\n\r\n    data: function (elem, name, data) {\r\n      return internalData(elem, name, data);\r\n    },\r\n\r\n    removeData: function (elem, name) {\r\n      return internalRemoveData(elem, name);\r\n    },\r\n\r\n    // For internal use only.\r\n    _data: function (elem, name, data) {\r\n      return internalData(elem, name, data, true);\r\n    },\r\n\r\n    _removeData: function (elem, name) {\r\n      return internalRemoveData(elem, name, true);\r\n    },\r\n\r\n    // A method for determining if a DOM node can handle the data expando\r\n    acceptData: function (elem) {\r\n      // Do not set data on non-element because it will not be cleared (#8335).\r\n      if (elem.nodeType && elem.nodeType !== 1 && elem.nodeType !== 9) {\r\n        return false;\r\n      }\r\n\r\n      var noData = elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()];\r\n\r\n      // nodes accept data unless otherwise specified; rejection can be conditional\r\n      return !noData || noData !== true && elem.getAttribute(\"classid\") === noData;\r\n    }\r\n  });\r\n\r\n  jQuery.fn.extend({\r\n    data: function (key, value) {\r\n      var attrs, name,\r\n        elem = this[0],\r\n        i = 0,\r\n        data = null;\r\n\r\n      // Gets all values\r\n      if (key === undefined) {\r\n        if (this.length) {\r\n          data = jQuery.data(elem);\r\n\r\n          if (elem.nodeType === 1 && !jQuery._data(elem, \"parsedAttrs\")) {\r\n            attrs = elem.attributes;\r\n            for (; i < attrs.length; i++) {\r\n              name = attrs[i].name;\r\n\r\n              if (!name.indexOf(\"data-\")) {\r\n                name = jQuery.camelCase(name.slice(5));\r\n\r\n                dataAttr(elem, name, data[name]);\r\n              }\r\n            }\r\n            jQuery._data(elem, \"parsedAttrs\", true);\r\n          }\r\n        }\r\n\r\n        return data;\r\n      }\r\n\r\n      // Sets multiple values\r\n      if (typeof key === \"object\") {\r\n        return this.each(function () {\r\n          jQuery.data(this, key);\r\n        });\r\n      }\r\n\r\n      return jQuery.access(this, function (value) {\r\n\r\n        if (value === undefined) {\r\n          // Try to fetch any internally stored data first\r\n          return elem ? dataAttr(elem, key, jQuery.data(elem, key)) : null;\r\n        }\r\n\r\n        this.each(function () {\r\n          jQuery.data(this, key, value);\r\n        });\r\n      }, null, value, arguments.length > 1, null, true);\r\n    },\r\n\r\n    removeData: function (key) {\r\n      return this.each(function () {\r\n        jQuery.removeData(this, key);\r\n      });\r\n    }\r\n  });\r\n\r\n  function dataAttr(elem, key, data) {\r\n    // If nothing was found internally, try to fetch any\r\n    // data from the HTML5 data-* attribute\r\n    if (data === undefined && elem.nodeType === 1) {\r\n\r\n      var name = \"data-\" + key.replace(rmultiDash, \"-$1\").toLowerCase();\r\n\r\n      data = elem.getAttribute(name);\r\n\r\n      if (typeof data === \"string\") {\r\n        try {\r\n          data = data === \"true\" ? true :\r\n            data === \"false\" ? false :\r\n              data === \"null\" ? null :\r\n                // Only convert to a number if it doesn't change the string\r\n                +data + \"\" === data ? +data :\r\n                  rbrace.test(data) ? jQuery.parseJSON(data) :\r\n                    data;\r\n        } catch (e) { }\r\n\r\n        // Make sure we set the data so it isn't changed later\r\n        jQuery.data(elem, key, data);\r\n\r\n      } else {\r\n        data = undefined;\r\n      }\r\n    }\r\n\r\n    return data;\r\n  }\r\n\r\n  // checks a cache object for emptiness\r\n  function isEmptyDataObject(obj) {\r\n    var name;\r\n    for (name in obj) {\r\n\r\n      // if the public data object is empty, the private is still empty\r\n      if (name === \"data\" && jQuery.isEmptyObject(obj[name])) {\r\n        continue;\r\n      }\r\n      if (name !== \"toJSON\") {\r\n        return false;\r\n      }\r\n    }\r\n\r\n    return true;\r\n  }\r\n  jQuery.extend({\r\n    queue: function (elem, type, data) {\r\n      var queue;\r\n\r\n      if (elem) {\r\n        type = (type || \"fx\") + \"queue\";\r\n        queue = jQuery._data(elem, type);\r\n\r\n        // Speed up dequeue by getting out quickly if this is just a lookup\r\n        if (data) {\r\n          if (!queue || jQuery.isArray(data)) {\r\n            queue = jQuery._data(elem, type, jQuery.makeArray(data));\r\n          } else {\r\n            queue.push(data);\r\n          }\r\n        }\r\n        return queue || [];\r\n      }\r\n    },\r\n\r\n    dequeue: function (elem, type) {\r\n      type = type || \"fx\";\r\n\r\n      var queue = jQuery.queue(elem, type),\r\n        startLength = queue.length,\r\n        fn = queue.shift(),\r\n        hooks = jQuery._queueHooks(elem, type),\r\n        next = function () {\r\n          jQuery.dequeue(elem, type);\r\n        };\r\n\r\n      // If the fx queue is dequeued, always remove the progress sentinel\r\n      if (fn === \"inprogress\") {\r\n        fn = queue.shift();\r\n        startLength--;\r\n      }\r\n\r\n      hooks.cur = fn;\r\n      if (fn) {\r\n\r\n        // Add a progress sentinel to prevent the fx queue from being\r\n        // automatically dequeued\r\n        if (type === \"fx\") {\r\n          queue.unshift(\"inprogress\");\r\n        }\r\n\r\n        // clear up the last queue stop function\r\n        delete hooks.stop;\r\n        fn.call(elem, next, hooks);\r\n      }\r\n\r\n      if (!startLength && hooks) {\r\n        hooks.empty.fire();\r\n      }\r\n    },\r\n\r\n    // not intended for public consumption - generates a queueHooks object, or returns the current one\r\n    _queueHooks: function (elem, type) {\r\n      var key = type + \"queueHooks\";\r\n      return jQuery._data(elem, key) || jQuery._data(elem, key, {\r\n        empty: jQuery.Callbacks(\"once memory\").add(function () {\r\n          jQuery._removeData(elem, type + \"queue\");\r\n          jQuery._removeData(elem, key);\r\n        })\r\n      });\r\n    }\r\n  });\r\n\r\n  jQuery.fn.extend({\r\n    queue: function (type, data) {\r\n      var setter = 2;\r\n\r\n      if (typeof type !== \"string\") {\r\n        data = type;\r\n        type = \"fx\";\r\n        setter--;\r\n      }\r\n\r\n      if (arguments.length < setter) {\r\n        return jQuery.queue(this[0], type);\r\n      }\r\n\r\n      return data === undefined ?\r\n        this :\r\n        this.each(function () {\r\n          var queue = jQuery.queue(this, type, data);\r\n\r\n          // ensure a hooks for this queue\r\n          jQuery._queueHooks(this, type);\r\n\r\n          if (type === \"fx\" && queue[0] !== \"inprogress\") {\r\n            jQuery.dequeue(this, type);\r\n          }\r\n        });\r\n    },\r\n    dequeue: function (type) {\r\n      return this.each(function () {\r\n        jQuery.dequeue(this, type);\r\n      });\r\n    },\r\n    // Based off of the plugin by Clint Helfers, with permission.\r\n    // http://blindsignals.com/index.php/2009/07/jquery-delay/\r\n    delay: function (time, type) {\r\n      time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;\r\n      type = type || \"fx\";\r\n\r\n      return this.queue(type, function (next, hooks) {\r\n        var timeout = setTimeout(next, time);\r\n        hooks.stop = function () {\r\n          clearTimeout(timeout);\r\n        };\r\n      });\r\n    },\r\n    clearQueue: function (type) {\r\n      return this.queue(type || \"fx\", []);\r\n    },\r\n    // Get a promise resolved when queues of a certain type\r\n    // are emptied (fx is the type by default)\r\n    promise: function (type, obj) {\r\n      var tmp,\r\n        count = 1,\r\n        defer = jQuery.Deferred(),\r\n        elements = this,\r\n        i = this.length,\r\n        resolve = function () {\r\n          if (!(--count)) {\r\n            defer.resolveWith(elements, [elements]);\r\n          }\r\n        };\r\n\r\n      if (typeof type !== \"string\") {\r\n        obj = type;\r\n        type = undefined;\r\n      }\r\n      type = type || \"fx\";\r\n\r\n      while (i--) {\r\n        tmp = jQuery._data(elements[i], type + \"queueHooks\");\r\n        if (tmp && tmp.empty) {\r\n          count++;\r\n          tmp.empty.add(resolve);\r\n        }\r\n      }\r\n      resolve();\r\n      return defer.promise(obj);\r\n    }\r\n  });\r\n  var nodeHook, boolHook,\r\n    rclass = /[\\t\\r\\n]/g,\r\n    rreturn = /\\r/g,\r\n    rfocusable = /^(?:input|select|textarea|button|object)$/i,\r\n    rclickable = /^(?:a|area)$/i,\r\n    rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,\r\n    ruseDefault = /^(?:checked|selected)$/i,\r\n    getSetAttribute = jQuery.support.getSetAttribute,\r\n    getSetInput = jQuery.support.input;\r\n\r\n  jQuery.fn.extend({\r\n    attr: function (name, value) {\r\n      return jQuery.access(this, jQuery.attr, name, value, arguments.length > 1);\r\n    },\r\n\r\n    removeAttr: function (name) {\r\n      return this.each(function () {\r\n        jQuery.removeAttr(this, name);\r\n      });\r\n    },\r\n\r\n    prop: function (name, value) {\r\n      return jQuery.access(this, jQuery.prop, name, value, arguments.length > 1);\r\n    },\r\n\r\n    removeProp: function (name) {\r\n      name = jQuery.propFix[name] || name;\r\n      return this.each(function () {\r\n        // try/catch handles cases where IE balks (such as removing a property on window)\r\n        try {\r\n          this[name] = undefined;\r\n          delete this[name];\r\n        } catch (e) { }\r\n      });\r\n    },\r\n\r\n    addClass: function (value) {\r\n      var classes, elem, cur, clazz, j,\r\n        i = 0,\r\n        len = this.length,\r\n        proceed = typeof value === \"string\" && value;\r\n\r\n      if (jQuery.isFunction(value)) {\r\n        return this.each(function (j) {\r\n          jQuery(this).addClass(value.call(this, j, this.className));\r\n        });\r\n      }\r\n\r\n      if (proceed) {\r\n        // The disjunction here is for better compressibility (see removeClass)\r\n        classes = (value || \"\").match(core_rnotwhite) || [];\r\n\r\n        for (; i < len; i++) {\r\n          elem = this[i];\r\n          cur = elem.nodeType === 1 && (elem.className ?\r\n            (\" \" + elem.className + \" \").replace(rclass, \" \") :\r\n            \" \"\r\n          );\r\n\r\n          if (cur) {\r\n            j = 0;\r\n            while ((clazz = classes[j++])) {\r\n              if (cur.indexOf(\" \" + clazz + \" \") < 0) {\r\n                cur += clazz + \" \";\r\n              }\r\n            }\r\n            elem.className = jQuery.trim(cur);\r\n\r\n          }\r\n        }\r\n      }\r\n\r\n      return this;\r\n    },\r\n\r\n    removeClass: function (value) {\r\n      var classes, elem, cur, clazz, j,\r\n        i = 0,\r\n        len = this.length,\r\n        proceed = arguments.length === 0 || typeof value === \"string\" && value;\r\n\r\n      if (jQuery.isFunction(value)) {\r\n        return this.each(function (j) {\r\n          jQuery(this).removeClass(value.call(this, j, this.className));\r\n        });\r\n      }\r\n      if (proceed) {\r\n        classes = (value || \"\").match(core_rnotwhite) || [];\r\n\r\n        for (; i < len; i++) {\r\n          elem = this[i];\r\n          // This expression is here for better compressibility (see addClass)\r\n          cur = elem.nodeType === 1 && (elem.className ?\r\n            (\" \" + elem.className + \" \").replace(rclass, \" \") :\r\n            \"\"\r\n          );\r\n\r\n          if (cur) {\r\n            j = 0;\r\n            while ((clazz = classes[j++])) {\r\n              // Remove *all* instances\r\n              while (cur.indexOf(\" \" + clazz + \" \") >= 0) {\r\n                cur = cur.replace(\" \" + clazz + \" \", \" \");\r\n              }\r\n            }\r\n            elem.className = value ? jQuery.trim(cur) : \"\";\r\n          }\r\n        }\r\n      }\r\n\r\n      return this;\r\n    },\r\n\r\n    toggleClass: function (value, stateVal) {\r\n      var type = typeof value,\r\n        isBool = typeof stateVal === \"boolean\";\r\n\r\n      if (jQuery.isFunction(value)) {\r\n        return this.each(function (i) {\r\n          jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);\r\n        });\r\n      }\r\n\r\n      return this.each(function () {\r\n        if (type === \"string\") {\r\n          // toggle individual class names\r\n          var className,\r\n            i = 0,\r\n            self = jQuery(this),\r\n            state = stateVal,\r\n            classNames = value.match(core_rnotwhite) || [];\r\n\r\n          while ((className = classNames[i++])) {\r\n            // check each className given, space separated list\r\n            state = isBool ? state : !self.hasClass(className);\r\n            self[state ? \"addClass\" : \"removeClass\"](className);\r\n          }\r\n\r\n          // Toggle whole class name\r\n        } else if (type === core_strundefined || type === \"boolean\") {\r\n          if (this.className) {\r\n            // store className if set\r\n            jQuery._data(this, \"__className__\", this.className);\r\n          }\r\n\r\n          // If the element has a class name or if we're passed \"false\",\r\n          // then remove the whole classname (if there was one, the above saved it).\r\n          // Otherwise bring back whatever was previously saved (if anything),\r\n          // falling back to the empty string if nothing was stored.\r\n          this.className = this.className || value === false ? \"\" : jQuery._data(this, \"__className__\") || \"\";\r\n        }\r\n      });\r\n    },\r\n\r\n    hasClass: function (selector) {\r\n      var className = \" \" + selector + \" \",\r\n        i = 0,\r\n        l = this.length;\r\n      for (; i < l; i++) {\r\n        if (this[i].nodeType === 1 && (\" \" + this[i].className + \" \").replace(rclass, \" \").indexOf(className) >= 0) {\r\n          return true;\r\n        }\r\n      }\r\n\r\n      return false;\r\n    },\r\n\r\n    val: function (value) {\r\n      var ret, hooks, isFunction,\r\n        elem = this[0];\r\n\r\n      if (!arguments.length) {\r\n        if (elem) {\r\n          hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];\r\n\r\n          if (hooks && \"get\" in hooks && (ret = hooks.get(elem, \"value\")) !== undefined) {\r\n            return ret;\r\n          }\r\n\r\n          ret = elem.value;\r\n\r\n          return typeof ret === \"string\" ?\r\n            // handle most common string cases\r\n            ret.replace(rreturn, \"\") :\r\n            // handle cases where value is null/undef or number\r\n            ret == null ? \"\" : ret;\r\n        }\r\n\r\n        return;\r\n      }\r\n\r\n      isFunction = jQuery.isFunction(value);\r\n\r\n      return this.each(function (i) {\r\n        var val,\r\n          self = jQuery(this);\r\n\r\n        if (this.nodeType !== 1) {\r\n          return;\r\n        }\r\n\r\n        if (isFunction) {\r\n          val = value.call(this, i, self.val());\r\n        } else {\r\n          val = value;\r\n        }\r\n\r\n        // Treat null/undefined as \"\"; convert numbers to string\r\n        if (val == null) {\r\n          val = \"\";\r\n        } else if (typeof val === \"number\") {\r\n          val += \"\";\r\n        } else if (jQuery.isArray(val)) {\r\n          val = jQuery.map(val, function (value) {\r\n            return value == null ? \"\" : value + \"\";\r\n          });\r\n        }\r\n\r\n        hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];\r\n\r\n        // If set returns undefined, fall back to normal setting\r\n        if (!hooks || !(\"set\" in hooks) || hooks.set(this, val, \"value\") === undefined) {\r\n          this.value = val;\r\n        }\r\n      });\r\n    }\r\n  });\r\n\r\n  jQuery.extend({\r\n    valHooks: {\r\n      option: {\r\n        get: function (elem) {\r\n          // attributes.value is undefined in Blackberry 4.7 but\r\n          // uses .value. See #6932\r\n          var val = elem.attributes.value;\r\n          return !val || val.specified ? elem.value : elem.text;\r\n        }\r\n      },\r\n      select: {\r\n        get: function (elem) {\r\n          var value, option,\r\n            options = elem.options,\r\n            index = elem.selectedIndex,\r\n            one = elem.type === \"select-one\" || index < 0,\r\n            values = one ? null : [],\r\n            max = one ? index + 1 : options.length,\r\n            i = index < 0 ?\r\n              max :\r\n              one ? index : 0;\r\n\r\n          // Loop through all the selected options\r\n          for (; i < max; i++) {\r\n            option = options[i];\r\n\r\n            // oldIE doesn't update selected after form reset (#2551)\r\n            if ((option.selected || i === index) &&\r\n              // Don't return options that are disabled or in a disabled optgroup\r\n              (jQuery.support.optDisabled ? !option.disabled : option.getAttribute(\"disabled\") === null) &&\r\n              (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, \"optgroup\"))) {\r\n\r\n              // Get the specific value for the option\r\n              value = jQuery(option).val();\r\n\r\n              // We don't need an array for one selects\r\n              if (one) {\r\n                return value;\r\n              }\r\n\r\n              // Multi-Selects return an array\r\n              values.push(value);\r\n            }\r\n          }\r\n\r\n          return values;\r\n        },\r\n\r\n        set: function (elem, value) {\r\n          var values = jQuery.makeArray(value);\r\n\r\n          jQuery(elem).find(\"option\").each(function () {\r\n            this.selected = jQuery.inArray(jQuery(this).val(), values) >= 0;\r\n          });\r\n\r\n          if (!values.length) {\r\n            elem.selectedIndex = -1;\r\n          }\r\n          return values;\r\n        }\r\n      }\r\n    },\r\n\r\n    attr: function (elem, name, value) {\r\n      var hooks, notxml, ret,\r\n        nType = elem.nodeType;\r\n\r\n      // don't get/set attributes on text, comment and attribute nodes\r\n      if (!elem || nType === 3 || nType === 8 || nType === 2) {\r\n        return;\r\n      }\r\n\r\n      // Fallback to prop when attributes are not supported\r\n      if (typeof elem.getAttribute === core_strundefined) {\r\n        return jQuery.prop(elem, name, value);\r\n      }\r\n\r\n      notxml = nType !== 1 || !jQuery.isXMLDoc(elem);\r\n\r\n      // All attributes are lowercase\r\n      // Grab necessary hook if one is defined\r\n      if (notxml) {\r\n        name = name.toLowerCase();\r\n        hooks = jQuery.attrHooks[name] || (rboolean.test(name) ? boolHook : nodeHook);\r\n      }\r\n\r\n      if (value !== undefined) {\r\n\r\n        if (value === null) {\r\n          jQuery.removeAttr(elem, name);\r\n\r\n        } else if (hooks && notxml && \"set\" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {\r\n          return ret;\r\n\r\n        } else {\r\n          elem.setAttribute(name, value + \"\");\r\n          return value;\r\n        }\r\n\r\n      } else if (hooks && notxml && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\r\n        return ret;\r\n\r\n      } else {\r\n\r\n        // In IE9+, Flash objects don't have .getAttribute (#12945)\r\n        // Support: IE9+\r\n        if (typeof elem.getAttribute !== core_strundefined) {\r\n          ret = elem.getAttribute(name);\r\n        }\r\n\r\n        // Non-existent attributes return null, we normalize to undefined\r\n        return ret == null ?\r\n          undefined :\r\n          ret;\r\n      }\r\n    },\r\n\r\n    removeAttr: function (elem, value) {\r\n      var name, propName,\r\n        i = 0,\r\n        attrNames = value && value.match(core_rnotwhite);\r\n\r\n      if (attrNames && elem.nodeType === 1) {\r\n        while ((name = attrNames[i++])) {\r\n          propName = jQuery.propFix[name] || name;\r\n\r\n          // Boolean attributes get special treatment (#10870)\r\n          if (rboolean.test(name)) {\r\n            // Set corresponding property to false for boolean attributes\r\n            // Also clear defaultChecked/defaultSelected (if appropriate) for IE<8\r\n            if (!getSetAttribute && ruseDefault.test(name)) {\r\n              elem[jQuery.camelCase(\"default-\" + name)] =\r\n                elem[propName] = false;\r\n            } else {\r\n              elem[propName] = false;\r\n            }\r\n\r\n            // See #9699 for explanation of this approach (setting first, then removal)\r\n          } else {\r\n            jQuery.attr(elem, name, \"\");\r\n          }\r\n\r\n          elem.removeAttribute(getSetAttribute ? name : propName);\r\n        }\r\n      }\r\n    },\r\n\r\n    attrHooks: {\r\n      type: {\r\n        set: function (elem, value) {\r\n          if (!jQuery.support.radioValue && value === \"radio\" && jQuery.nodeName(elem, \"input\")) {\r\n            // Setting the type on a radio button after the value resets the value in IE6-9\r\n            // Reset value to default in case type is set after value during creation\r\n            var val = elem.value;\r\n            elem.setAttribute(\"type\", value);\r\n            if (val) {\r\n              elem.value = val;\r\n            }\r\n            return value;\r\n          }\r\n        }\r\n      }\r\n    },\r\n\r\n    propFix: {\r\n      tabindex: \"tabIndex\",\r\n      readonly: \"readOnly\",\r\n      \"for\": \"htmlFor\",\r\n      \"class\": \"className\",\r\n      maxlength: \"maxLength\",\r\n      cellspacing: \"cellSpacing\",\r\n      cellpadding: \"cellPadding\",\r\n      rowspan: \"rowSpan\",\r\n      colspan: \"colSpan\",\r\n      usemap: \"useMap\",\r\n      frameborder: \"frameBorder\",\r\n      contenteditable: \"contentEditable\"\r\n    },\r\n\r\n    prop: function (elem, name, value) {\r\n      var ret, hooks, notxml,\r\n        nType = elem.nodeType;\r\n\r\n      // don't get/set properties on text, comment and attribute nodes\r\n      if (!elem || nType === 3 || nType === 8 || nType === 2) {\r\n        return;\r\n      }\r\n\r\n      notxml = nType !== 1 || !jQuery.isXMLDoc(elem);\r\n\r\n      if (notxml) {\r\n        // Fix name and attach hooks\r\n        name = jQuery.propFix[name] || name;\r\n        hooks = jQuery.propHooks[name];\r\n      }\r\n\r\n      if (value !== undefined) {\r\n        if (hooks && \"set\" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {\r\n          return ret;\r\n\r\n        } else {\r\n          return (elem[name] = value);\r\n        }\r\n\r\n      } else {\r\n        if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\r\n          return ret;\r\n\r\n        } else {\r\n          return elem[name];\r\n        }\r\n      }\r\n    },\r\n\r\n    propHooks: {\r\n      tabIndex: {\r\n        get: function (elem) {\r\n          // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set\r\n          // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\r\n          var attributeNode = elem.getAttributeNode(\"tabindex\");\r\n\r\n          return attributeNode && attributeNode.specified ?\r\n            parseInt(attributeNode.value, 10) :\r\n            rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ?\r\n              0 :\r\n              undefined;\r\n        }\r\n      }\r\n    }\r\n  });\r\n\r\n  // Hook for boolean attributes\r\n  boolHook = {\r\n    get: function (elem, name) {\r\n      var\r\n        // Use .prop to determine if this attribute is understood as boolean\r\n        prop = jQuery.prop(elem, name),\r\n\r\n        // Fetch it accordingly\r\n        attr = typeof prop === \"boolean\" && elem.getAttribute(name),\r\n        detail = typeof prop === \"boolean\" ?\r\n\r\n          getSetInput && getSetAttribute ?\r\n            attr != null :\r\n            // oldIE fabricates an empty string for missing boolean attributes\r\n            // and conflates checked/selected into attroperties\r\n            ruseDefault.test(name) ?\r\n              elem[jQuery.camelCase(\"default-\" + name)] :\r\n              !!attr :\r\n\r\n          // fetch an attribute node for properties not recognized as boolean\r\n          elem.getAttributeNode(name);\r\n\r\n      return detail && detail.value !== false ?\r\n        name.toLowerCase() :\r\n        undefined;\r\n    },\r\n    set: function (elem, value, name) {\r\n      if (value === false) {\r\n        // Remove boolean attributes when set to false\r\n        jQuery.removeAttr(elem, name);\r\n      } else if (getSetInput && getSetAttribute || !ruseDefault.test(name)) {\r\n        // IE<8 needs the *property* name\r\n        elem.setAttribute(!getSetAttribute && jQuery.propFix[name] || name, name);\r\n\r\n        // Use defaultChecked and defaultSelected for oldIE\r\n      } else {\r\n        elem[jQuery.camelCase(\"default-\" + name)] = elem[name] = true;\r\n      }\r\n\r\n      return name;\r\n    }\r\n  };\r\n\r\n  // fix oldIE value attroperty\r\n  if (!getSetInput || !getSetAttribute) {\r\n    jQuery.attrHooks.value = {\r\n      get: function (elem, name) {\r\n        var ret = elem.getAttributeNode(name);\r\n        return jQuery.nodeName(elem, \"input\") ?\r\n\r\n          // Ignore the value *property* by using defaultValue\r\n          elem.defaultValue :\r\n\r\n          ret && ret.specified ? ret.value : undefined;\r\n      },\r\n      set: function (elem, value, name) {\r\n        if (jQuery.nodeName(elem, \"input\")) {\r\n          // Does not return so that setAttribute is also used\r\n          elem.defaultValue = value;\r\n        } else {\r\n          // Use nodeHook if defined (#1954); otherwise setAttribute is fine\r\n          return nodeHook && nodeHook.set(elem, value, name);\r\n        }\r\n      }\r\n    };\r\n  }\r\n\r\n  // IE6/7 do not support getting/setting some attributes with get/setAttribute\r\n  if (!getSetAttribute) {\r\n\r\n    // Use this for any attribute in IE6/7\r\n    // This fixes almost every IE6/7 issue\r\n    nodeHook = jQuery.valHooks.button = {\r\n      get: function (elem, name) {\r\n        var ret = elem.getAttributeNode(name);\r\n        return ret && (name === \"id\" || name === \"name\" || name === \"coords\" ? ret.value !== \"\" : ret.specified) ?\r\n          ret.value :\r\n          undefined;\r\n      },\r\n      set: function (elem, value, name) {\r\n        // Set the existing or create a new attribute node\r\n        var ret = elem.getAttributeNode(name);\r\n        if (!ret) {\r\n          elem.setAttributeNode(\r\n            (ret = elem.ownerDocument.createAttribute(name))\r\n          );\r\n        }\r\n\r\n        ret.value = value += \"\";\r\n\r\n        // Break association with cloned elements by also using setAttribute (#9646)\r\n        return name === \"value\" || value === elem.getAttribute(name) ?\r\n          value :\r\n          undefined;\r\n      }\r\n    };\r\n\r\n    // Set contenteditable to false on removals(#10429)\r\n    // Setting to empty string throws an error as an invalid value\r\n    jQuery.attrHooks.contenteditable = {\r\n      get: nodeHook.get,\r\n      set: function (elem, value, name) {\r\n        nodeHook.set(elem, value === \"\" ? false : value, name);\r\n      }\r\n    };\r\n\r\n    // Set width and height to auto instead of 0 on empty string( Bug #8150 )\r\n    // This is for removals\r\n    jQuery.each([\"width\", \"height\"], function (i, name) {\r\n      jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {\r\n        set: function (elem, value) {\r\n          if (value === \"\") {\r\n            elem.setAttribute(name, \"auto\");\r\n            return value;\r\n          }\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n\r\n  // Some attributes require a special call on IE\r\n  // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\r\n  if (!jQuery.support.hrefNormalized) {\r\n    jQuery.each([\"href\", \"src\", \"width\", \"height\"], function (i, name) {\r\n      jQuery.attrHooks[name] = jQuery.extend(jQuery.attrHooks[name], {\r\n        get: function (elem) {\r\n          var ret = elem.getAttribute(name, 2);\r\n          return ret == null ? undefined : ret;\r\n        }\r\n      });\r\n    });\r\n\r\n    // href/src property should get the full normalized URL (#10299/#12915)\r\n    jQuery.each([\"href\", \"src\"], function (i, name) {\r\n      jQuery.propHooks[name] = {\r\n        get: function (elem) {\r\n          return elem.getAttribute(name, 4);\r\n        }\r\n      };\r\n    });\r\n  }\r\n\r\n  if (!jQuery.support.style) {\r\n    jQuery.attrHooks.style = {\r\n      get: function (elem) {\r\n        // Return undefined in the case of empty string\r\n        // Note: IE uppercases css property names, but if we were to .toLowerCase()\r\n        // .cssText, that would destroy case senstitivity in URL's, like in \"background\"\r\n        return elem.style.cssText || undefined;\r\n      },\r\n      set: function (elem, value) {\r\n        return (elem.style.cssText = value + \"\");\r\n      }\r\n    };\r\n  }\r\n\r\n  // Safari mis-reports the default selected property of an option\r\n  // Accessing the parent's selectedIndex property fixes it\r\n  if (!jQuery.support.optSelected) {\r\n    jQuery.propHooks.selected = jQuery.extend(jQuery.propHooks.selected, {\r\n      get: function (elem) {\r\n        var parent = elem.parentNode;\r\n\r\n        if (parent) {\r\n          parent.selectedIndex;\r\n\r\n          // Make sure that it also works with optgroups, see #5701\r\n          if (parent.parentNode) {\r\n            parent.parentNode.selectedIndex;\r\n          }\r\n        }\r\n        return null;\r\n      }\r\n    });\r\n  }\r\n\r\n  // IE6/7 call enctype encoding\r\n  if (!jQuery.support.enctype) {\r\n    jQuery.propFix.enctype = \"encoding\";\r\n  }\r\n\r\n  // Radios and checkboxes getter/setter\r\n  if (!jQuery.support.checkOn) {\r\n    jQuery.each([\"radio\", \"checkbox\"], function () {\r\n      jQuery.valHooks[this] = {\r\n        get: function (elem) {\r\n          // Handle the case where in Webkit \"\" is returned instead of \"on\" if a value isn't specified\r\n          return elem.getAttribute(\"value\") === null ? \"on\" : elem.value;\r\n        }\r\n      };\r\n    });\r\n  }\r\n  jQuery.each([\"radio\", \"checkbox\"], function () {\r\n    jQuery.valHooks[this] = jQuery.extend(jQuery.valHooks[this], {\r\n      set: function (elem, value) {\r\n        if (jQuery.isArray(value)) {\r\n          return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0);\r\n        }\r\n      }\r\n    });\r\n  });\r\n  var rformElems = /^(?:input|select|textarea)$/i,\r\n    rkeyEvent = /^key/,\r\n    rmouseEvent = /^(?:mouse|contextmenu)|click/,\r\n    rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\r\n    rtypenamespace = /^([^.]*)(?:\\.(.+)|)$/;\r\n\r\n  function returnTrue() {\r\n    return true;\r\n  }\r\n\r\n  function returnFalse() {\r\n    return false;\r\n  }\r\n\r\n  /*\r\n   * Helper functions for managing events -- not part of the public interface.\r\n   * Props to Dean Edwards' addEvent library for many of the ideas.\r\n   */\r\n  jQuery.event = {\r\n\r\n    global: {},\r\n\r\n    add: function (elem, types, handler, data, selector) {\r\n      var tmp, events, t, handleObjIn,\r\n        special, eventHandle, handleObj,\r\n        handlers, type, namespaces, origType,\r\n        elemData = jQuery._data(elem);\r\n\r\n      // Don't attach events to noData or text/comment nodes (but allow plain objects)\r\n      if (!elemData) {\r\n        return;\r\n      }\r\n\r\n      // Caller can pass in an object of custom data in lieu of the handler\r\n      if (handler.handler) {\r\n        handleObjIn = handler;\r\n        handler = handleObjIn.handler;\r\n        selector = handleObjIn.selector;\r\n      }\r\n\r\n      // Make sure that the handler has a unique ID, used to find/remove it later\r\n      if (!handler.guid) {\r\n        handler.guid = jQuery.guid++;\r\n      }\r\n\r\n      // Init the element's event structure and main handler, if this is the first\r\n      if (!(events = elemData.events)) {\r\n        events = elemData.events = {};\r\n      }\r\n      if (!(eventHandle = elemData.handle)) {\r\n        eventHandle = elemData.handle = function (e) {\r\n          // Discard the second event of a jQuery.event.trigger() and\r\n          // when an event is called after a page has unloaded\r\n          return typeof jQuery !== core_strundefined && (!e || jQuery.event.triggered !== e.type) ?\r\n            jQuery.event.dispatch.apply(eventHandle.elem, arguments) :\r\n            undefined;\r\n        };\r\n        // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events\r\n        eventHandle.elem = elem;\r\n      }\r\n\r\n      // Handle multiple events separated by a space\r\n      // jQuery(...).bind(\"mouseover mouseout\", fn);\r\n      types = (types || \"\").match(core_rnotwhite) || [\"\"];\r\n      t = types.length;\r\n      while (t--) {\r\n        tmp = rtypenamespace.exec(types[t]) || [];\r\n        type = origType = tmp[1];\r\n        namespaces = (tmp[2] || \"\").split(\".\").sort();\r\n\r\n        // If event changes its type, use the special event handlers for the changed type\r\n        special = jQuery.event.special[type] || {};\r\n\r\n        // If selector defined, determine special event api type, otherwise given type\r\n        type = (selector ? special.delegateType : special.bindType) || type;\r\n\r\n        // Update special based on newly reset type\r\n        special = jQuery.event.special[type] || {};\r\n\r\n        // handleObj is passed to all event handlers\r\n        handleObj = jQuery.extend({\r\n          type: type,\r\n          origType: origType,\r\n          data: data,\r\n          handler: handler,\r\n          guid: handler.guid,\r\n          selector: selector,\r\n          needsContext: selector && jQuery.expr.match.needsContext.test(selector),\r\n          namespace: namespaces.join(\".\")\r\n        }, handleObjIn);\r\n\r\n        // Init the event handler queue if we're the first\r\n        if (!(handlers = events[type])) {\r\n          handlers = events[type] = [];\r\n          handlers.delegateCount = 0;\r\n\r\n          // Only use addEventListener/attachEvent if the special events handler returns false\r\n          if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {\r\n            // Bind the global event handler to the element\r\n            if (elem.addEventListener) {\r\n              elem.addEventListener(type, eventHandle, false);\r\n\r\n            } else if (elem.attachEvent) {\r\n              elem.attachEvent(\"on\" + type, eventHandle);\r\n            }\r\n          }\r\n        }\r\n\r\n        if (special.add) {\r\n          special.add.call(elem, handleObj);\r\n\r\n          if (!handleObj.handler.guid) {\r\n            handleObj.handler.guid = handler.guid;\r\n          }\r\n        }\r\n\r\n        // Add to the element's handler list, delegates in front\r\n        if (selector) {\r\n          handlers.splice(handlers.delegateCount++, 0, handleObj);\r\n        } else {\r\n          handlers.push(handleObj);\r\n        }\r\n\r\n        // Keep track of which events have ever been used, for event optimization\r\n        jQuery.event.global[type] = true;\r\n      }\r\n\r\n      // Nullify elem to prevent memory leaks in IE\r\n      elem = null;\r\n    },\r\n\r\n    // Detach an event or set of events from an element\r\n    remove: function (elem, types, handler, selector, mappedTypes) {\r\n      var j, handleObj, tmp,\r\n        origCount, t, events,\r\n        special, handlers, type,\r\n        namespaces, origType,\r\n        elemData = jQuery.hasData(elem) && jQuery._data(elem);\r\n\r\n      if (!elemData || !(events = elemData.events)) {\r\n        return;\r\n      }\r\n\r\n      // Once for each type.namespace in types; type may be omitted\r\n      types = (types || \"\").match(core_rnotwhite) || [\"\"];\r\n      t = types.length;\r\n      while (t--) {\r\n        tmp = rtypenamespace.exec(types[t]) || [];\r\n        type = origType = tmp[1];\r\n        namespaces = (tmp[2] || \"\").split(\".\").sort();\r\n\r\n        // Unbind all events (on this namespace, if provided) for the element\r\n        if (!type) {\r\n          for (type in events) {\r\n            jQuery.event.remove(elem, type + types[t], handler, selector, true);\r\n          }\r\n          continue;\r\n        }\r\n\r\n        special = jQuery.event.special[type] || {};\r\n        type = (selector ? special.delegateType : special.bindType) || type;\r\n        handlers = events[type] || [];\r\n        tmp = tmp[2] && new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\");\r\n\r\n        // Remove matching events\r\n        origCount = j = handlers.length;\r\n        while (j--) {\r\n          handleObj = handlers[j];\r\n\r\n          if ((mappedTypes || origType === handleObj.origType) &&\r\n            (!handler || handler.guid === handleObj.guid) &&\r\n            (!tmp || tmp.test(handleObj.namespace)) &&\r\n            (!selector || selector === handleObj.selector || selector === \"**\" && handleObj.selector)) {\r\n            handlers.splice(j, 1);\r\n\r\n            if (handleObj.selector) {\r\n              handlers.delegateCount--;\r\n            }\r\n            if (special.remove) {\r\n              special.remove.call(elem, handleObj);\r\n            }\r\n          }\r\n        }\r\n\r\n        // Remove generic event handler if we removed something and no more handlers exist\r\n        // (avoids potential for endless recursion during removal of special event handlers)\r\n        if (origCount && !handlers.length) {\r\n          if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {\r\n            jQuery.removeEvent(elem, type, elemData.handle);\r\n          }\r\n\r\n          delete events[type];\r\n        }\r\n      }\r\n\r\n      // Remove the expando if it's no longer used\r\n      if (jQuery.isEmptyObject(events)) {\r\n        delete elemData.handle;\r\n\r\n        // removeData also checks for emptiness and clears the expando if empty\r\n        // so use it instead of delete\r\n        jQuery._removeData(elem, \"events\");\r\n      }\r\n    },\r\n\r\n    trigger: function (event, data, elem, onlyHandlers) {\r\n      var handle, ontype, cur,\r\n        bubbleType, special, tmp, i,\r\n        eventPath = [elem || document],\r\n        type = core_hasOwn.call(event, \"type\") ? event.type : event,\r\n        namespaces = core_hasOwn.call(event, \"namespace\") ? event.namespace.split(\".\") : [];\r\n\r\n      cur = tmp = elem = elem || document;\r\n\r\n      // Don't do events on text and comment nodes\r\n      if (elem.nodeType === 3 || elem.nodeType === 8) {\r\n        return;\r\n      }\r\n\r\n      // focus/blur morphs to focusin/out; ensure we're not firing them right now\r\n      if (rfocusMorph.test(type + jQuery.event.triggered)) {\r\n        return;\r\n      }\r\n\r\n      if (type.indexOf(\".\") >= 0) {\r\n        // Namespaced trigger; create a regexp to match event type in handle()\r\n        namespaces = type.split(\".\");\r\n        type = namespaces.shift();\r\n        namespaces.sort();\r\n      }\r\n      ontype = type.indexOf(\":\") < 0 && \"on\" + type;\r\n\r\n      // Caller can pass in a jQuery.Event object, Object, or just an event type string\r\n      event = event[jQuery.expando] ?\r\n        event :\r\n        new jQuery.Event(type, typeof event === \"object\" && event);\r\n\r\n      event.isTrigger = true;\r\n      event.namespace = namespaces.join(\".\");\r\n      event.namespace_re = event.namespace ?\r\n        new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\") :\r\n        null;\r\n\r\n      // Clean up the event in case it is being reused\r\n      event.result = undefined;\r\n      if (!event.target) {\r\n        event.target = elem;\r\n      }\r\n\r\n      // Clone any incoming data and prepend the event, creating the handler arg list\r\n      data = data == null ?\r\n        [event] :\r\n        jQuery.makeArray(data, [event]);\r\n\r\n      // Allow special events to draw outside the lines\r\n      special = jQuery.event.special[type] || {};\r\n      if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {\r\n        return;\r\n      }\r\n\r\n      // Determine event propagation path in advance, per W3C events spec (#9951)\r\n      // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\r\n      if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {\r\n\r\n        bubbleType = special.delegateType || type;\r\n        if (!rfocusMorph.test(bubbleType + type)) {\r\n          cur = cur.parentNode;\r\n        }\r\n        for (; cur; cur = cur.parentNode) {\r\n          eventPath.push(cur);\r\n          tmp = cur;\r\n        }\r\n\r\n        // Only add window if we got to document (e.g., not plain obj or detached DOM)\r\n        if (tmp === (elem.ownerDocument || document)) {\r\n          eventPath.push(tmp.defaultView || tmp.parentWindow || window);\r\n        }\r\n      }\r\n\r\n      // Fire handlers on the event path\r\n      i = 0;\r\n      while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {\r\n\r\n        event.type = i > 1 ?\r\n          bubbleType :\r\n          special.bindType || type;\r\n\r\n        // jQuery handler\r\n        handle = (jQuery._data(cur, \"events\") || {})[event.type] && jQuery._data(cur, \"handle\");\r\n        if (handle) {\r\n          handle.apply(cur, data);\r\n        }\r\n\r\n        // Native handler\r\n        handle = ontype && cur[ontype];\r\n        if (handle && jQuery.acceptData(cur) && handle.apply && handle.apply(cur, data) === false) {\r\n          event.preventDefault();\r\n        }\r\n      }\r\n      event.type = type;\r\n\r\n      // If nobody prevented the default action, do it now\r\n      if (!onlyHandlers && !event.isDefaultPrevented()) {\r\n\r\n        if ((!special._default || special._default.apply(elem.ownerDocument, data) === false) &&\r\n          !(type === \"click\" && jQuery.nodeName(elem, \"a\")) && jQuery.acceptData(elem)) {\r\n\r\n          // Call a native DOM method on the target with the same name name as the event.\r\n          // Can't use an .isFunction() check here because IE6/7 fails that test.\r\n          // Don't do default actions on window, that's where global variables be (#6170)\r\n          if (ontype && elem[type] && !jQuery.isWindow(elem)) {\r\n\r\n            // Don't re-trigger an onFOO event when we call its FOO() method\r\n            tmp = elem[ontype];\r\n\r\n            if (tmp) {\r\n              elem[ontype] = null;\r\n            }\r\n\r\n            // Prevent re-triggering of the same event, since we already bubbled it above\r\n            jQuery.event.triggered = type;\r\n            try {\r\n              elem[type]();\r\n            } catch (e) {\r\n              // IE<9 dies on focus/blur to hidden element (#1486,#12518)\r\n              // only reproducible on winXP IE8 native, not IE9 in IE8 mode\r\n            }\r\n            jQuery.event.triggered = undefined;\r\n\r\n            if (tmp) {\r\n              elem[ontype] = tmp;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return event.result;\r\n    },\r\n\r\n    dispatch: function (event) {\r\n\r\n      // Make a writable jQuery.Event from the native event object\r\n      event = jQuery.event.fix(event);\r\n\r\n      var i, ret, handleObj, matched, j,\r\n        handlerQueue = [],\r\n        args = core_slice.call(arguments),\r\n        handlers = (jQuery._data(this, \"events\") || {})[event.type] || [],\r\n        special = jQuery.event.special[event.type] || {};\r\n\r\n      // Use the fix-ed jQuery.Event rather than the (read-only) native event\r\n      args[0] = event;\r\n      event.delegateTarget = this;\r\n\r\n      // Call the preDispatch hook for the mapped type, and let it bail if desired\r\n      if (special.preDispatch && special.preDispatch.call(this, event) === false) {\r\n        return;\r\n      }\r\n\r\n      // Determine handlers\r\n      handlerQueue = jQuery.event.handlers.call(this, event, handlers);\r\n\r\n      // Run delegates first; they may want to stop propagation beneath us\r\n      i = 0;\r\n      while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {\r\n        event.currentTarget = matched.elem;\r\n\r\n        j = 0;\r\n        while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {\r\n\r\n          // Triggered event must either 1) have no namespace, or\r\n          // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).\r\n          if (!event.namespace_re || event.namespace_re.test(handleObj.namespace)) {\r\n\r\n            event.handleObj = handleObj;\r\n            event.data = handleObj.data;\r\n\r\n            ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler)\r\n              .apply(matched.elem, args);\r\n\r\n            if (ret !== undefined) {\r\n              if ((event.result = ret) === false) {\r\n                event.preventDefault();\r\n                event.stopPropagation();\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // Call the postDispatch hook for the mapped type\r\n      if (special.postDispatch) {\r\n        special.postDispatch.call(this, event);\r\n      }\r\n\r\n      return event.result;\r\n    },\r\n\r\n    handlers: function (event, handlers) {\r\n      var sel, handleObj, matches, i,\r\n        handlerQueue = [],\r\n        delegateCount = handlers.delegateCount,\r\n        cur = event.target;\r\n\r\n      // Find delegate handlers\r\n      // Black-hole SVG <use> instance trees (#13180)\r\n      // Avoid non-left-click bubbling in Firefox (#3861)\r\n      if (delegateCount && cur.nodeType && (!event.button || event.type !== \"click\")) {\r\n\r\n        for (; cur != this; cur = cur.parentNode || this) {\r\n\r\n          // Don't check non-elements (#13208)\r\n          // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\r\n          if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== \"click\")) {\r\n            matches = [];\r\n            for (i = 0; i < delegateCount; i++) {\r\n              handleObj = handlers[i];\r\n\r\n              // Don't conflict with Object.prototype properties (#13203)\r\n              sel = handleObj.selector + \" \";\r\n\r\n              if (matches[sel] === undefined) {\r\n                matches[sel] = handleObj.needsContext ?\r\n                  jQuery(sel, this).index(cur) >= 0 :\r\n                  jQuery.find(sel, this, null, [cur]).length;\r\n              }\r\n              if (matches[sel]) {\r\n                matches.push(handleObj);\r\n              }\r\n            }\r\n            if (matches.length) {\r\n              handlerQueue.push({ elem: cur, handlers: matches });\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // Add the remaining (directly-bound) handlers\r\n      if (delegateCount < handlers.length) {\r\n        handlerQueue.push({ elem: this, handlers: handlers.slice(delegateCount) });\r\n      }\r\n\r\n      return handlerQueue;\r\n    },\r\n\r\n    fix: function (event) {\r\n      if (event[jQuery.expando]) {\r\n        return event;\r\n      }\r\n\r\n      // Create a writable copy of the event object and normalize some properties\r\n      var i, prop, copy,\r\n        type = event.type,\r\n        originalEvent = event,\r\n        fixHook = this.fixHooks[type];\r\n\r\n      if (!fixHook) {\r\n        this.fixHooks[type] = fixHook =\r\n          rmouseEvent.test(type) ? this.mouseHooks :\r\n            rkeyEvent.test(type) ? this.keyHooks :\r\n              {};\r\n      }\r\n      copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;\r\n\r\n      event = new jQuery.Event(originalEvent);\r\n\r\n      i = copy.length;\r\n      while (i--) {\r\n        prop = copy[i];\r\n        event[prop] = originalEvent[prop];\r\n      }\r\n\r\n      // Support: IE<9\r\n      // Fix target property (#1925)\r\n      if (!event.target) {\r\n        event.target = originalEvent.srcElement || document;\r\n      }\r\n\r\n      // Support: Chrome 23+, Safari?\r\n      // Target should not be a text node (#504, #13143)\r\n      if (event.target.nodeType === 3) {\r\n        event.target = event.target.parentNode;\r\n      }\r\n\r\n      // Support: IE<9\r\n      // For mouse/key events, metaKey==false if it's undefined (#3368, #11328)\r\n      event.metaKey = !!event.metaKey;\r\n\r\n      return fixHook.filter ? fixHook.filter(event, originalEvent) : event;\r\n    },\r\n\r\n    // Includes some event props shared by KeyEvent and MouseEvent\r\n    props: \"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which\".split(\" \"),\r\n\r\n    fixHooks: {},\r\n\r\n    keyHooks: {\r\n      props: \"char charCode key keyCode\".split(\" \"),\r\n      filter: function (event, original) {\r\n\r\n        // Add which for key events\r\n        if (event.which == null) {\r\n          event.which = original.charCode != null ? original.charCode : original.keyCode;\r\n        }\r\n\r\n        return event;\r\n      }\r\n    },\r\n\r\n    mouseHooks: {\r\n      props: \"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement\".split(\" \"),\r\n      filter: function (event, original) {\r\n        var body, eventDoc, doc,\r\n          button = original.button,\r\n          fromElement = original.fromElement;\r\n\r\n        // Calculate pageX/Y if missing and clientX/Y available\r\n        if (event.pageX == null && original.clientX != null) {\r\n          eventDoc = event.target.ownerDocument || document;\r\n          doc = eventDoc.documentElement;\r\n          body = eventDoc.body;\r\n\r\n          event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);\r\n          event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);\r\n        }\r\n\r\n        // Add relatedTarget, if necessary\r\n        if (!event.relatedTarget && fromElement) {\r\n          event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;\r\n        }\r\n\r\n        // Add which for click: 1 === left; 2 === middle; 3 === right\r\n        // Note: button is not normalized, so don't use it\r\n        if (!event.which && button !== undefined) {\r\n          event.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));\r\n        }\r\n\r\n        return event;\r\n      }\r\n    },\r\n\r\n    special: {\r\n      load: {\r\n        // Prevent triggered image.load events from bubbling to window.load\r\n        noBubble: true\r\n      },\r\n      click: {\r\n        // For checkbox, fire native event so checked state will be right\r\n        trigger: function () {\r\n          if (jQuery.nodeName(this, \"input\") && this.type === \"checkbox\" && this.click) {\r\n            this.click();\r\n            return false;\r\n          }\r\n        }\r\n      },\r\n      focus: {\r\n        // Fire native event if possible so blur/focus sequence is correct\r\n        trigger: function () {\r\n          if (this !== document.activeElement && this.focus) {\r\n            try {\r\n              this.focus();\r\n              return false;\r\n            } catch (e) {\r\n              // Support: IE<9\r\n              // If we error on focus to hidden element (#1486, #12518),\r\n              // let .trigger() run the handlers\r\n            }\r\n          }\r\n        },\r\n        delegateType: \"focusin\"\r\n      },\r\n      blur: {\r\n        trigger: function () {\r\n          if (this === document.activeElement && this.blur) {\r\n            this.blur();\r\n            return false;\r\n          }\r\n        },\r\n        delegateType: \"focusout\"\r\n      },\r\n\r\n      beforeunload: {\r\n        postDispatch: function (event) {\r\n\r\n          // Even when returnValue equals to undefined Firefox will still show alert\r\n          if (event.result !== undefined) {\r\n            event.originalEvent.returnValue = event.result;\r\n          }\r\n        }\r\n      }\r\n    },\r\n\r\n    simulate: function (type, elem, event, bubble) {\r\n      // Piggyback on a donor event to simulate a different one.\r\n      // Fake originalEvent to avoid donor's stopPropagation, but if the\r\n      // simulated event prevents default then we do the same on the donor.\r\n      var e = jQuery.extend(\r\n        new jQuery.Event(),\r\n        event,\r\n        {\r\n          type: type,\r\n          isSimulated: true,\r\n          originalEvent: {}\r\n        }\r\n      );\r\n      if (bubble) {\r\n        jQuery.event.trigger(e, null, elem);\r\n      } else {\r\n        jQuery.event.dispatch.call(elem, e);\r\n      }\r\n      if (e.isDefaultPrevented()) {\r\n        event.preventDefault();\r\n      }\r\n    }\r\n  };\r\n\r\n  jQuery.removeEvent = document.removeEventListener ?\r\n    function (elem, type, handle) {\r\n      if (elem.removeEventListener) {\r\n        elem.removeEventListener(type, handle, false);\r\n      }\r\n    } :\r\n    function (elem, type, handle) {\r\n      var name = \"on\" + type;\r\n\r\n      if (elem.detachEvent) {\r\n\r\n        // #8545, #7054, preventing memory leaks for custom events in IE6-8\r\n        // detachEvent needed property on element, by name of that event, to properly expose it to GC\r\n        if (typeof elem[name] === core_strundefined) {\r\n          elem[name] = null;\r\n        }\r\n\r\n        elem.detachEvent(name, handle);\r\n      }\r\n    };\r\n\r\n  jQuery.Event = function (src, props) {\r\n    // Allow instantiation without the 'new' keyword\r\n    if (!(this instanceof jQuery.Event)) {\r\n      return new jQuery.Event(src, props);\r\n    }\r\n\r\n    // Event object\r\n    if (src && src.type) {\r\n      this.originalEvent = src;\r\n      this.type = src.type;\r\n\r\n      // Events bubbling up the document may have been marked as prevented\r\n      // by a handler lower down the tree; reflect the correct value.\r\n      this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||\r\n        src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;\r\n\r\n      // Event type\r\n    } else {\r\n      this.type = src;\r\n    }\r\n\r\n    // Put explicitly provided properties onto the event object\r\n    if (props) {\r\n      jQuery.extend(this, props);\r\n    }\r\n\r\n    // Create a timestamp if incoming event doesn't have one\r\n    this.timeStamp = src && src.timeStamp || jQuery.now();\r\n\r\n    // Mark it as fixed\r\n    this[jQuery.expando] = true;\r\n  };\r\n\r\n  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\r\n  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\r\n  jQuery.Event.prototype = {\r\n    isDefaultPrevented: returnFalse,\r\n    isPropagationStopped: returnFalse,\r\n    isImmediatePropagationStopped: returnFalse,\r\n\r\n    preventDefault: function () {\r\n      var e = this.originalEvent;\r\n\r\n      this.isDefaultPrevented = returnTrue;\r\n      if (!e) {\r\n        return;\r\n      }\r\n\r\n      // If preventDefault exists, run it on the original event\r\n      if (e.preventDefault) {\r\n        e.preventDefault();\r\n\r\n        // Support: IE\r\n        // Otherwise set the returnValue property of the original event to false\r\n      } else {\r\n        e.returnValue = false;\r\n      }\r\n    },\r\n    stopPropagation: function () {\r\n      var e = this.originalEvent;\r\n\r\n      this.isPropagationStopped = returnTrue;\r\n      if (!e) {\r\n        return;\r\n      }\r\n      // If stopPropagation exists, run it on the original event\r\n      if (e.stopPropagation) {\r\n        e.stopPropagation();\r\n      }\r\n\r\n      // Support: IE\r\n      // Set the cancelBubble property of the original event to true\r\n      e.cancelBubble = true;\r\n    },\r\n    stopImmediatePropagation: function () {\r\n      this.isImmediatePropagationStopped = returnTrue;\r\n      this.stopPropagation();\r\n    }\r\n  };\r\n\r\n  // Create mouseenter/leave events using mouseover/out and event-time checks\r\n  jQuery.each({\r\n    mouseenter: \"mouseover\",\r\n    mouseleave: \"mouseout\"\r\n  }, function (orig, fix) {\r\n    jQuery.event.special[orig] = {\r\n      delegateType: fix,\r\n      bindType: fix,\r\n\r\n      handle: function (event) {\r\n        var ret,\r\n          target = this,\r\n          related = event.relatedTarget,\r\n          handleObj = event.handleObj;\r\n\r\n        // For mousenter/leave call the handler if related is outside the target.\r\n        // NB: No relatedTarget if the mouse left/entered the browser window\r\n        if (!related || (related !== target && !jQuery.contains(target, related))) {\r\n          event.type = handleObj.origType;\r\n          ret = handleObj.handler.apply(this, arguments);\r\n          event.type = fix;\r\n        }\r\n        return ret;\r\n      }\r\n    };\r\n  });\r\n\r\n  // IE submit delegation\r\n  if (!jQuery.support.submitBubbles) {\r\n\r\n    jQuery.event.special.submit = {\r\n      setup: function () {\r\n        // Only need this for delegated form submit events\r\n        if (jQuery.nodeName(this, \"form\")) {\r\n          return false;\r\n        }\r\n\r\n        // Lazy-add a submit handler when a descendant form may potentially be submitted\r\n        jQuery.event.add(this, \"click._submit keypress._submit\", function (e) {\r\n          // Node name check avoids a VML-related crash in IE (#9807)\r\n          var elem = e.target,\r\n            form = jQuery.nodeName(elem, \"input\") || jQuery.nodeName(elem, \"button\") ? elem.form : undefined;\r\n          if (form && !jQuery._data(form, \"submitBubbles\")) {\r\n            jQuery.event.add(form, \"submit._submit\", function (event) {\r\n              event._submit_bubble = true;\r\n            });\r\n            jQuery._data(form, \"submitBubbles\", true);\r\n          }\r\n        });\r\n        // return undefined since we don't need an event listener\r\n      },\r\n\r\n      postDispatch: function (event) {\r\n        // If form was submitted by the user, bubble the event up the tree\r\n        if (event._submit_bubble) {\r\n          delete event._submit_bubble;\r\n          if (this.parentNode && !event.isTrigger) {\r\n            jQuery.event.simulate(\"submit\", this.parentNode, event, true);\r\n          }\r\n        }\r\n      },\r\n\r\n      teardown: function () {\r\n        // Only need this for delegated form submit events\r\n        if (jQuery.nodeName(this, \"form\")) {\r\n          return false;\r\n        }\r\n\r\n        // Remove delegated handlers; cleanData eventually reaps submit handlers attached above\r\n        jQuery.event.remove(this, \"._submit\");\r\n      }\r\n    };\r\n  }\r\n\r\n  // IE change delegation and checkbox/radio fix\r\n  if (!jQuery.support.changeBubbles) {\r\n\r\n    jQuery.event.special.change = {\r\n\r\n      setup: function () {\r\n\r\n        if (rformElems.test(this.nodeName)) {\r\n          // IE doesn't fire change on a check/radio until blur; trigger it on click\r\n          // after a propertychange. Eat the blur-change in special.change.handle.\r\n          // This still fires onchange a second time for check/radio after blur.\r\n          if (this.type === \"checkbox\" || this.type === \"radio\") {\r\n            jQuery.event.add(this, \"propertychange._change\", function (event) {\r\n              if (event.originalEvent.propertyName === \"checked\") {\r\n                this._just_changed = true;\r\n              }\r\n            });\r\n            jQuery.event.add(this, \"click._change\", function (event) {\r\n              if (this._just_changed && !event.isTrigger) {\r\n                this._just_changed = false;\r\n              }\r\n              // Allow triggered, simulated change events (#11500)\r\n              jQuery.event.simulate(\"change\", this, event, true);\r\n            });\r\n          }\r\n          return false;\r\n        }\r\n        // Delegated event; lazy-add a change handler on descendant inputs\r\n        jQuery.event.add(this, \"beforeactivate._change\", function (e) {\r\n          var elem = e.target;\r\n\r\n          if (rformElems.test(elem.nodeName) && !jQuery._data(elem, \"changeBubbles\")) {\r\n            jQuery.event.add(elem, \"change._change\", function (event) {\r\n              if (this.parentNode && !event.isSimulated && !event.isTrigger) {\r\n                jQuery.event.simulate(\"change\", this.parentNode, event, true);\r\n              }\r\n            });\r\n            jQuery._data(elem, \"changeBubbles\", true);\r\n          }\r\n        });\r\n      },\r\n\r\n      handle: function (event) {\r\n        var elem = event.target;\r\n\r\n        // Swallow native change events from checkbox/radio, we already triggered them above\r\n        if (this !== elem || event.isSimulated || event.isTrigger || (elem.type !== \"radio\" && elem.type !== \"checkbox\")) {\r\n          return event.handleObj.handler.apply(this, arguments);\r\n        }\r\n      },\r\n\r\n      teardown: function () {\r\n        jQuery.event.remove(this, \"._change\");\r\n\r\n        return !rformElems.test(this.nodeName);\r\n      }\r\n    };\r\n  }\r\n\r\n  // Create \"bubbling\" focus and blur events\r\n  if (!jQuery.support.focusinBubbles) {\r\n    jQuery.each({ focus: \"focusin\", blur: \"focusout\" }, function (orig, fix) {\r\n\r\n      // Attach a single capturing handler while someone wants focusin/focusout\r\n      var attaches = 0,\r\n        handler = function (event) {\r\n          jQuery.event.simulate(fix, event.target, jQuery.event.fix(event), true);\r\n        };\r\n\r\n      jQuery.event.special[fix] = {\r\n        setup: function () {\r\n          if (attaches++ === 0) {\r\n            document.addEventListener(orig, handler, true);\r\n          }\r\n        },\r\n        teardown: function () {\r\n          if (--attaches === 0) {\r\n            document.removeEventListener(orig, handler, true);\r\n          }\r\n        }\r\n      };\r\n    });\r\n  }\r\n\r\n  jQuery.fn.extend({\r\n\r\n    on: function (types, selector, data, fn, /*INTERNAL*/ one) {\r\n      var type, origFn;\r\n\r\n      // Types can be a map of types/handlers\r\n      if (typeof types === \"object\") {\r\n        // ( types-Object, selector, data )\r\n        if (typeof selector !== \"string\") {\r\n          // ( types-Object, data )\r\n          data = data || selector;\r\n          selector = undefined;\r\n        }\r\n        for (type in types) {\r\n          this.on(type, selector, data, types[type], one);\r\n        }\r\n        return this;\r\n      }\r\n\r\n      if (data == null && fn == null) {\r\n        // ( types, fn )\r\n        fn = selector;\r\n        data = selector = undefined;\r\n      } else if (fn == null) {\r\n        if (typeof selector === \"string\") {\r\n          // ( types, selector, fn )\r\n          fn = data;\r\n          data = undefined;\r\n        } else {\r\n          // ( types, data, fn )\r\n          fn = data;\r\n          data = selector;\r\n          selector = undefined;\r\n        }\r\n      }\r\n      if (fn === false) {\r\n        fn = returnFalse;\r\n      } else if (!fn) {\r\n        return this;\r\n      }\r\n\r\n      if (one === 1) {\r\n        origFn = fn;\r\n        fn = function (event) {\r\n          // Can use an empty set, since event contains the info\r\n          jQuery().off(event);\r\n          return origFn.apply(this, arguments);\r\n        };\r\n        // Use same guid so caller can remove using origFn\r\n        fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);\r\n      }\r\n      return this.each(function () {\r\n        jQuery.event.add(this, types, fn, data, selector);\r\n      });\r\n    },\r\n    one: function (types, selector, data, fn) {\r\n      return this.on(types, selector, data, fn, 1);\r\n    },\r\n    off: function (types, selector, fn) {\r\n      var handleObj, type;\r\n      if (types && types.preventDefault && types.handleObj) {\r\n        // ( event )  dispatched jQuery.Event\r\n        handleObj = types.handleObj;\r\n        jQuery(types.delegateTarget).off(\r\n          handleObj.namespace ? handleObj.origType + \".\" + handleObj.namespace : handleObj.origType,\r\n          handleObj.selector,\r\n          handleObj.handler\r\n        );\r\n        return this;\r\n      }\r\n      if (typeof types === \"object\") {\r\n        // ( types-object [, selector] )\r\n        for (type in types) {\r\n          this.off(type, selector, types[type]);\r\n        }\r\n        return this;\r\n      }\r\n      if (selector === false || typeof selector === \"function\") {\r\n        // ( types [, fn] )\r\n        fn = selector;\r\n        selector = undefined;\r\n      }\r\n      if (fn === false) {\r\n        fn = returnFalse;\r\n      }\r\n      return this.each(function () {\r\n        jQuery.event.remove(this, types, fn, selector);\r\n      });\r\n    },\r\n\r\n    bind: function (types, data, fn) {\r\n      return this.on(types, null, data, fn);\r\n    },\r\n    unbind: function (types, fn) {\r\n      return this.off(types, null, fn);\r\n    },\r\n\r\n    delegate: function (selector, types, data, fn) {\r\n      return this.on(types, selector, data, fn);\r\n    },\r\n    undelegate: function (selector, types, fn) {\r\n      // ( namespace ) or ( selector, types [, fn] )\r\n      return arguments.length === 1 ? this.off(selector, \"**\") : this.off(types, selector || \"**\", fn);\r\n    },\r\n\r\n    trigger: function (type, data) {\r\n      return this.each(function () {\r\n        jQuery.event.trigger(type, data, this);\r\n      });\r\n    },\r\n    triggerHandler: function (type, data) {\r\n      var elem = this[0];\r\n      if (elem) {\r\n        return jQuery.event.trigger(type, data, elem, true);\r\n      }\r\n    }\r\n  });\r\n  /*!\r\n   * Sizzle CSS Selector Engine\r\n   * Copyright 2012 jQuery Foundation and other contributors\r\n   * Released under the MIT license\r\n   * http://sizzlejs.com/\r\n   */\r\n  (function (window, undefined) {\r\n\r\n    var i,\r\n      cachedruns,\r\n      Expr,\r\n      getText,\r\n      isXML,\r\n      compile,\r\n      hasDuplicate,\r\n      outermostContext,\r\n\r\n      // Local document vars\r\n      setDocument,\r\n      document,\r\n      docElem,\r\n      documentIsXML,\r\n      rbuggyQSA,\r\n      rbuggyMatches,\r\n      matches,\r\n      contains,\r\n      sortOrder,\r\n\r\n      // Instance-specific data\r\n      expando = \"sizzle\" + -(new Date()),\r\n      preferredDoc = window.document,\r\n      support = {},\r\n      dirruns = 0,\r\n      done = 0,\r\n      classCache = createCache(),\r\n      tokenCache = createCache(),\r\n      compilerCache = createCache(),\r\n\r\n      // General-purpose constants\r\n      strundefined = typeof undefined,\r\n      MAX_NEGATIVE = 1 << 31,\r\n\r\n      // Array methods\r\n      arr = [],\r\n      pop = arr.pop,\r\n      push = arr.push,\r\n      slice = arr.slice,\r\n      // Use a stripped-down indexOf if we can't use a native one\r\n      indexOf = arr.indexOf || function (elem) {\r\n        var i = 0,\r\n          len = this.length;\r\n        for (; i < len; i++) {\r\n          if (this[i] === elem) {\r\n            return i;\r\n          }\r\n        }\r\n        return -1;\r\n      },\r\n\r\n\r\n      // Regular expressions\r\n\r\n      // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace\r\n      whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\r\n      // http://www.w3.org/TR/css3-syntax/#characters\r\n      characterEncoding = \"(?:\\\\\\\\.|[\\\\w-]|[^\\\\x00-\\\\xa0])+\",\r\n\r\n      // Loosely modeled on CSS identifier characters\r\n      // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors\r\n      // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\r\n      identifier = characterEncoding.replace(\"w\", \"w#\"),\r\n\r\n      // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors\r\n      operators = \"([*^$|!~]?=)\",\r\n      attributes = \"\\\\[\" + whitespace + \"*(\" + characterEncoding + \")\" + whitespace +\r\n        \"*(?:\" + operators + whitespace + \"*(?:(['\\\"])((?:\\\\\\\\.|[^\\\\\\\\])*?)\\\\3|(\" + identifier + \")|)|)\" + whitespace + \"*\\\\]\",\r\n\r\n      // Prefer arguments quoted,\r\n      //   then not containing pseudos/brackets,\r\n      //   then attribute selectors/non-parenthetical expressions,\r\n      //   then anything else\r\n      // These preferences are here to reduce the number of selectors\r\n      //   needing tokenize in the PSEUDO preFilter\r\n      pseudos = \":(\" + characterEncoding + \")(?:\\\\(((['\\\"])((?:\\\\\\\\.|[^\\\\\\\\])*?)\\\\3|((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes.replace(3, 8) + \")*)|.*)\\\\)|)\",\r\n\r\n      // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\r\n      rtrim = new RegExp(\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\"),\r\n\r\n      rcomma = new RegExp(\"^\" + whitespace + \"*,\" + whitespace + \"*\"),\r\n      rcombinators = new RegExp(\"^\" + whitespace + \"*([\\\\x20\\\\t\\\\r\\\\n\\\\f>+~])\" + whitespace + \"*\"),\r\n      rpseudo = new RegExp(pseudos),\r\n      ridentifier = new RegExp(\"^\" + identifier + \"$\"),\r\n\r\n      matchExpr = {\r\n        \"ID\": new RegExp(\"^#(\" + characterEncoding + \")\"),\r\n        \"CLASS\": new RegExp(\"^\\\\.(\" + characterEncoding + \")\"),\r\n        \"NAME\": new RegExp(\"^\\\\[name=['\\\"]?(\" + characterEncoding + \")['\\\"]?\\\\]\"),\r\n        \"TAG\": new RegExp(\"^(\" + characterEncoding.replace(\"w\", \"w*\") + \")\"),\r\n        \"ATTR\": new RegExp(\"^\" + attributes),\r\n        \"PSEUDO\": new RegExp(\"^\" + pseudos),\r\n        \"CHILD\": new RegExp(\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace +\r\n          \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace +\r\n          \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\"),\r\n        // For use in libraries implementing .is()\r\n        // We use this for POS matching in `select`\r\n        \"needsContext\": new RegExp(\"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" +\r\n          whitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\")\r\n      },\r\n\r\n      rsibling = /[\\x20\\t\\r\\n\\f]*[+~]/,\r\n\r\n      rnative = /^[^{]+\\{\\s*\\[native code/,\r\n\r\n      // Easily-parseable/retrievable ID or TAG or CLASS selectors\r\n      rquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\r\n\r\n      rinputs = /^(?:input|select|textarea|button)$/i,\r\n      rheader = /^h\\d$/i,\r\n\r\n      rescape = /'|\\\\/g,\r\n      rattributeQuotes = /\\=[\\x20\\t\\r\\n\\f]*([^'\"\\]]*)[\\x20\\t\\r\\n\\f]*\\]/g,\r\n\r\n      // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\r\n      runescape = /\\\\([\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|.)/g,\r\n      funescape = function (_, escaped) {\r\n        var high = \"0x\" + escaped - 0x10000;\r\n        // NaN means non-codepoint\r\n        return high !== high ?\r\n          escaped :\r\n          // BMP codepoint\r\n          high < 0 ?\r\n            String.fromCharCode(high + 0x10000) :\r\n            // Supplemental Plane codepoint (surrogate pair)\r\n            String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);\r\n      };\r\n\r\n    // Use a stripped-down slice if we can't use a native one\r\n    try {\r\n      slice.call(preferredDoc.documentElement.childNodes, 0)[0].nodeType;\r\n    } catch (e) {\r\n      slice = function (i) {\r\n        var elem,\r\n          results = [];\r\n        while ((elem = this[i++])) {\r\n          results.push(elem);\r\n        }\r\n        return results;\r\n      };\r\n    }\r\n\r\n    /**\r\n     * For feature detection\r\n     * @param {Function} fn The function to test for native support\r\n     */\r\n    function isNative(fn) {\r\n      return rnative.test(fn + \"\");\r\n    }\r\n\r\n    /**\r\n     * Create key-value caches of limited size\r\n     * @returns {Function(string, Object)} Returns the Object data after storing it on itself with\r\n     *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\r\n     *\tdeleting the oldest entry\r\n     */\r\n    function createCache() {\r\n      var cache,\r\n        keys = [];\r\n\r\n      return (cache = function (key, value) {\r\n        // Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\r\n        if (keys.push(key += \" \") > Expr.cacheLength) {\r\n          // Only keep the most recent entries\r\n          delete cache[keys.shift()];\r\n        }\r\n        return (cache[key] = value);\r\n      });\r\n    }\r\n\r\n    /**\r\n     * Mark a function for special use by Sizzle\r\n     * @param {Function} fn The function to mark\r\n     */\r\n    function markFunction(fn) {\r\n      fn[expando] = true;\r\n      return fn;\r\n    }\r\n\r\n    /**\r\n     * Support testing using an element\r\n     * @param {Function} fn Passed the created div and expects a boolean result\r\n     */\r\n    function assert(fn) {\r\n      var div = document.createElement(\"div\");\r\n\r\n      try {\r\n        return fn(div);\r\n      } catch (e) {\r\n        return false;\r\n      } finally {\r\n        // release memory in IE\r\n        div = null;\r\n      }\r\n    }\r\n\r\n    function Sizzle(selector, context, results, seed) {\r\n      var match, elem, m, nodeType,\r\n        // QSA vars\r\n        i, groups, old, nid, newContext, newSelector;\r\n\r\n      if ((context ? context.ownerDocument || context : preferredDoc) !== document) {\r\n        setDocument(context);\r\n      }\r\n\r\n      context = context || document;\r\n      results = results || [];\r\n\r\n      if (!selector || typeof selector !== \"string\") {\r\n        return results;\r\n      }\r\n\r\n      if ((nodeType = context.nodeType) !== 1 && nodeType !== 9) {\r\n        return [];\r\n      }\r\n\r\n      if (!documentIsXML && !seed) {\r\n\r\n        // Shortcuts\r\n        if ((match = rquickExpr.exec(selector))) {\r\n          // Speed-up: Sizzle(\"#ID\")\r\n          if ((m = match[1])) {\r\n            if (nodeType === 9) {\r\n              elem = context.getElementById(m);\r\n              // Check parentNode to catch when Blackberry 4.6 returns\r\n              // nodes that are no longer in the document #6963\r\n              if (elem && elem.parentNode) {\r\n                // Handle the case where IE, Opera, and Webkit return items\r\n                // by name instead of ID\r\n                if (elem.id === m) {\r\n                  results.push(elem);\r\n                  return results;\r\n                }\r\n              } else {\r\n                return results;\r\n              }\r\n            } else {\r\n              // Context is not a document\r\n              if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) &&\r\n                contains(context, elem) && elem.id === m) {\r\n                results.push(elem);\r\n                return results;\r\n              }\r\n            }\r\n\r\n            // Speed-up: Sizzle(\"TAG\")\r\n          } else if (match[2]) {\r\n            push.apply(results, slice.call(context.getElementsByTagName(selector), 0));\r\n            return results;\r\n\r\n            // Speed-up: Sizzle(\".CLASS\")\r\n          } else if ((m = match[3]) && support.getByClassName && context.getElementsByClassName) {\r\n            push.apply(results, slice.call(context.getElementsByClassName(m), 0));\r\n            return results;\r\n          }\r\n        }\r\n\r\n        // QSA path\r\n        if (support.qsa && !rbuggyQSA.test(selector)) {\r\n          old = true;\r\n          nid = expando;\r\n          newContext = context;\r\n          newSelector = nodeType === 9 && selector;\r\n\r\n          // qSA works strangely on Element-rooted queries\r\n          // We can work around this by specifying an extra ID on the root\r\n          // and working up from there (Thanks to Andrew Dupont for the technique)\r\n          // IE 8 doesn't work on object elements\r\n          if (nodeType === 1 && context.nodeName.toLowerCase() !== \"object\") {\r\n            groups = tokenize(selector);\r\n\r\n            if ((old = context.getAttribute(\"id\"))) {\r\n              nid = old.replace(rescape, \"\\\\$&\");\r\n            } else {\r\n              context.setAttribute(\"id\", nid);\r\n            }\r\n            nid = \"[id='\" + nid + \"'] \";\r\n\r\n            i = groups.length;\r\n            while (i--) {\r\n              groups[i] = nid + toSelector(groups[i]);\r\n            }\r\n            newContext = rsibling.test(selector) && context.parentNode || context;\r\n            newSelector = groups.join(\",\");\r\n          }\r\n\r\n          if (newSelector) {\r\n            try {\r\n              push.apply(results, slice.call(newContext.querySelectorAll(\r\n                newSelector\r\n              ), 0));\r\n              return results;\r\n            } catch (qsaError) {\r\n            } finally {\r\n              if (!old) {\r\n                context.removeAttribute(\"id\");\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // All others\r\n      return select(selector.replace(rtrim, \"$1\"), context, results, seed);\r\n    }\r\n\r\n    /**\r\n     * Detect xml\r\n     * @param {Element|Object} elem An element or a document\r\n     */\r\n    isXML = Sizzle.isXML = function (elem) {\r\n      // documentElement is verified for cases where it doesn't yet exist\r\n      // (such as loading iframes in IE - #4833)\r\n      var documentElement = elem && (elem.ownerDocument || elem).documentElement;\r\n      return documentElement ? documentElement.nodeName !== \"HTML\" : false;\r\n    };\r\n\r\n    /**\r\n     * Sets document-related variables once based on the current document\r\n     * @param {Element|Object} [doc] An element or document object to use to set the document\r\n     * @returns {Object} Returns the current document\r\n     */\r\n    setDocument = Sizzle.setDocument = function (node) {\r\n      var doc = node ? node.ownerDocument || node : preferredDoc;\r\n\r\n      // If no document and documentElement is available, return\r\n      if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {\r\n        return document;\r\n      }\r\n\r\n      // Set our document\r\n      document = doc;\r\n      docElem = doc.documentElement;\r\n\r\n      // Support tests\r\n      documentIsXML = isXML(doc);\r\n\r\n      // Check if getElementsByTagName(\"*\") returns only elements\r\n      support.tagNameNoComments = assert(function (div) {\r\n        div.appendChild(doc.createComment(\"\"));\r\n        return !div.getElementsByTagName(\"*\").length;\r\n      });\r\n\r\n      // Check if attributes should be retrieved by attribute nodes\r\n      support.attributes = assert(function (div) {\r\n        div.innerHTML = \"<select></select>\";\r\n        var type = typeof div.lastChild.getAttribute(\"multiple\");\r\n        // IE8 returns a string for some attributes even when not present\r\n        return type !== \"boolean\" && type !== \"string\";\r\n      });\r\n\r\n      // Check if getElementsByClassName can be trusted\r\n      support.getByClassName = assert(function (div) {\r\n        // Opera can't find a second classname (in 9.6)\r\n        div.innerHTML = \"<div class='hidden e'></div><div class='hidden'></div>\";\r\n        if (!div.getElementsByClassName || !div.getElementsByClassName(\"e\").length) {\r\n          return false;\r\n        }\r\n\r\n        // Safari 3.2 caches class attributes and doesn't catch changes\r\n        div.lastChild.className = \"e\";\r\n        return div.getElementsByClassName(\"e\").length === 2;\r\n      });\r\n\r\n      // Check if getElementById returns elements by name\r\n      // Check if getElementsByName privileges form controls or returns elements by ID\r\n      support.getByName = assert(function (div) {\r\n        // Inject content\r\n        div.id = expando + 0;\r\n        div.innerHTML = \"<a name='\" + expando + \"'></a><div name='\" + expando + \"'></div>\";\r\n        docElem.insertBefore(div, docElem.firstChild);\r\n\r\n        // Test\r\n        var pass = doc.getElementsByName &&\r\n          // buggy browsers will return fewer than the correct 2\r\n          doc.getElementsByName(expando).length === 2 +\r\n          // buggy browsers will return more than the correct 0\r\n          doc.getElementsByName(expando + 0).length;\r\n        support.getIdNotName = !doc.getElementById(expando);\r\n\r\n        // Cleanup\r\n        docElem.removeChild(div);\r\n\r\n        return pass;\r\n      });\r\n\r\n      // IE6/7 return modified attributes\r\n      Expr.attrHandle = assert(function (div) {\r\n        div.innerHTML = \"<a href='#'></a>\";\r\n        return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&\r\n          div.firstChild.getAttribute(\"href\") === \"#\";\r\n      }) ?\r\n        {} :\r\n        {\r\n          \"href\": function (elem) {\r\n            return elem.getAttribute(\"href\", 2);\r\n          },\r\n          \"type\": function (elem) {\r\n            return elem.getAttribute(\"type\");\r\n          }\r\n        };\r\n\r\n      // ID find and filter\r\n      if (support.getIdNotName) {\r\n        Expr.find[\"ID\"] = function (id, context) {\r\n          if (typeof context.getElementById !== strundefined && !documentIsXML) {\r\n            var m = context.getElementById(id);\r\n            // Check parentNode to catch when Blackberry 4.6 returns\r\n            // nodes that are no longer in the document #6963\r\n            return m && m.parentNode ? [m] : [];\r\n          }\r\n        };\r\n        Expr.filter[\"ID\"] = function (id) {\r\n          var attrId = id.replace(runescape, funescape);\r\n          return function (elem) {\r\n            return elem.getAttribute(\"id\") === attrId;\r\n          };\r\n        };\r\n      } else {\r\n        Expr.find[\"ID\"] = function (id, context) {\r\n          if (typeof context.getElementById !== strundefined && !documentIsXML) {\r\n            var m = context.getElementById(id);\r\n\r\n            return m ?\r\n              m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode(\"id\").value === id ?\r\n                [m] :\r\n                undefined :\r\n              [];\r\n          }\r\n        };\r\n        Expr.filter[\"ID\"] = function (id) {\r\n          var attrId = id.replace(runescape, funescape);\r\n          return function (elem) {\r\n            var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode(\"id\");\r\n            return node && node.value === attrId;\r\n          };\r\n        };\r\n      }\r\n\r\n      // Tag\r\n      Expr.find[\"TAG\"] = support.tagNameNoComments ?\r\n        function (tag, context) {\r\n          if (typeof context.getElementsByTagName !== strundefined) {\r\n            return context.getElementsByTagName(tag);\r\n          }\r\n        } :\r\n        function (tag, context) {\r\n          var elem,\r\n            tmp = [],\r\n            i = 0,\r\n            results = context.getElementsByTagName(tag);\r\n\r\n          // Filter out possible comments\r\n          if (tag === \"*\") {\r\n            while ((elem = results[i++])) {\r\n              if (elem.nodeType === 1) {\r\n                tmp.push(elem);\r\n              }\r\n            }\r\n\r\n            return tmp;\r\n          }\r\n          return results;\r\n        };\r\n\r\n      // Name\r\n      Expr.find[\"NAME\"] = support.getByName && function (tag, context) {\r\n        if (typeof context.getElementsByName !== strundefined) {\r\n          return context.getElementsByName(name);\r\n        }\r\n      };\r\n\r\n      // Class\r\n      Expr.find[\"CLASS\"] = support.getByClassName && function (className, context) {\r\n        if (typeof context.getElementsByClassName !== strundefined && !documentIsXML) {\r\n          return context.getElementsByClassName(className);\r\n        }\r\n      };\r\n\r\n      // QSA and matchesSelector support\r\n\r\n      // matchesSelector(:active) reports false when true (IE9/Opera 11.5)\r\n      rbuggyMatches = [];\r\n\r\n      // qSa(:focus) reports false when true (Chrome 21),\r\n      // no need to also add to buggyMatches since matches checks buggyQSA\r\n      // A support test would require too much code (would include document ready)\r\n      rbuggyQSA = [\":focus\"];\r\n\r\n      if ((support.qsa = isNative(doc.querySelectorAll))) {\r\n        // Build QSA regex\r\n        // Regex strategy adopted from Diego Perini\r\n        assert(function (div) {\r\n          // Select is set to empty string on purpose\r\n          // This is to test IE's treatment of not explictly\r\n          // setting a boolean content attribute,\r\n          // since its presence should be enough\r\n          // http://bugs.jquery.com/ticket/12359\r\n          div.innerHTML = \"<select><option selected=''></option></select>\";\r\n\r\n          // IE8 - Some boolean attributes are not treated correctly\r\n          if (!div.querySelectorAll(\"[selected]\").length) {\r\n            rbuggyQSA.push(\"\\\\[\" + whitespace + \"*(?:checked|disabled|ismap|multiple|readonly|selected|value)\");\r\n          }\r\n\r\n          // Webkit/Opera - :checked should return selected option elements\r\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\r\n          // IE8 throws error here and will not see later tests\r\n          if (!div.querySelectorAll(\":checked\").length) {\r\n            rbuggyQSA.push(\":checked\");\r\n          }\r\n        });\r\n\r\n        assert(function (div) {\r\n\r\n          // Opera 10-12/IE8 - ^= $= *= and empty values\r\n          // Should not select anything\r\n          div.innerHTML = \"<input type='hidden' i=''/>\";\r\n          if (div.querySelectorAll(\"[i^='']\").length) {\r\n            rbuggyQSA.push(\"[*^$]=\" + whitespace + \"*(?:\\\"\\\"|'')\");\r\n          }\r\n\r\n          // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\r\n          // IE8 throws error here and will not see later tests\r\n          if (!div.querySelectorAll(\":enabled\").length) {\r\n            rbuggyQSA.push(\":enabled\", \":disabled\");\r\n          }\r\n\r\n          // Opera 10-11 does not throw on post-comma invalid pseudos\r\n          div.querySelectorAll(\"*,:x\");\r\n          rbuggyQSA.push(\",.*:\");\r\n        });\r\n      }\r\n\r\n      if ((support.matchesSelector = isNative((matches = docElem.matchesSelector ||\r\n        docElem.mozMatchesSelector ||\r\n        docElem.webkitMatchesSelector ||\r\n        docElem.oMatchesSelector ||\r\n        docElem.msMatchesSelector)))) {\r\n\r\n        assert(function (div) {\r\n          // Check to see if it's possible to do matchesSelector\r\n          // on a disconnected node (IE 9)\r\n          support.disconnectedMatch = matches.call(div, \"div\");\r\n\r\n          // This should fail with an exception\r\n          // Gecko does not error, returns false instead\r\n          matches.call(div, \"[s!='']:x\");\r\n          rbuggyMatches.push(\"!=\", pseudos);\r\n        });\r\n      }\r\n\r\n      rbuggyQSA = new RegExp(rbuggyQSA.join(\"|\"));\r\n      rbuggyMatches = new RegExp(rbuggyMatches.join(\"|\"));\r\n\r\n      // Element contains another\r\n      // Purposefully does not implement inclusive descendent\r\n      // As in, an element does not contain itself\r\n      contains = isNative(docElem.contains) || docElem.compareDocumentPosition ?\r\n        function (a, b) {\r\n          var adown = a.nodeType === 9 ? a.documentElement : a,\r\n            bup = b && b.parentNode;\r\n          return a === bup || !!(bup && bup.nodeType === 1 && (\r\n            adown.contains ?\r\n              adown.contains(bup) :\r\n              a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16\r\n          ));\r\n        } :\r\n        function (a, b) {\r\n          if (b) {\r\n            while ((b = b.parentNode)) {\r\n              if (b === a) {\r\n                return true;\r\n              }\r\n            }\r\n          }\r\n          return false;\r\n        };\r\n\r\n      // Document order sorting\r\n      sortOrder = docElem.compareDocumentPosition ?\r\n        function (a, b) {\r\n          var compare;\r\n\r\n          if (a === b) {\r\n            hasDuplicate = true;\r\n            return 0;\r\n          }\r\n\r\n          if ((compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition(b))) {\r\n            if (compare & 1 || a.parentNode && a.parentNode.nodeType === 11) {\r\n              if (a === doc || contains(preferredDoc, a)) {\r\n                return -1;\r\n              }\r\n              if (b === doc || contains(preferredDoc, b)) {\r\n                return 1;\r\n              }\r\n              return 0;\r\n            }\r\n            return compare & 4 ? -1 : 1;\r\n          }\r\n\r\n          return a.compareDocumentPosition ? -1 : 1;\r\n        } :\r\n        function (a, b) {\r\n          var cur,\r\n            i = 0,\r\n            aup = a.parentNode,\r\n            bup = b.parentNode,\r\n            ap = [a],\r\n            bp = [b];\r\n\r\n          // Exit early if the nodes are identical\r\n          if (a === b) {\r\n            hasDuplicate = true;\r\n            return 0;\r\n\r\n            // Parentless nodes are either documents or disconnected\r\n          } else if (!aup || !bup) {\r\n            return a === doc ? -1 :\r\n              b === doc ? 1 :\r\n                aup ? -1 :\r\n                  bup ? 1 :\r\n                    0;\r\n\r\n            // If the nodes are siblings, we can do a quick check\r\n          } else if (aup === bup) {\r\n            return siblingCheck(a, b);\r\n          }\r\n\r\n          // Otherwise we need full lists of their ancestors for comparison\r\n          cur = a;\r\n          while ((cur = cur.parentNode)) {\r\n            ap.unshift(cur);\r\n          }\r\n          cur = b;\r\n          while ((cur = cur.parentNode)) {\r\n            bp.unshift(cur);\r\n          }\r\n\r\n          // Walk down the tree looking for a discrepancy\r\n          while (ap[i] === bp[i]) {\r\n            i++;\r\n          }\r\n\r\n          return i ?\r\n            // Do a sibling check if the nodes have a common ancestor\r\n            siblingCheck(ap[i], bp[i]) :\r\n\r\n            // Otherwise nodes in our document sort first\r\n            ap[i] === preferredDoc ? -1 :\r\n              bp[i] === preferredDoc ? 1 :\r\n                0;\r\n        };\r\n\r\n      // Always assume the presence of duplicates if sort doesn't\r\n      // pass them to our comparison function (as in Google Chrome).\r\n      hasDuplicate = false;\r\n      [0, 0].sort(sortOrder);\r\n      support.detectDuplicates = hasDuplicate;\r\n\r\n      return document;\r\n    };\r\n\r\n    Sizzle.matches = function (expr, elements) {\r\n      return Sizzle(expr, null, null, elements);\r\n    };\r\n\r\n    Sizzle.matchesSelector = function (elem, expr) {\r\n      // Set document vars if needed\r\n      if ((elem.ownerDocument || elem) !== document) {\r\n        setDocument(elem);\r\n      }\r\n\r\n      // Make sure that attribute selectors are quoted\r\n      expr = expr.replace(rattributeQuotes, \"='$1']\");\r\n\r\n      // rbuggyQSA always contains :focus, so no need for an existence check\r\n      if (support.matchesSelector && !documentIsXML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && !rbuggyQSA.test(expr)) {\r\n        try {\r\n          var ret = matches.call(elem, expr);\r\n\r\n          // IE 9's matchesSelector returns false on disconnected nodes\r\n          if (ret || support.disconnectedMatch ||\r\n            // As well, disconnected nodes are said to be in a document\r\n            // fragment in IE 9\r\n            elem.document && elem.document.nodeType !== 11) {\r\n            return ret;\r\n          }\r\n        } catch (e) { }\r\n      }\r\n\r\n      return Sizzle(expr, document, null, [elem]).length > 0;\r\n    };\r\n\r\n    Sizzle.contains = function (context, elem) {\r\n      // Set document vars if needed\r\n      if ((context.ownerDocument || context) !== document) {\r\n        setDocument(context);\r\n      }\r\n      return contains(context, elem);\r\n    };\r\n\r\n    Sizzle.attr = function (elem, name) {\r\n      var val;\r\n\r\n      // Set document vars if needed\r\n      if ((elem.ownerDocument || elem) !== document) {\r\n        setDocument(elem);\r\n      }\r\n\r\n      if (!documentIsXML) {\r\n        name = name.toLowerCase();\r\n      }\r\n      if ((val = Expr.attrHandle[name])) {\r\n        return val(elem);\r\n      }\r\n      if (documentIsXML || support.attributes) {\r\n        return elem.getAttribute(name);\r\n      }\r\n      return ((val = elem.getAttributeNode(name)) || elem.getAttribute(name)) && elem[name] === true ?\r\n        name :\r\n        val && val.specified ? val.value : null;\r\n    };\r\n\r\n    Sizzle.error = function (msg) {\r\n      throw new Error(\"Syntax error, unrecognized expression: \" + msg);\r\n    };\r\n\r\n    // Document sorting and removing duplicates\r\n    Sizzle.uniqueSort = function (results) {\r\n      var elem,\r\n        duplicates = [],\r\n        i = 1,\r\n        j = 0;\r\n\r\n      // Unless we *know* we can detect duplicates, assume their presence\r\n      hasDuplicate = !support.detectDuplicates;\r\n      results.sort(sortOrder);\r\n\r\n      if (hasDuplicate) {\r\n        for (; (elem = results[i]); i++) {\r\n          if (elem === results[i - 1]) {\r\n            j = duplicates.push(i);\r\n          }\r\n        }\r\n        while (j--) {\r\n          results.splice(duplicates[j], 1);\r\n        }\r\n      }\r\n\r\n      return results;\r\n    };\r\n\r\n    function siblingCheck(a, b) {\r\n      var cur = b && a,\r\n        diff = cur && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);\r\n\r\n      // Use IE sourceIndex if available on both nodes\r\n      if (diff) {\r\n        return diff;\r\n      }\r\n\r\n      // Check if b follows a\r\n      if (cur) {\r\n        while ((cur = cur.nextSibling)) {\r\n          if (cur === b) {\r\n            return -1;\r\n          }\r\n        }\r\n      }\r\n\r\n      return a ? 1 : -1;\r\n    }\r\n\r\n    // Returns a function to use in pseudos for input types\r\n    function createInputPseudo(type) {\r\n      return function (elem) {\r\n        var name = elem.nodeName.toLowerCase();\r\n        return name === \"input\" && elem.type === type;\r\n      };\r\n    }\r\n\r\n    // Returns a function to use in pseudos for buttons\r\n    function createButtonPseudo(type) {\r\n      return function (elem) {\r\n        var name = elem.nodeName.toLowerCase();\r\n        return (name === \"input\" || name === \"button\") && elem.type === type;\r\n      };\r\n    }\r\n\r\n    // Returns a function to use in pseudos for positionals\r\n    function createPositionalPseudo(fn) {\r\n      return markFunction(function (argument) {\r\n        argument = +argument;\r\n        return markFunction(function (seed, matches) {\r\n          var j,\r\n            matchIndexes = fn([], seed.length, argument),\r\n            i = matchIndexes.length;\r\n\r\n          // Match elements found at the specified indexes\r\n          while (i--) {\r\n            if (seed[(j = matchIndexes[i])]) {\r\n              seed[j] = !(matches[j] = seed[j]);\r\n            }\r\n          }\r\n        });\r\n      });\r\n    }\r\n\r\n    /**\r\n     * Utility function for retrieving the text value of an array of DOM nodes\r\n     * @param {Array|Element} elem\r\n     */\r\n    getText = Sizzle.getText = function (elem) {\r\n      var node,\r\n        ret = \"\",\r\n        i = 0,\r\n        nodeType = elem.nodeType;\r\n\r\n      if (!nodeType) {\r\n        // If no nodeType, this is expected to be an array\r\n        for (; (node = elem[i]); i++) {\r\n          // Do not traverse comment nodes\r\n          ret += getText(node);\r\n        }\r\n      } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {\r\n        // Use textContent for elements\r\n        // innerText usage removed for consistency of new lines (see #11153)\r\n        if (typeof elem.textContent === \"string\") {\r\n          return elem.textContent;\r\n        } else {\r\n          // Traverse its children\r\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\r\n            ret += getText(elem);\r\n          }\r\n        }\r\n      } else if (nodeType === 3 || nodeType === 4) {\r\n        return elem.nodeValue;\r\n      }\r\n      // Do not include comment or processing instruction nodes\r\n\r\n      return ret;\r\n    };\r\n\r\n    Expr = Sizzle.selectors = {\r\n\r\n      // Can be adjusted by the user\r\n      cacheLength: 50,\r\n\r\n      createPseudo: markFunction,\r\n\r\n      match: matchExpr,\r\n\r\n      find: {},\r\n\r\n      relative: {\r\n        \">\": { dir: \"parentNode\", first: true },\r\n        \" \": { dir: \"parentNode\" },\r\n        \"+\": { dir: \"previousSibling\", first: true },\r\n        \"~\": { dir: \"previousSibling\" }\r\n      },\r\n\r\n      preFilter: {\r\n        \"ATTR\": function (match) {\r\n          match[1] = match[1].replace(runescape, funescape);\r\n\r\n          // Move the given value to match[3] whether quoted or unquoted\r\n          match[3] = (match[4] || match[5] || \"\").replace(runescape, funescape);\r\n\r\n          if (match[2] === \"~=\") {\r\n            match[3] = \" \" + match[3] + \" \";\r\n          }\r\n\r\n          return match.slice(0, 4);\r\n        },\r\n\r\n        \"CHILD\": function (match) {\r\n          /* matches from matchExpr[\"CHILD\"]\r\n            1 type (only|nth|...)\r\n            2 what (child|of-type)\r\n            3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\r\n            4 xn-component of xn+y argument ([+-]?\\d*n|)\r\n            5 sign of xn-component\r\n            6 x of xn-component\r\n            7 sign of y-component\r\n            8 y of y-component\r\n          */\r\n          match[1] = match[1].toLowerCase();\r\n\r\n          if (match[1].slice(0, 3) === \"nth\") {\r\n            // nth-* requires argument\r\n            if (!match[3]) {\r\n              Sizzle.error(match[0]);\r\n            }\r\n\r\n            // numeric x and y parameters for Expr.filter.CHILD\r\n            // remember that false/true cast respectively to 0/1\r\n            match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === \"even\" || match[3] === \"odd\"));\r\n            match[5] = +((match[7] + match[8]) || match[3] === \"odd\");\r\n\r\n            // other types prohibit arguments\r\n          } else if (match[3]) {\r\n            Sizzle.error(match[0]);\r\n          }\r\n\r\n          return match;\r\n        },\r\n\r\n        \"PSEUDO\": function (match) {\r\n          var excess,\r\n            unquoted = !match[5] && match[2];\r\n\r\n          if (matchExpr[\"CHILD\"].test(match[0])) {\r\n            return null;\r\n          }\r\n\r\n          // Accept quoted arguments as-is\r\n          if (match[4]) {\r\n            match[2] = match[4];\r\n\r\n            // Strip excess characters from unquoted arguments\r\n          } else if (unquoted && rpseudo.test(unquoted) &&\r\n            // Get excess from tokenize (recursively)\r\n            (excess = tokenize(unquoted, true)) &&\r\n            // advance to the next closing parenthesis\r\n            (excess = unquoted.indexOf(\")\", unquoted.length - excess) - unquoted.length)) {\r\n\r\n            // excess is a negative index\r\n            match[0] = match[0].slice(0, excess);\r\n            match[2] = unquoted.slice(0, excess);\r\n          }\r\n\r\n          // Return only captures needed by the pseudo filter method (type and argument)\r\n          return match.slice(0, 3);\r\n        }\r\n      },\r\n\r\n      filter: {\r\n\r\n        \"TAG\": function (nodeName) {\r\n          if (nodeName === \"*\") {\r\n            return function () { return true; };\r\n          }\r\n\r\n          nodeName = nodeName.replace(runescape, funescape).toLowerCase();\r\n          return function (elem) {\r\n            return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\r\n          };\r\n        },\r\n\r\n        \"CLASS\": function (className) {\r\n          var pattern = classCache[className + \" \"];\r\n\r\n          return pattern ||\r\n            (pattern = new RegExp(\"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\")) &&\r\n            classCache(className, function (elem) {\r\n              return pattern.test(elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute(\"class\")) || \"\");\r\n            });\r\n        },\r\n\r\n        \"ATTR\": function (name, operator, check) {\r\n          return function (elem) {\r\n            var result = Sizzle.attr(elem, name);\r\n\r\n            if (result == null) {\r\n              return operator === \"!=\";\r\n            }\r\n            if (!operator) {\r\n              return true;\r\n            }\r\n\r\n            result += \"\";\r\n\r\n            return operator === \"=\" ? result === check :\r\n              operator === \"!=\" ? result !== check :\r\n                operator === \"^=\" ? check && result.indexOf(check) === 0 :\r\n                  operator === \"*=\" ? check && result.indexOf(check) > -1 :\r\n                    operator === \"$=\" ? check && result.slice(-check.length) === check :\r\n                      operator === \"~=\" ? (\" \" + result + \" \").indexOf(check) > -1 :\r\n                        operator === \"|=\" ? result === check || result.slice(0, check.length + 1) === check + \"-\" :\r\n                          false;\r\n          };\r\n        },\r\n\r\n        \"CHILD\": function (type, what, argument, first, last) {\r\n          var simple = type.slice(0, 3) !== \"nth\",\r\n            forward = type.slice(-4) !== \"last\",\r\n            ofType = what === \"of-type\";\r\n\r\n          return first === 1 && last === 0 ?\r\n\r\n            // Shortcut for :nth-*(n)\r\n            function (elem) {\r\n              return !!elem.parentNode;\r\n            } :\r\n\r\n            function (elem, context, xml) {\r\n              var cache, outerCache, node, diff, nodeIndex, start,\r\n                dir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\r\n                parent = elem.parentNode,\r\n                name = ofType && elem.nodeName.toLowerCase(),\r\n                useCache = !xml && !ofType;\r\n\r\n              if (parent) {\r\n\r\n                // :(first|last|only)-(child|of-type)\r\n                if (simple) {\r\n                  while (dir) {\r\n                    node = elem;\r\n                    while ((node = node[dir])) {\r\n                      if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {\r\n                        return false;\r\n                      }\r\n                    }\r\n                    // Reverse direction for :only-* (if we haven't yet done so)\r\n                    start = dir = type === \"only\" && !start && \"nextSibling\";\r\n                  }\r\n                  return true;\r\n                }\r\n\r\n                start = [forward ? parent.firstChild : parent.lastChild];\r\n\r\n                // non-xml :nth-child(...) stores cache data on `parent`\r\n                if (forward && useCache) {\r\n                  // Seek `elem` from a previously-cached index\r\n                  outerCache = parent[expando] || (parent[expando] = {});\r\n                  cache = outerCache[type] || [];\r\n                  nodeIndex = cache[0] === dirruns && cache[1];\r\n                  diff = cache[0] === dirruns && cache[2];\r\n                  node = nodeIndex && parent.childNodes[nodeIndex];\r\n\r\n                  while ((node = ++nodeIndex && node && node[dir] ||\r\n\r\n                    // Fallback to seeking `elem` from the start\r\n                    (diff = nodeIndex = 0) || start.pop())) {\r\n\r\n                    // When found, cache indexes on `parent` and break\r\n                    if (node.nodeType === 1 && ++diff && node === elem) {\r\n                      outerCache[type] = [dirruns, nodeIndex, diff];\r\n                      break;\r\n                    }\r\n                  }\r\n\r\n                  // Use previously-cached element index if available\r\n                } else if (useCache && (cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns) {\r\n                  diff = cache[1];\r\n\r\n                  // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)\r\n                } else {\r\n                  // Use the same loop as above to seek `elem` from the start\r\n                  while ((node = ++nodeIndex && node && node[dir] ||\r\n                    (diff = nodeIndex = 0) || start.pop())) {\r\n\r\n                    if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {\r\n                      // Cache the index of each encountered element\r\n                      if (useCache) {\r\n                        (node[expando] || (node[expando] = {}))[type] = [dirruns, diff];\r\n                      }\r\n\r\n                      if (node === elem) {\r\n                        break;\r\n                      }\r\n                    }\r\n                  }\r\n                }\r\n\r\n                // Incorporate the offset, then check against cycle size\r\n                diff -= last;\r\n                return diff === first || (diff % first === 0 && diff / first >= 0);\r\n              }\r\n            };\r\n        },\r\n\r\n        \"PSEUDO\": function (pseudo, argument) {\r\n          // pseudo-class names are case-insensitive\r\n          // http://www.w3.org/TR/selectors/#pseudo-classes\r\n          // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\r\n          // Remember that setFilters inherits from pseudos\r\n          var args,\r\n            fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] ||\r\n              Sizzle.error(\"unsupported pseudo: \" + pseudo);\r\n\r\n          // The user may use createPseudo to indicate that\r\n          // arguments are needed to create the filter function\r\n          // just as Sizzle does\r\n          if (fn[expando]) {\r\n            return fn(argument);\r\n          }\r\n\r\n          // But maintain support for old signatures\r\n          if (fn.length > 1) {\r\n            args = [pseudo, pseudo, \"\", argument];\r\n            return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ?\r\n              markFunction(function (seed, matches) {\r\n                var idx,\r\n                  matched = fn(seed, argument),\r\n                  i = matched.length;\r\n                while (i--) {\r\n                  idx = indexOf.call(seed, matched[i]);\r\n                  seed[idx] = !(matches[idx] = matched[i]);\r\n                }\r\n              }) :\r\n              function (elem) {\r\n                return fn(elem, 0, args);\r\n              };\r\n          }\r\n\r\n          return fn;\r\n        }\r\n      },\r\n\r\n      pseudos: {\r\n        // Potentially complex pseudos\r\n        \"not\": markFunction(function (selector) {\r\n          // Trim the selector passed to compile\r\n          // to avoid treating leading and trailing\r\n          // spaces as combinators\r\n          var input = [],\r\n            results = [],\r\n            matcher = compile(selector.replace(rtrim, \"$1\"));\r\n\r\n          return matcher[expando] ?\r\n            markFunction(function (seed, matches, context, xml) {\r\n              var elem,\r\n                unmatched = matcher(seed, null, xml, []),\r\n                i = seed.length;\r\n\r\n              // Match elements unmatched by `matcher`\r\n              while (i--) {\r\n                if ((elem = unmatched[i])) {\r\n                  seed[i] = !(matches[i] = elem);\r\n                }\r\n              }\r\n            }) :\r\n            function (elem, context, xml) {\r\n              input[0] = elem;\r\n              matcher(input, null, xml, results);\r\n              return !results.pop();\r\n            };\r\n        }),\r\n\r\n        \"has\": markFunction(function (selector) {\r\n          return function (elem) {\r\n            return Sizzle(selector, elem).length > 0;\r\n          };\r\n        }),\r\n\r\n        \"contains\": markFunction(function (text) {\r\n          return function (elem) {\r\n            return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;\r\n          };\r\n        }),\r\n\r\n        // \"Whether an element is represented by a :lang() selector\r\n        // is based solely on the element's language value\r\n        // being equal to the identifier C,\r\n        // or beginning with the identifier C immediately followed by \"-\".\r\n        // The matching of C against the element's language value is performed case-insensitively.\r\n        // The identifier C does not have to be a valid language name.\"\r\n        // http://www.w3.org/TR/selectors/#lang-pseudo\r\n        \"lang\": markFunction(function (lang) {\r\n          // lang value must be a valid identifider\r\n          if (!ridentifier.test(lang || \"\")) {\r\n            Sizzle.error(\"unsupported lang: \" + lang);\r\n          }\r\n          lang = lang.replace(runescape, funescape).toLowerCase();\r\n          return function (elem) {\r\n            var elemLang;\r\n            do {\r\n              if ((elemLang = documentIsXML ?\r\n                elem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\") :\r\n                elem.lang)) {\r\n\r\n                elemLang = elemLang.toLowerCase();\r\n                return elemLang === lang || elemLang.indexOf(lang + \"-\") === 0;\r\n              }\r\n            } while ((elem = elem.parentNode) && elem.nodeType === 1);\r\n            return false;\r\n          };\r\n        }),\r\n\r\n        // Miscellaneous\r\n        \"target\": function (elem) {\r\n          var hash = window.location && window.location.hash;\r\n          return hash && hash.slice(1) === elem.id;\r\n        },\r\n\r\n        \"root\": function (elem) {\r\n          return elem === docElem;\r\n        },\r\n\r\n        \"focus\": function (elem) {\r\n          return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\r\n        },\r\n\r\n        // Boolean properties\r\n        \"enabled\": function (elem) {\r\n          return elem.disabled === false;\r\n        },\r\n\r\n        \"disabled\": function (elem) {\r\n          return elem.disabled === true;\r\n        },\r\n\r\n        \"checked\": function (elem) {\r\n          // In CSS3, :checked should return both checked and selected elements\r\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\r\n          var nodeName = elem.nodeName.toLowerCase();\r\n          return (nodeName === \"input\" && !!elem.checked) || (nodeName === \"option\" && !!elem.selected);\r\n        },\r\n\r\n        \"selected\": function (elem) {\r\n          // Accessing this property makes selected-by-default\r\n          // options in Safari work properly\r\n          if (elem.parentNode) {\r\n            elem.parentNode.selectedIndex;\r\n          }\r\n\r\n          return elem.selected === true;\r\n        },\r\n\r\n        // Contents\r\n        \"empty\": function (elem) {\r\n          // http://www.w3.org/TR/selectors/#empty-pseudo\r\n          // :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),\r\n          //   not comment, processing instructions, or others\r\n          // Thanks to Diego Perini for the nodeName shortcut\r\n          //   Greater than \"@\" means alpha characters (specifically not starting with \"#\" or \"?\")\r\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\r\n            if (elem.nodeName > \"@\" || elem.nodeType === 3 || elem.nodeType === 4) {\r\n              return false;\r\n            }\r\n          }\r\n          return true;\r\n        },\r\n\r\n        \"parent\": function (elem) {\r\n          return !Expr.pseudos[\"empty\"](elem);\r\n        },\r\n\r\n        // Element/input types\r\n        \"header\": function (elem) {\r\n          return rheader.test(elem.nodeName);\r\n        },\r\n\r\n        \"input\": function (elem) {\r\n          return rinputs.test(elem.nodeName);\r\n        },\r\n\r\n        \"button\": function (elem) {\r\n          var name = elem.nodeName.toLowerCase();\r\n          return name === \"input\" && elem.type === \"button\" || name === \"button\";\r\n        },\r\n\r\n        \"text\": function (elem) {\r\n          var attr;\r\n          // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)\r\n          // use getAttribute instead to test this case\r\n          return elem.nodeName.toLowerCase() === \"input\" &&\r\n            elem.type === \"text\" &&\r\n            ((attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === elem.type);\r\n        },\r\n\r\n        // Position-in-collection\r\n        \"first\": createPositionalPseudo(function () {\r\n          return [0];\r\n        }),\r\n\r\n        \"last\": createPositionalPseudo(function (matchIndexes, length) {\r\n          return [length - 1];\r\n        }),\r\n\r\n        \"eq\": createPositionalPseudo(function (matchIndexes, length, argument) {\r\n          return [argument < 0 ? argument + length : argument];\r\n        }),\r\n\r\n        \"even\": createPositionalPseudo(function (matchIndexes, length) {\r\n          var i = 0;\r\n          for (; i < length; i += 2) {\r\n            matchIndexes.push(i);\r\n          }\r\n          return matchIndexes;\r\n        }),\r\n\r\n        \"odd\": createPositionalPseudo(function (matchIndexes, length) {\r\n          var i = 1;\r\n          for (; i < length; i += 2) {\r\n            matchIndexes.push(i);\r\n          }\r\n          return matchIndexes;\r\n        }),\r\n\r\n        \"lt\": createPositionalPseudo(function (matchIndexes, length, argument) {\r\n          var i = argument < 0 ? argument + length : argument;\r\n          for (; --i >= 0;) {\r\n            matchIndexes.push(i);\r\n          }\r\n          return matchIndexes;\r\n        }),\r\n\r\n        \"gt\": createPositionalPseudo(function (matchIndexes, length, argument) {\r\n          var i = argument < 0 ? argument + length : argument;\r\n          for (; ++i < length;) {\r\n            matchIndexes.push(i);\r\n          }\r\n          return matchIndexes;\r\n        })\r\n      }\r\n    };\r\n\r\n    // Add button/input type pseudos\r\n    for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {\r\n      Expr.pseudos[i] = createInputPseudo(i);\r\n    }\r\n    for (i in { submit: true, reset: true }) {\r\n      Expr.pseudos[i] = createButtonPseudo(i);\r\n    }\r\n\r\n    function tokenize(selector, parseOnly) {\r\n      var matched, match, tokens, type,\r\n        soFar, groups, preFilters,\r\n        cached = tokenCache[selector + \" \"];\r\n\r\n      if (cached) {\r\n        return parseOnly ? 0 : cached.slice(0);\r\n      }\r\n\r\n      soFar = selector;\r\n      groups = [];\r\n      preFilters = Expr.preFilter;\r\n\r\n      while (soFar) {\r\n\r\n        // Comma and first run\r\n        if (!matched || (match = rcomma.exec(soFar))) {\r\n          if (match) {\r\n            // Don't consume trailing commas as valid\r\n            soFar = soFar.slice(match[0].length) || soFar;\r\n          }\r\n          groups.push(tokens = []);\r\n        }\r\n\r\n        matched = false;\r\n\r\n        // Combinators\r\n        if ((match = rcombinators.exec(soFar))) {\r\n          matched = match.shift();\r\n          tokens.push({\r\n            value: matched,\r\n            // Cast descendant combinators to space\r\n            type: match[0].replace(rtrim, \" \")\r\n          });\r\n          soFar = soFar.slice(matched.length);\r\n        }\r\n\r\n        // Filters\r\n        for (type in Expr.filter) {\r\n          if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] ||\r\n            (match = preFilters[type](match)))) {\r\n            matched = match.shift();\r\n            tokens.push({\r\n              value: matched,\r\n              type: type,\r\n              matches: match\r\n            });\r\n            soFar = soFar.slice(matched.length);\r\n          }\r\n        }\r\n\r\n        if (!matched) {\r\n          break;\r\n        }\r\n      }\r\n\r\n      // Return the length of the invalid excess\r\n      // if we're just parsing\r\n      // Otherwise, throw an error or return tokens\r\n      return parseOnly ?\r\n        soFar.length :\r\n        soFar ?\r\n          Sizzle.error(selector) :\r\n          // Cache the tokens\r\n          tokenCache(selector, groups).slice(0);\r\n    }\r\n\r\n    function toSelector(tokens) {\r\n      var i = 0,\r\n        len = tokens.length,\r\n        selector = \"\";\r\n      for (; i < len; i++) {\r\n        selector += tokens[i].value;\r\n      }\r\n      return selector;\r\n    }\r\n\r\n    function addCombinator(matcher, combinator, base) {\r\n      var dir = combinator.dir,\r\n        checkNonElements = base && dir === \"parentNode\",\r\n        doneName = done++;\r\n\r\n      return combinator.first ?\r\n        // Check against closest ancestor/preceding element\r\n        function (elem, context, xml) {\r\n          while ((elem = elem[dir])) {\r\n            if (elem.nodeType === 1 || checkNonElements) {\r\n              return matcher(elem, context, xml);\r\n            }\r\n          }\r\n        } :\r\n\r\n        // Check against all ancestor/preceding elements\r\n        function (elem, context, xml) {\r\n          var data, cache, outerCache,\r\n            dirkey = dirruns + \" \" + doneName;\r\n\r\n          // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching\r\n          if (xml) {\r\n            while ((elem = elem[dir])) {\r\n              if (elem.nodeType === 1 || checkNonElements) {\r\n                if (matcher(elem, context, xml)) {\r\n                  return true;\r\n                }\r\n              }\r\n            }\r\n          } else {\r\n            while ((elem = elem[dir])) {\r\n              if (elem.nodeType === 1 || checkNonElements) {\r\n                outerCache = elem[expando] || (elem[expando] = {});\r\n                if ((cache = outerCache[dir]) && cache[0] === dirkey) {\r\n                  if ((data = cache[1]) === true || data === cachedruns) {\r\n                    return data === true;\r\n                  }\r\n                } else {\r\n                  cache = outerCache[dir] = [dirkey];\r\n                  cache[1] = matcher(elem, context, xml) || cachedruns;\r\n                  if (cache[1] === true) {\r\n                    return true;\r\n                  }\r\n                }\r\n              }\r\n            }\r\n          }\r\n        };\r\n    }\r\n\r\n    function elementMatcher(matchers) {\r\n      return matchers.length > 1 ?\r\n        function (elem, context, xml) {\r\n          var i = matchers.length;\r\n          while (i--) {\r\n            if (!matchers[i](elem, context, xml)) {\r\n              return false;\r\n            }\r\n          }\r\n          return true;\r\n        } :\r\n        matchers[0];\r\n    }\r\n\r\n    function condense(unmatched, map, filter, context, xml) {\r\n      var elem,\r\n        newUnmatched = [],\r\n        i = 0,\r\n        len = unmatched.length,\r\n        mapped = map != null;\r\n\r\n      for (; i < len; i++) {\r\n        if ((elem = unmatched[i])) {\r\n          if (!filter || filter(elem, context, xml)) {\r\n            newUnmatched.push(elem);\r\n            if (mapped) {\r\n              map.push(i);\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return newUnmatched;\r\n    }\r\n\r\n    function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {\r\n      if (postFilter && !postFilter[expando]) {\r\n        postFilter = setMatcher(postFilter);\r\n      }\r\n      if (postFinder && !postFinder[expando]) {\r\n        postFinder = setMatcher(postFinder, postSelector);\r\n      }\r\n      return markFunction(function (seed, results, context, xml) {\r\n        var temp, i, elem,\r\n          preMap = [],\r\n          postMap = [],\r\n          preexisting = results.length,\r\n\r\n          // Get initial elements from seed or context\r\n          elems = seed || multipleContexts(selector || \"*\", context.nodeType ? [context] : context, []),\r\n\r\n          // Prefilter to get matcher input, preserving a map for seed-results synchronization\r\n          matcherIn = preFilter && (seed || !selector) ?\r\n            condense(elems, preMap, preFilter, context, xml) :\r\n            elems,\r\n\r\n          matcherOut = matcher ?\r\n            // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\r\n            postFinder || (seed ? preFilter : preexisting || postFilter) ?\r\n\r\n              // ...intermediate processing is necessary\r\n              [] :\r\n\r\n              // ...otherwise use results directly\r\n              results :\r\n            matcherIn;\r\n\r\n        // Find primary matches\r\n        if (matcher) {\r\n          matcher(matcherIn, matcherOut, context, xml);\r\n        }\r\n\r\n        // Apply postFilter\r\n        if (postFilter) {\r\n          temp = condense(matcherOut, postMap);\r\n          postFilter(temp, [], context, xml);\r\n\r\n          // Un-match failing elements by moving them back to matcherIn\r\n          i = temp.length;\r\n          while (i--) {\r\n            if ((elem = temp[i])) {\r\n              matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);\r\n            }\r\n          }\r\n        }\r\n\r\n        if (seed) {\r\n          if (postFinder || preFilter) {\r\n            if (postFinder) {\r\n              // Get the final matcherOut by condensing this intermediate into postFinder contexts\r\n              temp = [];\r\n              i = matcherOut.length;\r\n              while (i--) {\r\n                if ((elem = matcherOut[i])) {\r\n                  // Restore matcherIn since elem is not yet a final match\r\n                  temp.push((matcherIn[i] = elem));\r\n                }\r\n              }\r\n              postFinder(null, (matcherOut = []), temp, xml);\r\n            }\r\n\r\n            // Move matched elements from seed to results to keep them synchronized\r\n            i = matcherOut.length;\r\n            while (i--) {\r\n              if ((elem = matcherOut[i]) &&\r\n                (temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1) {\r\n\r\n                seed[temp] = !(results[temp] = elem);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Add elements to results, through postFinder if defined\r\n        } else {\r\n          matcherOut = condense(\r\n            matcherOut === results ?\r\n              matcherOut.splice(preexisting, matcherOut.length) :\r\n              matcherOut\r\n          );\r\n          if (postFinder) {\r\n            postFinder(null, results, matcherOut, xml);\r\n          } else {\r\n            push.apply(results, matcherOut);\r\n          }\r\n        }\r\n      });\r\n    }\r\n\r\n    function matcherFromTokens(tokens) {\r\n      var checkContext, matcher, j,\r\n        len = tokens.length,\r\n        leadingRelative = Expr.relative[tokens[0].type],\r\n        implicitRelative = leadingRelative || Expr.relative[\" \"],\r\n        i = leadingRelative ? 1 : 0,\r\n\r\n        // The foundational matcher ensures that elements are reachable from top-level context(s)\r\n        matchContext = addCombinator(function (elem) {\r\n          return elem === checkContext;\r\n        }, implicitRelative, true),\r\n        matchAnyContext = addCombinator(function (elem) {\r\n          return indexOf.call(checkContext, elem) > -1;\r\n        }, implicitRelative, true),\r\n        matchers = [function (elem, context, xml) {\r\n          return (!leadingRelative && (xml || context !== outermostContext)) || (\r\n            (checkContext = context).nodeType ?\r\n              matchContext(elem, context, xml) :\r\n              matchAnyContext(elem, context, xml));\r\n        }];\r\n\r\n      for (; i < len; i++) {\r\n        if ((matcher = Expr.relative[tokens[i].type])) {\r\n          matchers = [addCombinator(elementMatcher(matchers), matcher)];\r\n        } else {\r\n          matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);\r\n\r\n          // Return special upon seeing a positional matcher\r\n          if (matcher[expando]) {\r\n            // Find the next relative operator (if any) for proper handling\r\n            j = ++i;\r\n            for (; j < len; j++) {\r\n              if (Expr.relative[tokens[j].type]) {\r\n                break;\r\n              }\r\n            }\r\n            return setMatcher(\r\n              i > 1 && elementMatcher(matchers),\r\n              i > 1 && toSelector(tokens.slice(0, i - 1)).replace(rtrim, \"$1\"),\r\n              matcher,\r\n              i < j && matcherFromTokens(tokens.slice(i, j)),\r\n              j < len && matcherFromTokens((tokens = tokens.slice(j))),\r\n              j < len && toSelector(tokens)\r\n            );\r\n          }\r\n          matchers.push(matcher);\r\n        }\r\n      }\r\n\r\n      return elementMatcher(matchers);\r\n    }\r\n\r\n    function matcherFromGroupMatchers(elementMatchers, setMatchers) {\r\n      // A counter to specify which element is currently being matched\r\n      var matcherCachedRuns = 0,\r\n        bySet = setMatchers.length > 0,\r\n        byElement = elementMatchers.length > 0,\r\n        superMatcher = function (seed, context, xml, results, expandContext) {\r\n          var elem, j, matcher,\r\n            setMatched = [],\r\n            matchedCount = 0,\r\n            i = \"0\",\r\n            unmatched = seed && [],\r\n            outermost = expandContext != null,\r\n            contextBackup = outermostContext,\r\n            // We must always have either seed elements or context\r\n            elems = seed || byElement && Expr.find[\"TAG\"](\"*\", expandContext && context.parentNode || context),\r\n            // Use integer dirruns iff this is the outermost matcher\r\n            dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);\r\n\r\n          if (outermost) {\r\n            outermostContext = context !== document && context;\r\n            cachedruns = matcherCachedRuns;\r\n          }\r\n\r\n          // Add elements passing elementMatchers directly to results\r\n          // Keep `i` a string if there are no elements so `matchedCount` will be \"00\" below\r\n          for (; (elem = elems[i]) != null; i++) {\r\n            if (byElement && elem) {\r\n              j = 0;\r\n              while ((matcher = elementMatchers[j++])) {\r\n                if (matcher(elem, context, xml)) {\r\n                  results.push(elem);\r\n                  break;\r\n                }\r\n              }\r\n              if (outermost) {\r\n                dirruns = dirrunsUnique;\r\n                cachedruns = ++matcherCachedRuns;\r\n              }\r\n            }\r\n\r\n            // Track unmatched elements for set filters\r\n            if (bySet) {\r\n              // They will have gone through all possible matchers\r\n              if ((elem = !matcher && elem)) {\r\n                matchedCount--;\r\n              }\r\n\r\n              // Lengthen the array for every element, matched or not\r\n              if (seed) {\r\n                unmatched.push(elem);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Apply set filters to unmatched elements\r\n          matchedCount += i;\r\n          if (bySet && i !== matchedCount) {\r\n            j = 0;\r\n            while ((matcher = setMatchers[j++])) {\r\n              matcher(unmatched, setMatched, context, xml);\r\n            }\r\n\r\n            if (seed) {\r\n              // Reintegrate element matches to eliminate the need for sorting\r\n              if (matchedCount > 0) {\r\n                while (i--) {\r\n                  if (!(unmatched[i] || setMatched[i])) {\r\n                    setMatched[i] = pop.call(results);\r\n                  }\r\n                }\r\n              }\r\n\r\n              // Discard index placeholder values to get only actual matches\r\n              setMatched = condense(setMatched);\r\n            }\r\n\r\n            // Add matches to results\r\n            push.apply(results, setMatched);\r\n\r\n            // Seedless set matches succeeding multiple successful matchers stipulate sorting\r\n            if (outermost && !seed && setMatched.length > 0 &&\r\n              (matchedCount + setMatchers.length) > 1) {\r\n\r\n              Sizzle.uniqueSort(results);\r\n            }\r\n          }\r\n\r\n          // Override manipulation of globals by nested matchers\r\n          if (outermost) {\r\n            dirruns = dirrunsUnique;\r\n            outermostContext = contextBackup;\r\n          }\r\n\r\n          return unmatched;\r\n        };\r\n\r\n      return bySet ?\r\n        markFunction(superMatcher) :\r\n        superMatcher;\r\n    }\r\n\r\n    compile = Sizzle.compile = function (selector, group /* Internal Use Only */) {\r\n      var i,\r\n        setMatchers = [],\r\n        elementMatchers = [],\r\n        cached = compilerCache[selector + \" \"];\r\n\r\n      if (!cached) {\r\n        // Generate a function of recursive functions that can be used to check each element\r\n        if (!group) {\r\n          group = tokenize(selector);\r\n        }\r\n        i = group.length;\r\n        while (i--) {\r\n          cached = matcherFromTokens(group[i]);\r\n          if (cached[expando]) {\r\n            setMatchers.push(cached);\r\n          } else {\r\n            elementMatchers.push(cached);\r\n          }\r\n        }\r\n\r\n        // Cache the compiled function\r\n        cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));\r\n      }\r\n      return cached;\r\n    };\r\n\r\n    function multipleContexts(selector, contexts, results) {\r\n      var i = 0,\r\n        len = contexts.length;\r\n      for (; i < len; i++) {\r\n        Sizzle(selector, contexts[i], results);\r\n      }\r\n      return results;\r\n    }\r\n\r\n    function select(selector, context, results, seed) {\r\n      var i, tokens, token, type, find,\r\n        match = tokenize(selector);\r\n\r\n      if (!seed) {\r\n        // Try to minimize operations if there is only one group\r\n        if (match.length === 1) {\r\n\r\n          // Take a shortcut and set the context if the root selector is an ID\r\n          tokens = match[0] = match[0].slice(0);\r\n          if (tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\r\n            context.nodeType === 9 && !documentIsXML &&\r\n            Expr.relative[tokens[1].type]) {\r\n\r\n            context = Expr.find[\"ID\"](token.matches[0].replace(runescape, funescape), context)[0];\r\n            if (!context) {\r\n              return results;\r\n            }\r\n\r\n            selector = selector.slice(tokens.shift().value.length);\r\n          }\r\n\r\n          // Fetch a seed set for right-to-left matching\r\n          i = matchExpr[\"needsContext\"].test(selector) ? 0 : tokens.length;\r\n          while (i--) {\r\n            token = tokens[i];\r\n\r\n            // Abort if we hit a combinator\r\n            if (Expr.relative[(type = token.type)]) {\r\n              break;\r\n            }\r\n            if ((find = Expr.find[type])) {\r\n              // Search, expanding context for leading sibling combinators\r\n              if ((seed = find(\r\n                token.matches[0].replace(runescape, funescape),\r\n                rsibling.test(tokens[0].type) && context.parentNode || context\r\n              ))) {\r\n\r\n                // If seed is empty or no tokens remain, we can return early\r\n                tokens.splice(i, 1);\r\n                selector = seed.length && toSelector(tokens);\r\n                if (!selector) {\r\n                  push.apply(results, slice.call(seed, 0));\r\n                  return results;\r\n                }\r\n\r\n                break;\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      // Compile and execute a filtering function\r\n      // Provide `match` to avoid retokenization if we modified the selector above\r\n      compile(selector, match)(\r\n        seed,\r\n        context,\r\n        documentIsXML,\r\n        results,\r\n        rsibling.test(selector)\r\n      );\r\n      return results;\r\n    }\r\n\r\n    // Deprecated\r\n    Expr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\r\n\r\n    // Easy API for creating new setFilters\r\n    function setFilters() { }\r\n    Expr.filters = setFilters.prototype = Expr.pseudos;\r\n    Expr.setFilters = new setFilters();\r\n\r\n    // Initialize with the default document\r\n    setDocument();\r\n\r\n    // Override sizzle attribute retrieval\r\n    Sizzle.attr = jQuery.attr;\r\n    jQuery.find = Sizzle;\r\n    jQuery.expr = Sizzle.selectors;\r\n    jQuery.expr[\":\"] = jQuery.expr.pseudos;\r\n    jQuery.unique = Sizzle.uniqueSort;\r\n    jQuery.text = Sizzle.getText;\r\n    jQuery.isXMLDoc = Sizzle.isXML;\r\n    jQuery.contains = Sizzle.contains;\r\n\r\n\r\n  })(window);\r\n  var runtil = /Until$/,\r\n    rparentsprev = /^(?:parents|prev(?:Until|All))/,\r\n    isSimple = /^.[^:#\\[\\.,]*$/,\r\n    rneedsContext = jQuery.expr.match.needsContext,\r\n    // methods guaranteed to produce a unique set when starting from a unique set\r\n    guaranteedUnique = {\r\n      children: true,\r\n      contents: true,\r\n      next: true,\r\n      prev: true\r\n    };\r\n\r\n  jQuery.fn.extend({\r\n    find: function (selector) {\r\n      var i, ret, self,\r\n        len = this.length;\r\n\r\n      if (typeof selector !== \"string\") {\r\n        self = this;\r\n        return this.pushStack(jQuery(selector).filter(function () {\r\n          for (i = 0; i < len; i++) {\r\n            if (jQuery.contains(self[i], this)) {\r\n              return true;\r\n            }\r\n          }\r\n        }));\r\n      }\r\n\r\n      ret = [];\r\n      for (i = 0; i < len; i++) {\r\n        jQuery.find(selector, this[i], ret);\r\n      }\r\n\r\n      // Needed because $( selector, context ) becomes $( context ).find( selector )\r\n      ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);\r\n      ret.selector = (this.selector ? this.selector + \" \" : \"\") + selector;\r\n      return ret;\r\n    },\r\n\r\n    has: function (target) {\r\n      var i,\r\n        targets = jQuery(target, this),\r\n        len = targets.length;\r\n\r\n      return this.filter(function () {\r\n        for (i = 0; i < len; i++) {\r\n          if (jQuery.contains(this, targets[i])) {\r\n            return true;\r\n          }\r\n        }\r\n      });\r\n    },\r\n\r\n    not: function (selector) {\r\n      return this.pushStack(winnow(this, selector, false));\r\n    },\r\n\r\n    filter: function (selector) {\r\n      return this.pushStack(winnow(this, selector, true));\r\n    },\r\n\r\n    is: function (selector) {\r\n      return !!selector && (\r\n        typeof selector === \"string\" ?\r\n          // If this is a positional/relative selector, check membership in the returned set\r\n          // so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\r\n          rneedsContext.test(selector) ?\r\n            jQuery(selector, this.context).index(this[0]) >= 0 :\r\n            jQuery.filter(selector, this).length > 0 :\r\n          this.filter(selector).length > 0);\r\n    },\r\n\r\n    closest: function (selectors, context) {\r\n      var cur,\r\n        i = 0,\r\n        l = this.length,\r\n        ret = [],\r\n        pos = rneedsContext.test(selectors) || typeof selectors !== \"string\" ?\r\n          jQuery(selectors, context || this.context) :\r\n          0;\r\n\r\n      for (; i < l; i++) {\r\n        cur = this[i];\r\n\r\n        while (cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11) {\r\n          if (pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors)) {\r\n            ret.push(cur);\r\n            break;\r\n          }\r\n          cur = cur.parentNode;\r\n        }\r\n      }\r\n\r\n      return this.pushStack(ret.length > 1 ? jQuery.unique(ret) : ret);\r\n    },\r\n\r\n    // Determine the position of an element within\r\n    // the matched set of elements\r\n    index: function (elem) {\r\n\r\n      // No argument, return index in parent\r\n      if (!elem) {\r\n        return (this[0] && this[0].parentNode) ? this.first().prevAll().length : -1;\r\n      }\r\n\r\n      // index in selector\r\n      if (typeof elem === \"string\") {\r\n        return jQuery.inArray(this[0], jQuery(elem));\r\n      }\r\n\r\n      // Locate the position of the desired element\r\n      return jQuery.inArray(\r\n        // If it receives a jQuery object, the first element is used\r\n        elem.jquery ? elem[0] : elem, this);\r\n    },\r\n\r\n    add: function (selector, context) {\r\n      var set = typeof selector === \"string\" ?\r\n        jQuery(selector, context) :\r\n        jQuery.makeArray(selector && selector.nodeType ? [selector] : selector),\r\n        all = jQuery.merge(this.get(), set);\r\n\r\n      return this.pushStack(jQuery.unique(all));\r\n    },\r\n\r\n    addBack: function (selector) {\r\n      return this.add(selector == null ?\r\n        this.prevObject : this.prevObject.filter(selector)\r\n      );\r\n    }\r\n  });\r\n\r\n  jQuery.fn.andSelf = jQuery.fn.addBack;\r\n\r\n  function sibling(cur, dir) {\r\n    do {\r\n      cur = cur[dir];\r\n    } while (cur && cur.nodeType !== 1);\r\n\r\n    return cur;\r\n  }\r\n\r\n  jQuery.each({\r\n    parent: function (elem) {\r\n      var parent = elem.parentNode;\r\n      return parent && parent.nodeType !== 11 ? parent : null;\r\n    },\r\n    parents: function (elem) {\r\n      return jQuery.dir(elem, \"parentNode\");\r\n    },\r\n    parentsUntil: function (elem, i, until) {\r\n      return jQuery.dir(elem, \"parentNode\", until);\r\n    },\r\n    next: function (elem) {\r\n      return sibling(elem, \"nextSibling\");\r\n    },\r\n    prev: function (elem) {\r\n      return sibling(elem, \"previousSibling\");\r\n    },\r\n    nextAll: function (elem) {\r\n      return jQuery.dir(elem, \"nextSibling\");\r\n    },\r\n    prevAll: function (elem) {\r\n      return jQuery.dir(elem, \"previousSibling\");\r\n    },\r\n    nextUntil: function (elem, i, until) {\r\n      return jQuery.dir(elem, \"nextSibling\", until);\r\n    },\r\n    prevUntil: function (elem, i, until) {\r\n      return jQuery.dir(elem, \"previousSibling\", until);\r\n    },\r\n    siblings: function (elem) {\r\n      return jQuery.sibling((elem.parentNode || {}).firstChild, elem);\r\n    },\r\n    children: function (elem) {\r\n      return jQuery.sibling(elem.firstChild);\r\n    },\r\n    contents: function (elem) {\r\n      return jQuery.nodeName(elem, \"iframe\") ?\r\n        elem.contentDocument || elem.contentWindow.document :\r\n        jQuery.merge([], elem.childNodes);\r\n    }\r\n  }, function (name, fn) {\r\n    jQuery.fn[name] = function (until, selector) {\r\n      var ret = jQuery.map(this, fn, until);\r\n\r\n      if (!runtil.test(name)) {\r\n        selector = until;\r\n      }\r\n\r\n      if (selector && typeof selector === \"string\") {\r\n        ret = jQuery.filter(selector, ret);\r\n      }\r\n\r\n      ret = this.length > 1 && !guaranteedUnique[name] ? jQuery.unique(ret) : ret;\r\n\r\n      if (this.length > 1 && rparentsprev.test(name)) {\r\n        ret = ret.reverse();\r\n      }\r\n\r\n      return this.pushStack(ret);\r\n    };\r\n  });\r\n\r\n  jQuery.extend({\r\n    filter: function (expr, elems, not) {\r\n      if (not) {\r\n        expr = \":not(\" + expr + \")\";\r\n      }\r\n\r\n      return elems.length === 1 ?\r\n        jQuery.find.matchesSelector(elems[0], expr) ? [elems[0]] : [] :\r\n        jQuery.find.matches(expr, elems);\r\n    },\r\n\r\n    dir: function (elem, dir, until) {\r\n      var matched = [],\r\n        cur = elem[dir];\r\n\r\n      while (cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery(cur).is(until))) {\r\n        if (cur.nodeType === 1) {\r\n          matched.push(cur);\r\n        }\r\n        cur = cur[dir];\r\n      }\r\n      return matched;\r\n    },\r\n\r\n    sibling: function (n, elem) {\r\n      var r = [];\r\n\r\n      for (; n; n = n.nextSibling) {\r\n        if (n.nodeType === 1 && n !== elem) {\r\n          r.push(n);\r\n        }\r\n      }\r\n\r\n      return r;\r\n    }\r\n  });\r\n\r\n  // Implement the identical functionality for filter and not\r\n  function winnow(elements, qualifier, keep) {\r\n\r\n    // Can't pass null or undefined to indexOf in Firefox 4\r\n    // Set to 0 to skip string check\r\n    qualifier = qualifier || 0;\r\n\r\n    if (jQuery.isFunction(qualifier)) {\r\n      return jQuery.grep(elements, function (elem, i) {\r\n        var retVal = !!qualifier.call(elem, i, elem);\r\n        return retVal === keep;\r\n      });\r\n\r\n    } else if (qualifier.nodeType) {\r\n      return jQuery.grep(elements, function (elem) {\r\n        return (elem === qualifier) === keep;\r\n      });\r\n\r\n    } else if (typeof qualifier === \"string\") {\r\n      var filtered = jQuery.grep(elements, function (elem) {\r\n        return elem.nodeType === 1;\r\n      });\r\n\r\n      if (isSimple.test(qualifier)) {\r\n        return jQuery.filter(qualifier, filtered, !keep);\r\n      } else {\r\n        qualifier = jQuery.filter(qualifier, filtered);\r\n      }\r\n    }\r\n\r\n    return jQuery.grep(elements, function (elem) {\r\n      return (jQuery.inArray(elem, qualifier) >= 0) === keep;\r\n    });\r\n  }\r\n  function createSafeFragment(document) {\r\n    var list = nodeNames.split(\"|\"),\r\n      safeFrag = document.createDocumentFragment();\r\n\r\n    if (safeFrag.createElement) {\r\n      while (list.length) {\r\n        safeFrag.createElement(\r\n          list.pop()\r\n        );\r\n      }\r\n    }\r\n    return safeFrag;\r\n  }\r\n\r\n  var nodeNames = \"abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|\" +\r\n    \"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video\",\r\n    rinlinejQuery = / jQuery\\d+=\"(?:null|\\d+)\"/g,\r\n    rnoshimcache = new RegExp(\"<(?:\" + nodeNames + \")[\\\\s/>]\", \"i\"),\r\n    rleadingWhitespace = /^\\s+/,\r\n    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\\w:]+)[^>]*)\\/>/gi,\r\n    rtagName = /<([\\w:]+)/,\r\n    rtbody = /<tbody/i,\r\n    rhtml = /<|&#?\\w+;/,\r\n    rnoInnerhtml = /<(?:script|style|link)/i,\r\n    manipulation_rcheckableType = /^(?:checkbox|radio)$/i,\r\n    // checked=\"checked\" or checked\r\n    rchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\r\n    rscriptType = /^$|\\/(?:java|ecma)script/i,\r\n    rscriptTypeMasked = /^true\\/(.*)/,\r\n    rcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g,\r\n\r\n    // We have to close these tags to support XHTML (#13200)\r\n    wrapMap = {\r\n      option: [1, \"<select multiple='multiple'>\", \"</select>\"],\r\n      legend: [1, \"<fieldset>\", \"</fieldset>\"],\r\n      area: [1, \"<map>\", \"</map>\"],\r\n      param: [1, \"<object>\", \"</object>\"],\r\n      thead: [1, \"<table>\", \"</table>\"],\r\n      tr: [2, \"<table><tbody>\", \"</tbody></table>\"],\r\n      col: [2, \"<table><tbody></tbody><colgroup>\", \"</colgroup></table>\"],\r\n      td: [3, \"<table><tbody><tr>\", \"</tr></tbody></table>\"],\r\n\r\n      // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,\r\n      // unless wrapped in a div with non-breaking characters in front of it.\r\n      _default: jQuery.support.htmlSerialize ? [0, \"\", \"\"] : [1, \"X<div>\", \"</div>\"]\r\n    },\r\n    safeFragment = createSafeFragment(document),\r\n    fragmentDiv = safeFragment.appendChild(document.createElement(\"div\"));\r\n\r\n  wrapMap.optgroup = wrapMap.option;\r\n  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\r\n  wrapMap.th = wrapMap.td;\r\n\r\n  jQuery.fn.extend({\r\n    text: function (value) {\r\n      return jQuery.access(this, function (value) {\r\n        return value === undefined ?\r\n          jQuery.text(this) :\r\n          this.empty().append((this[0] && this[0].ownerDocument || document).createTextNode(value));\r\n      }, null, value, arguments.length);\r\n    },\r\n\r\n    wrapAll: function (html) {\r\n      if (jQuery.isFunction(html)) {\r\n        return this.each(function (i) {\r\n          jQuery(this).wrapAll(html.call(this, i));\r\n        });\r\n      }\r\n\r\n      if (this[0]) {\r\n        // The elements to wrap the target around\r\n        var wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);\r\n\r\n        if (this[0].parentNode) {\r\n          wrap.insertBefore(this[0]);\r\n        }\r\n\r\n        wrap.map(function () {\r\n          var elem = this;\r\n\r\n          while (elem.firstChild && elem.firstChild.nodeType === 1) {\r\n            elem = elem.firstChild;\r\n          }\r\n\r\n          return elem;\r\n        }).append(this);\r\n      }\r\n\r\n      return this;\r\n    },\r\n\r\n    wrapInner: function (html) {\r\n      if (jQuery.isFunction(html)) {\r\n        return this.each(function (i) {\r\n          jQuery(this).wrapInner(html.call(this, i));\r\n        });\r\n      }\r\n\r\n      return this.each(function () {\r\n        var self = jQuery(this),\r\n          contents = self.contents();\r\n\r\n        if (contents.length) {\r\n          contents.wrapAll(html);\r\n\r\n        } else {\r\n          self.append(html);\r\n        }\r\n      });\r\n    },\r\n\r\n    wrap: function (html) {\r\n      var isFunction = jQuery.isFunction(html);\r\n\r\n      return this.each(function (i) {\r\n        jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);\r\n      });\r\n    },\r\n\r\n    unwrap: function () {\r\n      return this.parent().each(function () {\r\n        if (!jQuery.nodeName(this, \"body\")) {\r\n          jQuery(this).replaceWith(this.childNodes);\r\n        }\r\n      }).end();\r\n    },\r\n\r\n    append: function () {\r\n      return this.domManip(arguments, true, function (elem) {\r\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\r\n          this.appendChild(elem);\r\n        }\r\n      });\r\n    },\r\n\r\n    prepend: function () {\r\n      return this.domManip(arguments, true, function (elem) {\r\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\r\n          this.insertBefore(elem, this.firstChild);\r\n        }\r\n      });\r\n    },\r\n\r\n    before: function () {\r\n      return this.domManip(arguments, false, function (elem) {\r\n        if (this.parentNode) {\r\n          this.parentNode.insertBefore(elem, this);\r\n        }\r\n      });\r\n    },\r\n\r\n    after: function () {\r\n      return this.domManip(arguments, false, function (elem) {\r\n        if (this.parentNode) {\r\n          this.parentNode.insertBefore(elem, this.nextSibling);\r\n        }\r\n      });\r\n    },\r\n\r\n    // keepData is for internal use only--do not document\r\n    remove: function (selector, keepData) {\r\n      var elem,\r\n        i = 0;\r\n\r\n      for (; (elem = this[i]) != null; i++) {\r\n        if (!selector || jQuery.filter(selector, [elem]).length > 0) {\r\n          if (!keepData && elem.nodeType === 1) {\r\n            jQuery.cleanData(getAll(elem));\r\n          }\r\n\r\n          if (elem.parentNode) {\r\n            if (keepData && jQuery.contains(elem.ownerDocument, elem)) {\r\n              setGlobalEval(getAll(elem, \"script\"));\r\n            }\r\n            elem.parentNode.removeChild(elem);\r\n          }\r\n        }\r\n      }\r\n\r\n      return this;\r\n    },\r\n\r\n    empty: function () {\r\n      var elem,\r\n        i = 0;\r\n\r\n      for (; (elem = this[i]) != null; i++) {\r\n        // Remove element nodes and prevent memory leaks\r\n        if (elem.nodeType === 1) {\r\n          jQuery.cleanData(getAll(elem, false));\r\n        }\r\n\r\n        // Remove any remaining nodes\r\n        while (elem.firstChild) {\r\n          elem.removeChild(elem.firstChild);\r\n        }\r\n\r\n        // If this is a select, ensure that it displays empty (#12336)\r\n        // Support: IE<9\r\n        if (elem.options && jQuery.nodeName(elem, \"select\")) {\r\n          elem.options.length = 0;\r\n        }\r\n      }\r\n\r\n      return this;\r\n    },\r\n\r\n    clone: function (dataAndEvents, deepDataAndEvents) {\r\n      dataAndEvents = dataAndEvents == null ? false : dataAndEvents;\r\n      deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\r\n\r\n      return this.map(function () {\r\n        return jQuery.clone(this, dataAndEvents, deepDataAndEvents);\r\n      });\r\n    },\r\n\r\n    html: function (value) {\r\n      return jQuery.access(this, function (value) {\r\n        var elem = this[0] || {},\r\n          i = 0,\r\n          l = this.length;\r\n\r\n        if (value === undefined) {\r\n          return elem.nodeType === 1 ?\r\n            elem.innerHTML.replace(rinlinejQuery, \"\") :\r\n            undefined;\r\n        }\r\n\r\n        // See if we can take a shortcut and just use innerHTML\r\n        if (typeof value === \"string\" && !rnoInnerhtml.test(value) &&\r\n          (jQuery.support.htmlSerialize || !rnoshimcache.test(value)) &&\r\n          (jQuery.support.leadingWhitespace || !rleadingWhitespace.test(value)) &&\r\n          !wrapMap[(rtagName.exec(value) || [\"\", \"\"])[1].toLowerCase()]) {\r\n\r\n          value = value.replace(rxhtmlTag, \"<$1></$2>\");\r\n\r\n          try {\r\n            for (; i < l; i++) {\r\n              // Remove element nodes and prevent memory leaks\r\n              elem = this[i] || {};\r\n              if (elem.nodeType === 1) {\r\n                jQuery.cleanData(getAll(elem, false));\r\n                elem.innerHTML = value;\r\n              }\r\n            }\r\n\r\n            elem = 0;\r\n\r\n            // If using innerHTML throws an exception, use the fallback method\r\n          } catch (e) { }\r\n        }\r\n\r\n        if (elem) {\r\n          this.empty().append(value);\r\n        }\r\n      }, null, value, arguments.length);\r\n    },\r\n\r\n    replaceWith: function (value) {\r\n      var isFunc = jQuery.isFunction(value);\r\n\r\n      // Make sure that the elements are removed from the DOM before they are inserted\r\n      // this can help fix replacing a parent with child elements\r\n      if (!isFunc && typeof value !== \"string\") {\r\n        value = jQuery(value).not(this).detach();\r\n      }\r\n\r\n      return this.domManip([value], true, function (elem) {\r\n        var next = this.nextSibling,\r\n          parent = this.parentNode;\r\n\r\n        if (parent) {\r\n          jQuery(this).remove();\r\n          parent.insertBefore(elem, next);\r\n        }\r\n      });\r\n    },\r\n\r\n    detach: function (selector) {\r\n      return this.remove(selector, true);\r\n    },\r\n\r\n    domManip: function (args, table, callback) {\r\n\r\n      // Flatten any nested arrays\r\n      args = core_concat.apply([], args);\r\n\r\n      var first, node, hasScripts,\r\n        scripts, doc, fragment,\r\n        i = 0,\r\n        l = this.length,\r\n        set = this,\r\n        iNoClone = l - 1,\r\n        value = args[0],\r\n        isFunction = jQuery.isFunction(value);\r\n\r\n      // We can't cloneNode fragments that contain checked, in WebKit\r\n      if (isFunction || !(l <= 1 || typeof value !== \"string\" || jQuery.support.checkClone || !rchecked.test(value))) {\r\n        return this.each(function (index) {\r\n          var self = set.eq(index);\r\n          if (isFunction) {\r\n            args[0] = value.call(this, index, table ? self.html() : undefined);\r\n          }\r\n          self.domManip(args, table, callback);\r\n        });\r\n      }\r\n\r\n      if (l) {\r\n        fragment = jQuery.buildFragment(args, this[0].ownerDocument, false, this);\r\n        first = fragment.firstChild;\r\n\r\n        if (fragment.childNodes.length === 1) {\r\n          fragment = first;\r\n        }\r\n\r\n        if (first) {\r\n          table = table && jQuery.nodeName(first, \"tr\");\r\n          scripts = jQuery.map(getAll(fragment, \"script\"), disableScript);\r\n          hasScripts = scripts.length;\r\n\r\n          // Use the original fragment for the last item instead of the first because it can end up\r\n          // being emptied incorrectly in certain situations (#8070).\r\n          for (; i < l; i++) {\r\n            node = fragment;\r\n\r\n            if (i !== iNoClone) {\r\n              node = jQuery.clone(node, true, true);\r\n\r\n              // Keep references to cloned scripts for later restoration\r\n              if (hasScripts) {\r\n                jQuery.merge(scripts, getAll(node, \"script\"));\r\n              }\r\n            }\r\n\r\n            callback.call(\r\n              table && jQuery.nodeName(this[i], \"table\") ?\r\n                findOrAppend(this[i], \"tbody\") :\r\n                this[i],\r\n              node,\r\n              i\r\n            );\r\n          }\r\n\r\n          if (hasScripts) {\r\n            doc = scripts[scripts.length - 1].ownerDocument;\r\n\r\n            // Reenable scripts\r\n            jQuery.map(scripts, restoreScript);\r\n\r\n            // Evaluate executable scripts on first document insertion\r\n            for (i = 0; i < hasScripts; i++) {\r\n              node = scripts[i];\r\n              if (rscriptType.test(node.type || \"\") &&\r\n                !jQuery._data(node, \"globalEval\") && jQuery.contains(doc, node)) {\r\n\r\n                if (node.src) {\r\n                  // Hope ajax is available...\r\n                  jQuery.ajax({\r\n                    url: node.src,\r\n                    type: \"GET\",\r\n                    dataType: \"script\",\r\n                    async: false,\r\n                    global: false,\r\n                    \"throws\": true\r\n                  });\r\n                } else {\r\n                  jQuery.globalEval((node.text || node.textContent || node.innerHTML || \"\").replace(rcleanScript, \"\"));\r\n                }\r\n              }\r\n            }\r\n          }\r\n\r\n          // Fix #11809: Avoid leaking memory\r\n          fragment = first = null;\r\n        }\r\n      }\r\n\r\n      return this;\r\n    }\r\n  });\r\n\r\n  function findOrAppend(elem, tag) {\r\n    return elem.getElementsByTagName(tag)[0] || elem.appendChild(elem.ownerDocument.createElement(tag));\r\n  }\r\n\r\n  // Replace/restore the type attribute of script elements for safe DOM manipulation\r\n  function disableScript(elem) {\r\n    var attr = elem.getAttributeNode(\"type\");\r\n    elem.type = (attr && attr.specified) + \"/\" + elem.type;\r\n    return elem;\r\n  }\r\n  function restoreScript(elem) {\r\n    var match = rscriptTypeMasked.exec(elem.type);\r\n    if (match) {\r\n      elem.type = match[1];\r\n    } else {\r\n      elem.removeAttribute(\"type\");\r\n    }\r\n    return elem;\r\n  }\r\n\r\n  // Mark scripts as having already been evaluated\r\n  function setGlobalEval(elems, refElements) {\r\n    var elem,\r\n      i = 0;\r\n    for (; (elem = elems[i]) != null; i++) {\r\n      jQuery._data(elem, \"globalEval\", !refElements || jQuery._data(refElements[i], \"globalEval\"));\r\n    }\r\n  }\r\n\r\n  function cloneCopyEvent(src, dest) {\r\n\r\n    if (dest.nodeType !== 1 || !jQuery.hasData(src)) {\r\n      return;\r\n    }\r\n\r\n    var type, i, l,\r\n      oldData = jQuery._data(src),\r\n      curData = jQuery._data(dest, oldData),\r\n      events = oldData.events;\r\n\r\n    if (events) {\r\n      delete curData.handle;\r\n      curData.events = {};\r\n\r\n      for (type in events) {\r\n        for (i = 0, l = events[type].length; i < l; i++) {\r\n          jQuery.event.add(dest, type, events[type][i]);\r\n        }\r\n      }\r\n    }\r\n\r\n    // make the cloned public data object a copy from the original\r\n    if (curData.data) {\r\n      curData.data = jQuery.extend({}, curData.data);\r\n    }\r\n  }\r\n\r\n  function fixCloneNodeIssues(src, dest) {\r\n    var nodeName, e, data;\r\n\r\n    // We do not need to do anything for non-Elements\r\n    if (dest.nodeType !== 1) {\r\n      return;\r\n    }\r\n\r\n    nodeName = dest.nodeName.toLowerCase();\r\n\r\n    // IE6-8 copies events bound via attachEvent when using cloneNode.\r\n    if (!jQuery.support.noCloneEvent && dest[jQuery.expando]) {\r\n      data = jQuery._data(dest);\r\n\r\n      for (e in data.events) {\r\n        jQuery.removeEvent(dest, e, data.handle);\r\n      }\r\n\r\n      // Event data gets referenced instead of copied if the expando gets copied too\r\n      dest.removeAttribute(jQuery.expando);\r\n    }\r\n\r\n    // IE blanks contents when cloning scripts, and tries to evaluate newly-set text\r\n    if (nodeName === \"script\" && dest.text !== src.text) {\r\n      disableScript(dest).text = src.text;\r\n      restoreScript(dest);\r\n\r\n      // IE6-10 improperly clones children of object elements using classid.\r\n      // IE10 throws NoModificationAllowedError if parent is null, #12132.\r\n    } else if (nodeName === \"object\") {\r\n      if (dest.parentNode) {\r\n        dest.outerHTML = src.outerHTML;\r\n      }\r\n\r\n      // This path appears unavoidable for IE9. When cloning an object\r\n      // element in IE9, the outerHTML strategy above is not sufficient.\r\n      // If the src has innerHTML and the destination does not,\r\n      // copy the src.innerHTML into the dest.innerHTML. #10324\r\n      if (jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML))) {\r\n        dest.innerHTML = src.innerHTML;\r\n      }\r\n\r\n    } else if (nodeName === \"input\" && manipulation_rcheckableType.test(src.type)) {\r\n      // IE6-8 fails to persist the checked state of a cloned checkbox\r\n      // or radio button. Worse, IE6-7 fail to give the cloned element\r\n      // a checked appearance if the defaultChecked value isn't also set\r\n\r\n      dest.defaultChecked = dest.checked = src.checked;\r\n\r\n      // IE6-7 get confused and end up setting the value of a cloned\r\n      // checkbox/radio button to an empty string instead of \"on\"\r\n      if (dest.value !== src.value) {\r\n        dest.value = src.value;\r\n      }\r\n\r\n      // IE6-8 fails to return the selected option to the default selected\r\n      // state when cloning options\r\n    } else if (nodeName === \"option\") {\r\n      dest.defaultSelected = dest.selected = src.defaultSelected;\r\n\r\n      // IE6-8 fails to set the defaultValue to the correct value when\r\n      // cloning other types of input fields\r\n    } else if (nodeName === \"input\" || nodeName === \"textarea\") {\r\n      dest.defaultValue = src.defaultValue;\r\n    }\r\n  }\r\n\r\n  jQuery.each({\r\n    appendTo: \"append\",\r\n    prependTo: \"prepend\",\r\n    insertBefore: \"before\",\r\n    insertAfter: \"after\",\r\n    replaceAll: \"replaceWith\"\r\n  }, function (name, original) {\r\n    jQuery.fn[name] = function (selector) {\r\n      var elems,\r\n        i = 0,\r\n        ret = [],\r\n        insert = jQuery(selector),\r\n        last = insert.length - 1;\r\n\r\n      for (; i <= last; i++) {\r\n        elems = i === last ? this : this.clone(true);\r\n        jQuery(insert[i])[original](elems);\r\n\r\n        // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()\r\n        core_push.apply(ret, elems.get());\r\n      }\r\n\r\n      return this.pushStack(ret);\r\n    };\r\n  });\r\n\r\n  function getAll(context, tag) {\r\n    var elems, elem,\r\n      i = 0,\r\n      found = typeof context.getElementsByTagName !== core_strundefined ? context.getElementsByTagName(tag || \"*\") :\r\n        typeof context.querySelectorAll !== core_strundefined ? context.querySelectorAll(tag || \"*\") :\r\n          undefined;\r\n\r\n    if (!found) {\r\n      for (found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++) {\r\n        if (!tag || jQuery.nodeName(elem, tag)) {\r\n          found.push(elem);\r\n        } else {\r\n          jQuery.merge(found, getAll(elem, tag));\r\n        }\r\n      }\r\n    }\r\n\r\n    return tag === undefined || tag && jQuery.nodeName(context, tag) ?\r\n      jQuery.merge([context], found) :\r\n      found;\r\n  }\r\n\r\n  // Used in buildFragment, fixes the defaultChecked property\r\n  function fixDefaultChecked(elem) {\r\n    if (manipulation_rcheckableType.test(elem.type)) {\r\n      elem.defaultChecked = elem.checked;\r\n    }\r\n  }\r\n\r\n  jQuery.extend({\r\n    clone: function (elem, dataAndEvents, deepDataAndEvents) {\r\n      var destElements, node, clone, i, srcElements,\r\n        inPage = jQuery.contains(elem.ownerDocument, elem);\r\n\r\n      if (jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test(\"<\" + elem.nodeName + \">\")) {\r\n        clone = elem.cloneNode(true);\r\n\r\n        // IE<=8 does not properly clone detached, unknown element nodes\r\n      } else {\r\n        fragmentDiv.innerHTML = elem.outerHTML;\r\n        fragmentDiv.removeChild(clone = fragmentDiv.firstChild);\r\n      }\r\n\r\n      if ((!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&\r\n        (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {\r\n\r\n        // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2\r\n        destElements = getAll(clone);\r\n        srcElements = getAll(elem);\r\n\r\n        // Fix all IE cloning issues\r\n        for (i = 0; (node = srcElements[i]) != null; ++i) {\r\n          // Ensure that the destination node is not null; Fixes #9587\r\n          if (destElements[i]) {\r\n            fixCloneNodeIssues(node, destElements[i]);\r\n          }\r\n        }\r\n      }\r\n\r\n      // Copy the events from the original to the clone\r\n      if (dataAndEvents) {\r\n        if (deepDataAndEvents) {\r\n          srcElements = srcElements || getAll(elem);\r\n          destElements = destElements || getAll(clone);\r\n\r\n          for (i = 0; (node = srcElements[i]) != null; i++) {\r\n            cloneCopyEvent(node, destElements[i]);\r\n          }\r\n        } else {\r\n          cloneCopyEvent(elem, clone);\r\n        }\r\n      }\r\n\r\n      // Preserve script evaluation history\r\n      destElements = getAll(clone, \"script\");\r\n      if (destElements.length > 0) {\r\n        setGlobalEval(destElements, !inPage && getAll(elem, \"script\"));\r\n      }\r\n\r\n      destElements = srcElements = node = null;\r\n\r\n      // Return the cloned set\r\n      return clone;\r\n    },\r\n\r\n    buildFragment: function (elems, context, scripts, selection) {\r\n      var j, elem, contains,\r\n        tmp, tag, tbody, wrap,\r\n        l = elems.length,\r\n\r\n        // Ensure a safe fragment\r\n        safe = createSafeFragment(context),\r\n\r\n        nodes = [],\r\n        i = 0;\r\n\r\n      for (; i < l; i++) {\r\n        elem = elems[i];\r\n\r\n        if (elem || elem === 0) {\r\n\r\n          // Add nodes directly\r\n          if (jQuery.type(elem) === \"object\") {\r\n            jQuery.merge(nodes, elem.nodeType ? [elem] : elem);\r\n\r\n            // Convert non-html into a text node\r\n          } else if (!rhtml.test(elem)) {\r\n            nodes.push(context.createTextNode(elem));\r\n\r\n            // Convert html into DOM nodes\r\n          } else {\r\n            tmp = tmp || safe.appendChild(context.createElement(\"div\"));\r\n\r\n            // Deserialize a standard representation\r\n            tag = (rtagName.exec(elem) || [\"\", \"\"])[1].toLowerCase();\r\n            wrap = wrapMap[tag] || wrapMap._default;\r\n\r\n            tmp.innerHTML = wrap[1] + elem.replace(rxhtmlTag, \"<$1></$2>\") + wrap[2];\r\n\r\n            // Descend through wrappers to the right content\r\n            j = wrap[0];\r\n            while (j--) {\r\n              tmp = tmp.lastChild;\r\n            }\r\n\r\n            // Manually add leading whitespace removed by IE\r\n            if (!jQuery.support.leadingWhitespace && rleadingWhitespace.test(elem)) {\r\n              nodes.push(context.createTextNode(rleadingWhitespace.exec(elem)[0]));\r\n            }\r\n\r\n            // Remove IE's autoinserted <tbody> from table fragments\r\n            if (!jQuery.support.tbody) {\r\n\r\n              // String was a <table>, *may* have spurious <tbody>\r\n              elem = tag === \"table\" && !rtbody.test(elem) ?\r\n                tmp.firstChild :\r\n\r\n                // String was a bare <thead> or <tfoot>\r\n                wrap[1] === \"<table>\" && !rtbody.test(elem) ?\r\n                  tmp :\r\n                  0;\r\n\r\n              j = elem && elem.childNodes.length;\r\n              while (j--) {\r\n                if (jQuery.nodeName((tbody = elem.childNodes[j]), \"tbody\") && !tbody.childNodes.length) {\r\n                  elem.removeChild(tbody);\r\n                }\r\n              }\r\n            }\r\n\r\n            jQuery.merge(nodes, tmp.childNodes);\r\n\r\n            // Fix #12392 for WebKit and IE > 9\r\n            tmp.textContent = \"\";\r\n\r\n            // Fix #12392 for oldIE\r\n            while (tmp.firstChild) {\r\n              tmp.removeChild(tmp.firstChild);\r\n            }\r\n\r\n            // Remember the top-level container for proper cleanup\r\n            tmp = safe.lastChild;\r\n          }\r\n        }\r\n      }\r\n\r\n      // Fix #11356: Clear elements from fragment\r\n      if (tmp) {\r\n        safe.removeChild(tmp);\r\n      }\r\n\r\n      // Reset defaultChecked for any radios and checkboxes\r\n      // about to be appended to the DOM in IE 6/7 (#8060)\r\n      if (!jQuery.support.appendChecked) {\r\n        jQuery.grep(getAll(nodes, \"input\"), fixDefaultChecked);\r\n      }\r\n\r\n      i = 0;\r\n      while ((elem = nodes[i++])) {\r\n\r\n        // #4087 - If origin and destination elements are the same, and this is\r\n        // that element, do not do anything\r\n        if (selection && jQuery.inArray(elem, selection) !== -1) {\r\n          continue;\r\n        }\r\n\r\n        contains = jQuery.contains(elem.ownerDocument, elem);\r\n\r\n        // Append to fragment\r\n        tmp = getAll(safe.appendChild(elem), \"script\");\r\n\r\n        // Preserve script evaluation history\r\n        if (contains) {\r\n          setGlobalEval(tmp);\r\n        }\r\n\r\n        // Capture executables\r\n        if (scripts) {\r\n          j = 0;\r\n          while ((elem = tmp[j++])) {\r\n            if (rscriptType.test(elem.type || \"\")) {\r\n              scripts.push(elem);\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      tmp = null;\r\n\r\n      return safe;\r\n    },\r\n\r\n    cleanData: function (elems, /* internal */ acceptData) {\r\n      var elem, type, id, data,\r\n        i = 0,\r\n        internalKey = jQuery.expando,\r\n        cache = jQuery.cache,\r\n        deleteExpando = jQuery.support.deleteExpando,\r\n        special = jQuery.event.special;\r\n\r\n      for (; (elem = elems[i]) != null; i++) {\r\n\r\n        if (acceptData || jQuery.acceptData(elem)) {\r\n\r\n          id = elem[internalKey];\r\n          data = id && cache[id];\r\n\r\n          if (data) {\r\n            if (data.events) {\r\n              for (type in data.events) {\r\n                if (special[type]) {\r\n                  jQuery.event.remove(elem, type);\r\n\r\n                  // This is a shortcut to avoid jQuery.event.remove's overhead\r\n                } else {\r\n                  jQuery.removeEvent(elem, type, data.handle);\r\n                }\r\n              }\r\n            }\r\n\r\n            // Remove cache only if it was not already removed by jQuery.event.remove\r\n            if (cache[id]) {\r\n\r\n              delete cache[id];\r\n\r\n              // IE does not allow us to delete expando properties from nodes,\r\n              // nor does it have a removeAttribute function on Document nodes;\r\n              // we must handle all of these cases\r\n              if (deleteExpando) {\r\n                delete elem[internalKey];\r\n\r\n              } else if (typeof elem.removeAttribute !== core_strundefined) {\r\n                elem.removeAttribute(internalKey);\r\n\r\n              } else {\r\n                elem[internalKey] = null;\r\n              }\r\n\r\n              core_deletedIds.push(id);\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  });\r\n  var iframe, getStyles, curCSS,\r\n    ralpha = /alpha\\([^)]*\\)/i,\r\n    ropacity = /opacity\\s*=\\s*([^)]*)/,\r\n    rposition = /^(top|right|bottom|left)$/,\r\n    // swappable if display is none or starts with table except \"table\", \"table-cell\", or \"table-caption\"\r\n    // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\r\n    rdisplayswap = /^(none|table(?!-c[ea]).+)/,\r\n    rmargin = /^margin/,\r\n    rnumsplit = new RegExp(\"^(\" + core_pnum + \")(.*)$\", \"i\"),\r\n    rnumnonpx = new RegExp(\"^(\" + core_pnum + \")(?!px)[a-z%]+$\", \"i\"),\r\n    rrelNum = new RegExp(\"^([+-])=(\" + core_pnum + \")\", \"i\"),\r\n    elemdisplay = { BODY: \"block\" },\r\n\r\n    cssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\r\n    cssNormalTransform = {\r\n      letterSpacing: 0,\r\n      fontWeight: 400\r\n    },\r\n\r\n    cssExpand = [\"Top\", \"Right\", \"Bottom\", \"Left\"],\r\n    cssPrefixes = [\"Webkit\", \"O\", \"Moz\", \"ms\"];\r\n\r\n  // return a css property mapped to a potentially vendor prefixed property\r\n  function vendorPropName(style, name) {\r\n\r\n    // shortcut for names that are not vendor prefixed\r\n    if (name in style) {\r\n      return name;\r\n    }\r\n\r\n    // check for vendor prefixed names\r\n    var capName = name.charAt(0).toUpperCase() + name.slice(1),\r\n      origName = name,\r\n      i = cssPrefixes.length;\r\n\r\n    while (i--) {\r\n      name = cssPrefixes[i] + capName;\r\n      if (name in style) {\r\n        return name;\r\n      }\r\n    }\r\n\r\n    return origName;\r\n  }\r\n\r\n  function isHidden(elem, el) {\r\n    // isHidden might be called from jQuery#filter function;\r\n    // in that case, element will be second argument\r\n    elem = el || elem;\r\n    return jQuery.css(elem, \"display\") === \"none\" || !jQuery.contains(elem.ownerDocument, elem);\r\n  }\r\n\r\n  function showHide(elements, show) {\r\n    var display, elem, hidden,\r\n      values = [],\r\n      index = 0,\r\n      length = elements.length;\r\n\r\n    for (; index < length; index++) {\r\n      elem = elements[index];\r\n      if (!elem.style) {\r\n        continue;\r\n      }\r\n\r\n      values[index] = jQuery._data(elem, \"olddisplay\");\r\n      display = elem.style.display;\r\n      if (show) {\r\n        // Reset the inline display of this element to learn if it is\r\n        // being hidden by cascaded rules or not\r\n        if (!values[index] && display === \"none\") {\r\n          elem.style.display = \"\";\r\n        }\r\n\r\n        // Set elements which have been overridden with display: none\r\n        // in a stylesheet to whatever the default browser style is\r\n        // for such an element\r\n        if (elem.style.display === \"\" && isHidden(elem)) {\r\n          values[index] = jQuery._data(elem, \"olddisplay\", css_defaultDisplay(elem.nodeName));\r\n        }\r\n      } else {\r\n\r\n        if (!values[index]) {\r\n          hidden = isHidden(elem);\r\n\r\n          if (display && display !== \"none\" || !hidden) {\r\n            jQuery._data(elem, \"olddisplay\", hidden ? display : jQuery.css(elem, \"display\"));\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // Set the display of most of the elements in a second loop\r\n    // to avoid the constant reflow\r\n    for (index = 0; index < length; index++) {\r\n      elem = elements[index];\r\n      if (!elem.style) {\r\n        continue;\r\n      }\r\n      if (!show || elem.style.display === \"none\" || elem.style.display === \"\") {\r\n        elem.style.display = show ? values[index] || \"\" : \"none\";\r\n      }\r\n    }\r\n\r\n    return elements;\r\n  }\r\n\r\n  jQuery.fn.extend({\r\n    css: function (name, value) {\r\n      return jQuery.access(this, function (elem, name, value) {\r\n        var len, styles,\r\n          map = {},\r\n          i = 0;\r\n\r\n        if (jQuery.isArray(name)) {\r\n          styles = getStyles(elem);\r\n          len = name.length;\r\n\r\n          for (; i < len; i++) {\r\n            map[name[i]] = jQuery.css(elem, name[i], false, styles);\r\n          }\r\n\r\n          return map;\r\n        }\r\n\r\n        return value !== undefined ?\r\n          jQuery.style(elem, name, value) :\r\n          jQuery.css(elem, name);\r\n      }, name, value, arguments.length > 1);\r\n    },\r\n    show: function () {\r\n      return showHide(this, true);\r\n    },\r\n    hide: function () {\r\n      return showHide(this);\r\n    },\r\n    toggle: function (state) {\r\n      var bool = typeof state === \"boolean\";\r\n\r\n      return this.each(function () {\r\n        if (bool ? state : isHidden(this)) {\r\n          jQuery(this).show();\r\n        } else {\r\n          jQuery(this).hide();\r\n        }\r\n      });\r\n    }\r\n  });\r\n\r\n  jQuery.extend({\r\n    // Add in style property hooks for overriding the default\r\n    // behavior of getting and setting a style property\r\n    cssHooks: {\r\n      opacity: {\r\n        get: function (elem, computed) {\r\n          if (computed) {\r\n            // We should always get a number back from opacity\r\n            var ret = curCSS(elem, \"opacity\");\r\n            return ret === \"\" ? \"1\" : ret;\r\n          }\r\n        }\r\n      }\r\n    },\r\n\r\n    // Exclude the following css properties to add px\r\n    cssNumber: {\r\n      \"columnCount\": true,\r\n      \"fillOpacity\": true,\r\n      \"fontWeight\": true,\r\n      \"lineHeight\": true,\r\n      \"opacity\": true,\r\n      \"orphans\": true,\r\n      \"widows\": true,\r\n      \"zIndex\": true,\r\n      \"zoom\": true\r\n    },\r\n\r\n    // Add in properties whose names you wish to fix before\r\n    // setting or getting the value\r\n    cssProps: {\r\n      // normalize float css property\r\n      \"float\": jQuery.support.cssFloat ? \"cssFloat\" : \"styleFloat\"\r\n    },\r\n\r\n    // Get and set the style property on a DOM Node\r\n    style: function (elem, name, value, extra) {\r\n      // Don't set styles on text and comment nodes\r\n      if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {\r\n        return;\r\n      }\r\n\r\n      // Make sure that we're working with the right name\r\n      var ret, type, hooks,\r\n        origName = jQuery.camelCase(name),\r\n        style = elem.style;\r\n\r\n      name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(style, origName));\r\n\r\n      // gets hook for the prefixed version\r\n      // followed by the unprefixed version\r\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];\r\n\r\n      // Check if we're setting a value\r\n      if (value !== undefined) {\r\n        type = typeof value;\r\n\r\n        // convert relative number strings (+= or -=) to relative numbers. #7345\r\n        if (type === \"string\" && (ret = rrelNum.exec(value))) {\r\n          value = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name));\r\n          // Fixes bug #9237\r\n          type = \"number\";\r\n        }\r\n\r\n        // Make sure that NaN and null values aren't set. See: #7116\r\n        if (value == null || type === \"number\" && isNaN(value)) {\r\n          return;\r\n        }\r\n\r\n        // If a number was passed in, add 'px' to the (except for certain CSS properties)\r\n        if (type === \"number\" && !jQuery.cssNumber[origName]) {\r\n          value += \"px\";\r\n        }\r\n\r\n        // Fixes #8908, it can be done more correctly by specifing setters in cssHooks,\r\n        // but it would mean to define eight (for every problematic property) identical functions\r\n        if (!jQuery.support.clearCloneStyle && value === \"\" && name.indexOf(\"background\") === 0) {\r\n          style[name] = \"inherit\";\r\n        }\r\n\r\n        // If a hook was provided, use that value, otherwise just set the specified value\r\n        if (!hooks || !(\"set\" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {\r\n\r\n          // Wrapped to prevent IE from throwing errors when 'invalid' values are provided\r\n          // Fixes bug #5509\r\n          try {\r\n            style[name] = value;\r\n          } catch (e) { }\r\n        }\r\n\r\n      } else {\r\n        // If a hook was provided get the non-computed value from there\r\n        if (hooks && \"get\" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {\r\n          return ret;\r\n        }\r\n\r\n        // Otherwise just get the value from the style object\r\n        return style[name];\r\n      }\r\n    },\r\n\r\n    css: function (elem, name, extra, styles) {\r\n      var num, val, hooks,\r\n        origName = jQuery.camelCase(name);\r\n\r\n      // Make sure that we're working with the right name\r\n      name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(elem.style, origName));\r\n\r\n      // gets hook for the prefixed version\r\n      // followed by the unprefixed version\r\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];\r\n\r\n      // If a hook was provided get the computed value from there\r\n      if (hooks && \"get\" in hooks) {\r\n        val = hooks.get(elem, true, extra);\r\n      }\r\n\r\n      // Otherwise, if a way to get the computed value exists, use that\r\n      if (val === undefined) {\r\n        val = curCSS(elem, name, styles);\r\n      }\r\n\r\n      //convert \"normal\" to computed value\r\n      if (val === \"normal\" && name in cssNormalTransform) {\r\n        val = cssNormalTransform[name];\r\n      }\r\n\r\n      // Return, converting to number if forced or a qualifier was provided and val looks numeric\r\n      if (extra === \"\" || extra) {\r\n        num = parseFloat(val);\r\n        return extra === true || jQuery.isNumeric(num) ? num || 0 : val;\r\n      }\r\n      return val;\r\n    },\r\n\r\n    // A method for quickly swapping in/out CSS properties to get correct calculations\r\n    swap: function (elem, options, callback, args) {\r\n      var ret, name,\r\n        old = {};\r\n\r\n      // Remember the old values, and insert the new ones\r\n      for (name in options) {\r\n        old[name] = elem.style[name];\r\n        elem.style[name] = options[name];\r\n      }\r\n\r\n      ret = callback.apply(elem, args || []);\r\n\r\n      // Revert the old values\r\n      for (name in options) {\r\n        elem.style[name] = old[name];\r\n      }\r\n\r\n      return ret;\r\n    }\r\n  });\r\n\r\n  // NOTE: we've included the \"window\" in window.getComputedStyle\r\n  // because jsdom on node.js will break without it.\r\n  if (window.getComputedStyle) {\r\n    getStyles = function (elem) {\r\n      return window.getComputedStyle(elem, null);\r\n    };\r\n\r\n    curCSS = function (elem, name, _computed) {\r\n      var width, minWidth, maxWidth,\r\n        computed = _computed || getStyles(elem),\r\n\r\n        // getPropertyValue is only needed for .css('filter') in IE9, see #12537\r\n        ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined,\r\n        style = elem.style;\r\n\r\n      if (computed) {\r\n\r\n        if (ret === \"\" && !jQuery.contains(elem.ownerDocument, elem)) {\r\n          ret = jQuery.style(elem, name);\r\n        }\r\n\r\n        // A tribute to the \"awesome hack by Dean Edwards\"\r\n        // Chrome < 17 and Safari 5.0 uses \"computed value\" instead of \"used value\" for margin-right\r\n        // Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels\r\n        // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values\r\n        if (rnumnonpx.test(ret) && rmargin.test(name)) {\r\n\r\n          // Remember the original values\r\n          width = style.width;\r\n          minWidth = style.minWidth;\r\n          maxWidth = style.maxWidth;\r\n\r\n          // Put in the new values to get a computed value out\r\n          style.minWidth = style.maxWidth = style.width = ret;\r\n          ret = computed.width;\r\n\r\n          // Revert the changed values\r\n          style.width = width;\r\n          style.minWidth = minWidth;\r\n          style.maxWidth = maxWidth;\r\n        }\r\n      }\r\n\r\n      return ret;\r\n    };\r\n  } else if (document.documentElement.currentStyle) {\r\n    getStyles = function (elem) {\r\n      return elem.currentStyle;\r\n    };\r\n\r\n    curCSS = function (elem, name, _computed) {\r\n      var left, rs, rsLeft,\r\n        computed = _computed || getStyles(elem),\r\n        ret = computed ? computed[name] : undefined,\r\n        style = elem.style;\r\n\r\n      // Avoid setting ret to empty string here\r\n      // so we don't default to auto\r\n      if (ret == null && style && style[name]) {\r\n        ret = style[name];\r\n      }\r\n\r\n      // From the awesome hack by Dean Edwards\r\n      // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291\r\n\r\n      // If we're not dealing with a regular pixel number\r\n      // but a number that has a weird ending, we need to convert it to pixels\r\n      // but not position css attributes, as those are proportional to the parent element instead\r\n      // and we can't measure the parent instead because it might trigger a \"stacking dolls\" problem\r\n      if (rnumnonpx.test(ret) && !rposition.test(name)) {\r\n\r\n        // Remember the original values\r\n        left = style.left;\r\n        rs = elem.runtimeStyle;\r\n        rsLeft = rs && rs.left;\r\n\r\n        // Put in the new values to get a computed value out\r\n        if (rsLeft) {\r\n          rs.left = elem.currentStyle.left;\r\n        }\r\n        style.left = name === \"fontSize\" ? \"1em\" : ret;\r\n        ret = style.pixelLeft + \"px\";\r\n\r\n        // Revert the changed values\r\n        style.left = left;\r\n        if (rsLeft) {\r\n          rs.left = rsLeft;\r\n        }\r\n      }\r\n\r\n      return ret === \"\" ? \"auto\" : ret;\r\n    };\r\n  }\r\n\r\n  function setPositiveNumber(elem, value, subtract) {\r\n    var matches = rnumsplit.exec(value);\r\n    return matches ?\r\n      // Guard against undefined \"subtract\", e.g., when used as in cssHooks\r\n      Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || \"px\") :\r\n      value;\r\n  }\r\n\r\n  function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {\r\n    var i = extra === (isBorderBox ? \"border\" : \"content\") ?\r\n      // If we already have the right measurement, avoid augmentation\r\n      4 :\r\n      // Otherwise initialize for horizontal or vertical properties\r\n      name === \"width\" ? 1 : 0,\r\n\r\n      val = 0;\r\n\r\n    for (; i < 4; i += 2) {\r\n      // both box models exclude margin, so add it if we want it\r\n      if (extra === \"margin\") {\r\n        val += jQuery.css(elem, extra + cssExpand[i], true, styles);\r\n      }\r\n\r\n      if (isBorderBox) {\r\n        // border-box includes padding, so remove it if we want content\r\n        if (extra === \"content\") {\r\n          val -= jQuery.css(elem, \"padding\" + cssExpand[i], true, styles);\r\n        }\r\n\r\n        // at this point, extra isn't border nor margin, so remove border\r\n        if (extra !== \"margin\") {\r\n          val -= jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\r\n        }\r\n      } else {\r\n        // at this point, extra isn't content, so add padding\r\n        val += jQuery.css(elem, \"padding\" + cssExpand[i], true, styles);\r\n\r\n        // at this point, extra isn't content nor padding, so add border\r\n        if (extra !== \"padding\") {\r\n          val += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\r\n        }\r\n      }\r\n    }\r\n\r\n    return val;\r\n  }\r\n\r\n  function getWidthOrHeight(elem, name, extra) {\r\n\r\n    // Start with offset property, which is equivalent to the border-box value\r\n    var valueIsBorderBox = true,\r\n      val = name === \"width\" ? elem.offsetWidth : elem.offsetHeight,\r\n      styles = getStyles(elem),\r\n      isBorderBox = jQuery.support.boxSizing && jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\";\r\n\r\n    // some non-html elements return undefined for offsetWidth, so check for null/undefined\r\n    // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285\r\n    // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668\r\n    if (val <= 0 || val == null) {\r\n      // Fall back to computed then uncomputed css if necessary\r\n      val = curCSS(elem, name, styles);\r\n      if (val < 0 || val == null) {\r\n        val = elem.style[name];\r\n      }\r\n\r\n      // Computed unit is not pixels. Stop here and return.\r\n      if (rnumnonpx.test(val)) {\r\n        return val;\r\n      }\r\n\r\n      // we need the check for style in case a browser which returns unreliable values\r\n      // for getComputedStyle silently falls back to the reliable elem.style\r\n      valueIsBorderBox = isBorderBox && (jQuery.support.boxSizingReliable || val === elem.style[name]);\r\n\r\n      // Normalize \"\", auto, and prepare for extra\r\n      val = parseFloat(val) || 0;\r\n    }\r\n\r\n    // use the active box-sizing model to add/subtract irrelevant styles\r\n    return (val +\r\n      augmentWidthOrHeight(\r\n        elem,\r\n        name,\r\n        extra || (isBorderBox ? \"border\" : \"content\"),\r\n        valueIsBorderBox,\r\n        styles\r\n      )\r\n    ) + \"px\";\r\n  }\r\n\r\n  // Try to determine the default display value of an element\r\n  function css_defaultDisplay(nodeName) {\r\n    var doc = document,\r\n      display = elemdisplay[nodeName];\r\n\r\n    if (!display) {\r\n      display = actualDisplay(nodeName, doc);\r\n\r\n      // If the simple way fails, read from inside an iframe\r\n      if (display === \"none\" || !display) {\r\n        // Use the already-created iframe if possible\r\n        iframe = (iframe ||\r\n          jQuery(\"<iframe frameborder='0' width='0' height='0'/>\")\r\n            .css(\"cssText\", \"display:block !important\")\r\n        ).appendTo(doc.documentElement);\r\n\r\n        // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse\r\n        doc = (iframe[0].contentWindow || iframe[0].contentDocument).document;\r\n        doc.write(\"<!doctype html><html><body>\");\r\n        doc.close();\r\n\r\n        display = actualDisplay(nodeName, doc);\r\n        iframe.detach();\r\n      }\r\n\r\n      // Store the correct default display\r\n      elemdisplay[nodeName] = display;\r\n    }\r\n\r\n    return display;\r\n  }\r\n\r\n  // Called ONLY from within css_defaultDisplay\r\n  function actualDisplay(name, doc) {\r\n    var elem = jQuery(doc.createElement(name)).appendTo(doc.body),\r\n      display = jQuery.css(elem[0], \"display\");\r\n    elem.remove();\r\n    return display;\r\n  }\r\n\r\n  jQuery.each([\"height\", \"width\"], function (i, name) {\r\n    jQuery.cssHooks[name] = {\r\n      get: function (elem, computed, extra) {\r\n        if (computed) {\r\n          // certain elements can have dimension info if we invisibly show them\r\n          // however, it must have a current display style that would benefit from this\r\n          return elem.offsetWidth === 0 && rdisplayswap.test(jQuery.css(elem, \"display\")) ?\r\n            jQuery.swap(elem, cssShow, function () {\r\n              return getWidthOrHeight(elem, name, extra);\r\n            }) :\r\n            getWidthOrHeight(elem, name, extra);\r\n        }\r\n      },\r\n\r\n      set: function (elem, value, extra) {\r\n        var styles = extra && getStyles(elem);\r\n        return setPositiveNumber(elem, value, extra ?\r\n          augmentWidthOrHeight(\r\n            elem,\r\n            name,\r\n            extra,\r\n            jQuery.support.boxSizing && jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\r\n            styles\r\n          ) : 0\r\n        );\r\n      }\r\n    };\r\n  });\r\n\r\n  if (!jQuery.support.opacity) {\r\n    jQuery.cssHooks.opacity = {\r\n      get: function (elem, computed) {\r\n        // IE uses filters for opacity\r\n        return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || \"\") ?\r\n          (0.01 * parseFloat(RegExp.$1)) + \"\" :\r\n          computed ? \"1\" : \"\";\r\n      },\r\n\r\n      set: function (elem, value) {\r\n        var style = elem.style,\r\n          currentStyle = elem.currentStyle,\r\n          opacity = jQuery.isNumeric(value) ? \"alpha(opacity=\" + value * 100 + \")\" : \"\",\r\n          filter = currentStyle && currentStyle.filter || style.filter || \"\";\r\n\r\n        // IE has trouble with opacity if it does not have layout\r\n        // Force it by setting the zoom level\r\n        style.zoom = 1;\r\n\r\n        // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652\r\n        // if value === \"\", then remove inline opacity #12685\r\n        if ((value >= 1 || value === \"\") &&\r\n          jQuery.trim(filter.replace(ralpha, \"\")) === \"\" &&\r\n          style.removeAttribute) {\r\n\r\n          // Setting style.filter to null, \"\" & \" \" still leave \"filter:\" in the cssText\r\n          // if \"filter:\" is present at all, clearType is disabled, we want to avoid this\r\n          // style.removeAttribute is IE Only, but so apparently is this code path...\r\n          style.removeAttribute(\"filter\");\r\n\r\n          // if there is no filter style applied in a css rule or unset inline opacity, we are done\r\n          if (value === \"\" || currentStyle && !currentStyle.filter) {\r\n            return;\r\n          }\r\n        }\r\n\r\n        // otherwise, set new filter values\r\n        style.filter = ralpha.test(filter) ?\r\n          filter.replace(ralpha, opacity) :\r\n          filter + \" \" + opacity;\r\n      }\r\n    };\r\n  }\r\n\r\n  // These hooks cannot be added until DOM ready because the support test\r\n  // for it is not run until after DOM ready\r\n  jQuery(function () {\r\n    if (!jQuery.support.reliableMarginRight) {\r\n      jQuery.cssHooks.marginRight = {\r\n        get: function (elem, computed) {\r\n          if (computed) {\r\n            // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right\r\n            // Work around by temporarily setting element display to inline-block\r\n            return jQuery.swap(elem, { \"display\": \"inline-block\" },\r\n              curCSS, [elem, \"marginRight\"]);\r\n          }\r\n        }\r\n      };\r\n    }\r\n\r\n    // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\r\n    // getComputedStyle returns percent when specified for top/left/bottom/right\r\n    // rather than make the css module depend on the offset module, we just check for it here\r\n    if (!jQuery.support.pixelPosition && jQuery.fn.position) {\r\n      jQuery.each([\"top\", \"left\"], function (i, prop) {\r\n        jQuery.cssHooks[prop] = {\r\n          get: function (elem, computed) {\r\n            if (computed) {\r\n              computed = curCSS(elem, prop);\r\n              // if curCSS returns percentage, fallback to offset\r\n              return rnumnonpx.test(computed) ?\r\n                jQuery(elem).position()[prop] + \"px\" :\r\n                computed;\r\n            }\r\n          }\r\n        };\r\n      });\r\n    }\r\n\r\n  });\r\n\r\n  if (jQuery.expr && jQuery.expr.filters) {\r\n    jQuery.expr.filters.hidden = function (elem) {\r\n      // Support: Opera <= 12.12\r\n      // Opera reports offsetWidths and offsetHeights less than zero on some elements\r\n      return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||\r\n        (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css(elem, \"display\")) === \"none\");\r\n    };\r\n\r\n    jQuery.expr.filters.visible = function (elem) {\r\n      return !jQuery.expr.filters.hidden(elem);\r\n    };\r\n  }\r\n\r\n  // These hooks are used by animate to expand properties\r\n  jQuery.each({\r\n    margin: \"\",\r\n    padding: \"\",\r\n    border: \"Width\"\r\n  }, function (prefix, suffix) {\r\n    jQuery.cssHooks[prefix + suffix] = {\r\n      expand: function (value) {\r\n        var i = 0,\r\n          expanded = {},\r\n\r\n          // assumes a single number if not a string\r\n          parts = typeof value === \"string\" ? value.split(\" \") : [value];\r\n\r\n        for (; i < 4; i++) {\r\n          expanded[prefix + cssExpand[i] + suffix] =\r\n            parts[i] || parts[i - 2] || parts[0];\r\n        }\r\n\r\n        return expanded;\r\n      }\r\n    };\r\n\r\n    if (!rmargin.test(prefix)) {\r\n      jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;\r\n    }\r\n  });\r\n  var r20 = /%20/g,\r\n    rbracket = /\\[\\]$/,\r\n    rCRLF = /\\r?\\n/g,\r\n    rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\r\n    rsubmittable = /^(?:input|select|textarea|keygen)/i;\r\n\r\n  jQuery.fn.extend({\r\n    serialize: function () {\r\n      return jQuery.param(this.serializeArray());\r\n    },\r\n    serializeArray: function () {\r\n      return this.map(function () {\r\n        // Can add propHook for \"elements\" to filter or add form elements\r\n        var elements = jQuery.prop(this, \"elements\");\r\n        return elements ? jQuery.makeArray(elements) : this;\r\n      })\r\n        .filter(function () {\r\n          var type = this.type;\r\n          // Use .is(\":disabled\") so that fieldset[disabled] works\r\n          return this.name && !jQuery(this).is(\":disabled\") &&\r\n            rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) &&\r\n            (this.checked || !manipulation_rcheckableType.test(type));\r\n        })\r\n        .map(function (i, elem) {\r\n          var val = jQuery(this).val();\r\n\r\n          return val == null ?\r\n            null :\r\n            jQuery.isArray(val) ?\r\n              jQuery.map(val, function (val) {\r\n                return { name: elem.name, value: val.replace(rCRLF, \"\\r\\n\") };\r\n              }) :\r\n              { name: elem.name, value: val.replace(rCRLF, \"\\r\\n\") };\r\n        }).get();\r\n    }\r\n  });\r\n\r\n  //Serialize an array of form elements or a set of\r\n  //key/values into a query string\r\n  jQuery.param = function (a, traditional) {\r\n    var prefix,\r\n      s = [],\r\n      add = function (key, value) {\r\n        // If value is a function, invoke it and return its value\r\n        value = jQuery.isFunction(value) ? value() : (value == null ? \"\" : value);\r\n        s[s.length] = encodeURIComponent(key) + \"=\" + encodeURIComponent(value);\r\n      };\r\n\r\n    // Set traditional to true for jQuery <= 1.3.2 behavior.\r\n    if (traditional === undefined) {\r\n      traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;\r\n    }\r\n\r\n    // If an array was passed in, assume that it is an array of form elements.\r\n    if (jQuery.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) {\r\n      // Serialize the form elements\r\n      jQuery.each(a, function () {\r\n        add(this.name, this.value);\r\n      });\r\n\r\n    } else {\r\n      // If traditional, encode the \"old\" way (the way 1.3.2 or older\r\n      // did it), otherwise encode params recursively.\r\n      for (prefix in a) {\r\n        buildParams(prefix, a[prefix], traditional, add);\r\n      }\r\n    }\r\n\r\n    // Return the resulting serialization\r\n    return s.join(\"&\").replace(r20, \"+\");\r\n  };\r\n\r\n  function buildParams(prefix, obj, traditional, add) {\r\n    var name;\r\n\r\n    if (jQuery.isArray(obj)) {\r\n      // Serialize array item.\r\n      jQuery.each(obj, function (i, v) {\r\n        if (traditional || rbracket.test(prefix)) {\r\n          // Treat each array item as a scalar.\r\n          add(prefix, v);\r\n\r\n        } else {\r\n          // Item is non-scalar (array or object), encode its numeric index.\r\n          buildParams(prefix + \"[\" + (typeof v === \"object\" ? i : \"\") + \"]\", v, traditional, add);\r\n        }\r\n      });\r\n\r\n    } else if (!traditional && jQuery.type(obj) === \"object\") {\r\n      // Serialize object item.\r\n      for (name in obj) {\r\n        buildParams(prefix + \"[\" + name + \"]\", obj[name], traditional, add);\r\n      }\r\n\r\n    } else {\r\n      // Serialize scalar item.\r\n      add(prefix, obj);\r\n    }\r\n  }\r\n  jQuery.each((\"blur focus focusin focusout load resize scroll unload click dblclick \" +\r\n    \"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\r\n    \"change select submit keydown keypress keyup error contextmenu\").split(\" \"), function (i, name) {\r\n\r\n      // Handle event binding\r\n      jQuery.fn[name] = function (data, fn) {\r\n        return arguments.length > 0 ?\r\n          this.on(name, null, data, fn) :\r\n          this.trigger(name);\r\n      };\r\n    });\r\n\r\n  jQuery.fn.hover = function (fnOver, fnOut) {\r\n    return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);\r\n  };\r\n  var\r\n    // Document location\r\n    ajaxLocParts,\r\n    ajaxLocation,\r\n    ajax_nonce = jQuery.now(),\r\n\r\n    ajax_rquery = /\\?/,\r\n    rhash = /#.*$/,\r\n    rts = /([?&])_=[^&]*/,\r\n    rheaders = /^(.*?):[ \\t]*([^\\r\\n]*)\\r?$/mg, // IE leaves an \\r character at EOL\r\n    // #7653, #8125, #8152: local protocol detection\r\n    rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\r\n    rnoContent = /^(?:GET|HEAD)$/,\r\n    rprotocol = /^\\/\\//,\r\n    rurl = /^([\\w.+-]+:)(?:\\/\\/([^\\/?#:]*)(?::(\\d+)|)|)/,\r\n\r\n    // Keep a copy of the old load method\r\n    _load = jQuery.fn.load,\r\n\r\n    /* Prefilters\r\n     * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\r\n     * 2) These are called:\r\n     *    - BEFORE asking for a transport\r\n     *    - AFTER param serialization (s.data is a string if s.processData is true)\r\n     * 3) key is the dataType\r\n     * 4) the catchall symbol \"*\" can be used\r\n     * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\r\n     */\r\n    prefilters = {},\r\n\r\n    /* Transports bindings\r\n     * 1) key is the dataType\r\n     * 2) the catchall symbol \"*\" can be used\r\n     * 3) selection will start with transport dataType and THEN go to \"*\" if needed\r\n     */\r\n    transports = {},\r\n\r\n    // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\r\n    allTypes = \"*/\".concat(\"*\");\r\n\r\n  // #8138, IE may throw an exception when accessing\r\n  // a field from window.location if document.domain has been set\r\n  try {\r\n    ajaxLocation = location.href;\r\n  } catch (e) {\r\n    // Use the href attribute of an A element\r\n    // since IE will modify it given document.location\r\n    ajaxLocation = document.createElement(\"a\");\r\n    ajaxLocation.href = \"\";\r\n    ajaxLocation = ajaxLocation.href;\r\n  }\r\n\r\n  // Segment location into parts\r\n  ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];\r\n\r\n  // Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\r\n  function addToPrefiltersOrTransports(structure) {\r\n\r\n    // dataTypeExpression is optional and defaults to \"*\"\r\n    return function (dataTypeExpression, func) {\r\n\r\n      if (typeof dataTypeExpression !== \"string\") {\r\n        func = dataTypeExpression;\r\n        dataTypeExpression = \"*\";\r\n      }\r\n\r\n      var dataType,\r\n        i = 0,\r\n        dataTypes = dataTypeExpression.toLowerCase().match(core_rnotwhite) || [];\r\n\r\n      if (jQuery.isFunction(func)) {\r\n        // For each dataType in the dataTypeExpression\r\n        while ((dataType = dataTypes[i++])) {\r\n          // Prepend if requested\r\n          if (dataType[0] === \"+\") {\r\n            dataType = dataType.slice(1) || \"*\";\r\n            (structure[dataType] = structure[dataType] || []).unshift(func);\r\n\r\n            // Otherwise append\r\n          } else {\r\n            (structure[dataType] = structure[dataType] || []).push(func);\r\n          }\r\n        }\r\n      }\r\n    };\r\n  }\r\n\r\n  // Base inspection function for prefilters and transports\r\n  function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {\r\n\r\n    var inspected = {},\r\n      seekingTransport = (structure === transports);\r\n\r\n    function inspect(dataType) {\r\n      var selected;\r\n      inspected[dataType] = true;\r\n      jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {\r\n        var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);\r\n        if (typeof dataTypeOrTransport === \"string\" && !seekingTransport && !inspected[dataTypeOrTransport]) {\r\n          options.dataTypes.unshift(dataTypeOrTransport);\r\n          inspect(dataTypeOrTransport);\r\n          return false;\r\n        } else if (seekingTransport) {\r\n          return !(selected = dataTypeOrTransport);\r\n        }\r\n      });\r\n      return selected;\r\n    }\r\n\r\n    return inspect(options.dataTypes[0]) || !inspected[\"*\"] && inspect(\"*\");\r\n  }\r\n\r\n  // A special extend for ajax options\r\n  // that takes \"flat\" options (not to be deep extended)\r\n  // Fixes #9887\r\n  function ajaxExtend(target, src) {\r\n    var deep, key,\r\n      flatOptions = jQuery.ajaxSettings.flatOptions || {};\r\n\r\n    for (key in src) {\r\n      if (src[key] !== undefined) {\r\n        (flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key];\r\n      }\r\n    }\r\n    if (deep) {\r\n      jQuery.extend(true, target, deep);\r\n    }\r\n\r\n    return target;\r\n  }\r\n\r\n  jQuery.fn.load = function (url, params, callback) {\r\n    if (typeof url !== \"string\" && _load) {\r\n      return _load.apply(this, arguments);\r\n    }\r\n\r\n    var selector, response, type,\r\n      self = this,\r\n      off = url.indexOf(\" \");\r\n\r\n    if (off >= 0) {\r\n      selector = url.slice(off, url.length);\r\n      url = url.slice(0, off);\r\n    }\r\n\r\n    // If it's a function\r\n    if (jQuery.isFunction(params)) {\r\n\r\n      // We assume that it's the callback\r\n      callback = params;\r\n      params = undefined;\r\n\r\n      // Otherwise, build a param string\r\n    } else if (params && typeof params === \"object\") {\r\n      type = \"POST\";\r\n    }\r\n\r\n    // If we have elements to modify, make the request\r\n    if (self.length > 0) {\r\n      jQuery.ajax({\r\n        url: url,\r\n\r\n        // if \"type\" variable is undefined, then \"GET\" method will be used\r\n        type: type,\r\n        dataType: \"html\",\r\n        data: params\r\n      }).done(function (responseText) {\r\n\r\n        // Save response for use in complete callback\r\n        response = arguments;\r\n\r\n        self.html(selector ?\r\n\r\n          // If a selector was specified, locate the right elements in a dummy div\r\n          // Exclude scripts to avoid IE 'Permission Denied' errors\r\n          jQuery(\"<div>\").append(jQuery.parseHTML(responseText)).find(selector) :\r\n\r\n          // Otherwise use the full result\r\n          responseText);\r\n\r\n      }).complete(callback && function (jqXHR, status) {\r\n        self.each(callback, response || [jqXHR.responseText, status, jqXHR]);\r\n      });\r\n    }\r\n\r\n    return this;\r\n  };\r\n\r\n  // Attach a bunch of functions for handling common AJAX events\r\n  jQuery.each([\"ajaxStart\", \"ajaxStop\", \"ajaxComplete\", \"ajaxError\", \"ajaxSuccess\", \"ajaxSend\"], function (i, type) {\r\n    jQuery.fn[type] = function (fn) {\r\n      return this.on(type, fn);\r\n    };\r\n  });\r\n\r\n  jQuery.each([\"get\", \"post\"], function (i, method) {\r\n    jQuery[method] = function (url, data, callback, type) {\r\n      // shift arguments if data argument was omitted\r\n      if (jQuery.isFunction(data)) {\r\n        type = type || callback;\r\n        callback = data;\r\n        data = undefined;\r\n      }\r\n\r\n      return jQuery.ajax({\r\n        url: url,\r\n        type: method,\r\n        dataType: type,\r\n        data: data,\r\n        success: callback\r\n      });\r\n    };\r\n  });\r\n\r\n  jQuery.extend({\r\n\r\n    // Counter for holding the number of active queries\r\n    active: 0,\r\n\r\n    // Last-Modified header cache for next request\r\n    lastModified: {},\r\n    etag: {},\r\n\r\n    ajaxSettings: {\r\n      url: ajaxLocation,\r\n      type: \"GET\",\r\n      isLocal: rlocalProtocol.test(ajaxLocParts[1]),\r\n      global: true,\r\n      processData: true,\r\n      async: true,\r\n      contentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\r\n      /*\r\n      timeout: 0,\r\n      data: null,\r\n      dataType: null,\r\n      username: null,\r\n      password: null,\r\n      cache: null,\r\n      throws: false,\r\n      traditional: false,\r\n      headers: {},\r\n      */\r\n\r\n      accepts: {\r\n        \"*\": allTypes,\r\n        text: \"text/plain\",\r\n        html: \"text/html\",\r\n        xml: \"application/xml, text/xml\",\r\n        json: \"application/json, text/javascript\"\r\n      },\r\n\r\n      contents: {\r\n        xml: /xml/,\r\n        html: /html/,\r\n        json: /json/\r\n      },\r\n\r\n      responseFields: {\r\n        xml: \"responseXML\",\r\n        text: \"responseText\"\r\n      },\r\n\r\n      // Data converters\r\n      // Keys separate source (or catchall \"*\") and destination types with a single space\r\n      converters: {\r\n\r\n        // Convert anything to text\r\n        \"* text\": window.String,\r\n\r\n        // Text to html (true = no transformation)\r\n        \"text html\": true,\r\n\r\n        // Evaluate text as a json expression\r\n        \"text json\": jQuery.parseJSON,\r\n\r\n        // Parse text as xml\r\n        \"text xml\": jQuery.parseXML\r\n      },\r\n\r\n      // For options that shouldn't be deep extended:\r\n      // you can add your own custom options here if\r\n      // and when you create one that shouldn't be\r\n      // deep extended (see ajaxExtend)\r\n      flatOptions: {\r\n        url: true,\r\n        context: true\r\n      }\r\n    },\r\n\r\n    // Creates a full fledged settings object into target\r\n    // with both ajaxSettings and settings fields.\r\n    // If target is omitted, writes into ajaxSettings.\r\n    ajaxSetup: function (target, settings) {\r\n      return settings ?\r\n\r\n        // Building a settings object\r\n        ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) :\r\n\r\n        // Extending ajaxSettings\r\n        ajaxExtend(jQuery.ajaxSettings, target);\r\n    },\r\n\r\n    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),\r\n    ajaxTransport: addToPrefiltersOrTransports(transports),\r\n\r\n    // Main method\r\n    ajax: function (url, options) {\r\n\r\n      // If url is an object, simulate pre-1.5 signature\r\n      if (typeof url === \"object\") {\r\n        options = url;\r\n        url = undefined;\r\n      }\r\n\r\n      // Force options to be an object\r\n      options = options || {};\r\n\r\n      var // Cross-domain detection vars\r\n        parts,\r\n        // Loop variable\r\n        i,\r\n        // URL without anti-cache param\r\n        cacheURL,\r\n        // Response headers as string\r\n        responseHeadersString,\r\n        // timeout handle\r\n        timeoutTimer,\r\n\r\n        // To know if global events are to be dispatched\r\n        fireGlobals,\r\n\r\n        transport,\r\n        // Response headers\r\n        responseHeaders,\r\n        // Create the final options object\r\n        s = jQuery.ajaxSetup({}, options),\r\n        // Callbacks context\r\n        callbackContext = s.context || s,\r\n        // Context for global events is callbackContext if it is a DOM node or jQuery collection\r\n        globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ?\r\n          jQuery(callbackContext) :\r\n          jQuery.event,\r\n        // Deferreds\r\n        deferred = jQuery.Deferred(),\r\n        completeDeferred = jQuery.Callbacks(\"once memory\"),\r\n        // Status-dependent callbacks\r\n        statusCode = s.statusCode || {},\r\n        // Headers (they are sent all at once)\r\n        requestHeaders = {},\r\n        requestHeadersNames = {},\r\n        // The jqXHR state\r\n        state = 0,\r\n        // Default abort message\r\n        strAbort = \"canceled\",\r\n        // Fake xhr\r\n        jqXHR = {\r\n          readyState: 0,\r\n\r\n          // Builds headers hashtable if needed\r\n          getResponseHeader: function (key) {\r\n            var match;\r\n            if (state === 2) {\r\n              if (!responseHeaders) {\r\n                responseHeaders = {};\r\n                while ((match = rheaders.exec(responseHeadersString))) {\r\n                  responseHeaders[match[1].toLowerCase()] = match[2];\r\n                }\r\n              }\r\n              match = responseHeaders[key.toLowerCase()];\r\n            }\r\n            return match == null ? null : match;\r\n          },\r\n\r\n          // Raw string\r\n          getAllResponseHeaders: function () {\r\n            return state === 2 ? responseHeadersString : null;\r\n          },\r\n\r\n          // Caches the header\r\n          setRequestHeader: function (name, value) {\r\n            var lname = name.toLowerCase();\r\n            if (!state) {\r\n              name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;\r\n              requestHeaders[name] = value;\r\n            }\r\n            return this;\r\n          },\r\n\r\n          // Overrides response content-type header\r\n          overrideMimeType: function (type) {\r\n            if (!state) {\r\n              s.mimeType = type;\r\n            }\r\n            return this;\r\n          },\r\n\r\n          // Status-dependent callbacks\r\n          statusCode: function (map) {\r\n            var code;\r\n            if (map) {\r\n              if (state < 2) {\r\n                for (code in map) {\r\n                  // Lazy-add the new callback in a way that preserves old ones\r\n                  statusCode[code] = [statusCode[code], map[code]];\r\n                }\r\n              } else {\r\n                // Execute the appropriate callbacks\r\n                jqXHR.always(map[jqXHR.status]);\r\n              }\r\n            }\r\n            return this;\r\n          },\r\n\r\n          // Cancel the request\r\n          abort: function (statusText) {\r\n            var finalText = statusText || strAbort;\r\n            if (transport) {\r\n              transport.abort(finalText);\r\n            }\r\n            done(0, finalText);\r\n            return this;\r\n          }\r\n        };\r\n\r\n      // Attach deferreds\r\n      deferred.promise(jqXHR).complete = completeDeferred.add;\r\n      jqXHR.success = jqXHR.done;\r\n      jqXHR.error = jqXHR.fail;\r\n\r\n      // Remove hash character (#7531: and string promotion)\r\n      // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)\r\n      // Handle falsy url in the settings object (#10093: consistency with old signature)\r\n      // We also use the url parameter if available\r\n      s.url = ((url || s.url || ajaxLocation) + \"\").replace(rhash, \"\").replace(rprotocol, ajaxLocParts[1] + \"//\");\r\n\r\n      // Alias method option to type as per ticket #12004\r\n      s.type = options.method || options.type || s.method || s.type;\r\n\r\n      // Extract dataTypes list\r\n      s.dataTypes = jQuery.trim(s.dataType || \"*\").toLowerCase().match(core_rnotwhite) || [\"\"];\r\n\r\n      // A cross-domain request is in order when we have a protocol:host:port mismatch\r\n      if (s.crossDomain == null) {\r\n        parts = rurl.exec(s.url.toLowerCase());\r\n        s.crossDomain = !!(parts &&\r\n          (parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2] ||\r\n            (parts[3] || (parts[1] === \"http:\" ? 80 : 443)) !=\r\n            (ajaxLocParts[3] || (ajaxLocParts[1] === \"http:\" ? 80 : 443)))\r\n        );\r\n      }\r\n\r\n      // Convert data if not already a string\r\n      if (s.data && s.processData && typeof s.data !== \"string\") {\r\n        s.data = jQuery.param(s.data, s.traditional);\r\n      }\r\n\r\n      // Apply prefilters\r\n      inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);\r\n\r\n      // If request was aborted inside a prefilter, stop there\r\n      if (state === 2) {\r\n        return jqXHR;\r\n      }\r\n\r\n      // We can fire global events as of now if asked to\r\n      fireGlobals = s.global;\r\n\r\n      // Watch for a new set of requests\r\n      if (fireGlobals && jQuery.active++ === 0) {\r\n        jQuery.event.trigger(\"ajaxStart\");\r\n      }\r\n\r\n      // Uppercase the type\r\n      s.type = s.type.toUpperCase();\r\n\r\n      // Determine if request has content\r\n      s.hasContent = !rnoContent.test(s.type);\r\n\r\n      // Save the URL in case we're toying with the If-Modified-Since\r\n      // and/or If-None-Match header later on\r\n      cacheURL = s.url;\r\n\r\n      // More options handling for requests with no content\r\n      if (!s.hasContent) {\r\n\r\n        // If data is available, append data to url\r\n        if (s.data) {\r\n          cacheURL = (s.url += (ajax_rquery.test(cacheURL) ? \"&\" : \"?\") + s.data);\r\n          // #9682: remove data so that it's not used in an eventual retry\r\n          delete s.data;\r\n        }\r\n\r\n        // Add anti-cache in url if needed\r\n        if (s.cache === false) {\r\n          s.url = rts.test(cacheURL) ?\r\n\r\n            // If there is already a '_' parameter, set its value\r\n            cacheURL.replace(rts, \"$1_=\" + ajax_nonce++) :\r\n\r\n            // Otherwise add one to the end\r\n            cacheURL + (ajax_rquery.test(cacheURL) ? \"&\" : \"?\") + \"_=\" + ajax_nonce++;\r\n        }\r\n      }\r\n\r\n      // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\r\n      if (s.ifModified) {\r\n        if (jQuery.lastModified[cacheURL]) {\r\n          jqXHR.setRequestHeader(\"If-Modified-Since\", jQuery.lastModified[cacheURL]);\r\n        }\r\n        if (jQuery.etag[cacheURL]) {\r\n          jqXHR.setRequestHeader(\"If-None-Match\", jQuery.etag[cacheURL]);\r\n        }\r\n      }\r\n\r\n      // Set the correct header, if data is being sent\r\n      if (s.data && s.hasContent && s.contentType !== false || options.contentType) {\r\n        jqXHR.setRequestHeader(\"Content-Type\", s.contentType);\r\n      }\r\n\r\n      // Set the Accepts header for the server, depending on the dataType\r\n      jqXHR.setRequestHeader(\r\n        \"Accept\",\r\n        s.dataTypes[0] && s.accepts[s.dataTypes[0]] ?\r\n          s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\") :\r\n          s.accepts[\"*\"]\r\n      );\r\n\r\n      // Check for headers option\r\n      for (i in s.headers) {\r\n        jqXHR.setRequestHeader(i, s.headers[i]);\r\n      }\r\n\r\n      // Allow custom headers/mimetypes and early abort\r\n      if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {\r\n        // Abort if not done already and return\r\n        return jqXHR.abort();\r\n      }\r\n\r\n      // aborting is no longer a cancellation\r\n      strAbort = \"abort\";\r\n\r\n      // Install callbacks on deferreds\r\n      for (i in { success: 1, error: 1, complete: 1 }) {\r\n        jqXHR[i](s[i]);\r\n      }\r\n\r\n      // Get transport\r\n      transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);\r\n\r\n      // If no transport, we auto-abort\r\n      if (!transport) {\r\n        done(-1, \"No Transport\");\r\n      } else {\r\n        jqXHR.readyState = 1;\r\n\r\n        // Send global event\r\n        if (fireGlobals) {\r\n          globalEventContext.trigger(\"ajaxSend\", [jqXHR, s]);\r\n        }\r\n        // Timeout\r\n        if (s.async && s.timeout > 0) {\r\n          timeoutTimer = setTimeout(function () {\r\n            jqXHR.abort(\"timeout\");\r\n          }, s.timeout);\r\n        }\r\n\r\n        try {\r\n          state = 1;\r\n          transport.send(requestHeaders, done);\r\n        } catch (e) {\r\n          // Propagate exception as error if not done\r\n          if (state < 2) {\r\n            done(-1, e);\r\n            // Simply rethrow otherwise\r\n          } else {\r\n            throw e;\r\n          }\r\n        }\r\n      }\r\n\r\n      // Callback for when everything is done\r\n      function done(status, nativeStatusText, responses, headers) {\r\n        var isSuccess, success, error, response, modified,\r\n          statusText = nativeStatusText;\r\n\r\n        // Called once\r\n        if (state === 2) {\r\n          return;\r\n        }\r\n\r\n        // State is \"done\" now\r\n        state = 2;\r\n\r\n        // Clear timeout if it exists\r\n        if (timeoutTimer) {\r\n          clearTimeout(timeoutTimer);\r\n        }\r\n\r\n        // Dereference transport for early garbage collection\r\n        // (no matter how long the jqXHR object will be used)\r\n        transport = undefined;\r\n\r\n        // Cache response headers\r\n        responseHeadersString = headers || \"\";\r\n\r\n        // Set readyState\r\n        jqXHR.readyState = status > 0 ? 4 : 0;\r\n\r\n        // Get response data\r\n        if (responses) {\r\n          response = ajaxHandleResponses(s, jqXHR, responses);\r\n        }\r\n\r\n        // If successful, handle type chaining\r\n        if (status >= 200 && status < 300 || status === 304) {\r\n\r\n          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\r\n          if (s.ifModified) {\r\n            modified = jqXHR.getResponseHeader(\"Last-Modified\");\r\n            if (modified) {\r\n              jQuery.lastModified[cacheURL] = modified;\r\n            }\r\n            modified = jqXHR.getResponseHeader(\"etag\");\r\n            if (modified) {\r\n              jQuery.etag[cacheURL] = modified;\r\n            }\r\n          }\r\n\r\n          // if no content\r\n          if (status === 204) {\r\n            isSuccess = true;\r\n            statusText = \"nocontent\";\r\n\r\n            // if not modified\r\n          } else if (status === 304) {\r\n            isSuccess = true;\r\n            statusText = \"notmodified\";\r\n\r\n            // If we have data, let's convert it\r\n          } else {\r\n            isSuccess = ajaxConvert(s, response);\r\n            statusText = isSuccess.state;\r\n            success = isSuccess.data;\r\n            error = isSuccess.error;\r\n            isSuccess = !error;\r\n          }\r\n        } else {\r\n          // We extract error from statusText\r\n          // then normalize statusText and status for non-aborts\r\n          error = statusText;\r\n          if (status || !statusText) {\r\n            statusText = \"error\";\r\n            if (status < 0) {\r\n              status = 0;\r\n            }\r\n          }\r\n        }\r\n\r\n        // Set data for the fake xhr object\r\n        jqXHR.status = status;\r\n        jqXHR.statusText = (nativeStatusText || statusText) + \"\";\r\n\r\n        // Success/Error\r\n        if (isSuccess) {\r\n          deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);\r\n        } else {\r\n          deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);\r\n        }\r\n\r\n        // Status-dependent callbacks\r\n        jqXHR.statusCode(statusCode);\r\n        statusCode = undefined;\r\n\r\n        if (fireGlobals) {\r\n          globalEventContext.trigger(isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\r\n            [jqXHR, s, isSuccess ? success : error]);\r\n        }\r\n\r\n        // Complete\r\n        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);\r\n\r\n        if (fireGlobals) {\r\n          globalEventContext.trigger(\"ajaxComplete\", [jqXHR, s]);\r\n          // Handle the global AJAX counter\r\n          if (!(--jQuery.active)) {\r\n            jQuery.event.trigger(\"ajaxStop\");\r\n          }\r\n        }\r\n      }\r\n\r\n      return jqXHR;\r\n    },\r\n\r\n    getScript: function (url, callback) {\r\n      return jQuery.get(url, undefined, callback, \"script\");\r\n    },\r\n\r\n    getJSON: function (url, data, callback) {\r\n      return jQuery.get(url, data, callback, \"json\");\r\n    }\r\n  });\r\n\r\n  /* Handles responses to an ajax request:\r\n   * - sets all responseXXX fields accordingly\r\n   * - finds the right dataType (mediates between content-type and expected dataType)\r\n   * - returns the corresponding response\r\n   */\r\n  function ajaxHandleResponses(s, jqXHR, responses) {\r\n    var firstDataType, ct, finalDataType, type,\r\n      contents = s.contents,\r\n      dataTypes = s.dataTypes,\r\n      responseFields = s.responseFields;\r\n\r\n    // Fill responseXXX fields\r\n    for (type in responseFields) {\r\n      if (type in responses) {\r\n        jqXHR[responseFields[type]] = responses[type];\r\n      }\r\n    }\r\n\r\n    // Remove auto dataType and get content-type in the process\r\n    while (dataTypes[0] === \"*\") {\r\n      dataTypes.shift();\r\n      if (ct === undefined) {\r\n        ct = s.mimeType || jqXHR.getResponseHeader(\"Content-Type\");\r\n      }\r\n    }\r\n\r\n    // Check if we're dealing with a known content-type\r\n    if (ct) {\r\n      for (type in contents) {\r\n        if (contents[type] && contents[type].test(ct)) {\r\n          dataTypes.unshift(type);\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Check to see if we have a response for the expected dataType\r\n    if (dataTypes[0] in responses) {\r\n      finalDataType = dataTypes[0];\r\n    } else {\r\n      // Try convertible dataTypes\r\n      for (type in responses) {\r\n        if (!dataTypes[0] || s.converters[type + \" \" + dataTypes[0]]) {\r\n          finalDataType = type;\r\n          break;\r\n        }\r\n        if (!firstDataType) {\r\n          firstDataType = type;\r\n        }\r\n      }\r\n      // Or just use first one\r\n      finalDataType = finalDataType || firstDataType;\r\n    }\r\n\r\n    // If we found a dataType\r\n    // We add the dataType to the list if needed\r\n    // and return the corresponding response\r\n    if (finalDataType) {\r\n      if (finalDataType !== dataTypes[0]) {\r\n        dataTypes.unshift(finalDataType);\r\n      }\r\n      return responses[finalDataType];\r\n    }\r\n  }\r\n\r\n  // Chain conversions given the request and the original response\r\n  function ajaxConvert(s, response) {\r\n    var conv2, current, conv, tmp,\r\n      converters = {},\r\n      i = 0,\r\n      // Work with a copy of dataTypes in case we need to modify it for conversion\r\n      dataTypes = s.dataTypes.slice(),\r\n      prev = dataTypes[0];\r\n\r\n    // Apply the dataFilter if provided\r\n    if (s.dataFilter) {\r\n      response = s.dataFilter(response, s.dataType);\r\n    }\r\n\r\n    // Create converters map with lowercased keys\r\n    if (dataTypes[1]) {\r\n      for (conv in s.converters) {\r\n        converters[conv.toLowerCase()] = s.converters[conv];\r\n      }\r\n    }\r\n\r\n    // Convert to each sequential dataType, tolerating list modification\r\n    for (; (current = dataTypes[++i]);) {\r\n\r\n      // There's only work to do if current dataType is non-auto\r\n      if (current !== \"*\") {\r\n\r\n        // Convert response if prev dataType is non-auto and differs from current\r\n        if (prev !== \"*\" && prev !== current) {\r\n\r\n          // Seek a direct converter\r\n          conv = converters[prev + \" \" + current] || converters[\"* \" + current];\r\n\r\n          // If none found, seek a pair\r\n          if (!conv) {\r\n            for (conv2 in converters) {\r\n\r\n              // If conv2 outputs current\r\n              tmp = conv2.split(\" \");\r\n              if (tmp[1] === current) {\r\n\r\n                // If prev can be converted to accepted input\r\n                conv = converters[prev + \" \" + tmp[0]] ||\r\n                  converters[\"* \" + tmp[0]];\r\n                if (conv) {\r\n                  // Condense equivalence converters\r\n                  if (conv === true) {\r\n                    conv = converters[conv2];\r\n\r\n                    // Otherwise, insert the intermediate dataType\r\n                  } else if (converters[conv2] !== true) {\r\n                    current = tmp[0];\r\n                    dataTypes.splice(i--, 0, current);\r\n                  }\r\n\r\n                  break;\r\n                }\r\n              }\r\n            }\r\n          }\r\n\r\n          // Apply converter (if not an equivalence)\r\n          if (conv !== true) {\r\n\r\n            // Unless errors are allowed to bubble, catch and return them\r\n            if (conv && s[\"throws\"]) {\r\n              response = conv(response);\r\n            } else {\r\n              try {\r\n                response = conv(response);\r\n              } catch (e) {\r\n                return { state: \"parsererror\", error: conv ? e : \"No conversion from \" + prev + \" to \" + current };\r\n              }\r\n            }\r\n          }\r\n        }\r\n\r\n        // Update prev for next iteration\r\n        prev = current;\r\n      }\r\n    }\r\n\r\n    return { state: \"success\", data: response };\r\n  }\r\n  // Install script dataType\r\n  jQuery.ajaxSetup({\r\n    accepts: {\r\n      script: \"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript\"\r\n    },\r\n    contents: {\r\n      script: /(?:java|ecma)script/\r\n    },\r\n    converters: {\r\n      \"text script\": function (text) {\r\n        jQuery.globalEval(text);\r\n        return text;\r\n      }\r\n    }\r\n  });\r\n\r\n  // Handle cache's special case and global\r\n  jQuery.ajaxPrefilter(\"script\", function (s) {\r\n    if (s.cache === undefined) {\r\n      s.cache = false;\r\n    }\r\n    if (s.crossDomain) {\r\n      s.type = \"GET\";\r\n      s.global = false;\r\n    }\r\n  });\r\n\r\n  // Bind script tag hack transport\r\n  jQuery.ajaxTransport(\"script\", function (s) {\r\n\r\n    // This transport only deals with cross domain requests\r\n    if (s.crossDomain) {\r\n\r\n      var script,\r\n        head = document.head || jQuery(\"head\")[0] || document.documentElement;\r\n\r\n      return {\r\n\r\n        send: function (_, callback) {\r\n\r\n          script = document.createElement(\"script\");\r\n\r\n          script.async = true;\r\n\r\n          if (s.scriptCharset) {\r\n            script.charset = s.scriptCharset;\r\n          }\r\n\r\n          script.src = s.url;\r\n\r\n          // Attach handlers for all browsers\r\n          script.onload = script.onreadystatechange = function (_, isAbort) {\r\n\r\n            if (isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) {\r\n\r\n              // Handle memory leak in IE\r\n              script.onload = script.onreadystatechange = null;\r\n\r\n              // Remove the script\r\n              if (script.parentNode) {\r\n                script.parentNode.removeChild(script);\r\n              }\r\n\r\n              // Dereference the script\r\n              script = null;\r\n\r\n              // Callback if not abort\r\n              if (!isAbort) {\r\n                callback(200, \"success\");\r\n              }\r\n            }\r\n          };\r\n\r\n          // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending\r\n          // Use native DOM manipulation to avoid our domManip AJAX trickery\r\n          head.insertBefore(script, head.firstChild);\r\n        },\r\n\r\n        abort: function () {\r\n          if (script) {\r\n            script.onload(undefined, true);\r\n          }\r\n        }\r\n      };\r\n    }\r\n  });\r\n  var oldCallbacks = [],\r\n    rjsonp = /(=)\\?(?=&|$)|\\?\\?/;\r\n\r\n  // Default jsonp settings\r\n  jQuery.ajaxSetup({\r\n    jsonp: \"callback\",\r\n    jsonpCallback: function () {\r\n      var callback = oldCallbacks.pop() || (jQuery.expando + \"_\" + (ajax_nonce++));\r\n      this[callback] = true;\r\n      return callback;\r\n    }\r\n  });\r\n\r\n  // Detect, normalize options and install callbacks for jsonp requests\r\n  jQuery.ajaxPrefilter(\"json jsonp\", function (s, originalSettings, jqXHR) {\r\n\r\n    var callbackName, overwritten, responseContainer,\r\n      jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ?\r\n        \"url\" :\r\n        typeof s.data === \"string\" && !(s.contentType || \"\").indexOf(\"application/x-www-form-urlencoded\") && rjsonp.test(s.data) && \"data\"\r\n      );\r\n\r\n    // Handle iff the expected data type is \"jsonp\" or we have a parameter to set\r\n    if (jsonProp || s.dataTypes[0] === \"jsonp\") {\r\n\r\n      // Get callback name, remembering preexisting value associated with it\r\n      callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ?\r\n        s.jsonpCallback() :\r\n        s.jsonpCallback;\r\n\r\n      // Insert callback into url or form data\r\n      if (jsonProp) {\r\n        s[jsonProp] = s[jsonProp].replace(rjsonp, \"$1\" + callbackName);\r\n      } else if (s.jsonp !== false) {\r\n        s.url += (ajax_rquery.test(s.url) ? \"&\" : \"?\") + s.jsonp + \"=\" + callbackName;\r\n      }\r\n\r\n      // Use data converter to retrieve json after script execution\r\n      s.converters[\"script json\"] = function () {\r\n        if (!responseContainer) {\r\n          jQuery.error(callbackName + \" was not called\");\r\n        }\r\n        return responseContainer[0];\r\n      };\r\n\r\n      // force json dataType\r\n      s.dataTypes[0] = \"json\";\r\n\r\n      // Install callback\r\n      overwritten = window[callbackName];\r\n      window[callbackName] = function () {\r\n        responseContainer = arguments;\r\n      };\r\n\r\n      // Clean-up function (fires after converters)\r\n      jqXHR.always(function () {\r\n        // Restore preexisting value\r\n        window[callbackName] = overwritten;\r\n\r\n        // Save back as free\r\n        if (s[callbackName]) {\r\n          // make sure that re-using the options doesn't screw things around\r\n          s.jsonpCallback = originalSettings.jsonpCallback;\r\n\r\n          // save the callback name for future use\r\n          oldCallbacks.push(callbackName);\r\n        }\r\n\r\n        // Call if it was a function and we have a response\r\n        if (responseContainer && jQuery.isFunction(overwritten)) {\r\n          overwritten(responseContainer[0]);\r\n        }\r\n\r\n        responseContainer = overwritten = undefined;\r\n      });\r\n\r\n      // Delegate to script\r\n      return \"script\";\r\n    }\r\n  });\r\n  var xhrCallbacks, xhrSupported,\r\n    xhrId = 0,\r\n    // #5280: Internet Explorer will keep connections alive if we don't abort on unload\r\n    xhrOnUnloadAbort = window.ActiveXObject && function () {\r\n      // Abort all pending requests\r\n      var key;\r\n      for (key in xhrCallbacks) {\r\n        xhrCallbacks[key](undefined, true);\r\n      }\r\n    };\r\n\r\n  // Functions to create xhrs\r\n  function createStandardXHR() {\r\n    try {\r\n      return new window.XMLHttpRequest();\r\n    } catch (e) { }\r\n  }\r\n\r\n  function createActiveXHR() {\r\n    try {\r\n      return new window.ActiveXObject(\"Microsoft.XMLHTTP\");\r\n    } catch (e) { }\r\n  }\r\n\r\n  // Create the request object\r\n  // (This is still attached to ajaxSettings for backward compatibility)\r\n  jQuery.ajaxSettings.xhr = window.ActiveXObject ?\r\n    /* Microsoft failed to properly\r\n     * implement the XMLHttpRequest in IE7 (can't request local files),\r\n     * so we use the ActiveXObject when it is available\r\n     * Additionally XMLHttpRequest can be disabled in IE7/IE8 so\r\n     * we need a fallback.\r\n     */\r\n    function () {\r\n      return !this.isLocal && createStandardXHR() || createActiveXHR();\r\n    } :\r\n    // For all other browsers, use the standard XMLHttpRequest object\r\n    createStandardXHR;\r\n\r\n  // Determine support properties\r\n  xhrSupported = jQuery.ajaxSettings.xhr();\r\n  jQuery.support.cors = !!xhrSupported && (\"withCredentials\" in xhrSupported);\r\n  xhrSupported = jQuery.support.ajax = !!xhrSupported;\r\n\r\n  // Create transport if the browser can provide an xhr\r\n  if (xhrSupported) {\r\n\r\n    jQuery.ajaxTransport(function (s) {\r\n      // Cross domain only allowed if supported through XMLHttpRequest\r\n      if (!s.crossDomain || jQuery.support.cors) {\r\n\r\n        var callback;\r\n\r\n        return {\r\n          send: function (headers, complete) {\r\n\r\n            // Get a new xhr\r\n            var handle, i,\r\n              xhr = s.xhr();\r\n\r\n            // Open the socket\r\n            // Passing null username, generates a login popup on Opera (#2865)\r\n            if (s.username) {\r\n              xhr.open(s.type, s.url, s.async, s.username, s.password);\r\n            } else {\r\n              xhr.open(s.type, s.url, s.async);\r\n            }\r\n\r\n            // Apply custom fields if provided\r\n            if (s.xhrFields) {\r\n              for (i in s.xhrFields) {\r\n                xhr[i] = s.xhrFields[i];\r\n              }\r\n            }\r\n\r\n            // Override mime type if needed\r\n            if (s.mimeType && xhr.overrideMimeType) {\r\n              xhr.overrideMimeType(s.mimeType);\r\n            }\r\n\r\n            // X-Requested-With header\r\n            // For cross-domain requests, seeing as conditions for a preflight are\r\n            // akin to a jigsaw puzzle, we simply never set it to be sure.\r\n            // (it can always be set on a per-request basis or even using ajaxSetup)\r\n            // For same-domain requests, won't change header if already provided.\r\n            if (!s.crossDomain && !headers[\"X-Requested-With\"]) {\r\n              headers[\"X-Requested-With\"] = \"XMLHttpRequest\";\r\n            }\r\n\r\n            // Need an extra try/catch for cross domain requests in Firefox 3\r\n            try {\r\n              for (i in headers) {\r\n                xhr.setRequestHeader(i, headers[i]);\r\n              }\r\n            } catch (err) { }\r\n\r\n            // Do send the request\r\n            // This may raise an exception which is actually\r\n            // handled in jQuery.ajax (so no try/catch here)\r\n            xhr.send((s.hasContent && s.data) || null);\r\n\r\n            // Listener\r\n            callback = function (_, isAbort) {\r\n              var status, responseHeaders, statusText, responses;\r\n\r\n              // Firefox throws exceptions when accessing properties\r\n              // of an xhr when a network error occurred\r\n              // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)\r\n              try {\r\n\r\n                // Was never called and is aborted or complete\r\n                if (callback && (isAbort || xhr.readyState === 4)) {\r\n\r\n                  // Only called once\r\n                  callback = undefined;\r\n\r\n                  // Do not keep as active anymore\r\n                  if (handle) {\r\n                    xhr.onreadystatechange = jQuery.noop;\r\n                    if (xhrOnUnloadAbort) {\r\n                      delete xhrCallbacks[handle];\r\n                    }\r\n                  }\r\n\r\n                  // If it's an abort\r\n                  if (isAbort) {\r\n                    // Abort it manually if needed\r\n                    if (xhr.readyState !== 4) {\r\n                      xhr.abort();\r\n                    }\r\n                  } else {\r\n                    responses = {};\r\n                    status = xhr.status;\r\n                    responseHeaders = xhr.getAllResponseHeaders();\r\n\r\n                    // When requesting binary data, IE6-9 will throw an exception\r\n                    // on any attempt to access responseText (#11426)\r\n                    if (typeof xhr.responseText === \"string\") {\r\n                      responses.text = xhr.responseText;\r\n                    }\r\n\r\n                    // Firefox throws an exception when accessing\r\n                    // statusText for faulty cross-domain requests\r\n                    try {\r\n                      statusText = xhr.statusText;\r\n                    } catch (e) {\r\n                      // We normalize with Webkit giving an empty statusText\r\n                      statusText = \"\";\r\n                    }\r\n\r\n                    // Filter status for non standard behaviors\r\n\r\n                    // If the request is local and we have data: assume a success\r\n                    // (success with no data won't get notified, that's the best we\r\n                    // can do given current implementations)\r\n                    if (!status && s.isLocal && !s.crossDomain) {\r\n                      status = responses.text ? 200 : 404;\r\n                      // IE - #1450: sometimes returns 1223 when it should be 204\r\n                    } else if (status === 1223) {\r\n                      status = 204;\r\n                    }\r\n                  }\r\n                }\r\n              } catch (firefoxAccessException) {\r\n                if (!isAbort) {\r\n                  complete(-1, firefoxAccessException);\r\n                }\r\n              }\r\n\r\n              // Call complete if needed\r\n              if (responses) {\r\n                complete(status, statusText, responses, responseHeaders);\r\n              }\r\n            };\r\n\r\n            if (!s.async) {\r\n              // if we're in sync mode we fire the callback\r\n              callback();\r\n            } else if (xhr.readyState === 4) {\r\n              // (IE6 & IE7) if it's in cache and has been\r\n              // retrieved directly we need to fire the callback\r\n              setTimeout(callback);\r\n            } else {\r\n              handle = ++xhrId;\r\n              if (xhrOnUnloadAbort) {\r\n                // Create the active xhrs callbacks list if needed\r\n                // and attach the unload handler\r\n                if (!xhrCallbacks) {\r\n                  xhrCallbacks = {};\r\n                  jQuery(window).unload(xhrOnUnloadAbort);\r\n                }\r\n                // Add to list of active xhrs callbacks\r\n                xhrCallbacks[handle] = callback;\r\n              }\r\n              xhr.onreadystatechange = callback;\r\n            }\r\n          },\r\n\r\n          abort: function () {\r\n            if (callback) {\r\n              callback(undefined, true);\r\n            }\r\n          }\r\n        };\r\n      }\r\n    });\r\n  }\r\n  var fxNow, timerId,\r\n    rfxtypes = /^(?:toggle|show|hide)$/,\r\n    rfxnum = new RegExp(\"^(?:([+-])=|)(\" + core_pnum + \")([a-z%]*)$\", \"i\"),\r\n    rrun = /queueHooks$/,\r\n    animationPrefilters = [defaultPrefilter],\r\n    tweeners = {\r\n      \"*\": [function (prop, value) {\r\n        var end, unit,\r\n          tween = this.createTween(prop, value),\r\n          parts = rfxnum.exec(value),\r\n          target = tween.cur(),\r\n          start = +target || 0,\r\n          scale = 1,\r\n          maxIterations = 20;\r\n\r\n        if (parts) {\r\n          end = +parts[2];\r\n          unit = parts[3] || (jQuery.cssNumber[prop] ? \"\" : \"px\");\r\n\r\n          // We need to compute starting value\r\n          if (unit !== \"px\" && start) {\r\n            // Iteratively approximate from a nonzero starting point\r\n            // Prefer the current property, because this process will be trivial if it uses the same units\r\n            // Fallback to end or a simple constant\r\n            start = jQuery.css(tween.elem, prop, true) || end || 1;\r\n\r\n            do {\r\n              // If previous iteration zeroed out, double until we get *something*\r\n              // Use a string for doubling factor so we don't accidentally see scale as unchanged below\r\n              scale = scale || \".5\";\r\n\r\n              // Adjust and apply\r\n              start = start / scale;\r\n              jQuery.style(tween.elem, prop, start + unit);\r\n\r\n              // Update scale, tolerating zero or NaN from tween.cur()\r\n              // And breaking the loop if scale is unchanged or perfect, or if we've just had enough\r\n            } while (scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations);\r\n          }\r\n\r\n          tween.unit = unit;\r\n          tween.start = start;\r\n          // If a +=/-= token was provided, we're doing a relative animation\r\n          tween.end = parts[1] ? start + (parts[1] + 1) * end : end;\r\n        }\r\n        return tween;\r\n      }]\r\n    };\r\n\r\n  // Animations created synchronously will run synchronously\r\n  function createFxNow() {\r\n    setTimeout(function () {\r\n      fxNow = undefined;\r\n    });\r\n    return (fxNow = jQuery.now());\r\n  }\r\n\r\n  function createTweens(animation, props) {\r\n    jQuery.each(props, function (prop, value) {\r\n      var collection = (tweeners[prop] || []).concat(tweeners[\"*\"]),\r\n        index = 0,\r\n        length = collection.length;\r\n      for (; index < length; index++) {\r\n        if (collection[index].call(animation, prop, value)) {\r\n\r\n          // we're done with this property\r\n          return;\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  function Animation(elem, properties, options) {\r\n    var result,\r\n      stopped,\r\n      index = 0,\r\n      length = animationPrefilters.length,\r\n      deferred = jQuery.Deferred().always(function () {\r\n        // don't match elem in the :animated selector\r\n        delete tick.elem;\r\n      }),\r\n      tick = function () {\r\n        if (stopped) {\r\n          return false;\r\n        }\r\n        var currentTime = fxNow || createFxNow(),\r\n          remaining = Math.max(0, animation.startTime + animation.duration - currentTime),\r\n          // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)\r\n          temp = remaining / animation.duration || 0,\r\n          percent = 1 - temp,\r\n          index = 0,\r\n          length = animation.tweens.length;\r\n\r\n        for (; index < length; index++) {\r\n          animation.tweens[index].run(percent);\r\n        }\r\n\r\n        deferred.notifyWith(elem, [animation, percent, remaining]);\r\n\r\n        if (percent < 1 && length) {\r\n          return remaining;\r\n        } else {\r\n          deferred.resolveWith(elem, [animation]);\r\n          return false;\r\n        }\r\n      },\r\n      animation = deferred.promise({\r\n        elem: elem,\r\n        props: jQuery.extend({}, properties),\r\n        opts: jQuery.extend(true, { specialEasing: {} }, options),\r\n        originalProperties: properties,\r\n        originalOptions: options,\r\n        startTime: fxNow || createFxNow(),\r\n        duration: options.duration,\r\n        tweens: [],\r\n        createTween: function (prop, end) {\r\n          var tween = jQuery.Tween(elem, animation.opts, prop, end,\r\n            animation.opts.specialEasing[prop] || animation.opts.easing);\r\n          animation.tweens.push(tween);\r\n          return tween;\r\n        },\r\n        stop: function (gotoEnd) {\r\n          var index = 0,\r\n            // if we are going to the end, we want to run all the tweens\r\n            // otherwise we skip this part\r\n            length = gotoEnd ? animation.tweens.length : 0;\r\n          if (stopped) {\r\n            return this;\r\n          }\r\n          stopped = true;\r\n          for (; index < length; index++) {\r\n            animation.tweens[index].run(1);\r\n          }\r\n\r\n          // resolve when we played the last frame\r\n          // otherwise, reject\r\n          if (gotoEnd) {\r\n            deferred.resolveWith(elem, [animation, gotoEnd]);\r\n          } else {\r\n            deferred.rejectWith(elem, [animation, gotoEnd]);\r\n          }\r\n          return this;\r\n        }\r\n      }),\r\n      props = animation.props;\r\n\r\n    propFilter(props, animation.opts.specialEasing);\r\n\r\n    for (; index < length; index++) {\r\n      result = animationPrefilters[index].call(animation, elem, props, animation.opts);\r\n      if (result) {\r\n        return result;\r\n      }\r\n    }\r\n\r\n    createTweens(animation, props);\r\n\r\n    if (jQuery.isFunction(animation.opts.start)) {\r\n      animation.opts.start.call(elem, animation);\r\n    }\r\n\r\n    jQuery.fx.timer(\r\n      jQuery.extend(tick, {\r\n        elem: elem,\r\n        anim: animation,\r\n        queue: animation.opts.queue\r\n      })\r\n    );\r\n\r\n    // attach callbacks from options\r\n    return animation.progress(animation.opts.progress)\r\n      .done(animation.opts.done, animation.opts.complete)\r\n      .fail(animation.opts.fail)\r\n      .always(animation.opts.always);\r\n  }\r\n\r\n  function propFilter(props, specialEasing) {\r\n    var value, name, index, easing, hooks;\r\n\r\n    // camelCase, specialEasing and expand cssHook pass\r\n    for (index in props) {\r\n      name = jQuery.camelCase(index);\r\n      easing = specialEasing[name];\r\n      value = props[index];\r\n      if (jQuery.isArray(value)) {\r\n        easing = value[1];\r\n        value = props[index] = value[0];\r\n      }\r\n\r\n      if (index !== name) {\r\n        props[name] = value;\r\n        delete props[index];\r\n      }\r\n\r\n      hooks = jQuery.cssHooks[name];\r\n      if (hooks && \"expand\" in hooks) {\r\n        value = hooks.expand(value);\r\n        delete props[name];\r\n\r\n        // not quite $.extend, this wont overwrite keys already present.\r\n        // also - reusing 'index' from above because we have the correct \"name\"\r\n        for (index in value) {\r\n          if (!(index in props)) {\r\n            props[index] = value[index];\r\n            specialEasing[index] = easing;\r\n          }\r\n        }\r\n      } else {\r\n        specialEasing[name] = easing;\r\n      }\r\n    }\r\n  }\r\n\r\n  jQuery.Animation = jQuery.extend(Animation, {\r\n\r\n    tweener: function (props, callback) {\r\n      if (jQuery.isFunction(props)) {\r\n        callback = props;\r\n        props = [\"*\"];\r\n      } else {\r\n        props = props.split(\" \");\r\n      }\r\n\r\n      var prop,\r\n        index = 0,\r\n        length = props.length;\r\n\r\n      for (; index < length; index++) {\r\n        prop = props[index];\r\n        tweeners[prop] = tweeners[prop] || [];\r\n        tweeners[prop].unshift(callback);\r\n      }\r\n    },\r\n\r\n    prefilter: function (callback, prepend) {\r\n      if (prepend) {\r\n        animationPrefilters.unshift(callback);\r\n      } else {\r\n        animationPrefilters.push(callback);\r\n      }\r\n    }\r\n  });\r\n\r\n  function defaultPrefilter(elem, props, opts) {\r\n    /*jshint validthis:true */\r\n    var prop, index, length,\r\n      value, dataShow, toggle,\r\n      tween, hooks, oldfire,\r\n      anim = this,\r\n      style = elem.style,\r\n      orig = {},\r\n      handled = [],\r\n      hidden = elem.nodeType && isHidden(elem);\r\n\r\n    // handle queue: false promises\r\n    if (!opts.queue) {\r\n      hooks = jQuery._queueHooks(elem, \"fx\");\r\n      if (hooks.unqueued == null) {\r\n        hooks.unqueued = 0;\r\n        oldfire = hooks.empty.fire;\r\n        hooks.empty.fire = function () {\r\n          if (!hooks.unqueued) {\r\n            oldfire();\r\n          }\r\n        };\r\n      }\r\n      hooks.unqueued++;\r\n\r\n      anim.always(function () {\r\n        // doing this makes sure that the complete handler will be called\r\n        // before this completes\r\n        anim.always(function () {\r\n          hooks.unqueued--;\r\n          if (!jQuery.queue(elem, \"fx\").length) {\r\n            hooks.empty.fire();\r\n          }\r\n        });\r\n      });\r\n    }\r\n\r\n    // height/width overflow pass\r\n    if (elem.nodeType === 1 && (\"height\" in props || \"width\" in props)) {\r\n      // Make sure that nothing sneaks out\r\n      // Record all 3 overflow attributes because IE does not\r\n      // change the overflow attribute when overflowX and\r\n      // overflowY are set to the same value\r\n      opts.overflow = [style.overflow, style.overflowX, style.overflowY];\r\n\r\n      // Set display property to inline-block for height/width\r\n      // animations on inline elements that are having width/height animated\r\n      if (jQuery.css(elem, \"display\") === \"inline\" &&\r\n        jQuery.css(elem, \"float\") === \"none\") {\r\n\r\n        // inline-level elements accept inline-block;\r\n        // block-level elements need to be inline with layout\r\n        if (!jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay(elem.nodeName) === \"inline\") {\r\n          style.display = \"inline-block\";\r\n\r\n        } else {\r\n          style.zoom = 1;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (opts.overflow) {\r\n      style.overflow = \"hidden\";\r\n      if (!jQuery.support.shrinkWrapBlocks) {\r\n        anim.always(function () {\r\n          style.overflow = opts.overflow[0];\r\n          style.overflowX = opts.overflow[1];\r\n          style.overflowY = opts.overflow[2];\r\n        });\r\n      }\r\n    }\r\n\r\n\r\n    // show/hide pass\r\n    for (index in props) {\r\n      value = props[index];\r\n      if (rfxtypes.exec(value)) {\r\n        delete props[index];\r\n        toggle = toggle || value === \"toggle\";\r\n        if (value === (hidden ? \"hide\" : \"show\")) {\r\n          continue;\r\n        }\r\n        handled.push(index);\r\n      }\r\n    }\r\n\r\n    length = handled.length;\r\n    if (length) {\r\n      dataShow = jQuery._data(elem, \"fxshow\") || jQuery._data(elem, \"fxshow\", {});\r\n      if (\"hidden\" in dataShow) {\r\n        hidden = dataShow.hidden;\r\n      }\r\n\r\n      // store state if its toggle - enables .stop().toggle() to \"reverse\"\r\n      if (toggle) {\r\n        dataShow.hidden = !hidden;\r\n      }\r\n      if (hidden) {\r\n        jQuery(elem).show();\r\n      } else {\r\n        anim.done(function () {\r\n          jQuery(elem).hide();\r\n        });\r\n      }\r\n      anim.done(function () {\r\n        var prop;\r\n        jQuery._removeData(elem, \"fxshow\");\r\n        for (prop in orig) {\r\n          jQuery.style(elem, prop, orig[prop]);\r\n        }\r\n      });\r\n      for (index = 0; index < length; index++) {\r\n        prop = handled[index];\r\n        tween = anim.createTween(prop, hidden ? dataShow[prop] : 0);\r\n        orig[prop] = dataShow[prop] || jQuery.style(elem, prop);\r\n\r\n        if (!(prop in dataShow)) {\r\n          dataShow[prop] = tween.start;\r\n          if (hidden) {\r\n            tween.end = tween.start;\r\n            tween.start = prop === \"width\" || prop === \"height\" ? 1 : 0;\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  function Tween(elem, options, prop, end, easing) {\r\n    return new Tween.prototype.init(elem, options, prop, end, easing);\r\n  }\r\n  jQuery.Tween = Tween;\r\n\r\n  Tween.prototype = {\r\n    constructor: Tween,\r\n    init: function (elem, options, prop, end, easing, unit) {\r\n      this.elem = elem;\r\n      this.prop = prop;\r\n      this.easing = easing || \"swing\";\r\n      this.options = options;\r\n      this.start = this.now = this.cur();\r\n      this.end = end;\r\n      this.unit = unit || (jQuery.cssNumber[prop] ? \"\" : \"px\");\r\n    },\r\n    cur: function () {\r\n      var hooks = Tween.propHooks[this.prop];\r\n\r\n      return hooks && hooks.get ?\r\n        hooks.get(this) :\r\n        Tween.propHooks._default.get(this);\r\n    },\r\n    run: function (percent) {\r\n      var eased,\r\n        hooks = Tween.propHooks[this.prop];\r\n\r\n      if (this.options.duration) {\r\n        this.pos = eased = jQuery.easing[this.easing](\r\n          percent, this.options.duration * percent, 0, 1, this.options.duration\r\n        );\r\n      } else {\r\n        this.pos = eased = percent;\r\n      }\r\n      this.now = (this.end - this.start) * eased + this.start;\r\n\r\n      if (this.options.step) {\r\n        this.options.step.call(this.elem, this.now, this);\r\n      }\r\n\r\n      if (hooks && hooks.set) {\r\n        hooks.set(this);\r\n      } else {\r\n        Tween.propHooks._default.set(this);\r\n      }\r\n      return this;\r\n    }\r\n  };\r\n\r\n  Tween.prototype.init.prototype = Tween.prototype;\r\n\r\n  Tween.propHooks = {\r\n    _default: {\r\n      get: function (tween) {\r\n        var result;\r\n\r\n        if (tween.elem[tween.prop] != null &&\r\n          (!tween.elem.style || tween.elem.style[tween.prop] == null)) {\r\n          return tween.elem[tween.prop];\r\n        }\r\n\r\n        // passing an empty string as a 3rd parameter to .css will automatically\r\n        // attempt a parseFloat and fallback to a string if the parse fails\r\n        // so, simple values such as \"10px\" are parsed to Float.\r\n        // complex values such as \"rotate(1rad)\" are returned as is.\r\n        result = jQuery.css(tween.elem, tween.prop, \"\");\r\n        // Empty strings, null, undefined and \"auto\" are converted to 0.\r\n        return !result || result === \"auto\" ? 0 : result;\r\n      },\r\n      set: function (tween) {\r\n        // use step hook for back compat - use cssHook if its there - use .style if its\r\n        // available and use plain properties where available\r\n        if (jQuery.fx.step[tween.prop]) {\r\n          jQuery.fx.step[tween.prop](tween);\r\n        } else if (tween.elem.style && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {\r\n          jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);\r\n        } else {\r\n          tween.elem[tween.prop] = tween.now;\r\n        }\r\n      }\r\n    }\r\n  };\r\n\r\n  // Remove in 2.0 - this supports IE8's panic based approach\r\n  // to setting things on disconnected nodes\r\n\r\n  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\r\n    set: function (tween) {\r\n      if (tween.elem.nodeType && tween.elem.parentNode) {\r\n        tween.elem[tween.prop] = tween.now;\r\n      }\r\n    }\r\n  };\r\n\r\n  jQuery.each([\"toggle\", \"show\", \"hide\"], function (i, name) {\r\n    var cssFn = jQuery.fn[name];\r\n    jQuery.fn[name] = function (speed, easing, callback) {\r\n      return speed == null || typeof speed === \"boolean\" ?\r\n        cssFn.apply(this, arguments) :\r\n        this.animate(genFx(name, true), speed, easing, callback);\r\n    };\r\n  });\r\n\r\n  jQuery.fn.extend({\r\n    fadeTo: function (speed, to, easing, callback) {\r\n\r\n      // show any hidden elements after setting opacity to 0\r\n      return this.filter(isHidden).css(\"opacity\", 0).show()\r\n\r\n        // animate to the value specified\r\n        .end().animate({ opacity: to }, speed, easing, callback);\r\n    },\r\n    animate: function (prop, speed, easing, callback) {\r\n      var empty = jQuery.isEmptyObject(prop),\r\n        optall = jQuery.speed(speed, easing, callback),\r\n        doAnimation = function () {\r\n          // Operate on a copy of prop so per-property easing won't be lost\r\n          var anim = Animation(this, jQuery.extend({}, prop), optall);\r\n          doAnimation.finish = function () {\r\n            anim.stop(true);\r\n          };\r\n          // Empty animations, or finishing resolves immediately\r\n          if (empty || jQuery._data(this, \"finish\")) {\r\n            anim.stop(true);\r\n          }\r\n        };\r\n      doAnimation.finish = doAnimation;\r\n\r\n      return empty || optall.queue === false ?\r\n        this.each(doAnimation) :\r\n        this.queue(optall.queue, doAnimation);\r\n    },\r\n    stop: function (type, clearQueue, gotoEnd) {\r\n      var stopQueue = function (hooks) {\r\n        var stop = hooks.stop;\r\n        delete hooks.stop;\r\n        stop(gotoEnd);\r\n      };\r\n\r\n      if (typeof type !== \"string\") {\r\n        gotoEnd = clearQueue;\r\n        clearQueue = type;\r\n        type = undefined;\r\n      }\r\n      if (clearQueue && type !== false) {\r\n        this.queue(type || \"fx\", []);\r\n      }\r\n\r\n      return this.each(function () {\r\n        var dequeue = true,\r\n          index = type != null && type + \"queueHooks\",\r\n          timers = jQuery.timers,\r\n          data = jQuery._data(this);\r\n\r\n        if (index) {\r\n          if (data[index] && data[index].stop) {\r\n            stopQueue(data[index]);\r\n          }\r\n        } else {\r\n          for (index in data) {\r\n            if (data[index] && data[index].stop && rrun.test(index)) {\r\n              stopQueue(data[index]);\r\n            }\r\n          }\r\n        }\r\n\r\n        for (index = timers.length; index--;) {\r\n          if (timers[index].elem === this && (type == null || timers[index].queue === type)) {\r\n            timers[index].anim.stop(gotoEnd);\r\n            dequeue = false;\r\n            timers.splice(index, 1);\r\n          }\r\n        }\r\n\r\n        // start the next in the queue if the last step wasn't forced\r\n        // timers currently will call their complete callbacks, which will dequeue\r\n        // but only if they were gotoEnd\r\n        if (dequeue || !gotoEnd) {\r\n          jQuery.dequeue(this, type);\r\n        }\r\n      });\r\n    },\r\n    finish: function (type) {\r\n      if (type !== false) {\r\n        type = type || \"fx\";\r\n      }\r\n      return this.each(function () {\r\n        var index,\r\n          data = jQuery._data(this),\r\n          queue = data[type + \"queue\"],\r\n          hooks = data[type + \"queueHooks\"],\r\n          timers = jQuery.timers,\r\n          length = queue ? queue.length : 0;\r\n\r\n        // enable finishing flag on private data\r\n        data.finish = true;\r\n\r\n        // empty the queue first\r\n        jQuery.queue(this, type, []);\r\n\r\n        if (hooks && hooks.cur && hooks.cur.finish) {\r\n          hooks.cur.finish.call(this);\r\n        }\r\n\r\n        // look for any active animations, and finish them\r\n        for (index = timers.length; index--;) {\r\n          if (timers[index].elem === this && timers[index].queue === type) {\r\n            timers[index].anim.stop(true);\r\n            timers.splice(index, 1);\r\n          }\r\n        }\r\n\r\n        // look for any animations in the old queue and finish them\r\n        for (index = 0; index < length; index++) {\r\n          if (queue[index] && queue[index].finish) {\r\n            queue[index].finish.call(this);\r\n          }\r\n        }\r\n\r\n        // turn off finishing flag\r\n        delete data.finish;\r\n      });\r\n    }\r\n  });\r\n\r\n  // Generate parameters to create a standard animation\r\n  function genFx(type, includeWidth) {\r\n    var which,\r\n      attrs = { height: type },\r\n      i = 0;\r\n\r\n    // if we include width, step value is 1 to do all cssExpand values,\r\n    // if we don't include width, step value is 2 to skip over Left and Right\r\n    includeWidth = includeWidth ? 1 : 0;\r\n    for (; i < 4; i += 2 - includeWidth) {\r\n      which = cssExpand[i];\r\n      attrs[\"margin\" + which] = attrs[\"padding\" + which] = type;\r\n    }\r\n\r\n    if (includeWidth) {\r\n      attrs.opacity = attrs.width = type;\r\n    }\r\n\r\n    return attrs;\r\n  }\r\n\r\n  // Generate shortcuts for custom animations\r\n  jQuery.each({\r\n    slideDown: genFx(\"show\"),\r\n    slideUp: genFx(\"hide\"),\r\n    slideToggle: genFx(\"toggle\"),\r\n    fadeIn: { opacity: \"show\" },\r\n    fadeOut: { opacity: \"hide\" },\r\n    fadeToggle: { opacity: \"toggle\" }\r\n  }, function (name, props) {\r\n    jQuery.fn[name] = function (speed, easing, callback) {\r\n      return this.animate(props, speed, easing, callback);\r\n    };\r\n  });\r\n\r\n  jQuery.speed = function (speed, easing, fn) {\r\n    var opt = speed && typeof speed === \"object\" ? jQuery.extend({}, speed) : {\r\n      complete: fn || !fn && easing ||\r\n        jQuery.isFunction(speed) && speed,\r\n      duration: speed,\r\n      easing: fn && easing || easing && !jQuery.isFunction(easing) && easing\r\n    };\r\n\r\n    opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === \"number\" ? opt.duration :\r\n      opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;\r\n\r\n    // normalize opt.queue - true/undefined/null -> \"fx\"\r\n    if (opt.queue == null || opt.queue === true) {\r\n      opt.queue = \"fx\";\r\n    }\r\n\r\n    // Queueing\r\n    opt.old = opt.complete;\r\n\r\n    opt.complete = function () {\r\n      if (jQuery.isFunction(opt.old)) {\r\n        opt.old.call(this);\r\n      }\r\n\r\n      if (opt.queue) {\r\n        jQuery.dequeue(this, opt.queue);\r\n      }\r\n    };\r\n\r\n    return opt;\r\n  };\r\n\r\n  jQuery.easing = {\r\n    linear: function (p) {\r\n      return p;\r\n    },\r\n    swing: function (p) {\r\n      return 0.5 - Math.cos(p * Math.PI) / 2;\r\n    }\r\n  };\r\n\r\n  jQuery.timers = [];\r\n  jQuery.fx = Tween.prototype.init;\r\n  jQuery.fx.tick = function () {\r\n    var timer,\r\n      timers = jQuery.timers,\r\n      i = 0;\r\n\r\n    fxNow = jQuery.now();\r\n\r\n    for (; i < timers.length; i++) {\r\n      timer = timers[i];\r\n      // Checks the timer has not already been removed\r\n      if (!timer() && timers[i] === timer) {\r\n        timers.splice(i--, 1);\r\n      }\r\n    }\r\n\r\n    if (!timers.length) {\r\n      jQuery.fx.stop();\r\n    }\r\n    fxNow = undefined;\r\n  };\r\n\r\n  jQuery.fx.timer = function (timer) {\r\n    if (timer() && jQuery.timers.push(timer)) {\r\n      jQuery.fx.start();\r\n    }\r\n  };\r\n\r\n  jQuery.fx.interval = 13;\r\n\r\n  jQuery.fx.start = function () {\r\n    if (!timerId) {\r\n      timerId = setInterval(jQuery.fx.tick, jQuery.fx.interval);\r\n    }\r\n  };\r\n\r\n  jQuery.fx.stop = function () {\r\n    clearInterval(timerId);\r\n    timerId = null;\r\n  };\r\n\r\n  jQuery.fx.speeds = {\r\n    slow: 600,\r\n    fast: 200,\r\n    // Default speed\r\n    _default: 400\r\n  };\r\n\r\n  // Back Compat <1.8 extension point\r\n  jQuery.fx.step = {};\r\n\r\n  if (jQuery.expr && jQuery.expr.filters) {\r\n    jQuery.expr.filters.animated = function (elem) {\r\n      return jQuery.grep(jQuery.timers, function (fn) {\r\n        return elem === fn.elem;\r\n      }).length;\r\n    };\r\n  }\r\n  jQuery.fn.offset = function (options) {\r\n    if (arguments.length) {\r\n      return options === undefined ?\r\n        this :\r\n        this.each(function (i) {\r\n          jQuery.offset.setOffset(this, options, i);\r\n        });\r\n    }\r\n\r\n    var docElem, win,\r\n      box = { top: 0, left: 0 },\r\n      elem = this[0],\r\n      doc = elem && elem.ownerDocument;\r\n\r\n    if (!doc) {\r\n      return;\r\n    }\r\n\r\n    docElem = doc.documentElement;\r\n\r\n    // Make sure it's not a disconnected DOM node\r\n    if (!jQuery.contains(docElem, elem)) {\r\n      return box;\r\n    }\r\n\r\n    // If we don't have gBCR, just use 0,0 rather than error\r\n    // BlackBerry 5, iOS 3 (original iPhone)\r\n    if (typeof elem.getBoundingClientRect !== core_strundefined) {\r\n      box = elem.getBoundingClientRect();\r\n    }\r\n    win = getWindow(doc);\r\n    return {\r\n      top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),\r\n      left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)\r\n    };\r\n  };\r\n\r\n  jQuery.offset = {\r\n\r\n    setOffset: function (elem, options, i) {\r\n      var position = jQuery.css(elem, \"position\");\r\n\r\n      // set position first, in-case top/left are set even on static elem\r\n      if (position === \"static\") {\r\n        elem.style.position = \"relative\";\r\n      }\r\n\r\n      var curElem = jQuery(elem),\r\n        curOffset = curElem.offset(),\r\n        curCSSTop = jQuery.css(elem, \"top\"),\r\n        curCSSLeft = jQuery.css(elem, \"left\"),\r\n        calculatePosition = (position === \"absolute\" || position === \"fixed\") && jQuery.inArray(\"auto\", [curCSSTop, curCSSLeft]) > -1,\r\n        props = {}, curPosition = {}, curTop, curLeft;\r\n\r\n      // need to be able to calculate position if either top or left is auto and position is either absolute or fixed\r\n      if (calculatePosition) {\r\n        curPosition = curElem.position();\r\n        curTop = curPosition.top;\r\n        curLeft = curPosition.left;\r\n      } else {\r\n        curTop = parseFloat(curCSSTop) || 0;\r\n        curLeft = parseFloat(curCSSLeft) || 0;\r\n      }\r\n\r\n      if (jQuery.isFunction(options)) {\r\n        options = options.call(elem, i, curOffset);\r\n      }\r\n\r\n      if (options.top != null) {\r\n        props.top = (options.top - curOffset.top) + curTop;\r\n      }\r\n      if (options.left != null) {\r\n        props.left = (options.left - curOffset.left) + curLeft;\r\n      }\r\n\r\n      if (\"using\" in options) {\r\n        options.using.call(elem, props);\r\n      } else {\r\n        curElem.css(props);\r\n      }\r\n    }\r\n  };\r\n\r\n\r\n  jQuery.fn.extend({\r\n\r\n    position: function () {\r\n      if (!this[0]) {\r\n        return;\r\n      }\r\n\r\n      var offsetParent, offset,\r\n        parentOffset = { top: 0, left: 0 },\r\n        elem = this[0];\r\n\r\n      // fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is it's only offset parent\r\n      if (jQuery.css(elem, \"position\") === \"fixed\") {\r\n        // we assume that getBoundingClientRect is available when computed position is fixed\r\n        offset = elem.getBoundingClientRect();\r\n      } else {\r\n        // Get *real* offsetParent\r\n        offsetParent = this.offsetParent();\r\n\r\n        // Get correct offsets\r\n        offset = this.offset();\r\n        if (!jQuery.nodeName(offsetParent[0], \"html\")) {\r\n          parentOffset = offsetParent.offset();\r\n        }\r\n\r\n        // Add offsetParent borders\r\n        parentOffset.top += jQuery.css(offsetParent[0], \"borderTopWidth\", true);\r\n        parentOffset.left += jQuery.css(offsetParent[0], \"borderLeftWidth\", true);\r\n      }\r\n\r\n      // Subtract parent offsets and element margins\r\n      // note: when an element has margin: auto the offsetLeft and marginLeft\r\n      // are the same in Safari causing offset.left to incorrectly be 0\r\n      return {\r\n        top: offset.top - parentOffset.top - jQuery.css(elem, \"marginTop\", true),\r\n        left: offset.left - parentOffset.left - jQuery.css(elem, \"marginLeft\", true)\r\n      };\r\n    },\r\n\r\n    offsetParent: function () {\r\n      return this.map(function () {\r\n        var offsetParent = this.offsetParent || document.documentElement;\r\n        while (offsetParent && (!jQuery.nodeName(offsetParent, \"html\") && jQuery.css(offsetParent, \"position\") === \"static\")) {\r\n          offsetParent = offsetParent.offsetParent;\r\n        }\r\n        return offsetParent || document.documentElement;\r\n      });\r\n    }\r\n  });\r\n\r\n\r\n  // Create scrollLeft and scrollTop methods\r\n  jQuery.each({ scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function (method, prop) {\r\n    var top = /Y/.test(prop);\r\n\r\n    jQuery.fn[method] = function (val) {\r\n      return jQuery.access(this, function (elem, method, val) {\r\n        var win = getWindow(elem);\r\n\r\n        if (val === undefined) {\r\n          return win ? (prop in win) ? win[prop] :\r\n            win.document.documentElement[method] :\r\n            elem[method];\r\n        }\r\n\r\n        if (win) {\r\n          win.scrollTo(\r\n            !top ? val : jQuery(win).scrollLeft(),\r\n            top ? val : jQuery(win).scrollTop()\r\n          );\r\n\r\n        } else {\r\n          elem[method] = val;\r\n        }\r\n      }, method, val, arguments.length, null);\r\n    };\r\n  });\r\n\r\n  function getWindow(elem) {\r\n    return jQuery.isWindow(elem) ?\r\n      elem :\r\n      elem.nodeType === 9 ?\r\n        elem.defaultView || elem.parentWindow :\r\n        false;\r\n  }\r\n  // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\r\n  jQuery.each({ Height: \"height\", Width: \"width\" }, function (name, type) {\r\n    jQuery.each({ padding: \"inner\" + name, content: type, \"\": \"outer\" + name }, function (defaultExtra, funcName) {\r\n      // margin is only for outerHeight, outerWidth\r\n      jQuery.fn[funcName] = function (margin, value) {\r\n        var chainable = arguments.length && (defaultExtra || typeof margin !== \"boolean\"),\r\n          extra = defaultExtra || (margin === true || value === true ? \"margin\" : \"border\");\r\n\r\n        return jQuery.access(this, function (elem, type, value) {\r\n          var doc;\r\n\r\n          if (jQuery.isWindow(elem)) {\r\n            // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there\r\n            // isn't a whole lot we can do. See pull request at this URL for discussion:\r\n            // https://github.com/jquery/jquery/pull/764\r\n            return elem.document.documentElement[\"client\" + name];\r\n          }\r\n\r\n          // Get document width or height\r\n          if (elem.nodeType === 9) {\r\n            doc = elem.documentElement;\r\n\r\n            // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest\r\n            // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.\r\n            return Math.max(\r\n              elem.body[\"scroll\" + name], doc[\"scroll\" + name],\r\n              elem.body[\"offset\" + name], doc[\"offset\" + name],\r\n              doc[\"client\" + name]\r\n            );\r\n          }\r\n\r\n          return value === undefined ?\r\n            // Get width or height on the element, requesting but not forcing parseFloat\r\n            jQuery.css(elem, type, extra) :\r\n\r\n            // Set width or height on the element\r\n            jQuery.style(elem, type, value, extra);\r\n        }, type, chainable ? margin : undefined, chainable, null);\r\n      };\r\n    });\r\n  });\r\n  // Limit scope pollution from any deprecated API\r\n  // (function() {\r\n\r\n  // })();\r\n  // Expose jQuery to the global object\r\n  window.jQuery = window.$ = jQuery;\r\n\r\n  // Expose jQuery as an AMD module, but only for AMD loaders that\r\n  // understand the issues with loading multiple versions of jQuery\r\n  // in a page that all might call define(). The loader will indicate\r\n  // they have special allowances for multiple jQuery versions by\r\n  // specifying define.amd.jQuery = true. Register as a named module,\r\n  // since jQuery can be concatenated with other files that may use define,\r\n  // but not use a proper concatenation script that understands anonymous\r\n  // AMD modules. A named AMD is safest and most robust way to register.\r\n  // Lowercase jquery is used because AMD module names are derived from\r\n  // file names, and jQuery is normally delivered in a lowercase file name.\r\n  // Do this after creating the global so that if an AMD module wants to call\r\n  // noConflict to hide this version of jQuery, it will work.\r\n  if (typeof define === \"function\" && define.amd && define.amd.jQuery) {\r\n    define(\"jquery\", [], function () { return jQuery; });\r\n  }\r\n\r\n})(window);\r\n"],"sourceRoot":""}