{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/@glidejs/glide/dist/glide.esm.js","webpack:///(webpack)/buildin/module.js","webpack:///./app/javascript/packs/application.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/@rails/ujs/lib/assets/compiled/rails-ujs.js","webpack:///./node_modules/@rails/activestorage/app/assets/javascripts/activestorage.js","webpack:///./app/javascript/channels/index.js","webpack:///./app/javascript/channels sync _channel\\.js$","webpack:///./node_modules/jquery/dist/jquery.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","_typeof2","obj","iterator","constructor","defaults","type","startAt","perView","focusAt","gap","autoplay","hoverpause","keyboard","bound","swipeThreshold","dragThreshold","perTouch","touchRatio","touchAngle","animationDuration","rewind","rewindDuration","animationTimingFunc","throttle","direction","peek","breakpoints","classes","ltr","rtl","slider","carousel","swipeable","dragging","cloneSlide","activeNav","activeSlide","disabledArrow","warn","msg","console","error","_typeof","classCallCheck","instance","Constructor","TypeError","createClass","defineProperties","target","props","length","descriptor","configurable","writable","protoProps","staticProps","_extends","assign","arguments","source","receiver","Function","desc","getOwnPropertyDescriptor","undefined","parent","getPrototypeOf","possibleConstructorReturn","self","ReferenceError","toInt","parseInt","isString","isObject","isFunction","isUndefined","isArray","Array","mount","glide","extensions","events","components","_name","define","prop","definition","mergeOptions","settings","options","EventsBus","this","hop","event","handler","on","index","push","remove","context","emit","forEach","item","Glide","selector","_c","_t","_e","disabled","transformers","pattern","Run","make","distance","Transition","disable","Move","interval","_o","set","_i","_d","status","now","Date","getTime","func","wait","timeout","args","result","previous","later","leading","apply","throttled","at","remaining","clearTimeout","trailing","setTimeout","cancel","MARGIN_TYPE","siblings","node","parentNode","firstChild","matched","nextSibling","nodeType","exist","window","HTMLElement","EventsBinder","listeners","el","closure","capture","addEventListener","removeEventListener","VALID_DIRECTIONS","FLIPED_MOVEMENTS","Rtl","Components","modify","translate","Direction","is","Gap","Gaps","Grow","Clones","grow","Peeking","Peek","before","Focusing","width","Sizes","slideWidth","supportsPassive","opts","e","supportsPassive$1","START_EVENTS","MOVE_EVENTS","END_EVENTS","MOUSE_EVENTS","sortBreakpoints","points","keys","sort","reduce","k","COMPONENTS","Html","root","track","querySelector","slides","slice","wrapper","children","filter","slide","classList","contains","_r","document","Translate","Events","transform","TRANSFORMERS","concat","mutate","transformer","mutator","style","isType","isOffset","after","movement","compose","duration","transition","callback","enable","offset","resolve","token","split","join","addClass","add","removeClass","_v","indexOf","setupSlides","setupWrapper","dimention","wrapperSize","offsetWidth","reductor","len","marginLeft","marginRight","_this","items","collect","_Glide$settings","peekIncrementer","part","start","end","Math","max","floor","clone","cloneNode","_clone","unshift","append","_Components$Html","half","prepend","reverse","appendChild","_i2","insertBefore","_i3","removeChild","Resize","Binder","unbind","off","destroy","Build","typeClass","activeClass","sibling","removeClasses","move","calculate","isStart","isEnd","steps","countableSteps","min","_m","step","substr","Swipe","swipeSin","swipeStartX","swipeStartY","passive","bindSwipeStart","swipe","touches","pageX","pageY","bindSwipeMove","bindSwipeEnd","subExSx","subEySy","powEX","abs","powEY","swipeHypotenuse","sqrt","swipeCathetus","asin","PI","stopPropagation","parseFloat","threshold","swipeDistance","swipeDeg","round","unbindSwipeMove","unbindSwipeEnd","unbindSwipeStart","_this2","_this3","changedTouches","Images","dragstart","preventDefault","Anchors","detached","prevented","_a","querySelectorAll","click","detach","draggable","setAttribute","getAttribute","removeAttribute","attach","Controls","_n","addBindings","setActive","removeActive","controls","removeBindings","elements","currentTarget","Keyboard","press","keyCode","Autoplay","setInterval","stop","time","clearInterval","Breakpoints","match","matchMedia","point","matches","Glide$1","_Core","Glide$$1","__proto__","subClass","superClass","setPrototypeOf","inherits","webpackPolyfill","deprecate","paths","require","global","$","jQuery","find","modal","mainCarousel","refList","g","Rails","linkClickSelector","buttonClickSelector","exclude","inputChangeSelector","formSubmitSelector","formInputClickSelector","formDisableSelector","formEnableSelector","fileInputSelector","linkDisableSelector","buttonDisableSelector","nonce","loadCSPNonce","ref","content","cspNonce","Element","matchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","element","getData","setData","csrfParam","csrfToken","meta","CSRFProtection","xhr","setRequestHeader","refreshCSRFTokens","param","input","CustomEvent","fire","params","evt","createEvent","initCustomEvent","bubbles","cancelable","detail","Event","defaultPrevented","data","dispatchEvent","stopEverything","stopImmediatePropagation","delegate","eventType","AcceptHeaders","createXHR","prepareOptions","processResponse","text","html","xml","json","script","ajax","response","responseText","getResponseHeader","success","statusText","complete","beforeSend","readyState","XMLHttpRequest","OPENED","send","url","location","href","toUpperCase","dataType","accept","done","open","crossDomain","withCredentials","onreadystatechange","DONE","parser","JSON","parse","createElement","head","DOMParser","replace","parseFromString","isCrossDomain","originAnchor","urlAnchor","protocol","host","toArray","serializeElement","additionalParam","inputs","option","selected","checked","map","encodeURIComponent","formElements","form","allowAction","handleConfirm","confirm","message","answer","disableFormElement","disableFormElements","disableLinkElement","enableFormElement","enableFormElements","enableLinkElement","isXhrRedirect","handleDisabledElement","enableElement","disableElement","replacement","innerHTML","originalText","handleMethod","formContent","method","action","display","body","isRemote","handleRemote","button","enctype","FormData","formSubmitButtonClick","formNoValidate","preventInsignificantClick","insignificantMetaClick","metaKey","ctrlKey","rails","Error","ajaxPrefilter","originalOptions","_rails_loaded","factory","sparkMd5","fn","createCommonjsModule","hex_chr","md5cycle","x","a","b","md5blk","md5blks","charCodeAt","md5blk_array","md51","tail","tmp","lo","hi","state","substring","toString","rhex","j","hex","toUtf8","str","test","unescape","hexToBinaryString","bytes","String","fromCharCode","SparkMD5","reset","ArrayBuffer","clamp","val","from","to","num","targetArray","sourceArray","byteLength","begin","Uint8Array","appendBinary","contents","_buff","_length","_hash","raw","ret","buff","_finish","getState","hash","setState","hashBinary","arr","first","second","returnUInt8Array","buffer","subarray","utf8Str2ArrayBuffer","md51_array","fileSlice","File","mozSlice","webkitSlice","FileChecksum","file","chunkSize","chunkCount","ceil","size","chunkIndex","md5Buffer","fileReader","FileReader","fileReaderDidLoad","fileReaderDidError","readNextChunk","binaryDigest","base64digest","btoa","readAsArrayBuffer","findElement","eventInit","initEvent","toArray$1","BlobRecord","checksum","attributes","filename","content_type","byte_size","responseType","getMetaValue","requestDidLoad","requestDidError","stringify","blob","direct_upload","directUploadData","toJSON","_xhr","BlobUpload","_blob$directUploadDat","headers","id","DirectUpload","notify","upload","methodName","_len","messages","_key","DirectUploadController","directUpload","dispatch","hiddenInput","insertAdjacentElement","dispatchError","signed_id","progress","loaded","total","alert","uploadRequestDidProgress","DirectUploadsController","files","controllers","createDirectUploadControllers","startNextController","controller","shift","submitButtonsByForm","WeakMap","started","didClick","didSubmitForm","didSubmitRemoteElement","tagName","handleFormSubmissionEvent","hasAttribute","focus","delete","submitForm","ActiveStorage","channels","webpackEmptyContext","req","code","w","noGlobal","getProto","_slice","flat","array","class2type","hasOwn","fnToString","ObjectFunctionString","support","isWindow","preservedScriptAttributes","src","noModule","DOMEval","doc","toType","init","isArrayLike","jquery","pushStack","elems","merge","prevObject","each","elem","eq","last","even","grep","_elem","odd","splice","extend","copy","copyIsArray","deep","isPlainObject","expando","random","isReady","noop","proto","Ctor","isEmptyObject","globalEval","makeArray","results","inArray","invert","callbackExpect","arg","guid","toLowerCase","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","preferredDoc","dirruns","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","pop","pushNative","list","booleans","whitespace","identifier","pseudos","rwhitespace","RegExp","rtrim","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","rcssescape","fcssescape","ch","asCodePoint","unloadHandler","inDisabledFieldset","addCombinator","nodeName","dir","next","childNodes","els","seed","nid","groups","newSelector","newContext","ownerDocument","exec","getElementById","getElementsByTagName","getElementsByClassName","qsa","testContext","scope","toSelector","qsaError","cache","cacheLength","markFunction","assert","addHandle","attrs","attrHandle","siblingCheck","cur","diff","sourceIndex","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","namespace","namespaceURI","documentElement","hasCompare","subWindow","defaultView","top","attachEvent","className","createComment","getById","getElementsByName","attrId","getAttributeNode","tag","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","expr","attr","specified","sel","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","nodeValue","selectors","createPseudo","relative","preFilter","excess","unquoted","nodeNameSelector","operator","check","what","_argument","simple","forward","ofType","_context","uniqueCache","outerCache","nodeIndex","useCache","lastChild","uniqueID","pseudo","setFilters","idx","matcher","unmatched","lang","elemLang","activeElement","hasFocus","tabIndex","selectedIndex","_matchIndexes","radio","checkbox","password","image","submit","tokens","combinator","base","skip","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","contexts","multipleContexts","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","filters","parseOnly","soFar","preFilters","cached","setMatchers","elementMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","matcherFromGroupMatchers","compiled","defaultValue","unique","isXMLDoc","escapeSelector","_dir","until","truncate","_siblings","rneedsContext","needsContext","rsingleTag","winnow","qualifier","not","rootjQuery","parseHTML","ready","rparentsprev","guaranteedUnique","prev","has","targets","closest","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","rnothtmlwhite","Identity","v","Thrower","ex","adoptValue","reject","noValue","promise","fail","then","Callbacks","_","flag","createOptions","firing","memory","_fired","_locked","queue","firingIndex","once","stopOnFalse","empty","lock","locked","fireWith","fired","Deferred","tuples","_state","_promise","always","deferred","pipe","fns","newDefer","tuple","returned","onFulfilled","onRejected","onProgress","maxDepth","depth","special","that","mightThrow","notifyWith","resolveWith","process","exceptionHook","stackTrace","rejectWith","getStackHook","stateString","when","singleValue","resolveContexts","resolveValues","primary","updateFunc","rerrorNames","stack","readyException","readyList","completed","catch","readyWait","doScroll","access","chainable","emptyGet","bulk","rmsPrefix","rdashAlpha","fcamelCase","_all","letter","camelCase","string","acceptData","owner","Data","uid","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","_data","removeData","_removeData","dequeue","startLength","hooks","_queueHooks","setter","clearQueue","count","defer","pnum","rcssNum","cssExpand","isAttached","composed","getRootNode","isHiddenWithinTree","css","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","initial","unit","cssNumber","initialInUnit","defaultDisplayMap","getDefaultDisplay","showHide","show","values","hide","toggle","div","rcheckableType","rtagName","rscriptType","createDocumentFragment","checkClone","noCloneChecked","wrapMap","thead","col","tr","td","_default","getAll","setGlobalEval","refElements","tbody","tfoot","colgroup","caption","th","optgroup","buildFragment","scripts","selection","ignored","wrap","attached","fragment","nodes","htmlPrefilter","createTextNode","rtypenamespace","returnTrue","returnFalse","expectSync","err","safeActiveElement","_on","types","one","origFn","leverageNative","notAsync","saved","isTrigger","delegateType","trigger","handleObjIn","eventHandle","handleObj","handlers","namespaces","origType","elemData","handle","triggered","bindType","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","nativeEvent","handlerQueue","fix","delegateTarget","preDispatch","isPropagationStopped","isImmediatePropagationStopped","rnamespace","postDispatch","_handlers","matchedHandlers","matchedSelectors","addProp","hook","originalEvent","load","noBubble","beforeunload","returnValue","isDefaultPrevented","relatedTarget","timeStamp","isSimulated","altKey","eventPhase","shiftKey","view","charCode","buttons","clientX","clientY","offsetX","offsetY","pointerId","pointerType","screenX","screenY","targetTouches","toElement","which","blur","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","rnoInnerhtml","rchecked","rcleanScript","manipulationTarget","disableScript","restoreScript","cloneCopyEvent","dest","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","valueIsFunction","_evalUrl","_remove","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","original","insert","rnumnonpx","getStyles","opener","getComputedStyle","swap","old","rboxStyle","curCSS","computed","minWidth","maxWidth","getPropertyValue","pixelBoxStyles","addGetHookIf","conditionFn","hookFn","computeStyleTests","container","cssText","divStyle","pixelPositionVal","reliableMarginLeftVal","roundPixelMeasures","right","pixelBoxStylesVal","boxSizingReliableVal","position","scrollboxSizeVal","measure","reliableTrDimensionsVal","backgroundClip","clearCloneStyle","boxSizingReliable","pixelPosition","reliableMarginLeft","scrollboxSize","reliableTrDimensions","table","trChild","trStyle","height","borderTopWidth","borderBottomWidth","offsetHeight","cssPrefixes","emptyStyle","vendorProps","finalPropName","final","cssProps","capName","vendorPropName","rdisplayswap","rcustomProp","cssShow","visibility","cssNormalTransform","letterSpacing","fontWeight","setPositiveNumber","subtract","boxModelAdjustment","dimension","box","isBorderBox","styles","computedVal","extra","delta","getWidthOrHeight","valueIsBorderBox","offsetProp","getClientRects","Tween","easing","cssHooks","opacity","origName","isCustomProp","setProperty","isFinite","getBoundingClientRect","scrollboxSizeBuggy","left","margin","padding","border","prefix","suffix","expand","expanded","parts","propHooks","run","percent","eased","pos","fx","scrollTop","scrollLeft","linear","swing","cos","fxNow","inProgress","rfxtypes","rrun","schedule","hidden","requestAnimationFrame","tick","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","properties","stopped","prefilters","currentTime","startTime","tweens","specialEasing","originalProperties","gotoEnd","propFilter","timer","anim","tweener","oldfire","propTween","restoreDisplay","isBox","dataShow","unqueued","overflow","overflowX","overflowY","prefilter","speed","opt","speeds","fadeTo","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","slow","fast","delay","checkOn","optSelected","radioValue","boolHook","removeAttr","nType","attrHooks","bool","attrNames","lowercaseName","rfocusable","rclickable","stripAndCollapse","getClass","classesToArray","removeProp","propFix","tabindex","curValue","clazz","finalValue","toggleClass","stateVal","isValidValue","classNames","hasClass","rreturn","valHooks","optionSet","focusin","rfocusMorph","stopPropagationCallback","onlyHandlers","bubbleType","ontype","lastElement","eventPath","parentWindow","simulate","triggerHandler","attaches","rquery","parseXML","parserErrorElem","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","traditional","valueOrFunction","serialize","serializeArray","r20","rhash","rantiCache","rheaders","rnoContent","rprotocol","transports","allTypes","addToPrefiltersOrTransports","structure","dataTypeExpression","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","active","lastModified","etag","isLocal","processData","async","contentType","accepts","responseFields","converters","ajaxSetup","ajaxTransport","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","fireGlobals","uncached","callbackContext","globalEventContext","completeDeferred","_statusCode","statusCode","requestHeaders","requestHeadersNames","strAbort","getAllResponseHeaders","overrideMimeType","mimeType","abort","finalText","hasContent","ifModified","nativeStatusText","responses","isSuccess","modified","ct","finalDataType","firstDataType","ajaxHandleResponses","conv2","current","conv","dataFilter","throws","ajaxConvert","getJSON","getScript","wrapAll","firstElementChild","wrapInner","htmlIsFunction","unwrap","visible","xhrSuccessStatus","0","1223","xhrSupported","cors","_callback","errorCallback","username","xhrFields","onload","onerror","onabort","ontimeout","binary","_callback2","scriptAttrs","charset","scriptCharset","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","createHTMLDocument","implementation","keepScripts","parsed","animated","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","curElem","using","rect","win","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","undelegate","hover","fnOver","fnOut","proxy","holdReady","hold","parseJSON","isNumeric","isNaN","trim","_jQuery","_$","noConflict"],"mappings":";aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,qBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,kBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,UAIjBlC,EAAoBA,EAAoBmC,EAAI,G,+BClFrD,SAASC,EAASC,GAAuV,OAA1OD,EAArD,oBAAXjB,QAAoD,kBAApBA,OAAOmB,SAAoC,SAAkBD,GAAO,cAAcA,GAA4B,SAAkBA,GAAO,OAAOA,GAAyB,oBAAXlB,QAAyBkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,IAA0BA,GAOzX,IAAIG,EAAW,CAUbC,KAAM,SAONC,QAAS,EAOTC,QAAS,EAWTC,QAAS,EAOTC,IAAK,GAOLC,UAAU,EAOVC,YAAY,EAOZC,UAAU,EAUVC,OAAO,EAOPC,eAAgB,GAOhBC,cAAe,IAOfC,UAAU,EAOVC,WAAY,GAOZC,WAAY,GAOZC,kBAAmB,IAOnBC,QAAQ,EAORC,eAAgB,IAOhBC,oBAAqB,oCAOrBC,SAAU,GAWVC,UAAW,MAcXC,KAAM,EAWNC,YAAa,GAQbC,QAAS,CACPH,UAAW,CACTI,IAAK,aACLC,IAAK,cAEPC,OAAQ,gBACRC,SAAU,kBACVC,UAAW,mBACXC,SAAU,kBACVC,WAAY,sBACZC,UAAW,wBACXC,YAAa,uBACbC,cAAe,2BAUnB,SAASC,EAAKC,GACZC,QAAQC,MAAM,iBAAmBF,GAGnC,IAAIG,EAA4B,oBAAX3D,QAAuD,WAA9BiB,EAASjB,OAAOmB,UAAyB,SAAUD,GAC/F,OAAOD,EAASC,IACd,SAAUA,GACZ,OAAOA,GAAyB,oBAAXlB,QAAyBkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,SAAWI,EAASC,IAGzH0C,EAAiB,SAAwBC,EAAUC,GACrD,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,sCAIpBC,EAAc,WAChB,SAASC,EAAiBC,EAAQC,GAChC,IAAK,IAAIlF,EAAI,EAAGA,EAAIkF,EAAMC,OAAQnF,IAAK,CACrC,IAAIoF,EAAaF,EAAMlF,GACvBoF,EAAWxE,WAAawE,EAAWxE,aAAc,EACjDwE,EAAWC,cAAe,EACtB,UAAWD,IAAYA,EAAWE,UAAW,GACjD5E,OAAOC,eAAesE,EAAQG,EAAW7D,IAAK6D,IAIlD,OAAO,SAAUP,EAAaU,EAAYC,GAGxC,OAFID,GAAYP,EAAiBH,EAAYjD,UAAW2D,GACpDC,GAAaR,EAAiBH,EAAaW,GACxCX,GAdO,GAkBdY,EAAW/E,OAAOgF,QAAU,SAAUT,GACxC,IAAK,IAAIjF,EAAI,EAAGA,EAAI2F,UAAUR,OAAQnF,IAAK,CACzC,IAAI4F,EAASD,UAAU3F,GAEvB,IAAK,IAAIuB,KAAOqE,EACVlF,OAAOkB,UAAUC,eAAe1B,KAAKyF,EAAQrE,KAC/C0D,EAAO1D,GAAOqE,EAAOrE,IAK3B,OAAO0D,GAGLpE,EAAM,SAASA,EAAIa,EAAQC,EAAUkE,GACxB,OAAXnE,IAAiBA,EAASoE,SAASlE,WACvC,IAAImE,EAAOrF,OAAOsF,yBAAyBtE,EAAQC,GAEnD,QAAasE,IAATF,EAAoB,CACtB,IAAIG,EAASxF,OAAOyF,eAAezE,GAEnC,OAAe,OAAXwE,OACF,EAEOrF,EAAIqF,EAAQvE,EAAUkE,GAE1B,GAAI,UAAWE,EACpB,OAAOA,EAAK9E,MAEZ,IAAIT,EAASuF,EAAKlF,IAElB,YAAeoF,IAAXzF,EAIGA,EAAOL,KAAK0F,QAJnB,GAwBAO,EAA4B,SAAmCC,EAAMlG,GACvE,IAAKkG,EACH,MAAM,IAAIC,eAAe,6DAG3B,OAAOnG,GAA4B,WAAnB6B,EAAS7B,IAAsC,oBAATA,EAA8BkG,EAAPlG,GAW/E,SAASoG,EAAMtF,GACb,OAAOuF,SAASvF,GAsBlB,SAASwF,EAASxF,GAChB,MAAwB,kBAAVA,EAYhB,SAASyF,EAASzF,GAChB,IAAIoB,EAAwB,qBAAVpB,EAAwB,YAAcyD,EAAQzD,GAChE,MAAgB,aAAToB,GAAgC,WAATA,KAAuBpB,EAqBvD,SAAS0F,EAAW1F,GAClB,MAAwB,oBAAVA,EAUhB,SAAS2F,EAAY3F,GACnB,MAAwB,qBAAVA,EAUhB,SAAS4F,EAAQ5F,GACf,OAAOA,EAAMkB,cAAgB2E,MAa/B,SAASC,EAAMC,EAAOC,EAAYC,GAChC,IAAIC,EAAa,GAEjB,IAAK,IAAI5G,KAAQ0G,EACXN,EAAWM,EAAW1G,IACxB4G,EAAW5G,GAAQ0G,EAAW1G,GAAMyG,EAAOG,EAAYD,GAEvD5C,EAAK,gCAIT,IAAK,IAAI8C,KAASD,EACZR,EAAWQ,EAAWC,GAAOL,QAC/BI,EAAWC,GAAOL,QAItB,OAAOI,EAYT,SAASE,EAAOpF,EAAKqF,EAAMC,GACzB7G,OAAOC,eAAesB,EAAKqF,EAAMC,GAyBnC,SAASC,EAAapF,EAAUqF,GAC9B,IAAIC,EAAUjC,EAAS,GAAIrD,EAAUqF,GAmBrC,OAZIA,EAAS5F,eAAe,aAC1B6F,EAAQ/D,QAAU8B,EAAS,GAAIrD,EAASuB,QAAS8D,EAAS9D,SAEtD8D,EAAS9D,QAAQ9B,eAAe,eAClC6F,EAAQ/D,QAAQH,UAAYiC,EAAS,GAAIrD,EAASuB,QAAQH,UAAWiE,EAAS9D,QAAQH,aAItFiE,EAAS5F,eAAe,iBAC1B6F,EAAQhE,YAAc+B,EAAS,GAAIrD,EAASsB,YAAa+D,EAAS/D,cAG7DgE,EAGT,IAAIC,EAAY,WAMd,SAASA,IACP,IAAIT,EAASvB,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GACjFhB,EAAeiD,KAAMD,GACrBC,KAAKV,OAASA,EACdU,KAAKC,IAAMX,EAAOrF,eA4DpB,OAlDAkD,EAAY4C,EAAW,CAAC,CACtBpG,IAAK,KACLN,MAAO,SAAY6G,EAAOC,GACxB,GAAIlB,EAAQiB,GACV,IAAK,IAAI9H,EAAI,EAAGA,EAAI8H,EAAM3C,OAAQnF,IAChC4H,KAAKI,GAAGF,EAAM9H,GAAI+H,GAKjBH,KAAKC,IAAI1H,KAAKyH,KAAKV,OAAQY,KAC9BF,KAAKV,OAAOY,GAAS,IAIvB,IAAIG,EAAQL,KAAKV,OAAOY,GAAOI,KAAKH,GAAW,EAE/C,MAAO,CACLI,OAAQ,kBACCP,KAAKV,OAAOY,GAAOG,OAW/B,CACD1G,IAAK,OACLN,MAAO,SAAc6G,EAAOM,GAC1B,GAAIvB,EAAQiB,GACV,IAAK,IAAI9H,EAAI,EAAGA,EAAI8H,EAAM3C,OAAQnF,IAChC4H,KAAKS,KAAKP,EAAM9H,GAAIoI,GAKnBR,KAAKC,IAAI1H,KAAKyH,KAAKV,OAAQY,IAKhCF,KAAKV,OAAOY,GAAOQ,SAAQ,SAAUC,GACnCA,EAAKH,GAAW,WAIfT,EAtEO,GAyEZa,EAAQ,WAOV,SAASA,EAAMC,GACb,IAAIf,EAAU/B,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GAClFhB,EAAeiD,KAAMY,GACrBZ,KAAKc,GAAK,GACVd,KAAKe,GAAK,GACVf,KAAKgB,GAAK,IAAIjB,EACdC,KAAKiB,UAAW,EAChBjB,KAAKa,SAAWA,EAChBb,KAAKH,SAAWD,EAAapF,EAAUsF,GACvCE,KAAKK,MAAQL,KAAKH,SAASnF,QAqR7B,OA3QAyC,EAAYyD,EAAO,CAAC,CAClBjH,IAAK,QACLN,MAAO,WACL,IAAIgG,EAAatB,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GAYrF,OAVAiC,KAAKgB,GAAGP,KAAK,gBAET3B,EAASO,GACXW,KAAKc,GAAK3B,EAAMa,KAAMX,EAAYW,KAAKgB,IAEvCtE,EAAK,6CAGPsD,KAAKgB,GAAGP,KAAK,eAENT,OASR,CACDrG,IAAK,SACLN,MAAO,WACL,IAAI6H,EAAenD,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GAQvF,OANIkB,EAAQiC,GACVlB,KAAKe,GAAKG,EAEVxE,EAAK,6CAGAsD,OASR,CACDrG,IAAK,SACLN,MAAO,WACL,IAAIwG,EAAW9B,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GASnF,OARAiC,KAAKH,SAAWD,EAAaI,KAAKH,SAAUA,GAExCA,EAAS5F,eAAe,aAC1B+F,KAAKK,MAAQR,EAASnF,SAGxBsF,KAAKgB,GAAGP,KAAK,UAENT,OAcR,CACDrG,IAAK,KACLN,MAAO,SAAY8H,GAGjB,OAFAnB,KAAKc,GAAGM,IAAIC,KAAKF,GAEVnB,OASR,CACDrG,IAAK,OACLN,MAAO,SAAciI,GAKnB,OAJAtB,KAAKc,GAAGS,WAAWC,UAEnBxB,KAAKc,GAAGW,KAAKJ,KAAKC,GAEXtB,OAQR,CACDrG,IAAK,UACLN,MAAO,WAGL,OAFA2G,KAAKgB,GAAGP,KAAK,WAENT,OASR,CACDrG,IAAK,OACLN,MAAO,WACL,IAAIqI,EAAW3D,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,IAAmBA,UAAU,GAQ9E,OANI2D,IACF1B,KAAKH,SAAS/E,SAAW4G,GAG3B1B,KAAKgB,GAAGP,KAAK,QAENT,OAQR,CACDrG,IAAK,QACLN,MAAO,WAGL,OAFA2G,KAAKgB,GAAGP,KAAK,SAENT,OAQR,CACDrG,IAAK,UACLN,MAAO,WAEL,OADA2G,KAAKiB,UAAW,EACTjB,OAQR,CACDrG,IAAK,SACLN,MAAO,WAEL,OADA2G,KAAKiB,UAAW,EACTjB,OAUR,CACDrG,IAAK,KACLN,MAAO,SAAY6G,EAAOC,GAGxB,OAFAH,KAAKgB,GAAGZ,GAAGF,EAAOC,GAEXH,OASR,CACDrG,IAAK,SACLN,MAAO,SAAgBV,GACrB,OAAOqH,KAAKH,SAASpF,OAAS9B,IAQ/B,CACDgB,IAAK,WACLV,IAAK,WACH,OAAO+G,KAAK2B,IASdC,IAAK,SAAgB/I,GACfiG,EAASjG,GACXmH,KAAK2B,GAAK9I,EAEV6D,EAAK,2CASR,CACD/C,IAAK,QACLV,IAAK,WACH,OAAO+G,KAAK6B,IAQdD,IAAK,SAAgBxJ,GACnB4H,KAAK6B,GAAKlD,EAAMvG,KAQjB,CACDuB,IAAK,OACLV,IAAK,WACH,OAAO+G,KAAKH,SAASpF,OAQtB,CACDd,IAAK,WACLV,IAAK,WACH,OAAO+G,KAAK8B,IAQdF,IAAK,SAAgBG,GACnB/B,KAAK8B,KAAOC,MAGTnB,EArSG,GAseZ,SAASoB,IACP,OAAO,IAAIC,MAAOC,UAepB,SAASvG,EAASwG,EAAMC,EAAMtC,GAC5B,IAAIuC,OAAU,EACV7B,OAAU,EACV8B,OAAO,EACPC,OAAS,EACTC,EAAW,EACV1C,IAASA,EAAU,IAExB,IAAI2C,EAAQ,WACVD,GAA+B,IAApB1C,EAAQ4C,QAAoB,EAAIV,IAC3CK,EAAU,KACVE,EAASJ,EAAKQ,MAAMnC,EAAS8B,GACxBD,IAAS7B,EAAU8B,EAAO,OAG7BM,EAAY,WACd,IAAIC,EAAKb,IACJQ,IAAgC,IAApB1C,EAAQ4C,UAAmBF,EAAWK,GACvD,IAAIC,EAAYV,GAAQS,EAAKL,GAiB7B,OAhBAhC,EAAUR,KACVsC,EAAOvE,UAEH+E,GAAa,GAAKA,EAAYV,GAC5BC,IACFU,aAAaV,GACbA,EAAU,MAGZG,EAAWK,EACXN,EAASJ,EAAKQ,MAAMnC,EAAS8B,GACxBD,IAAS7B,EAAU8B,EAAO,OACrBD,IAAgC,IAArBvC,EAAQkD,WAC7BX,EAAUY,WAAWR,EAAOK,IAGvBP,GAST,OANAK,EAAUM,OAAS,WACjBH,aAAaV,GACbG,EAAW,EACXH,EAAU7B,EAAU8B,EAAO,MAGtBM,EAGT,IAAIO,EAAc,CAChBnH,IAAK,CAAC,aAAc,eACpBC,IAAK,CAAC,cAAe,eAyGvB,SAASmH,EAASC,GAChB,GAAIA,GAAQA,EAAKC,WAAY,CAI3B,IAHA,IAAIzJ,EAAIwJ,EAAKC,WAAWC,WACpBC,EAAU,GAEP3J,EAAGA,EAAIA,EAAE4J,YACK,IAAf5J,EAAE6J,UAAkB7J,IAAMwJ,GAC5BG,EAAQlD,KAAKzG,GAIjB,OAAO2J,EAGT,MAAO,GAUT,SAASG,EAAMN,GACb,SAAIA,GAAQA,aAAgBO,OAAOC,aA8iBrC,IAAIC,EAAe,WAIjB,SAASA,IACP,IAAIC,EAAYhG,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GACpFhB,EAAeiD,KAAM8D,GACrB9D,KAAK+D,UAAYA,EA6DnB,OAhDA5G,EAAY2G,EAAc,CAAC,CACzBnK,IAAK,KACLN,MAAO,SAAYiG,EAAQ0E,EAAIC,GAC7B,IAAIC,EAAUnG,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,IAAmBA,UAAU,GAEzEc,EAASS,KACXA,EAAS,CAACA,IAGZ,IAAK,IAAIlH,EAAI,EAAGA,EAAIkH,EAAO/B,OAAQnF,IACjC4H,KAAK+D,UAAUzE,EAAOlH,IAAM6L,EAC5BD,EAAGG,iBAAiB7E,EAAOlH,GAAI4H,KAAK+D,UAAUzE,EAAOlH,IAAK8L,KAY7D,CACDvK,IAAK,MACLN,MAAO,SAAaiG,EAAQ0E,GAC1B,IAAIE,EAAUnG,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,IAAmBA,UAAU,GAEzEc,EAASS,KACXA,EAAS,CAACA,IAGZ,IAAK,IAAIlH,EAAI,EAAGA,EAAIkH,EAAO/B,OAAQnF,IACjC4L,EAAGI,oBAAoB9E,EAAOlH,GAAI4H,KAAK+D,UAAUzE,EAAOlH,IAAK8L,KAShE,CACDvK,IAAK,UACLN,MAAO,kBACE2G,KAAK+D,cAGTD,EApEU,GAuHnB,IAAIO,EAAmB,CAAC,MAAO,OAC3BC,EAAmB,CACrB,IAAK,IACL,IAAK,IACL,IAAK,KAuHP,SAASC,EAAI3D,EAAO4D,GAClB,MAAO,CAOLC,OAAQ,SAAgBC,GACtB,OAAIF,EAAWG,UAAUC,GAAG,QAClBF,EAGHA,IAab,SAASG,EAAIjE,EAAO4D,GAClB,MAAO,CAOLC,OAAQ,SAAgBC,GACtB,OAAOA,EAAYF,EAAWM,KAAKzL,MAAQuH,EAAMP,QAavD,SAAS0E,EAAKnE,EAAO4D,GACnB,MAAO,CAOLC,OAAQ,SAAgBC,GACtB,OAAOA,EAAYF,EAAWQ,OAAOC,KAAO,IAalD,SAASC,EAAQtE,EAAO4D,GACtB,MAAO,CAOLC,OAAQ,SAAgBC,GACtB,GAAI9D,EAAMf,SAASjF,SAAW,EAAG,CAC/B,IAAIiB,EAAO2I,EAAWW,KAAK9L,MAE3B,OAAIyF,EAASjD,GACJ6I,EAAY7I,EAAKuJ,OAGnBV,EAAY7I,EAGrB,OAAO6I,IAab,SAASW,EAASzE,EAAO4D,GACvB,MAAO,CAOLC,OAAQ,SAAgBC,GACtB,IAAI7J,EAAM2J,EAAWM,KAAKzL,MACtBiM,EAAQd,EAAWe,MAAMD,MACzB1K,EAAUgG,EAAMf,SAASjF,QACzB4K,EAAahB,EAAWe,MAAMC,WAElC,MAAgB,WAAZ5K,EACK8J,GAAaY,EAAQ,EAAIE,EAAa,GAGxCd,EAAYc,EAAa5K,EAAUC,EAAMD,IAqPtD,IAAI6K,GAAkB,EAEtB,IACE,IAAIC,EAAO5M,OAAOC,eAAe,GAAI,UAAW,CAC9CE,IAAK,WACHwM,GAAkB,KAGtB7B,OAAOO,iBAAiB,cAAe,KAAMuB,GAC7C9B,OAAOQ,oBAAoB,cAAe,KAAMsB,GAChD,MAAOC,IAET,IAAIC,EAAoBH,EACpBI,EAAe,CAAC,aAAc,aAC9BC,EAAc,CAAC,YAAa,aAC5BC,EAAa,CAAC,WAAY,cAAe,UAAW,cACpDC,EAAe,CAAC,YAAa,YAAa,UAAW,cAu4BzD,SAASC,EAAgBC,GACvB,OAAIpH,EAASoH,IA7zFG7L,EA8zFE6L,EA7zFXpN,OAAOqN,KAAK9L,GAAK+L,OAAOC,QAAO,SAAUnN,EAAGoN,GAEjD,OADApN,EAAEoN,GAAKjM,EAAIiM,GACJpN,EAAEoN,GAAIpN,IACZ,MA4zFDwD,EAAK,wCAGA,IAn0FT,IAAkBrC,EA65FlB,IAAIkM,EAAa,CAEfC,KA9nEF,SAAc5F,EAAO4D,GACnB,IAAIgC,EAAO,CAMTrH,MAAO,WACLa,KAAKyG,KAAO7F,EAAMC,SAClBb,KAAK0G,MAAQ1G,KAAKyG,KAAKE,cAXR,2BAYf3G,KAAK4G,OAAS1H,MAAMlF,UAAU6M,MAAMtO,KAAKyH,KAAK8G,QAAQC,UAAUC,QAAO,SAAUC,GAC/E,OAAQA,EAAMC,UAAUC,SAASvG,EAAMf,SAAS9D,QAAQO,iBAgE9D,OA5DAmD,EAAO+G,EAAM,OAAQ,CAMnBvN,IAAK,WACH,OAAOuN,EAAKY,IAQdxF,IAAK,SAAa1I,GACZ2F,EAAS3F,KACXA,EAAImO,SAASV,cAAczN,IAGzByK,EAAMzK,GACRsN,EAAKY,GAAKlO,EAEVwD,EAAK,gDAIX+C,EAAO+G,EAAM,QAAS,CAMpBvN,IAAK,WACH,OAAOuN,EAAKzF,IAQda,IAAK,SAAatI,GACZqK,EAAMrK,GACRkN,EAAKzF,GAAKzH,EAEVoD,EAAK,kFAIX+C,EAAO+G,EAAM,UAAW,CAMtBvN,IAAK,WACH,OAAOuN,EAAKE,MAAMK,SAAS,MAGxBP,GAojEPc,UAnsCF,SAAmB1G,EAAO4D,EAAY+C,GACpC,IAAID,EAAY,CAOd1F,IAAK,SAAavI,GAChB,IAAImO,EAzCV,SAAiB5G,EAAO4D,EAAY+C,GAQlC,IAAIE,EAAe,CAAC5C,EAAKE,EAAMG,EAASG,GAAUqC,OAAO9G,EAAMG,GAAI,CAACwD,IACpE,MAAO,CAOLoD,OAAQ,SAAgBjD,GACtB,IAAK,IAAItM,EAAI,EAAGA,EAAIqP,EAAalK,OAAQnF,IAAK,CAC5C,IAAIwP,EAAcH,EAAarP,GAE3B2G,EAAW6I,IAAgB7I,EAAW6I,IAAcnD,QACtDC,EAAYkD,EAAYhH,EAAO4D,EAAY+C,GAAQ9C,OAAOC,GAE1DhI,EAAK,kFAIT,OAAOgI,IAcSmD,CAAQjH,EAAO4D,GAAYmD,OAAOtO,GAClDmL,EAAWgC,KAAKM,QAAQgB,MAAMN,UAAY,gBAAkB,EAAIA,EAAY,iBAQ9EjH,OAAQ,WACNiE,EAAWgC,KAAKM,QAAQgB,MAAMN,UAAY,KAwC9C,OA/BAD,EAAOnH,GAAG,QAAQ,SAAUI,GAC1B,IAAI3F,EAAM2J,EAAWM,KAAKzL,MACtBkE,EAASiH,EAAWe,MAAMhI,OAC1B+H,EAAQd,EAAWe,MAAMC,WAE7B,OAAI5E,EAAMmH,OAAO,aAAevD,EAAWpD,IAAI4G,SAAS,MACtDxD,EAAWjD,WAAW0G,OAAM,WAC1BV,EAAO9G,KAAK,kBACZ6G,EAAU1F,IAAI0D,GAAS/H,EAAS,OAE3B+J,EAAU1F,KAAK0D,EAAQzK,EAAM0C,IAGlCqD,EAAMmH,OAAO,aAAevD,EAAWpD,IAAI4G,SAAS,MACtDxD,EAAWjD,WAAW0G,OAAM,WAC1BV,EAAO9G,KAAK,kBACZ6G,EAAU1F,IAAI,MAET0F,EAAU1F,IAAI0D,EAAQ/H,EAAS1C,EAAM0C,IAGvC+J,EAAU1F,IAAIpB,EAAQ0H,aAO/BX,EAAOnH,GAAG,WAAW,WACnBkH,EAAU/G,YAEL+G,GAyoCP/F,WAtoCF,SAAoBX,EAAO4D,EAAY+C,GAOrC,IAAItG,GAAW,EACXM,EAAa,CAOf4G,QAAS,SAAiBpO,GACxB,IAAI8F,EAAWe,EAAMf,SAErB,OAAKoB,EAIElH,EAAW,QAAU8F,EAASnE,oBAH5B3B,EAAW,IAAMiG,KAAKoI,SAAW,MAAQvI,EAASnE,qBAY7DkG,IAAK,WACH,IAAI7H,EAAWgE,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,YACnFyG,EAAWgC,KAAKM,QAAQgB,MAAMO,WAAarI,KAAKmI,QAAQpO,IAQ1DwG,OAAQ,WACNiE,EAAWgC,KAAKM,QAAQgB,MAAMO,WAAa,IAS7CJ,MAAO,SAAeK,GACpBrF,YAAW,WACTqF,MACCtI,KAAKoI,WAQVG,OAAQ,WACNtH,GAAW,EACXjB,KAAK4B,OAQPJ,QAAS,WACPP,GAAW,EACXjB,KAAK4B,QAsDT,OAnDAnC,EAAO8B,EAAY,WAAY,CAO7BtI,IAAK,WACH,IAAI4G,EAAWe,EAAMf,SAErB,OAAIe,EAAMmH,OAAO,WAAavD,EAAWpD,IAAIoH,OACpC3I,EAASpE,eAGXoE,EAAStE,qBAQpBgM,EAAOnH,GAAG,QAAQ,WAChBmB,EAAWK,SASb2F,EAAOnH,GAAG,CAAC,eAAgB,SAAU,mBAAmB,WACtDmB,EAAWC,aAOb+F,EAAOnH,GAAG,OAAO,WACfmB,EAAWgH,YAObhB,EAAOnH,GAAG,WAAW,WACnBmB,EAAWhB,YAENgB,GAugCPoD,UA99CF,SAAmB/D,EAAO4D,EAAY+C,GACpC,IAAI5C,EAAY,CAMdxF,MAAO,WACLa,KAAK3G,MAAQuH,EAAMf,SAASjE,WAS9B6M,QAAS,SAAiBtH,GACxB,IAAIuH,EAAQvH,EAAQ0F,MAAM,EAAG,GAE7B,OAAI7G,KAAK4E,GAAG,OACHzD,EAAQwH,MAAMD,GAAOE,KAAKtE,EAAiBoE,IAG7CvH,GASTyD,GAAI,SAAYhJ,GACd,OAAOoE,KAAK3G,QAAUuC,GAQxBiN,SAAU,WACRrE,EAAWgC,KAAKC,KAAKS,UAAU4B,IAAIlI,EAAMf,SAAS9D,QAAQH,UAAUoE,KAAK3G,SAQ3E0P,YAAa,WACXvE,EAAWgC,KAAKC,KAAKS,UAAU3G,OAAOK,EAAMf,SAAS9D,QAAQH,UAAUoE,KAAK3G,UAqDhF,OAlDAoG,EAAOkF,EAAW,QAAS,CAMzB1L,IAAK,WACH,OAAO0L,EAAUqE,IASnBpH,IAAK,SAAavI,GACZgL,EAAiB4E,QAAQ5P,IAAU,EACrCsL,EAAUqE,GAAK3P,EAEfqD,EAAK,6CAUX6K,EAAOnH,GAAG,CAAC,UAAW,WAAW,WAC/BuE,EAAUoE,iBAOZxB,EAAOnH,GAAG,UAAU,WAClBuE,EAAUxF,WAQZoI,EAAOnH,GAAG,CAAC,eAAgB,WAAW,WACpCuE,EAAUkE,cAELlE,GAs3CPQ,KApjEF,SAAcvE,EAAO4D,EAAY+C,GAC/B,IAAIpC,EAAO,CAMThG,MAAO,WACLa,KAAK3G,MAAQuH,EAAMf,SAAShE,OAuDhC,OApDA4D,EAAO0F,EAAM,QAAS,CAMpBlM,IAAK,WACH,OAAOkM,EAAK6D,IASdpH,IAAK,SAAavI,GACZyF,EAASzF,IACXA,EAAM+L,OAASzG,EAAMtF,EAAM+L,QAC3B/L,EAAM4O,MAAQtJ,EAAMtF,EAAM4O,QAE1B5O,EAAQsF,EAAMtF,GAGhB8L,EAAK6D,GAAK3P,KAGdoG,EAAO0F,EAAM,WAAY,CAMvBlM,IAAK,WACH,IAAII,EAAQ8L,EAAK9L,MACbsB,EAAUiG,EAAMf,SAASlF,QAE7B,OAAImE,EAASzF,GACJA,EAAM+L,OAASzK,EAAUtB,EAAM4O,MAAQtN,EAGjC,EAARtB,EAAYsB,KAQvB4M,EAAOnH,GAAG,CAAC,SAAU,WAAW,WAC9B+E,EAAKhG,WAEAgG,GAs/DPI,MAz5DF,SAAe3E,EAAO4D,EAAY+C,GAChC,IAAIhC,EAAQ,CAMV2D,YAAa,WAIX,IAHA,IAAI5D,EAAQtF,KAAKwF,WAAa,KAC1BoB,EAASpC,EAAWgC,KAAKI,OAEpBxO,EAAI,EAAGA,EAAIwO,EAAOrJ,OAAQnF,IACjCwO,EAAOxO,GAAG0P,MAAMxC,MAAQA,GAS5B6D,aAAc,SAAsBC,GAClC5E,EAAWgC,KAAKM,QAAQgB,MAAMxC,MAAQtF,KAAKqJ,YAAc,MAQ3D9I,OAAQ,WAGN,IAFA,IAAIqG,EAASpC,EAAWgC,KAAKI,OAEpBxO,EAAI,EAAGA,EAAIwO,EAAOrJ,OAAQnF,IACjCwO,EAAOxO,GAAG0P,MAAMxC,MAAQ,GAG1Bd,EAAWgC,KAAKM,QAAQgB,MAAMxC,MAAQ,KA8D1C,OA3DA7F,EAAO8F,EAAO,SAAU,CAMtBtM,IAAK,WACH,OAAOuL,EAAWgC,KAAKI,OAAOrJ,UAGlCkC,EAAO8F,EAAO,QAAS,CAMrBtM,IAAK,WACH,OAAOuL,EAAWgC,KAAKC,KAAK6C,eAGhC7J,EAAO8F,EAAO,cAAe,CAM3BtM,IAAK,WACH,OAAOsM,EAAMC,WAAaD,EAAMhI,OAASiH,EAAWM,KAAKG,KAAOT,EAAWQ,OAAOC,QAGtFxF,EAAO8F,EAAO,aAAc,CAM1BtM,IAAK,WACH,OAAOsM,EAAMD,MAAQ1E,EAAMf,SAASlF,QAAU6J,EAAWW,KAAKoE,SAAW/E,EAAWM,KAAKyE,YAU7FhC,EAAOnH,GAAG,CAAC,eAAgB,SAAU,WAAW,WAC9CmF,EAAM2D,cACN3D,EAAM4D,kBAOR5B,EAAOnH,GAAG,WAAW,WACnBmF,EAAMhF,YAEDgF,GAuzDPT,KA5wEF,SAAclE,EAAO4D,EAAY+C,GAC/B,IAAIzC,EAAO,CAQTnC,MAAO,SAAeiE,GACpB,IAAK,IAAIxO,EAAI,EAAGoR,EAAM5C,EAAOrJ,OAAQnF,EAAIoR,EAAKpR,IAAK,CACjD,IAAI0P,EAAQlB,EAAOxO,GAAG0P,MAClBlM,EAAY4I,EAAWG,UAAUtL,MAGnCyO,EAAM3E,EAAYvH,GAAW,IADrB,IAANxD,EACiC4H,KAAK3G,MAAQ,EAAI,KAEjB,GAGjCjB,IAAMwO,EAAOrJ,OAAS,EACxBuK,EAAM3E,EAAYvH,GAAW,IAAMoE,KAAK3G,MAAQ,EAAI,KAEpDyO,EAAM3E,EAAYvH,GAAW,IAAM,KAWzC2E,OAAQ,SAAgBqG,GACtB,IAAK,IAAIxO,EAAI,EAAGoR,EAAM5C,EAAOrJ,OAAQnF,EAAIoR,EAAKpR,IAAK,CACjD,IAAI0P,EAAQlB,EAAOxO,GAAG0P,MACtBA,EAAM2B,WAAa,GACnB3B,EAAM4B,YAAc,MAsD1B,OAlDAjK,EAAOqF,EAAM,QAAS,CAMpB7L,IAAK,WACH,OAAO0F,EAAMiC,EAAMf,SAAShF,QAGhC4E,EAAOqF,EAAM,OAAQ,CAOnB7L,IAAK,WACH,OAAO6L,EAAKzL,OAASmL,EAAWe,MAAMhI,OAAS,MAGnDkC,EAAOqF,EAAM,WAAY,CAOvB7L,IAAK,WACH,IAAI0B,EAAUiG,EAAMf,SAASlF,QAC7B,OAAOmK,EAAKzL,OAASsB,EAAU,GAAKA,KASxC4M,EAAOnH,GAAG,CAAC,cAAe,UAAWzE,GAAS,WAC5CmJ,EAAKnC,MAAM6B,EAAWgC,KAAKM,QAAQC,YAClC,KAMHQ,EAAOnH,GAAG,WAAW,WACnB0E,EAAKvE,OAAOiE,EAAWgC,KAAKM,QAAQC,aAE/BjC,GAirEPrD,KAr/DF,SAAcb,EAAO4D,EAAY+C,GAC/B,IAAI9F,EAAO,CAMTtC,MAAO,WACLa,KAAK2B,GAAK,GASZN,KAAM,WACJ,IAAIsI,EAAQ3J,KAERwI,EAASzK,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,EACjFiC,KAAKwI,OAASA,EACdjB,EAAO9G,KAAK,OAAQ,CAClByH,SAAUlI,KAAK3G,QAEjBmL,EAAWjD,WAAW0G,OAAM,WAC1BV,EAAO9G,KAAK,aAAc,CACxByH,SAAUyB,EAAMtQ,aA4DxB,OAvDAoG,EAAOgC,EAAM,SAAU,CAMrBxI,IAAK,WACH,OAAOwI,EAAKE,IAQdC,IAAK,SAAavI,GAChBoI,EAAKE,GAAM3C,EAAY3F,GAAwB,EAAfsF,EAAMtF,MAG1CoG,EAAOgC,EAAM,YAAa,CAMxBxI,IAAK,WACH,OAAOuL,EAAWe,MAAMC,WAAa5E,EAAMP,SAG/CZ,EAAOgC,EAAM,QAAS,CAMpBxI,IAAK,WACH,IAAIuP,EAASxI,KAAKwI,OACd9D,EAAY1E,KAAK0E,UAErB,OAAIF,EAAWG,UAAUC,GAAG,OACnBF,EAAY8D,EAGd9D,EAAY8D,KASvBjB,EAAOnH,GAAG,CAAC,eAAgB,QAAQ,WACjCqB,EAAKJ,UAEAI,GA+5DPuD,OAnuDF,SAAgBpE,EAAO4D,EAAY+C,GACjC,IAAIvC,EAAS,CAIX7F,MAAO,WACLa,KAAK4J,MAAQ,GAEThJ,EAAMmH,OAAO,cACf/H,KAAK4J,MAAQ5J,KAAK6J,YAStBA,QAAS,WAWP,IAVA,IAAID,EAAQ7L,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GAC5E6I,EAASpC,EAAWgC,KAAKI,OACzBkD,EAAkBlJ,EAAMf,SACxBlF,EAAUmP,EAAgBnP,QAC1BoB,EAAU+N,EAAgB/N,QAC1BgO,KAAqBnJ,EAAMf,SAAShE,KACpCmO,EAAOrP,EAAUoP,EACjBE,EAAQrD,EAAOC,MAAM,EAAGmD,GACxBE,EAAMtD,EAAOC,OAAOmD,GAEf9Q,EAAI,EAAGA,EAAIiR,KAAKC,IAAI,EAAGD,KAAKE,MAAM1P,EAAUiM,EAAOrJ,SAAUrE,IAAK,CACzE,IAAK,IAAId,EAAI,EAAGA,EAAI6R,EAAM1M,OAAQnF,IAAK,CACrC,IAAIkS,EAAQL,EAAM7R,GAAGmS,WAAU,GAC/BD,EAAMpD,UAAU4B,IAAI/M,EAAQO,YAC5BsN,EAAMtJ,KAAKgK,GAGb,IAAK,IAAIzI,EAAK,EAAGA,EAAKqI,EAAI3M,OAAQsE,IAAM,CACtC,IAAI2I,EAASN,EAAIrI,GAAI0I,WAAU,GAE/BC,EAAOtD,UAAU4B,IAAI/M,EAAQO,YAE7BsN,EAAMa,QAAQD,IAIlB,OAAOZ,GAQTc,OAAQ,WAUN,IATA,IAAId,EAAQ5J,KAAK4J,MACbe,EAAmBnG,EAAWgC,KAC9BM,EAAU6D,EAAiB7D,QAC3BF,EAAS+D,EAAiB/D,OAC1BgE,EAAOT,KAAKE,MAAMT,EAAMrM,OAAS,GACjCsN,EAAUjB,EAAM/C,MAAM,EAAG+D,GAAME,UAC/BJ,EAASd,EAAM/C,MAAM+D,EAAMhB,EAAMrM,QACjC+H,EAAQd,EAAWe,MAAMC,WAAa,KAEjCpN,EAAI,EAAGA,EAAIsS,EAAOnN,OAAQnF,IACjC0O,EAAQiE,YAAYL,EAAOtS,IAG7B,IAAK,IAAI4S,EAAM,EAAGA,EAAMH,EAAQtN,OAAQyN,IACtClE,EAAQmE,aAAaJ,EAAQG,GAAMpE,EAAO,IAG5C,IAAK,IAAIsE,EAAM,EAAGA,EAAMtB,EAAMrM,OAAQ2N,IACpCtB,EAAMsB,GAAKpD,MAAMxC,MAAQA,GAS7B/E,OAAQ,WAGN,IAFA,IAAIqJ,EAAQ5J,KAAK4J,MAERxR,EAAI,EAAGA,EAAIwR,EAAMrM,OAAQnF,IAChCoM,EAAWgC,KAAKM,QAAQqE,YAAYvB,EAAMxR,MA0ChD,OAtCAqH,EAAOuF,EAAQ,OAAQ,CAMrB/L,IAAK,WACH,OAAQuL,EAAWe,MAAMC,WAAahB,EAAWM,KAAKzL,OAAS2L,EAAO4E,MAAMrM,UAQhFgK,EAAOnH,GAAG,UAAU,WAClB4E,EAAOzE,SACPyE,EAAO7F,QACP6F,EAAO0F,YAOTnD,EAAOnH,GAAG,gBAAgB,WACpBQ,EAAMmH,OAAO,aACf/C,EAAO0F,YAQXnD,EAAOnH,GAAG,WAAW,WACnB4E,EAAOzE,YAEFyE,GAqmDPoG,OA3hDF,SAAgBxK,EAAO4D,EAAY+C,GAMjC,IAAI8D,EAAS,IAAIvH,EACbsH,EAAS,CAIXjM,MAAO,WACLa,KAAKpG,QASPA,KAAM,WACJyR,EAAOjL,GAAG,SAAUwD,OAAQjI,GAAS,WACnC4L,EAAO9G,KAAK,YACXG,EAAMf,SAASlE,YAQpB2P,OAAQ,WACND,EAAOE,IAAI,SAAU3H,UAYzB,OAJA2D,EAAOnH,GAAG,WAAW,WACnBgL,EAAOE,SACPD,EAAOG,aAEFJ,GA++CPK,MAxzDF,SAAe7K,EAAO4D,EAAY+C,GAChC,IAAIkE,EAAQ,CAOVtM,MAAO,WACLoI,EAAO9G,KAAK,gBACZT,KAAK0L,YACL1L,KAAK2L,cACLpE,EAAO9G,KAAK,gBAQdiL,UAAW,WACTlH,EAAWgC,KAAKC,KAAKS,UAAU4B,IAAIlI,EAAMf,SAAS9D,QAAQ6E,EAAMf,SAASpF,QAQ3EkR,YAAa,WACX,IAAI5P,EAAU6E,EAAMf,SAAS9D,QACzBkL,EAAQzC,EAAWgC,KAAKI,OAAOhG,EAAMP,OAErC4G,IACFA,EAAMC,UAAU4B,IAAI/M,EAAQS,aAC5B4G,EAAS6D,GAAOvG,SAAQ,SAAUkL,GAChCA,EAAQ1E,UAAU3G,OAAOxE,EAAQS,kBAUvCqP,cAAe,WACb,IAAI9P,EAAU6E,EAAMf,SAAS9D,QAC7ByI,EAAWgC,KAAKC,KAAKS,UAAU3G,OAAOxE,EAAQ6E,EAAMf,SAASpF,OAC7D+J,EAAWgC,KAAKI,OAAOlG,SAAQ,SAAUkL,GACvCA,EAAQ1E,UAAU3G,OAAOxE,EAAQS,kBA8BvC,OApBA+K,EAAOnH,GAAG,CAAC,UAAW,WAAW,WAC/BqL,EAAMI,mBAQRtE,EAAOnH,GAAG,CAAC,SAAU,WAAW,WAC9BqL,EAAMtM,WAORoI,EAAOnH,GAAG,cAAc,WACtBqL,EAAME,iBAEDF,GAyuDPrK,IAnhFF,SAAaR,EAAO4D,EAAY+C,GAC9B,IAAInG,EAAM,CAMRjC,MAAO,WACLa,KAAK2B,IAAK,GAQZN,KAAM,SAAcyK,GAClB,IAAInC,EAAQ3J,KAEPY,EAAMK,WACTL,EAAMY,UACNxB,KAAK8L,KAAOA,EACZvE,EAAO9G,KAAK,aAAcT,KAAK8L,MAC/B9L,KAAK+L,YACLxE,EAAO9G,KAAK,MAAOT,KAAK8L,MACxBtH,EAAWjD,WAAW0G,OAAM,WACtB0B,EAAMqC,WACRzE,EAAO9G,KAAK,YAAakJ,EAAMmC,MAG7BnC,EAAMsC,SACR1E,EAAO9G,KAAK,UAAWkJ,EAAMmC,OAG3BnC,EAAM3B,SAAS,MAAQ2B,EAAM3B,SAAS,QACxC2B,EAAMhI,IAAK,EACX4F,EAAO9G,KAAK,aAAckJ,EAAMmC,OAGlCvE,EAAO9G,KAAK,YAAakJ,EAAMmC,MAC/BlL,EAAM2H,cAUZwD,UAAW,WACT,IAAID,EAAO9L,KAAK8L,KACZvO,EAASyC,KAAKzC,OACd2O,EAAQJ,EAAKI,MACbtQ,EAAYkQ,EAAKlQ,UACjBuQ,EApiBgB,kBAoiBUxN,EAAMuN,IAA4B,IAAjBvN,EAAMuN,GAErD,OAAQtQ,GACN,IAAK,IACW,MAAVsQ,EACFtL,EAAMP,MAAQ9C,EACLyC,KAAKiM,QACRrL,EAAMmH,OAAO,YAAcnH,EAAMf,SAASrE,SAC9CwE,KAAK2B,IAAK,EACVf,EAAMP,MAAQ,GAEP8L,EACTvL,EAAMP,OAAS8J,KAAKiC,IAAI7O,EAASqD,EAAMP,OAAQ1B,EAAMuN,IAErDtL,EAAMP,QAGR,MAEF,IAAK,IACW,MAAV6L,EACFtL,EAAMP,MAAQ,EACLL,KAAKgM,UACRpL,EAAMmH,OAAO,YAAcnH,EAAMf,SAASrE,SAC9CwE,KAAK2B,IAAK,EACVf,EAAMP,MAAQ9C,GAEP4O,EACTvL,EAAMP,OAAS8J,KAAKiC,IAAIxL,EAAMP,MAAO1B,EAAMuN,IAE3CtL,EAAMP,QAGR,MAEF,IAAK,IACHO,EAAMP,MAAQ6L,EACd,MAEF,QACExP,EAAK,8BAAgCd,EAAYsQ,EAAQ,qBAU/DF,QAAS,WACP,OAAuB,IAAhBpL,EAAMP,OAQf4L,MAAO,WACL,OAAOrL,EAAMP,QAAUL,KAAKzC,QAS9ByK,SAAU,SAAkBpM,GAC1B,OAAOoE,KAAK2B,IAAM3B,KAAK8L,KAAKlQ,YAAcA,IAwD9C,OArDA6D,EAAO2B,EAAK,OAAQ,CAMlBnI,IAAK,WACH,OAAO+G,KAAKqM,IAQdzK,IAAK,SAAavI,GAChB,IAAIiT,EAAOjT,EAAMkT,OAAO,GACxBvM,KAAKqM,GAAK,CACRzQ,UAAWvC,EAAMkT,OAAO,EAAG,GAC3BL,MAAOI,EAAO3N,EAAM2N,GAAQ3N,EAAM2N,GAAQA,EAAO,MAIvD7M,EAAO2B,EAAK,SAAU,CAOpBnI,IAAK,WACH,IAAI4G,EAAWe,EAAMf,SACjBtC,EAASiH,EAAWgC,KAAKI,OAAOrJ,OAIpC,OAAIqD,EAAMmH,OAAO,WAAkC,WAArBlI,EAASjF,SAAwBiF,EAAS5E,MAC/DsC,EAAS,GAAKoB,EAAMkB,EAASlF,SAAW,GAAKgE,EAAMkB,EAASjF,SAG9D2C,EAAS,KAGpBkC,EAAO2B,EAAK,SAAU,CAMpBnI,IAAK,WACH,OAAO+G,KAAK2B,MAGTP,GAg2EPoL,MAr/BF,SAAe5L,EAAO4D,EAAY+C,GAMhC,IAAI8D,EAAS,IAAIvH,EACb2I,EAAW,EACXC,EAAc,EACdC,EAAc,EACd1L,GAAW,EACXiD,IAAU0B,GAAoB,CAChCgH,SAAS,GAEPJ,EAAQ,CAMVrN,MAAO,WACLa,KAAK6M,kBASP5C,MAAO,SAAe/J,GACpB,IAAKe,IAAaL,EAAMK,SAAU,CAChCjB,KAAKwB,UACL,IAAIsL,EAAQ9M,KAAK+M,QAAQ7M,GACzBuM,EAAW,KACXC,EAAc/N,EAAMmO,EAAME,OAC1BL,EAAchO,EAAMmO,EAAMG,OAC1BjN,KAAKkN,gBACLlN,KAAKmN,eACL5F,EAAO9G,KAAK,iBAShBqL,KAAM,SAAc5L,GAClB,IAAKU,EAAMK,SAAU,CACnB,IAAI6I,EAAkBlJ,EAAMf,SACxBvE,EAAawO,EAAgBxO,WAC7BD,EAAayO,EAAgBzO,WAC7BU,EAAU+N,EAAgB/N,QAC1B+Q,EAAQ9M,KAAK+M,QAAQ7M,GACrBkN,EAAUzO,EAAMmO,EAAME,OAASN,EAC/BW,EAAU1O,EAAMmO,EAAMG,OAASN,EAC/BW,EAAQnD,KAAKoD,IAAIH,GAAW,GAC5BI,EAAQrD,KAAKoD,IAAIF,GAAW,GAC5BI,EAAkBtD,KAAKuD,KAAKJ,EAAQE,GACpCG,EAAgBxD,KAAKuD,KAAKF,GAG9B,KAAe,KAFff,EAAWtC,KAAKyD,KAAKD,EAAgBF,IAEhBtD,KAAK0D,GAAKvS,GAM7B,OAAO,EALP4E,EAAM4N,kBACNtJ,EAAW/C,KAAKJ,KAAK+L,EAlnEtBW,WAknEwC1S,IACvCmJ,EAAWgC,KAAKC,KAAKS,UAAU4B,IAAI/M,EAAQM,UAC3CkL,EAAO9G,KAAK,gBAalByJ,IAAK,SAAahK,GAChB,IAAKU,EAAMK,SAAU,CACnB,IAAIpB,EAAWe,EAAMf,SACjBiN,EAAQ9M,KAAK+M,QAAQ7M,GACrB8N,EAAYhO,KAAKgO,UAAU9N,GAC3B+N,EAAgBnB,EAAME,MAAQN,EAC9BwB,EAAsB,IAAXzB,EAAiBtC,KAAK0D,GACjC3B,EAAQ/B,KAAKgE,MAAMF,EAAgBzJ,EAAWe,MAAMC,YACxDxF,KAAKuI,SAED0F,EAAgBD,GAAaE,EAAWrO,EAASvE,YAE/CuE,EAASzE,WACX8Q,EAAQ/B,KAAKiC,IAAIF,EAAOvN,EAAMkB,EAASzE,YAGrCoJ,EAAWG,UAAUC,GAAG,SAC1BsH,GAASA,GAGX1H,EAAWpD,IAAIC,KAAKmD,EAAWG,UAAU8D,QAAQ,IAAMyD,KAC9C+B,GAAiBD,GAAaE,EAAWrO,EAASvE,YAEvDuE,EAASzE,WACX8Q,EAAQ/B,KAAKC,IAAI8B,GAAQvN,EAAMkB,EAASzE,YAGtCoJ,EAAWG,UAAUC,GAAG,SAC1BsH,GAASA,GAGX1H,EAAWpD,IAAIC,KAAKmD,EAAWG,UAAU8D,QAAQ,IAAMyD,KAGvD1H,EAAW/C,KAAKJ,OAGlBmD,EAAWgC,KAAKC,KAAKS,UAAU3G,OAAOV,EAAS9D,QAAQM,UACvD2D,KAAKoO,kBACLpO,KAAKqO,iBACL9G,EAAO9G,KAAK,eAShBoM,eAAgB,WACd,IAAIlD,EAAQ3J,KAERH,EAAWe,EAAMf,SAEjBA,EAAS3E,gBACXmQ,EAAOjL,GAAGyF,EAAa,GAAIrB,EAAWgC,KAAKM,SAAS,SAAU5G,GAC5DyJ,EAAMM,MAAM/J,KACXgE,GAGDrE,EAAS1E,eACXkQ,EAAOjL,GAAGyF,EAAa,GAAIrB,EAAWgC,KAAKM,SAAS,SAAU5G,GAC5DyJ,EAAMM,MAAM/J,KACXgE,IASPoK,iBAAkB,WAChBjD,EAAOE,IAAI1F,EAAa,GAAIrB,EAAWgC,KAAKM,QAAS5C,GACrDmH,EAAOE,IAAI1F,EAAa,GAAIrB,EAAWgC,KAAKM,QAAS5C,IAQvDgJ,cAAe,WACb,IAAIqB,EAASvO,KAEbqL,EAAOjL,GAAG0F,EAAatB,EAAWgC,KAAKM,QAASnL,GAAS,SAAUuE,GACjEqO,EAAOzC,KAAK5L,KACXU,EAAMf,SAASlE,UAAWuI,IAQ/BkK,gBAAiB,WACf/C,EAAOE,IAAIzF,EAAatB,EAAWgC,KAAKM,QAAS5C,IAQnDiJ,aAAc,WACZ,IAAIqB,EAASxO,KAEbqL,EAAOjL,GAAG2F,EAAYvB,EAAWgC,KAAKM,SAAS,SAAU5G,GACvDsO,EAAOtE,IAAIhK,OASfmO,eAAgB,WACdhD,EAAOE,IAAIxF,EAAYvB,EAAWgC,KAAKM,UAQzCiG,QAAS,SAAiB7M,GACxB,OAAI8F,EAAaiD,QAAQ/I,EAAMzF,OAAS,EAC/ByF,EAGFA,EAAM6M,QAAQ,IAAM7M,EAAMuO,eAAe,IAQlDT,UAAW,SAAmB9N,GAC5B,IAAIL,EAAWe,EAAMf,SAErB,OAAImG,EAAaiD,QAAQ/I,EAAMzF,OAAS,EAC/BoF,EAAS1E,cAGX0E,EAAS3E,gBAQlBqN,OAAQ,WAGN,OAFAtH,GAAW,EACXuD,EAAWjD,WAAWgH,SACfvI,MAQTwB,QAAS,WAGP,OAFAP,GAAW,EACXuD,EAAWjD,WAAWC,UACfxB,OAsBX,OAdAuH,EAAOnH,GAAG,eAAe,WACvBoE,EAAWgC,KAAKC,KAAKS,UAAU4B,IAAIlI,EAAMf,SAAS9D,QAAQK,cAO5DmL,EAAOnH,GAAG,WAAW,WACnBoM,EAAM8B,mBACN9B,EAAM4B,kBACN5B,EAAM6B,iBACNhD,EAAOG,aAEFgB,GAwuBPkC,OAruBF,SAAgB9N,EAAO4D,EAAY+C,GAMjC,IAAI8D,EAAS,IAAIvH,EACb4K,EAAS,CAMXvP,MAAO,WACLa,KAAKpG,QAQPA,KAAM,WACJyR,EAAOjL,GAAG,YAAaoE,EAAWgC,KAAKM,QAAS9G,KAAK2O,YAQvDrD,OAAQ,WACND,EAAOE,IAAI,YAAa/G,EAAWgC,KAAKM,UAQ1C6H,UAAW,SAAmBzO,GAC5BA,EAAM0O,mBAYV,OAJArH,EAAOnH,GAAG,WAAW,WACnBsO,EAAOpD,SACPD,EAAOG,aAEFkD,GAirBPG,QA9qBF,SAAiBjO,EAAO4D,EAAY+C,GAMlC,IAAI8D,EAAS,IAAIvH,EASbgL,GAAW,EASXC,GAAY,EACZF,EAAU,CAMZ1P,MAAO,WAOLa,KAAKgP,GAAKxK,EAAWgC,KAAKM,QAAQmI,iBAAiB,KACnDjP,KAAKpG,QAQPA,KAAM,WACJyR,EAAOjL,GAAG,QAASoE,EAAWgC,KAAKM,QAAS9G,KAAKkP,QAQnD5D,OAAQ,WACND,EAAOE,IAAI,QAAS/G,EAAWgC,KAAKM,UAStCoI,MAAO,SAAehP,GAChB6O,IACF7O,EAAM4N,kBACN5N,EAAM0O,mBASVO,OAAQ,WAGN,GAFAJ,GAAY,GAEPD,EAAU,CACb,IAAK,IAAI1W,EAAI,EAAGA,EAAI4H,KAAK4J,MAAMrM,OAAQnF,IACrC4H,KAAK4J,MAAMxR,GAAGgX,WAAY,EAC1BpP,KAAK4J,MAAMxR,GAAGiX,aAAa,YAAarP,KAAK4J,MAAMxR,GAAGkX,aAAa,SACnEtP,KAAK4J,MAAMxR,GAAGmX,gBAAgB,QAGhCT,GAAW,EAGb,OAAO9O,MAQTwP,OAAQ,WAGN,GAFAT,GAAY,EAERD,EAAU,CACZ,IAAK,IAAI1W,EAAI,EAAGA,EAAI4H,KAAK4J,MAAMrM,OAAQnF,IACrC4H,KAAK4J,MAAMxR,GAAGgX,WAAY,EAC1BpP,KAAK4J,MAAMxR,GAAGiX,aAAa,OAAQrP,KAAK4J,MAAMxR,GAAGkX,aAAa,cAGhER,GAAW,EAGb,OAAO9O,OAyCX,OAtCAP,EAAOoP,EAAS,QAAS,CAMvB5V,IAAK,WACH,OAAO4V,EAAQG,MAQnBzH,EAAOnH,GAAG,cAAc,WACtByO,EAAQM,YAOV5H,EAAOnH,GAAG,aAAa,WACrBoE,EAAWjD,WAAW0G,OAAM,WAC1B4G,EAAQW,eAQZjI,EAAOnH,GAAG,WAAW,WACnByO,EAAQW,SACRX,EAAQvD,SACRD,EAAOG,aAEFqD,GAuhBPY,SAjhBF,SAAkB7O,EAAO4D,EAAY+C,GAMnC,IAAI8D,EAAS,IAAIvH,EACbI,IAAU0B,GAAoB,CAChCgH,SAAS,GAEP6C,EAAW,CAObtQ,MAAO,WAOLa,KAAK0P,GAAKlL,EAAWgC,KAAKC,KAAKwI,iBA3BlB,mCAmCbjP,KAAKc,GAAK0D,EAAWgC,KAAKC,KAAKwI,iBAlCb,+BAmClBjP,KAAK2P,eAQPC,UAAW,WACT,IAAK,IAAIxX,EAAI,EAAGA,EAAI4H,KAAK0P,GAAGnS,OAAQnF,IAClC4H,KAAK6I,SAAS7I,KAAK0P,GAAGtX,GAAG2O,WAS7B8I,aAAc,WACZ,IAAK,IAAIzX,EAAI,EAAGA,EAAI4H,KAAK0P,GAAGnS,OAAQnF,IAClC4H,KAAK+I,YAAY/I,KAAK0P,GAAGtX,GAAG2O,WAUhC8B,SAAU,SAAkBiH,GAC1B,IAAIjQ,EAAWe,EAAMf,SACjBc,EAAOmP,EAASlP,EAAMP,OAEtBM,IACFA,EAAKuG,UAAU4B,IAAIjJ,EAAS9D,QAAQQ,WACpC6G,EAASzC,GAAMD,SAAQ,SAAUkL,GAC/BA,EAAQ1E,UAAU3G,OAAOV,EAAS9D,QAAQQ,gBAWhDwM,YAAa,SAAqB+G,GAChC,IAAInP,EAAOmP,EAASlP,EAAMP,OAEtBM,GACFA,EAAKuG,UAAU3G,OAAOK,EAAMf,SAAS9D,QAAQQ,YASjDoT,YAAa,WACX,IAAK,IAAIvX,EAAI,EAAGA,EAAI4H,KAAKc,GAAGvD,OAAQnF,IAClC4H,KAAKpG,KAAKoG,KAAKc,GAAG1I,GAAG2O,WASzBgJ,eAAgB,WACd,IAAK,IAAI3X,EAAI,EAAGA,EAAI4H,KAAKc,GAAGvD,OAAQnF,IAClC4H,KAAKsL,OAAOtL,KAAKc,GAAG1I,GAAG2O,WAU3BnN,KAAM,SAAcoW,GAClB,IAAK,IAAI5X,EAAI,EAAGA,EAAI4X,EAASzS,OAAQnF,IACnCiT,EAAOjL,GAAG,QAAS4P,EAAS5X,GAAI4H,KAAKkP,OACrC7D,EAAOjL,GAAG,aAAc4P,EAAS5X,GAAI4H,KAAKkP,MAAOhL,IAUrDoH,OAAQ,SAAgB0E,GACtB,IAAK,IAAI5X,EAAI,EAAGA,EAAI4X,EAASzS,OAAQnF,IACnCiT,EAAOE,IAAI,CAAC,QAAS,cAAeyE,EAAS5X,KAYjD8W,MAAO,SAAehP,GACpBA,EAAM0O,iBACNpK,EAAWpD,IAAIC,KAAKmD,EAAWG,UAAU8D,QAAQvI,EAAM+P,cAAcX,aAAa,sBAgCtF,OA7BA7P,EAAOgQ,EAAU,QAAS,CAMxBxW,IAAK,WACH,OAAOwW,EAAS3O,MASpByG,EAAOnH,GAAG,CAAC,cAAe,eAAe,WACvCqP,EAASG,eAOXrI,EAAOnH,GAAG,WAAW,WACnBqP,EAASM,iBACTN,EAASI,eACTxE,EAAOG,aAEFiE,GA+VPS,SA5VF,SAAkBtP,EAAO4D,EAAY+C,GAMnC,IAAI8D,EAAS,IAAIvH,EACboM,EAAW,CAMb/Q,MAAO,WACDyB,EAAMf,SAAS7E,UACjBgF,KAAKpG,QASTA,KAAM,WACJyR,EAAOjL,GAAG,QAASiH,SAAUrH,KAAKmQ,QAQpC7E,OAAQ,WACND,EAAOE,IAAI,QAASlE,WAStB8I,MAAO,SAAejQ,GACE,KAAlBA,EAAMkQ,SACR5L,EAAWpD,IAAIC,KAAKmD,EAAWG,UAAU8D,QAAQ,MAG7B,KAAlBvI,EAAMkQ,SACR5L,EAAWpD,IAAIC,KAAKmD,EAAWG,UAAU8D,QAAQ,QA6BvD,OAnBAlB,EAAOnH,GAAG,CAAC,UAAW,WAAW,WAC/B8P,EAAS5E,YAOX/D,EAAOnH,GAAG,UAAU,WAClB8P,EAAS/Q,WAOXoI,EAAOnH,GAAG,WAAW,WACnBiL,EAAOG,aAEF0E,GA+QPG,SA5QF,SAAkBzP,EAAO4D,EAAY+C,GAMnC,IAAI8D,EAAS,IAAIvH,EACbuM,EAAW,CAMblR,MAAO,WACLa,KAAKiK,QAEDrJ,EAAMf,SAAS9E,YACjBiF,KAAKpG,QAUTqQ,MAAO,WACL,IAAIN,EAAQ3J,KAERY,EAAMf,SAAS/E,UACbkE,EAAYgB,KAAK6B,MACnB7B,KAAK6B,GAAKyO,aAAY,WACpB3G,EAAM4G,OAEN/L,EAAWpD,IAAIC,KAAK,KAEpBsI,EAAMM,UACLjK,KAAKwQ,QAUdD,KAAM,WACJvQ,KAAK6B,GAAK4O,cAAczQ,KAAK6B,KAQ/BjI,KAAM,WACJ,IAAI2U,EAASvO,KAEbqL,EAAOjL,GAAG,YAAaoE,EAAWgC,KAAKC,MAAM,WAC3C8H,EAAOgC,UAETlF,EAAOjL,GAAG,WAAYoE,EAAWgC,KAAKC,MAAM,WAC1C8H,EAAOtE,YASXqB,OAAQ,WACND,EAAOE,IAAI,CAAC,YAAa,YAAa/G,EAAWgC,KAAKC,QAmE1D,OAhEAhH,EAAO4Q,EAAU,OAAQ,CAOvBpX,IAAK,WACH,IAAI6B,EAAW0J,EAAWgC,KAAKI,OAAOhG,EAAMP,OAAOiP,aAAa,uBAEhE,OACS3Q,EADL7D,GAIS8F,EAAMf,SAAS/E,aAShCyM,EAAOnH,GAAG,CAAC,UAAW,WAAW,WAC/BiQ,EAAS/E,YAWX/D,EAAOnH,GAAG,CAAC,aAAc,QAAS,UAAW,cAAe,WAAW,WACrEiQ,EAASE,UASXhJ,EAAOnH,GAAG,CAAC,YAAa,OAAQ,cAAc,WAC5CiQ,EAASpG,WAOX1C,EAAOnH,GAAG,UAAU,WAClBiQ,EAASlR,WAOXoI,EAAOnH,GAAG,WAAW,WACnBiL,EAAOG,aAEF6E,GAgIPK,YA5GF,SAAqB9P,EAAO4D,EAAY+C,GAMtC,IAAI8D,EAAS,IAAIvH,EAObjE,EAAWe,EAAMf,SASjBqG,EAASD,EAAgBpG,EAAS/D,aAOlCtB,EAAWqD,EAAS,GAAIgC,GAExB6Q,EAAc,CAOhBC,MAAO,SAAezK,GACpB,GAAiC,qBAAtBtC,OAAOgN,WAChB,IAAK,IAAIC,KAAS3K,EAChB,GAAIA,EAAOjM,eAAe4W,IACpBjN,OAAOgN,WAAW,eAAiBC,EAAQ,OAAOC,QACpD,OAAO5K,EAAO2K,GAMtB,OAAOrW,IAmCX,OA3BAqD,EAASgC,EAAU6Q,EAAYC,MAAMzK,IAOrCmF,EAAOjL,GAAG,SAAUwD,OAAQjI,GAAS,WACnCiF,EAAMf,SAAWD,EAAaC,EAAU6Q,EAAYC,MAAMzK,MACzDtF,EAAMf,SAASlE,WAMlB4L,EAAOnH,GAAG,UAAU,WAClB8F,EAASD,EAAgBC,GACzB1L,EAAWqD,EAAS,GAAIgC,MAO1B0H,EAAOnH,GAAG,WAAW,WACnBiL,EAAOE,IAAI,SAAU3H,WAEhB8M,IA2BLK,EAAU,SAAUC,GAGtB,SAASC,IAEP,OADAlU,EAAeiD,KAAMiR,GACdzS,EAA0BwB,MAAOiR,EAASC,WAAapY,OAAOyF,eAAe0S,IAAWtO,MAAM3C,KAAMjC,YAU7G,OA3mGa,SAAkBoT,EAAUC,GACzC,GAA0B,oBAAfA,GAA4C,OAAfA,EACtC,MAAM,IAAIlU,UAAU,2DAA6D9C,EAASgX,IAG5FD,EAASnX,UAAYlB,OAAOY,OAAO0X,GAAcA,EAAWpX,UAAW,CACrEO,YAAa,CACXlB,MAAO8X,EACPnY,YAAY,EACZ0E,UAAU,EACVD,cAAc,KAGd2T,IAAYtY,OAAOuY,eAAiBvY,OAAOuY,eAAeF,EAAUC,GAAcD,EAASD,UAAYE,GAglG3GE,CAASL,EAAUD,GAOnB7T,EAAY8T,EAAU,CAAC,CACrBtX,IAAK,QACLN,MAAO,WACL,IAAIgG,EAAatB,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GACrF,OAAO9E,EAAIgY,EAASjX,UAAUkX,WAAapY,OAAOyF,eAAe0S,EAASjX,WAAY,QAASgG,MAAMzH,KAAKyH,KAAMnC,EAAS,GAAI0I,EAAYlH,QAGtI4R,EAfK,CAgBZrQ,GAEa,O,cC/4GfzI,EAAOD,QAAU,SAAUC,GAsBzB,OArBKA,EAAOoZ,kBACVpZ,EAAOqZ,UAAY,aAEnBrZ,EAAOsZ,MAAQ,GAEVtZ,EAAO4O,WAAU5O,EAAO4O,SAAW,IACxCjO,OAAOC,eAAeZ,EAAQ,SAAU,CACtCa,YAAY,EACZC,IAAK,WACH,OAAOd,EAAOE,KAGlBS,OAAOC,eAAeZ,EAAQ,KAAM,CAClCa,YAAY,EACZC,IAAK,WACH,OAAOd,EAAOC,KAGlBD,EAAOoZ,gBAAkB,GAGpBpZ,I,6BCtBT,8BAKAuZ,EAAQ,GAAczH,QACtByH,EAAQ,GAAwBzH,QAChCyH,EAAQ,GACRC,EAAOC,EAAIF,EAAQ,GACnB9N,OAAOiO,OAASD,EAChBhO,OAAOgO,EAAIA,EAKXvK,SAASlD,iBAAiB,oBAAoB,WAE1CyN,EAAE,uBAAuBxR,GAAG,aAAa,SAAUuF,GAC/CiM,EAAE5R,MAAM1B,SAASwT,KAAK,yBAAyBC,MAAM,WAGzD,IAAIC,EAAe,IAAIpR,IAAM,kBAAmB,CAC5CnG,KAAM,WACNE,QAAS,EACTG,SAAU,MAGVmX,EAAU,IAAIrR,IAAM,kBAAmB,CACvCnG,KAAM,WACNE,QAAS,EACTG,SAAU,MAGdkX,EAAa7S,QACb8S,EAAQ9S,Y,+BClCZ,SAASrC,EAAQzC,GAAmV,OAAtOyC,EAArD,oBAAX3D,QAAoD,kBAApBA,OAAOmB,SAAmC,SAAiBD,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXlB,QAAyBkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,IAAyBA,GAEnX,IAAI6X,EAEJA,EAAI,WACF,OAAOlS,KADL,GAIJ,IAEEkS,EAAIA,GAAK,IAAIhU,SAAS,cAAb,GACT,MAAOyH,GAEiE,YAAjD,qBAAX/B,OAAyB,YAAc9G,EAAQ8G,WAAuBsO,EAAItO,QAMxFzL,EAAOD,QAAUga,G,iBCnBjB,kCAAoW,OAAtOpV,EAArD,oBAAX3D,QAAoD,kBAApBA,OAAOmB,SAAmC,SAAiBD,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXlB,QAAyBkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,IAAyBA,IAQnX,YAEE,YACE,WACE2F,KAAKmS,MAAQ,CACXC,kBAAmB,yGACnBC,oBAAqB,CACnBxR,SAAU,oEACVyR,QAAS,eAEXC,oBAAqB,iEACrBC,mBAAoB,OACpBC,uBAAwB,6MACxBC,oBAAqB,sMACrBC,mBAAoB,4MACpBC,kBAAmB,yCACnBC,oBAAqB,wCACrBC,sBAAuB,+EAExBva,KAAKyH,QACPzH,KAnBWyH,MAoBd,IAAImS,EApBUnS,KAoBMmS,OACpB,YACE,WACE,IAAIY,EACJA,EAAQ,KAERZ,EAAMa,aAAe,WACnB,IAAIC,EACJ,OAAOF,EAAkE,OAAzDE,EAAM5L,SAASV,cAAc,yBAAmCsM,EAAIC,aAAU,GAGhGf,EAAMgB,SAAW,WACf,OAAgB,MAATJ,EAAgBA,EAAQZ,EAAMa,kBAEtCza,KAAKyH,MACR,WACE,IAAaxH,EACbA,EAAI4a,QAAQpZ,UAAU8W,SAAWsC,QAAQpZ,UAAUqZ,iBAAmBD,QAAQpZ,UAAUsZ,oBAAsBF,QAAQpZ,UAAUuZ,mBAAqBH,QAAQpZ,UAAUwZ,kBAAoBJ,QAAQpZ,UAAUyZ,sBAE7MtB,EAAMrB,QAAU,SAAU4C,EAAS7S,GACjC,OAAwB,MAApBA,EAASyR,QACJ9Z,EAAED,KAAKmb,EAAS7S,EAASA,YAAcrI,EAAED,KAAKmb,EAAS7S,EAASyR,SAEhE9Z,EAAED,KAAKmb,EAAS7S,IAM3BsR,EAAMwB,QAAU,SAAUD,EAAS/Z,GACjC,IAAIsZ,EACJ,OAAmC,OAA3BA,EAAMS,EAAe,UAAaT,EAAItZ,QAAO,GAGvDwY,EAAMyB,QAAU,SAAUF,EAAS/Z,EAAKN,GAKtC,OAJwB,MAApBqa,EAAe,WACjBA,EAAe,SAAI,IAGdA,EAAe,SAAE/Z,GAAON,GAGjC8Y,EAAMP,EAAI,SAAU/Q,GAClB,OAAO3B,MAAMlF,UAAU6M,MAAMtO,KAAK8O,SAAS4H,iBAAiBpO,MAE7DtI,KAAKyH,MACR,WACE,IAAI4R,EAAGiC,EAAWC,EAClBlC,EAAIO,EAAMP,EAEVkC,EAAY3B,EAAM2B,UAAY,WAC5B,IAAIC,EAEJ,OADAA,EAAO1M,SAASV,cAAc,2BACfoN,EAAKb,SAGtBW,EAAY1B,EAAM0B,UAAY,WAC5B,IAAIE,EAEJ,OADAA,EAAO1M,SAASV,cAAc,2BACfoN,EAAKb,SAGtBf,EAAM6B,eAAiB,SAAUC,GAC/B,IAAIvL,EAGJ,GAAa,OAFbA,EAAQoL,KAGN,OAAOG,EAAIC,iBAAiB,eAAgBxL,IAIhDyJ,EAAMgC,kBAAoB,WACxB,IAAIC,EAAO1L,EAIX,GAHAA,EAAQoL,IACRM,EAAQP,IAEK,MAATnL,GAA0B,MAAT0L,EACnB,OAAOxC,EAAE,oBAAsBwC,EAAQ,MAAM1T,SAAQ,SAAU2T,GAC7D,OAAOA,EAAMhb,MAAQqP,OAI1BnQ,KAAKyH,MACR,WACE,IAAIsU,EAAaC,EAAMzD,EAASlC,EAChCkC,EAAUqB,EAAMrB,QAGW,oBAF3BwD,EAAc1Q,OAAO0Q,gBAGnBA,EAAc,SAAqBpU,EAAOsU,GACxC,IAAIC,EAGJ,OAFAA,EAAMpN,SAASqN,YAAY,gBACvBC,gBAAgBzU,EAAOsU,EAAOI,QAASJ,EAAOK,WAAYL,EAAOM,QAC9DL,IAGGza,UAAY4J,OAAOmR,MAAM/a,UACrC4U,EAAiB0F,EAAYta,UAAU4U,eAEvC0F,EAAYta,UAAU4U,eAAiB,WACrC,IAAIrM,EAWJ,OAVAA,EAASqM,EAAerW,KAAKyH,MAEzBA,KAAK6U,aAAe7U,KAAKgV,kBAC3Blc,OAAOC,eAAeiH,KAAM,mBAAoB,CAC9C/G,IAAK,WACH,OAAO,KAKNsJ,IAIXgS,EAAOpC,EAAMoC,KAAO,SAAUla,EAAK1B,EAAMsc,GACvC,IAAI/U,EAOJ,OANAA,EAAQ,IAAIoU,EAAY3b,EAAM,CAC5Bic,SAAS,EACTC,YAAY,EACZC,OAAQG,IAEV5a,EAAI6a,cAAchV,IACVA,EAAM8U,kBAGhB7C,EAAMgD,eAAiB,SAAUxP,GAI/B,OAHA4O,EAAK5O,EAAEtI,OAAQ,yBACfsI,EAAEiJ,iBACFjJ,EAAEmI,kBACKnI,EAAEyP,4BAGXjD,EAAMkD,SAAW,SAAU3B,EAAS7S,EAAUyU,EAAWnV,GACvD,OAAOuT,EAAQvP,iBAAiBmR,GAAW,SAAU3P,GACnD,IAAItI,EAGJ,IAFAA,EAASsI,EAAEtI,OAEAA,aAAkB+V,UAAYtC,EAAQzT,EAAQwD,IACvDxD,EAASA,EAAOiG,WAGlB,GAAIjG,aAAkB+V,UAAuC,IAA5BjT,EAAQ5H,KAAK8E,EAAQsI,GAEpD,OADAA,EAAEiJ,iBACKjJ,EAAEmI,uBAIdvV,KAAKyH,MACR,WACE,IAAIuV,EAAevB,EAAgBwB,EAAWrC,EAAgBsC,EAAgBC,EAC9EvC,EAAWhB,EAAMgB,SAAUa,EAAiB7B,EAAM6B,eAAuB7B,EAAMoC,KAC/EgB,EAAgB,CACd,IAAK,MACLI,KAAM,aACNC,KAAM,YACNC,IAAK,4BACLC,KAAM,oCACNC,OAAQ,6FAGV5D,EAAM6D,KAAO,SAAUlW,GACrB,IAAImU,EAmBJ,OAlBAnU,EAAU2V,EAAe3V,GACzBmU,EAAMuB,EAAU1V,GAAS,WACvB,IAAImT,EAAKgD,EAaT,OAZAA,EAAWP,EAAwC,OAAvBzC,EAAMgB,EAAIgC,UAAoBhD,EAAMgB,EAAIiC,aAAcjC,EAAIkC,kBAAkB,iBAEnE,IAAjChM,KAAKE,MAAM4J,EAAIlS,OAAS,KACK,oBAApBjC,EAAQsW,SACjBtW,EAAQsW,QAAQH,EAAUhC,EAAIoC,WAAYpC,GAGf,oBAAlBnU,EAAQjD,OACjBiD,EAAQjD,MAAMoZ,EAAUhC,EAAIoC,WAAYpC,GAIT,oBAArBnU,EAAQwW,SAA0BxW,EAAQwW,SAASrC,EAAKA,EAAIoC,iBAAc,OAGhE,MAAtBvW,EAAQyW,aAAuBzW,EAAQyW,WAAWtC,EAAKnU,MAIvDmU,EAAIuC,aAAeC,eAAeC,OAC7BzC,EAAI0C,KAAK7W,EAAQmV,WAD1B,IAKFQ,EAAiB,SAAwB3V,GAsBvC,OArBAA,EAAQ8W,IAAM9W,EAAQ8W,KAAOC,SAASC,KACtChX,EAAQrF,KAAOqF,EAAQrF,KAAKsc,cAEP,QAAjBjX,EAAQrF,MAAkBqF,EAAQmV,OAChCnV,EAAQ8W,IAAI3N,QAAQ,KAAO,EAC7BnJ,EAAQ8W,KAAO,IAAM9W,EAAQmV,KAE7BnV,EAAQ8W,KAAO,IAAM9W,EAAQmV,MAIM,MAAnCM,EAAczV,EAAQkX,YACxBlX,EAAQkX,SAAW,KAGrBlX,EAAQmX,OAAS1B,EAAczV,EAAQkX,UAEd,MAArBlX,EAAQkX,WACVlX,EAAQmX,QAAU,iBAGbnX,GAGT0V,EAAY,SAAmB1V,EAASoX,GACtC,IAAIjD,EAsBJ,OArBAA,EAAM,IAAIwC,gBACNU,KAAKrX,EAAQrF,KAAMqF,EAAQ8W,KAAK,GACpC3C,EAAIC,iBAAiB,SAAUpU,EAAQmX,QAEX,kBAAjBnX,EAAQmV,MACjBhB,EAAIC,iBAAiB,eAAgB,oDAGlCpU,EAAQsX,cACXnD,EAAIC,iBAAiB,mBAAoB,kBACzCF,EAAeC,IAGjBA,EAAIoD,kBAAoBvX,EAAQuX,gBAEhCpD,EAAIqD,mBAAqB,WACvB,GAAIrD,EAAIuC,aAAeC,eAAec,KACpC,OAAOL,EAAKjD,IAITA,GAGTyB,EAAkB,SAAyBO,EAAUxb,GACnD,IAAI+c,EAAQzB,EAEZ,GAAwB,kBAAbE,GAAyC,kBAATxb,EACzC,GAAIA,EAAKkW,MAAM,YACb,IACEsF,EAAWwB,KAAKC,MAAMzB,GACtB,MAAOpZ,SACJ,GAAIpC,EAAKkW,MAAM,4BACpBoF,EAAS1O,SAASsQ,cAAc,WACzBtI,aAAa,QAAS8D,KAC7B4C,EAAOJ,KAAOM,EACd5O,SAASuQ,KAAK7M,YAAYgL,GAAQzS,WAAW6H,YAAY4K,QACpD,GAAItb,EAAKkW,MAAM,sBAAuB,CAC3C6G,EAAS,IAAIK,UACbpd,EAAOA,EAAKqd,QAAQ,MAAO,IAE3B,IACE7B,EAAWuB,EAAOO,gBAAgB9B,EAAUxb,GAC5C,MAAOoC,KAIb,OAAOoZ,GAGT9D,EAAM2E,KAAO,SAAUpD,GACrB,OAAOA,EAAQoD,MAGjB3E,EAAM6F,cAAgB,SAAUpB,GAC9B,IAAOqB,EAAcC,GACrBD,EAAe5Q,SAASsQ,cAAc,MACzBb,KAAOD,SAASC,KAC7BoB,EAAY7Q,SAASsQ,cAAc,KAEnC,IAEE,OADAO,EAAUpB,KAAOF,MACNsB,EAAUC,UAAmC,MAAvBD,EAAUC,YAAsBD,EAAUE,MAAQH,EAAaE,SAAW,KAAOF,EAAaG,OAASF,EAAUC,SAAW,KAAOD,EAAUE,MAC9K,MAAOvb,GAEP,OADIA,GACG,KAGVtE,KAAKyH,MACR,WACE,IAAI8Q,EAASuH,EACbvH,EAAUqB,EAAMrB,QAEhBuH,EAAU,SAAiB1S,GACzB,OAAOzG,MAAMlF,UAAU6M,MAAMtO,KAAKoN,IAGpCwM,EAAMmG,iBAAmB,SAAU5E,EAAS6E,GAC1C,IAAIC,EAAQhE,EAsCZ,OArCAgE,EAAS,CAAC9E,GAEN5C,EAAQ4C,EAAS,UACnB8E,EAASH,EAAQ3E,EAAQ1D,WAG3BwE,EAAS,GACTgE,EAAO9X,SAAQ,SAAU2T,GACvB,GAAKA,EAAM1b,OAAQ0b,EAAMpT,WAIrB6P,EAAQuD,EAAO,wBAInB,OAAIvD,EAAQuD,EAAO,UACVgE,EAAQhE,EAAMvU,SAASY,SAAQ,SAAU+X,GAC9C,GAAIA,EAAOC,SACT,OAAOlE,EAAOlU,KAAK,CACjB3H,KAAM0b,EAAM1b,KACZU,MAAOof,EAAOpf,WAIXgb,EAAMsE,UAAoE,IAAzD,CAAC,QAAS,WAAY,UAAU1P,QAAQoL,EAAM5Z,MACjE+Z,EAAOlU,KAAK,CACjB3H,KAAM0b,EAAM1b,KACZU,MAAOgb,EAAMhb,aAHV,KAQLkf,GACF/D,EAAOlU,KAAKiY,GAGP/D,EAAOoE,KAAI,SAAUxE,GAC1B,OAAkB,MAAdA,EAAMzb,KACDkgB,mBAAmBzE,EAAMzb,MAAQ,IAAMkgB,mBAAmBzE,EAAM/a,OAEhE+a,KAERxL,KAAK,MAGVuJ,EAAM2G,aAAe,SAAUC,EAAMlY,GACnC,OAAIiQ,EAAQiI,EAAM,QACTV,EAAQU,EAAK/I,UAAUhJ,QAAO,SAAUhD,GAC7C,OAAO8M,EAAQ9M,EAAInD,MAGdwX,EAAQU,EAAK9J,iBAAiBpO,MAGxCtI,KAAKyH,MACR,WACE,IAAIgZ,EAAazE,EAAMY,EACvBZ,EAAOpC,EAAMoC,KAAMY,EAAiBhD,EAAMgD,eAE1ChD,EAAM8G,cAAgB,SAAUtT,GAC9B,IAAKqT,EAAYhZ,MACf,OAAOmV,EAAexP,IAI1BwM,EAAM+G,QAAU,SAAUC,EAASzF,GACjC,OAAOwF,QAAQC,IAGjBH,EAAc,SAAqBtF,GACjC,IAAI0F,EAAQ9Q,EAAU6Q,EAGtB,KAFAA,EAAUzF,EAAQpE,aAAa,iBAG7B,OAAO,EAKT,GAFA8J,GAAS,EAEL7E,EAAKb,EAAS,WAAY,CAC5B,IACE0F,EAASjH,EAAM+G,QAAQC,EAASzF,GAChC,MAAO7W,IAETyL,EAAWiM,EAAKb,EAAS,mBAAoB,CAAC0F,IAGhD,OAAOA,GAAU9Q,IAElB/P,KAAKyH,MACR,WACE,IAAIqZ,EAAoBC,EAAqBC,EAAoBC,EAAmBC,EAAoBC,EAAmBZ,EAAcnF,EAASgG,EAAe7I,EAAS8C,EAASuB,EACnLrE,EAAUqB,EAAMrB,QAAS6C,EAAUxB,EAAMwB,QAASC,EAAUzB,EAAMyB,QAASuB,EAAiBhD,EAAMgD,eAAgB2D,EAAe3G,EAAM2G,aAEvI3G,EAAMyH,sBAAwB,SAAUjU,GAItC,GAFU3F,UAEEiB,SACV,OAAOkU,EAAexP,IAI1BwM,EAAM0H,cAAgB,SAAUlU,GAC9B,IAAI+N,EAEJ,GAAI/N,aAAaoP,MAAO,CACtB,GAAI4E,EAAchU,GAChB,OAGF+N,EAAU/N,EAAEtI,YAEZqW,EAAU/N,EAGZ,OAAImL,EAAQ4C,EAASvB,EAAMU,qBAClB6G,EAAkBhG,GAChB5C,EAAQ4C,EAASvB,EAAMW,wBAA0BhC,EAAQ4C,EAASvB,EAAMQ,oBAC1E6G,EAAkB9F,GAChB5C,EAAQ4C,EAASvB,EAAMK,oBACzBiH,EAAmB/F,QADrB,GAKTvB,EAAM2H,eAAiB,SAAUnU,GAC/B,IAAI+N,EAGJ,OAFAA,EAAU/N,aAAaoP,MAAQpP,EAAEtI,OAASsI,EAEtCmL,EAAQ4C,EAASvB,EAAMU,qBAClB0G,EAAmB7F,GACjB5C,EAAQ4C,EAASvB,EAAMW,wBAA0BhC,EAAQ4C,EAASvB,EAAMO,qBAC1E2G,EAAmB3F,GACjB5C,EAAQ4C,EAASvB,EAAMK,oBACzB8G,EAAoB5F,QADtB,GAKT6F,EAAqB,SAA4B7F,GAC/C,IAAIqG,EAEJ,IAAIpG,EAAQD,EAAS,gBAYrB,OANmB,OAFnBqG,EAAcrG,EAAQpE,aAAa,wBAGjCsE,EAAQF,EAAS,kBAAmBA,EAAQsG,WAC5CtG,EAAQsG,UAAYD,GAGtBrG,EAAQvP,iBAAiB,QAASgR,GAC3BvB,EAAQF,EAAS,gBAAgB,IAG1CgG,EAAoB,SAA2BhG,GAC7C,IAAIuG,EASJ,OANoB,OAFpBA,EAAetG,EAAQD,EAAS,sBAG9BA,EAAQsG,UAAYC,EACpBrG,EAAQF,EAAS,kBAAmB,OAGtCA,EAAQtP,oBAAoB,QAAS+Q,GAC9BvB,EAAQF,EAAS,eAAgB,OAG1C4F,EAAsB,SAA6BP,GACjD,OAAOD,EAAaC,EAAM5G,EAAMO,qBAAqBhS,QAAQ2Y,IAG/DA,EAAqB,SAA4B3F,GAC/C,IAAIqG,EAEJ,IAAIpG,EAAQD,EAAS,gBAiBrB,OAXmB,OAFnBqG,EAAcrG,EAAQpE,aAAa,wBAG7BwB,EAAQ4C,EAAS,WACnBE,EAAQF,EAAS,kBAAmBA,EAAQsG,WAC5CtG,EAAQsG,UAAYD,IAEpBnG,EAAQF,EAAS,kBAAmBA,EAAQra,OAC5Cqa,EAAQra,MAAQ0gB,IAIpBrG,EAAQzS,UAAW,EACZ2S,EAAQF,EAAS,gBAAgB,IAG1C+F,EAAqB,SAA4BV,GAC/C,OAAOD,EAAaC,EAAM5G,EAAMQ,oBAAoBjS,QAAQ8Y,IAG9DA,EAAoB,SAA2B9F,GAC7C,IAAIuG,EAcJ,OAXoB,OAFpBA,EAAetG,EAAQD,EAAS,sBAG1B5C,EAAQ4C,EAAS,UACnBA,EAAQsG,UAAYC,EAEpBvG,EAAQra,MAAQ4gB,EAGlBrG,EAAQF,EAAS,kBAAmB,OAGtCA,EAAQzS,UAAW,EACZ2S,EAAQF,EAAS,eAAgB,OAG1CiG,EAAgB,SAAuBzZ,GACrC,IAAI+S,EAAKgB,EAET,OAA2E,OAA5D,OADfA,EAA8B,OAAvBhB,EAAM/S,EAAM4U,QAAkB7B,EAAI,QAAK,GACxBgB,EAAIkC,kBAAkB,uBAAoB,KAEjE5d,KAAKyH,MACR,WACE,IAAImV,EACJA,EAAiBhD,EAAMgD,eAEvBhD,EAAM+H,aAAe,SAAUvU,GAC7B,IAAIkO,EAAWC,EAAWiF,EAAMoB,EAAarD,EAAYsD,EAIzD,GAHOpa,KACPoa,EADOpa,KACOsP,aAAa,eAwB3B,OAlBAwH,EAAO3E,EAAM2E,KAPN9W,MAQP8T,EAAY3B,EAAM2B,YAClBD,EAAY1B,EAAM0B,YAClBkF,EAAO1R,SAASsQ,cAAc,QAC9BwC,EAAc,gCAAkCC,EAAS,qBAExC,MAAbvG,GAAkC,MAAbC,GAAsB3B,EAAM6F,cAAclB,KACjEqD,GAAe,gBAAkBtG,EAAY,YAAcC,EAAY,sBAGzEqG,GAAe,0BACfpB,EAAKqB,OAAS,OACdrB,EAAKsB,OAASvD,EACdiC,EAAK1b,OApBE2C,KAoBY3C,OACnB0b,EAAKiB,UAAYG,EACjBpB,EAAKjR,MAAMwS,QAAU,OACrBjT,SAASkT,KAAKxP,YAAYgO,GAC1BA,EAAKpS,cAAc,mBAAmBuI,QAC/BiG,EAAexP,KAEvBpN,KAAKyH,MACR,WACE,IAAIgW,EACAzB,EACAZ,EACAqE,EACAwC,EACA1J,EACAwH,EACA1E,EACAuB,EACAtO,EAAQ,GAAGA,MACfiK,EAAUqB,EAAMrB,QAAS6C,EAAUxB,EAAMwB,QAASC,EAAUzB,EAAMyB,QAASW,EAAOpC,EAAMoC,KAAMY,EAAiBhD,EAAMgD,eAAgBa,EAAO7D,EAAM6D,KAAMgC,EAAgB7F,EAAM6F,cAAeM,EAAmBnG,EAAMmG,iBAEtNkC,EAAW,SAAkB9G,GAC3B,IAAIra,EAEJ,OAAgB,OADhBA,EAAQqa,EAAQpE,aAAa,iBACK,UAAVjW,GAG1B8Y,EAAMsI,aAAe,SAAU9U,GAC7B,IAAI+U,EAAQzF,EAAM+B,EAAUtD,EAAS0G,EAAQxD,EAAKS,EAGlD,OAAKmD,EAFL9G,EAAU1T,QAMLuU,EAAKb,EAAS,gBAKnB2D,EAAkB3D,EAAQpE,aAAa,yBACvC0H,EAAWtD,EAAQpE,aAAa,cAAgB,SAE5CwB,EAAQ4C,EAASvB,EAAMK,qBACzBkI,EAAS/G,EAAQD,EAAS,qBAC1B0G,EAASzG,EAAQD,EAAS,iCAAmCA,EAAQ0G,OACrExD,EAAMjD,EAAQD,EAAS,iCAAmCA,EAAQpE,aAAa,WAAauH,SAASC,KAExE,QAAzBsD,EAAOrD,gBACTH,EAAMA,EAAIkB,QAAQ,QAAS,KAGL,wBAApBpE,EAAQiH,SACV1F,EAAO,IAAI2F,SAASlH,GAEN,MAAVgH,GACFzF,EAAKvK,OAAOgQ,EAAO/hB,KAAM+hB,EAAOrhB,QAGlC4b,EAAOqD,EAAiB5E,EAASgH,GAGnC9G,EAAQF,EAAS,oBAAqB,MACtCE,EAAQF,EAAS,+BAAgC,MACjDE,EAAQF,EAAS,+BAAgC,OACxC5C,EAAQ4C,EAASvB,EAAME,sBAAwBvB,EAAQ4C,EAASvB,EAAMI,sBAC/E6H,EAAS1G,EAAQpE,aAAa,eAC9BsH,EAAMlD,EAAQpE,aAAa,YAC3B2F,EAAOqD,EAAiB5E,EAASA,EAAQpE,aAAa,kBAEtD8K,EAAS1G,EAAQpE,aAAa,eAC9BsH,EAAMzE,EAAM2E,KAAKpD,GACjBuB,EAAOvB,EAAQpE,aAAa,gBAG9B0G,EAAK,CACHvb,KAAM2f,GAAU,MAChBxD,IAAKA,EACL3B,KAAMA,EACN+B,SAAUA,EACVT,WAAY,SAAoBtC,EAAKnU,GACnC,OAAIyU,EAAKb,EAAS,kBAAmB,CAACO,EAAKnU,IAClCyU,EAAKb,EAAS,YAAa,CAACO,KAEnCM,EAAKb,EAAS,iBACP,IAGX0C,QAAS,WACP,IAAI9T,EAEJ,OADAA,EAAO,GAAKvE,UAAUR,OAASsJ,EAAMtO,KAAKwF,UAAW,GAAK,GACnDwW,EAAKb,EAAS,eAAgBpR,IAEvCzF,MAAO,WACL,IAAIyF,EAEJ,OADAA,EAAO,GAAKvE,UAAUR,OAASsJ,EAAMtO,KAAKwF,UAAW,GAAK,GACnDwW,EAAKb,EAAS,aAAcpR,IAErCgU,SAAU,WACR,IAAIhU,EAEJ,OADAA,EAAO,GAAKvE,UAAUR,OAASsJ,EAAMtO,KAAKwF,UAAW,GAAK,GACnDwW,EAAKb,EAAS,gBAAiBpR,IAExC8U,YAAaY,EAAcpB,GAC3BS,gBAAoC,MAAnBA,GAA+C,UAApBA,IAEvClC,EAAexP,KAtEpB4O,EAAKb,EAAS,iBACP,KAwEXvB,EAAM0I,sBAAwB,SAAUlV,GACtC,IAAYoT,EAIZ,GAHS/Y,KACT+Y,EADS/Y,KACK+Y,KAed,OAhBS/Y,KAOErH,MACTib,EAAQmF,EAAM,oBAAqB,CACjCpgB,KATKqH,KASQrH,KACbU,MAVK2G,KAUS3G,QAIlBua,EAAQmF,EAAM,4BAdL/Y,KAcyC8a,gBAClDlH,EAAQmF,EAAM,+BAfL/Y,KAe4CsP,aAAa,eAC3DsE,EAAQmF,EAAM,+BAhBZ/Y,KAgBmDsP,aAAa,gBAG3E6C,EAAM4I,0BAA4B,SAAUpV,GAC1C,IAAIsP,EAAM+F,EAAyCZ,EAQnD,GAPOpa,KACPoa,GADOpa,KACQsP,aAAa,gBAAkB,OAAOyH,cACrD9B,EAFOjV,KAEKsP,aAAa,eAEzB0L,GADYrV,EAAEsV,SAAWtV,EAAEuV,UACsB,QAAXd,IAAqBnF,EACxB,MAAZtP,EAAE+U,QAA+B,IAAb/U,EAAE+U,QAEjBM,EAC1B,OAAOrV,EAAEyP,6BAGZ7c,KAAKyH,MACR,WACE,IAAI4R,EAAGoC,EAAgBqB,EAAUyE,EAAgBD,EAAetF,EAAMsG,EAAuBlH,EAASsF,EAAeW,EAAuBM,EAAcO,EAAczH,EAAc+H,EAA2B5G,EAGjN,GAFAI,EAAOpC,EAAMoC,KAAMc,EAAWlD,EAAMkD,SAAU1B,EAAUxB,EAAMwB,QAAS/B,EAAIO,EAAMP,EAAGuC,EAAoBhC,EAAMgC,kBAAmBH,EAAiB7B,EAAM6B,eAAgBhB,EAAeb,EAAMa,aAAc6G,EAAgB1H,EAAM0H,cAAeC,EAAiB3H,EAAM2H,eAAgBF,EAAwBzH,EAAMyH,sBAAuBX,EAAgB9G,EAAM8G,cAAe8B,EAA4B5I,EAAM4I,0BAA2BN,EAAetI,EAAMsI,aAAcI,EAAwB1I,EAAM0I,sBAAuBX,EAAe/H,EAAM+H,aAErgB,qBAAXrI,QAAqC,OAAXA,QAAkC,MAAfA,OAAOmE,KAAc,CAC3E,GAAInE,OAAOsJ,MACT,MAAM,IAAIC,MAAM,kEAGlBvJ,OAAOsJ,MAAQhJ,EACfN,OAAOwJ,eAAc,SAAUvb,EAASwb,EAAiBrH,GACvD,IAAKnU,EAAQsX,YACX,OAAOpD,EAAeC,MAK5B9B,EAAMlI,MAAQ,WACZ,GAAIrG,OAAO2X,cACT,MAAM,IAAIH,MAAM,sCAiDlB,OA9CAxX,OAAOO,iBAAiB,YAAY,WAMlC,OALAyN,EAAEO,EAAMQ,oBAAoBjS,SAAQ,SAAUsD,GAC5C,GAAI2P,EAAQ3P,EAAI,gBACd,OAAO6V,EAAc7V,MAGlB4N,EAAEO,EAAMU,qBAAqBnS,SAAQ,SAAUsD,GACpD,GAAI2P,EAAQ3P,EAAI,gBACd,OAAO6V,EAAc7V,SAI3BqR,EAAShO,SAAU8K,EAAMU,oBAAqB,gBAAiBgH,GAC/DxE,EAAShO,SAAU8K,EAAMU,oBAAqB,eAAgBgH,GAC9DxE,EAAShO,SAAU8K,EAAMW,sBAAuB,gBAAiB+G,GACjExE,EAAShO,SAAU8K,EAAMW,sBAAuB,eAAgB+G,GAChExE,EAAShO,SAAU8K,EAAMC,kBAAmB,QAAS2I,GACrD1F,EAAShO,SAAU8K,EAAMC,kBAAmB,QAASwH,GACrDvE,EAAShO,SAAU8K,EAAMC,kBAAmB,QAAS6G,GACrD5D,EAAShO,SAAU8K,EAAMC,kBAAmB,QAAS0H,GACrDzE,EAAShO,SAAU8K,EAAMC,kBAAmB,QAASqI,GACrDpF,EAAShO,SAAU8K,EAAMC,kBAAmB,QAAS8H,GACrD7E,EAAShO,SAAU8K,EAAME,oBAAqB,QAAS0I,GACvD1F,EAAShO,SAAU8K,EAAME,oBAAqB,QAASuH,GACvDvE,EAAShO,SAAU8K,EAAME,oBAAqB,QAAS4G,GACvD5D,EAAShO,SAAU8K,EAAME,oBAAqB,QAASyH,GACvDzE,EAAShO,SAAU8K,EAAME,oBAAqB,QAASoI,GACvDpF,EAAShO,SAAU8K,EAAMI,oBAAqB,SAAUqH,GACxDvE,EAAShO,SAAU8K,EAAMI,oBAAqB,SAAU0G,GACxD5D,EAAShO,SAAU8K,EAAMI,oBAAqB,SAAUkI,GACxDpF,EAAShO,SAAU8K,EAAMK,mBAAoB,SAAUoH,GACvDvE,EAAShO,SAAU8K,EAAMK,mBAAoB,SAAUyG,GACvD5D,EAAShO,SAAU8K,EAAMK,mBAAoB,SAAUiI,GACvDpF,EAAShO,SAAU8K,EAAMK,mBAAoB,UAAU,SAAU7M,GAC/D,OAAO1C,YAAW,WAChB,OAAO6W,EAAenU,KACrB,OAEL0P,EAAShO,SAAU8K,EAAMK,mBAAoB,YAAasH,GAC1DzE,EAAShO,SAAU8K,EAAMK,mBAAoB,gBAAiBqH,GAC9DxE,EAAShO,SAAU8K,EAAMM,uBAAwB,QAASsI,GAC1D1F,EAAShO,SAAU8K,EAAMM,uBAAwB,QAASmH,GAC1DvE,EAAShO,SAAU8K,EAAMM,uBAAwB,QAASwG,GAC1D5D,EAAShO,SAAU8K,EAAMM,uBAAwB,QAASoI,GAC1DxT,SAASlD,iBAAiB,mBAAoBgQ,GAC9C9M,SAASlD,iBAAiB,mBAAoB6O,GACvCpP,OAAO2X,eAAgB,GAG5B3X,OAAOuO,QAAUA,GAASoC,EAAKlN,SAAU,yBAC3C8K,EAAMlI,SAEP1R,KAAKyH,QACPzH,KAAKyH,MAEgE,WAArBlD,EAAQ3E,IAAyBA,EAAOD,QACzFC,EAAOD,QAAUia,OAEL,2BAAZ,KAAY,oCAEb5Z,KAAKyH,Q,oCClyBR,UAEmBwb,EAFnB,cAAoW,OAAtO1e,EAArD,oBAAX3D,QAAoD,kBAApBA,OAAOmB,SAAmC,SAAiBD,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXlB,QAAyBkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,IAAyBA,GAEhWmhB,EAEV,SAAUtjB,GACjB,aAQA,IAAIujB,EANJ,SAA8BC,EAAIvjB,GAChC,OAEGujB,EAFIvjB,EAAS,CACdD,QAAS,IACGC,EAAOD,SAAUC,EAAOD,QAGzByjB,EAAqB,SAAUxjB,EAAQD,GAGhDC,EAAOD,QAER,SAAUmG,GACX,IAAIud,EAAU,CAAC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAE1F,SAASC,EAASC,EAAGxV,GACnB,IAAIyV,EAAID,EAAE,GACNE,EAAIF,EAAE,GACNrjB,EAAIqjB,EAAE,GACNpjB,EAAIojB,EAAE,GAQVE,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,GAAKujB,EAAItjB,GAAK4N,EAAE,GAAK,UAAY,IACjC,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,GAAKD,EAAItjB,GAAK6N,EAAE,GAAK,UAAY,IACjC,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,GAAKrjB,EAAIsjB,GAAK1V,EAAE,GAAK,UAAY,IACjC,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,GAAKD,EAAIsjB,GAAKzV,EAAE,GAAK,WAAa,IAClC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,GAAKujB,EAAItjB,GAAK4N,EAAE,GAAK,UAAY,IACjC,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,GAAKD,EAAItjB,GAAK6N,EAAE,GAAK,WAAa,IAClC,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,GAAKrjB,EAAIsjB,GAAK1V,EAAE,GAAK,WAAa,IAClC,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,GAAKD,EAAIsjB,GAAKzV,EAAE,GAAK,SAAW,IAChC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,GAAKujB,EAAItjB,GAAK4N,EAAE,GAAK,WAAa,IAClC,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,GAAKD,EAAItjB,GAAK6N,EAAE,GAAK,WAAa,IAClC,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,GAAKrjB,EAAIsjB,GAAK1V,EAAE,IAAM,MAAQ,IAC9B,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,GAAKD,EAAIsjB,GAAKzV,EAAE,IAAM,WAAa,IACnC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,GAAKujB,EAAItjB,GAAK4N,EAAE,IAAM,WAAa,IACnC,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,GAAKD,EAAItjB,GAAK6N,EAAE,IAAM,SAAW,IACjC,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,GAAKrjB,EAAIsjB,GAAK1V,EAAE,IAAM,WAAa,IACnC,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,GAAKD,EAAIsjB,GAAKzV,EAAE,IAAM,WAAa,IACnC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAItjB,EAAID,GAAKC,GAAK4N,EAAE,GAAK,UAAY,IACjC,EAAIyV,IAAM,IAAMC,EAAI,GACpBvjB,EAAIujB,GAAKvjB,GAAK6N,EAAE,GAAK,WAAa,IAClC,EAAI5N,IAAM,IAAMqjB,EAAI,GACpBC,EAAID,GAAKC,GAAK1V,EAAE,IAAM,UAAY,IAClC,GAAK7N,IAAM,IAAMC,EAAI,GACrBqjB,EAAIrjB,GAAKqjB,GAAKzV,EAAE,GAAK,UAAY,IACjC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAItjB,EAAID,GAAKC,GAAK4N,EAAE,GAAK,UAAY,IACjC,EAAIyV,IAAM,IAAMC,EAAI,GACpBvjB,EAAIujB,GAAKvjB,GAAK6N,EAAE,IAAM,SAAW,IACjC,EAAI5N,IAAM,IAAMqjB,EAAI,GACpBC,EAAID,GAAKC,GAAK1V,EAAE,IAAM,UAAY,IAClC,GAAK7N,IAAM,IAAMC,EAAI,GACrBqjB,EAAIrjB,GAAKqjB,GAAKzV,EAAE,GAAK,UAAY,IACjC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAItjB,EAAID,GAAKC,GAAK4N,EAAE,GAAK,UAAY,IACjC,EAAIyV,IAAM,IAAMC,EAAI,GACpBvjB,EAAIujB,GAAKvjB,GAAK6N,EAAE,IAAM,WAAa,IACnC,EAAI5N,IAAM,IAAMqjB,EAAI,GACpBC,EAAID,GAAKC,GAAK1V,EAAE,GAAK,UAAY,IACjC,GAAK7N,IAAM,IAAMC,EAAI,GACrBqjB,EAAIrjB,GAAKqjB,GAAKzV,EAAE,GAAK,WAAa,IAClC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAItjB,EAAID,GAAKC,GAAK4N,EAAE,IAAM,WAAa,IACnC,EAAIyV,IAAM,IAAMC,EAAI,GACpBvjB,EAAIujB,GAAKvjB,GAAK6N,EAAE,GAAK,SAAW,IAChC,EAAI5N,IAAM,IAAMqjB,EAAI,GACpBC,EAAID,GAAKC,GAAK1V,EAAE,GAAK,WAAa,IAClC,GAAK7N,IAAM,IAAMC,EAAI,GACrBqjB,EAAIrjB,GAAKqjB,GAAKzV,EAAE,IAAM,WAAa,IACnC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,EAAIC,GAAK4N,EAAE,GAAK,OAAS,IACzB,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,EAAIvjB,GAAK6N,EAAE,GAAK,WAAa,IAC7B,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,EAAIC,GAAK1V,EAAE,IAAM,WAAa,IAC9B,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,EAAIqjB,GAAKzV,EAAE,IAAM,SAAW,IAC5B,GAAK0V,IAAM,GAAKvjB,EAAI,EAQ9BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,EAAIC,GAAK4N,EAAE,GAAK,WAAa,IAC7B,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,EAAIvjB,GAAK6N,EAAE,GAAK,WAAa,IAC7B,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,EAAIC,GAAK1V,EAAE,GAAK,UAAY,IAC5B,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,EAAIqjB,GAAKzV,EAAE,IAAM,WAAa,IAC9B,GAAK0V,IAAM,GAAKvjB,EAAI,EAQ9BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,EAAIC,GAAK4N,EAAE,IAAM,UAAY,IAC7B,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,EAAIvjB,GAAK6N,EAAE,GAAK,UAAY,IAC5B,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,EAAIC,GAAK1V,EAAE,GAAK,UAAY,IAC5B,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,EAAIqjB,GAAKzV,EAAE,GAAK,SAAW,IAC3B,GAAK0V,IAAM,GAAKvjB,EAAI,EAQ9BujB,IADAA,KADAvjB,IADAA,KADAC,IADAA,KADAqjB,IADAA,IAAMC,EAAIvjB,EAAIC,GAAK4N,EAAE,GAAK,UAAY,IAC5B,EAAIyV,IAAM,IAAMC,EAAI,GACpBA,EAAIvjB,GAAK6N,EAAE,IAAM,UAAY,IAC7B,GAAK5N,IAAM,IAAMqjB,EAAI,GACrBA,EAAIC,GAAK1V,EAAE,IAAM,UAAY,IAC7B,GAAK7N,IAAM,IAAMC,EAAI,GACrBA,EAAIqjB,GAAKzV,EAAE,GAAK,UAAY,IAC5B,GAAK0V,IAAM,GAAKvjB,EAAI,EAQ9BujB,IADAA,KAHAtjB,IADAA,IAAMsjB,IADND,IADAA,IAAMtjB,GAAKujB,GAAKtjB,IAAM4N,EAAE,GAAK,UAAY,IAC/B,EAAIyV,IAAM,IAAMC,EAAI,IACdvjB,IAAM6N,EAAE,GAAK,WAAa,IAChC,GAAK5N,IAAM,IAAMqjB,EAAI,KAE/BtjB,IADAA,IAAMsjB,GAAKrjB,GAAKsjB,IAAM1V,EAAE,IAAM,WAAa,IACjC,GAAK7N,IAAM,IAAMC,EAAI,IACfqjB,IAAMzV,EAAE,GAAK,SAAW,IAC9B,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KAHAtjB,IADAA,IAAMsjB,IADND,IADAA,IAAMtjB,GAAKujB,GAAKtjB,IAAM4N,EAAE,IAAM,WAAa,IACjC,EAAIyV,IAAM,IAAMC,EAAI,IACdvjB,IAAM6N,EAAE,GAAK,WAAa,IAChC,GAAK5N,IAAM,IAAMqjB,EAAI,KAE/BtjB,IADAA,IAAMsjB,GAAKrjB,GAAKsjB,IAAM1V,EAAE,IAAM,QAAU,IAC9B,GAAK7N,IAAM,IAAMC,EAAI,IACfqjB,IAAMzV,EAAE,GAAK,WAAa,IAChC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KAHAtjB,IADAA,IAAMsjB,IADND,IADAA,IAAMtjB,GAAKujB,GAAKtjB,IAAM4N,EAAE,GAAK,WAAa,IAChC,EAAIyV,IAAM,IAAMC,EAAI,IACdvjB,IAAM6N,EAAE,IAAM,SAAW,IAC/B,GAAK5N,IAAM,IAAMqjB,EAAI,KAE/BtjB,IADAA,IAAMsjB,GAAKrjB,GAAKsjB,IAAM1V,EAAE,GAAK,WAAa,IAChC,GAAK7N,IAAM,IAAMC,EAAI,IACfqjB,IAAMzV,EAAE,IAAM,WAAa,IACjC,GAAK0V,IAAM,IAAMvjB,EAAI,EAQ/BujB,IADAA,KAHAtjB,IADAA,IAAMsjB,IADND,IADAA,IAAMtjB,GAAKujB,GAAKtjB,IAAM4N,EAAE,GAAK,UAAY,IAC/B,EAAIyV,IAAM,IAAMC,EAAI,IACdvjB,IAAM6N,EAAE,IAAM,WAAa,IACjC,GAAK5N,IAAM,IAAMqjB,EAAI,KAE/BtjB,IADAA,IAAMsjB,GAAKrjB,GAAKsjB,IAAM1V,EAAE,GAAK,UAAY,IAC/B,GAAK7N,IAAM,IAAMC,EAAI,IACfqjB,IAAMzV,EAAE,GAAK,UAAY,IAC/B,GAAK0V,IAAM,IAAMvjB,EAAI,EAC/BqjB,EAAE,GAAKC,EAAID,EAAE,GAAK,EAClBA,EAAE,GAAKE,EAAIF,EAAE,GAAK,EAClBA,EAAE,GAAKrjB,EAAIqjB,EAAE,GAAK,EAClBA,EAAE,GAAKpjB,EAAIojB,EAAE,GAAK,EAGpB,SAASG,EAAO9hB,GACd,IACI/B,EADA8jB,EAAU,GAGd,IAAK9jB,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACvB8jB,EAAQ9jB,GAAK,GAAK+B,EAAEgiB,WAAW/jB,IAAM+B,EAAEgiB,WAAW/jB,EAAI,IAAM,IAAM+B,EAAEgiB,WAAW/jB,EAAI,IAAM,KAAO+B,EAAEgiB,WAAW/jB,EAAI,IAAM,IAGzH,OAAO8jB,EAGT,SAASE,EAAaL,GACpB,IACI3jB,EADA8jB,EAAU,GAGd,IAAK9jB,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACvB8jB,EAAQ9jB,GAAK,GAAK2jB,EAAE3jB,IAAM2jB,EAAE3jB,EAAI,IAAM,IAAM2jB,EAAE3jB,EAAI,IAAM,KAAO2jB,EAAE3jB,EAAI,IAAM,IAG7E,OAAO8jB,EAGT,SAASG,EAAKliB,GACZ,IAEI/B,EACAmF,EACA+e,EACAC,EACAC,EACAC,EAPA5iB,EAAIM,EAAEoD,OACNmf,EAAQ,CAAC,YAAa,WAAY,WAAY,WAQlD,IAAKtkB,EAAI,GAAIA,GAAKyB,EAAGzB,GAAK,GACxByjB,EAASa,EAAOT,EAAO9hB,EAAEwiB,UAAUvkB,EAAI,GAAIA,KAO7C,IAHAmF,GADApD,EAAIA,EAAEwiB,UAAUvkB,EAAI,KACTmF,OACX+e,EAAO,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAEhDlkB,EAAI,EAAGA,EAAImF,EAAQnF,GAAK,EAC3BkkB,EAAKlkB,GAAK,IAAM+B,EAAEgiB,WAAW/jB,KAAOA,EAAI,GAAK,GAK/C,GAFAkkB,EAAKlkB,GAAK,IAAM,MAAQA,EAAI,GAAK,GAE7BA,EAAI,GAGN,IAFAyjB,EAASa,EAAOJ,GAEXlkB,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACvBkkB,EAAKlkB,GAAK,EAWd,OANAmkB,GADAA,EAAU,EAAJ1iB,GACI+iB,SAAS,IAAIjM,MAAM,kBAC7B6L,EAAK5d,SAAS2d,EAAI,GAAI,IACtBE,EAAK7d,SAAS2d,EAAI,GAAI,KAAO,EAC7BD,EAAK,IAAME,EACXF,EAAK,IAAMG,EACXZ,EAASa,EAAOJ,GACTI,EA6CT,SAASG,EAAKhjB,GACZ,IACIijB,EADA3iB,EAAI,GAGR,IAAK2iB,EAAI,EAAGA,EAAI,EAAGA,GAAK,EACtB3iB,GAAKyhB,EAAQ/hB,GAAS,EAAJijB,EAAQ,EAAI,IAAMlB,EAAQ/hB,GAAS,EAAJijB,EAAQ,IAG3D,OAAO3iB,EAGT,SAAS4iB,EAAIjB,GACX,IAAI1jB,EAEJ,IAAKA,EAAI,EAAGA,EAAI0jB,EAAEve,OAAQnF,GAAK,EAC7B0jB,EAAE1jB,GAAKykB,EAAKf,EAAE1jB,IAGhB,OAAO0jB,EAAElT,KAAK,IA4ChB,SAASoU,EAAOC,GAKd,MAJI,kBAAkBC,KAAKD,KACzBA,EAAME,SAAStE,mBAAmBoE,KAG7BA,EA2BT,SAASG,EAAkBL,GACzB,IAEIjB,EAFAuB,EAAQ,GACR9f,EAASwf,EAAIxf,OAGjB,IAAKue,EAAI,EAAGA,EAAIve,EAAS,EAAGue,GAAK,EAC/BuB,EAAM/c,KAAK1B,SAASme,EAAIxQ,OAAOuP,EAAG,GAAI,KAGxC,OAAOwB,OAAOC,aAAa5a,MAAM2a,OAAQD,GAG3C,SAASG,IACPxd,KAAKyd,QA+KP,OArQIV,EAAIV,EAAK,UAEc,qBAAhBqB,aAAgCA,YAAY1jB,UAAU6M,OAC/D,WACE,SAAS8W,EAAMC,EAAKrgB,GAGlB,OAFAqgB,EAAY,EAANA,GAAW,GAEP,EACDzT,KAAKC,IAAIwT,EAAMrgB,EAAQ,GAGzB4M,KAAKiC,IAAIwR,EAAKrgB,GAGvBmgB,YAAY1jB,UAAU6M,MAAQ,SAAUgX,EAAMC,GAC5C,IAGIC,EACA1gB,EACA2gB,EACAC,EANA1gB,EAASyC,KAAKke,WACdC,EAAQR,EAAME,EAAMtgB,GACpB2M,EAAM3M,EAUV,OAJIugB,IAAOzf,IACT6L,EAAMyT,EAAMG,EAAIvgB,IAGd4gB,EAAQjU,EACH,IAAIwT,YAAY,IAGzBK,EAAM7T,EAAMiU,EACZ9gB,EAAS,IAAIqgB,YAAYK,GACzBC,EAAc,IAAII,WAAW/gB,GAC7B4gB,EAAc,IAAIG,WAAWpe,KAAMme,EAAOJ,GAC1CC,EAAYpc,IAAIqc,GACT5gB,IAjCX,GAsFFmgB,EAASxjB,UAAU0Q,OAAS,SAAUuS,GAEpC,OADAjd,KAAKqe,aAAarB,EAAOC,IAClBjd,MAGTwd,EAASxjB,UAAUqkB,aAAe,SAAUC,GAC1Cte,KAAKue,OAASD,EACdte,KAAKwe,SAAWF,EAAS/gB,OACzB,IACInF,EADAmF,EAASyC,KAAKue,MAAMhhB,OAGxB,IAAKnF,EAAI,GAAIA,GAAKmF,EAAQnF,GAAK,GAC7ByjB,EAAS7b,KAAKye,MAAOxC,EAAOjc,KAAKue,MAAM5B,UAAUvkB,EAAI,GAAIA,KAI3D,OADA4H,KAAKue,MAAQve,KAAKue,MAAM5B,UAAUvkB,EAAI,IAC/B4H,MAGTwd,EAASxjB,UAAUkQ,IAAM,SAAUwU,GACjC,IAEItmB,EAEAumB,EAJAC,EAAO5e,KAAKue,MACZhhB,EAASqhB,EAAKrhB,OAEd+e,EAAO,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAGzD,IAAKlkB,EAAI,EAAGA,EAAImF,EAAQnF,GAAK,EAC3BkkB,EAAKlkB,GAAK,IAAMwmB,EAAKzC,WAAW/jB,KAAOA,EAAI,GAAK,GAYlD,OATA4H,KAAK6e,QAAQvC,EAAM/e,GAEnBohB,EAAM5B,EAAI/c,KAAKye,OAEXC,IACFC,EAAMvB,EAAkBuB,IAG1B3e,KAAKyd,QACEkB,GAGTnB,EAASxjB,UAAUyjB,MAAQ,WAIzB,OAHAzd,KAAKue,MAAQ,GACbve,KAAKwe,QAAU,EACfxe,KAAKye,MAAQ,CAAC,YAAa,WAAY,WAAY,WAC5Cze,MAGTwd,EAASxjB,UAAU8kB,SAAW,WAC5B,MAAO,CACLF,KAAM5e,KAAKue,MACXhhB,OAAQyC,KAAKwe,QACbO,KAAM/e,KAAKye,QAIfjB,EAASxjB,UAAUglB,SAAW,SAAUtC,GAItC,OAHA1c,KAAKue,MAAQ7B,EAAMkC,KACnB5e,KAAKwe,QAAU9B,EAAMnf,OACrByC,KAAKye,MAAQ/B,EAAMqC,KACZ/e,MAGTwd,EAASxjB,UAAUwR,QAAU,kBACpBxL,KAAKye,aACLze,KAAKue,aACLve,KAAKwe,SAGdhB,EAASxjB,UAAU6kB,QAAU,SAAUvC,EAAM/e,GAC3C,IACIgf,EACAC,EACAC,EAHArkB,EAAImF,EAMR,GAFA+e,EAAKlkB,GAAK,IAAM,MAAQA,EAAI,GAAK,GAE7BA,EAAI,GAGN,IAFAyjB,EAAS7b,KAAKye,MAAOnC,GAEhBlkB,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACvBkkB,EAAKlkB,GAAK,EAKdmkB,GADAA,EAAqB,EAAfvc,KAAKwe,SACD5B,SAAS,IAAIjM,MAAM,kBAC7B6L,EAAK5d,SAAS2d,EAAI,GAAI,IACtBE,EAAK7d,SAAS2d,EAAI,GAAI,KAAO,EAC7BD,EAAK,IAAME,EACXF,EAAK,IAAMG,EACXZ,EAAS7b,KAAKye,MAAOnC,IAGvBkB,EAASuB,KAAO,SAAU9B,EAAKyB,GAC7B,OAAOlB,EAASyB,WAAWjC,EAAOC,GAAMyB,IAG1ClB,EAASyB,WAAa,SAAU/L,EAASwL,GACvC,IACIC,EAAM5B,EADCV,EAAKnJ,IAEhB,OAAOwL,EAAMtB,EAAkBuB,GAAOA,GAGxCnB,EAASE,YAAc,WACrB1d,KAAKyd,SAGPD,EAASE,YAAY1jB,UAAU0Q,OAAS,SAAUwU,GAChD,IAEI9mB,EAtI2B+mB,EAAOC,EAAQC,EAC1C9c,EAmIAqc,GApI2BO,EAoIInf,KAAKue,MAAMe,OApIRF,EAoIgBF,EApIRG,GAoIa,GAnIvD9c,EAAS,IAAI6b,WAAWe,EAAMjB,WAAakB,EAAOlB,aAC/Ctc,IAAI,IAAIwc,WAAWe,IAC1B5c,EAAOX,IAAI,IAAIwc,WAAWgB,GAASD,EAAMjB,YAClCmB,EAAmB9c,EAASA,EAAO+c,QAiItC/hB,EAASqhB,EAAKrhB,OAIlB,IAFAyC,KAAKwe,SAAWU,EAAIhB,WAEf9lB,EAAI,GAAIA,GAAKmF,EAAQnF,GAAK,GAC7ByjB,EAAS7b,KAAKye,MAAOrC,EAAawC,EAAKW,SAASnnB,EAAI,GAAIA,KAI1D,OADA4H,KAAKue,MAAQnmB,EAAI,GAAKmF,EAAS,IAAI6gB,WAAWQ,EAAKU,OAAOzY,MAAMzO,EAAI,KAAO,IAAIgmB,WAAW,GACnFpe,MAGTwd,EAASE,YAAY1jB,UAAUkQ,IAAM,SAAUwU,GAC7C,IAGItmB,EACAumB,EAJAC,EAAO5e,KAAKue,MACZhhB,EAASqhB,EAAKrhB,OACd+e,EAAO,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAIzD,IAAKlkB,EAAI,EAAGA,EAAImF,EAAQnF,GAAK,EAC3BkkB,EAAKlkB,GAAK,IAAMwmB,EAAKxmB,KAAOA,EAAI,GAAK,GAYvC,OATA4H,KAAK6e,QAAQvC,EAAM/e,GAEnBohB,EAAM5B,EAAI/c,KAAKye,OAEXC,IACFC,EAAMvB,EAAkBuB,IAG1B3e,KAAKyd,QACEkB,GAGTnB,EAASE,YAAY1jB,UAAUyjB,MAAQ,WAIrC,OAHAzd,KAAKue,MAAQ,IAAIH,WAAW,GAC5Bpe,KAAKwe,QAAU,EACfxe,KAAKye,MAAQ,CAAC,YAAa,WAAY,WAAY,WAC5Cze,MAGTwd,EAASE,YAAY1jB,UAAU8kB,SAAW,WACxC,IApL2BF,EAoLvBlC,EAAQc,EAASxjB,UAAU8kB,SAASvmB,KAAKyH,MAE7C,OADA0c,EAAMkC,MArLqBA,EAqLMlC,EAAMkC,KApLhCtB,OAAOC,aAAa5a,MAAM,KAAM,IAAIyb,WAAWQ,KAqL/ClC,GAGTc,EAASE,YAAY1jB,UAAUglB,SAAW,SAAUtC,GAElD,OADAA,EAAMkC,KAvMR,SAA6B3B,EAAKoC,GAChC,IAGIjnB,EAHAmF,EAAS0f,EAAI1f,OACbqhB,EAAO,IAAIlB,YAAYngB,GACvB2hB,EAAM,IAAId,WAAWQ,GAGzB,IAAKxmB,EAAI,EAAGA,EAAImF,EAAQnF,GAAK,EAC3B8mB,EAAI9mB,GAAK6kB,EAAId,WAAW/jB,GAG1B,OAAOinB,EAAmBH,EAAMN,EA6LnBY,CAAoB9C,EAAMkC,MAAM,GACtCpB,EAASxjB,UAAUglB,SAASzmB,KAAKyH,KAAM0c,IAGhDc,EAASE,YAAY1jB,UAAUwR,QAAUgS,EAASxjB,UAAUwR,QAC5DgS,EAASE,YAAY1jB,UAAU6kB,QAAUrB,EAASxjB,UAAU6kB,QAE5DrB,EAASE,YAAYqB,KAAO,SAAUG,EAAKR,GACzC,IACIC,EAAM5B,EAhUZ,SAAoBhB,GAClB,IAEI3jB,EACAmF,EACA+e,EACAC,EACAC,EACAC,EAPA5iB,EAAIkiB,EAAExe,OACNmf,EAAQ,CAAC,YAAa,WAAY,WAAY,WAQlD,IAAKtkB,EAAI,GAAIA,GAAKyB,EAAGzB,GAAK,GACxByjB,EAASa,EAAON,EAAaL,EAAEwD,SAASnnB,EAAI,GAAIA,KAOlD,IAJA2jB,EAAI3jB,EAAI,GAAKyB,EAAIkiB,EAAEwD,SAASnnB,EAAI,IAAM,IAAIgmB,WAAW,GACrD7gB,EAASwe,EAAExe,OACX+e,EAAO,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAEhDlkB,EAAI,EAAGA,EAAImF,EAAQnF,GAAK,EAC3BkkB,EAAKlkB,GAAK,IAAM2jB,EAAE3jB,KAAOA,EAAI,GAAK,GAKpC,GAFAkkB,EAAKlkB,GAAK,IAAM,MAAQA,EAAI,GAAK,GAE7BA,EAAI,GAGN,IAFAyjB,EAASa,EAAOJ,GAEXlkB,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACvBkkB,EAAKlkB,GAAK,EAWd,OANAmkB,GADAA,EAAU,EAAJ1iB,GACI+iB,SAAS,IAAIjM,MAAM,kBAC7B6L,EAAK5d,SAAS2d,EAAI,GAAI,IACtBE,EAAK7d,SAAS2d,EAAI,GAAI,KAAO,EAC7BD,EAAK,IAAME,EACXF,EAAK,IAAMG,EACXZ,EAASa,EAAOJ,GACTI,EAwRI+C,CAAW,IAAIrB,WAAWc,KAErC,OAAOR,EAAMtB,EAAkBuB,GAAOA,GAGjCnB,EAphBYhC,MAwhBnBze,EAAiB,SAAwBC,EAAUC,GACrD,KAAMD,aAAoBC,GACxB,MAAM,IAAIC,UAAU,sCAIpBC,EAAc,WAChB,SAASC,EAAiBC,EAAQC,GAChC,IAAK,IAAIlF,EAAI,EAAGA,EAAIkF,EAAMC,OAAQnF,IAAK,CACrC,IAAIoF,EAAaF,EAAMlF,GACvBoF,EAAWxE,WAAawE,EAAWxE,aAAc,EACjDwE,EAAWC,cAAe,EACtB,UAAWD,IAAYA,EAAWE,UAAW,GACjD5E,OAAOC,eAAesE,EAAQG,EAAW7D,IAAK6D,IAIlD,OAAO,SAAUP,EAAaU,EAAYC,GAGxC,OAFID,GAAYP,EAAiBH,EAAYjD,UAAW2D,GACpDC,GAAaR,EAAiBH,EAAaW,GACxCX,GAdO,GAkBdyiB,EAAYC,KAAK3lB,UAAU6M,OAAS8Y,KAAK3lB,UAAU4lB,UAAYD,KAAK3lB,UAAU6lB,YAE9EC,EAAe,WASjB,SAASA,EAAaC,GACpBhjB,EAAeiD,KAAM8f,GACrB9f,KAAK+f,KAAOA,EACZ/f,KAAKggB,UAAY,QACjBhgB,KAAKigB,WAAa9V,KAAK+V,KAAKlgB,KAAK+f,KAAKI,KAAOngB,KAAKggB,WAClDhgB,KAAKogB,WAAa,EAkDpB,OA/DAjjB,EAAY2iB,EAAc,KAAM,CAAC,CAC/BnmB,IAAK,SACLN,MAAO,SAAgB0mB,EAAMzX,GACZ,IAAIwX,EAAaC,GACvBrmB,OAAO4O,OAYpBnL,EAAY2iB,EAAc,CAAC,CACzBnmB,IAAK,SACLN,MAAO,SAAgBiP,GACrB,IAAIqB,EAAQ3J,KAEZA,KAAKsI,SAAWA,EAChBtI,KAAKqgB,UAAY,IAAI5E,EAASiC,YAC9B1d,KAAKsgB,WAAa,IAAIC,WACtBvgB,KAAKsgB,WAAWnc,iBAAiB,QAAQ,SAAUjE,GACjD,OAAOyJ,EAAM6W,kBAAkBtgB,MAEjCF,KAAKsgB,WAAWnc,iBAAiB,SAAS,SAAUjE,GAClD,OAAOyJ,EAAM8W,mBAAmBvgB,MAElCF,KAAK0gB,kBAEN,CACD/mB,IAAK,oBACLN,MAAO,SAA2B6G,GAGhC,GAFAF,KAAKqgB,UAAU3V,OAAOxK,EAAM7C,OAAOkF,SAE9BvC,KAAK0gB,gBAAiB,CACzB,IAAIC,EAAe3gB,KAAKqgB,UAAUnW,KAAI,GAClC0W,EAAeC,KAAKF,GACxB3gB,KAAKsI,SAAS,KAAMsY,MAGvB,CACDjnB,IAAK,qBACLN,MAAO,SAA4B6G,GACjCF,KAAKsI,SAAS,iBAAmBtI,KAAK+f,KAAKpnB,QAE5C,CACDgB,IAAK,gBACLN,MAAO,WACL,GAAI2G,KAAKogB,WAAapgB,KAAKigB,YAAiC,GAAnBjgB,KAAKogB,YAAsC,GAAnBpgB,KAAKigB,WAAiB,CACrF,IAAIhW,EAAQjK,KAAKogB,WAAapgB,KAAKggB,UAC/B9V,EAAMC,KAAKiC,IAAInC,EAAQjK,KAAKggB,UAAWhgB,KAAK+f,KAAKI,MACjD9C,EAAQqC,EAAUnnB,KAAKyH,KAAK+f,KAAM9V,EAAOC,GAG7C,OAFAlK,KAAKsgB,WAAWQ,kBAAkBzD,GAClCrd,KAAKogB,cACE,EAEP,OAAO,MAINN,EAhEU,GAqFnB,SAASiB,EAAYta,EAAM5F,GAMzB,MALmB,iBAAR4F,IACT5F,EAAW4F,EACXA,EAAOY,UAGFZ,EAAKE,cAAc9F,GAG5B,SAASqU,EAAcxB,EAASjZ,GAC9B,IAAIumB,EAAYjjB,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GAChFkD,EAAWyS,EAAQzS,SACnB2T,EAAUoM,EAAUpM,QACpBC,EAAamM,EAAUnM,WACvBC,EAASkM,EAAUlM,OACnB5U,EAAQmH,SAASqN,YAAY,SACjCxU,EAAM+gB,UAAUxmB,EAAMma,IAAW,EAAMC,IAAc,GACrD3U,EAAM4U,OAASA,GAAU,GAEzB,IACEpB,EAAQzS,UAAW,EACnByS,EAAQwB,cAAchV,GACtB,QACAwT,EAAQzS,SAAWA,EAGrB,OAAOf,EAGT,SAASghB,EAAU7nB,GACjB,OAAI6F,MAAMD,QAAQ5F,GACTA,EACE6F,MAAM2e,KACR3e,MAAM2e,KAAKxkB,GAEX,GAAGwN,MAAMtO,KAAKc,GAIzB,IAAI8nB,EAAa,WACf,SAASA,EAAWpB,EAAMqB,EAAUxK,GAClC,IAAIjN,EAAQ3J,KAEZjD,EAAeiD,KAAMmhB,GACrBnhB,KAAK+f,KAAOA,EACZ/f,KAAKqhB,WAAa,CAChBC,SAAUvB,EAAKpnB,KACf4oB,aAAcxB,EAAKtlB,MAAQ,2BAC3B+mB,UAAWzB,EAAKI,KAChBiB,SAAUA,GAEZphB,KAAKiU,IAAM,IAAIwC,eACfzW,KAAKiU,IAAIkD,KAAK,OAAQP,GAAK,GAC3B5W,KAAKiU,IAAIwN,aAAe,OACxBzhB,KAAKiU,IAAIC,iBAAiB,eAAgB,oBAC1ClU,KAAKiU,IAAIC,iBAAiB,SAAU,oBACpClU,KAAKiU,IAAIC,iBAAiB,mBAAoB,kBAC9C,IAAIJ,EA3ER,SAAsBnb,GACpB,IAAI+a,EAAUqN,EAAY1Z,SAASuQ,KAAM,cAAgBjf,EAAO,MAEhE,GAAI+a,EACF,OAAOA,EAAQpE,aAAa,WAuEZoS,CAAa,mBAEZrjB,GAAbyV,GACF9T,KAAKiU,IAAIC,iBAAiB,eAAgBJ,GAG5C9T,KAAKiU,IAAI9P,iBAAiB,QAAQ,SAAUjE,GAC1C,OAAOyJ,EAAMgY,eAAezhB,MAE9BF,KAAKiU,IAAI9P,iBAAiB,SAAS,SAAUjE,GAC3C,OAAOyJ,EAAMiY,gBAAgB1hB,MA6DjC,OAzDA/C,EAAYgkB,EAAY,CAAC,CACvBxnB,IAAK,SACLN,MAAO,SAAgBiP,GACrBtI,KAAKsI,SAAWA,EAChBtI,KAAKiU,IAAI0C,KAAKc,KAAKoK,UAAU,CAC3BC,KAAM9hB,KAAKqhB,gBAGd,CACD1nB,IAAK,iBACLN,MAAO,SAAwB6G,GAC7B,GAAIF,KAAK+B,QAAU,KAAO/B,KAAK+B,OAAS,IAAK,CAC3C,IAAIkU,EAAWjW,KAAKiW,SAChB8L,EAAgB9L,EAAS8L,qBACtB9L,EAAS8L,cAChB/hB,KAAKqhB,WAAapL,EAClBjW,KAAKgiB,iBAAmBD,EACxB/hB,KAAKsI,SAAS,KAAMtI,KAAKiiB,eAEzBjiB,KAAK4hB,gBAAgB1hB,KAGxB,CACDvG,IAAK,kBACLN,MAAO,SAAyB6G,GAC9BF,KAAKsI,SAAS,4BAA8BtI,KAAK+f,KAAKpnB,KAAO,cAAgBqH,KAAK+B,UAEnF,CACDpI,IAAK,SACLN,MAAO,WACL,IAAIkJ,EAAS,GAEb,IAAK,IAAI5I,KAAOqG,KAAKqhB,WACnB9e,EAAO5I,GAAOqG,KAAKqhB,WAAW1nB,GAGhC,OAAO4I,IAER,CACD5I,IAAK,SACLV,IAAK,WACH,OAAO+G,KAAKiU,IAAIlS,SAEjB,CACDpI,IAAK,WACLV,IAAK,WACH,IAAIipB,EAAOliB,KAAKiU,IACZwN,EAAeS,EAAKT,aACpBxL,EAAWiM,EAAKjM,SAEpB,MAAoB,QAAhBwL,EACKxL,EAEAwB,KAAKC,MAAMzB,OAIjBkL,EAzFQ,GA4FbgB,EAAa,WACf,SAASA,EAAWL,GAClB,IAAInY,EAAQ3J,KAEZjD,EAAeiD,KAAMmiB,GACrBniB,KAAK8hB,KAAOA,EACZ9hB,KAAK+f,KAAO+B,EAAK/B,KACjB,IAAIqC,EAAwBN,EAAKE,iBAC7BpL,EAAMwL,EAAsBxL,IAC5ByL,EAAUD,EAAsBC,QAKpC,IAAK,IAAI1oB,KAJTqG,KAAKiU,IAAM,IAAIwC,eACfzW,KAAKiU,IAAIkD,KAAK,MAAOP,GAAK,GAC1B5W,KAAKiU,IAAIwN,aAAe,OAERY,EACdriB,KAAKiU,IAAIC,iBAAiBva,EAAK0oB,EAAQ1oB,IAGzCqG,KAAKiU,IAAI9P,iBAAiB,QAAQ,SAAUjE,GAC1C,OAAOyJ,EAAMgY,eAAezhB,MAE9BF,KAAKiU,IAAI9P,iBAAiB,SAAS,SAAUjE,GAC3C,OAAOyJ,EAAMiY,gBAAgB1hB,MA6BjC,OAzBA/C,EAAYglB,EAAY,CAAC,CACvBxoB,IAAK,SACLN,MAAO,SAAgBiP,GACrBtI,KAAKsI,SAAWA,EAChBtI,KAAKiU,IAAI0C,KAAK3W,KAAK+f,KAAKlZ,WAEzB,CACDlN,IAAK,iBACLN,MAAO,SAAwB6G,GAC7B,IAAIgiB,EAAOliB,KAAKiU,IACZlS,EAASmgB,EAAKngB,OACdkU,EAAWiM,EAAKjM,SAEhBlU,GAAU,KAAOA,EAAS,IAC5B/B,KAAKsI,SAAS,KAAM2N,GAEpBjW,KAAK4hB,gBAAgB1hB,KAGxB,CACDvG,IAAK,kBACLN,MAAO,SAAyB6G,GAC9BF,KAAKsI,SAAS,kBAAoBtI,KAAK+f,KAAKpnB,KAAO,cAAgBqH,KAAKiU,IAAIlS,YAGzEogB,EAnDQ,GAsDbG,EAAK,EAELC,EAAe,WACjB,SAASA,EAAaxC,EAAMnJ,EAAKvB,GAC/BtY,EAAeiD,KAAMuiB,GACrBviB,KAAKsiB,KAAOA,EACZtiB,KAAK+f,KAAOA,EACZ/f,KAAK4W,IAAMA,EACX5W,KAAKqV,SAAWA,EAkClB,OA/BAlY,EAAYolB,EAAc,CAAC,CACzB5oB,IAAK,SACLN,MAAO,SAAgBiP,GACrB,IAAIqB,EAAQ3J,KAEZ8f,EAAapmB,OAAOsG,KAAK+f,MAAM,SAAUljB,EAAOukB,GAC9C,GAAIvkB,EACFyL,EAASzL,OADX,CAKA,IAAIilB,EAAO,IAAIX,EAAWxX,EAAMoW,KAAMqB,EAAUzX,EAAMiN,KACtD4L,EAAO7Y,EAAM0L,SAAU,oCAAqCyM,EAAK7N,KACjE6N,EAAKpoB,QAAO,SAAUmD,GACpB,GAAIA,EACFyL,EAASzL,OACJ,CACL,IAAI4lB,EAAS,IAAIN,EAAWL,GAC5BU,EAAO7Y,EAAM0L,SAAU,mCAAoCoN,EAAOxO,KAClEwO,EAAO/oB,QAAO,SAAUmD,GAClBA,EACFyL,EAASzL,GAETyL,EAAS,KAAMwZ,EAAKG,yBAQ3BM,EAxCU,GA2CnB,SAASC,EAAO1oB,EAAQ4oB,GACtB,GAAI5oB,GAAuC,mBAAtBA,EAAO4oB,GAA2B,CACrD,IAAK,IAAIC,EAAO5kB,UAAUR,OAAQqlB,EAAW1jB,MAAMyjB,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IAClGD,EAASC,EAAO,GAAK9kB,UAAU8kB,GAGjC,OAAO/oB,EAAO4oB,GAAY/f,MAAM7I,EAAQ8oB,IAI5C,IAAIE,EAAyB,WAC3B,SAASA,EAAuBzO,EAAO0L,GACrChjB,EAAeiD,KAAM8iB,GACrB9iB,KAAKqU,MAAQA,EACbrU,KAAK+f,KAAOA,EACZ/f,KAAK+iB,aAAe,IAAIR,EAAaviB,KAAK+f,KAAM/f,KAAK4W,IAAK5W,MAC1DA,KAAKgjB,SAAS,cAoFhB,OAjFA7lB,EAAY2lB,EAAwB,CAAC,CACnCnpB,IAAK,QACLN,MAAO,SAAeiP,GACpB,IAAIqB,EAAQ3J,KAERijB,EAAc5b,SAASsQ,cAAc,SACzCsL,EAAYxoB,KAAO,SACnBwoB,EAAYtqB,KAAOqH,KAAKqU,MAAM1b,KAC9BqH,KAAKqU,MAAM6O,sBAAsB,cAAeD,GAChDjjB,KAAKgjB,SAAS,SACdhjB,KAAK+iB,aAAarpB,QAAO,SAAUmD,EAAOwkB,GACpCxkB,GACFomB,EAAY3f,WAAW6H,YAAY8X,GAEnCtZ,EAAMwZ,cAActmB,IAEpBomB,EAAY5pB,MAAQgoB,EAAW+B,UAGjCzZ,EAAMqZ,SAAS,OAEf1a,EAASzL,QAGZ,CACDlD,IAAK,2BACLN,MAAO,SAAkC6G,GACvC,IAAImjB,EAAWnjB,EAAMojB,OAASpjB,EAAMqjB,MAAQ,IAExCF,GACFrjB,KAAKgjB,SAAS,WAAY,CACxBK,SAAUA,MAIf,CACD1pB,IAAK,WACLN,MAAO,SAAkBV,GACvB,IAAImc,EAAS/W,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GAGjF,OAFA+W,EAAOiL,KAAO/f,KAAK+f,KACnBjL,EAAOwN,GAAKtiB,KAAK+iB,aAAaT,GACvBpN,EAAclV,KAAKqU,MAAO,iBAAmB1b,EAAM,CACxDmc,OAAQA,MAGX,CACDnb,IAAK,gBACLN,MAAO,SAAuBwD,GAChBmD,KAAKgjB,SAAS,QAAS,CACjCnmB,MAAOA,IAGEmY,kBACTwO,MAAM3mB,KAGT,CACDlD,IAAK,oCACLN,MAAO,SAA2C4a,GAChDjU,KAAKgjB,SAAS,sBAAuB,CACnC/O,IAAKA,MAGR,CACDta,IAAK,mCACLN,MAAO,SAA0C4a,GAC/C,IAAI1F,EAASvO,KAEbA,KAAKgjB,SAAS,yBAA0B,CACtC/O,IAAKA,IAEPA,EAAIwO,OAAOte,iBAAiB,YAAY,SAAUjE,GAChD,OAAOqO,EAAOkV,yBAAyBvjB,QAG1C,CACDvG,IAAK,MACLV,IAAK,WACH,OAAO+G,KAAKqU,MAAM/E,aAAa,8BAG5BwT,EA1FoB,GA+FzBY,EAA0B,WAC5B,SAASA,EAAwB3K,GA1VnC,IAAsBtS,EAAM5F,EA2VxB9D,EAAeiD,KAAM0jB,GACrB1jB,KAAK+Y,KAAOA,EACZ/Y,KAAKwY,QA7Va/R,EA6VSsS,EA7VHlY,EAuVR,2DAtVC,iBAAR4F,IACT5F,EAAW4F,EACXA,EAAOY,UAIF6Z,EADQza,EAAKwI,iBAAiBpO,KAuVamG,QAAO,SAAUqN,GAC/D,OAAOA,EAAMsP,MAAMpmB,UAuDvB,OAnDAJ,EAAYumB,EAAyB,CAAC,CACpC/pB,IAAK,QACLN,MAAO,SAAeiP,GACpB,IAAIqB,EAAQ3J,KAER4jB,EAAc5jB,KAAK6jB,gCAsBvB7jB,KAAKgjB,SAAS,SApBY,SAASc,IACjC,IAAIC,EAAaH,EAAYI,QAEzBD,EACFA,EAAW9Z,OAAM,SAAUpN,GACrBA,GACFyL,EAASzL,GAET8M,EAAMqZ,SAAS,QAEfc,QAIJxb,IAEAqB,EAAMqZ,SAAS,QAKnBc,KAED,CACDnqB,IAAK,gCACLN,MAAO,WACL,IAAIuqB,EAAc,GAOlB,OANA5jB,KAAKwY,OAAO9X,SAAQ,SAAU2T,GAC5B6M,EAAU7M,EAAMsP,OAAOjjB,SAAQ,SAAUqf,GACvC,IAAIgE,EAAa,IAAIjB,EAAuBzO,EAAO0L,GACnD6D,EAAYtjB,KAAKyjB,SAGdH,IAER,CACDjqB,IAAK,WACLN,MAAO,SAAkBV,GACvB,IAAImc,EAAS/W,UAAUR,OAAS,QAAsBc,IAAjBN,UAAU,GAAmBA,UAAU,GAAK,GACjF,OAAOmX,EAAclV,KAAK+Y,KAAM,kBAAoBpgB,EAAM,CACxDmc,OAAQA,QAIP4O,EA5DqB,GAgE1BO,EAAsB,IAAIC,QAC1BC,GAAU,EAEd,SAASla,IACFka,IACHA,GAAU,EACV9c,SAASlD,iBAAiB,QAASigB,GAAU,GAC7C/c,SAASlD,iBAAiB,SAAUkgB,GACpChd,SAASlD,iBAAiB,cAAemgB,IAI7C,SAASF,EAASlkB,GAChB,IAAI7C,EAAS6C,EAAM7C,OAEI,SAAlBA,EAAOknB,SAAwC,UAAlBlnB,EAAOknB,SAAuC,UAAflnB,EAAO5C,OAAoB4C,EAAO0b,MACjGkL,EAAoBriB,IAAIvE,EAAO0b,KAAM1b,GAIzC,SAASgnB,EAAcnkB,GACrBskB,EAA0BtkB,GAG5B,SAASokB,EAAuBpkB,GACF,QAAxBA,EAAM7C,OAAOknB,SACfC,EAA0BtkB,GAI9B,SAASskB,EAA0BtkB,GACjC,IAAI6Y,EAAO7Y,EAAM7C,OAEjB,GAAI0b,EAAK0L,aAlCe,kCAmCtBvkB,EAAM0O,qBADR,CAKA,IAAImV,EAAa,IAAIL,EAAwB3K,GACzCP,EAASuL,EAAWvL,OAEpBA,EAAOjb,SACT2C,EAAM0O,iBACNmK,EAAK1J,aA5CiB,iCA4CiB,IACvCmJ,EAAO9X,QAAQc,GACfuiB,EAAW9Z,OAAM,SAAUpN,GACzBkc,EAAKxJ,gBA/Ce,kCAiDhB1S,EACF2b,EAAO9X,QAAQ6H,GAQvB,SAAoBwQ,GAClB,IAAI2B,EAASuJ,EAAoBhrB,IAAI8f,IAASgI,EAAYhI,EAAM,2CAEhE,GAAI2B,EAAQ,CACV,IACIzZ,EADUyZ,EACSzZ,SACvByZ,EAAOzZ,UAAW,EAClByZ,EAAOgK,QACPhK,EAAOxL,QACPwL,EAAOzZ,SAAWA,OAElByZ,EAASrT,SAASsQ,cAAc,UACzBld,KAAO,SACdigB,EAAO5S,MAAMwS,QAAU,OACvBvB,EAAKhO,YAAY2P,GACjBA,EAAOxL,QACP6J,EAAK5N,YAAYuP,GAGnBuJ,EAAoBU,OAAO5L,GAzBrB6L,CAAW7L,QA4BnB,SAASvX,EAAQ6S,GACfA,EAAMpT,UAAW,EAGnB,SAASsH,EAAO8L,GACdA,EAAMpT,UAAW,EASnBgC,YANA,WACMW,OAAOihB,eACT5a,MAIkB,GACtB/R,EAAQ+R,MAAQA,EAChB/R,EAAQqqB,aAAeA,EACvBzpB,OAAOC,eAAeb,EAAS,aAAc,CAC3CmB,OAAO,KApoC6D,WAAtByD,EAAQ5E,IAA4C,qBAAXC,EAAyBqjB,EAAQtjB,IAAwD,EAAO,CAAC,QAAmB,2BAAP,EAAF,GAAS,iC,gBCA/M,IAAM4sB,EAAWpT,KACjBoT,EAAS3e,OAAOzF,QAAQokB,I,cCJxB,SAASC,EAAoBC,GAC5B,IAAIrf,EAAI,IAAIyV,MAAM,uBAAyB4J,EAAM,KAEjD,MADArf,EAAEsf,KAAO,mBACHtf,EAEPof,EAAoB5e,KAAO,WAAa,MAAO,IAC/C4e,EAAoBtc,QAAUsc,EAC9B5sB,EAAOD,QAAU6sB,EACjBA,EAAoBzC,GAAK,G,iBCRzB,gCAAoW,OAAtOxlB,EAArD,oBAAX3D,QAAoD,kBAApBA,OAAOmB,SAAmC,SAAiBD,GAAO,cAAcA,GAA2B,SAAiBA,GAAO,OAAOA,GAAyB,oBAAXlB,QAAyBkB,EAAIE,cAAgBpB,QAAUkB,IAAQlB,OAAOa,UAAY,gBAAkBK,IAAyBA,IAenX,SAAWsX,EAAQ6J,GACjB,aAEwE,WAArB1e,EAAQ3E,IAAqD,WAA5B2E,EAAQ3E,EAAOD,SAQjGC,EAAOD,QAAUyZ,EAAOtK,SAAWmU,EAAQ7J,GAAQ,GAAQ,SAAUuT,GACnE,IAAKA,EAAE7d,SACL,MAAM,IAAI+T,MAAM,4CAGlB,OAAOI,EAAQ0J,IAGjB1J,EAAQ7J,GAnBZ,CAsBqB,qBAAX/N,OAAyBA,OAAS5D,MAAM,SAAU4D,EAAQuhB,GAKlE,aAEA,IAAIjG,EAAM,GACNkG,EAAWtsB,OAAOyF,eAClB8mB,EAASnG,EAAIrY,MACbye,EAAOpG,EAAIoG,KAAO,SAAUC,GAC9B,OAAOrG,EAAIoG,KAAK/sB,KAAKgtB,IACnB,SAAUA,GACZ,OAAOrG,EAAIxX,OAAO/E,MAAM,GAAI4iB,IAE1BjlB,EAAO4e,EAAI5e,KACX2I,EAAUiW,EAAIjW,QACduc,EAAa,GACb5I,EAAW4I,EAAW5I,SACtB6I,EAASD,EAAWvrB,eACpByrB,EAAaD,EAAO7I,SACpB+I,EAAuBD,EAAWntB,KAAKO,QACvC8sB,EAAU,GAEV7mB,EAAa,SAAoB1E,GAQnC,MAAsB,oBAARA,GAA8C,kBAAjBA,EAAIqJ,UAA6C,oBAAbrJ,EAAIsG,MAGjFklB,EAAW,SAAkBxrB,GAC/B,OAAc,MAAPA,GAAeA,IAAQA,EAAIuJ,QAGhCyD,EAAWzD,EAAOyD,SAClBye,EAA4B,CAC9BrrB,MAAM,EACNsrB,KAAK,EACLhT,OAAO,EACPiT,UAAU,GAGZ,SAASC,EAAQhB,EAAM5hB,EAAM6iB,GAE3B,IAAI9tB,EACAwlB,EACA7H,GAHJmQ,EAAMA,GAAO7e,GAGIsQ,cAAc,UAG/B,GAFA5B,EAAOJ,KAAOsP,EAEV5hB,EACF,IAAKjL,KAAK0tB,GAWRlI,EAAMva,EAAKjL,IAAMiL,EAAKiM,cAAgBjM,EAAKiM,aAAalX,KAGtD2d,EAAO1G,aAAajX,EAAGwlB,GAK7BsI,EAAItO,KAAK7M,YAAYgL,GAAQzS,WAAW6H,YAAY4K,GAGtD,SAASoQ,EAAO9rB,GACd,OAAW,MAAPA,EACKA,EAAM,GAIS,WAAjByC,EAAQzC,IAAoC,oBAARA,EAAqBmrB,EAAW5I,EAASrkB,KAAK8B,KAAS,SAAWyC,EAAQzC,GAOvH,IAEAwX,EAAS,SAASA,EAAOhR,EAAUL,GAGjC,OAAO,IAAIqR,EAAO6J,GAAG0K,KAAKvlB,EAAUL,IAiTtC,SAAS6lB,EAAYhsB,GAKnB,IAAIkD,IAAWlD,GAAO,WAAYA,GAAOA,EAAIkD,OACzC9C,EAAO0rB,EAAO9rB,GAElB,OAAI0E,EAAW1E,KAAQwrB,EAASxrB,KAIhB,UAATI,GAA+B,IAAX8C,GAAkC,kBAAXA,GAAuBA,EAAS,GAAKA,EAAS,KAAKlD,GA1TvGwX,EAAO6J,GAAK7J,EAAO7X,UAAY,CAE7BssB,OAVY,QAWZ/rB,YAAasX,EAEbtU,OAAQ,EACR8a,QAAS,WACP,OAAOgN,EAAO9sB,KAAKyH,OAIrB/G,IAAK,SAAa8kB,GAEhB,OAAW,MAAPA,EACKsH,EAAO9sB,KAAKyH,MAId+d,EAAM,EAAI/d,KAAK+d,EAAM/d,KAAKzC,QAAUyC,KAAK+d,IAIlDwI,UAAW,SAAmBC,GAE5B,IAAI7H,EAAM9M,EAAO4U,MAAMzmB,KAAKzF,cAAeisB,GAI3C,OAFA7H,EAAI+H,WAAa1mB,KAEV2e,GAGTgI,KAAM,SAAcre,GAClB,OAAOuJ,EAAO8U,KAAK3mB,KAAMsI,IAE3BsQ,IAAK,SAAatQ,GAChB,OAAOtI,KAAKumB,UAAU1U,EAAO+G,IAAI5Y,MAAM,SAAU4mB,EAAMxuB,GACrD,OAAOkQ,EAAS/P,KAAKquB,EAAMxuB,EAAGwuB,QAGlC/f,MAAO,WACL,OAAO7G,KAAKumB,UAAUlB,EAAO1iB,MAAM3C,KAAMjC,aAE3CohB,MAAO,WACL,OAAOnf,KAAK6mB,GAAG,IAEjBC,KAAM,WACJ,OAAO9mB,KAAK6mB,IAAI,IAElBE,KAAM,WACJ,OAAO/mB,KAAKumB,UAAU1U,EAAOmV,KAAKhnB,MAAM,SAAUinB,EAAO7uB,GACvD,OAAQA,EAAI,GAAK,OAGrB8uB,IAAK,WACH,OAAOlnB,KAAKumB,UAAU1U,EAAOmV,KAAKhnB,MAAM,SAAUinB,EAAO7uB,GACvD,OAAOA,EAAI,OAGfyuB,GAAI,SAAYzuB,GACd,IAAIoR,EAAMxJ,KAAKzC,OACXuf,GAAK1kB,GAAKA,EAAI,EAAIoR,EAAM,GAC5B,OAAOxJ,KAAKumB,UAAUzJ,GAAK,GAAKA,EAAItT,EAAM,CAACxJ,KAAK8c,IAAM,KAExD5S,IAAK,WACH,OAAOlK,KAAK0mB,YAAc1mB,KAAKzF,eAIjC+F,KAAMA,EACN8F,KAAM8Y,EAAI9Y,KACV+gB,OAAQjI,EAAIiI,QAGdtV,EAAOuV,OAASvV,EAAO6J,GAAG0L,OAAS,WACjC,IAAItnB,EACAnH,EACAotB,EACAsB,EACAC,EACAhd,EACAjN,EAASU,UAAU,IAAM,GACzB3F,EAAI,EACJmF,EAASQ,UAAUR,OACnBgqB,GAAO,EAoBX,IAlBsB,mBAAXlqB,IACTkqB,EAAOlqB,EAEPA,EAASU,UAAU3F,IAAM,GACzBA,KAIsB,WAApB0E,EAAQO,IAAyB0B,EAAW1B,KAC9CA,EAAS,IAIPjF,IAAMmF,IACRF,EAAS2C,KACT5H,KAGKA,EAAImF,EAAQnF,IAEjB,GAAgC,OAA3B0H,EAAU/B,UAAU3F,IAEvB,IAAKO,KAAQmH,EACXunB,EAAOvnB,EAAQnH,GAGF,cAATA,GAAwB0E,IAAWgqB,IAKnCE,GAAQF,IAASxV,EAAO2V,cAAcH,KAAUC,EAAcpoB,MAAMD,QAAQooB,MAC9EtB,EAAM1oB,EAAO1E,GAGX2R,EADEgd,IAAgBpoB,MAAMD,QAAQ8mB,GACxB,GACEuB,GAAgBzV,EAAO2V,cAAczB,GAGvCA,EAFA,GAKVuB,GAAc,EAEdjqB,EAAO1E,GAAQkZ,EAAOuV,OAAOG,EAAMjd,EAAO+c,SACxBhpB,IAATgpB,IACThqB,EAAO1E,GAAQ0uB,IAOvB,OAAOhqB,GAGTwU,EAAOuV,OAAO,CAEZK,QAAS,UAvJG,QAuJmBtd,KAAKud,UAAU5P,QAAQ,MAAO,IAE7D6P,SAAS,EACT9qB,MAAO,SAAeF,GACpB,MAAM,IAAIye,MAAMze,IAElBirB,KAAM,aACNJ,cAAe,SAAuBntB,GACpC,IAAIwtB,EAAOC,EAGX,SAAKztB,GAA8B,oBAAvBuiB,EAASrkB,KAAK8B,QAI1BwtB,EAAQzC,EAAS/qB,KAQM,oBADvBytB,EAAOrC,EAAOltB,KAAKsvB,EAAO,gBAAkBA,EAAMttB,cACbmrB,EAAWntB,KAAKuvB,KAAUnC,IAEjEoC,cAAe,SAAuB1tB,GACpC,IAAI1B,EAEJ,IAAKA,KAAQ0B,EACX,OAAO,EAGT,OAAO,GAIT2tB,WAAY,SAAoB/C,EAAMnlB,EAASomB,GAC7CD,EAAQhB,EAAM,CACZlS,MAAOjT,GAAWA,EAAQiT,OACzBmT,IAELS,KAAM,SAActsB,EAAKiO,GACvB,IAAI/K,EACAnF,EAAI,EAER,GAAIiuB,EAAYhsB,GAGd,IAFAkD,EAASlD,EAAIkD,OAENnF,EAAImF,IACgC,IAArC+K,EAAS/P,KAAK8B,EAAIjC,GAAIA,EAAGiC,EAAIjC,IADhBA,UAMnB,IAAKA,KAAKiC,EACR,IAAyC,IAArCiO,EAAS/P,KAAK8B,EAAIjC,GAAIA,EAAGiC,EAAIjC,IAC/B,MAKN,OAAOiC,GAGT4tB,UAAW,SAAmB/I,EAAKgJ,GACjC,IAAIvJ,EAAMuJ,GAAW,GAUrB,OARW,MAAPhJ,IACEmH,EAAYvtB,OAAOomB,IACrBrN,EAAO4U,MAAM9H,EAAoB,kBAARO,EAAmB,CAACA,GAAOA,GAEpD5e,EAAK/H,KAAKomB,EAAKO,IAIZP,GAETwJ,QAAS,SAAiBvB,EAAM1H,EAAK9mB,GACnC,OAAc,MAAP8mB,GAAe,EAAIjW,EAAQ1Q,KAAK2mB,EAAK0H,EAAMxuB,IAIpDquB,MAAO,SAAetH,EAAOC,GAK3B,IAJA,IAAI5V,GAAO4V,EAAO7hB,OACduf,EAAI,EACJ1kB,EAAI+mB,EAAM5hB,OAEPuf,EAAItT,EAAKsT,IACdqC,EAAM/mB,KAAOgnB,EAAOtC,GAItB,OADAqC,EAAM5hB,OAASnF,EACR+mB,GAET6H,KAAM,SAAcR,EAAOle,EAAU8f,GAQnC,IAPA,IACItX,EAAU,GACV1Y,EAAI,EACJmF,EAASipB,EAAMjpB,OACf8qB,GAAkBD,EAGfhwB,EAAImF,EAAQnF,KACEkQ,EAASke,EAAMpuB,GAAIA,KAEdiwB,GACtBvX,EAAQxQ,KAAKkmB,EAAMpuB,IAIvB,OAAO0Y,GAGT8H,IAAK,SAAa4N,EAAOle,EAAUggB,GACjC,IAAI/qB,EACAlE,EACAjB,EAAI,EACJumB,EAAM,GAEV,GAAI0H,EAAYG,GAGd,IAFAjpB,EAASipB,EAAMjpB,OAERnF,EAAImF,EAAQnF,IAGJ,OAFbiB,EAAQiP,EAASke,EAAMpuB,GAAIA,EAAGkwB,KAG5B3J,EAAIre,KAAKjH,QAKb,IAAKjB,KAAKouB,EAGK,OAFbntB,EAAQiP,EAASke,EAAMpuB,GAAIA,EAAGkwB,KAG5B3J,EAAIre,KAAKjH,GAMf,OAAOisB,EAAK3G,IAGd4J,KAAM,EAGN3C,QAASA,IAGW,oBAAXzsB,SACT0Y,EAAO6J,GAAGviB,OAAOmB,UAAY4kB,EAAI/lB,OAAOmB,WAI1CuX,EAAO8U,KAAK,uEAAuEhe,MAAM,MAAM,SAAU9G,EAAIlJ,GAC3G6sB,EAAW,WAAa7sB,EAAO,KAAOA,EAAK6vB,iBAkB7C,IAAIC,EAWJ,SAAU7kB,GACR,IAAIxL,EACAwtB,EACA8C,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAEJC,EACI9hB,EACA+hB,EACAC,EACAC,EACAC,EACAzY,EACA3J,EAEJsgB,EAAU,SAAW,EAAI,IAAIxlB,KACzBunB,EAAe5lB,EAAOyD,SACtBoiB,EAAU,EACVvS,EAAO,EACPwS,EAAaC,KACbC,EAAaD,KACbE,EAAgBF,KAChBG,EAAyBH,KACzBI,EAAY,SAAmBhO,EAAGC,GAKpC,OAJID,IAAMC,IACRkN,GAAe,GAGV,GAGTzD,EAAS,GAAGxrB,eACRilB,EAAM,GACN8K,EAAM9K,EAAI8K,IACVC,EAAa/K,EAAI5e,KACjBA,EAAO4e,EAAI5e,KACXuG,EAAQqY,EAAIrY,MAGhBoC,EAAU,SAAiBihB,EAAMtD,GAI/B,IAHA,IAAIxuB,EAAI,EACJoR,EAAM0gB,EAAK3sB,OAERnF,EAAIoR,EAAKpR,IACd,GAAI8xB,EAAK9xB,KAAOwuB,EACd,OAAOxuB,EAIX,OAAQ,GAEN+xB,EAAW,6HAGfC,EAAa,sBAEbC,EAAa,0BAA4BD,EAAa,0CAEtD/I,EAAa,MAAQ+I,EAAa,KAAOC,EAAa,OAASD,EAC/D,gBAAkBA,EAElB,2DAA6DC,EAAa,OAASD,EAAa,OAC5FE,EAAU,KAAOD,EAAP,wFAGehJ,EAHf,eAMdkJ,EAAc,IAAIC,OAAOJ,EAAa,IAAK,KACvCK,EAAQ,IAAID,OAAO,IAAMJ,EAAa,8BAAgCA,EAAa,KAAM,KACzFM,EAAS,IAAIF,OAAO,IAAMJ,EAAa,KAAOA,EAAa,KAC3DO,EAAe,IAAIH,OAAO,IAAMJ,EAAa,WAAaA,EAAa,IAAMA,EAAa,KAC1FQ,EAAW,IAAIJ,OAAOJ,EAAa,MACnCS,EAAU,IAAIL,OAAOF,GACrBQ,EAAc,IAAIN,OAAO,IAAMH,EAAa,KAC5CU,EAAY,CACd,GAAM,IAAIP,OAAO,MAAQH,EAAa,KACtC,MAAS,IAAIG,OAAO,QAAUH,EAAa,KAC3C,IAAO,IAAIG,OAAO,KAAOH,EAAa,SACtC,KAAQ,IAAIG,OAAO,IAAMnJ,GACzB,OAAU,IAAImJ,OAAO,IAAMF,GAC3B,MAAS,IAAIE,OAAO,yDAA2DJ,EAAa,+BAAiCA,EAAa,cAAgBA,EAAa,aAAeA,EAAa,SAAU,KAC7M,KAAQ,IAAII,OAAO,OAASL,EAAW,KAAM,KAG7C,aAAgB,IAAIK,OAAO,IAAMJ,EAAa,mDAAqDA,EAAa,mBAAqBA,EAAa,mBAAoB,MAEpKY,EAAQ,SACRC,EAAU,sCACVC,EAAU,SACVC,EAAU,yBAEdC,EAAa,mCACTC,GAAW,OAGfC,GAAY,IAAId,OAAO,uBAAyBJ,EAAa,uBAAwB,KACjFmB,GAAY,SAAmBC,EAAQC,GACzC,IAAIC,EAAO,KAAOF,EAAO3kB,MAAM,GAAK,MACpC,OAAO4kB,IAKPC,EAAO,EAAIpO,OAAOC,aAAamO,EAAO,OAAWpO,OAAOC,aAAamO,GAAQ,GAAK,MAAe,KAAPA,EAAe,SAI3GC,GAAa,sDACTC,GAAa,SAAoBC,EAAIC,GACvC,OAAIA,EAES,OAAPD,EACK,SAIFA,EAAGhlB,MAAM,GAAI,GAAK,KAAOglB,EAAG1P,WAAW0P,EAAGtuB,OAAS,GAAGqf,SAAS,IAAM,IAIvE,KAAOiP,GAMhBE,GAAgB,WACd5C,KAEE6C,GAAqBC,IAAc,SAAUrF,GAC/C,OAAyB,IAAlBA,EAAK3lB,UAAqD,aAAhC2lB,EAAKsF,SAAS1D,gBAC9C,CACD2D,IAAK,aACLC,KAAM,WAIR,IACE9rB,EAAKqC,MAAMuc,EAAMrY,EAAMtO,KAAKixB,EAAa6C,YAAa7C,EAAa6C,YAInEnN,EAAIsK,EAAa6C,WAAW9uB,QAAQmG,SACpC,MAAOiC,IACPrF,EAAO,CACLqC,MAAOuc,EAAI3hB,OACX,SAAUF,EAAQivB,GAChBrC,EAAWtnB,MAAMtF,EAAQwJ,EAAMtO,KAAK+zB,KAGtC,SAAUjvB,EAAQivB,GAIhB,IAHA,IAAIxP,EAAIzf,EAAOE,OACXnF,EAAI,EAEDiF,EAAOyf,KAAOwP,EAAIl0B,OAEzBiF,EAAOE,OAASuf,EAAI,IAK1B,SAAS2L,GAAO5nB,EAAUL,EAAS0nB,EAASqE,GAC1C,IAAI/zB,EACAJ,EACAwuB,EACA4F,EACA7b,EACA8b,EACAC,EACAC,EAAansB,GAAWA,EAAQosB,cAEpClpB,EAAWlD,EAAUA,EAAQkD,SAAW,EAGxC,GAFAwkB,EAAUA,GAAW,GAEG,kBAAbrnB,IAA0BA,GAAyB,IAAb6C,GAA+B,IAAbA,GAA+B,KAAbA,EACnF,OAAOwkB,EAIT,IAAKqE,IACHpD,EAAY3oB,GACZA,EAAUA,GAAW6G,EAEjBgiB,GAAgB,CAGlB,GAAiB,KAAb3lB,IAAoBiN,EAAQya,EAAWyB,KAAKhsB,IAE9C,GAAIrI,EAAImY,EAAM,IAEZ,GAAiB,IAAbjN,EAAgB,CAClB,KAAIkjB,EAAOpmB,EAAQssB,eAAet0B,IAShC,OAAO0vB,EALP,GAAItB,EAAKtE,KAAO9pB,EAEd,OADA0vB,EAAQ5nB,KAAKsmB,GACNsB,OAUX,GAAIyE,IAAe/F,EAAO+F,EAAWG,eAAet0B,KAAO2O,EAAS3G,EAASomB,IAASA,EAAKtE,KAAO9pB,EAEhG,OADA0vB,EAAQ5nB,KAAKsmB,GACNsB,MAIN,IAAIvX,EAAM,GAEf,OADArQ,EAAKqC,MAAMulB,EAAS1nB,EAAQusB,qBAAqBlsB,IAC1CqnB,EACF,IAAK1vB,EAAImY,EAAM,KAAOiV,EAAQoH,wBAA0BxsB,EAAQwsB,uBAErE,OADA1sB,EAAKqC,MAAMulB,EAAS1nB,EAAQwsB,uBAAuBx0B,IAC5C0vB,EAKX,GAAItC,EAAQqH,MAAQnD,EAAuBjpB,EAAW,QAAUyoB,IAAcA,EAAUpM,KAAKrc,MAEhF,IAAb6C,GAAqD,WAAnClD,EAAQ0rB,SAAS1D,eAA6B,CAU9D,GATAkE,EAAc7rB,EACd8rB,EAAansB,EAQI,IAAbkD,IAAmBknB,EAAS1N,KAAKrc,IAAa8pB,EAAazN,KAAKrc,IAAY,CAkB9E,KAhBA8rB,EAAatB,GAASnO,KAAKrc,IAAaqsB,GAAY1sB,EAAQ8C,aAAe9C,KAGxDA,GAAYolB,EAAQuH,SAEjCX,EAAMhsB,EAAQ8O,aAAa,OAC7Bkd,EAAMA,EAAI1U,QAAQ6T,GAAYC,IAE9BprB,EAAQ6O,aAAa,KAAMmd,EAAM/E,IAMrCrvB,GADAq0B,EAAS5D,EAAShoB,IACPtD,OAEJnF,KACLq0B,EAAOr0B,IAAMo0B,EAAM,IAAMA,EAAM,UAAY,IAAMY,GAAWX,EAAOr0B,IAGrEs0B,EAAcD,EAAO7jB,KAAK,KAG5B,IAEE,OADAtI,EAAKqC,MAAMulB,EAASyE,EAAW1d,iBAAiByd,IACzCxE,EACP,MAAOmF,GACPvD,EAAuBjpB,GAAU,GACjC,QACI2rB,IAAQ/E,GACVjnB,EAAQ+O,gBAAgB,QAQlC,OAAOwZ,EAAOloB,EAASiX,QAAQ2S,EAAO,MAAOjqB,EAAS0nB,EAASqE,GAUjE,SAAS5C,KACP,IAAIxjB,EAAO,GAYX,OAVA,SAASmnB,EAAM3zB,EAAKN,GAOlB,OALI8M,EAAK7F,KAAK3G,EAAM,KAAO+uB,EAAK6E,oBAEvBD,EAAMnnB,EAAK6d,SAGbsJ,EAAM3zB,EAAM,KAAON,GAW9B,SAASm0B,GAAa9R,GAEpB,OADAA,EAAG+L,IAAW,EACP/L,EAQT,SAAS+R,GAAO/R,GACd,IAAI1X,EAAKqD,EAASsQ,cAAc,YAEhC,IACE,QAAS+D,EAAG1X,GACZ,MAAO2B,IACP,OAAO,EACP,QAEI3B,EAAGV,YACLU,EAAGV,WAAW6H,YAAYnH,GAI5BA,EAAK,MAUT,SAAS0pB,GAAUC,EAAOxtB,GAIxB,IAHA,IAAI+e,EAAMyO,EAAMhlB,MAAM,KAClBvQ,EAAI8mB,EAAI3hB,OAELnF,KACLswB,EAAKkF,WAAW1O,EAAI9mB,IAAM+H,EAW9B,SAAS0tB,GAAa9R,EAAGC,GACvB,IAAI8R,EAAM9R,GAAKD,EACXgS,EAAOD,GAAsB,IAAf/R,EAAErY,UAAiC,IAAfsY,EAAEtY,UAAkBqY,EAAEiS,YAAchS,EAAEgS,YAE5E,GAAID,EACF,OAAOA,EAIT,GAAID,EACF,KAAOA,EAAMA,EAAIrqB,aACf,GAAIqqB,IAAQ9R,EACV,OAAQ,EAKd,OAAOD,EAAI,GAAK,EAQlB,SAASkS,GAAkBxzB,GACzB,OAAO,SAAUmsB,GAEf,MAAgB,UADLA,EAAKsF,SAAS1D,eACE5B,EAAKnsB,OAASA,GAS7C,SAASyzB,GAAmBzzB,GAC1B,OAAO,SAAUmsB,GACf,IAAIjuB,EAAOiuB,EAAKsF,SAAS1D,cACzB,OAAiB,UAAT7vB,GAA6B,WAATA,IAAsBiuB,EAAKnsB,OAASA,GASpE,SAAS0zB,GAAqBltB,GAE5B,OAAO,SAAU2lB,GAIf,MAAI,SAAUA,EAQRA,EAAKtjB,aAAgC,IAAlBsjB,EAAK3lB,SAEtB,UAAW2lB,EACT,UAAWA,EAAKtjB,WACXsjB,EAAKtjB,WAAWrC,WAAaA,EAE7B2lB,EAAK3lB,WAAaA,EAMtB2lB,EAAKwH,aAAentB,GAG3B2lB,EAAKwH,cAAgBntB,GAAY+qB,GAAmBpF,KAAU3lB,EAGzD2lB,EAAK3lB,WAAaA,EAGhB,UAAW2lB,GACbA,EAAK3lB,WAAaA,GAa/B,SAASotB,GAAuB3S,GAC9B,OAAO8R,IAAa,SAAUc,GAE5B,OADAA,GAAYA,EACLd,IAAa,SAAUjB,EAAMzb,GAKlC,IAJA,IAAIgM,EACAyR,EAAe7S,EAAG,GAAI6Q,EAAKhvB,OAAQ+wB,GACnCl2B,EAAIm2B,EAAahxB,OAEdnF,KACDm0B,EAAKzP,EAAIyR,EAAan2B,MACxBm0B,EAAKzP,KAAOhM,EAAQgM,GAAKyP,EAAKzP,WAaxC,SAASoQ,GAAY1sB,GACnB,OAAOA,GAAmD,qBAAjCA,EAAQusB,sBAAwCvsB,EAi/B3E,IAAKpI,KA7+BLwtB,EAAU6C,GAAO7C,QAAU,GAO3BgD,EAAQH,GAAOG,MAAQ,SAAUhC,GAC/B,IAAI4H,EAAY5H,GAAQA,EAAK6H,aACzBrF,EAAUxC,IAASA,EAAKgG,eAAiBhG,GAAM8H,gBAInD,OAAQ1D,EAAM9N,KAAKsR,GAAapF,GAAWA,EAAQ8C,UAAY,SASjE/C,EAAcV,GAAOU,YAAc,SAAU9lB,GAC3C,IAAIsrB,EACAC,EACA1I,EAAM7iB,EAAOA,EAAKupB,eAAiBvpB,EAAOmmB,EAM9C,OAAItD,GAAO7e,GAA6B,IAAjB6e,EAAIxiB,UAAmBwiB,EAAIwI,iBAMlDtF,GADA/hB,EAAW6e,GACQwI,gBACnBrF,GAAkBT,EAAMvhB,GAOpBmiB,GAAgBniB,IAAaunB,EAAYvnB,EAASwnB,cAAgBD,EAAUE,MAAQF,IAElFA,EAAUzqB,iBACZyqB,EAAUzqB,iBAAiB,SAAU4nB,IAAe,GAC3C6C,EAAUG,aACnBH,EAAUG,YAAY,WAAYhD,KAStCnG,EAAQuH,MAAQM,IAAO,SAAUzpB,GAE/B,OADAolB,EAAQre,YAAY/G,GAAI+G,YAAY1D,EAASsQ,cAAc,QACrB,qBAAxB3T,EAAGiL,mBAAqCjL,EAAGiL,iBAAiB,uBAAuB1R,UAQnGqoB,EAAQvE,WAAaoM,IAAO,SAAUzpB,GAEpC,OADAA,EAAGgrB,UAAY,KACPhrB,EAAGsL,aAAa,gBAM1BsW,EAAQmH,qBAAuBU,IAAO,SAAUzpB,GAE9C,OADAA,EAAG+G,YAAY1D,EAAS4nB,cAAc,MAC9BjrB,EAAG+oB,qBAAqB,KAAKxvB,UAGvCqoB,EAAQoH,uBAAyB7B,EAAQjO,KAAK7V,EAAS2lB,wBAKvDpH,EAAQsJ,QAAUzB,IAAO,SAAUzpB,GAEjC,OADAolB,EAAQre,YAAY/G,GAAIse,GAAKmF,GACrBpgB,EAAS8nB,oBAAsB9nB,EAAS8nB,kBAAkB1H,GAASlqB,UAGzEqoB,EAAQsJ,SACVxG,EAAK1hB,OAAW,GAAI,SAAUsb,GAC5B,IAAI8M,EAAS9M,EAAGxK,QAAQwT,GAAWC,IACnC,OAAO,SAAU3E,GACf,OAAOA,EAAKtX,aAAa,QAAU8f,IAIvC1G,EAAK5W,KAAS,GAAI,SAAUwQ,EAAI9hB,GAC9B,GAAsC,qBAA3BA,EAAQssB,gBAAkCzD,EAAgB,CACnE,IAAIzC,EAAOpmB,EAAQssB,eAAexK,GAClC,OAAOsE,EAAO,CAACA,GAAQ,OAI3B8B,EAAK1hB,OAAW,GAAI,SAAUsb,GAC5B,IAAI8M,EAAS9M,EAAGxK,QAAQwT,GAAWC,IACnC,OAAO,SAAU3E,GACf,IAAIvjB,EAAwC,qBAA1BujB,EAAKyI,kBAAoCzI,EAAKyI,iBAAiB,MACjF,OAAOhsB,GAAQA,EAAKhK,QAAU+1B,IAMlC1G,EAAK5W,KAAS,GAAI,SAAUwQ,EAAI9hB,GAC9B,GAAsC,qBAA3BA,EAAQssB,gBAAkCzD,EAAgB,CACnE,IAAIhmB,EACAjL,EACAouB,EACAI,EAAOpmB,EAAQssB,eAAexK,GAElC,GAAIsE,EAAM,CAIR,IAFAvjB,EAAOujB,EAAKyI,iBAAiB,QAEjBhsB,EAAKhK,QAAUipB,EACzB,MAAO,CAACsE,GAOV,IAHAJ,EAAQhmB,EAAQ2uB,kBAAkB7M,GAClClqB,EAAI,EAEGwuB,EAAOJ,EAAMpuB,MAGlB,IAFAiL,EAAOujB,EAAKyI,iBAAiB,QAEjBhsB,EAAKhK,QAAUipB,EACzB,MAAO,CAACsE,GAKd,MAAO,MAMb8B,EAAK5W,KAAU,IAAI8T,EAAQmH,qBAAuB,SAAUuC,EAAK9uB,GAC/D,MAA4C,qBAAjCA,EAAQusB,qBACVvsB,EAAQusB,qBAAqBuC,GAC3B1J,EAAQqH,IACVzsB,EAAQyO,iBAAiBqgB,QAD3B,GAGL,SAAUA,EAAK9uB,GACjB,IAAIomB,EACArK,EAAM,GACNnkB,EAAI,EAER8vB,EAAU1nB,EAAQusB,qBAAqBuC,GAEvC,GAAY,MAARA,EAAa,CACf,KAAO1I,EAAOsB,EAAQ9vB,MACE,IAAlBwuB,EAAKljB,UACP6Y,EAAIjc,KAAKsmB,GAIb,OAAOrK,EAGT,OAAO2L,GAGTQ,EAAK5W,KAAY,MAAI8T,EAAQoH,wBAA0B,SAAUgC,EAAWxuB,GAC1E,GAA8C,qBAAnCA,EAAQwsB,wBAA0C3D,EAC3D,OAAO7oB,EAAQwsB,uBAAuBgC,IAS1CzF,EAAgB,GAMhBD,EAAY,IAER1D,EAAQqH,IAAM9B,EAAQjO,KAAK7V,EAAS4H,qBAGtCwe,IAAO,SAAUzpB,GACf,IAAIqQ,EAMJ+U,EAAQre,YAAY/G,GAAIgW,UAAY,UAAYyN,EAAZ,qBAAkDA,EAAlD,kEAKhCzjB,EAAGiL,iBAAiB,wBAAwB1R,QAC9C+rB,EAAUhpB,KAAK,SAAW8pB,EAAa,gBAKpCpmB,EAAGiL,iBAAiB,cAAc1R,QACrC+rB,EAAUhpB,KAAK,MAAQ8pB,EAAa,aAAeD,EAAW,KAI3DnmB,EAAGiL,iBAAiB,QAAUwY,EAAU,MAAMlqB,QACjD+rB,EAAUhpB,KAAK,OAQjB+T,EAAQhN,EAASsQ,cAAc,UACzBtI,aAAa,OAAQ,IAC3BrL,EAAG+G,YAAYsJ,GAEVrQ,EAAGiL,iBAAiB,aAAa1R,QACpC+rB,EAAUhpB,KAAK,MAAQ8pB,EAAa,QAAUA,EAAa,KAAOA,EAAa,gBAM5EpmB,EAAGiL,iBAAiB,YAAY1R,QACnC+rB,EAAUhpB,KAAK,YAMZ0D,EAAGiL,iBAAiB,KAAOwY,EAAU,MAAMlqB,QAC9C+rB,EAAUhpB,KAAK,YAKjB0D,EAAGiL,iBAAiB,QACpBqa,EAAUhpB,KAAK,kBAEjBmtB,IAAO,SAAUzpB,GACfA,EAAGgW,UAAY,oFAGf,IAAI3F,EAAQhN,EAASsQ,cAAc,SACnCtD,EAAMhF,aAAa,OAAQ,UAC3BrL,EAAG+G,YAAYsJ,GAAOhF,aAAa,OAAQ,KAGvCrL,EAAGiL,iBAAiB,YAAY1R,QAClC+rB,EAAUhpB,KAAK,OAAS8pB,EAAa,eAKQ,IAA3CpmB,EAAGiL,iBAAiB,YAAY1R,QAClC+rB,EAAUhpB,KAAK,WAAY,aAK7B8oB,EAAQre,YAAY/G,GAAI/C,UAAW,EAEa,IAA5C+C,EAAGiL,iBAAiB,aAAa1R,QACnC+rB,EAAUhpB,KAAK,WAAY,aAK7B0D,EAAGiL,iBAAiB,QACpBqa,EAAUhpB,KAAK,aAIfslB,EAAQvS,gBAAkB8X,EAAQjO,KAAKpM,EAAUsY,EAAQtY,SAAWsY,EAAQ3V,uBAAyB2V,EAAQ9V,oBAAsB8V,EAAQ5V,kBAAoB4V,EAAQ7V,qBACzKka,IAAO,SAAUzpB,GAGf4hB,EAAQ2J,kBAAoBze,EAAQvY,KAAKyL,EAAI,KAG7C8M,EAAQvY,KAAKyL,EAAI,aACjBulB,EAAcjpB,KAAK,KAAMgqB,MAI7BhB,EAAYA,EAAU/rB,QAAU,IAAIitB,OAAOlB,EAAU1gB,KAAK,MAC1D2gB,EAAgBA,EAAchsB,QAAU,IAAIitB,OAAOjB,EAAc3gB,KAAK,MAItE+lB,EAAaxD,EAAQjO,KAAKkM,EAAQoG,yBAIlCroB,EAAWwnB,GAAcxD,EAAQjO,KAAKkM,EAAQjiB,UAAY,SAAU4U,EAAGC,GACrE,IAAIyT,EAAuB,IAAf1T,EAAErY,SAAiBqY,EAAE2S,gBAAkB3S,EAC/C2T,EAAM1T,GAAKA,EAAE1Y,WACjB,OAAOyY,IAAM2T,MAAUA,GAAwB,IAAjBA,EAAIhsB,YAAmB+rB,EAAMtoB,SAAWsoB,EAAMtoB,SAASuoB,GAAO3T,EAAEyT,yBAA4D,GAAjCzT,EAAEyT,wBAAwBE,MACjJ,SAAU3T,EAAGC,GACf,GAAIA,EACF,KAAOA,EAAIA,EAAE1Y,YACX,GAAI0Y,IAAMD,EACR,OAAO,EAKb,OAAO,GAMTgO,EAAY4E,EAAa,SAAU5S,EAAGC,GAEpC,GAAID,IAAMC,EAER,OADAkN,GAAe,EACR,EAIT,IAAIyG,GAAW5T,EAAEyT,yBAA2BxT,EAAEwT,wBAE9C,OAAIG,IAYU,GAHdA,GAAW5T,EAAE6Q,eAAiB7Q,KAAOC,EAAE4Q,eAAiB5Q,GAAKD,EAAEyT,wBAAwBxT,GACvF,KAEoB4J,EAAQgK,cAAgB5T,EAAEwT,wBAAwBzT,KAAO4T,EAMvE5T,GAAK1U,GAAY0U,EAAE6Q,eAAiBpD,GAAgBriB,EAASqiB,EAAczN,IACrE,EAONC,GAAK3U,GAAY2U,EAAE4Q,eAAiBpD,GAAgBriB,EAASqiB,EAAcxN,GACtE,EAIFiN,EAAYhgB,EAAQggB,EAAWlN,GAAK9S,EAAQggB,EAAWjN,GAAK,EAGpD,EAAV2T,GAAe,EAAI,IACxB,SAAU5T,EAAGC,GAEf,GAAID,IAAMC,EAER,OADAkN,GAAe,EACR,EAGT,IAAI4E,EACA11B,EAAI,EACJy3B,EAAM9T,EAAEzY,WACRosB,EAAM1T,EAAE1Y,WACRwsB,EAAK,CAAC/T,GACNgU,EAAK,CAAC/T,GAEV,IAAK6T,IAAQH,EAMX,OAAO3T,GAAK1U,GAAY,EAAI2U,GAAK3U,EAAW,EAE5CwoB,GAAO,EAAIH,EAAM,EAAIzG,EAAYhgB,EAAQggB,EAAWlN,GAAK9S,EAAQggB,EAAWjN,GAAK,EAC5E,GAAI6T,IAAQH,EACjB,OAAO7B,GAAa9R,EAAGC,GAMzB,IAFA8R,EAAM/R,EAEC+R,EAAMA,EAAIxqB,YACfwsB,EAAGrlB,QAAQqjB,GAKb,IAFAA,EAAM9R,EAEC8R,EAAMA,EAAIxqB,YACfysB,EAAGtlB,QAAQqjB,GAIb,KAAOgC,EAAG13B,KAAO23B,EAAG33B,IAClBA,IAGF,OAAOA,EACPy1B,GAAaiC,EAAG13B,GAAI23B,EAAG33B,IAMvB03B,EAAG13B,IAAMoxB,GAAgB,EAAIuG,EAAG33B,IAAMoxB,EAAe,EAErD,GAEKniB,GAjZEA,GAoZXohB,GAAO3X,QAAU,SAAUkf,EAAMhgB,GAC/B,OAAOyY,GAAOuH,EAAM,KAAM,KAAMhgB,IAGlCyY,GAAOpV,gBAAkB,SAAUuT,EAAMoJ,GAGvC,GAFA7G,EAAYvC,GAERhB,EAAQvS,iBAAmBgW,IAAmBS,EAAuBkG,EAAO,QAAUzG,IAAkBA,EAAcrM,KAAK8S,OAAY1G,IAAcA,EAAUpM,KAAK8S,IACtK,IACE,IAAIrR,EAAM7N,EAAQvY,KAAKquB,EAAMoJ,GAE7B,GAAIrR,GAAOiH,EAAQ2J,mBAEnB3I,EAAKvf,UAAuC,KAA3Buf,EAAKvf,SAAS3D,SAC7B,OAAOib,EAET,MAAOhZ,IACPmkB,EAAuBkG,GAAM,GAIjC,OAAOvH,GAAOuH,EAAM3oB,EAAU,KAAM,CAACuf,IAAOrpB,OAAS,GAGvDkrB,GAAOthB,SAAW,SAAU3G,EAASomB,GAUnC,OAJKpmB,EAAQosB,eAAiBpsB,IAAY6G,GACxC8hB,EAAY3oB,GAGP2G,EAAS3G,EAASomB,IAG3B6B,GAAOwH,KAAO,SAAUrJ,EAAMjuB,IAMvBiuB,EAAKgG,eAAiBhG,IAASvf,GAClC8hB,EAAYvC,GAGd,IAAIlL,EAAKgN,EAAKkF,WAAWj1B,EAAK6vB,eAE9B5K,EAAMlC,GAAM+J,EAAOltB,KAAKmwB,EAAKkF,WAAYj1B,EAAK6vB,eAAiB9M,EAAGkL,EAAMjuB,GAAO0wB,QAAkBhrB,EACjG,YAAeA,IAARuf,EAAoBA,EAAMgI,EAAQvE,aAAegI,EAAiBzC,EAAKtX,aAAa3W,IAASilB,EAAMgJ,EAAKyI,iBAAiB12B,KAAUilB,EAAIsS,UAAYtS,EAAIvkB,MAAQ,MAGxKovB,GAAO+C,OAAS,SAAU2E,GACxB,OAAQA,EAAM,IAAIrY,QAAQ6T,GAAYC,KAGxCnD,GAAO5rB,MAAQ,SAAUF,GACvB,MAAM,IAAIye,MAAM,0CAA4Cze,IAQ9D8rB,GAAO2H,WAAa,SAAUlI,GAC5B,IAAItB,EACAyJ,EAAa,GACbvT,EAAI,EACJ1kB,EAAI,EAMR,GAJA8wB,GAAgBtD,EAAQ0K,iBACxBrH,GAAarD,EAAQ2K,YAAcrI,EAAQrhB,MAAM,GACjDqhB,EAAQ9hB,KAAK2jB,GAETb,EAAc,CAChB,KAAOtC,EAAOsB,EAAQ9vB,MAChBwuB,IAASsB,EAAQ9vB,KACnB0kB,EAAIuT,EAAW/vB,KAAKlI,IAIxB,KAAO0kB,KACLoL,EAAQf,OAAOkJ,EAAWvT,GAAI,GAOlC,OADAmM,EAAY,KACLf,GAQTS,EAAUF,GAAOE,QAAU,SAAU/B,GACnC,IAAIvjB,EACAsb,EAAM,GACNvmB,EAAI,EACJsL,EAAWkjB,EAAKljB,SAEpB,GAAKA,GAME,GAAiB,IAAbA,GAA+B,IAAbA,GAA+B,KAAbA,EAAiB,CAG9D,GAAgC,kBAArBkjB,EAAK4J,YACd,OAAO5J,EAAK4J,YAGZ,IAAK5J,EAAOA,EAAKrjB,WAAYqjB,EAAMA,EAAOA,EAAKnjB,YAC7Ckb,GAAOgK,EAAQ/B,QAGd,GAAiB,IAAbljB,GAA+B,IAAbA,EAC3B,OAAOkjB,EAAK6J,eAhBZ,KAAOptB,EAAOujB,EAAKxuB,MAEjBumB,GAAOgK,EAAQtlB,GAkBnB,OAAOsb,IAGT+J,EAAOD,GAAOiI,UAAY,CAExBnD,YAAa,GACboD,aAAcnD,GACd7c,MAAOoa,EACP6C,WAAY,GACZ9b,KAAM,GACN8e,SAAU,CACR,IAAK,CACHzE,IAAK,aACLhN,OAAO,GAET,IAAK,CACHgN,IAAK,cAEP,IAAK,CACHA,IAAK,kBACLhN,OAAO,GAET,IAAK,CACHgN,IAAK,oBAGT0E,UAAW,CACT,KAAQ,SAAclgB,GASpB,OARAA,EAAM,GAAKA,EAAM,GAAGmH,QAAQwT,GAAWC,IAEvC5a,EAAM,IAAMA,EAAM,IAAMA,EAAM,IAAMA,EAAM,IAAM,IAAImH,QAAQwT,GAAWC,IAEtD,OAAb5a,EAAM,KACRA,EAAM,GAAK,IAAMA,EAAM,GAAK,KAGvBA,EAAM9J,MAAM,EAAG,IAExB,MAAS,SAAe8J,GA2BtB,OAhBAA,EAAM,GAAKA,EAAM,GAAG6X,cAES,QAAzB7X,EAAM,GAAG9J,MAAM,EAAG,IAEf8J,EAAM,IACT8X,GAAO5rB,MAAM8T,EAAM,IAKrBA,EAAM,KAAOA,EAAM,GAAKA,EAAM,IAAMA,EAAM,IAAM,GAAK,GAAkB,SAAbA,EAAM,IAA8B,QAAbA,EAAM,KACvFA,EAAM,KAAOA,EAAM,GAAKA,EAAM,IAAmB,QAAbA,EAAM,KACjCA,EAAM,IACf8X,GAAO5rB,MAAM8T,EAAM,IAGdA,GAET,OAAU,SAAgBA,GACxB,IAAImgB,EACAC,GAAYpgB,EAAM,IAAMA,EAAM,GAElC,OAAIoa,EAAiB,MAAE7N,KAAKvM,EAAM,IACzB,MAILA,EAAM,GACRA,EAAM,GAAKA,EAAM,IAAMA,EAAM,IAAM,GAC1BogB,GAAYlG,EAAQ3N,KAAK6T,KACpCD,EAASjI,EAASkI,GAAU,MAC5BD,EAASC,EAAS9nB,QAAQ,IAAK8nB,EAASxzB,OAASuzB,GAAUC,EAASxzB,UAElEoT,EAAM,GAAKA,EAAM,GAAG9J,MAAM,EAAGiqB,GAC7BngB,EAAM,GAAKogB,EAASlqB,MAAM,EAAGiqB,IAIxBngB,EAAM9J,MAAM,EAAG,MAG1BG,OAAQ,CACN,IAAO,SAAagqB,GAClB,IAAI9E,EAAW8E,EAAiBlZ,QAAQwT,GAAWC,IAAW/C,cAC9D,MAA4B,MAArBwI,EAA2B,WAChC,OAAO,GACL,SAAUpK,GACZ,OAAOA,EAAKsF,UAAYtF,EAAKsF,SAAS1D,gBAAkB0D,IAG5D,MAAS,SAAe8C,GACtB,IAAI7tB,EAAUuoB,EAAWsF,EAAY,KACrC,OAAO7tB,IAAYA,EAAU,IAAIqpB,OAAO,MAAQJ,EAAa,IAAM4E,EAAY,IAAM5E,EAAa,SAAWV,EAAWsF,GAAW,SAAUpI,GAC3I,OAAOzlB,EAAQ+b,KAA+B,kBAAnB0J,EAAKoI,WAA0BpI,EAAKoI,WAA0C,qBAAtBpI,EAAKtX,cAAgCsX,EAAKtX,aAAa,UAAY,QAG1J,KAAQ,SAAc3W,EAAMs4B,EAAUC,GACpC,OAAO,SAAUtK,GACf,IAAIrkB,EAASkmB,GAAOwH,KAAKrJ,EAAMjuB,GAE/B,OAAc,MAAV4J,EACkB,OAAb0uB,GAGJA,IAIL1uB,GAAU,GAGU,MAAb0uB,EAAmB1uB,IAAW2uB,EAAqB,OAAbD,EAAoB1uB,IAAW2uB,EAAqB,OAAbD,EAAoBC,GAAmC,IAA1B3uB,EAAO0G,QAAQioB,GAA4B,OAAbD,EAAoBC,GAAS3uB,EAAO0G,QAAQioB,IAAU,EAAiB,OAAbD,EAAoBC,GAAS3uB,EAAOsE,OAAOqqB,EAAM3zB,UAAY2zB,EAAqB,OAAbD,GAAqB,IAAM1uB,EAAOuV,QAAQyS,EAAa,KAAO,KAAKthB,QAAQioB,IAAU,EAAiB,OAAbD,IAAoB1uB,IAAW2uB,GAAS3uB,EAAOsE,MAAM,EAAGqqB,EAAM3zB,OAAS,KAAO2zB,EAAQ,QAIjc,MAAS,SAAez2B,EAAM02B,EAAMC,EAAWjS,EAAO2H,GACpD,IAAIuK,EAA8B,QAArB52B,EAAKoM,MAAM,EAAG,GACvByqB,EAA6B,SAAnB72B,EAAKoM,OAAO,GACtB0qB,EAAkB,YAATJ,EACb,OAAiB,IAAVhS,GAAwB,IAAT2H,EACtB,SAAUF,GACR,QAASA,EAAKtjB,YACZ,SAAUsjB,EAAM4K,EAAU3b,GAC5B,IAAIyX,EACAmE,EACAC,EACAruB,EACAsuB,EACA1nB,EACAkiB,EAAMkF,IAAWC,EAAU,cAAgB,kBAC3ChzB,EAASsoB,EAAKtjB,WACd3K,EAAO44B,GAAU3K,EAAKsF,SAAS1D,cAC/BoJ,GAAY/b,IAAQ0b,EACpBxD,GAAO,EAEX,GAAIzvB,EAAQ,CAEV,GAAI+yB,EAAQ,CACV,KAAOlF,GAAK,CAGV,IAFA9oB,EAAOujB,EAEAvjB,EAAOA,EAAK8oB,IACjB,GAAIoF,EAASluB,EAAK6oB,SAAS1D,gBAAkB7vB,EAAyB,IAAlB0K,EAAKK,SACvD,OAAO,EAKXuG,EAAQkiB,EAAe,SAAT1xB,IAAoBwP,GAAS,cAG7C,OAAO,EAKT,GAFAA,EAAQ,CAACqnB,EAAUhzB,EAAOiF,WAAajF,EAAOuzB,WAE1CP,GAAWM,GAab,IAHA7D,GADA4D,GADArE,GADAmE,GAHAC,GADAruB,EAAO/E,GACWmpB,KAAapkB,EAAKokB,GAAW,KAGtBpkB,EAAKyuB,YAAcJ,EAAWruB,EAAKyuB,UAAY,KACpDr3B,IAAS,IACX,KAAOgvB,GAAW6D,EAAM,KACtBA,EAAM,GAC1BjqB,EAAOsuB,GAAarzB,EAAO+tB,WAAWsF,GAE/BtuB,IAASsuB,GAAatuB,GAAQA,EAAK8oB,KAC1C4B,EAAO4D,EAAY,IAAM1nB,EAAM+f,OAE7B,GAAsB,IAAlB3mB,EAAKK,YAAoBqqB,GAAQ1qB,IAASujB,EAAM,CAClD6K,EAAYh3B,GAAQ,CAACgvB,EAASkI,EAAW5D,GACzC,YAmBJ,GAdI6D,IASF7D,EADA4D,GADArE,GADAmE,GAHAC,GADAruB,EAAOujB,GACWa,KAAapkB,EAAKokB,GAAW,KAGtBpkB,EAAKyuB,YAAcJ,EAAWruB,EAAKyuB,UAAY,KACpDr3B,IAAS,IACX,KAAOgvB,GAAW6D,EAAM,KAM/B,IAATS,EAEF,MAAO1qB,IAASsuB,GAAatuB,GAAQA,EAAK8oB,KAAS4B,EAAO4D,EAAY,IAAM1nB,EAAM+f,UAC3EuH,EAASluB,EAAK6oB,SAAS1D,gBAAkB7vB,EAAyB,IAAlB0K,EAAKK,cAAqBqqB,IAEzE6D,KAIFH,GAHAC,EAAaruB,EAAKokB,KAAapkB,EAAKokB,GAAW,KAGtBpkB,EAAKyuB,YAAcJ,EAAWruB,EAAKyuB,UAAY,KAC5Dr3B,GAAQ,CAACgvB,EAASsE,IAG5B1qB,IAASujB,MAUrB,OADAmH,GAAQjH,KACQ3H,GAAS4O,EAAO5O,IAAU,GAAK4O,EAAO5O,GAAS,KAIrE,OAAU,SAAgB4S,EAAQzD,GAKhC,IAAIhsB,EACAoZ,EAAKgN,EAAK4B,QAAQyH,IAAWrJ,EAAKsJ,WAAWD,EAAOvJ,gBAAkBC,GAAO5rB,MAAM,uBAAyBk1B,GAIhH,OAAIrW,EAAG+L,GACE/L,EAAG4S,GAIR5S,EAAGne,OAAS,GACd+E,EAAO,CAACyvB,EAAQA,EAAQ,GAAIzD,GACrB5F,EAAKsJ,WAAW/3B,eAAe83B,EAAOvJ,eAAiBgF,IAAa,SAAUjB,EAAMzb,GAKzF,IAJA,IAAImhB,EACAzuB,EAAUkY,EAAG6Q,EAAM+B,GACnBl2B,EAAIoL,EAAQjG,OAETnF,KAELm0B,EADA0F,EAAMhpB,EAAQsjB,EAAM/oB,EAAQpL,OACd0Y,EAAQmhB,GAAOzuB,EAAQpL,OAEpC,SAAUwuB,GACb,OAAOlL,EAAGkL,EAAM,EAAGtkB,KAIhBoZ,IAGX4O,QAAS,CAEP,IAAOkD,IAAa,SAAU3sB,GAI5B,IAAIwT,EAAQ,GACR6T,EAAU,GACVgK,EAAUpJ,EAAQjoB,EAASiX,QAAQ2S,EAAO,OAC9C,OAAOyH,EAAQzK,GAAW+F,IAAa,SAAUjB,EAAMzb,EAAS0gB,EAAU3b,GAKxE,IAJA,IAAI+Q,EACAuL,EAAYD,EAAQ3F,EAAM,KAAM1W,EAAK,IACrCzd,EAAIm0B,EAAKhvB,OAENnF,MACDwuB,EAAOuL,EAAU/5B,MACnBm0B,EAAKn0B,KAAO0Y,EAAQ1Y,GAAKwuB,OAG1B,SAAUA,EAAM4K,EAAU3b,GAK7B,OAJAxB,EAAM,GAAKuS,EACXsL,EAAQ7d,EAAO,KAAMwB,EAAKqS,GAE1B7T,EAAM,GAAK,MACH6T,EAAQ8B,UAGpB,IAAOwD,IAAa,SAAU3sB,GAC5B,OAAO,SAAU+lB,GACf,OAAO6B,GAAO5nB,EAAU+lB,GAAMrpB,OAAS,MAG3C,SAAYiwB,IAAa,SAAU7X,GAEjC,OADAA,EAAOA,EAAKmC,QAAQwT,GAAWC,IACxB,SAAU3E,GACf,OAAQA,EAAK4J,aAAe7H,EAAQ/B,IAAO3d,QAAQ0M,IAAS,MAUhE,KAAQ6X,IAAa,SAAU4E,GAO7B,OALKtH,EAAY5N,KAAKkV,GAAQ,KAC5B3J,GAAO5rB,MAAM,qBAAuBu1B,GAGtCA,EAAOA,EAAKta,QAAQwT,GAAWC,IAAW/C,cACnC,SAAU5B,GACf,IAAIyL,EAEJ,GACE,GAAIA,EAAWhJ,EAAiBzC,EAAKwL,KAAOxL,EAAKtX,aAAa,aAAesX,EAAKtX,aAAa,QAE7F,OADA+iB,EAAWA,EAAS7J,iBACA4J,GAAyC,IAAjCC,EAASppB,QAAQmpB,EAAO,YAE9CxL,EAAOA,EAAKtjB,aAAiC,IAAlBsjB,EAAKljB,UAE1C,OAAO,MAIX,OAAU,SAAgBkjB,GACxB,IAAI7H,EAAOnb,EAAOiT,UAAYjT,EAAOiT,SAASkI,KAC9C,OAAOA,GAAQA,EAAKlY,MAAM,KAAO+f,EAAKtE,IAExC,KAAQ,SAAcsE,GACpB,OAAOA,IAASwC,GAElB,MAAS,SAAexC,GACtB,OAAOA,IAASvf,EAASirB,iBAAmBjrB,EAASkrB,UAAYlrB,EAASkrB,gBAAkB3L,EAAKnsB,MAAQmsB,EAAK9P,OAAS8P,EAAK4L,WAG9H,QAAWrE,IAAqB,GAChC,SAAYA,IAAqB,GACjC,QAAW,SAAiBvH,GAG1B,IAAIsF,EAAWtF,EAAKsF,SAAS1D,cAC7B,MAAoB,UAAb0D,KAA0BtF,EAAKjO,SAAwB,WAAbuT,KAA2BtF,EAAKlO,UAEnF,SAAY,SAAkBkO,GAQ5B,OALIA,EAAKtjB,YAEPsjB,EAAKtjB,WAAWmvB,eAGO,IAAlB7L,EAAKlO,UAGd,MAAS,SAAekO,GAKtB,IAAKA,EAAOA,EAAKrjB,WAAYqjB,EAAMA,EAAOA,EAAKnjB,YAC7C,GAAImjB,EAAKljB,SAAW,EAClB,OAAO,EAIX,OAAO,GAET,OAAU,SAAgBkjB,GACxB,OAAQ8B,EAAK4B,QAAe,MAAE1D,IAGhC,OAAU,SAAgBA,GACxB,OAAOsE,EAAQhO,KAAK0J,EAAKsF,WAE3B,MAAS,SAAetF,GACtB,OAAOqE,EAAQ/N,KAAK0J,EAAKsF,WAE3B,OAAU,SAAgBtF,GACxB,IAAIjuB,EAAOiuB,EAAKsF,SAAS1D,cACzB,MAAgB,UAAT7vB,GAAkC,WAAdiuB,EAAKnsB,MAA8B,WAAT9B,GAEvD,KAAQ,SAAciuB,GACpB,IAAIqJ,EACJ,MAAuC,UAAhCrJ,EAAKsF,SAAS1D,eAA2C,SAAd5B,EAAKnsB,OAEjB,OAArCw1B,EAAOrJ,EAAKtX,aAAa,UAA2C,SAAvB2gB,EAAKzH,gBAGrD,MAAS6F,IAAuB,WAC9B,MAAO,CAAC,MAEV,KAAQA,IAAuB,SAAUqE,EAAen1B,GACtD,MAAO,CAACA,EAAS,MAEnB,GAAM8wB,IAAuB,SAAUqE,EAAen1B,EAAQ+wB,GAC5D,MAAO,CAACA,EAAW,EAAIA,EAAW/wB,EAAS+wB,MAE7C,KAAQD,IAAuB,SAAUE,EAAchxB,GAGrD,IAFA,IAAInF,EAAI,EAEDA,EAAImF,EAAQnF,GAAK,EACtBm2B,EAAajuB,KAAKlI,GAGpB,OAAOm2B,KAET,IAAOF,IAAuB,SAAUE,EAAchxB,GAGpD,IAFA,IAAInF,EAAI,EAEDA,EAAImF,EAAQnF,GAAK,EACtBm2B,EAAajuB,KAAKlI,GAGpB,OAAOm2B,KAET,GAAMF,IAAuB,SAAUE,EAAchxB,EAAQ+wB,GAG3D,IAFA,IAAIl2B,EAAIk2B,EAAW,EAAIA,EAAW/wB,EAAS+wB,EAAW/wB,EAASA,EAAS+wB,IAE/Dl2B,GAAK,GACZm2B,EAAajuB,KAAKlI,GAGpB,OAAOm2B,KAET,GAAMF,IAAuB,SAAUE,EAAchxB,EAAQ+wB,GAG3D,IAFA,IAAIl2B,EAAIk2B,EAAW,EAAIA,EAAW/wB,EAAS+wB,IAElCl2B,EAAImF,GACXgxB,EAAajuB,KAAKlI,GAGpB,OAAOm2B,QAIRjE,QAAa,IAAI5B,EAAK4B,QAAY,GAE7B,CACRqI,OAAO,EACPC,UAAU,EACV7S,MAAM,EACN8S,UAAU,EACVC,OAAO,GAEPpK,EAAK4B,QAAQlyB,GAAK61B,GAAkB71B,GAGtC,IAAKA,IAAK,CACR26B,QAAQ,EACRtV,OAAO,GAEPiL,EAAK4B,QAAQlyB,GAAK81B,GAAmB91B,GAIvC,SAAS45B,MAuET,SAAS5E,GAAW4F,GAKlB,IAJA,IAAI56B,EAAI,EACJoR,EAAMwpB,EAAOz1B,OACbsD,EAAW,GAERzI,EAAIoR,EAAKpR,IACdyI,GAAYmyB,EAAO56B,GAAGiB,MAGxB,OAAOwH,EAGT,SAASorB,GAAciG,EAASe,EAAYC,GAC1C,IAAI/G,EAAM8G,EAAW9G,IACjBgH,EAAOF,EAAW7G,KAClBzyB,EAAMw5B,GAAQhH,EACdiH,EAAmBF,GAAgB,eAARv5B,EAC3B05B,EAAWnc,IACf,OAAO+b,EAAW9T,MAClB,SAAUyH,EAAMpmB,EAASqV,GACvB,KAAO+Q,EAAOA,EAAKuF,IACjB,GAAsB,IAAlBvF,EAAKljB,UAAkB0vB,EACzB,OAAOlB,EAAQtL,EAAMpmB,EAASqV,GAIlC,OAAO,GAET,SAAU+Q,EAAMpmB,EAASqV,GACvB,IAAIyd,EACA7B,EACAC,EACA6B,EAAW,CAAC9J,EAAS4J,GAEzB,GAAIxd,GACF,KAAO+Q,EAAOA,EAAKuF,IACjB,IAAsB,IAAlBvF,EAAKljB,UAAkB0vB,IACrBlB,EAAQtL,EAAMpmB,EAASqV,GACzB,OAAO,OAKb,KAAO+Q,EAAOA,EAAKuF,IACjB,GAAsB,IAAlBvF,EAAKljB,UAAkB0vB,EAMzB,GAFA3B,GAHAC,EAAa9K,EAAKa,KAAab,EAAKa,GAAW,KAGtBb,EAAKkL,YAAcJ,EAAW9K,EAAKkL,UAAY,IAEpEqB,GAAQA,IAASvM,EAAKsF,SAAS1D,cACjC5B,EAAOA,EAAKuF,IAAQvF,MACf,KAAK0M,EAAW7B,EAAY93B,KAAS25B,EAAS,KAAO7J,GAAW6J,EAAS,KAAOD,EAErF,OAAOE,EAAS,GAAKD,EAAS,GAK9B,GAFA7B,EAAY93B,GAAO45B,EAEfA,EAAS,GAAKrB,EAAQtL,EAAMpmB,EAASqV,GACvC,OAAO,EAOjB,OAAO,GAIX,SAAS2d,GAAeC,GACtB,OAAOA,EAASl2B,OAAS,EAAI,SAAUqpB,EAAMpmB,EAASqV,GAGpD,IAFA,IAAIzd,EAAIq7B,EAASl2B,OAEVnF,KACL,IAAKq7B,EAASr7B,GAAGwuB,EAAMpmB,EAASqV,GAC9B,OAAO,EAIX,OAAO,GACL4d,EAAS,GAcf,SAASC,GAASvB,EAAWvZ,EAAK5R,EAAQxG,EAASqV,GAOjD,IANA,IAAI+Q,EACA+M,EAAe,GACfv7B,EAAI,EACJoR,EAAM2oB,EAAU50B,OAChBq2B,EAAgB,MAAPhb,EAENxgB,EAAIoR,EAAKpR,KACVwuB,EAAOuL,EAAU/5B,MACd4O,IAAUA,EAAO4f,EAAMpmB,EAASqV,KACnC8d,EAAarzB,KAAKsmB,GAEdgN,GACFhb,EAAItY,KAAKlI,KAMjB,OAAOu7B,EAGT,SAASE,GAAWhD,EAAWhwB,EAAUqxB,EAAS4B,EAAYC,EAAYC,GASxE,OARIF,IAAeA,EAAWrM,KAC5BqM,EAAaD,GAAWC,IAGtBC,IAAeA,EAAWtM,KAC5BsM,EAAaF,GAAWE,EAAYC,IAG/BxG,IAAa,SAAUjB,EAAMrE,EAAS1nB,EAASqV,GACpD,IAAIoe,EACA77B,EACAwuB,EACAsN,EAAS,GACTC,EAAU,GACVC,EAAclM,EAAQ3qB,OAE1BipB,EAAQ+F,GAlDZ,SAA0B1rB,EAAUwzB,EAAUnM,GAI5C,IAHA,IAAI9vB,EAAI,EACJoR,EAAM6qB,EAAS92B,OAEZnF,EAAIoR,EAAKpR,IACdqwB,GAAO5nB,EAAUwzB,EAASj8B,GAAI8vB,GAGhC,OAAOA,EA0CWoM,CAAiBzzB,GAAY,IAAKL,EAAQkD,SAAW,CAAClD,GAAWA,EAAS,IAE1F+zB,GAAY1D,IAActE,GAAS1rB,EAA+D2lB,EAAnDkN,GAASlN,EAAO0N,EAAQrD,EAAWrwB,EAASqV,GACvF2e,EAAatC,EACjB6B,IAAexH,EAAOsE,EAAYuD,GAAeN,GACjD,GACA5L,EAAUqM,EAOV,GALIrC,GACFA,EAAQqC,EAAWC,EAAYh0B,EAASqV,GAItCie,EAMF,IALAG,EAAOP,GAASc,EAAYL,GAC5BL,EAAWG,EAAM,GAAIzzB,EAASqV,GAE9Bzd,EAAI67B,EAAK12B,OAEFnF,MACDwuB,EAAOqN,EAAK77B,MACdo8B,EAAWL,EAAQ/7B,MAAQm8B,EAAUJ,EAAQ/7B,IAAMwuB,IAKzD,GAAI2F,GACF,GAAIwH,GAAclD,EAAW,CAC3B,GAAIkD,EAAY,CAKd,IAHAE,EAAO,GACP77B,EAAIo8B,EAAWj3B,OAERnF,MACDwuB,EAAO4N,EAAWp8B,KAEpB67B,EAAK3zB,KAAKi0B,EAAUn8B,GAAKwuB,GAI7BmN,EAAW,KAAMS,EAAa,GAAIP,EAAMpe,GAM1C,IAFAzd,EAAIo8B,EAAWj3B,OAERnF,MACAwuB,EAAO4N,EAAWp8B,MAAQ67B,EAAOF,EAAa9qB,EAAQsjB,EAAM3F,GAAQsN,EAAO97B,KAAO,IACrFm0B,EAAK0H,KAAU/L,EAAQ+L,GAAQrN,UAMrC4N,EAAad,GAASc,IAAetM,EAAUsM,EAAWrN,OAAOiN,EAAaI,EAAWj3B,QAAUi3B,GAE/FT,EACFA,EAAW,KAAM7L,EAASsM,EAAY3e,GAEtCvV,EAAKqC,MAAMulB,EAASsM,MAM5B,SAASC,GAAkBzB,GAsBzB,IArBA,IAAI0B,EACAxC,EACApV,EACAtT,EAAMwpB,EAAOz1B,OACbo3B,EAAkBjM,EAAKkI,SAASoC,EAAO,GAAGv4B,MAC1Cm6B,EAAmBD,GAAmBjM,EAAKkI,SAAS,KACpDx4B,EAAIu8B,EAAkB,EAAI,EAE9BE,EAAe5I,IAAc,SAAUrF,GACrC,OAAOA,IAAS8N,IACfE,GAAkB,GACjBE,EAAkB7I,IAAc,SAAUrF,GAC5C,OAAO3d,EAAQyrB,EAAc9N,IAAS,IACrCgO,GAAkB,GACjBnB,EAAW,CAAC,SAAU7M,EAAMpmB,EAASqV,GACvC,IAAI8I,GAAOgW,IAAoB9e,GAAOrV,IAAYwoB,MAAuB0L,EAAel0B,GAASkD,SAAWmxB,EAAajO,EAAMpmB,EAASqV,GAAOif,EAAgBlO,EAAMpmB,EAASqV,IAG9K,OADA6e,EAAe,KACR/V,IAGFvmB,EAAIoR,EAAKpR,IACd,GAAI85B,EAAUxJ,EAAKkI,SAASoC,EAAO56B,GAAGqC,MACpCg5B,EAAW,CAACxH,GAAcuH,GAAeC,GAAWvB,QAC/C,CAGL,IAFAA,EAAUxJ,EAAK1hB,OAAOgsB,EAAO56B,GAAGqC,MAAMkI,MAAM,KAAMqwB,EAAO56B,GAAG0Y,UAEhD2W,GAAU,CAIpB,IAFA3K,IAAM1kB,EAEC0kB,EAAItT,IACLkf,EAAKkI,SAASoC,EAAOlW,GAAGriB,MADdqiB,KAMhB,OAAO+W,GAAWz7B,EAAI,GAAKo7B,GAAeC,GAAWr7B,EAAI,GAAKg1B,GAC9D4F,EAAOnsB,MAAM,EAAGzO,EAAI,GAAGsP,OAAO,CAC5BrO,MAA8B,MAAvB25B,EAAO56B,EAAI,GAAGqC,KAAe,IAAM,MACxCqd,QAAQ2S,EAAO,MAAOyH,EAAS95B,EAAI0kB,GAAK2X,GAAkBzB,EAAOnsB,MAAMzO,EAAG0kB,IAAKA,EAAItT,GAAOirB,GAAkBzB,EAASA,EAAOnsB,MAAMiW,IAAKA,EAAItT,GAAO4jB,GAAW4F,IAGnKS,EAASnzB,KAAK4xB,GAIlB,OAAOsB,GAAeC,GA2RxB,OAxlBAzB,GAAWh4B,UAAY0uB,EAAKqM,QAAUrM,EAAK4B,QAC3C5B,EAAKsJ,WAAa,IAAIA,GAEtBnJ,EAAWJ,GAAOI,SAAW,SAAUhoB,EAAUm0B,GAC/C,IAAIxxB,EACAmN,EACAqiB,EACAv4B,EACAw6B,EACAxI,EACAyI,EACAC,EAASvL,EAAW/oB,EAAW,KAEnC,GAAIs0B,EACF,OAAOH,EAAY,EAAIG,EAAOtuB,MAAM,GAOtC,IAJAouB,EAAQp0B,EACR4rB,EAAS,GACTyI,EAAaxM,EAAKmI,UAEXoE,GAAO,CAwBZ,IAAKx6B,KAtBA+I,KAAYmN,EAAQ+Z,EAAOmC,KAAKoI,MAC/BtkB,IAEFskB,EAAQA,EAAMpuB,MAAM8J,EAAM,GAAGpT,SAAW03B,GAG1CxI,EAAOnsB,KAAK0yB,EAAS,KAGvBxvB,GAAU,GAENmN,EAAQga,EAAakC,KAAKoI,MAC5BzxB,EAAUmN,EAAMqT,QAChBgP,EAAO1yB,KAAK,CACVjH,MAAOmK,EAEP/I,KAAMkW,EAAM,GAAGmH,QAAQ2S,EAAO,OAEhCwK,EAAQA,EAAMpuB,MAAMrD,EAAQjG,SAIjBmrB,EAAK1hB,SACX2J,EAAQoa,EAAUtwB,GAAMoyB,KAAKoI,KAAaC,EAAWz6B,MAAUkW,EAAQukB,EAAWz6B,GAAMkW,MAC3FnN,EAAUmN,EAAMqT,QAChBgP,EAAO1yB,KAAK,CACVjH,MAAOmK,EACP/I,KAAMA,EACNqW,QAASH,IAEXskB,EAAQA,EAAMpuB,MAAMrD,EAAQjG,SAIhC,IAAKiG,EACH,MAOJ,OAAOwxB,EAAYC,EAAM13B,OAAS03B,EAAQxM,GAAO5rB,MAAMgE,GACvD+oB,EAAW/oB,EAAU4rB,GAAQ5lB,MAAM,IAoXrCiiB,EAAUL,GAAOK,QAAU,SAAUjoB,EAAU8P,GAG7C,IAAIvY,EACAg9B,EAAc,GACdC,EAAkB,GAClBF,EAAStL,EAAchpB,EAAW,KAEtC,IAAKs0B,EAAQ,CAQX,IANKxkB,IACHA,EAAQkY,EAAShoB,IAGnBzI,EAAIuY,EAAMpT,OAEHnF,MACL+8B,EAASV,GAAkB9jB,EAAMvY,KAEtBqvB,GACT2N,EAAY90B,KAAK60B,GAEjBE,EAAgB/0B,KAAK60B,IAKzBA,EAAStL,EAAchpB,EAjJ3B,SAAkCw0B,EAAiBD,GACjD,IAAIE,EAAQF,EAAY73B,OAAS,EAC7Bg4B,EAAYF,EAAgB93B,OAAS,EACrCi4B,EAAe,SAAsBjJ,EAAM/rB,EAASqV,EAAKqS,EAASuN,GACpE,IAAI7O,EACA9J,EACAoV,EACAwD,EAAe,EACft9B,EAAI,IACJ+5B,EAAY5F,GAAQ,GACpBoJ,EAAa,GACbC,EAAgB5M,EAEpBxC,EAAQ+F,GAAQgJ,GAAa7M,EAAK5W,KAAU,IAAE,IAAK2jB,GAEnDI,EAAgBpM,GAA4B,MAAjBmM,EAAwB,EAAIzrB,KAAKud,UAAY,GACpEle,EAAMgd,EAAMjpB,OAahB,IAXIk4B,IAKFzM,EAAmBxoB,GAAW6G,GAAY7G,GAAWi1B,GAMhDr9B,IAAMoR,GAA4B,OAApBod,EAAOJ,EAAMpuB,IAAaA,IAAK,CAClD,GAAIm9B,GAAa3O,EAAM,CAWrB,IAVA9J,EAAI,EAKCtc,GAAWomB,EAAKgG,eAAiBvlB,IACpC8hB,EAAYvC,GACZ/Q,GAAOwT,GAGF6I,EAAUmD,EAAgBvY,MAC/B,GAAIoV,EAAQtL,EAAMpmB,GAAW6G,EAAUwO,GAAM,CAC3CqS,EAAQ5nB,KAAKsmB,GACb,MAIA6O,IACFhM,EAAUoM,GAKVP,KAEE1O,GAAQsL,GAAWtL,IACrB8O,IAIEnJ,GACF4F,EAAU7xB,KAAKsmB,IAerB,GARA8O,GAAgBt9B,EAQZk9B,GAASl9B,IAAMs9B,EAAc,CAG/B,IAFA5Y,EAAI,EAEGoV,EAAUkD,EAAYtY,MAC3BoV,EAAQC,EAAWwD,EAAYn1B,EAASqV,GAG1C,GAAI0W,EAAM,CAER,GAAImJ,EAAe,EACjB,KAAOt9B,KACC+5B,EAAU/5B,IAAMu9B,EAAWv9B,KAC/Bu9B,EAAWv9B,GAAK4xB,EAAIzxB,KAAK2vB,IAM/ByN,EAAajC,GAASiC,GAIxBr1B,EAAKqC,MAAMulB,EAASyN,GAEhBF,IAAclJ,GAAQoJ,EAAWp4B,OAAS,GAAKm4B,EAAeN,EAAY73B,OAAS,GACrFkrB,GAAO2H,WAAWlI,GAUtB,OALIuN,IACFhM,EAAUoM,EACV7M,EAAmB4M,GAGdzD,GAGT,OAAOmD,EAAQ9H,GAAagI,GAAgBA,EA8BTM,CAAyBT,EAAiBD,KAEpEv0B,SAAWA,EAGpB,OAAOs0B,GAaTpM,EAASN,GAAOM,OAAS,SAAUloB,EAAUL,EAAS0nB,EAASqE,GAC7D,IAAIn0B,EACA46B,EACAtqB,EACAjO,EACAqX,EACAikB,EAA+B,oBAAbl1B,GAA2BA,EAC7C8P,GAAS4b,GAAQ1D,EAAShoB,EAAWk1B,EAASl1B,UAAYA,GAI9D,GAHAqnB,EAAUA,GAAW,GAGA,IAAjBvX,EAAMpT,OAAc,CAItB,IAFAy1B,EAASriB,EAAM,GAAKA,EAAM,GAAG9J,MAAM,IAExBtJ,OAAS,GAAkC,QAA5BmL,EAAQsqB,EAAO,IAAIv4B,MAAsC,IAArB+F,EAAQkD,UAAkB2lB,GAAkBX,EAAKkI,SAASoC,EAAO,GAAGv4B,MAAO,CAGvI,KAFA+F,GAAWkoB,EAAK5W,KAAS,GAAEpJ,EAAMoI,QAAQ,GAAGgH,QAAQwT,GAAWC,IAAY/qB,IAAY,IAAI,IAGzF,OAAO0nB,EACE6N,IACTv1B,EAAUA,EAAQ8C,YAGpBzC,EAAWA,EAASgG,MAAMmsB,EAAOhP,QAAQ3qB,MAAMkE,QAMjD,IAFAnF,EAAI2yB,EAAwB,aAAE7N,KAAKrc,GAAY,EAAImyB,EAAOz1B,OAEnDnF,MACLsQ,EAAQsqB,EAAO56B,IAEXswB,EAAKkI,SAASn2B,EAAOiO,EAAMjO,QAI/B,IAAIqX,EAAO4W,EAAK5W,KAAKrX,MAEf8xB,EAAOza,EAAKpJ,EAAMoI,QAAQ,GAAGgH,QAAQwT,GAAWC,IAAYF,GAASnO,KAAK8V,EAAO,GAAGv4B,OAASyyB,GAAY1sB,EAAQ8C,aAAe9C,IAAU,CAK5I,GAHAwyB,EAAO7L,OAAO/uB,EAAG,KACjByI,EAAW0rB,EAAKhvB,QAAU6vB,GAAW4F,IAInC,OADA1yB,EAAKqC,MAAMulB,EAASqE,GACbrE,EAGT,OASR,OADC6N,GAAYjN,EAAQjoB,EAAU8P,IAAQ4b,EAAM/rB,GAAU6oB,EAAgBnB,GAAU1nB,GAAW6qB,GAASnO,KAAKrc,IAAaqsB,GAAY1sB,EAAQ8C,aAAe9C,GACnJ0nB,GAKTtC,EAAQ2K,WAAa9I,EAAQ9e,MAAM,IAAIvC,KAAK2jB,GAAWnhB,KAAK,MAAQ6e,EAGpE7B,EAAQ0K,mBAAqBpH,EAE7BC,IAGAvD,EAAQgK,aAAenC,IAAO,SAAUzpB,GAEtC,OAAwE,EAAjEA,EAAGwrB,wBAAwBnoB,EAASsQ,cAAc,gBAKtD8V,IAAO,SAAUzpB,GAEpB,OADAA,EAAGgW,UAAY,mBAC+B,MAAvChW,EAAGT,WAAW+L,aAAa,YAElCoe,GAAU,0BAA0B,SAAU9G,EAAMjuB,EAAMiwB,GACxD,IAAKA,EACH,OAAOhC,EAAKtX,aAAa3W,EAA6B,SAAvBA,EAAK6vB,cAA2B,EAAI,MAOpE5C,EAAQvE,YAAeoM,IAAO,SAAUzpB,GAG3C,OAFAA,EAAGgW,UAAY,WACfhW,EAAGT,WAAW8L,aAAa,QAAS,IACW,KAAxCrL,EAAGT,WAAW+L,aAAa,aAElCoe,GAAU,SAAS,SAAU9G,EAAMpnB,EAAOopB,GACxC,IAAKA,GAAyC,UAAhChC,EAAKsF,SAAS1D,cAC1B,OAAO5B,EAAKoP,gBAObvI,IAAO,SAAUzpB,GACpB,OAAsC,MAA/BA,EAAGsL,aAAa,gBAEvBoe,GAAUvD,GAAU,SAAUvD,EAAMjuB,EAAMiwB,GACxC,IAAIhL,EAEJ,IAAKgL,EACH,OAAsB,IAAfhC,EAAKjuB,GAAiBA,EAAK6vB,eAAiB5K,EAAMgJ,EAAKyI,iBAAiB12B,KAAUilB,EAAIsS,UAAYtS,EAAIvkB,MAAQ,QAKpHovB,GAnkET,CAokEE7kB,GAEFiO,EAAOC,KAAO2W,GACd5W,EAAOme,KAAOvH,EAAOiI,WAET,KAAO7e,EAAOme,KAAK1F,QAC/BzY,EAAOue,WAAave,EAAOokB,OAASxN,EAAO2H,WAC3Cve,EAAO8D,KAAO8S,EAAOE,QACrB9W,EAAOqkB,SAAWzN,EAAOG,MACzB/W,EAAO1K,SAAWshB,EAAOthB,SACzB0K,EAAOskB,eAAiB1N,EAAO+C,OAE/B,IAAIW,EAAM,SAAavF,EAAMwP,EAAMC,GAIjC,IAHA,IAAI7yB,EAAU,GACV8yB,OAAqBj4B,IAAVg4B,GAEPzP,EAAOA,EAAKwP,KAA4B,IAAlBxP,EAAKljB,UACjC,GAAsB,IAAlBkjB,EAAKljB,SAAgB,CACvB,GAAI4yB,GAAYzkB,EAAO+U,GAAMhiB,GAAGyxB,GAC9B,MAGF7yB,EAAQlD,KAAKsmB,GAIjB,OAAOpjB,GAGL+yB,EAAY,SAAkB18B,EAAG+sB,GAGnC,IAFA,IAAIpjB,EAAU,GAEP3J,EAAGA,EAAIA,EAAE4J,YACK,IAAf5J,EAAE6J,UAAkB7J,IAAM+sB,GAC5BpjB,EAAQlD,KAAKzG,GAIjB,OAAO2J,GAGLgzB,EAAgB3kB,EAAOme,KAAKrf,MAAM8lB,aAEtC,SAASvK,EAAStF,EAAMjuB,GACtB,OAAOiuB,EAAKsF,UAAYtF,EAAKsF,SAAS1D,gBAAkB7vB,EAAK6vB,cAG/D,IAAIkO,EAAa,kEAEjB,SAASC,EAAO3mB,EAAU4mB,EAAWC,GACnC,OAAI93B,EAAW63B,GACN/kB,EAAOmV,KAAKhX,GAAU,SAAU4W,EAAMxuB,GAC3C,QAASw+B,EAAUr+B,KAAKquB,EAAMxuB,EAAGwuB,KAAUiQ,KAK3CD,EAAUlzB,SACLmO,EAAOmV,KAAKhX,GAAU,SAAU4W,GACrC,OAAOA,IAASgQ,IAAcC,KAKT,kBAAdD,EACF/kB,EAAOmV,KAAKhX,GAAU,SAAU4W,GACrC,OAAO3d,EAAQ1Q,KAAKq+B,EAAWhQ,IAAS,IAAMiQ,KAK3ChlB,EAAO7K,OAAO4vB,EAAW5mB,EAAU6mB,GAG5ChlB,EAAO7K,OAAS,SAAUgpB,EAAMxJ,EAAOqQ,GACrC,IAAIjQ,EAAOJ,EAAM,GAMjB,OAJIqQ,IACF7G,EAAO,QAAUA,EAAO,KAGL,IAAjBxJ,EAAMjpB,QAAkC,IAAlBqpB,EAAKljB,SACtBmO,EAAOC,KAAKuB,gBAAgBuT,EAAMoJ,GAAQ,CAACpJ,GAAQ,GAGrD/U,EAAOC,KAAKhB,QAAQkf,EAAMne,EAAOmV,KAAKR,GAAO,SAAUI,GAC5D,OAAyB,IAAlBA,EAAKljB,cAIhBmO,EAAO6J,GAAG0L,OAAO,CACftV,KAAM,SAAcjR,GAClB,IAAIzI,EACAumB,EACAnV,EAAMxJ,KAAKzC,OACXkB,EAAOuB,KAEX,GAAwB,kBAAba,EACT,OAAOb,KAAKumB,UAAU1U,EAAOhR,GAAUmG,QAAO,WAC5C,IAAK5O,EAAI,EAAGA,EAAIoR,EAAKpR,IACnB,GAAIyZ,EAAO1K,SAAS1I,EAAKrG,GAAI4H,MAC3B,OAAO,MAQf,IAFA2e,EAAM3e,KAAKumB,UAAU,IAEhBnuB,EAAI,EAAGA,EAAIoR,EAAKpR,IACnByZ,EAAOC,KAAKjR,EAAUpC,EAAKrG,GAAIumB,GAGjC,OAAOnV,EAAM,EAAIqI,EAAOue,WAAWzR,GAAOA,GAE5C3X,OAAQ,SAAgBnG,GACtB,OAAOb,KAAKumB,UAAUoQ,EAAO32B,KAAMa,GAAY,IAAI,KAErDg2B,IAAK,SAAah2B,GAChB,OAAOb,KAAKumB,UAAUoQ,EAAO32B,KAAMa,GAAY,IAAI,KAErD+D,GAAI,SAAY/D,GACd,QAAS81B,EAAO32B,KAEI,kBAAba,GAAyB21B,EAActZ,KAAKrc,GAAYgR,EAAOhR,GAAYA,GAAY,IAAI,GAAOtD,UAK7G,IAAIu5B,EAKJ1L,EAAa,uCACFvZ,EAAO6J,GAAG0K,KAAO,SAAUvlB,EAAUL,EAASiG,GACvD,IAAIkK,EAAOiW,EAEX,IAAK/lB,EACH,OAAOb,KAOT,GAFAyG,EAAOA,GAAQqwB,EAES,kBAAbj2B,EAAuB,CAShC,KANE8P,EAFkB,MAAhB9P,EAAS,IAAgD,MAAlCA,EAASA,EAAStD,OAAS,IAAcsD,EAAStD,QAAU,EAE7E,CAAC,KAAMsD,EAAU,MAEjBuqB,EAAWyB,KAAKhsB,MAIZ8P,EAAM,IAAOnQ,EAgCpB,OAAKA,GAAWA,EAAQ8lB,QACrB9lB,GAAWiG,GAAMqL,KAAKjR,GAGvBb,KAAKzF,YAAYiG,GAASsR,KAAKjR,GAlCtC,GAAI8P,EAAM,GAAI,CAMZ,GALAnQ,EAAUA,aAAmBqR,EAASrR,EAAQ,GAAKA,EAGnDqR,EAAO4U,MAAMzmB,KAAM6R,EAAOklB,UAAUpmB,EAAM,GAAInQ,GAAWA,EAAQkD,SAAWlD,EAAQosB,eAAiBpsB,EAAU6G,GAAU,IAErHqvB,EAAWxZ,KAAKvM,EAAM,KAAOkB,EAAO2V,cAAchnB,GACpD,IAAKmQ,KAASnQ,EAERzB,EAAWiB,KAAK2Q,IAClB3Q,KAAK2Q,GAAOnQ,EAAQmQ,IAEpB3Q,KAAKiwB,KAAKtf,EAAOnQ,EAAQmQ,IAK/B,OAAO3Q,KAUP,OARA4mB,EAAOvf,EAASylB,eAAenc,EAAM,OAInC3Q,KAAK,GAAK4mB,EACV5mB,KAAKzC,OAAS,GAGTyC,KAUN,OAAIa,EAAS6C,UAClB1D,KAAK,GAAKa,EACVb,KAAKzC,OAAS,EACPyC,MAEEjB,EAAW8B,QACExC,IAAfoI,EAAKuwB,MAAsBvwB,EAAKuwB,MAAMn2B,GAC7CA,EAASgR,GAGJA,EAAOoW,UAAUpnB,EAAUb,QAI/BhG,UAAY6X,EAAO6J,GAExBob,EAAajlB,EAAOxK,GACpB,IAAI4vB,EAAe,iCAEnBC,EAAmB,CACjBnwB,UAAU,EACVuX,UAAU,EACV8N,MAAM,EACN+K,MAAM,GA8DR,SAASvrB,EAAQkiB,EAAK3B,GACpB,MAAQ2B,EAAMA,EAAI3B,KAA0B,IAAjB2B,EAAIpqB,WAE/B,OAAOoqB,EA/DTjc,EAAO6J,GAAG0L,OAAO,CACfgQ,IAAK,SAAa/5B,GAChB,IAAIg6B,EAAUxlB,EAAOxU,EAAQ2C,MACzB3H,EAAIg/B,EAAQ95B,OAChB,OAAOyC,KAAKgH,QAAO,WAGjB,IAFA,IAAI5O,EAAI,EAEDA,EAAIC,EAAGD,IACZ,GAAIyZ,EAAO1K,SAASnH,KAAMq3B,EAAQj/B,IAChC,OAAO,MAKfk/B,QAAS,SAAiB5G,EAAWlwB,GACnC,IAAIstB,EACA11B,EAAI,EACJC,EAAI2H,KAAKzC,OACTiG,EAAU,GACV6zB,EAA+B,kBAAd3G,GAA0B7e,EAAO6e,GAEtD,IAAK8F,EAActZ,KAAKwT,GACtB,KAAOt4B,EAAIC,EAAGD,IACZ,IAAK01B,EAAM9tB,KAAK5H,GAAI01B,GAAOA,IAAQttB,EAASstB,EAAMA,EAAIxqB,WAEpD,GAAIwqB,EAAIpqB,SAAW,KAAO2zB,EAAUA,EAAQh3B,MAAMytB,IAAQ,EACzC,IAAjBA,EAAIpqB,UAAkBmO,EAAOC,KAAKuB,gBAAgBya,EAAK4C,IAAa,CAClEltB,EAAQlD,KAAKwtB,GACb,MAMR,OAAO9tB,KAAKumB,UAAU/iB,EAAQjG,OAAS,EAAIsU,EAAOue,WAAW5sB,GAAWA,IAG1EnD,MAAO,SAAeumB,GAEpB,OAAKA,EAKe,kBAATA,EACF3d,EAAQ1Q,KAAKsZ,EAAO+U,GAAO5mB,KAAK,IAIlCiJ,EAAQ1Q,KAAKyH,KACpB4mB,EAAKN,OAASM,EAAK,GAAKA,GAVf5mB,KAAK,IAAMA,KAAK,GAAGsD,WAAatD,KAAKmf,QAAQoY,UAAUh6B,QAAU,GAY5EuL,IAAK,SAAajI,EAAUL,GAC1B,OAAOR,KAAKumB,UAAU1U,EAAOue,WAAWve,EAAO4U,MAAMzmB,KAAK/G,MAAO4Y,EAAOhR,EAAUL,OAEpFg3B,QAAS,SAAiB32B,GACxB,OAAOb,KAAK8I,IAAgB,MAAZjI,EAAmBb,KAAK0mB,WAAa1mB,KAAK0mB,WAAW1f,OAAOnG,OAUhFgR,EAAO8U,KAAK,CACVroB,OAAQ,SAAgBsoB,GACtB,IAAItoB,EAASsoB,EAAKtjB,WAClB,OAAOhF,GAA8B,KAApBA,EAAOoF,SAAkBpF,EAAS,MAErDm5B,QAAS,SAAiB7Q,GACxB,OAAOuF,EAAIvF,EAAM,eAEnB8Q,aAAc,SAAsB9Q,EAAM/kB,EAAIw0B,GAC5C,OAAOlK,EAAIvF,EAAM,aAAcyP,IAEjCjK,KAAM,SAAcxF,GAClB,OAAOhb,EAAQgb,EAAM,gBAEvBuQ,KAAM,SAAcvQ,GAClB,OAAOhb,EAAQgb,EAAM,oBAEvB+Q,QAAS,SAAiB/Q,GACxB,OAAOuF,EAAIvF,EAAM,gBAEnB2Q,QAAS,SAAiB3Q,GACxB,OAAOuF,EAAIvF,EAAM,oBAEnBgR,UAAW,SAAmBhR,EAAM/kB,EAAIw0B,GACtC,OAAOlK,EAAIvF,EAAM,cAAeyP,IAElCwB,UAAW,SAAmBjR,EAAM/kB,EAAIw0B,GACtC,OAAOlK,EAAIvF,EAAM,kBAAmByP,IAEtCjzB,SAAU,SAAkBwjB,GAC1B,OAAO2P,GAAW3P,EAAKtjB,YAAc,IAAIC,WAAYqjB,IAEvD7f,SAAU,SAAkB6f,GAC1B,OAAO2P,EAAU3P,EAAKrjB,aAExB+a,SAAU,SAAkBsI,GAC1B,OAA4B,MAAxBA,EAAKkR,iBAGT1S,EAASwB,EAAKkR,iBACLlR,EAAKkR,iBAMV5L,EAAStF,EAAM,cACjBA,EAAOA,EAAK1T,SAAW0T,GAGlB/U,EAAO4U,MAAM,GAAIG,EAAKyF,gBAE9B,SAAU1zB,EAAM+iB,GACjB7J,EAAO6J,GAAG/iB,GAAQ,SAAU09B,EAAOx1B,GACjC,IAAI2C,EAAUqO,EAAO+G,IAAI5Y,KAAM0b,EAAI2a,GAsBnC,MApBuB,UAAnB19B,EAAKkO,OAAO,KACdhG,EAAWw1B,GAGTx1B,GAAgC,kBAAbA,IACrB2C,EAAUqO,EAAO7K,OAAOnG,EAAU2C,IAGhCxD,KAAKzC,OAAS,IAEX25B,EAAiBv+B,IACpBkZ,EAAOue,WAAW5sB,GAIhByzB,EAAa/Z,KAAKvkB,IACpB6K,EAAQsH,WAIL9K,KAAKumB,UAAU/iB,OAG1B,IAAIu0B,EAAgB,oBA0MpB,SAASC,EAASC,GAChB,OAAOA,EAGT,SAASC,EAAQC,GACf,MAAMA,EAGR,SAASC,EAAW/+B,EAAOoP,EAAS4vB,EAAQC,GAC1C,IAAIle,EAEJ,IAEM/gB,GAAS0F,EAAWqb,EAAS/gB,EAAMk/B,SACrCne,EAAO7hB,KAAKc,GAAO6d,KAAKzO,GAAS+vB,KAAKH,GAC7Bh/B,GAAS0F,EAAWqb,EAAS/gB,EAAMo/B,MAC5Cre,EAAO7hB,KAAKc,EAAOoP,EAAS4vB,GAK5B5vB,EAAQ9F,WAAMtE,EAAW,CAAChF,GAAOwN,MAAMyxB,IAKzC,MAAOj/B,GAGPg/B,EAAO11B,WAAMtE,EAAW,CAAChF,KAtM7BwY,EAAO6mB,UAAY,SAAU54B,GAG3BA,EAA6B,kBAAZA,EAlCnB,SAAuBA,GACrB,IAAIhG,EAAS,GAIb,OAHA+X,EAAO8U,KAAK7mB,EAAQ6Q,MAAMonB,IAAkB,IAAI,SAAUY,EAAGC,GAC3D9+B,EAAO8+B,IAAQ,KAEV9+B,EA6BiC++B,CAAc/4B,GAAW+R,EAAOuV,OAAO,GAAItnB,GAEnF,IACAg5B,EAEAC,EAEAC,EAEAC,EAEA/O,EAAO,GAEPgP,EAAQ,GAERC,GAAe,EAEf5kB,EAAO,WAOL,IALA0kB,EAAUA,GAAWn5B,EAAQs5B,KAG7BJ,EAASF,GAAS,EAEXI,EAAM37B,OAAQ47B,GAAe,EAGlC,IAFAJ,EAASG,EAAMlV,UAENmV,EAAcjP,EAAK3sB,SAE4B,IAAlD2sB,EAAKiP,GAAax2B,MAAMo2B,EAAO,GAAIA,EAAO,KAAiBj5B,EAAQu5B,cAErEF,EAAcjP,EAAK3sB,OACnBw7B,GAAS,GAMVj5B,EAAQi5B,SACXA,GAAS,GAGXD,GAAS,EAELG,IAGA/O,EADE6O,EACK,GAEA,KAKbt6B,EAAO,CAELqK,IAAK,WA0BH,OAzBIohB,IAEE6O,IAAWD,IACbK,EAAcjP,EAAK3sB,OAAS,EAC5B27B,EAAM54B,KAAKy4B,IAGb,SAAUjwB,EAAIxG,GACZuP,EAAO8U,KAAKrkB,GAAM,SAAUq2B,EAAGrQ,GACzBvpB,EAAWupB,GACRxoB,EAAQm2B,QAAWx3B,EAAK24B,IAAI9O,IAC/B4B,EAAK5pB,KAAKgoB,GAEHA,GAAOA,EAAI/qB,QAA0B,WAAhB4oB,EAAOmC,IAErCxf,EAAIwf,MARV,CAWGvqB,WAECg7B,IAAWD,GACbvkB,KAIGvU,MAGTO,OAAQ,WAYN,OAXAsR,EAAO8U,KAAK5oB,WAAW,SAAU46B,EAAGrQ,GAGlC,IAFA,IAAIjoB,GAEIA,EAAQwR,EAAOsW,QAAQG,EAAK4B,EAAM7pB,KAAW,GACnD6pB,EAAK/C,OAAO9mB,EAAO,GAEfA,GAAS84B,GACXA,OAICn5B,MAITo3B,IAAK,SAAa1b,GAChB,OAAOA,EAAK7J,EAAOsW,QAAQzM,EAAIwO,IAAS,EAAIA,EAAK3sB,OAAS,GAG5D+7B,MAAO,WAKL,OAJIpP,IACFA,EAAO,IAGFlqB,MAKTwB,QAAS,WAGP,OAFAy3B,EAAUC,EAAQ,GAClBhP,EAAO6O,EAAS,GACT/4B,MAETiB,SAAU,WACR,OAAQipB,GAKVqP,KAAM,WAOJ,OANAN,EAAUC,EAAQ,GAEbH,GAAWD,IACd5O,EAAO6O,EAAS,IAGX/4B,MAETw5B,OAAQ,WACN,QAASP,GAGXQ,SAAU,SAAkBj5B,EAAS8B,GAWnC,OAVK22B,IAEH32B,EAAO,CAAC9B,GADR8B,EAAOA,GAAQ,IACOuE,MAAQvE,EAAKuE,QAAUvE,GAC7C42B,EAAM54B,KAAKgC,GAENw2B,GACHvkB,KAIGvU,MAGTuU,KAAM,WAEJ,OADA9V,EAAKg7B,SAASz5B,KAAMjC,WACbiC,MAGT05B,MAAO,WACL,QAASV,IAIb,OAAOv6B,GAoCToT,EAAOuV,OAAO,CACZuS,SAAU,SAAkBx3B,GAC1B,IAAIy3B,EAAS,CAEb,CAAC,SAAU,WAAY/nB,EAAO6mB,UAAU,UAAW7mB,EAAO6mB,UAAU,UAAW,GAAI,CAAC,UAAW,OAAQ7mB,EAAO6mB,UAAU,eAAgB7mB,EAAO6mB,UAAU,eAAgB,EAAG,YAAa,CAAC,SAAU,OAAQ7mB,EAAO6mB,UAAU,eAAgB7mB,EAAO6mB,UAAU,eAAgB,EAAG,aAC7QmB,EAAS,UACTC,EAAW,CACbpd,MAAO,WACL,OAAOmd,GAETE,OAAQ,WAEN,OADAC,EAAS9iB,KAAKnZ,WAAWy6B,KAAKz6B,WACvBiC,MAET,MAAS,SAAgB0b,GACvB,OAAOoe,EAASrB,KAAK,KAAM/c,IAG7Bue,KAAM,WAGJ,IAAIC,EAAMn8B,UACV,OAAO8T,EAAO8nB,UAAS,SAAUQ,GAC/BtoB,EAAO8U,KAAKiT,GAAQ,SAAU/3B,EAAIu4B,GAEhC,IAAI1e,EAAK3c,EAAWm7B,EAAIE,EAAM,MAAQF,EAAIE,EAAM,IAIhDJ,EAASI,EAAM,KAAI,WACjB,IAAIC,EAAW3e,GAAMA,EAAG/Y,MAAM3C,KAAMjC,WAEhCs8B,GAAYt7B,EAAWs7B,EAAS9B,SAClC8B,EAAS9B,UAAUlV,SAAS8W,EAAS3X,QAAQtL,KAAKijB,EAAS1xB,SAAS+vB,KAAK2B,EAAS9B,QAElF8B,EAASC,EAAM,GAAK,QAAQp6B,KAAM0b,EAAK,CAAC2e,GAAYt8B,iBAI1Dm8B,EAAM,QACL3B,WAELE,KAAM,SAAc6B,EAAaC,EAAYC,GAC3C,IAAIC,EAAW,EAEf,SAAShyB,EAAQiyB,EAAOV,EAAU75B,EAASw6B,GACzC,OAAO,WACL,IAAIC,EAAO56B,KACPsC,EAAOvE,UACP88B,EAAa,WACf,IAAIR,EAAU5B,EAId,KAAIiC,EAAQD,GAAZ,CAOA,IAHAJ,EAAWl6B,EAAQwC,MAAMi4B,EAAMt4B,MAGd03B,EAASzB,UACxB,MAAM,IAAIr7B,UAAU,4BAOtBu7B,EAAO4B,IAGe,WAAtBv9B,EAAQu9B,IAA8C,oBAAbA,IAA4BA,EAAS5B,KAE1E15B,EAAW05B,GAETkC,EACFlC,EAAKlgC,KAAK8hC,EAAU5xB,EAAQgyB,EAAUT,EAAUhC,EAAU2C,GAAUlyB,EAAQgyB,EAAUT,EAAU9B,EAASyC,KAGzGF,IACAhC,EAAKlgC,KAAK8hC,EAAU5xB,EAAQgyB,EAAUT,EAAUhC,EAAU2C,GAAUlyB,EAAQgyB,EAAUT,EAAU9B,EAASyC,GAAUlyB,EAAQgyB,EAAUT,EAAUhC,EAAUgC,EAASc,eAMhK36B,IAAY63B,IACd4C,OAAOv8B,EACPiE,EAAO,CAAC+3B,KAKTM,GAAWX,EAASe,aAAaH,EAAMt4B,MAI5C04B,EAAUL,EAAUE,EAAa,WAC/B,IACEA,IACA,MAAOl1B,GACHkM,EAAO8nB,SAASsB,eAClBppB,EAAO8nB,SAASsB,cAAct1B,EAAGq1B,EAAQE,YAMvCR,EAAQ,GAAKD,IAGXt6B,IAAY+3B,IACd0C,OAAOv8B,EACPiE,EAAO,CAACqD,IAGVq0B,EAASmB,WAAWP,EAAMt4B,MAS5Bo4B,EACFM,KAIInpB,EAAO8nB,SAASyB,eAClBJ,EAAQE,WAAarpB,EAAO8nB,SAASyB,gBAGvCx3B,EAAOX,WAAW+3B,KAKxB,OAAOnpB,EAAO8nB,UAAS,SAAUQ,GAE/BP,EAAO,GAAG,GAAG9wB,IAAIL,EAAQ,EAAG0xB,EAAUp7B,EAAWy7B,GAAcA,EAAaxC,EAAUmC,EAASW,aAE/FlB,EAAO,GAAG,GAAG9wB,IAAIL,EAAQ,EAAG0xB,EAAUp7B,EAAWu7B,GAAeA,EAActC,IAE9E4B,EAAO,GAAG,GAAG9wB,IAAIL,EAAQ,EAAG0xB,EAAUp7B,EAAWw7B,GAAcA,EAAarC,OAC3EK,WAILA,QAAS,SAAiBl+B,GACxB,OAAc,MAAPA,EAAcwX,EAAOuV,OAAO/sB,EAAKy/B,GAAYA,IAGpDE,EAAW,GAkDf,OAhDAnoB,EAAO8U,KAAKiT,GAAQ,SAAUxhC,EAAGgiC,GAC/B,IAAIlQ,EAAOkQ,EAAM,GACbiB,EAAcjB,EAAM,GAIxBN,EAASM,EAAM,IAAMlQ,EAAKphB,IAEtBuyB,GACFnR,EAAKphB,KAAI,WAGP+wB,EAASwB,IAGXzB,EAAO,EAAIxhC,GAAG,GAAGoJ,QAEjBo4B,EAAO,EAAIxhC,GAAG,GAAGoJ,QACjBo4B,EAAO,GAAG,GAAGL,KACbK,EAAO,GAAG,GAAGL,MAMfrP,EAAKphB,IAAIsxB,EAAM,GAAG7lB,MAIlBylB,EAASI,EAAM,IAAM,WAEnB,OADAJ,EAASI,EAAM,GAAK,QAAQp6B,OAASg6B,OAAW37B,EAAY2B,KAAMjC,WAC3DiC,MAMTg6B,EAASI,EAAM,GAAK,QAAUlQ,EAAKuP,YAGrCK,EAASvB,QAAQyB,GAGb73B,GACFA,EAAK5J,KAAKyhC,EAAUA,GAIfA,GAGTsB,KAAM,SAAcC,GAClB,IACAz4B,EAAY/E,UAAUR,OAEtBnF,EAAI0K,EAEJ04B,EAAkBt8B,MAAM9G,GACpBqjC,EAAgBpW,EAAO9sB,KAAKwF,WAEhC29B,EAAU7pB,EAAO8nB,WAEjBgC,EAAa,SAAoBvjC,GAC/B,OAAO,SAAUiB,GACfmiC,EAAgBpjC,GAAK4H,KACrBy7B,EAAcrjC,GAAK2F,UAAUR,OAAS,EAAI8nB,EAAO9sB,KAAKwF,WAAa1E,IAE3DyJ,GACN44B,EAAQX,YAAYS,EAAiBC,KAM3C,GAAI34B,GAAa,IACfs1B,EAAWmD,EAAaG,EAAQxkB,KAAKykB,EAAWvjC,IAAIqQ,QAASizB,EAAQrD,QAASv1B,GAEtD,YAApB44B,EAAQhf,SAAyB3d,EAAW08B,EAAcrjC,IAAMqjC,EAAcrjC,GAAGqgC,OACnF,OAAOiD,EAAQjD,OAKnB,KAAOrgC,KACLggC,EAAWqD,EAAcrjC,GAAIujC,EAAWvjC,GAAIsjC,EAAQrD,QAGtD,OAAOqD,EAAQnD,aAKnB,IAAIqD,EAAc,yDAElB/pB,EAAO8nB,SAASsB,cAAgB,SAAUp+B,EAAOg/B,GAG3Cj4B,EAAOhH,SAAWgH,EAAOhH,QAAQF,MAAQG,GAAS++B,EAAY1e,KAAKrgB,EAAMlE,OAC3EiL,EAAOhH,QAAQF,KAAK,8BAAgCG,EAAMsc,QAAStc,EAAMg/B,MAAOA,IAIpFhqB,EAAOiqB,eAAiB,SAAUj/B,GAChC+G,EAAOX,YAAW,WAChB,MAAMpG,MAKV,IAAIk/B,EAAYlqB,EAAO8nB,WAsCvB,SAASqC,IACP30B,EAASjD,oBAAoB,mBAAoB43B,GACjDp4B,EAAOQ,oBAAoB,OAAQ43B,GACnCnqB,EAAOmlB,QAvCTnlB,EAAO6J,GAAGsb,MAAQ,SAAUtb,GAO1B,OANAqgB,EAAUtD,KAAK/c,GAGdugB,OAAM,SAAUp/B,GACfgV,EAAOiqB,eAAej/B,MAEjBmD,MAGT6R,EAAOuV,OAAO,CAEZO,SAAS,EAGTuU,UAAW,EAEXlF,MAAO,SAAe50B,KAEP,IAATA,IAAkByP,EAAOqqB,UAAYrqB,EAAO8V,WAKhD9V,EAAO8V,SAAU,GAEJ,IAATvlB,KAAmByP,EAAOqqB,UAAY,GAK1CH,EAAUhB,YAAY1zB,EAAU,CAACwK,QAGrCA,EAAOmlB,MAAMyB,KAAOsD,EAAUtD,KAYF,aAAxBpxB,EAASmP,YAAqD,YAAxBnP,EAASmP,aAA6BnP,EAASqnB,gBAAgByN,SAEvGv4B,EAAOX,WAAW4O,EAAOmlB,QAGzB3vB,EAASlD,iBAAiB,mBAAoB63B,GAE9Cp4B,EAAOO,iBAAiB,OAAQ63B,IAKlC,IAAII,EAAS,SAASA,EAAO5V,EAAO9K,EAAI/hB,EAAKN,EAAOgjC,EAAWC,EAAU5d,GACvE,IAAItmB,EAAI,EACJoR,EAAMgd,EAAMjpB,OACZg/B,EAAc,MAAP5iC,EAEX,GAAoB,WAAhBwsB,EAAOxsB,GAGT,IAAKvB,KAFLikC,GAAY,EAEF1iC,EACRyiC,EAAO5V,EAAO9K,EAAItjB,EAAGuB,EAAIvB,IAAI,EAAMkkC,EAAU5d,QAG1C,QAAcrgB,IAAVhF,IACTgjC,GAAY,EAEPt9B,EAAW1F,KACdqlB,GAAM,GAGJ6d,IAEE7d,GACFhD,EAAGnjB,KAAKiuB,EAAOntB,GACfqiB,EAAK,OAEL6gB,EAAO7gB,EAEPA,EAAK,SAAYkL,EAAM/D,EAAMxpB,GAC3B,OAAOkjC,EAAKhkC,KAAKsZ,EAAO+U,GAAOvtB,MAKjCqiB,GACF,KAAOtjB,EAAIoR,EAAKpR,IACdsjB,EAAG8K,EAAMpuB,GAAIuB,EAAK+kB,EAAMrlB,EAAQA,EAAMd,KAAKiuB,EAAMpuB,GAAIA,EAAGsjB,EAAG8K,EAAMpuB,GAAIuB,KAK3E,OAAI0iC,EACK7V,EAIL+V,EACK7gB,EAAGnjB,KAAKiuB,GAGVhd,EAAMkS,EAAG8K,EAAM,GAAI7sB,GAAO2iC,GAI/BE,EAAY,QACZC,EAAa,YAEjB,SAASC,EAAWC,EAAMC,GACxB,OAAOA,EAAO7lB,cAMhB,SAAS8lB,EAAUC,GACjB,OAAOA,EAAOhlB,QAAQ0kB,EAAW,OAAO1kB,QAAQ2kB,EAAYC,GAG9D,IAAIK,EAAa,SAAoBC,GAOnC,OAA0B,IAAnBA,EAAMt5B,UAAqC,IAAnBs5B,EAAMt5B,YAAoBs5B,EAAMt5B,UAGjE,SAASu5B,IACPj9B,KAAKynB,QAAU5V,EAAO4V,QAAUwV,EAAKC,MAGvCD,EAAKC,IAAM,EACXD,EAAKjjC,UAAY,CACfszB,MAAO,SAAe0P,GAEpB,IAAI3jC,EAAQ2jC,EAAMh9B,KAAKynB,SAuBvB,OArBKpuB,IACHA,EAAQ,GAIJ0jC,EAAWC,KAGTA,EAAMt5B,SACRs5B,EAAMh9B,KAAKynB,SAAWpuB,EAItBP,OAAOC,eAAeikC,EAAOh9B,KAAKynB,QAAS,CACzCpuB,MAAOA,EACPoE,cAAc,MAMfpE,GAETuI,IAAK,SAAao7B,EAAO/nB,EAAM5b,GAC7B,IAAIqG,EACA4tB,EAAQttB,KAAKstB,MAAM0P,GAGvB,GAAoB,kBAAT/nB,EACTqY,EAAMuP,EAAU5nB,IAAS5b,OAGzB,IAAKqG,KAAQuV,EACXqY,EAAMuP,EAAUn9B,IAASuV,EAAKvV,GAIlC,OAAO4tB,GAETr0B,IAAK,SAAa+jC,EAAOrjC,GACvB,YAAe0E,IAAR1E,EAAoBqG,KAAKstB,MAAM0P,GACtCA,EAAMh9B,KAAKynB,UAAYuV,EAAMh9B,KAAKynB,SAASoV,EAAUljC,KAEvDyiC,OAAQ,SAAgBY,EAAOrjC,EAAKN,GAYlC,YAAYgF,IAAR1E,GAAqBA,GAAsB,kBAARA,QAA8B0E,IAAVhF,EAClD2G,KAAK/G,IAAI+jC,EAAOrjC,IASzBqG,KAAK4B,IAAIo7B,EAAOrjC,EAAKN,QAGJgF,IAAVhF,EAAsBA,EAAQM,IAEvC4G,OAAQ,SAAgBy8B,EAAOrjC,GAC7B,IAAIvB,EACAk1B,EAAQ0P,EAAMh9B,KAAKynB,SAEvB,QAAcppB,IAAVivB,EAAJ,CAIA,QAAYjvB,IAAR1E,EAAmB,CAarBvB,GAREuB,EAHEuF,MAAMD,QAAQtF,GAGVA,EAAIif,IAAIikB,IAEdljC,EAAMkjC,EAAUljC,MAGH2zB,EAAQ,CAAC3zB,GAAOA,EAAIgX,MAAMonB,IAAkB,IAGnDx6B,OAER,KAAOnF,YACEk1B,EAAM3zB,EAAIvB,UAKTiG,IAAR1E,GAAqBkY,EAAOkW,cAAcuF,MAKxC0P,EAAMt5B,SACRs5B,EAAMh9B,KAAKynB,cAAWppB,SAEf2+B,EAAMh9B,KAAKynB,YAIxB0V,QAAS,SAAiBH,GACxB,IAAI1P,EAAQ0P,EAAMh9B,KAAKynB,SACvB,YAAiBppB,IAAVivB,IAAwBzb,EAAOkW,cAAcuF,KAGxD,IAAI8P,EAAW,IAAIH,EACfI,EAAW,IAAIJ,EAUfK,GAAS,gCACTC,GAAa,SA2BjB,SAASC,GAAS5W,EAAMjtB,EAAKsb,GAC3B,IAAItc,EAGJ,QAAa0F,IAAT4W,GAAwC,IAAlB2R,EAAKljB,SAI7B,GAHA/K,EAAO,QAAUgB,EAAIme,QAAQylB,GAAY,OAAO/U,cAG5B,kBAFpBvT,EAAO2R,EAAKtX,aAAa3W,IAEK,CAC5B,IACEsc,EAnCR,SAAiBA,GACf,MAAa,SAATA,GAIS,UAATA,IAIS,SAATA,EACK,KAILA,KAAUA,EAAO,IACXA,EAGNqoB,GAAOpgB,KAAKjI,GACPwC,KAAKC,MAAMzC,GAGbA,GAaMtB,CAAQsB,GACf,MAAOtP,IAGT03B,EAASz7B,IAAIglB,EAAMjtB,EAAKsb,QAExBA,OAAO5W,EAIX,OAAO4W,EAGTpD,EAAOuV,OAAO,CACZ+V,QAAS,SAAiBvW,GACxB,OAAOyW,EAASF,QAAQvW,IAASwW,EAASD,QAAQvW,IAEpD3R,KAAM,SAAc2R,EAAMjuB,EAAM8kC,GAC9B,OAAOJ,EAASjB,OAAOxV,EAAMjuB,EAAM8kC,IAErCC,WAAY,SAAoB9W,EAAMjuB,GACpC0kC,EAAS98B,OAAOqmB,EAAMjuB,IAIxB8kC,MAAO,SAAe7W,EAAMjuB,EAAMsc,GAChC,OAAOmoB,EAAShB,OAAOxV,EAAMjuB,EAAMsc,IAErC0oB,YAAa,SAAqB/W,EAAMjuB,GACtCykC,EAAS78B,OAAOqmB,EAAMjuB,MAG1BkZ,EAAO6J,GAAG0L,OAAO,CACfnS,KAAM,SAActb,EAAKN,GACvB,IAAIjB,EACAO,EACAsc,EACA2R,EAAO5mB,KAAK,GACZ2tB,EAAQ/G,GAAQA,EAAKvF,WAEzB,QAAYhjB,IAAR1E,EAAmB,CACrB,GAAIqG,KAAKzC,SACP0X,EAAOooB,EAASpkC,IAAI2tB,GAEE,IAAlBA,EAAKljB,WAAmB05B,EAASnkC,IAAI2tB,EAAM,iBAAiB,CAG9D,IAFAxuB,EAAIu1B,EAAMpwB,OAEHnF,KAGDu1B,EAAMv1B,IAGsB,KAF9BO,EAAOg1B,EAAMv1B,GAAGO,MAEPsQ,QAAQ,WACftQ,EAAOkkC,EAAUlkC,EAAKkO,MAAM,IAC5B22B,GAAS5W,EAAMjuB,EAAMsc,EAAKtc,KAKhCykC,EAASx7B,IAAIglB,EAAM,gBAAgB,GAIvC,OAAO3R,EAIT,MAAqB,WAAjBnY,EAAQnD,GACHqG,KAAK2mB,MAAK,WACf0W,EAASz7B,IAAI5B,KAAMrG,MAIhByiC,EAAOp8B,MAAM,SAAU3G,GAC5B,IAAI4b,EAMJ,GAAI2R,QAAkBvoB,IAAVhF,EAKV,YAAagF,KAFb4W,EAAOooB,EAASpkC,IAAI2tB,EAAMjtB,UAUb0E,KAFb4W,EAAOuoB,GAAS5W,EAAMjtB,IALbsb,OAYT,EAIFjV,KAAK2mB,MAAK,WAER0W,EAASz7B,IAAI5B,KAAMrG,EAAKN,QAEzB,KAAMA,EAAO0E,UAAUR,OAAS,EAAG,MAAM,IAE9CmgC,WAAY,SAAoB/jC,GAC9B,OAAOqG,KAAK2mB,MAAK,WACf0W,EAAS98B,OAAOP,KAAMrG,SAI5BkY,EAAOuV,OAAO,CACZ8R,MAAO,SAAetS,EAAMnsB,EAAMwa,GAChC,IAAIikB,EAEJ,GAAItS,EAYF,OAXAnsB,GAAQA,GAAQ,MAAQ,QACxBy+B,EAAQkE,EAASnkC,IAAI2tB,EAAMnsB,GAEvBwa,KACGikB,GAASh6B,MAAMD,QAAQgW,GAC1BikB,EAAQkE,EAAShB,OAAOxV,EAAMnsB,EAAMoX,EAAOoW,UAAUhT,IAErDikB,EAAM54B,KAAK2U,IAIRikB,GAAS,IAGpB0E,QAAS,SAAiBhX,EAAMnsB,GAG9B,IAAIy+B,EAAQrnB,EAAOqnB,MAAMtS,EAFzBnsB,EAAOA,GAAQ,MAGXojC,EAAc3E,EAAM37B,OACpBme,EAAKwd,EAAMlV,QACX8Z,EAAQjsB,EAAOksB,YAAYnX,EAAMnsB,GAM1B,eAAPihB,IACFA,EAAKwd,EAAMlV,QACX6Z,KAGEniB,IAGW,OAATjhB,GACFy+B,EAAMzuB,QAAQ,qBAITqzB,EAAMvtB,KACbmL,EAAGnjB,KAAKquB,GAnBC,WACT/U,EAAO+rB,QAAQhX,EAAMnsB,KAkBDqjC,KAGjBD,GAAeC,GAClBA,EAAMxE,MAAM/kB,QAIhBwpB,YAAa,SAAqBnX,EAAMnsB,GACtC,IAAId,EAAMc,EAAO,aACjB,OAAO2iC,EAASnkC,IAAI2tB,EAAMjtB,IAAQyjC,EAAShB,OAAOxV,EAAMjtB,EAAK,CAC3D2/B,MAAOznB,EAAO6mB,UAAU,eAAe5vB,KAAI,WACzCs0B,EAAS78B,OAAOqmB,EAAM,CAACnsB,EAAO,QAASd,YAK/CkY,EAAO6J,GAAG0L,OAAO,CACf8R,MAAO,SAAez+B,EAAMwa,GAC1B,IAAI+oB,EAAS,EAQb,MANoB,kBAATvjC,IACTwa,EAAOxa,EACPA,EAAO,KACPujC,KAGEjgC,UAAUR,OAASygC,EACdnsB,EAAOqnB,MAAMl5B,KAAK,GAAIvF,QAGf4D,IAAT4W,EAAqBjV,KAAOA,KAAK2mB,MAAK,WAC3C,IAAIuS,EAAQrnB,EAAOqnB,MAAMl5B,KAAMvF,EAAMwa,GAErCpD,EAAOksB,YAAY/9B,KAAMvF,GAEZ,OAATA,GAA8B,eAAby+B,EAAM,IACzBrnB,EAAO+rB,QAAQ59B,KAAMvF,OAI3BmjC,QAAS,SAAiBnjC,GACxB,OAAOuF,KAAK2mB,MAAK,WACf9U,EAAO+rB,QAAQ59B,KAAMvF,OAGzBwjC,WAAY,SAAoBxjC,GAC9B,OAAOuF,KAAKk5B,MAAMz+B,GAAQ,KAAM,KAIlC89B,QAAS,SAAiB99B,EAAMJ,GAC9B,IAAIkiB,EACA2hB,EAAQ,EACRC,EAAQtsB,EAAO8nB,WACf3pB,EAAWhQ,KACX5H,EAAI4H,KAAKzC,OACTkL,EAAU,aACJy1B,GACNC,EAAMpD,YAAY/qB,EAAU,CAACA,KAWjC,IAPoB,kBAATvV,IACTJ,EAAMI,EACNA,OAAO4D,GAGT5D,EAAOA,GAAQ,KAERrC,MACLmkB,EAAM6gB,EAASnkC,IAAI+W,EAAS5X,GAAIqC,EAAO,gBAE5B8hB,EAAI+c,QACb4E,IACA3hB,EAAI+c,MAAMxwB,IAAIL,IAKlB,OADAA,IACO01B,EAAM5F,QAAQl+B,MAGzB,IAAI+jC,GAAO,sCAAsCpgC,OAC7CqgC,GAAU,IAAI7T,OAAO,iBAAmB4T,GAAO,cAAe,KAC9DE,GAAY,CAAC,MAAO,QAAS,SAAU,QACvC5P,GAAkBrnB,EAASqnB,gBAE3B6P,GAAa,SAAoB3X,GACnC,OAAO/U,EAAO1K,SAASyf,EAAKgG,cAAehG,IAEzC4X,GAAW,CACbA,UAAU,GAQR9P,GAAgB+P,cAClBF,GAAa,SAAoB3X,GAC/B,OAAO/U,EAAO1K,SAASyf,EAAKgG,cAAehG,IAASA,EAAK6X,YAAYD,MAAc5X,EAAKgG,gBAI5F,IAAI8R,GAAqB,SAA4B9X,EAAM5iB,GAKzD,MAA8B,UAF9B4iB,EAAO5iB,GAAM4iB,GAED9e,MAAMwS,SAA6C,KAAvBsM,EAAK9e,MAAMwS,SAInDikB,GAAW3X,IAAyC,SAAhC/U,EAAO8sB,IAAI/X,EAAM,YAGvC,SAASgY,GAAUhY,EAAMlnB,EAAMm/B,EAAYC,GACzC,IAAIC,EACAC,EACAC,EAAgB,GAChBC,EAAeJ,EAAQ,WACzB,OAAOA,EAAMhR,OACX,WACF,OAAOjc,EAAO8sB,IAAI/X,EAAMlnB,EAAM,KAE5By/B,EAAUD,IACVE,EAAOP,GAAcA,EAAW,KAAOhtB,EAAOwtB,UAAU3/B,GAAQ,GAAK,MAEzE4/B,EAAgB1Y,EAAKljB,WAAamO,EAAOwtB,UAAU3/B,IAAkB,OAAT0/B,IAAkBD,IAAYd,GAAQxR,KAAKhb,EAAO8sB,IAAI/X,EAAMlnB,IAExH,GAAI4/B,GAAiBA,EAAc,KAAOF,EAAM,CAS9C,IANAD,GAAoB,EAEpBC,EAAOA,GAAQE,EAAc,GAE7BA,GAAiBH,GAAW,EAErBF,KAGLptB,EAAO/J,MAAM8e,EAAMlnB,EAAM4/B,EAAgBF,IAEpC,EAAIJ,IAAU,GAAKA,EAAQE,IAAiBC,GAAW,MAAS,IACnEF,EAAgB,GAGlBK,GAAgCN,EAIlCntB,EAAO/J,MAAM8e,EAAMlnB,GADnB4/B,GAAgC,GACSF,GAEzCP,EAAaA,GAAc,GAe7B,OAZIA,IACFS,GAAiBA,IAAkBH,GAAW,EAE9CJ,EAAWF,EAAW,GAAKS,GAAiBT,EAAW,GAAK,GAAKA,EAAW,IAAMA,EAAW,GAEzFC,IACFA,EAAMM,KAAOA,EACbN,EAAM70B,MAAQq1B,EACdR,EAAM50B,IAAM60B,IAITA,EAGT,IAAIQ,GAAoB,GAExB,SAASC,GAAkB5Y,GACzB,IAAIqN,EACA/N,EAAMU,EAAKgG,cACXV,EAAWtF,EAAKsF,SAChB5R,EAAUilB,GAAkBrT,GAEhC,OAAI5R,IAIJ2Z,EAAO/N,EAAI3L,KAAKxP,YAAYmb,EAAIvO,cAAcuU,IAC9C5R,EAAUzI,EAAO8sB,IAAI1K,EAAM,WAC3BA,EAAK3wB,WAAW6H,YAAY8oB,GAEZ,SAAZ3Z,IACFA,EAAU,SAGZilB,GAAkBrT,GAAY5R,EACvBA,GAGT,SAASmlB,GAASzvB,EAAU0vB,GAO1B,IANA,IAAIplB,EACAsM,EACA+Y,EAAS,GACTt/B,EAAQ,EACR9C,EAASyS,EAASzS,OAEf8C,EAAQ9C,EAAQ8C,KACrBumB,EAAO5W,EAAS3P,IAENyH,QAIVwS,EAAUsM,EAAK9e,MAAMwS,QAEjBolB,GAIc,SAAZplB,IACFqlB,EAAOt/B,GAAS+8B,EAASnkC,IAAI2tB,EAAM,YAAc,KAE5C+Y,EAAOt/B,KACVumB,EAAK9e,MAAMwS,QAAU,KAIE,KAAvBsM,EAAK9e,MAAMwS,SAAkBokB,GAAmB9X,KAClD+Y,EAAOt/B,GAASm/B,GAAkB5Y,KAGpB,SAAZtM,IACFqlB,EAAOt/B,GAAS,OAEhB+8B,EAASx7B,IAAIglB,EAAM,UAAWtM,KAMpC,IAAKja,EAAQ,EAAGA,EAAQ9C,EAAQ8C,IACT,MAAjBs/B,EAAOt/B,KACT2P,EAAS3P,GAAOyH,MAAMwS,QAAUqlB,EAAOt/B,IAI3C,OAAO2P,EAGT6B,EAAO6J,GAAG0L,OAAO,CACfsY,KAAM,WACJ,OAAOD,GAASz/B,MAAM,IAExB4/B,KAAM,WACJ,OAAOH,GAASz/B,OAElB6/B,OAAQ,SAAgBnjB,GACtB,MAAqB,mBAAVA,EACFA,EAAQ1c,KAAK0/B,OAAS1/B,KAAK4/B,OAG7B5/B,KAAK2mB,MAAK,WACX+X,GAAmB1+B,MACrB6R,EAAO7R,MAAM0/B,OAEb7tB,EAAO7R,MAAM4/B,aAKrB,IAMME,GACAzrB,GAPF0rB,GAAiB,wBACjBC,GAAW,iCACXC,GAAc,qCAIZH,GADWz4B,EAAS64B,yBACLn1B,YAAY1D,EAASsQ,cAAc,SAClDtD,GAAQhN,EAASsQ,cAAc,UAK7BtI,aAAa,OAAQ,SAC3BgF,GAAMhF,aAAa,UAAW,WAC9BgF,GAAMhF,aAAa,OAAQ,KAC3BywB,GAAI/0B,YAAYsJ,IAGhBuR,EAAQua,WAAaL,GAAIv1B,WAAU,GAAMA,WAAU,GAAMsnB,UAAUlZ,QAGnEmnB,GAAI9lB,UAAY,yBAChB4L,EAAQwa,iBAAmBN,GAAIv1B,WAAU,GAAMsnB,UAAUmE,aAIzD8J,GAAI9lB,UAAY,oBAChB4L,EAAQnN,SAAWqnB,GAAIjO,UAIzB,IAAIwO,GAAU,CAIZC,MAAO,CAAC,EAAG,UAAW,YACtBC,IAAK,CAAC,EAAG,oBAAqB,uBAC9BC,GAAI,CAAC,EAAG,iBAAkB,oBAC1BC,GAAI,CAAC,EAAG,qBAAsB,yBAC9BC,SAAU,CAAC,EAAG,GAAI,KASpB,SAASC,GAAOngC,EAAS8uB,GAGvB,IAAI3Q,EAUJ,OAPEA,EAD0C,qBAAjCne,EAAQusB,qBACXvsB,EAAQusB,qBAAqBuC,GAAO,KACG,qBAA7B9uB,EAAQyO,iBAClBzO,EAAQyO,iBAAiBqgB,GAAO,KAEhC,QAGIjxB,IAARixB,GAAqBA,GAAOpD,EAAS1rB,EAAS8uB,GACzCzd,EAAO4U,MAAM,CAACjmB,GAAUme,GAG1BA,EAIT,SAASiiB,GAAcpa,EAAOqa,GAI5B,IAHA,IAAIzoC,EAAI,EACJC,EAAImuB,EAAMjpB,OAEPnF,EAAIC,EAAGD,IACZglC,EAASx7B,IAAI4kB,EAAMpuB,GAAI,cAAeyoC,GAAezD,EAASnkC,IAAI4nC,EAAYzoC,GAAI,eAjCtFioC,GAAQS,MAAQT,GAAQU,MAAQV,GAAQW,SAAWX,GAAQY,QAAUZ,GAAQC,MAC7ED,GAAQa,GAAKb,GAAQI,GAEhB7a,EAAQnN,SACX4nB,GAAQc,SAAWd,GAAQ5nB,OAAS,CAAC,EAAG,+BAAgC,cAiC1E,IAAIuS,GAAQ,YAEZ,SAASoW,GAAc5a,EAAOhmB,EAAS6gC,EAASC,EAAWC,GAYzD,IAXA,IAAI3a,EACArK,EACA+S,EACAkS,EACAC,EACA3kB,EACA4kB,EAAWlhC,EAAQ0/B,yBACnByB,EAAQ,GACRvpC,EAAI,EACJC,EAAImuB,EAAMjpB,OAEPnF,EAAIC,EAAGD,IAGZ,IAFAwuB,EAAOJ,EAAMpuB,KAEQ,IAATwuB,EAEV,GAAqB,WAAjBT,EAAOS,GAGT/U,EAAO4U,MAAMkb,EAAO/a,EAAKljB,SAAW,CAACkjB,GAAQA,QACxC,GAAKoE,GAAM9N,KAAK0J,GAEhB,CASL,IARArK,EAAMA,GAAOmlB,EAAS32B,YAAYvK,EAAQmX,cAAc,QAExD2X,GAAO0Q,GAASnT,KAAKjG,IAAS,CAAC,GAAI,KAAK,GAAG4B,cAC3CgZ,EAAOnB,GAAQ/Q,IAAQ+Q,GAAQK,SAC/BnkB,EAAIvC,UAAYwnB,EAAK,GAAK3vB,EAAO+vB,cAAchb,GAAQ4a,EAAK,GAE5D1kB,EAAI0kB,EAAK,GAEF1kB,KACLP,EAAMA,EAAIsV,UAKZhgB,EAAO4U,MAAMkb,EAAOplB,EAAI8P,aAExB9P,EAAMmlB,EAASn+B,YAEXitB,YAAc,QApBlBmR,EAAMrhC,KAAKE,EAAQqhC,eAAejb,IA6BxC,IAHA8a,EAASlR,YAAc,GACvBp4B,EAAI,EAEGwuB,EAAO+a,EAAMvpC,MAElB,GAAIkpC,GAAazvB,EAAOsW,QAAQvB,EAAM0a,IAAc,EAC9CC,GACFA,EAAQjhC,KAAKsmB,QAejB,GATA6a,EAAWlD,GAAW3X,GAEtBrK,EAAMokB,GAAOe,EAAS32B,YAAY6b,GAAO,UAErC6a,GACFb,GAAcrkB,GAIZ8kB,EAGF,IAFAvkB,EAAI,EAEG8J,EAAOrK,EAAIO,MACZmjB,GAAY/iB,KAAK0J,EAAKnsB,MAAQ,KAChC4mC,EAAQ/gC,KAAKsmB,GAMrB,OAAO8a,EAGT,IAAII,GAAiB,sBAErB,SAASC,KACP,OAAO,EAGT,SAASC,KACP,OAAO,EAST,SAASC,GAAWrb,EAAMnsB,GACxB,OAAOmsB,IAMT,WACE,IACE,OAAOvf,EAASirB,cAChB,MAAO4P,KATOC,MAAkC,UAAT1nC,GAY3C,SAAS2nC,GAAIxb,EAAMyb,EAAOxhC,EAAUoU,EAAMyG,EAAI4mB,GAC5C,IAAIC,EAAQ9nC,EAEZ,GAAuB,WAAnBqC,EAAQulC,GAAqB,CAQ/B,IAAK5nC,IANmB,kBAAboG,IAEToU,EAAOA,GAAQpU,EACfA,OAAWxC,GAGAgkC,EACXD,GAAIxb,EAAMnsB,EAAMoG,EAAUoU,EAAMotB,EAAM5nC,GAAO6nC,GAG/C,OAAO1b,EAoBT,GAjBY,MAAR3R,GAAsB,MAANyG,GAElBA,EAAK7a,EACLoU,EAAOpU,OAAWxC,GACH,MAANqd,IACe,kBAAb7a,GAET6a,EAAKzG,EACLA,OAAO5W,IAGPqd,EAAKzG,EACLA,EAAOpU,EACPA,OAAWxC,KAIJ,IAAPqd,EACFA,EAAKsmB,QACA,IAAKtmB,EACV,OAAOkL,EAgBT,OAbY,IAAR0b,IACFC,EAAS7mB,GAETA,EAAK,SAAYxb,GAGf,OADA2R,IAAStG,IAAIrL,GACNqiC,EAAO5/B,MAAM3C,KAAMjC,aAIzBwqB,KAAOga,EAAOha,OAASga,EAAOha,KAAO1W,EAAO0W,SAG1C3B,EAAKD,MAAK,WACf9U,EAAO3R,MAAM4I,IAAI9I,KAAMqiC,EAAO3mB,EAAIzG,EAAMpU,MA4Y5C,SAAS2hC,GAAex+B,EAAIvJ,EAAMwnC,GAE3BA,GASL7E,EAASx7B,IAAIoC,EAAIvJ,GAAM,GACvBoX,EAAO3R,MAAM4I,IAAI9E,EAAIvJ,EAAM,CACzB+zB,WAAW,EACXruB,QAAS,SAAiBD,GACxB,IAAIuiC,EACAlgC,EACAmgC,EAAQtF,EAASnkC,IAAI+G,KAAMvF,GAE/B,GAAsB,EAAlByF,EAAMyiC,WAAiB3iC,KAAKvF,IAI9B,GAAKioC,EAAMnlC,QAoCCsU,EAAO3R,MAAMy6B,QAAQlgC,IAAS,IAAImoC,cAC5C1iC,EAAM4N,uBAlBN,GAfA40B,EAAQrd,EAAO9sB,KAAKwF,WACpBq/B,EAASx7B,IAAI5B,KAAMvF,EAAMioC,GAIzBD,EAAWR,EAAWjiC,KAAMvF,GAC5BuF,KAAKvF,KAGDioC,KAFJngC,EAAS66B,EAASnkC,IAAI+G,KAAMvF,KAEJgoC,EACtBrF,EAASx7B,IAAI5B,KAAMvF,GAAM,GAEzB8H,EAAS,GAGPmgC,IAAUngC,EASZ,OAPArC,EAAMkV,2BACNlV,EAAM0O,iBAMCrM,GAAUA,EAAOlJ,WAanBqpC,EAAMnlC,SAEf6/B,EAASx7B,IAAI5B,KAAMvF,EAAM,CACvBpB,MAAOwY,EAAO3R,MAAM2iC,QAEpBhxB,EAAOuV,OAAOsb,EAAM,GAAI7wB,EAAOkD,MAAM/a,WAAY0oC,EAAM77B,MAAM,GAAI7G,QAGnEE,EAAMkV,qCArEqB/W,IAA3B++B,EAASnkC,IAAI+K,EAAIvJ,IACnBoX,EAAO3R,MAAM4I,IAAI9E,EAAIvJ,EAAMsnC,IAvYjClwB,EAAO3R,MAAQ,CACbyR,OAAQ,GACR7I,IAAK,SAAa8d,EAAMyb,EAAOliC,EAAS8U,EAAMpU,GAC5C,IAAIiiC,EACAC,EACAxmB,EACAjd,EACAhG,EACA0pC,EACArI,EACAsI,EACAxoC,EACAyoC,EACAC,EACAC,EAAWhG,EAASnkC,IAAI2tB,GAE5B,GAAKmW,EAAWnW,GAuChB,IAlCIzmB,EAAQA,UAEVA,GADA2iC,EAAc3iC,GACQA,QACtBU,EAAWiiC,EAAYjiC,UAKrBA,GACFgR,EAAOC,KAAKuB,gBAAgBqb,GAAiB7tB,GAI1CV,EAAQooB,OACXpoB,EAAQooB,KAAO1W,EAAO0W,SAIlBjpB,EAAS8jC,EAAS9jC,UACtBA,EAAS8jC,EAAS9jC,OAASxG,OAAOY,OAAO,QAGrCqpC,EAAcK,EAASC,UAC3BN,EAAcK,EAASC,OAAS,SAAU19B,GAGxC,OAAwCkM,EAAO3R,MAAMojC,YAAc39B,EAAElL,KAAOoX,EAAO3R,MAAM8iB,SAASrgB,MAAMikB,EAAM7oB,gBAAaM,IAM/H/E,GADA+oC,GAASA,GAAS,IAAI1xB,MAAMonB,IAAkB,CAAC,KACrCx6B,OAEHjE,KAELmB,EAAO0oC,GADP5mB,EAAMulB,GAAejV,KAAKwV,EAAM/oC,KAAO,IACjB,GACtB4pC,GAAc3mB,EAAI,IAAM,IAAI5T,MAAM,KAAKvC,OAElC3L,IAKLkgC,EAAU9oB,EAAO3R,MAAMy6B,QAAQlgC,IAAS,GAExCA,GAAQoG,EAAW85B,EAAQiI,aAAejI,EAAQ4I,WAAa9oC,EAE/DkgC,EAAU9oB,EAAO3R,MAAMy6B,QAAQlgC,IAAS,GAExCuoC,EAAYnxB,EAAOuV,OAAO,CACxB3sB,KAAMA,EACN0oC,SAAUA,EACVluB,KAAMA,EACN9U,QAASA,EACTooB,KAAMpoB,EAAQooB,KACd1nB,SAAUA,EACV41B,aAAc51B,GAAYgR,EAAOme,KAAKrf,MAAM8lB,aAAavZ,KAAKrc,GAC9D2tB,UAAW0U,EAAWt6B,KAAK,MAC1Bk6B,IAEGG,EAAW3jC,EAAO7E,OACtBwoC,EAAW3jC,EAAO7E,GAAQ,IACjB+oC,cAAgB,EAEpB7I,EAAQ8I,QAAqE,IAA5D9I,EAAQ8I,MAAMlrC,KAAKquB,EAAM3R,EAAMiuB,EAAYH,IAC3Dnc,EAAKziB,kBACPyiB,EAAKziB,iBAAiB1J,EAAMsoC,IAK9BpI,EAAQ7xB,MACV6xB,EAAQ7xB,IAAIvQ,KAAKquB,EAAMoc,GAElBA,EAAU7iC,QAAQooB,OACrBya,EAAU7iC,QAAQooB,KAAOpoB,EAAQooB,OAKjC1nB,EACFoiC,EAAS9b,OAAO8b,EAASO,gBAAiB,EAAGR,GAE7CC,EAAS3iC,KAAK0iC,GAIhBnxB,EAAO3R,MAAMyR,OAAOlX,IAAQ,IAIhC8F,OAAQ,SAAgBqmB,EAAMyb,EAAOliC,EAASU,EAAU6iC,GACtD,IAAI5mB,EACA6mB,EACApnB,EACAjd,EACAhG,EACA0pC,EACArI,EACAsI,EACAxoC,EACAyoC,EACAC,EACAC,EAAWhG,EAASD,QAAQvW,IAASwW,EAASnkC,IAAI2tB,GAEtD,GAAKwc,IAAc9jC,EAAS8jC,EAAS9jC,QAArC,CAQA,IAFAhG,GADA+oC,GAASA,GAAS,IAAI1xB,MAAMonB,IAAkB,CAAC,KACrCx6B,OAEHjE,KAKL,GAHAmB,EAAO0oC,GADP5mB,EAAMulB,GAAejV,KAAKwV,EAAM/oC,KAAO,IACjB,GACtB4pC,GAAc3mB,EAAI,IAAM,IAAI5T,MAAM,KAAKvC,OAElC3L,EAAL,CAeA,IAPAkgC,EAAU9oB,EAAO3R,MAAMy6B,QAAQlgC,IAAS,GAExCwoC,EAAW3jC,EADX7E,GAAQoG,EAAW85B,EAAQiI,aAAejI,EAAQ4I,WAAa9oC,IACpC,GAC3B8hB,EAAMA,EAAI,IAAM,IAAIiO,OAAO,UAAY0Y,EAAWt6B,KAAK,iBAAmB,WAE1E+6B,EAAY7mB,EAAImmB,EAAS1lC,OAElBuf,KACLkmB,EAAYC,EAASnmB,IAEhB4mB,GAAeP,IAAaH,EAAUG,UAAehjC,GAAWA,EAAQooB,OAASya,EAAUza,MAAWhM,IAAOA,EAAIW,KAAK8lB,EAAUxU,YAAiB3tB,GAAYA,IAAamiC,EAAUniC,WAAyB,OAAbA,IAAqBmiC,EAAUniC,YAClOoiC,EAAS9b,OAAOrK,EAAG,GAEfkmB,EAAUniC,UACZoiC,EAASO,gBAGP7I,EAAQp6B,QACVo6B,EAAQp6B,OAAOhI,KAAKquB,EAAMoc,IAO5BW,IAAcV,EAAS1lC,SACpBo9B,EAAQiJ,WAAyE,IAA7DjJ,EAAQiJ,SAASrrC,KAAKquB,EAAMsc,EAAYE,EAASC,SACxExxB,EAAOgyB,YAAYjd,EAAMnsB,EAAM2oC,EAASC,eAGnC/jC,EAAO7E,SArCd,IAAKA,KAAQ6E,EACXuS,EAAO3R,MAAMK,OAAOqmB,EAAMnsB,EAAO4nC,EAAM/oC,GAAI6G,EAASU,GAAU,GAyChEgR,EAAOkW,cAAczoB,IACvB89B,EAAS78B,OAAOqmB,EAAM,mBAG1B5D,SAAU,SAAkB8gB,GAC1B,IAAI1rC,EACA0kB,EACA6B,EACAnb,EACAw/B,EACAe,EACAzhC,EAAO,IAAIpD,MAAMnB,UAAUR,QAE/B2C,EAAQ2R,EAAO3R,MAAM8jC,IAAIF,GACrBb,GAAY7F,EAASnkC,IAAI+G,KAAM,WAAalH,OAAOY,OAAO,OAAOwG,EAAMzF,OAAS,GAChFkgC,EAAU9oB,EAAO3R,MAAMy6B,QAAQz6B,EAAMzF,OAAS,GAIlD,IAFA6H,EAAK,GAAKpC,EAEL9H,EAAI,EAAGA,EAAI2F,UAAUR,OAAQnF,IAChCkK,EAAKlK,GAAK2F,UAAU3F,GAKtB,GAFA8H,EAAM+jC,eAAiBjkC,MAEnB26B,EAAQuJ,cAAyD,IAA1CvJ,EAAQuJ,YAAY3rC,KAAKyH,KAAME,GAA1D,CASA,IAJA6jC,EAAelyB,EAAO3R,MAAM+iC,SAAS1qC,KAAKyH,KAAME,EAAO+iC,GAEvD7qC,EAAI,GAEIoL,EAAUugC,EAAa3rC,QAAU8H,EAAMikC,wBAI7C,IAHAjkC,EAAM+P,cAAgBzM,EAAQojB,KAC9B9J,EAAI,GAEIkmB,EAAYx/B,EAAQy/B,SAASnmB,QAAU5c,EAAMkkC,iCAG9ClkC,EAAMmkC,aAAsC,IAAxBrB,EAAUxU,YAAuBtuB,EAAMmkC,WAAWnnB,KAAK8lB,EAAUxU,aACxFtuB,EAAM8iC,UAAYA,EAClB9iC,EAAM+U,KAAO+tB,EAAU/tB,UAGX5W,KAFZsgB,IAAQ9M,EAAO3R,MAAMy6B,QAAQqI,EAAUG,WAAa,IAAIE,QAAUL,EAAU7iC,SAASwC,MAAMa,EAAQojB,KAAMtkB,MAG1E,KAAxBpC,EAAMqC,OAASoc,KAClBze,EAAM0O,iBACN1O,EAAM4N,oBAYhB,OAJI6sB,EAAQ2J,cACV3J,EAAQ2J,aAAa/rC,KAAKyH,KAAME,GAG3BA,EAAMqC,SAEf0gC,SAAU,SAAkB/iC,EAAOqkC,GACjC,IAAInsC,EACA4qC,EACA7S,EACAqU,EACAC,EACAV,EAAe,GACfP,EAAgBe,EAAUf,cAC1B1V,EAAM5tB,EAAM7C,OAEhB,GAAImmC,GAEJ1V,EAAIpqB,YAKa,UAAfxD,EAAMzF,MAAoByF,EAAMwa,QAAU,GAC1C,KAAOoT,IAAQ9tB,KAAM8tB,EAAMA,EAAIxqB,YAActD,KAG3C,GAAqB,IAAjB8tB,EAAIpqB,WAAmC,UAAfxD,EAAMzF,OAAqC,IAAjBqzB,EAAI7sB,UAAoB,CAI5E,IAHAujC,EAAkB,GAClBC,EAAmB,GAEdrsC,EAAI,EAAGA,EAAIorC,EAAeprC,SAKCiG,IAA1BomC,EAFJtU,GAFA6S,EAAYuB,EAAUnsC,IAENyI,SAAW,OAGzB4jC,EAAiBtU,GAAO6S,EAAUvM,aAAe5kB,EAAOse,EAAKnwB,MAAMK,MAAMytB,IAAQ,EAAIjc,EAAOC,KAAKqe,EAAKnwB,KAAM,KAAM,CAAC8tB,IAAMvwB,QAGvHknC,EAAiBtU,IACnBqU,EAAgBlkC,KAAK0iC,GAIrBwB,EAAgBjnC,QAClBwmC,EAAazjC,KAAK,CAChBsmB,KAAMkH,EACNmV,SAAUuB,IAiBpB,OATA1W,EAAM9tB,KAEFwjC,EAAgBe,EAAUhnC,QAC5BwmC,EAAazjC,KAAK,CAChBsmB,KAAMkH,EACNmV,SAAUsB,EAAU19B,MAAM28B,KAIvBO,GAETW,QAAS,SAAiB/rC,EAAMgsC,GAC9B7rC,OAAOC,eAAe8Y,EAAOkD,MAAM/a,UAAWrB,EAAM,CAClDK,YAAY,EACZyE,cAAc,EACdxE,IAAK8F,EAAW4lC,GAAQ,WACtB,GAAI3kC,KAAK4kC,cACP,OAAOD,EAAK3kC,KAAK4kC,gBAEjB,WACF,GAAI5kC,KAAK4kC,cACP,OAAO5kC,KAAK4kC,cAAcjsC,IAG9BiJ,IAAK,SAAavI,GAChBP,OAAOC,eAAeiH,KAAMrH,EAAM,CAChCK,YAAY,EACZyE,cAAc,EACdC,UAAU,EACVrE,MAAOA,QAKf2qC,IAAK,SAAaY,GAChB,OAAOA,EAAc/yB,EAAO4V,SAAWmd,EAAgB,IAAI/yB,EAAOkD,MAAM6vB,IAE1EjK,QAAS,CACPkK,KAAM,CAEJC,UAAU,GAEZ51B,MAAO,CAELu0B,MAAO,SAAexuB,GAGpB,IAAIjR,EAAKhE,MAAQiV,EAQjB,OANI8qB,GAAe7iB,KAAKlZ,EAAGvJ,OAASuJ,EAAGkL,OAASgd,EAASloB,EAAI,UAE3Dw+B,GAAex+B,EAAI,QAAS+9B,KAIvB,GAETc,QAAS,SAAiB5tB,GAGxB,IAAIjR,EAAKhE,MAAQiV,EAOjB,OALI8qB,GAAe7iB,KAAKlZ,EAAGvJ,OAASuJ,EAAGkL,OAASgd,EAASloB,EAAI,UAC3Dw+B,GAAex+B,EAAI,UAId,GAIT08B,SAAU,SAAkBxgC,GAC1B,IAAI7C,EAAS6C,EAAM7C,OACnB,OAAO0iC,GAAe7iB,KAAK7f,EAAO5C,OAAS4C,EAAO6R,OAASgd,EAAS7uB,EAAQ,UAAY+/B,EAASnkC,IAAIoE,EAAQ,UAAY6uB,EAAS7uB,EAAQ,OAG9I0nC,aAAc,CACZT,aAAc,SAAsBpkC,QAGb7B,IAAjB6B,EAAMqC,QAAwBrC,EAAM0kC,gBACtC1kC,EAAM0kC,cAAcI,YAAc9kC,EAAMqC,YAwFlDsP,EAAOgyB,YAAc,SAAUjd,EAAMnsB,EAAM4oC,GAErCzc,EAAKxiB,qBACPwiB,EAAKxiB,oBAAoB3J,EAAM4oC,KAInCxxB,EAAOkD,MAAQ,SAAUgR,EAAKzoB,GAE5B,KAAM0C,gBAAgB6R,EAAOkD,OAC3B,OAAO,IAAIlD,EAAOkD,MAAMgR,EAAKzoB,GAI3ByoB,GAAOA,EAAItrB,MACbuF,KAAK4kC,cAAgB7e,EACrB/lB,KAAKvF,KAAOsrB,EAAItrB,KAGhBuF,KAAKilC,mBAAqBlf,EAAI/Q,uBAA6C3W,IAAzB0nB,EAAI/Q,mBAClC,IAApB+Q,EAAIif,YAAwBjD,GAAaC,GAIzChiC,KAAK3C,OAAS0oB,EAAI1oB,QAAkC,IAAxB0oB,EAAI1oB,OAAOqG,SAAiBqiB,EAAI1oB,OAAOiG,WAAayiB,EAAI1oB,OACpF2C,KAAKiQ,cAAgB8V,EAAI9V,cACzBjQ,KAAKklC,cAAgBnf,EAAImf,eAEzBllC,KAAKvF,KAAOsrB,EAIVzoB,GACFuU,EAAOuV,OAAOpnB,KAAM1C,GAItB0C,KAAKmlC,UAAYpf,GAAOA,EAAIof,WAAaljC,KAAKD,MAE9ChC,KAAK6R,EAAO4V,UAAW,IAKZztB,UAAY,CACvBO,YAAasX,EAAOkD,MACpBkwB,mBAAoBjD,GACpBmC,qBAAsBnC,GACtBoC,8BAA+BpC,GAC/BoD,aAAa,EACbx2B,eAAgB,WACd,IAAIjJ,EAAI3F,KAAK4kC,cACb5kC,KAAKilC,mBAAqBlD,GAEtBp8B,IAAM3F,KAAKolC,aACbz/B,EAAEiJ,kBAGNd,gBAAiB,WACf,IAAInI,EAAI3F,KAAK4kC,cACb5kC,KAAKmkC,qBAAuBpC,GAExBp8B,IAAM3F,KAAKolC,aACbz/B,EAAEmI,mBAGNsH,yBAA0B,WACxB,IAAIzP,EAAI3F,KAAK4kC,cACb5kC,KAAKokC,8BAAgCrC,GAEjCp8B,IAAM3F,KAAKolC,aACbz/B,EAAEyP,2BAGJpV,KAAK8N,oBAIT+D,EAAO8U,KAAK,CACV0e,QAAQ,EACRzwB,SAAS,EACTC,YAAY,EACZpG,gBAAgB,EAChByM,SAAS,EACTpG,QAAQ,EACRwwB,YAAY,EACZrqB,SAAS,EACTjO,OAAO,EACPC,OAAO,EACPs4B,UAAU,EACVC,MAAM,EACN,MAAQ,EACRvgB,MAAM,EACNwgB,UAAU,EACV9rC,KAAK,EACLyW,SAAS,EACTsK,QAAQ,EACRgrB,SAAS,EACTC,SAAS,EACTC,SAAS,EACTC,SAAS,EACTC,SAAS,EACTC,WAAW,EACXC,aAAa,EACbC,SAAS,EACTC,SAAS,EACTC,eAAe,EACfC,WAAW,EACXr5B,SAAS,EACTs5B,OAAO,GACNx0B,EAAO3R,MAAMwkC,SAChB7yB,EAAO8U,KAAK,CACVjC,MAAO,UACP4hB,KAAM,aACL,SAAU7rC,EAAMmoC,GACjB/wB,EAAO3R,MAAMy6B,QAAQlgC,GAAQ,CAE3BgpC,MAAO,WAML,OAFAjB,GAAexiC,KAAMvF,EAAMwnC,KAEpB,GAETY,QAAS,WAIP,OAFAL,GAAexiC,KAAMvF,IAEd,GAITimC,SAAU,WACR,OAAO,GAETkC,aAAcA,MAWlB/wB,EAAO8U,KAAK,CACV4f,WAAY,YACZC,WAAY,WACZC,aAAc,cACdC,aAAc,eACb,SAAUC,EAAM3C,GACjBnyB,EAAO3R,MAAMy6B,QAAQgM,GAAQ,CAC3B/D,aAAcoB,EACdT,SAAUS,EACVX,OAAQ,SAAgBnjC,GACtB,IAAIye,EACAthB,EAAS2C,KACT4mC,EAAU1mC,EAAMglC,cAChBlC,EAAY9iC,EAAM8iC,UAStB,OANK4D,IAAWA,IAAYvpC,GAAWwU,EAAO1K,SAAS9J,EAAQupC,MAC7D1mC,EAAMzF,KAAOuoC,EAAUG,SACvBxkB,EAAMqkB,EAAU7iC,QAAQwC,MAAM3C,KAAMjC,WACpCmC,EAAMzF,KAAOupC,GAGRrlB,OAIb9M,EAAO6J,GAAG0L,OAAO,CACfhnB,GAAI,SAAYiiC,EAAOxhC,EAAUoU,EAAMyG,GACrC,OAAO0mB,GAAIpiC,KAAMqiC,EAAOxhC,EAAUoU,EAAMyG,IAE1C4mB,IAAK,SAAaD,EAAOxhC,EAAUoU,EAAMyG,GACvC,OAAO0mB,GAAIpiC,KAAMqiC,EAAOxhC,EAAUoU,EAAMyG,EAAI,IAE9CnQ,IAAK,SAAa82B,EAAOxhC,EAAU6a,GACjC,IAAIsnB,EAAWvoC,EAEf,GAAI4nC,GAASA,EAAMzzB,gBAAkByzB,EAAMW,UAIzC,OAFAA,EAAYX,EAAMW,UAClBnxB,EAAOwwB,EAAM4B,gBAAgB14B,IAAIy3B,EAAUxU,UAAYwU,EAAUG,SAAW,IAAMH,EAAUxU,UAAYwU,EAAUG,SAAUH,EAAUniC,SAAUmiC,EAAU7iC,SACnJH,KAGT,GAAuB,WAAnBlD,EAAQulC,GAAqB,CAE/B,IAAK5nC,KAAQ4nC,EACXriC,KAAKuL,IAAI9Q,EAAMoG,EAAUwhC,EAAM5nC,IAGjC,OAAOuF,KAaT,OAViB,IAAba,GAA0C,oBAAbA,IAE/B6a,EAAK7a,EACLA,OAAWxC,IAGF,IAAPqd,IACFA,EAAKsmB,IAGAhiC,KAAK2mB,MAAK,WACf9U,EAAO3R,MAAMK,OAAOP,KAAMqiC,EAAO3mB,EAAI7a,SAI3C,IAGAgmC,GAAe,wBAEfC,GAAW,oCACPC,GAAe,2CAEnB,SAASC,GAAmBpgB,EAAM1T,GAChC,OAAIgZ,EAAStF,EAAM,UAAYsF,EAA8B,KAArBhZ,EAAQxP,SAAkBwP,EAAUA,EAAQ3P,WAAY,OACvFsO,EAAO+U,GAAM7f,SAAS,SAAS,IAGjC6f,EAIT,SAASqgB,GAAcrgB,GAErB,OADAA,EAAKnsB,MAAsC,OAA9BmsB,EAAKtX,aAAa,SAAoB,IAAMsX,EAAKnsB,KACvDmsB,EAGT,SAASsgB,GAActgB,GAOrB,MANsC,WAAjCA,EAAKnsB,MAAQ,IAAIoM,MAAM,EAAG,GAC7B+f,EAAKnsB,KAAOmsB,EAAKnsB,KAAKoM,MAAM,GAE5B+f,EAAKrX,gBAAgB,QAGhBqX,EAGT,SAASugB,GAAephB,EAAKqhB,GAC3B,IAAIhvC,EAAGC,EAAGoC,EAAgB4sC,EAAUC,EAAUhoC,EAE9C,GAAsB,IAAlB8nC,EAAK1jC,SAAT,CAKA,GAAI05B,EAASD,QAAQpX,KAEnBzmB,EADW89B,EAASnkC,IAAI8sB,GACNzmB,QAKhB,IAAK7E,KAFL2iC,EAAS78B,OAAO6mC,EAAM,iBAET9nC,EACX,IAAKlH,EAAI,EAAGC,EAAIiH,EAAO7E,GAAM8C,OAAQnF,EAAIC,EAAGD,IAC1CyZ,EAAO3R,MAAM4I,IAAIs+B,EAAM3sC,EAAM6E,EAAO7E,GAAMrC,IAO9CilC,EAASF,QAAQpX,KACnBshB,EAAWhK,EAASjB,OAAOrW,GAC3BuhB,EAAWz1B,EAAOuV,OAAO,GAAIigB,GAC7BhK,EAASz7B,IAAIwlC,EAAME,KAKvB,SAASC,GAASxhB,EAAKqhB,GACrB,IAAIlb,EAAWkb,EAAKlb,SAAS1D,cAEZ,UAAb0D,GAAwB6T,GAAe7iB,KAAK6I,EAAItrB,MAClD2sC,EAAKzuB,QAAUoN,EAAIpN,QACG,UAAbuT,GAAqC,aAAbA,IACjCkb,EAAKpR,aAAejQ,EAAIiQ,cAI5B,SAASwR,GAASC,EAAYnlC,EAAMgG,EAAUi5B,GAE5Cj/B,EAAOgjB,EAAKhjB,GACZ,IAAIo/B,EACAviB,EACAkiB,EACAqG,EACArkC,EACA6iB,EACA9tB,EAAI,EACJC,EAAIovC,EAAWlqC,OACfoqC,EAAWtvC,EAAI,EACfgB,EAAQiJ,EAAK,GACbslC,EAAkB7oC,EAAW1F,GAEjC,GAAIuuC,GAAmBvvC,EAAI,GAAsB,kBAAVgB,IAAuBusB,EAAQua,YAAc2G,GAAS5pB,KAAK7jB,GAChG,OAAOouC,EAAW9gB,MAAK,SAAUtmB,GAC/B,IAAI5B,EAAOgpC,EAAW5gB,GAAGxmB,GAErBunC,IACFtlC,EAAK,GAAKjJ,EAAMd,KAAKyH,KAAMK,EAAO5B,EAAKmX,SAGzC4xB,GAAS/oC,EAAM6D,EAAMgG,EAAUi5B,MAInC,GAAIlpC,IAEF8mB,GADAuiB,EAAWN,GAAc9+B,EAAMmlC,EAAW,GAAG7a,eAAe,EAAO6a,EAAYlG,IAC9Dh+B,WAEkB,IAA/Bm+B,EAASrV,WAAW9uB,SACtBmkC,EAAWviB,GAITA,GAASoiB,GAAS,CAMpB,IAJAmG,GADArG,EAAUxvB,EAAO+G,IAAI+nB,GAAOe,EAAU,UAAWuF,KAC5B1pC,OAIdnF,EAAIC,EAAGD,IACZiL,EAAOq+B,EAEHtpC,IAAMuvC,IACRtkC,EAAOwO,EAAOvH,MAAMjH,GAAM,GAAM,GAE5BqkC,GAGF71B,EAAO4U,MAAM4a,EAASV,GAAOt9B,EAAM,YAIvCiF,EAAS/P,KAAKkvC,EAAWrvC,GAAIiL,EAAMjL,GAGrC,GAAIsvC,EAKF,IAJAxhB,EAAMmb,EAAQA,EAAQ9jC,OAAS,GAAGqvB,cAElC/a,EAAO+G,IAAIyoB,EAAS6F,IAEf9uC,EAAI,EAAGA,EAAIsvC,EAAYtvC,IAC1BiL,EAAOg+B,EAAQjpC,GAEX6nC,GAAY/iB,KAAK7Z,EAAK5I,MAAQ,MAAQ2iC,EAAShB,OAAO/4B,EAAM,eAAiBwO,EAAO1K,SAAS+e,EAAK7iB,KAChGA,EAAK0iB,KAA2C,YAAnC1iB,EAAK5I,MAAQ,IAAI+tB,cAE5B3W,EAAOg2B,WAAaxkC,EAAK2iB,UAC3BnU,EAAOg2B,SAASxkC,EAAK0iB,IAAK,CACxBhT,MAAO1P,EAAK0P,OAAS1P,EAAKiM,aAAa,UACtC4W,GAGLD,EAAQ5iB,EAAKmtB,YAAY1Y,QAAQivB,GAAc,IAAK1jC,EAAM6iB,IAQtE,OAAOuhB,EAGT,SAASK,GAAQlhB,EAAM/lB,EAAUknC,GAK/B,IAJA,IAAI1kC,EACAs+B,EAAQ9gC,EAAWgR,EAAO7K,OAAOnG,EAAU+lB,GAAQA,EACnDxuB,EAAI,EAEoB,OAApBiL,EAAOs+B,EAAMvpC,IAAaA,IAC3B2vC,GAA8B,IAAlB1kC,EAAKK,UACpBmO,EAAOm2B,UAAUrH,GAAOt9B,IAGtBA,EAAKC,aACHykC,GAAYxJ,GAAWl7B,IACzBu9B,GAAcD,GAAOt9B,EAAM,WAG7BA,EAAKC,WAAW6H,YAAY9H,IAIhC,OAAOujB,EAGT/U,EAAOuV,OAAO,CACZwa,cAAe,SAAuBhsB,GACpC,OAAOA,GAETtL,MAAO,SAAesc,EAAMqhB,EAAeC,GACzC,IAAI9vC,EACAC,EACA8vC,EACAC,EACA99B,EAAQsc,EAAKrc,WAAU,GACvB89B,EAAS9J,GAAW3X,GAExB,IAAKhB,EAAQwa,iBAAqC,IAAlBxZ,EAAKljB,UAAoC,KAAlBkjB,EAAKljB,YAAqBmO,EAAOqkB,SAAStP,GAK/F,IAHAwhB,EAAezH,GAAOr2B,GAGjBlS,EAAI,EAAGC,GAFZ8vC,EAAcxH,GAAO/Z,IAEOrpB,OAAQnF,EAAIC,EAAGD,IACzCmvC,GAASY,EAAY/vC,GAAIgwC,EAAahwC,IAK1C,GAAI6vC,EACF,GAAIC,EAIF,IAHAC,EAAcA,GAAexH,GAAO/Z,GACpCwhB,EAAeA,GAAgBzH,GAAOr2B,GAEjClS,EAAI,EAAGC,EAAI8vC,EAAY5qC,OAAQnF,EAAIC,EAAGD,IACzC+uC,GAAegB,EAAY/vC,GAAIgwC,EAAahwC,SAG9C+uC,GAAevgB,EAAMtc,GAYzB,OAPA89B,EAAezH,GAAOr2B,EAAO,WAEZ/M,OAAS,GACxBqjC,GAAcwH,GAAeC,GAAU1H,GAAO/Z,EAAM,WAI/Ctc,GAET09B,UAAW,SAAmBxhB,GAO5B,IANA,IAAIvR,EACA2R,EACAnsB,EACAkgC,EAAU9oB,EAAO3R,MAAMy6B,QACvBviC,EAAI,OAEqBiG,KAArBuoB,EAAOJ,EAAMpuB,IAAmBA,IACtC,GAAI2kC,EAAWnW,GAAO,CACpB,GAAI3R,EAAO2R,EAAKwW,EAAS3V,SAAU,CACjC,GAAIxS,EAAK3V,OACP,IAAK7E,KAAQwa,EAAK3V,OACZq7B,EAAQlgC,GACVoX,EAAO3R,MAAMK,OAAOqmB,EAAMnsB,GAE1BoX,EAAOgyB,YAAYjd,EAAMnsB,EAAMwa,EAAKouB,QAO1Czc,EAAKwW,EAAS3V,cAAWppB,EAGvBuoB,EAAKyW,EAAS5V,WAGhBb,EAAKyW,EAAS5V,cAAWppB,OAMnCwT,EAAO6J,GAAG0L,OAAO,CACfjY,OAAQ,SAAgBtO,GACtB,OAAOinC,GAAQ9nC,KAAMa,GAAU,IAEjCN,OAAQ,SAAgBM,GACtB,OAAOinC,GAAQ9nC,KAAMa,IAEvB8U,KAAM,SAActc,GAClB,OAAO+iC,EAAOp8B,MAAM,SAAU3G,GAC5B,YAAiBgF,IAAVhF,EAAsBwY,EAAO8D,KAAK3V,MAAQA,KAAKs5B,QAAQ3S,MAAK,WAC3C,IAAlB3mB,KAAK0D,UAAoC,KAAlB1D,KAAK0D,UAAqC,IAAlB1D,KAAK0D,WACtD1D,KAAKwwB,YAAcn3B,QAGtB,KAAMA,EAAO0E,UAAUR,SAE5BmN,OAAQ,WACN,OAAO88B,GAASxnC,KAAMjC,WAAW,SAAU6oB,GACnB,IAAlB5mB,KAAK0D,UAAoC,KAAlB1D,KAAK0D,UAAqC,IAAlB1D,KAAK0D,UACzCsjC,GAAmBhnC,KAAM4mB,GAC/B7b,YAAY6b,OAIzB/b,QAAS,WACP,OAAO28B,GAASxnC,KAAMjC,WAAW,SAAU6oB,GACzC,GAAsB,IAAlB5mB,KAAK0D,UAAoC,KAAlB1D,KAAK0D,UAAqC,IAAlB1D,KAAK0D,SAAgB,CACtE,IAAIrG,EAAS2pC,GAAmBhnC,KAAM4mB,GACtCvpB,EAAO4N,aAAa2b,EAAMvpB,EAAOkG,iBAIvC6B,OAAQ,WACN,OAAOoiC,GAASxnC,KAAMjC,WAAW,SAAU6oB,GACrC5mB,KAAKsD,YACPtD,KAAKsD,WAAW2H,aAAa2b,EAAM5mB,UAIzCiI,MAAO,WACL,OAAOu/B,GAASxnC,KAAMjC,WAAW,SAAU6oB,GACrC5mB,KAAKsD,YACPtD,KAAKsD,WAAW2H,aAAa2b,EAAM5mB,KAAKyD,iBAI9C61B,MAAO,WAIL,IAHA,IAAI1S,EACAxuB,EAAI,EAEmB,OAAnBwuB,EAAO5mB,KAAK5H,IAAaA,IACT,IAAlBwuB,EAAKljB,WAEPmO,EAAOm2B,UAAUrH,GAAO/Z,GAAM,IAE9BA,EAAK4J,YAAc,IAIvB,OAAOxwB,MAETsK,MAAO,SAAe29B,EAAeC,GAGnC,OAFAD,EAAiC,MAAjBA,GAAgCA,EAChDC,EAAyC,MAArBA,EAA4BD,EAAgBC,EACzDloC,KAAK4Y,KAAI,WACd,OAAO/G,EAAOvH,MAAMtK,KAAMioC,EAAeC,OAG7CtyB,KAAM,SAAcvc,GAClB,OAAO+iC,EAAOp8B,MAAM,SAAU3G,GAC5B,IAAIutB,EAAO5mB,KAAK,IAAM,GAClB5H,EAAI,EACJC,EAAI2H,KAAKzC,OAEb,QAAcc,IAAVhF,GAAyC,IAAlButB,EAAKljB,SAC9B,OAAOkjB,EAAK5M,UAId,GAAqB,kBAAV3gB,IAAuBwtC,GAAa3pB,KAAK7jB,KAAWgnC,IAASL,GAASnT,KAAKxzB,IAAU,CAAC,GAAI,KAAK,GAAGmvB,eAAgB,CAC3HnvB,EAAQwY,EAAO+vB,cAAcvoC,GAE7B,IACE,KAAOjB,EAAIC,EAAGD,IAGU,KAFtBwuB,EAAO5mB,KAAK5H,IAAM,IAETsL,WACPmO,EAAOm2B,UAAUrH,GAAO/Z,GAAM,IAC9BA,EAAK5M,UAAY3gB,GAIrButB,EAAO,EACP,MAAOjhB,KAGPihB,GACF5mB,KAAKs5B,QAAQ5uB,OAAOrR,KAErB,KAAMA,EAAO0E,UAAUR,SAE5B+qC,YAAa,WACX,IAAI/G,EAAU,GAEd,OAAOiG,GAASxnC,KAAMjC,WAAW,SAAU6oB,GACzC,IAAItoB,EAAS0B,KAAKsD,WAEduO,EAAOsW,QAAQnoB,KAAMuhC,GAAW,IAClC1vB,EAAOm2B,UAAUrH,GAAO3gC,OAEpB1B,GACFA,EAAOiqC,aAAa3hB,EAAM5mB,SAI7BuhC,MAGP1vB,EAAO8U,KAAK,CACV6hB,SAAU,SACVC,UAAW,UACXx9B,aAAc,SACdy9B,YAAa,QACbC,WAAY,gBACX,SAAUhwC,EAAMiwC,GACjB/2B,EAAO6J,GAAG/iB,GAAQ,SAAUkI,GAO1B,IANA,IAAI2lB,EACA7H,EAAM,GACNkqB,EAASh3B,EAAOhR,GAChBimB,EAAO+hB,EAAOtrC,OAAS,EACvBnF,EAAI,EAEDA,GAAK0uB,EAAM1uB,IAChBouB,EAAQpuB,IAAM0uB,EAAO9mB,KAAOA,KAAKsK,OAAM,GACvCuH,EAAOg3B,EAAOzwC,IAAIwwC,GAAUpiB,GAG5BlmB,EAAKqC,MAAMgc,EAAK6H,EAAMvtB,OAGxB,OAAO+G,KAAKumB,UAAU5H,OAG1B,IAAImqB,GAAY,IAAIte,OAAO,KAAO4T,GAAO,kBAAmB,KAExD2K,GAAY,SAAmBniB,GAIjC,IAAI4e,EAAO5e,EAAKgG,cAAciC,YAM9B,OAJK2W,GAASA,EAAKwD,SACjBxD,EAAO5hC,GAGF4hC,EAAKyD,iBAAiBriB,IAG3BsiB,GAAO,SAActiB,EAAM9mB,EAASwI,GACtC,IAAIqW,EACAhmB,EACAwwC,EAAM,GAEV,IAAKxwC,KAAQmH,EACXqpC,EAAIxwC,GAAQiuB,EAAK9e,MAAMnP,GACvBiuB,EAAK9e,MAAMnP,GAAQmH,EAAQnH,GAK7B,IAAKA,KAFLgmB,EAAMrW,EAAS/P,KAAKquB,GAEP9mB,EACX8mB,EAAK9e,MAAMnP,GAAQwwC,EAAIxwC,GAGzB,OAAOgmB,GAGLyqB,GAAY,IAAI5e,OAAO8T,GAAU11B,KAAK,KAAM,KAyHhD,SAASygC,GAAOziB,EAAMjuB,EAAM2wC,GAC1B,IAAIhkC,EACAikC,EACAC,EACA7qB,EAKJ7W,EAAQ8e,EAAK9e,MAgCb,OA/BAwhC,EAAWA,GAAYP,GAAUniB,MAOnB,MAFZjI,EAAM2qB,EAASG,iBAAiB9wC,IAAS2wC,EAAS3wC,KAE/B4lC,GAAW3X,KAC5BjI,EAAM9M,EAAO/J,MAAM8e,EAAMjuB,KAQtBitB,EAAQ8jB,kBAAoBZ,GAAU5rB,KAAKyB,IAAQyqB,GAAUlsB,KAAKvkB,KAErE2M,EAAQwC,EAAMxC,MACdikC,EAAWzhC,EAAMyhC,SACjBC,EAAW1hC,EAAM0hC,SAEjB1hC,EAAMyhC,SAAWzhC,EAAM0hC,SAAW1hC,EAAMxC,MAAQqZ,EAChDA,EAAM2qB,EAAShkC,MAEfwC,EAAMxC,MAAQA,EACdwC,EAAMyhC,SAAWA,EACjBzhC,EAAM0hC,SAAWA,SAINnrC,IAARsgB,EAEPA,EAAM,GAAKA,EAGb,SAASgrB,GAAaC,EAAaC,GAEjC,MAAO,CACL5wC,IAAK,WACH,IAAI2wC,IAQJ,OAAQ5pC,KAAK/G,IAAM4wC,GAAQlnC,MAAM3C,KAAMjC,kBAL9BiC,KAAK/G,OA5KpB,WAGE,SAAS6wC,IAEP,GAAKhK,EAAL,CAIAiK,EAAUjiC,MAAMkiC,QAAU,+EAC1BlK,EAAIh4B,MAAMkiC,QAAU,4HACpBtb,GAAgB3jB,YAAYg/B,GAAWh/B,YAAY+0B,GACnD,IAAImK,EAAWrmC,EAAOqlC,iBAAiBnJ,GACvCoK,EAAoC,OAAjBD,EAASnb,IAE5Bqb,EAAoE,KAA5CC,EAAmBH,EAASxgC,YAGpDq2B,EAAIh4B,MAAMuiC,MAAQ,MAClBC,EAA2D,KAAvCF,EAAmBH,EAASI,OAGhDE,EAA8D,KAAvCH,EAAmBH,EAAS3kC,OAKnDw6B,EAAIh4B,MAAM0iC,SAAW,WACrBC,EAA+D,KAA5CL,EAAmBtK,EAAIx2B,YAAc,GACxDolB,GAAgBvjB,YAAY4+B,GAG5BjK,EAAM,MAGR,SAASsK,EAAmBM,GAC1B,OAAOvgC,KAAKgE,MAAMJ,WAAW28B,IAG/B,IAAIR,EACAK,EACAE,EACAH,EACAK,EACAR,EACAJ,EAAY1iC,EAASsQ,cAAc,OACnCmoB,EAAMz4B,EAASsQ,cAAc,OAE5BmoB,EAAIh4B,QAMTg4B,EAAIh4B,MAAM8iC,eAAiB,cAC3B9K,EAAIv1B,WAAU,GAAMzC,MAAM8iC,eAAiB,GAC3ChlB,EAAQilB,gBAA+C,gBAA7B/K,EAAIh4B,MAAM8iC,eACpC/4B,EAAOuV,OAAOxB,EAAS,CACrBklB,kBAAmB,WAEjB,OADAhB,IACOS,GAETb,eAAgB,WAEd,OADAI,IACOQ,GAETS,cAAe,WAEb,OADAjB,IACOI,GAETc,mBAAoB,WAElB,OADAlB,IACOK,GAETc,cAAe,WAEb,OADAnB,IACOW,GAWTS,qBAAsB,WACpB,IAAIC,EAAO3K,EAAI4K,EAASC,EA0BxB,OAxB+B,MAA3BV,IACFQ,EAAQ9jC,EAASsQ,cAAc,SAC/B6oB,EAAKn5B,EAASsQ,cAAc,MAC5ByzB,EAAU/jC,EAASsQ,cAAc,OACjCwzB,EAAMrjC,MAAMkiC,QAAU,2DACtBxJ,EAAG14B,MAAMkiC,QAAU,mBAInBxJ,EAAG14B,MAAMwjC,OAAS,MAClBF,EAAQtjC,MAAMwjC,OAAS,MAOvBF,EAAQtjC,MAAMwS,QAAU,QACxBoU,GAAgB3jB,YAAYogC,GAAOpgC,YAAYy1B,GAAIz1B,YAAYqgC,GAC/DC,EAAUznC,EAAOqlC,iBAAiBzI,GAClCmK,EAA0B/rC,SAASysC,EAAQC,OAAQ,IAAM1sC,SAASysC,EAAQE,eAAgB,IAAM3sC,SAASysC,EAAQG,kBAAmB,MAAQhL,EAAGiL,aAC/I/c,GAAgBvjB,YAAYggC,IAGvBR,MAlHb,GAsLA,IAAIe,GAAc,CAAC,SAAU,MAAO,MAChCC,GAAatkC,EAASsQ,cAAc,OAAO7P,MAC3C8jC,GAAc,GAiBlB,SAASC,GAAclzC,GACrB,IAAImzC,EAAQj6B,EAAOk6B,SAASpzC,IAASizC,GAAYjzC,GAEjD,OAAImzC,IAIAnzC,KAAQgzC,GACHhzC,EAGFizC,GAAYjzC,GA1BrB,SAAwBA,GAKtB,IAHA,IAAIqzC,EAAUrzC,EAAK,GAAGoe,cAAgBpe,EAAKkO,MAAM,GAC7CzO,EAAIszC,GAAYnuC,OAEbnF,KAGL,IAFAO,EAAO+yC,GAAYtzC,GAAK4zC,KAEZL,GACV,OAAOhzC,EAiBgBszC,CAAetzC,IAASA,GAGrD,IAGAuzC,GAAe,4BACXC,GAAc,MACdC,GAAU,CACZ5B,SAAU,WACV6B,WAAY,SACZ/xB,QAAS,SAEPgyB,GAAqB,CACvBC,cAAe,IACfC,WAAY,OAGd,SAASC,GAAkBxlB,EAAO5tB,EAAOqzC,GAGvC,IAAI57B,EAAUutB,GAAQxR,KAAKxzB,GAC3B,OAAOyX,EACP3G,KAAKC,IAAI,EAAG0G,EAAQ,IAAM47B,GAAY,KAAO57B,EAAQ,IAAM,MAAQzX,EAGrE,SAASszC,GAAmB/lB,EAAMgmB,EAAWC,EAAKC,EAAaC,EAAQC,GACrE,IAAI50C,EAAkB,UAAdw0C,EAAwB,EAAI,EAChCK,EAAQ,EACRC,EAAQ,EAEZ,GAAIL,KAASC,EAAc,SAAW,WACpC,OAAO,EAGT,KAAO10C,EAAI,EAAGA,GAAK,EAEL,WAARy0C,IACFK,GAASr7B,EAAO8sB,IAAI/X,EAAMimB,EAAMvO,GAAUlmC,IAAI,EAAM20C,IAIjDD,GAaS,YAARD,IACFK,GAASr7B,EAAO8sB,IAAI/X,EAAM,UAAY0X,GAAUlmC,IAAI,EAAM20C,IAIhD,WAARF,IACFK,GAASr7B,EAAO8sB,IAAI/X,EAAM,SAAW0X,GAAUlmC,GAAK,SAAS,EAAM20C,MAjBrEG,GAASr7B,EAAO8sB,IAAI/X,EAAM,UAAY0X,GAAUlmC,IAAI,EAAM20C,GAE9C,YAARF,EACFK,GAASr7B,EAAO8sB,IAAI/X,EAAM,SAAW0X,GAAUlmC,GAAK,SAAS,EAAM20C,GAEnEE,GAASp7B,EAAO8sB,IAAI/X,EAAM,SAAW0X,GAAUlmC,GAAK,SAAS,EAAM20C,IA0BzE,OARKD,GAAeE,GAAe,IAGjCE,GAAS/iC,KAAKC,IAAI,EAAGD,KAAK+V,KAAK0G,EAAK,SAAWgmB,EAAU,GAAG71B,cAAgB61B,EAAU/lC,MAAM,IAAMmmC,EAAcE,EAAQD,EAAQ,MAE1H,GAGDC,EAGT,SAASC,GAAiBvmB,EAAMgmB,EAAWK,GAEzC,IAAIF,EAAShE,GAAUniB,GAInBkmB,IADelnB,EAAQklB,qBAAuBmC,IACoC,eAAjDp7B,EAAO8sB,IAAI/X,EAAM,aAAa,EAAOmmB,GACtEK,EAAmBN,EACnBlvB,EAAMyrB,GAAOziB,EAAMgmB,EAAWG,GAC9BM,EAAa,SAAWT,EAAU,GAAG71B,cAAgB61B,EAAU/lC,MAAM,GAGzE,GAAIiiC,GAAU5rB,KAAKU,GAAM,CACvB,IAAKqvB,EACH,OAAOrvB,EAGTA,EAAM,OA8BR,QAxBMgI,EAAQklB,qBAAuBgC,IAIpClnB,EAAQslB,wBAA0Bhf,EAAStF,EAAM,OAE1C,SAARhJ,IAEC7P,WAAW6P,IAAuD,WAA/C/L,EAAO8sB,IAAI/X,EAAM,WAAW,EAAOmmB,KACvDnmB,EAAK0mB,iBAAiB/vC,SACpBuvC,EAA+D,eAAjDj7B,EAAO8sB,IAAI/X,EAAM,aAAa,EAAOmmB,IAInDK,EAAmBC,KAAczmB,KAG/BhJ,EAAMgJ,EAAKymB,MAKfzvB,EAAM7P,WAAW6P,IAAQ,GAEZ+uB,GAAmB/lB,EAAMgmB,EAAWK,IAAUH,EAAc,SAAW,WAAYM,EAAkBL,EAClHnvB,GAAO,KA2PT,SAAS2vB,GAAM3mB,EAAM9mB,EAASJ,EAAMwK,EAAKsjC,GACvC,OAAO,IAAID,GAAMvzC,UAAUosB,KAAKQ,EAAM9mB,EAASJ,EAAMwK,EAAKsjC,GAzP5D37B,EAAOuV,OAAO,CAGZqmB,SAAU,CACRC,QAAS,CACPz0C,IAAK,SAAa2tB,EAAM0iB,GACtB,GAAIA,EAAU,CAEZ,IAAI3qB,EAAM0qB,GAAOziB,EAAM,WACvB,MAAe,KAARjI,EAAa,IAAMA,MAMlC0gB,UAAW,CACT,yBAA2B,EAC3B,aAAe,EACf,aAAe,EACf,UAAY,EACZ,YAAc,EACd,YAAc,EACd,UAAY,EACZ,YAAc,EACd,eAAiB,EACjB,iBAAmB,EACnB,SAAW,EACX,YAAc,EACd,cAAgB,EAChB,YAAc,EACd,SAAW,EACX,OAAS,EACT,SAAW,EACX,QAAU,EACV,QAAU,EACV,MAAQ,GAIV0M,SAAU,GAEVjkC,MAAO,SAAe8e,EAAMjuB,EAAMU,EAAO4zC,GAEvC,GAAKrmB,GAA0B,IAAlBA,EAAKljB,UAAoC,IAAlBkjB,EAAKljB,UAAmBkjB,EAAK9e,MAAjE,CAKA,IAAI6W,EACAlkB,EACAqjC,EACA6P,EAAW9Q,EAAUlkC,GACrBi1C,EAAezB,GAAYjvB,KAAKvkB,GAChCmP,EAAQ8e,EAAK9e,MAWjB,GAPK8lC,IACHj1C,EAAOkzC,GAAc8B,IAIvB7P,EAAQjsB,EAAO47B,SAAS90C,IAASkZ,EAAO47B,SAASE,QAEnCtvC,IAAVhF,EAoCF,OAAIykC,GAAS,QAASA,QAAmDz/B,KAAzCsgB,EAAMmf,EAAM7kC,IAAI2tB,GAAM,EAAOqmB,IACpDtuB,EAIF7W,EAAMnP,GAtCA,YAFb8B,EAAOqC,EAAQzD,MAEWslB,EAAM0f,GAAQxR,KAAKxzB,KAAWslB,EAAI,KAC1DtlB,EAAQulC,GAAUhY,EAAMjuB,EAAMgmB,GAE9BlkB,EAAO,UAII,MAATpB,GAAiBA,IAAUA,IAOlB,WAAToB,GAAsBmzC,IACxBv0C,GAASslB,GAAOA,EAAI,KAAO9M,EAAOwtB,UAAUsO,GAAY,GAAK,OAI1D/nB,EAAQilB,iBAA6B,KAAVxxC,GAA+C,IAA/BV,EAAKsQ,QAAQ,gBAC3DnB,EAAMnP,GAAQ,WAIXmlC,GAAW,QAASA,QAAsDz/B,KAA3ChF,EAAQykC,EAAMl8B,IAAIglB,EAAMvtB,EAAO4zC,MAC7DW,EACF9lC,EAAM+lC,YAAYl1C,EAAMU,GAExByO,EAAMnP,GAAQU,MAatBslC,IAAK,SAAa/X,EAAMjuB,EAAMs0C,EAAOF,GACnC,IAAInvB,EACAG,EACA+f,EACA6P,EAAW9Q,EAAUlkC,GA2BzB,OA1BmBwzC,GAAYjvB,KAAKvkB,KAKlCA,EAAOkzC,GAAc8B,KAIvB7P,EAAQjsB,EAAO47B,SAAS90C,IAASkZ,EAAO47B,SAASE,KAEpC,QAAS7P,IACpBlgB,EAAMkgB,EAAM7kC,IAAI2tB,GAAM,EAAMqmB,SAIlB5uC,IAARuf,IACFA,EAAMyrB,GAAOziB,EAAMjuB,EAAMo0C,IAIf,WAARnvB,GAAoBjlB,KAAQ2zC,KAC9B1uB,EAAM0uB,GAAmB3zC,IAIb,KAAVs0C,GAAgBA,GAClBlvB,EAAMhQ,WAAW6P,IACA,IAAVqvB,GAAkBa,SAAS/vB,GAAOA,GAAO,EAAIH,GAG/CA,KAGX/L,EAAO8U,KAAK,CAAC,SAAU,UAAU,SAAU9kB,EAAI+qC,GAC7C/6B,EAAO47B,SAASb,GAAa,CAC3B3zC,IAAK,SAAa2tB,EAAM0iB,EAAU2D,GAChC,GAAI3D,EAGF,OAAO4C,GAAahvB,KAAKrL,EAAO8sB,IAAI/X,EAAM,aAMzCA,EAAK0mB,iBAAiB/vC,QAAWqpB,EAAKmnB,wBAAwBzoC,MAE1D6nC,GAAiBvmB,EAAMgmB,EAAWK,GAFiC/D,GAAKtiB,EAAMwlB,IAAS,WAC1F,OAAOe,GAAiBvmB,EAAMgmB,EAAWK,OAI/CrrC,IAAK,SAAaglB,EAAMvtB,EAAO4zC,GAC7B,IAAIn8B,EACAi8B,EAAShE,GAAUniB,GAGvBonB,GAAsBpoB,EAAQqlB,iBAAuC,aAApB8B,EAAOvC,SAGpDsC,GADckB,GAAsBf,IAC8C,eAAjDp7B,EAAO8sB,IAAI/X,EAAM,aAAa,EAAOmmB,GACtEL,EAAWO,EAAQN,GAAmB/lB,EAAMgmB,EAAWK,EAAOH,EAAaC,GAAU,EAazF,OAVID,GAAekB,IACjBtB,GAAYviC,KAAK+V,KAAK0G,EAAK,SAAWgmB,EAAU,GAAG71B,cAAgB61B,EAAU/lC,MAAM,IAAMkH,WAAWg/B,EAAOH,IAAcD,GAAmB/lB,EAAMgmB,EAAW,UAAU,EAAOG,GAAU,KAItLL,IAAa57B,EAAUutB,GAAQxR,KAAKxzB,KAAoC,QAAxByX,EAAQ,IAAM,QAChE8V,EAAK9e,MAAM8kC,GAAavzC,EACxBA,EAAQwY,EAAO8sB,IAAI/X,EAAMgmB,IAGpBH,GAAkB7lB,EAAMvtB,EAAOqzC,QAI5C76B,EAAO47B,SAAShkC,WAAakgC,GAAa/jB,EAAQolB,oBAAoB,SAAUpkB,EAAM0iB,GACpF,GAAIA,EACF,OAAQv7B,WAAWs7B,GAAOziB,EAAM,gBAAkBA,EAAKmnB,wBAAwBE,KAAO/E,GAAKtiB,EAAM,CAC/Fnd,WAAY,IACX,WACD,OAAOmd,EAAKmnB,wBAAwBE,SAChC,QAIVp8B,EAAO8U,KAAK,CACVunB,OAAQ,GACRC,QAAS,GACTC,OAAQ,UACP,SAAUC,EAAQC,GACnBz8B,EAAO47B,SAASY,EAASC,GAAU,CACjCC,OAAQ,SAAgBl1C,GAMtB,IALA,IAAIjB,EAAI,EACJo2C,EAAW,GAEfC,EAAyB,kBAAVp1C,EAAqBA,EAAMsP,MAAM,KAAO,CAACtP,GAEjDjB,EAAI,EAAGA,IACZo2C,EAASH,EAAS/P,GAAUlmC,GAAKk2C,GAAUG,EAAMr2C,IAAMq2C,EAAMr2C,EAAI,IAAMq2C,EAAM,GAG/E,OAAOD,IAII,WAAXH,IACFx8B,EAAO47B,SAASY,EAASC,GAAQ1sC,IAAM6qC,OAG3C56B,EAAO6J,GAAG0L,OAAO,CACfuX,IAAK,SAAahmC,EAAMU,GACtB,OAAO+iC,EAAOp8B,MAAM,SAAU4mB,EAAMjuB,EAAMU,GACxC,IAAI0zC,EACAvjC,EACAoP,EAAM,GACNxgB,EAAI,EAER,GAAI8G,MAAMD,QAAQtG,GAAO,CAIvB,IAHAo0C,EAAShE,GAAUniB,GACnBpd,EAAM7Q,EAAK4E,OAEJnF,EAAIoR,EAAKpR,IACdwgB,EAAIjgB,EAAKP,IAAMyZ,EAAO8sB,IAAI/X,EAAMjuB,EAAKP,IAAI,EAAO20C,GAGlD,OAAOn0B,EAGT,YAAiBva,IAAVhF,EAAsBwY,EAAO/J,MAAM8e,EAAMjuB,EAAMU,GAASwY,EAAO8sB,IAAI/X,EAAMjuB,KAC/EA,EAAMU,EAAO0E,UAAUR,OAAS,MAQvCsU,EAAO07B,MAAQA,GACfA,GAAMvzC,UAAY,CAChBO,YAAagzC,GACbnnB,KAAM,SAAcQ,EAAM9mB,EAASJ,EAAMwK,EAAKsjC,EAAQpO,GACpDp/B,KAAK4mB,KAAOA,EACZ5mB,KAAKN,KAAOA,EACZM,KAAKwtC,OAASA,GAAU37B,EAAO27B,OAAO9M,SACtC1gC,KAAKF,QAAUA,EACfE,KAAKiK,MAAQjK,KAAKgC,IAAMhC,KAAK8tB,MAC7B9tB,KAAKkK,IAAMA,EACXlK,KAAKo/B,KAAOA,IAASvtB,EAAOwtB,UAAU3/B,GAAQ,GAAK,OAErDouB,IAAK,WACH,IAAIgQ,EAAQyP,GAAMmB,UAAU1uC,KAAKN,MACjC,OAAOo+B,GAASA,EAAM7kC,IAAM6kC,EAAM7kC,IAAI+G,MAAQutC,GAAMmB,UAAUhO,SAASznC,IAAI+G,OAE7E2uC,IAAK,SAAaC,GAChB,IAAIC,EACA/Q,EAAQyP,GAAMmB,UAAU1uC,KAAKN,MAoBjC,OAlBIM,KAAKF,QAAQsI,SACfpI,KAAK8uC,IAAMD,EAAQh9B,EAAO27B,OAAOxtC,KAAKwtC,QAAQoB,EAAS5uC,KAAKF,QAAQsI,SAAWwmC,EAAS,EAAG,EAAG5uC,KAAKF,QAAQsI,UAE3GpI,KAAK8uC,IAAMD,EAAQD,EAGrB5uC,KAAKgC,KAAOhC,KAAKkK,IAAMlK,KAAKiK,OAAS4kC,EAAQ7uC,KAAKiK,MAE9CjK,KAAKF,QAAQwM,MACftM,KAAKF,QAAQwM,KAAK/T,KAAKyH,KAAK4mB,KAAM5mB,KAAKgC,IAAKhC,MAG1C89B,GAASA,EAAMl8B,IACjBk8B,EAAMl8B,IAAI5B,MAEVutC,GAAMmB,UAAUhO,SAAS9+B,IAAI5B,MAGxBA,OAGXutC,GAAMvzC,UAAUosB,KAAKpsB,UAAYuzC,GAAMvzC,UACvCuzC,GAAMmB,UAAY,CAChBhO,SAAU,CACRznC,IAAK,SAAa6lC,GAChB,IAAIv8B,EAGJ,OAA4B,IAAxBu8B,EAAMlY,KAAKljB,UAA4C,MAA1Bo7B,EAAMlY,KAAKkY,EAAMp/B,OAAiD,MAAhCo/B,EAAMlY,KAAK9e,MAAMg3B,EAAMp/B,MACjFo/B,EAAMlY,KAAKkY,EAAMp/B,OAO1B6C,EAASsP,EAAO8sB,IAAIG,EAAMlY,KAAMkY,EAAMp/B,KAAM,MAEf,SAAX6C,EAAwBA,EAAJ,GAExCX,IAAK,SAAak9B,GAIZjtB,EAAOk9B,GAAGziC,KAAKwyB,EAAMp/B,MACvBmS,EAAOk9B,GAAGziC,KAAKwyB,EAAMp/B,MAAMo/B,GACM,IAAxBA,EAAMlY,KAAKljB,WAAmBmO,EAAO47B,SAAS3O,EAAMp/B,OAAwD,MAA/Co/B,EAAMlY,KAAK9e,MAAM+jC,GAAc/M,EAAMp/B,OAG3Go/B,EAAMlY,KAAKkY,EAAMp/B,MAAQo/B,EAAM98B,IAF/B6P,EAAO/J,MAAMg3B,EAAMlY,KAAMkY,EAAMp/B,KAAMo/B,EAAM98B,IAAM88B,EAAMM,SAS/DmO,GAAMmB,UAAUM,UAAYzB,GAAMmB,UAAUO,WAAa,CACvDrtC,IAAK,SAAak9B,GACZA,EAAMlY,KAAKljB,UAAYo7B,EAAMlY,KAAKtjB,aACpCw7B,EAAMlY,KAAKkY,EAAMp/B,MAAQo/B,EAAM98B,OAIrC6P,EAAO27B,OAAS,CACd0B,OAAQ,SAAgBh1C,GACtB,OAAOA,GAETi1C,MAAO,SAAej1C,GACpB,MAAO,GAAMiQ,KAAKilC,IAAIl1C,EAAIiQ,KAAK0D,IAAM,GAEvC6yB,SAAU,UAEZ7uB,EAAOk9B,GAAKxB,GAAMvzC,UAAUosB,MAElB9Z,KAAO,GACjB,IAAI+iC,GACAC,GACAC,GAAW,yBACXC,GAAO,cAEX,SAASC,KACHH,MACsB,IAApBjoC,EAASqoC,QAAoB9rC,EAAO+rC,sBACtC/rC,EAAO+rC,sBAAsBF,IAE7B7rC,EAAOX,WAAWwsC,GAAU59B,EAAOk9B,GAAGrtC,UAGxCmQ,EAAOk9B,GAAGa,QAKd,SAASC,KAIP,OAHAjsC,EAAOX,YAAW,WAChBosC,QAAQhxC,KAEHgxC,GAAQptC,KAAKD,MAItB,SAAS8tC,GAAMr1C,EAAMs1C,GACnB,IAAI1J,EACAjuC,EAAI,EACJu1B,EAAQ,CACV2d,OAAQ7wC,GAMV,IAFAs1C,EAAeA,EAAe,EAAI,EAE3B33C,EAAI,EAAGA,GAAK,EAAI23C,EAErBpiB,EAAM,UADN0Y,EAAQ/H,GAAUlmC,KACQu1B,EAAM,UAAY0Y,GAAS5rC,EAOvD,OAJIs1C,IACFpiB,EAAM+f,QAAU/f,EAAMroB,MAAQ7K,GAGzBkzB,EAGT,SAASqiB,GAAY32C,EAAOqG,EAAMuwC,GAMhC,IALA,IAAInR,EACA2I,GAAcyI,GAAUC,SAASzwC,IAAS,IAAIgI,OAAOwoC,GAAUC,SAAS,MACxE9vC,EAAQ,EACR9C,EAASkqC,EAAWlqC,OAEjB8C,EAAQ9C,EAAQ8C,IACrB,GAAIy+B,EAAQ2I,EAAWpnC,GAAO9H,KAAK03C,EAAWvwC,EAAMrG,GAElD,OAAOylC,EAoOb,SAASoR,GAAUtpB,EAAMwpB,EAAYtwC,GACnC,IAAIyC,EACA8tC,EACAhwC,EAAQ,EACR9C,EAAS2yC,GAAUI,WAAW/yC,OAC9By8B,EAAWnoB,EAAO8nB,WAAWI,QAAO,kBAE/B6V,EAAKhpB,QAEVgpB,EAAO,WACT,GAAIS,EACF,OAAO,EAYT,IATA,IAAIE,EAAclB,IAASQ,KACvB/sC,EAAYqH,KAAKC,IAAI,EAAG6lC,EAAUO,UAAYP,EAAU7nC,SAAWmoC,GAInE3B,EAAU,GADP9rC,EAAYmtC,EAAU7nC,UAAY,GAErC/H,EAAQ,EACR9C,EAAS0yC,EAAUQ,OAAOlzC,OAEvB8C,EAAQ9C,EAAQ8C,IACrB4vC,EAAUQ,OAAOpwC,GAAOsuC,IAAIC,GAK9B,OAFA5U,EAASc,WAAWlU,EAAM,CAACqpB,EAAWrB,EAAS9rC,IAE3C8rC,EAAU,GAAKrxC,EACVuF,GAIJvF,GACHy8B,EAASc,WAAWlU,EAAM,CAACqpB,EAAW,EAAG,IAI3CjW,EAASe,YAAYnU,EAAM,CAACqpB,KACrB,IAELA,EAAYjW,EAASzB,QAAQ,CAC/B3R,KAAMA,EACNtpB,MAAOuU,EAAOuV,OAAO,GAAIgpB,GACzB1qC,KAAMmM,EAAOuV,QAAO,EAAM,CACxBspB,cAAe,GACflD,OAAQ37B,EAAO27B,OAAO9M,UACrB5gC,GACH6wC,mBAAoBP,EACpB90B,gBAAiBxb,EACjB0wC,UAAWnB,IAASQ,KACpBznC,SAAUtI,EAAQsI,SAClBqoC,OAAQ,GACRT,YAAa,SAAqBtwC,EAAMwK,GACtC,IAAI40B,EAAQjtB,EAAO07B,MAAM3mB,EAAMqpB,EAAUvqC,KAAMhG,EAAMwK,EAAK+lC,EAAUvqC,KAAKgrC,cAAchxC,IAASuwC,EAAUvqC,KAAK8nC,QAE/G,OADAyC,EAAUQ,OAAOnwC,KAAKw+B,GACfA,GAETvuB,KAAM,SAAcqgC,GAClB,IAAIvwC,EAAQ,EAGZ9C,EAASqzC,EAAUX,EAAUQ,OAAOlzC,OAAS,EAE7C,GAAI8yC,EACF,OAAOrwC,KAKT,IAFAqwC,GAAU,EAEHhwC,EAAQ9C,EAAQ8C,IACrB4vC,EAAUQ,OAAOpwC,GAAOsuC,IAAI,GAW9B,OAPIiC,GACF5W,EAASc,WAAWlU,EAAM,CAACqpB,EAAW,EAAG,IACzCjW,EAASe,YAAYnU,EAAM,CAACqpB,EAAWW,KAEvC5W,EAASmB,WAAWvU,EAAM,CAACqpB,EAAWW,IAGjC5wC,QAGP1C,EAAQ2yC,EAAU3yC,MAItB,KA/HF,SAAoBA,EAAOozC,GACzB,IAAIrwC,EAAO1H,EAAM60C,EAAQn0C,EAAOykC,EAEhC,IAAKz9B,KAAS/C,EAiBZ,GAfAkwC,EAASkD,EADT/3C,EAAOkkC,EAAUx8B,IAEjBhH,EAAQiE,EAAM+C,GAEVnB,MAAMD,QAAQ5F,KAChBm0C,EAASn0C,EAAM,GACfA,EAAQiE,EAAM+C,GAAShH,EAAM,IAG3BgH,IAAU1H,IACZ2E,EAAM3E,GAAQU,SACPiE,EAAM+C,KAGfy9B,EAAQjsB,EAAO47B,SAAS90C,KAEX,WAAYmlC,EAKvB,IAAKz9B,KAJLhH,EAAQykC,EAAMyQ,OAAOl1C,UACdiE,EAAM3E,GAGCU,EACNgH,KAAS/C,IACbA,EAAM+C,GAAShH,EAAMgH,GACrBqwC,EAAcrwC,GAASmtC,QAI3BkD,EAAc/3C,GAAQ60C,EA6F1BqD,CAAWvzC,EAAO2yC,EAAUvqC,KAAKgrC,eAE1BrwC,EAAQ9C,EAAQ8C,IAGrB,GAFAkC,EAAS2tC,GAAUI,WAAWjwC,GAAO9H,KAAK03C,EAAWrpB,EAAMtpB,EAAO2yC,EAAUvqC,MAO1E,OAJI3G,EAAWwD,EAAOgO,QACpBsB,EAAOksB,YAAYkS,EAAUrpB,KAAMqpB,EAAUvqC,KAAKwzB,OAAO3oB,KAAOhO,EAAOgO,KAAK3W,KAAK2I,IAG5EA,EAiBX,OAbAsP,EAAO+G,IAAItb,EAAO0yC,GAAaC,GAE3BlxC,EAAWkxC,EAAUvqC,KAAKuE,QAC5BgmC,EAAUvqC,KAAKuE,MAAM1R,KAAKquB,EAAMqpB,GAIlCA,EAAU5sB,SAAS4sB,EAAUvqC,KAAK2d,UAAUnM,KAAK+4B,EAAUvqC,KAAKwR,KAAM+4B,EAAUvqC,KAAK4Q,UAAUkiB,KAAKyX,EAAUvqC,KAAK8yB,MAAMuB,OAAOkW,EAAUvqC,KAAKq0B,QAC/IloB,EAAOk9B,GAAG+B,MAAMj/B,EAAOuV,OAAOwoB,EAAM,CAClChpB,KAAMA,EACNmqB,KAAMd,EACN/W,MAAO+W,EAAUvqC,KAAKwzB,SAEjB+W,EAGTp+B,EAAOq+B,UAAYr+B,EAAOuV,OAAO8oB,GAAW,CAC1CC,SAAU,CACR,IAAK,CAAC,SAAUzwC,EAAMrG,GACpB,IAAIylC,EAAQ9+B,KAAKgwC,YAAYtwC,EAAMrG,GAEnC,OADAulC,GAAUE,EAAMlY,KAAMlnB,EAAM2+B,GAAQxR,KAAKxzB,GAAQylC,GAC1CA,KAGXkS,QAAS,SAAiB1zC,EAAOgL,GAC3BvJ,EAAWzB,IACbgL,EAAWhL,EACXA,EAAQ,CAAC,MAETA,EAAQA,EAAMqT,MAAMonB,GAOtB,IAJA,IAAIr4B,EACAW,EAAQ,EACR9C,EAASD,EAAMC,OAEZ8C,EAAQ9C,EAAQ8C,IACrBX,EAAOpC,EAAM+C,GACb6vC,GAAUC,SAASzwC,GAAQwwC,GAAUC,SAASzwC,IAAS,GACvDwwC,GAAUC,SAASzwC,GAAM+K,QAAQnC,IAGrCgoC,WAAY,CA/Wd,SAA0B1pB,EAAMtpB,EAAOoI,GACrC,IAAIhG,EACArG,EACAwmC,EACA/B,EACAmT,EACAC,EACAC,EACA72B,EACA82B,EAAQ,UAAW9zC,GAAS,WAAYA,EACxCyzC,EAAO/wC,KACP2mC,EAAO,GACP7+B,EAAQ8e,EAAK9e,MACb4nC,EAAS9oB,EAAKljB,UAAYg7B,GAAmB9X,GAC7CyqB,EAAWjU,EAASnkC,IAAI2tB,EAAM,UA8BlC,IAAKlnB,KA5BAgG,EAAKwzB,QAGc,OAFtB4E,EAAQjsB,EAAOksB,YAAYnX,EAAM,OAEvB0qB,WACRxT,EAAMwT,SAAW,EACjBL,EAAUnT,EAAMxE,MAAM/kB,KAEtBupB,EAAMxE,MAAM/kB,KAAO,WACZupB,EAAMwT,UACTL,MAKNnT,EAAMwT,WACNP,EAAKhX,QAAO,WAEVgX,EAAKhX,QAAO,WACV+D,EAAMwT,WAEDz/B,EAAOqnB,MAAMtS,EAAM,MAAMrpB,QAC5BugC,EAAMxE,MAAM/kB,cAOPjX,EAGX,GAFAjE,EAAQiE,EAAMoC,GAEV6vC,GAASryB,KAAK7jB,GAAQ,CAIxB,UAHOiE,EAAMoC,GACbmgC,EAASA,GAAoB,WAAVxmC,EAEfA,KAAWq2C,EAAS,OAAS,QAAS,CAGxC,GAAc,SAAVr2C,IAAoBg4C,QAA+BhzC,IAAnBgzC,EAAS3xC,GAG3C,SAFAgwC,GAAS,EAMb/I,EAAKjnC,GAAQ2xC,GAAYA,EAAS3xC,IAASmS,EAAO/J,MAAM8e,EAAMlnB,GAOlE,IAFAwxC,GAAar/B,EAAOkW,cAAczqB,MAEhBuU,EAAOkW,cAAc4e,GAgEvC,IAAKjnC,KA3DD0xC,GAA2B,IAAlBxqB,EAAKljB,WAKhBgC,EAAK6rC,SAAW,CAACzpC,EAAMypC,SAAUzpC,EAAM0pC,UAAW1pC,EAAM2pC,WAIlC,OAFtBN,EAAiBE,GAAYA,EAAS/2B,WAGpC62B,EAAiB/T,EAASnkC,IAAI2tB,EAAM,YAKtB,UAFhBtM,EAAUzI,EAAO8sB,IAAI/X,EAAM,cAGrBuqB,EACF72B,EAAU62B,GAGV1R,GAAS,CAAC7Y,IAAO,GACjBuqB,EAAiBvqB,EAAK9e,MAAMwS,SAAW62B,EACvC72B,EAAUzI,EAAO8sB,IAAI/X,EAAM,WAC3B6Y,GAAS,CAAC7Y,OAKE,WAAZtM,GAAoC,iBAAZA,GAAgD,MAAlB62B,IACtB,SAA9Bt/B,EAAO8sB,IAAI/X,EAAM,WAEdsqB,IACHH,EAAK75B,MAAK,WACRpP,EAAMwS,QAAU62B,KAGI,MAAlBA,IACF72B,EAAUxS,EAAMwS,QAChB62B,EAA6B,SAAZ72B,EAAqB,GAAKA,IAI/CxS,EAAMwS,QAAU,iBAKlB5U,EAAK6rC,WACPzpC,EAAMypC,SAAW,SACjBR,EAAKhX,QAAO,WACVjyB,EAAMypC,SAAW7rC,EAAK6rC,SAAS,GAC/BzpC,EAAM0pC,UAAY9rC,EAAK6rC,SAAS,GAChCzpC,EAAM2pC,UAAY/rC,EAAK6rC,SAAS,OAKpCL,GAAY,EAECvK,EAENuK,IACCG,EACE,WAAYA,IACd3B,EAAS2B,EAAS3B,QAGpB2B,EAAWjU,EAAShB,OAAOxV,EAAM,SAAU,CACzCtM,QAAS62B,IAKTtR,IACFwR,EAAS3B,QAAUA,GAIjBA,GACFjQ,GAAS,CAAC7Y,IAAO,GAKnBmqB,EAAK75B,MAAK,WASR,IAAKxX,KANAgwC,GACHjQ,GAAS,CAAC7Y,IAGZwW,EAAS78B,OAAOqmB,EAAM,UAET+f,EACX90B,EAAO/J,MAAM8e,EAAMlnB,EAAMinC,EAAKjnC,QAMpCwxC,EAAYlB,GAAYN,EAAS2B,EAAS3xC,GAAQ,EAAGA,EAAMqxC,GAErDrxC,KAAQ2xC,IACZA,EAAS3xC,GAAQwxC,EAAUjnC,MAEvBylC,IACFwB,EAAUhnC,IAAMgnC,EAAUjnC,MAC1BinC,EAAUjnC,MAAQ,MA4LxBynC,UAAW,SAAmBppC,EAAUuC,GAClCA,EACFqlC,GAAUI,WAAW7lC,QAAQnC,GAE7B4nC,GAAUI,WAAWhwC,KAAKgI,MAKhCuJ,EAAO8/B,MAAQ,SAAUA,EAAOnE,EAAQ9xB,GACtC,IAAIk2B,EAAMD,GAA4B,WAAnB70C,EAAQ60C,GAAsB9/B,EAAOuV,OAAO,GAAIuqB,GAAS,CAC1Er7B,SAAUoF,IAAOA,GAAM8xB,GAAUzuC,EAAW4yC,IAAUA,EACtDvpC,SAAUupC,EACVnE,OAAQ9xB,GAAM8xB,GAAUA,IAAWzuC,EAAWyuC,IAAWA,GAiC3D,OA9BI37B,EAAOk9B,GAAGxjC,IACZqmC,EAAIxpC,SAAW,EAEa,kBAAjBwpC,EAAIxpC,WACTwpC,EAAIxpC,YAAYyJ,EAAOk9B,GAAG8C,OAC5BD,EAAIxpC,SAAWyJ,EAAOk9B,GAAG8C,OAAOD,EAAIxpC,UAEpCwpC,EAAIxpC,SAAWyJ,EAAOk9B,GAAG8C,OAAOnR,UAMrB,MAAbkR,EAAI1Y,QAA+B,IAAd0Y,EAAI1Y,QAC3B0Y,EAAI1Y,MAAQ,MAId0Y,EAAIzI,IAAMyI,EAAIt7B,SAEds7B,EAAIt7B,SAAW,WACTvX,EAAW6yC,EAAIzI,MACjByI,EAAIzI,IAAI5wC,KAAKyH,MAGX4xC,EAAI1Y,OACNrnB,EAAO+rB,QAAQ59B,KAAM4xC,EAAI1Y,QAItB0Y,GAGT//B,EAAO6J,GAAG0L,OAAO,CACf0qB,OAAQ,SAAgBH,EAAO7zB,EAAI0vB,EAAQllC,GAEzC,OAAOtI,KAAKgH,OAAO03B,IAAoBC,IAAI,UAAW,GAAGe,OACxDx1B,MAAM6nC,QAAQ,CACbrE,QAAS5vB,GACR6zB,EAAOnE,EAAQllC,IAEpBypC,QAAS,SAAiBryC,EAAMiyC,EAAOnE,EAAQllC,GAC7C,IAAIgxB,EAAQznB,EAAOkW,cAAcroB,GAC7BsyC,EAASngC,EAAO8/B,MAAMA,EAAOnE,EAAQllC,GACrC2pC,EAAc,WAEhB,IAAIlB,EAAOb,GAAUlwC,KAAM6R,EAAOuV,OAAO,GAAI1nB,GAAOsyC,IAEhD1Y,GAAS8D,EAASnkC,IAAI+G,KAAM,YAC9B+wC,EAAKxgC,MAAK,IAKd,OADA0hC,EAAYC,OAASD,EACd3Y,IAA0B,IAAjB0Y,EAAO9Y,MAAkBl5B,KAAK2mB,KAAKsrB,GAAejyC,KAAKk5B,MAAM8Y,EAAO9Y,MAAO+Y,IAE7F1hC,KAAM,SAAc9V,EAAMwjC,EAAY2S,GACpC,IAAIuB,EAAY,SAAmBrU,GACjC,IAAIvtB,EAAOutB,EAAMvtB,YACVutB,EAAMvtB,KACbA,EAAKqgC,IAaP,MAVoB,kBAATn2C,IACTm2C,EAAU3S,EACVA,EAAaxjC,EACbA,OAAO4D,GAGL4/B,GACFj+B,KAAKk5B,MAAMz+B,GAAQ,KAAM,IAGpBuF,KAAK2mB,MAAK,WACf,IAAIiX,GAAU,EACVv9B,EAAgB,MAAR5F,GAAgBA,EAAO,aAC/B23C,EAASvgC,EAAOugC,OAChBn9B,EAAOmoB,EAASnkC,IAAI+G,MAExB,GAAIK,EACE4U,EAAK5U,IAAU4U,EAAK5U,GAAOkQ,MAC7B4hC,EAAUl9B,EAAK5U,SAGjB,IAAKA,KAAS4U,EACRA,EAAK5U,IAAU4U,EAAK5U,GAAOkQ,MAAQi/B,GAAKtyB,KAAK7c,IAC/C8xC,EAAUl9B,EAAK5U,IAKrB,IAAKA,EAAQ+xC,EAAO70C,OAAQ8C,KACtB+xC,EAAO/xC,GAAOumB,OAAS5mB,MAAiB,MAARvF,GAAgB23C,EAAO/xC,GAAO64B,QAAUz+B,IAC1E23C,EAAO/xC,GAAO0wC,KAAKxgC,KAAKqgC,GACxBhT,GAAU,EACVwU,EAAOjrB,OAAO9mB,EAAO,KAOrBu9B,GAAYgT,GACd/+B,EAAO+rB,QAAQ59B,KAAMvF,OAI3By3C,OAAQ,SAAgBz3C,GAKtB,OAJa,IAATA,IACFA,EAAOA,GAAQ,MAGVuF,KAAK2mB,MAAK,WACf,IAAItmB,EACA4U,EAAOmoB,EAASnkC,IAAI+G,MACpBk5B,EAAQjkB,EAAKxa,EAAO,SACpBqjC,EAAQ7oB,EAAKxa,EAAO,cACpB23C,EAASvgC,EAAOugC,OAChB70C,EAAS27B,EAAQA,EAAM37B,OAAS,EAWpC,IATA0X,EAAKi9B,QAAS,EAEdrgC,EAAOqnB,MAAMl5B,KAAMvF,EAAM,IAErBqjC,GAASA,EAAMvtB,MACjButB,EAAMvtB,KAAKhY,KAAKyH,MAAM,GAInBK,EAAQ+xC,EAAO70C,OAAQ8C,KACtB+xC,EAAO/xC,GAAOumB,OAAS5mB,MAAQoyC,EAAO/xC,GAAO64B,QAAUz+B,IACzD23C,EAAO/xC,GAAO0wC,KAAKxgC,MAAK,GACxB6hC,EAAOjrB,OAAO9mB,EAAO,IAKzB,IAAKA,EAAQ,EAAGA,EAAQ9C,EAAQ8C,IAC1B64B,EAAM74B,IAAU64B,EAAM74B,GAAO6xC,QAC/BhZ,EAAM74B,GAAO6xC,OAAO35C,KAAKyH,aAKtBiV,EAAKi9B,aAIlBrgC,EAAO8U,KAAK,CAAC,SAAU,OAAQ,SAAS,SAAU9kB,EAAIlJ,GACpD,IAAI05C,EAAQxgC,EAAO6J,GAAG/iB,GAEtBkZ,EAAO6J,GAAG/iB,GAAQ,SAAUg5C,EAAOnE,EAAQllC,GACzC,OAAgB,MAATqpC,GAAkC,mBAAVA,EAAsBU,EAAM1vC,MAAM3C,KAAMjC,WAAaiC,KAAK+xC,QAAQjC,GAAMn3C,GAAM,GAAOg5C,EAAOnE,EAAQllC,OAIvIuJ,EAAO8U,KAAK,CACV2rB,UAAWxC,GAAM,QACjByC,QAASzC,GAAM,QACf0C,YAAa1C,GAAM,UACnB2C,OAAQ,CACN/E,QAAS,QAEXgF,QAAS,CACPhF,QAAS,QAEXiF,WAAY,CACVjF,QAAS,YAEV,SAAU/0C,EAAM2E,GACjBuU,EAAO6J,GAAG/iB,GAAQ,SAAUg5C,EAAOnE,EAAQllC,GACzC,OAAOtI,KAAK+xC,QAAQz0C,EAAOq0C,EAAOnE,EAAQllC,OAG9CuJ,EAAOugC,OAAS,GAEhBvgC,EAAOk9B,GAAGa,KAAO,WACf,IAAIkB,EACA14C,EAAI,EACJg6C,EAASvgC,EAAOugC,OAGpB,IAFA/C,GAAQptC,KAAKD,MAEN5J,EAAIg6C,EAAO70C,OAAQnF,KACxB04C,EAAQsB,EAAOh6C,OAECg6C,EAAOh6C,KAAO04C,GAC5BsB,EAAOjrB,OAAO/uB,IAAK,GAIlBg6C,EAAO70C,QACVsU,EAAOk9B,GAAGx+B,OAGZ8+B,QAAQhxC,GAGVwT,EAAOk9B,GAAG+B,MAAQ,SAAUA,GAC1Bj/B,EAAOugC,OAAO9xC,KAAKwwC,GACnBj/B,EAAOk9B,GAAG9kC,SAGZ4H,EAAOk9B,GAAGrtC,SAAW,GAErBmQ,EAAOk9B,GAAG9kC,MAAQ,WACZqlC,KAIJA,IAAa,EACbG,OAGF59B,EAAOk9B,GAAGx+B,KAAO,WACf++B,GAAa,MAGfz9B,EAAOk9B,GAAG8C,OAAS,CACjBe,KAAM,IACNC,KAAM,IAENnS,SAAU,KAIZ7uB,EAAO6J,GAAGo3B,MAAQ,SAAUtiC,EAAM/V,GAGhC,OAFA+V,EAAOqB,EAAOk9B,IAAKl9B,EAAOk9B,GAAG8C,OAAOrhC,IAAgBA,EACpD/V,EAAOA,GAAQ,KACRuF,KAAKk5B,MAAMz+B,GAAM,SAAU2xB,EAAM0R,GACtC,IAAIz7B,EAAUuB,EAAOX,WAAWmpB,EAAM5b,GAEtCstB,EAAMvtB,KAAO,WACX3M,EAAOb,aAAaV,QAK1B,WACE,IAAIgS,EAAQhN,EAASsQ,cAAc,SAE/Bi6B,EADSvqC,EAASsQ,cAAc,UACnB5M,YAAY1D,EAASsQ,cAAc,WACpDtD,EAAM5Z,KAAO,WAGbmrB,EAAQmtB,QAA0B,KAAhB1+B,EAAMhb,MAGxBusB,EAAQotB,YAAcpB,EAAIl5B,UAG1BrE,EAAQhN,EAASsQ,cAAc,UACzBte,MAAQ,IACdgb,EAAM5Z,KAAO,QACbmrB,EAAQqtB,WAA6B,MAAhB5+B,EAAMhb,MAhB7B,GAmBA,IAAI65C,GACAtlB,GAAa/b,EAAOme,KAAKpC,WAC7B/b,EAAO6J,GAAG0L,OAAO,CACf6I,KAAM,SAAct3B,EAAMU,GACxB,OAAO+iC,EAAOp8B,KAAM6R,EAAOoe,KAAMt3B,EAAMU,EAAO0E,UAAUR,OAAS,IAEnE41C,WAAY,SAAoBx6C,GAC9B,OAAOqH,KAAK2mB,MAAK,WACf9U,EAAOshC,WAAWnzC,KAAMrH,SAI9BkZ,EAAOuV,OAAO,CACZ6I,KAAM,SAAcrJ,EAAMjuB,EAAMU,GAC9B,IAAIslB,EACAmf,EACAsV,EAAQxsB,EAAKljB,SAEjB,GAAc,IAAV0vC,GAAyB,IAAVA,GAAyB,IAAVA,EAKlC,MAAiC,qBAAtBxsB,EAAKtX,aACPuC,EAAOnS,KAAKknB,EAAMjuB,EAAMU,IAKnB,IAAV+5C,GAAgBvhC,EAAOqkB,SAAStP,KAClCkX,EAAQjsB,EAAOwhC,UAAU16C,EAAK6vB,iBAAmB3W,EAAOme,KAAKrf,MAAM2iC,KAAKp2B,KAAKvkB,GAAQu6C,QAAW70C,SAGpFA,IAAVhF,EACY,OAAVA,OACFwY,EAAOshC,WAAWvsB,EAAMjuB,GAItBmlC,GAAS,QAASA,QAAkDz/B,KAAxCsgB,EAAMmf,EAAMl8B,IAAIglB,EAAMvtB,EAAOV,IACpDgmB,GAGTiI,EAAKvX,aAAa1W,EAAMU,EAAQ,IACzBA,GAGLykC,GAAS,QAASA,GAA2C,QAAjCnf,EAAMmf,EAAM7kC,IAAI2tB,EAAMjuB,IAC7CgmB,EAKK,OAFdA,EAAM9M,EAAOC,KAAKme,KAAKrJ,EAAMjuB,SAER0F,EAAYsgB,IAEnC00B,UAAW,CACT54C,KAAM,CACJmH,IAAK,SAAaglB,EAAMvtB,GACtB,IAAKusB,EAAQqtB,YAAwB,UAAV55C,GAAqB6yB,EAAStF,EAAM,SAAU,CACvE,IAAIhJ,EAAMgJ,EAAKvtB,MAOf,OANAutB,EAAKvX,aAAa,OAAQhW,GAEtBukB,IACFgJ,EAAKvtB,MAAQukB,GAGRvkB,MAKf85C,WAAY,SAAoBvsB,EAAMvtB,GACpC,IAAIV,EACAP,EAAI,EAGRm7C,EAAYl6C,GAASA,EAAMsX,MAAMonB,GAEjC,GAAIwb,GAA+B,IAAlB3sB,EAAKljB,SACpB,KAAO/K,EAAO46C,EAAUn7C,MACtBwuB,EAAKrX,gBAAgB5W,MAM7Bu6C,GAAW,CACTtxC,IAAK,SAAaglB,EAAMvtB,EAAOV,GAQ7B,OAPc,IAAVU,EAEFwY,EAAOshC,WAAWvsB,EAAMjuB,GAExBiuB,EAAKvX,aAAa1W,EAAMA,GAGnBA,IAGXkZ,EAAO8U,KAAK9U,EAAOme,KAAKrf,MAAM2iC,KAAKt1C,OAAO2S,MAAM,SAAS,SAAU9O,EAAIlJ,GACrE,IAAIC,EAASg1B,GAAWj1B,IAASkZ,EAAOC,KAAKme,KAE7CrC,GAAWj1B,GAAQ,SAAUiuB,EAAMjuB,EAAMiwB,GACvC,IAAIjK,EACA0kB,EACAmQ,EAAgB76C,EAAK6vB,cAUzB,OARKI,IAEHya,EAASzV,GAAW4lB,GACpB5lB,GAAW4lB,GAAiB70B,EAC5BA,EAAmC,MAA7B/lB,EAAOguB,EAAMjuB,EAAMiwB,GAAiB4qB,EAAgB,KAC1D5lB,GAAW4lB,GAAiBnQ,GAGvB1kB,MAGX,IAAI80B,GAAa,sCACbC,GAAa,gBA4GjB,SAASC,GAAiBt6C,GAExB,OADaA,EAAMsX,MAAMonB,IAAkB,IAC7BnvB,KAAK,KAGrB,SAASgrC,GAAShtB,GAChB,OAAOA,EAAKtX,cAAgBsX,EAAKtX,aAAa,UAAY,GAG5D,SAASukC,GAAex6C,GACtB,OAAI6F,MAAMD,QAAQ5F,GACTA,EAGY,kBAAVA,GACFA,EAAMsX,MAAMonB,IAGd,GA7HTlmB,EAAO6J,GAAG0L,OAAO,CACf1nB,KAAM,SAAc/G,EAAMU,GACxB,OAAO+iC,EAAOp8B,KAAM6R,EAAOnS,KAAM/G,EAAMU,EAAO0E,UAAUR,OAAS,IAEnEu2C,WAAY,SAAoBn7C,GAC9B,OAAOqH,KAAK2mB,MAAK,kBACR3mB,KAAK6R,EAAOkiC,QAAQp7C,IAASA,SAI1CkZ,EAAOuV,OAAO,CACZ1nB,KAAM,SAAcknB,EAAMjuB,EAAMU,GAC9B,IAAIslB,EACAmf,EACAsV,EAAQxsB,EAAKljB,SAEjB,GAAc,IAAV0vC,GAAyB,IAAVA,GAAyB,IAAVA,EAUlC,OANc,IAAVA,GAAgBvhC,EAAOqkB,SAAStP,KAElCjuB,EAAOkZ,EAAOkiC,QAAQp7C,IAASA,EAC/BmlC,EAAQjsB,EAAO68B,UAAU/1C,SAGb0F,IAAVhF,EACEykC,GAAS,QAASA,QAAkDz/B,KAAxCsgB,EAAMmf,EAAMl8B,IAAIglB,EAAMvtB,EAAOV,IACpDgmB,EAGFiI,EAAKjuB,GAAQU,EAGlBykC,GAAS,QAASA,GAA2C,QAAjCnf,EAAMmf,EAAM7kC,IAAI2tB,EAAMjuB,IAC7CgmB,EAGFiI,EAAKjuB,IAEd+1C,UAAW,CACTlc,SAAU,CACRv5B,IAAK,SAAa2tB,GAMhB,IAAIotB,EAAWniC,EAAOC,KAAKme,KAAKrJ,EAAM,YAEtC,OAAIotB,EACKp1C,SAASo1C,EAAU,IAGxBP,GAAWv2B,KAAK0J,EAAKsF,WAAawnB,GAAWx2B,KAAK0J,EAAKsF,WAAatF,EAAK9P,KACpE,GAGD,KAIdi9B,QAAS,CACP,IAAO,UACP,MAAS,eAWRnuB,EAAQotB,cACXnhC,EAAO68B,UAAUh2B,SAAW,CAC1Bzf,IAAK,SAAa2tB,GAEhB,IAAItoB,EAASsoB,EAAKtjB,WAMlB,OAJIhF,GAAUA,EAAOgF,YACnBhF,EAAOgF,WAAWmvB,cAGb,MAET7wB,IAAK,SAAaglB,GAEhB,IAAItoB,EAASsoB,EAAKtjB,WAEdhF,IACFA,EAAOm0B,cAEHn0B,EAAOgF,YACThF,EAAOgF,WAAWmvB,kBAO5B5gB,EAAO8U,KAAK,CAAC,WAAY,WAAY,YAAa,cAAe,cAAe,UAAW,UAAW,SAAU,cAAe,oBAAoB,WACjJ9U,EAAOkiC,QAAQ/zC,KAAKwoB,eAAiBxoB,QAyBvC6R,EAAO6J,GAAG0L,OAAO,CACfve,SAAU,SAAkBxP,GAC1B,IAAI0C,EACA6qB,EACAkH,EACAmmB,EACAC,EACAp3B,EACAq3B,EACA/7C,EAAI,EAER,GAAI2G,EAAW1F,GACb,OAAO2G,KAAK2mB,MAAK,SAAU7J,GACzBjL,EAAO7R,MAAM6I,SAASxP,EAAMd,KAAKyH,KAAM8c,EAAG82B,GAAS5zC,WAMvD,IAFAjE,EAAU83C,GAAex6C,IAEbkE,OACV,KAAOqpB,EAAO5mB,KAAK5H,MAIjB,GAHA67C,EAAWL,GAAShtB,GACpBkH,EAAwB,IAAlBlH,EAAKljB,UAAkB,IAAMiwC,GAAiBM,GAAY,IAEvD,CAGP,IAFAn3B,EAAI,EAEGo3B,EAAQn4C,EAAQ+gB,MACjBgR,EAAI7kB,QAAQ,IAAMirC,EAAQ,KAAO,IACnCpmB,GAAOomB,EAAQ,KAOfD,KAFJE,EAAaR,GAAiB7lB,KAG5BlH,EAAKvX,aAAa,QAAS8kC,GAMnC,OAAOn0C,MAET+I,YAAa,SAAqB1P,GAChC,IAAI0C,EACA6qB,EACAkH,EACAmmB,EACAC,EACAp3B,EACAq3B,EACA/7C,EAAI,EAER,GAAI2G,EAAW1F,GACb,OAAO2G,KAAK2mB,MAAK,SAAU7J,GACzBjL,EAAO7R,MAAM+I,YAAY1P,EAAMd,KAAKyH,KAAM8c,EAAG82B,GAAS5zC,WAI1D,IAAKjC,UAAUR,OACb,OAAOyC,KAAKiwB,KAAK,QAAS,IAK5B,IAFAl0B,EAAU83C,GAAex6C,IAEbkE,OACV,KAAOqpB,EAAO5mB,KAAK5H,MAKjB,GAJA67C,EAAWL,GAAShtB,GAEpBkH,EAAwB,IAAlBlH,EAAKljB,UAAkB,IAAMiwC,GAAiBM,GAAY,IAEvD,CAGP,IAFAn3B,EAAI,EAEGo3B,EAAQn4C,EAAQ+gB,MAErB,KAAOgR,EAAI7kB,QAAQ,IAAMirC,EAAQ,MAAQ,GACvCpmB,EAAMA,EAAIhW,QAAQ,IAAMo8B,EAAQ,IAAK,KAOrCD,KAFJE,EAAaR,GAAiB7lB,KAG5BlH,EAAKvX,aAAa,QAAS8kC,GAMnC,OAAOn0C,MAETo0C,YAAa,SAAqB/6C,EAAOg7C,GACvC,IAAI55C,EAAOqC,EAAQzD,GACfi7C,EAAwB,WAAT75C,GAAqByE,MAAMD,QAAQ5F,GAEtD,MAAwB,mBAAbg7C,GAA0BC,EAC5BD,EAAWr0C,KAAK6I,SAASxP,GAAS2G,KAAK+I,YAAY1P,GAGxD0F,EAAW1F,GACN2G,KAAK2mB,MAAK,SAAUvuB,GACzByZ,EAAO7R,MAAMo0C,YAAY/6C,EAAMd,KAAKyH,KAAM5H,EAAGw7C,GAAS5zC,MAAOq0C,GAAWA,MAIrEr0C,KAAK2mB,MAAK,WACf,IAAIqI,EAAW52B,EAAGqG,EAAM81C,EAExB,GAAID,EAMF,IAJAl8C,EAAI,EACJqG,EAAOoT,EAAO7R,MACdu0C,EAAaV,GAAex6C,GAErB21B,EAAYulB,EAAWn8C,MAExBqG,EAAK+1C,SAASxlB,GAChBvwB,EAAKsK,YAAYimB,GAEjBvwB,EAAKoK,SAASmmB,aAIC3wB,IAAVhF,GAAgC,YAAToB,KAChCu0B,EAAY4kB,GAAS5zC,QAInBo9B,EAASx7B,IAAI5B,KAAM,gBAAiBgvB,GAOlChvB,KAAKqP,cACPrP,KAAKqP,aAAa,QAAS2f,IAAuB,IAAV31B,EAAkB,GAAK+jC,EAASnkC,IAAI+G,KAAM,kBAAoB,SAK9Gw0C,SAAU,SAAkB3zC,GAC1B,IAAImuB,EACApI,EACAxuB,EAAI,EAGR,IAFA42B,EAAY,IAAMnuB,EAAW,IAEtB+lB,EAAO5mB,KAAK5H,MACjB,GAAsB,IAAlBwuB,EAAKljB,WAAmB,IAAMiwC,GAAiBC,GAAShtB,IAAS,KAAK3d,QAAQ+lB,IAAc,EAC9F,OAAO,EAIX,OAAO,KAGX,IAAIylB,GAAU,MACd5iC,EAAO6J,GAAG0L,OAAO,CACfxJ,IAAK,SAAavkB,GAChB,IAAIykC,EACAnf,EACAipB,EACAhhB,EAAO5mB,KAAK,GAEhB,OAAKjC,UAAUR,QAqBfqqC,EAAkB7oC,EAAW1F,GACtB2G,KAAK2mB,MAAK,SAAUvuB,GACzB,IAAIwlB,EAEkB,IAAlB5d,KAAK0D,WAWE,OANTka,EADEgqB,EACIvuC,EAAMd,KAAKyH,KAAM5H,EAAGyZ,EAAO7R,MAAM4d,OAEjCvkB,GAKNukB,EAAM,GACkB,kBAARA,EAChBA,GAAO,GACE1e,MAAMD,QAAQ2e,KACvBA,EAAM/L,EAAO+G,IAAIgF,GAAK,SAAUvkB,GAC9B,OAAgB,MAATA,EAAgB,GAAKA,EAAQ,QAIxCykC,EAAQjsB,EAAO6iC,SAAS10C,KAAKvF,OAASoX,EAAO6iC,SAAS10C,KAAKksB,SAAS1D,iBAEpD,QAASsV,QAA4Cz/B,IAAlCy/B,EAAMl8B,IAAI5B,KAAM4d,EAAK,WACtD5d,KAAK3G,MAAQukB,QAhDXgJ,GACFkX,EAAQjsB,EAAO6iC,SAAS9tB,EAAKnsB,OAASoX,EAAO6iC,SAAS9tB,EAAKsF,SAAS1D,iBAEvD,QAASsV,QAA8Cz/B,KAApCsgB,EAAMmf,EAAM7kC,IAAI2tB,EAAM,UAC7CjI,EAKU,kBAFnBA,EAAMiI,EAAKvtB,OAGFslB,EAAI7G,QAAQ28B,GAAS,IAIhB,MAAP91B,EAAc,GAAKA,OAG5B,KAoCN9M,EAAOuV,OAAO,CACZstB,SAAU,CACRj8B,OAAQ,CACNxf,IAAK,SAAa2tB,GAChB,IAAIhJ,EAAM/L,EAAOC,KAAKme,KAAKrJ,EAAM,SACjC,OAAc,MAAPhJ,EAAcA,EAIrB+1B,GAAiB9hC,EAAO8D,KAAKiR,MAGjCmC,OAAQ,CACN9vB,IAAK,SAAa2tB,GAChB,IAAIvtB,EACAof,EACArgB,EACA0H,EAAU8mB,EAAK9mB,QACfO,EAAQumB,EAAK6L,cACb6P,EAAoB,eAAd1b,EAAKnsB,KACXklC,EAAS2C,EAAM,KAAO,GACtBl4B,EAAMk4B,EAAMjiC,EAAQ,EAAIP,EAAQvC,OASpC,IANEnF,EADEiI,EAAQ,EACN+J,EAEAk4B,EAAMjiC,EAAQ,EAIbjI,EAAIgS,EAAKhS,IAId,KAHAqgB,EAAS3Y,EAAQ1H,IAGLsgB,UAAYtgB,IAAMiI,KAC7BoY,EAAOxX,YAAcwX,EAAOnV,WAAWrC,WAAairB,EAASzT,EAAOnV,WAAY,aAAc,CAI7F,GAFAjK,EAAQwY,EAAO4G,GAAQmF,MAEnB0kB,EACF,OAAOjpC,EAITsmC,EAAOr/B,KAAKjH,GAIhB,OAAOsmC,GAET/9B,IAAK,SAAaglB,EAAMvtB,GAOtB,IANA,IAAIs7C,EACAl8B,EACA3Y,EAAU8mB,EAAK9mB,QACf6/B,EAAS9tB,EAAOoW,UAAU5uB,GAC1BjB,EAAI0H,EAAQvC,OAETnF,OACLqgB,EAAS3Y,EAAQ1H,IAGNsgB,SAAW7G,EAAOsW,QAAQtW,EAAO6iC,SAASj8B,OAAOxf,IAAIwf,GAASknB,IAAW,KAClFgV,GAAY,GAWhB,OAJKA,IACH/tB,EAAK6L,eAAiB,GAGjBkN,OAMf9tB,EAAO8U,KAAK,CAAC,QAAS,aAAa,WACjC9U,EAAO6iC,SAAS10C,MAAQ,CACtB4B,IAAK,SAAaglB,EAAMvtB,GACtB,GAAI6F,MAAMD,QAAQ5F,GAChB,OAAOutB,EAAKjO,QAAU9G,EAAOsW,QAAQtW,EAAO+U,GAAMhJ,MAAOvkB,IAAU,IAKpEusB,EAAQmtB,UACXlhC,EAAO6iC,SAAS10C,MAAM/G,IAAM,SAAU2tB,GACpC,OAAsC,OAA/BA,EAAKtX,aAAa,SAAoB,KAAOsX,EAAKvtB,WAK/DusB,EAAQgvB,QAAU,cAAehxC,EAEjC,IAAIixC,GAAc,kCACdC,GAA0B,SAAiCnvC,GAC7DA,EAAEmI,mBAGJ+D,EAAOuV,OAAOvV,EAAO3R,MAAO,CAC1B2iC,QAAS,SAAiB3iC,EAAO+U,EAAM2R,EAAMmuB,GAC3C,IAAI38C,EACA01B,EACAvR,EACAy4B,EACAC,EACA5R,EACA1I,EACAua,EACAC,EAAY,CAACvuB,GAAQvf,GACrB5M,EAAOgrB,EAAOltB,KAAK2H,EAAO,QAAUA,EAAMzF,KAAOyF,EACjDgjC,EAAazd,EAAOltB,KAAK2H,EAAO,aAAeA,EAAMsuB,UAAU7lB,MAAM,KAAO,GAGhF,GAFAmlB,EAAMonB,EAAc34B,EAAMqK,EAAOA,GAAQvf,EAEnB,IAAlBuf,EAAKljB,UAAoC,IAAlBkjB,EAAKljB,WAK5BmxC,GAAY33B,KAAKziB,EAAOoX,EAAO3R,MAAMojC,aAIrC7oC,EAAKwO,QAAQ,MAAQ,IAEvBi6B,EAAazoC,EAAKkO,MAAM,KACxBlO,EAAOyoC,EAAWlf,QAClBkf,EAAW98B,QAGb6uC,EAASx6C,EAAKwO,QAAQ,KAAO,GAAK,KAAOxO,GAEzCyF,EAAQA,EAAM2R,EAAO4V,SAAWvnB,EAAQ,IAAI2R,EAAOkD,MAAMta,EAAyB,WAAnBqC,EAAQoD,IAAuBA,IAExFyiC,UAAYoS,EAAe,EAAI,EACrC70C,EAAMsuB,UAAY0U,EAAWt6B,KAAK,KAClC1I,EAAMmkC,WAAankC,EAAMsuB,UAAY,IAAIhE,OAAO,UAAY0Y,EAAWt6B,KAAK,iBAAmB,WAAa,KAE5G1I,EAAMqC,YAASlE,EAEV6B,EAAM7C,SACT6C,EAAM7C,OAASupB,GAIjB3R,EAAe,MAARA,EAAe,CAAC/U,GAAS2R,EAAOoW,UAAUhT,EAAM,CAAC/U,IAExDy6B,EAAU9oB,EAAO3R,MAAMy6B,QAAQlgC,IAAS,GAEnCs6C,IAAgBpa,EAAQkI,UAAiD,IAAtClI,EAAQkI,QAAQlgC,MAAMikB,EAAM3R,IAApE,CAMA,IAAK8/B,IAAiBpa,EAAQmK,WAAajf,EAASe,GAAO,CAOzD,IANAouB,EAAara,EAAQiI,cAAgBnoC,EAEhCo6C,GAAY33B,KAAK83B,EAAav6C,KACjCqzB,EAAMA,EAAIxqB,YAGLwqB,EAAKA,EAAMA,EAAIxqB,WACpB6xC,EAAU70C,KAAKwtB,GACfvR,EAAMuR,EAIJvR,KAASqK,EAAKgG,eAAiBvlB,IACjC8tC,EAAU70C,KAAKic,EAAIsS,aAAetS,EAAI64B,cAAgBxxC,GAO1D,IAFAxL,EAAI,GAEI01B,EAAMqnB,EAAU/8C,QAAU8H,EAAMikC,wBACtC+Q,EAAcpnB,EACd5tB,EAAMzF,KAAOrC,EAAI,EAAI48C,EAAara,EAAQ4I,UAAY9oC,GAEtD4oC,GAAUjG,EAASnkC,IAAI60B,EAAK,WAAah1B,OAAOY,OAAO,OAAOwG,EAAMzF,OAAS2iC,EAASnkC,IAAI60B,EAAK,YAG7FuV,EAAO1gC,MAAMmrB,EAAK7Y,IAIpBouB,EAAS4R,GAAUnnB,EAAImnB,KAET5R,EAAO1gC,OAASo6B,EAAWjP,KACvC5tB,EAAMqC,OAAS8gC,EAAO1gC,MAAMmrB,EAAK7Y,IAEZ,IAAjB/U,EAAMqC,QACRrC,EAAM0O,kBAyCZ,OApCA1O,EAAMzF,KAAOA,EAERs6C,GAAiB70C,EAAM+kC,sBACpBtK,EAAQ+F,WAA8D,IAAlD/F,EAAQ+F,SAAS/9B,MAAMwyC,EAAUnrB,MAAO/U,KAAoB8nB,EAAWnW,IAG3FquB,GAAUl2C,EAAW6nB,EAAKnsB,MAAWorB,EAASe,MAEhDrK,EAAMqK,EAAKquB,MAGTruB,EAAKquB,GAAU,MAIjBpjC,EAAO3R,MAAMojC,UAAY7oC,EAErByF,EAAMikC,wBACR+Q,EAAY/wC,iBAAiB1J,EAAMq6C,IAGrCluB,EAAKnsB,KAEDyF,EAAMikC,wBACR+Q,EAAY9wC,oBAAoB3J,EAAMq6C,IAGxCjjC,EAAO3R,MAAMojC,eAAYjlC,EAErBke,IACFqK,EAAKquB,GAAU14B,IAMhBrc,EAAMqC,SAIf8yC,SAAU,SAAkB56C,EAAMmsB,EAAM1mB,GACtC,IAAIyF,EAAIkM,EAAOuV,OAAO,IAAIvV,EAAOkD,MAAS7U,EAAO,CAC/CzF,KAAMA,EACN2qC,aAAa,IAEfvzB,EAAO3R,MAAM2iC,QAAQl9B,EAAG,KAAMihB,MAGlC/U,EAAO6J,GAAG0L,OAAO,CACfyb,QAAS,SAAiBpoC,EAAMwa,GAC9B,OAAOjV,KAAK2mB,MAAK,WACf9U,EAAO3R,MAAM2iC,QAAQpoC,EAAMwa,EAAMjV,UAGrCs1C,eAAgB,SAAwB76C,EAAMwa,GAC5C,IAAI2R,EAAO5mB,KAAK,GAEhB,GAAI4mB,EACF,OAAO/U,EAAO3R,MAAM2iC,QAAQpoC,EAAMwa,EAAM2R,GAAM,MAY/ChB,EAAQgvB,SACX/iC,EAAO8U,KAAK,CACVjC,MAAO,UACP4hB,KAAM,aACL,SAAUK,EAAM3C,GAEjB,IAAI7jC,EAAU,SAAiBD,GAC7B2R,EAAO3R,MAAMm1C,SAASrR,EAAK9jC,EAAM7C,OAAQwU,EAAO3R,MAAM8jC,IAAI9jC,KAG5D2R,EAAO3R,MAAMy6B,QAAQqJ,GAAO,CAC1BP,MAAO,WAGL,IAAIvd,EAAMlmB,KAAK4sB,eAAiB5sB,KAAKqH,UAAYrH,KAC7Cu1C,EAAWnY,EAAShB,OAAOlW,EAAK8d,GAE/BuR,GACHrvB,EAAI/hB,iBAAiBwiC,EAAMxmC,GAAS,GAGtCi9B,EAAShB,OAAOlW,EAAK8d,GAAMuR,GAAY,GAAK,IAE9C3R,SAAU,WACR,IAAI1d,EAAMlmB,KAAK4sB,eAAiB5sB,KAAKqH,UAAYrH,KAC7Cu1C,EAAWnY,EAAShB,OAAOlW,EAAK8d,GAAO,EAEtCuR,EAIHnY,EAAShB,OAAOlW,EAAK8d,EAAKuR,IAH1BrvB,EAAI9hB,oBAAoBuiC,EAAMxmC,GAAS,GACvCi9B,EAAS78B,OAAO2lB,EAAK8d,SAS/B,IAAIntB,GAAWjT,EAAOiT,SAClB9D,GAAQ,CACVwV,KAAMtmB,KAAKD,OAETwzC,GAAS,KAEb3jC,EAAO4jC,SAAW,SAAUxgC,GAC1B,IAAIY,EAAK6/B,EAET,IAAKzgC,GAAwB,kBAATA,EAClB,OAAO,KAKT,IACEY,GAAM,IAAIjS,EAAOiU,WAAYE,gBAAgB9C,EAAM,YACnD,MAAOtP,IAUT,OARA+vC,EAAkB7/B,GAAOA,EAAIkX,qBAAqB,eAAe,GAE5DlX,IAAO6/B,GACV7jC,EAAOhV,MAAM,iBAAmB64C,EAAkB7jC,EAAO+G,IAAI88B,EAAgBrpB,YAAY,SAAUroB,GACjG,OAAOA,EAAGwsB,eACT5nB,KAAK,MAAQqM,IAGXY,GAGT,IAAI8/B,GAAW,QACXC,GAAQ,SACRC,GAAkB,wCAClBC,GAAe,qCAEnB,SAASC,GAAY1H,EAAQh0C,EAAK27C,EAAaltC,GAC7C,IAAInQ,EAEJ,GAAIuG,MAAMD,QAAQ5E,GAEhBwX,EAAO8U,KAAKtsB,GAAK,SAAUjC,EAAG6/B,GACxB+d,GAAeL,GAASz4B,KAAKmxB,GAE/BvlC,EAAIulC,EAAQpW,GAGZ8d,GAAY1H,EAAS,KAAsB,WAAfvxC,EAAQm7B,IAAwB,MAALA,EAAY7/B,EAAI,IAAM,IAAK6/B,EAAG+d,EAAaltC,WAGjG,GAAKktC,GAA+B,WAAhB7vB,EAAO9rB,GAOhCyO,EAAIulC,EAAQh0C,QALZ,IAAK1B,KAAQ0B,EACX07C,GAAY1H,EAAS,IAAM11C,EAAO,IAAK0B,EAAI1B,GAAOq9C,EAAaltC,GAUrE+I,EAAOuC,MAAQ,SAAU2H,EAAGi6B,GAC1B,IAAI3H,EACAl0C,EAAI,GACJ2O,EAAM,SAAanP,EAAKs8C,GAE1B,IAAI58C,EAAQ0F,EAAWk3C,GAAmBA,IAAoBA,EAC9D97C,EAAEA,EAAEoD,QAAUsb,mBAAmBlf,GAAO,IAAMkf,mBAA4B,MAATxf,EAAgB,GAAKA,IAGxF,GAAS,MAAL0iB,EACF,MAAO,GAIT,GAAI7c,MAAMD,QAAQ8c,IAAMA,EAAEuK,SAAWzU,EAAO2V,cAAczL,GAExDlK,EAAO8U,KAAK5K,GAAG,WACbjT,EAAI9I,KAAKrH,KAAMqH,KAAK3G,eAKtB,IAAKg1C,KAAUtyB,EACbg6B,GAAY1H,EAAQtyB,EAAEsyB,GAAS2H,EAAaltC,GAKhD,OAAO3O,EAAEyO,KAAK,MAGhBiJ,EAAO6J,GAAG0L,OAAO,CACf8uB,UAAW,WACT,OAAOrkC,EAAOuC,MAAMpU,KAAKm2C,mBAE3BA,eAAgB,WACd,OAAOn2C,KAAK4Y,KAAI,WAEd,IAAI5I,EAAW6B,EAAOnS,KAAKM,KAAM,YACjC,OAAOgQ,EAAW6B,EAAOoW,UAAUjY,GAAYhQ,QAC9CgH,QAAO,WACR,IAAIvM,EAAOuF,KAAKvF,KAEhB,OAAOuF,KAAKrH,OAASkZ,EAAO7R,MAAM4E,GAAG,cAAgBkxC,GAAa54B,KAAKld,KAAKksB,YAAc2pB,GAAgB34B,KAAKziB,KAAUuF,KAAK2Y,UAAYonB,GAAe7iB,KAAKziB,OAC7Jme,KAAI,SAAU/W,EAAI+kB,GACnB,IAAIhJ,EAAM/L,EAAO7R,MAAM4d,MAEvB,OAAW,MAAPA,EACK,KAGL1e,MAAMD,QAAQ2e,GACT/L,EAAO+G,IAAIgF,GAAK,SAAUA,GAC/B,MAAO,CACLjlB,KAAMiuB,EAAKjuB,KACXU,MAAOukB,EAAI9F,QAAQ89B,GAAO,YAKzB,CACLj9C,KAAMiuB,EAAKjuB,KACXU,MAAOukB,EAAI9F,QAAQ89B,GAAO,YAE3B38C,SAGP,IAAIm9C,GAAM,OACNC,GAAQ,OACRC,GAAa,gBACbC,GAAW,6BAGXC,GAAa,iBACbC,GAAY,QAWhBnG,GAAa,GAOboG,GAAa,GAEbC,GAAW,KAAKjvC,OAAO,KAEvBuQ,GAAe5Q,EAASsQ,cAAc,KAGtC,SAASi/B,GAA4BC,GAEnC,OAAO,SAAUC,EAAoB30C,GACD,kBAAvB20C,IACT30C,EAAO20C,EACPA,EAAqB,KAGvB,IAAI9/B,EACA5e,EAAI,EACJ2+C,EAAYD,EAAmBtuB,cAAc7X,MAAMonB,IAAkB,GAEzE,GAAIh5B,EAAWoD,GAEb,KAAO6U,EAAW+/B,EAAU3+C,MAEN,MAAhB4e,EAAS,IACXA,EAAWA,EAASnQ,MAAM,IAAM,KAC/BgwC,EAAU7/B,GAAY6/B,EAAU7/B,IAAa,IAAIvM,QAAQtI,KAEzD00C,EAAU7/B,GAAY6/B,EAAU7/B,IAAa,IAAI1W,KAAK6B,IAQjE,SAAS60C,GAA8BH,EAAW/2C,EAASwb,EAAiB27B,GAC1E,IAAIC,EAAY,GACZC,EAAmBN,IAAcH,GAErC,SAASU,EAAQpgC,GACf,IAAI0B,EAaJ,OAZAw+B,EAAUlgC,IAAY,EACtBnF,EAAO8U,KAAKkwB,EAAU7/B,IAAa,IAAI,SAAU2hB,EAAG0e,GAClD,IAAIC,EAAsBD,EAAmBv3C,EAASwb,EAAiB27B,GAEvE,MAAmC,kBAAxBK,GAAqCH,GAAqBD,EAAUI,GAIpEH,IACAz+B,EAAW4+B,QADf,GAHLx3C,EAAQi3C,UAAUtsC,QAAQ6sC,GAC1BF,EAAQE,IACD,MAKJ5+B,EAGT,OAAO0+B,EAAQt3C,EAAQi3C,UAAU,MAAQG,EAAU,MAAQE,EAAQ,KAMrE,SAASG,GAAWl6C,EAAQ0oB,GAC1B,IAAIpsB,EACA4tB,EACAiwB,EAAc3lC,EAAO4lC,aAAaD,aAAe,GAErD,IAAK79C,KAAOosB,OACO1nB,IAAb0nB,EAAIpsB,MACL69C,EAAY79C,GAAO0D,EAASkqB,IAASA,EAAO,KAAK5tB,GAAOosB,EAAIpsB,IAQjE,OAJI4tB,GACF1V,EAAOuV,QAAO,EAAM/pB,EAAQkqB,GAGvBlqB,EAxET4a,GAAanB,KAAOD,GAASC,KAuO7BjF,EAAOuV,OAAO,CAEZswB,OAAQ,EAERC,aAAc,GACdC,KAAM,GACNH,aAAc,CACZ7gC,IAAKC,GAASC,KACdrc,KAAM,MACNo9C,QAzQa,4DAyQW36B,KAAKrG,GAASsB,UACtCxG,QAAQ,EACRmmC,aAAa,EACbC,OAAO,EACPC,YAAa,mDAabC,QAAS,CACP,IAAKtB,GACLhhC,KAAM,aACNC,KAAM,YACNC,IAAK,4BACLC,KAAM,qCAERwI,SAAU,CACRzI,IAAK,UACLD,KAAM,SACNE,KAAM,YAERoiC,eAAgB,CACdriC,IAAK,cACLF,KAAM,eACNG,KAAM,gBAIRqiC,WAAY,CAEV,SAAU76B,OAEV,aAAa,EAEb,YAAa7F,KAAKC,MAElB,WAAY7F,EAAO4jC,UAMrB+B,YAAa,CACX5gC,KAAK,EACLpW,SAAS,IAMb43C,UAAW,SAAmB/6C,EAAQwC,GACpC,OAAOA,EACP03C,GAAWA,GAAWl6C,EAAQwU,EAAO4lC,cAAe53C,GACpD03C,GAAW1lC,EAAO4lC,aAAcp6C,IAElCge,cAAeu7B,GAA4BtG,IAC3C+H,cAAezB,GAA4BF,IAE3C1gC,KAAM,SAAcY,EAAK9W,GAEF,WAAjBhD,EAAQ8Z,KACV9W,EAAU8W,EACVA,OAAMvY,GAMR,IAAIi6C,EAEJC,EAEAC,EACIC,EAEJC,EAEAxgC,EAEA8jB,EAEA2c,EAEAvgD,EAEAwgD,EAEAz+C,EAAI0X,EAAOumC,UAAU,GArBrBt4C,EAAUA,GAAW,IAuBrB+4C,EAAkB1+C,EAAEqG,SAAWrG,EAE/B2+C,EAAqB3+C,EAAEqG,UAAYq4C,EAAgBn1C,UAAYm1C,EAAgBvyB,QAAUzU,EAAOgnC,GAAmBhnC,EAAO3R,MAE1H85B,EAAWnoB,EAAO8nB,WACdof,EAAmBlnC,EAAO6mB,UAAU,eAExCsgB,EAAc7+C,EAAE8+C,YAAc,GAE9BC,EAAiB,GACbC,EAAsB,GAE1BC,EAAW,WAEXnC,EAAQ,CACNzgC,WAAY,EAEZL,kBAAmB,SAA2Bxc,GAC5C,IAAIgX,EAEJ,GAAIqrB,EAAW,CACb,IAAKyc,EAGH,IAFAA,EAAkB,GAEX9nC,EAAQ4lC,GAAS1pB,KAAK2rB,IAC3BC,EAAgB9nC,EAAM,GAAG6X,cAAgB,MAAQiwB,EAAgB9nC,EAAM,GAAG6X,cAAgB,MAAQ,IAAI9gB,OAAOiJ,EAAM,IAIvHA,EAAQ8nC,EAAgB9+C,EAAI6uB,cAAgB,KAG9C,OAAgB,MAAT7X,EAAgB,KAAOA,EAAM/H,KAAK,OAG3CywC,sBAAuB,WACrB,OAAOrd,EAAYwc,EAAwB,MAG7CtkC,iBAAkB,SAA0Bvb,EAAMU,GAMhD,OALiB,MAAb2iC,IACFrjC,EAAOwgD,EAAoBxgD,EAAK6vB,eAAiB2wB,EAAoBxgD,EAAK6vB,gBAAkB7vB,EAC5FugD,EAAevgD,GAAQU,GAGlB2G,MAGTs5C,iBAAkB,SAA0B7+C,GAK1C,OAJiB,MAAbuhC,IACF7hC,EAAEo/C,SAAW9+C,GAGRuF,MAGTi5C,WAAY,SAAoBrgC,GAC9B,IAAIqM,EAEJ,GAAIrM,EACF,GAAIojB,EAEFib,EAAMld,OAAOnhB,EAAIq+B,EAAMl1C,cAGvB,IAAKkjB,KAAQrM,EACXogC,EAAY/zB,GAAQ,CAAC+zB,EAAY/zB,GAAOrM,EAAIqM,IAKlD,OAAOjlB,MAGTw5C,MAAO,SAAenjC,GACpB,IAAIojC,EAAYpjC,GAAc+iC,EAO9B,OALId,GACFA,EAAUkB,MAAMC,GAGlBviC,EAAK,EAAGuiC,GACDz5C,OAeX,GAVAg6B,EAASzB,QAAQ0e,GAIjB98C,EAAEyc,MAAQA,GAAOzc,EAAEyc,KAAOC,GAASC,MAAQ,IAAIgB,QAAQ2+B,GAAW5/B,GAASsB,SAAW,MAEtFhe,EAAEM,KAAOqF,EAAQsa,QAAUta,EAAQrF,MAAQN,EAAEigB,QAAUjgB,EAAEM,KAEzDN,EAAE48C,WAAa58C,EAAE6c,UAAY,KAAKwR,cAAc7X,MAAMonB,IAAkB,CAAC,IAEpD,MAAjB59B,EAAEid,YAAqB,CACzBc,EAAY7Q,EAASsQ,cAAc,KAInC,IACEO,EAAUpB,KAAO3c,EAAEyc,IAGnBsB,EAAUpB,KAAOoB,EAAUpB,KAC3B3c,EAAEid,YAAca,GAAaE,SAAW,KAAOF,GAAaG,OAASF,EAAUC,SAAW,KAAOD,EAAUE,KAC3G,MAAOzS,GAGPxL,EAAEid,aAAc,GAYpB,GAPIjd,EAAE8a,MAAQ9a,EAAE29C,aAAiC,kBAAX39C,EAAE8a,OACtC9a,EAAE8a,KAAOpD,EAAOuC,MAAMja,EAAE8a,KAAM9a,EAAE67C,cAIlCgB,GAA8B1G,GAAYn2C,EAAG2F,EAASm3C,GAElDjb,EACF,OAAOib,EA6DT,IAAK7+C,KAxDLugD,EAAc9mC,EAAO3R,OAAS/F,EAAEwX,SAEO,IAApBE,EAAO6lC,UACxB7lC,EAAO3R,MAAM2iC,QAAQ,aAIvB1oC,EAAEM,KAAON,EAAEM,KAAKsc,cAEhB5c,EAAEu/C,YAAclD,GAAWt5B,KAAK/iB,EAAEM,MAIlC89C,EAAWp+C,EAAEyc,IAAIkB,QAAQu+B,GAAO,IAE3Bl8C,EAAEu/C,WAkBIv/C,EAAE8a,MAAQ9a,EAAE29C,aAAsF,KAAtE39C,EAAE69C,aAAe,IAAI/uC,QAAQ,uCAClE9O,EAAE8a,KAAO9a,EAAE8a,KAAK6C,QAAQs+B,GAAK,OAjB7BwC,EAAWz+C,EAAEyc,IAAI/P,MAAM0xC,EAASh7C,QAE5BpD,EAAE8a,OAAS9a,EAAE29C,aAAiC,kBAAX39C,EAAE8a,QACvCsjC,IAAa/C,GAAOt4B,KAAKq7B,GAAY,IAAM,KAAOp+C,EAAE8a,YAE7C9a,EAAE8a,OAIK,IAAZ9a,EAAEmzB,QACJirB,EAAWA,EAASzgC,QAAQw+B,GAAY,MACxCsC,GAAYpD,GAAOt4B,KAAKq7B,GAAY,IAAM,KAAO,KAAOxlC,GAAMwV,OAASqwB,GAIzEz+C,EAAEyc,IAAM2hC,EAAWK,GAMjBz+C,EAAEw/C,aACA9nC,EAAO8lC,aAAaY,IACtBtB,EAAM/iC,iBAAiB,oBAAqBrC,EAAO8lC,aAAaY,IAG9D1mC,EAAO+lC,KAAKW,IACdtB,EAAM/iC,iBAAiB,gBAAiBrC,EAAO+lC,KAAKW,MAKpDp+C,EAAE8a,MAAQ9a,EAAEu/C,aAAgC,IAAlBv/C,EAAE69C,aAAyBl4C,EAAQk4C,cAC/Df,EAAM/iC,iBAAiB,eAAgB/Z,EAAE69C,aAI3Cf,EAAM/iC,iBAAiB,SAAU/Z,EAAE48C,UAAU,IAAM58C,EAAE89C,QAAQ99C,EAAE48C,UAAU,IAAM58C,EAAE89C,QAAQ99C,EAAE48C,UAAU,KAA0B,MAAnB58C,EAAE48C,UAAU,GAAa,KAAOJ,GAAW,WAAa,IAAMx8C,EAAE89C,QAAQ,MAE1K99C,EAAEkoB,QACV40B,EAAM/iC,iBAAiB9b,EAAG+B,EAAEkoB,QAAQjqB,IAItC,GAAI+B,EAAEoc,cAAgE,IAAjDpc,EAAEoc,WAAWhe,KAAKsgD,EAAiB5B,EAAO98C,IAAgB6hC,GAE7E,OAAOib,EAAMuC,QAYf,GARAJ,EAAW,QAEXL,EAAiBjwC,IAAI3O,EAAEmc,UACvB2gC,EAAM//B,KAAK/c,EAAEic,SACb6gC,EAAMze,KAAKr+B,EAAE0C,OAEby7C,EAAYtB,GAA8BN,GAAYv8C,EAAG2F,EAASm3C,GAI3D,CAQL,GAPAA,EAAMzgC,WAAa,EAEfmiC,GACFG,EAAmBjW,QAAQ,WAAY,CAACoU,EAAO98C,IAI7C6hC,EACF,OAAOib,EAIL98C,EAAE49C,OAAS59C,EAAEkI,QAAU,IACzBq2C,EAAe90C,EAAOX,YAAW,WAC/Bg0C,EAAMuC,MAAM,aACXr/C,EAAEkI,UAGP,IACE25B,GAAY,EACZsc,EAAU3hC,KAAKuiC,EAAgBhiC,GAC/B,MAAOvR,GAEP,GAAIq2B,EACF,MAAMr2B,EAIRuR,GAAM,EAAGvR,SA9BXuR,GAAM,EAAG,gBAmCX,SAASA,EAAKnV,EAAQ63C,EAAkBC,EAAWx3B,GACjD,IAAIy3B,EACA1jC,EACAvZ,EACAoZ,EACA8jC,EACA1jC,EAAaujC,EAEb5d,IAIJA,GAAY,EAER0c,GACF90C,EAAOb,aAAa21C,GAKtBJ,OAAYj6C,EAEZm6C,EAAwBn2B,GAAW,GAEnC40B,EAAMzgC,WAAazU,EAAS,EAAI,EAAI,EAEpC+3C,EAAY/3C,GAAU,KAAOA,EAAS,KAAkB,MAAXA,EAEzC83C,IACF5jC,EA9gBR,SAA6B9b,EAAG88C,EAAO4C,GAQrC,IAPA,IAAIG,EACAv/C,EACAw/C,EACAC,EACA57B,EAAWnkB,EAAEmkB,SACby4B,EAAY58C,EAAE48C,UAEM,MAAjBA,EAAU,IACfA,EAAU/yB,aAEC3lB,IAAP27C,IACFA,EAAK7/C,EAAEo/C,UAAYtC,EAAM9gC,kBAAkB,iBAK/C,GAAI6jC,EACF,IAAKv/C,KAAQ6jB,EACX,GAAIA,EAAS7jB,IAAS6jB,EAAS7jB,GAAMyiB,KAAK88B,GAAK,CAC7CjD,EAAUtsC,QAAQhQ,GAClB,MAMN,GAAIs8C,EAAU,KAAM8C,EAClBI,EAAgBlD,EAAU,OACrB,CAEL,IAAKt8C,KAAQo/C,EAAW,CACtB,IAAK9C,EAAU,IAAM58C,EAAEg+C,WAAW19C,EAAO,IAAMs8C,EAAU,IAAK,CAC5DkD,EAAgBx/C,EAChB,MAGGy/C,IACHA,EAAgBz/C,GAKpBw/C,EAAgBA,GAAiBC,EAMnC,GAAID,EAKF,OAJIA,IAAkBlD,EAAU,IAC9BA,EAAUtsC,QAAQwvC,GAGbJ,EAAUI,GAwdFE,CAAoBhgD,EAAG88C,EAAO4C,KAItCC,GAAajoC,EAAOsW,QAAQ,SAAUhuB,EAAE48C,YAAc,GAAKllC,EAAOsW,QAAQ,OAAQhuB,EAAE48C,WAAa,IACpG58C,EAAEg+C,WAAW,eAAiB,cAIhCliC,EAzdN,SAAqB9b,EAAG8b,EAAUghC,EAAO6C,GACvC,IAAIM,EACAC,EACAC,EACA/9B,EACA4a,EACAghB,EAAa,GAEjBpB,EAAY58C,EAAE48C,UAAUlwC,QAExB,GAAIkwC,EAAU,GACZ,IAAKuD,KAAQngD,EAAEg+C,WACbA,EAAWmC,EAAK9xB,eAAiBruB,EAAEg+C,WAAWmC,GAMlD,IAFAD,EAAUtD,EAAU/yB,QAEbq2B,GAaL,GAZIlgD,EAAE+9C,eAAemC,KACnBpD,EAAM98C,EAAE+9C,eAAemC,IAAYpkC,IAIhCkhB,GAAQ2iB,GAAa3/C,EAAEogD,aAC1BtkC,EAAW9b,EAAEogD,WAAWtkC,EAAU9b,EAAE6c,WAGtCmgB,EAAOkjB,EACPA,EAAUtD,EAAU/yB,QAIlB,GAAgB,MAAZq2B,EACFA,EAAUljB,OACL,GAAa,MAATA,GAAgBA,IAASkjB,EAAS,CAI3C,KAFAC,EAAOnC,EAAWhhB,EAAO,IAAMkjB,IAAYlC,EAAW,KAAOkC,IAG3D,IAAKD,KAASjC,EAIZ,IAFA57B,EAAM69B,EAAMzxC,MAAM,MAEV,KAAO0xC,IAEbC,EAAOnC,EAAWhhB,EAAO,IAAM5a,EAAI,KAAO47B,EAAW,KAAO57B,EAAI,KAEtD,EAEK,IAAT+9B,EACFA,EAAOnC,EAAWiC,IACa,IAAtBjC,EAAWiC,KACpBC,EAAU99B,EAAI,GACdw6B,EAAUtsC,QAAQ8R,EAAI,KAGxB,MAOR,IAAa,IAAT+9B,EAEF,GAAIA,GAAQngD,EAAEqgD,OACZvkC,EAAWqkC,EAAKrkC,QAEhB,IACEA,EAAWqkC,EAAKrkC,GAChB,MAAOtQ,GACP,MAAO,CACL+W,MAAO,cACP7f,MAAOy9C,EAAO30C,EAAI,sBAAwBwxB,EAAO,OAASkjB,IASxE,MAAO,CACL39B,MAAO,UACPzH,KAAMgB,GAoYOwkC,CAAYtgD,EAAG8b,EAAUghC,EAAO6C,GAEvCA,GAEE3/C,EAAEw/C,cACJI,EAAW9C,EAAM9gC,kBAAkB,oBAGjCtE,EAAO8lC,aAAaY,GAAYwB,IAGlCA,EAAW9C,EAAM9gC,kBAAkB,WAGjCtE,EAAO+lC,KAAKW,GAAYwB,IAKb,MAAXh4C,GAA6B,SAAX5H,EAAEM,KACtB4b,EAAa,YACO,MAAXtU,EACTsU,EAAa,eAEbA,EAAaJ,EAASyG,MACtBtG,EAAUH,EAAShB,KAEnB6kC,IADAj9C,EAAQoZ,EAASpZ,UAKnBA,EAAQwZ,GAEJtU,GAAWsU,IACbA,EAAa,QAETtU,EAAS,IACXA,EAAS,KAMfk1C,EAAMl1C,OAASA,EACfk1C,EAAM5gC,YAAcujC,GAAoBvjC,GAAc,GAElDyjC,EACF9f,EAASe,YAAY8d,EAAiB,CAACziC,EAASC,EAAY4gC,IAE5Djd,EAASmB,WAAW0d,EAAiB,CAAC5B,EAAO5gC,EAAYxZ,IAI3Do6C,EAAMgC,WAAWD,GACjBA,OAAc36C,EAEVs6C,GACFG,EAAmBjW,QAAQiX,EAAY,cAAgB,YAAa,CAAC7C,EAAO98C,EAAG2/C,EAAY1jC,EAAUvZ,IAIvGk8C,EAAiBtf,SAASof,EAAiB,CAAC5B,EAAO5gC,IAE/CsiC,IACFG,EAAmBjW,QAAQ,eAAgB,CAACoU,EAAO98C,MAE3C0X,EAAO6lC,QACb7lC,EAAO3R,MAAM2iC,QAAQ,cAK3B,OAAOoU,GAETyD,QAAS,SAAiB9jC,EAAK3B,EAAM3M,GACnC,OAAOuJ,EAAO5Y,IAAI2d,EAAK3B,EAAM3M,EAAU,SAEzCqyC,UAAW,SAAmB/jC,EAAKtO,GACjC,OAAOuJ,EAAO5Y,IAAI2d,OAAKvY,EAAWiK,EAAU,aAGhDuJ,EAAO8U,KAAK,CAAC,MAAO,SAAS,SAAU9kB,EAAIuY,GACzCvI,EAAOuI,GAAU,SAAUxD,EAAK3B,EAAM3M,EAAU7N,GAS9C,OAPIsE,EAAWkW,KACbxa,EAAOA,GAAQ6N,EACfA,EAAW2M,EACXA,OAAO5W,GAIFwT,EAAOmE,KAAKnE,EAAOuV,OAAO,CAC/BxQ,IAAKA,EACLnc,KAAM2f,EACNpD,SAAUvc,EACVwa,KAAMA,EACNmB,QAAS9N,GACRuJ,EAAO2V,cAAc5Q,IAAQA,QAGpC/E,EAAOwJ,eAAc,SAAUlhB,GAC7B,IAAI/B,EAEJ,IAAKA,KAAK+B,EAAEkoB,QACc,iBAApBjqB,EAAEowB,gBACJruB,EAAE69C,YAAc79C,EAAEkoB,QAAQjqB,IAAM,OAKtCyZ,EAAOg2B,SAAW,SAAUjxB,EAAK9W,EAASomB,GACxC,OAAOrU,EAAOmE,KAAK,CACjBY,IAAKA,EAELnc,KAAM,MACNuc,SAAU,SACVsW,OAAO,EACPyqB,OAAO,EACPpmC,QAAQ,EAIRwmC,WAAY,CACV,cAAe,cAEjBoC,WAAY,SAAoBtkC,GAC9BpE,EAAOmW,WAAW/R,EAAUnW,EAASomB,OAK3CrU,EAAO6J,GAAG0L,OAAO,CACfwzB,QAAS,SAAiBhlC,GACxB,IAAI4rB,EAyBJ,OAvBIxhC,KAAK,KACHjB,EAAW6W,KACbA,EAAOA,EAAKrd,KAAKyH,KAAK,KAIxBwhC,EAAO3vB,EAAO+D,EAAM5V,KAAK,GAAG4sB,eAAe/F,GAAG,GAAGvc,OAAM,GAEnDtK,KAAK,GAAGsD,YACVk+B,EAAKv2B,aAAajL,KAAK,IAGzBwhC,EAAK5oB,KAAI,WAGP,IAFA,IAAIgO,EAAO5mB,KAEJ4mB,EAAKi0B,mBACVj0B,EAAOA,EAAKi0B,kBAGd,OAAOj0B,KACNlc,OAAO1K,OAGLA,MAET86C,UAAW,SAAmBllC,GAC5B,OAAI7W,EAAW6W,GACN5V,KAAK2mB,MAAK,SAAUvuB,GACzByZ,EAAO7R,MAAM86C,UAAUllC,EAAKrd,KAAKyH,KAAM5H,OAIpC4H,KAAK2mB,MAAK,WACf,IAAIloB,EAAOoT,EAAO7R,MACdse,EAAW7f,EAAK6f,WAEhBA,EAAS/gB,OACX+gB,EAASs8B,QAAQhlC,GAEjBnX,EAAKiM,OAAOkL,OAIlB4rB,KAAM,SAAc5rB,GAClB,IAAImlC,EAAiBh8C,EAAW6W,GAChC,OAAO5V,KAAK2mB,MAAK,SAAUvuB,GACzByZ,EAAO7R,MAAM46C,QAAQG,EAAiBnlC,EAAKrd,KAAKyH,KAAM5H,GAAKwd,OAG/DolC,OAAQ,SAAgBn6C,GAItB,OAHAb,KAAK1B,OAAOuC,GAAUg2B,IAAI,QAAQlQ,MAAK,WACrC9U,EAAO7R,MAAMsoC,YAAYtoC,KAAKqsB,eAEzBrsB,QAIX6R,EAAOme,KAAK1F,QAAQolB,OAAS,SAAU9oB,GACrC,OAAQ/U,EAAOme,KAAK1F,QAAQ2wB,QAAQr0B,IAGtC/U,EAAOme,KAAK1F,QAAQ2wB,QAAU,SAAUr0B,GACtC,SAAUA,EAAKtd,aAAesd,EAAK6kB,cAAgB7kB,EAAK0mB,iBAAiB/vC,SAG3EsU,EAAO4lC,aAAaxjC,IAAM,WACxB,IACE,OAAO,IAAIrQ,EAAO6S,eAClB,MAAO9Q,MAGX,IAAIu1C,GAAmB,CAErBC,EAAG,IAGHC,KAAM,KAEJC,GAAexpC,EAAO4lC,aAAaxjC,MACvC2R,EAAQ01B,OAASD,IAAgB,oBAAqBA,GACtDz1B,EAAQ5P,KAAOqlC,KAAiBA,GAChCxpC,EAAOwmC,eAAc,SAAUv4C,GAC7B,IAAIy7C,EAAWC,EAGf,GAAI51B,EAAQ01B,MAAQD,KAAiBv7C,EAAQsX,YAC3C,MAAO,CACLT,KAAM,SAAc0L,EAAS/L,GAC3B,IAAIle,EACA6b,EAAMnU,EAAQmU,MAGlB,GAFAA,EAAIkD,KAAKrX,EAAQrF,KAAMqF,EAAQ8W,IAAK9W,EAAQi4C,MAAOj4C,EAAQ27C,SAAU37C,EAAQ+yB,UAEzE/yB,EAAQ47C,UACV,IAAKtjD,KAAK0H,EAAQ47C,UAChBznC,EAAI7b,GAAK0H,EAAQ47C,UAAUtjD,GAmB/B,IAAKA,KAdD0H,EAAQy5C,UAAYtlC,EAAIqlC,kBAC1BrlC,EAAIqlC,iBAAiBx5C,EAAQy5C,UAQ1Bz5C,EAAQsX,aAAgBiL,EAAQ,sBACnCA,EAAQ,oBAAsB,kBAItBA,EACRpO,EAAIC,iBAAiB9b,EAAGiqB,EAAQjqB,IAIlCmjD,EAAY,SAAkB9gD,GAC5B,OAAO,WACD8gD,IACFA,EAAYC,EAAgBvnC,EAAI0nC,OAAS1nC,EAAI2nC,QAAU3nC,EAAI4nC,QAAU5nC,EAAI6nC,UAAY7nC,EAAIqD,mBAAqB,KAEjG,UAAT7c,EACFwZ,EAAIulC,QACc,UAAT/+C,EAIiB,kBAAfwZ,EAAIlS,OACbuU,EAAS,EAAG,SAEZA,EACArC,EAAIlS,OAAQkS,EAAIoC,YAGlBC,EAAS4kC,GAAiBjnC,EAAIlS,SAAWkS,EAAIlS,OAAQkS,EAAIoC,WAGxB,UAAhCpC,EAAIwN,cAAgB,SAAkD,kBAArBxN,EAAIiC,aAA4B,CAChF6lC,OAAQ9nC,EAAIgC,UACV,CACFN,KAAM1B,EAAIiC,cACTjC,EAAIolC,4BAOfplC,EAAI0nC,OAASJ,IACbC,EAAgBvnC,EAAI2nC,QAAU3nC,EAAI6nC,UAAYP,EAAU,cAIpCl9C,IAAhB4V,EAAI4nC,QACN5nC,EAAI4nC,QAAUL,EAEdvnC,EAAIqD,mBAAqB,WAEA,IAAnBrD,EAAIuC,YAKN5S,EAAOX,YAAW,WACZs4C,GACFC,QAQVD,EAAYA,EAAU,SAEtB,IAEEtnC,EAAI0C,KAAK7W,EAAQ45C,YAAc55C,EAAQmV,MAAQ,MAC/C,MAAOtP,GAEP,GAAI41C,EACF,MAAM51C,IAIZ6zC,MAAO,WACD+B,GACFA,SAOV1pC,EAAOwJ,eAAc,SAAUlhB,GACzBA,EAAEid,cACJjd,EAAEmkB,SAASvI,QAAS,MAIxBlE,EAAOumC,UAAU,CACfH,QAAS,CACPliC,OAAQ,6FAEVuI,SAAU,CACRvI,OAAQ,2BAEVoiC,WAAY,CACV,cAAe,SAAoBxiC,GAEjC,OADA9D,EAAOmW,WAAWrS,GACXA,MAKb9D,EAAOwJ,cAAc,UAAU,SAAUlhB,QACvBkE,IAAZlE,EAAEmzB,QACJnzB,EAAEmzB,OAAQ,GAGRnzB,EAAEid,cACJjd,EAAEM,KAAO,UAIboX,EAAOwmC,cAAc,UAAU,SAAUl+C,GAGrC,IAAI4b,EAAQimC,EADd,GAAI7hD,EAAEid,aAAejd,EAAE8hD,YAGrB,MAAO,CACLtlC,KAAM,SAAcgiB,EAAGriB,GACrBP,EAASlE,EAAO,YAAYoe,KAAK91B,EAAE8hD,aAAe,IAAIv8C,KAAK,CACzDw8C,QAAS/hD,EAAEgiD,cACXp2B,IAAK5rB,EAAEyc,MACNxW,GAAG,aAAc47C,EAAa,SAAkBvnC,GACjDsB,EAAOxV,SACPy7C,EAAa,KAETvnC,GACF6B,EAAsB,UAAb7B,EAAIha,KAAmB,IAAM,IAAKga,EAAIha,QAInD4M,EAASuQ,KAAK7M,YAAYgL,EAAO,KAEnCyjC,MAAO,WACDwC,GACFA,SAMV,IAgFMzhC,GAhFF6hC,GAAe,GACfC,GAAS,oBAEbxqC,EAAOumC,UAAU,CACfkE,MAAO,WACPC,cAAe,WACb,IAAIj0C,EAAW8zC,GAAapyB,OAASnY,EAAO4V,QAAU,IAAM1U,GAAMwV,OAElE,OADAvoB,KAAKsI,IAAY,EACVA,KAIXuJ,EAAOwJ,cAAc,cAAc,SAAUlhB,EAAGqiD,EAAkBvF,GAChE,IAAIwF,EACAC,EACAC,EACAC,GAAuB,IAAZziD,EAAEmiD,QAAoBD,GAAOn/B,KAAK/iB,EAAEyc,KAAO,MAA0B,kBAAXzc,EAAE8a,MAA4F,KAAtE9a,EAAE69C,aAAe,IAAI/uC,QAAQ,sCAA8CozC,GAAOn/B,KAAK/iB,EAAE8a,OAAS,QAEnM,GAAI2nC,GAA+B,UAAnBziD,EAAE48C,UAAU,GAqD1B,OAnDA0F,EAAetiD,EAAEoiD,cAAgBx9C,EAAW5E,EAAEoiD,eAAiBpiD,EAAEoiD,gBAAkBpiD,EAAEoiD,cAEjFK,EACFziD,EAAEyiD,GAAYziD,EAAEyiD,GAAU9kC,QAAQukC,GAAQ,KAAOI,IAC5B,IAAZtiD,EAAEmiD,QACXniD,EAAEyc,MAAQ4+B,GAAOt4B,KAAK/iB,EAAEyc,KAAO,IAAM,KAAOzc,EAAEmiD,MAAQ,IAAMG,GAI9DtiD,EAAEg+C,WAAW,eAAiB,WAK5B,OAJKwE,GACH9qC,EAAOhV,MAAM4/C,EAAe,mBAGvBE,EAAkB,IAI3BxiD,EAAE48C,UAAU,GAAK,OAEjB2F,EAAc94C,EAAO64C,GAErB74C,EAAO64C,GAAgB,WACrBE,EAAoB5+C,WAItBk5C,EAAMld,QAAO,gBAES17B,IAAhBq+C,EACF7qC,EAAOjO,GAAQkwC,WAAW2I,GAE1B74C,EAAO64C,GAAgBC,EAIrBviD,EAAEsiD,KAEJtiD,EAAEoiD,cAAgBC,EAAiBD,cAEnCH,GAAa97C,KAAKm8C,IAIhBE,GAAqB59C,EAAW29C,IAClCA,EAAYC,EAAkB,IAGhCA,EAAoBD,OAAcr+C,KAG7B,YAQXunB,EAAQi3B,qBACFtiC,GAAOlT,EAASy1C,eAAeD,mBAAmB,IAAItiC,MACrDP,UAAY,6BACiB,IAA3BO,GAAK8R,WAAW9uB,QAOzBsU,EAAOklB,UAAY,SAAU9hB,EAAMzU,EAASu8C,GAC1C,MAAoB,kBAAT9nC,EACF,IAGc,mBAAZzU,IACTu8C,EAAcv8C,EACdA,GAAU,GAKPA,IAGColB,EAAQi3B,qBAKV3pB,GAJA1yB,EAAU6G,EAASy1C,eAAeD,mBAAmB,KAItCllC,cAAc,SACxBb,KAAOzP,EAASwP,SAASC,KAC9BtW,EAAQoX,KAAK7M,YAAYmoB,IAEzB1yB,EAAU6G,GAKdg6B,GAAW0b,GAAe,IAD1BC,EAAStmB,EAAW7J,KAAK5X,IAIhB,CAACzU,EAAQmX,cAAcqlC,EAAO,MAGvCA,EAAS5b,GAAc,CAACnsB,GAAOzU,EAAS6gC,GAEpCA,GAAWA,EAAQ9jC,QACrBsU,EAAOwvB,GAAS9gC,SAGXsR,EAAO4U,MAAM,GAAIu2B,EAAO3wB,cA/B/B,IAAI6G,EAAM8pB,EAAQ3b,GAsCpBxvB,EAAO6J,GAAGmpB,KAAO,SAAUjuB,EAAKpC,EAAQlM,GACtC,IAAIzH,EACApG,EACAwb,EACAxX,EAAOuB,KACPuL,EAAMqL,EAAI3N,QAAQ,KA0CtB,OAxCIsC,GAAO,IACT1K,EAAW8yC,GAAiB/8B,EAAI/P,MAAM0E,IACtCqL,EAAMA,EAAI/P,MAAM,EAAG0E,IAIjBxM,EAAWyV,IAEblM,EAAWkM,EACXA,OAASnW,GACAmW,GAA8B,WAApB1X,EAAQ0X,KAC3B/Z,EAAO,QAILgE,EAAKlB,OAAS,GAChBsU,EAAOmE,KAAK,CACVY,IAAKA,EAILnc,KAAMA,GAAQ,MACduc,SAAU,OACV/B,KAAMT,IACL0C,MAAK,SAAUhB,GAEhBD,EAAWlY,UACXU,EAAKmX,KAAK/U,EAEVgR,EAAO,SAASnH,OAAOmH,EAAOklB,UAAU7gB,IAAepE,KAAKjR,GAC5DqV,MAGC6jB,OAAOzxB,GAAY,SAAU2uC,EAAOl1C,GACrCtD,EAAKkoB,MAAK,WACRre,EAAS3F,MAAM3C,KAAMiW,GAAY,CAACghC,EAAM/gC,aAAcnU,EAAQk1C,SAK7Dj3C,MAGT6R,EAAOme,KAAK1F,QAAQ2yB,SAAW,SAAUr2B,GACvC,OAAO/U,EAAOmV,KAAKnV,EAAOugC,QAAQ,SAAU12B,GAC1C,OAAOkL,IAASlL,EAAGkL,QAClBrpB,QAGLsU,EAAOrJ,OAAS,CACd00C,UAAW,SAAmBt2B,EAAM9mB,EAAS1H,GAC3C,IAAI+kD,EACAC,EACAC,EACAC,EACAC,EACAC,EAEAhT,EAAW34B,EAAO8sB,IAAI/X,EAAM,YAC5B62B,EAAU5rC,EAAO+U,GACjBtpB,EAAQ,GAEK,WAAbktC,IACF5jB,EAAK9e,MAAM0iC,SAAW,YAGxB+S,EAAYE,EAAQj1C,SACpB60C,EAAYxrC,EAAO8sB,IAAI/X,EAAM,OAC7B42B,EAAa3rC,EAAO8sB,IAAI/X,EAAM,SACI,aAAb4jB,GAAwC,UAAbA,KAA0B6S,EAAYG,GAAYv0C,QAAQ,SAAW,GAKnHq0C,GADAH,EAAcM,EAAQjT,YACD1b,IACrBsuB,EAAUD,EAAYlP,OAEtBqP,EAASvvC,WAAWsvC,IAAc,EAClCD,EAAUrvC,WAAWyvC,IAAe,GAGlCz+C,EAAWe,KAEbA,EAAUA,EAAQvH,KAAKquB,EAAMxuB,EAAGyZ,EAAOuV,OAAO,GAAIm2B,KAGjC,MAAfz9C,EAAQgvB,MACVxxB,EAAMwxB,IAAMhvB,EAAQgvB,IAAMyuB,EAAUzuB,IAAMwuB,GAGxB,MAAhBx9C,EAAQmuC,OACV3wC,EAAM2wC,KAAOnuC,EAAQmuC,KAAOsP,EAAUtP,KAAOmP,GAG3C,UAAWt9C,EACbA,EAAQ49C,MAAMnlD,KAAKquB,EAAMtpB,GAEzBmgD,EAAQ9e,IAAIrhC,KAIlBuU,EAAO6J,GAAG0L,OAAO,CAEf5e,OAAQ,SAAgB1I,GAEtB,GAAI/B,UAAUR,OACZ,YAAmBc,IAAZyB,EAAwBE,KAAOA,KAAK2mB,MAAK,SAAUvuB,GACxDyZ,EAAOrJ,OAAO00C,UAAUl9C,KAAMF,EAAS1H,MAI3C,IAAIulD,EACAC,EACAh3B,EAAO5mB,KAAK,GAEhB,OAAK4mB,EAQAA,EAAK0mB,iBAAiB/vC,QAQ3BogD,EAAO/2B,EAAKmnB,wBACZ6P,EAAMh3B,EAAKgG,cAAciC,YAClB,CACLC,IAAK6uB,EAAK7uB,IAAM8uB,EAAIC,YACpB5P,KAAM0P,EAAK1P,KAAO2P,EAAIE,cAXf,CACLhvB,IAAK,EACLmf,KAAM,QAXV,GAyBFzD,SAAU,WACR,GAAKxqC,KAAK,GAAV,CAIA,IAAI+9C,EACAv1C,EACA0d,EACAU,EAAO5mB,KAAK,GACZg+C,EAAe,CACjBlvB,IAAK,EACLmf,KAAM,GAGR,GAAqC,UAAjCp8B,EAAO8sB,IAAI/X,EAAM,YAEnBpe,EAASoe,EAAKmnB,4BACT,CAOL,IANAvlC,EAASxI,KAAKwI,SAGd0d,EAAMU,EAAKgG,cACXmxB,EAAen3B,EAAKm3B,cAAgB73B,EAAIwI,gBAEjCqvB,IAAiBA,IAAiB73B,EAAI3L,MAAQwjC,IAAiB73B,EAAIwI,kBAA6D,WAAzC7c,EAAO8sB,IAAIof,EAAc,aACrHA,EAAeA,EAAaz6C,WAG1By6C,GAAgBA,IAAiBn3B,GAAkC,IAA1Bm3B,EAAar6C,YAExDs6C,EAAensC,EAAOksC,GAAcv1C,UACvBsmB,KAAOjd,EAAO8sB,IAAIof,EAAc,kBAAkB,GAC/DC,EAAa/P,MAAQp8B,EAAO8sB,IAAIof,EAAc,mBAAmB,IAKrE,MAAO,CACLjvB,IAAKtmB,EAAOsmB,IAAMkvB,EAAalvB,IAAMjd,EAAO8sB,IAAI/X,EAAM,aAAa,GACnEqnB,KAAMzlC,EAAOylC,KAAO+P,EAAa/P,KAAOp8B,EAAO8sB,IAAI/X,EAAM,cAAc,MAa3Em3B,aAAc,WACZ,OAAO/9C,KAAK4Y,KAAI,WAGd,IAFA,IAAImlC,EAAe/9C,KAAK+9C,aAEjBA,GAAyD,WAAzClsC,EAAO8sB,IAAIof,EAAc,aAC9CA,EAAeA,EAAaA,aAG9B,OAAOA,GAAgBrvB,SAK7B7c,EAAO8U,KAAK,CACVsoB,WAAY,cACZD,UAAW,gBACV,SAAU50B,EAAQ1a,GACnB,IAAIovB,EAAM,gBAAkBpvB,EAE5BmS,EAAO6J,GAAGtB,GAAU,SAAUwD,GAC5B,OAAOwe,EAAOp8B,MAAM,SAAU4mB,EAAMxM,EAAQwD,GAE1C,IAAIggC,EAQJ,GANI/3B,EAASe,GACXg3B,EAAMh3B,EACqB,IAAlBA,EAAKljB,WACdk6C,EAAMh3B,EAAKiI,kBAGDxwB,IAARuf,EACF,OAAOggC,EAAMA,EAAIl+C,GAAQknB,EAAKxM,GAG5BwjC,EACFA,EAAIK,SAAUnvB,EAAY8uB,EAAIE,YAAVlgC,EAAuBkR,EAAMlR,EAAMggC,EAAIC,aAE3Dj3B,EAAKxM,GAAUwD,IAEhBxD,EAAQwD,EAAK7f,UAAUR,YAS9BsU,EAAO8U,KAAK,CAAC,MAAO,SAAS,SAAU9kB,EAAInC,GACzCmS,EAAO47B,SAAS/tC,GAAQiqC,GAAa/jB,EAAQmlB,eAAe,SAAUnkB,EAAM0iB,GAC1E,GAAIA,EAGF,OAFAA,EAAWD,GAAOziB,EAAMlnB,GAEjBopC,GAAU5rB,KAAKosB,GAAYz3B,EAAO+U,GAAM4jB,WAAW9qC,GAAQ,KAAO4pC,QAK/Ez3B,EAAO8U,KAAK,CACVu3B,OAAQ,SACRC,MAAO,UACN,SAAUxlD,EAAM8B,GACjBoX,EAAO8U,KAAK,CACVwnB,QAAS,QAAUx1C,EACnBua,QAASzY,EACT,GAAI,QAAU9B,IACb,SAAUylD,EAAcC,GAEzBxsC,EAAO6J,GAAG2iC,GAAY,SAAUnQ,EAAQ70C,GACtC,IAAIgjC,EAAYt+B,UAAUR,SAAW6gD,GAAkC,mBAAXlQ,GACxDjB,EAAQmR,KAA4B,IAAXlQ,IAA6B,IAAV70C,EAAiB,SAAW,UAC5E,OAAO+iC,EAAOp8B,MAAM,SAAU4mB,EAAMnsB,EAAMpB,GACxC,IAAI6sB,EAEJ,OAAIL,EAASe,GAE0B,IAA9By3B,EAASp1C,QAAQ,SAAiB2d,EAAK,QAAUjuB,GAAQiuB,EAAKvf,SAASqnB,gBAAgB,SAAW/1B,GAIrF,IAAlBiuB,EAAKljB,UACPwiB,EAAMU,EAAK8H,gBAGJvkB,KAAKC,IAAIwc,EAAKrM,KAAK,SAAW5hB,GAAOutB,EAAI,SAAWvtB,GAAOiuB,EAAKrM,KAAK,SAAW5hB,GAAOutB,EAAI,SAAWvtB,GAAOutB,EAAI,SAAWvtB,UAGpH0F,IAAVhF,EACPwY,EAAO8sB,IAAI/X,EAAMnsB,EAAMwyC,GACvBp7B,EAAO/J,MAAM8e,EAAMnsB,EAAMpB,EAAO4zC,KAC/BxyC,EAAM4hC,EAAY6R,OAAS7vC,EAAWg+B,UAI/CxqB,EAAO8U,KAAK,CAAC,YAAa,WAAY,eAAgB,YAAa,cAAe,aAAa,SAAU9kB,EAAIpH,GAC3GoX,EAAO6J,GAAGjhB,GAAQ,SAAUihB,GAC1B,OAAO1b,KAAKI,GAAG3F,EAAMihB,OAGzB7J,EAAO6J,GAAG0L,OAAO,CACfxtB,KAAM,SAAcyoC,EAAOptB,EAAMyG,GAC/B,OAAO1b,KAAKI,GAAGiiC,EAAO,KAAMptB,EAAMyG,IAEpCpQ,OAAQ,SAAgB+2B,EAAO3mB,GAC7B,OAAO1b,KAAKuL,IAAI82B,EAAO,KAAM3mB,IAE/BrG,SAAU,SAAkBxU,EAAUwhC,EAAOptB,EAAMyG,GACjD,OAAO1b,KAAKI,GAAGiiC,EAAOxhC,EAAUoU,EAAMyG,IAExC4iC,WAAY,SAAoBz9C,EAAUwhC,EAAO3mB,GAE/C,OAA4B,IAArB3d,UAAUR,OAAeyC,KAAKuL,IAAI1K,EAAU,MAAQb,KAAKuL,IAAI82B,EAAOxhC,GAAY,KAAM6a,IAE/F6iC,MAAO,SAAeC,EAAQC,GAC5B,OAAOz+C,KAAKumC,WAAWiY,GAAQhY,WAAWiY,GAASD,MAGvD3sC,EAAO8U,KAAK,wLAAoMhe,MAAM,MAAM,SAAU9G,EAAIlJ,GAExOkZ,EAAO6J,GAAG/iB,GAAQ,SAAUsc,EAAMyG,GAChC,OAAO3d,UAAUR,OAAS,EAAIyC,KAAKI,GAAGzH,EAAM,KAAMsc,EAAMyG,GAAM1b,KAAK6iC,QAAQlqC,OAK/E,IAAI8xB,GAAQ,qCAKZ5Y,EAAO6sC,MAAQ,SAAUhjC,EAAIlb,GAC3B,IAAI+b,EAAKja,EAAMo8C,EAUf,GARuB,kBAAZl+C,IACT+b,EAAMb,EAAGlb,GACTA,EAAUkb,EACVA,EAAKa,GAKFxd,EAAW2c,GAahB,OARApZ,EAAO+iB,EAAO9sB,KAAKwF,UAAW,IAE9B2gD,EAAQ,WACN,OAAOhjC,EAAG/Y,MAAMnC,GAAWR,KAAMsC,EAAKoF,OAAO2d,EAAO9sB,KAAKwF,eAIrDwqB,KAAO7M,EAAG6M,KAAO7M,EAAG6M,MAAQ1W,EAAO0W,OAClCm2B,GAGT7sC,EAAO8sC,UAAY,SAAUC,GACvBA,EACF/sC,EAAOqqB,YAEPrqB,EAAOmlB,OAAM,IAIjBnlB,EAAO5S,QAAUC,MAAMD,QACvB4S,EAAOgtC,UAAYpnC,KAAKC,MACxB7F,EAAOqa,SAAWA,EAClBra,EAAO9S,WAAaA,EACpB8S,EAAOgU,SAAWA,EAClBhU,EAAOgrB,UAAYA,EACnBhrB,EAAOpX,KAAO0rB,EACdtU,EAAO7P,IAAMC,KAAKD,IAElB6P,EAAOitC,UAAY,SAAUzkD,GAI3B,IAAII,EAAOoX,EAAOpX,KAAKJ,GACvB,OAAiB,WAATI,GAA8B,WAATA,KAG5BskD,MAAM1kD,EAAM0T,WAAW1T,KAG1BwX,EAAOmtC,KAAO,SAAUrpC,GACtB,OAAe,MAARA,EAAe,IAAMA,EAAO,IAAImC,QAAQ2S,GAAO,UAiBrD,KAFoB,EAAF,WACjB,OAAO5Y,GACR,QAFgB,OAEhB,aAGH,IACAotC,GAAUr7C,EAAOiO,OAEjBqtC,GAAKt7C,EAAOgO,EAqBZ,OAnBAC,EAAOstC,WAAa,SAAU53B,GAS5B,OARI3jB,EAAOgO,IAAMC,IACfjO,EAAOgO,EAAIstC,IAGT33B,GAAQ3jB,EAAOiO,SAAWA,IAC5BjO,EAAOiO,OAASotC,IAGXptC,GAMe,qBAAbsT,IACTvhB,EAAOiO,OAASjO,EAAOgO,EAAIC,GAGtBA,O","file":"js/application-d39d7a49127a74787f66.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 2);\n","function _typeof2(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof2(obj); }\n\n/*!\n * Glide.js v3.4.1\n * (c) 2013-2019 Jędrzej Chałubek <jedrzej.chalubek@gmail.com> (http://jedrzejchalubek.com/)\n * Released under the MIT License.\n */\nvar defaults = {\n  /**\n   * Type of the movement.\n   *\n   * Available types:\n   * `slider` - Rewinds slider to the start/end when it reaches the first or last slide.\n   * `carousel` - Changes slides without starting over when it reaches the first or last slide.\n   *\n   * @type {String}\n   */\n  type: 'slider',\n\n  /**\n   * Start at specific slide number defined with zero-based index.\n   *\n   * @type {Number}\n   */\n  startAt: 0,\n\n  /**\n   * A number of slides visible on the single viewport.\n   *\n   * @type {Number}\n   */\n  perView: 1,\n\n  /**\n   * Focus currently active slide at a specified position in the track.\n   *\n   * Available inputs:\n   * `center` - Current slide will be always focused at the center of a track.\n   * `0,1,2,3...` - Current slide will be focused on the specified zero-based index.\n   *\n   * @type {String|Number}\n   */\n  focusAt: 0,\n\n  /**\n   * A size of the gap added between slides.\n   *\n   * @type {Number}\n   */\n  gap: 10,\n\n  /**\n   * Change slides after a specified interval. Use `false` for turning off autoplay.\n   *\n   * @type {Number|Boolean}\n   */\n  autoplay: false,\n\n  /**\n   * Stop autoplay on mouseover event.\n   *\n   * @type {Boolean}\n   */\n  hoverpause: true,\n\n  /**\n   * Allow for changing slides with left and right keyboard arrows.\n   *\n   * @type {Boolean}\n   */\n  keyboard: true,\n\n  /**\n   * Stop running `perView` number of slides from the end. Use this\n   * option if you don't want to have an empty space after\n   * a slider. Works only with `slider` type and a\n   * non-centered `focusAt` setting.\n   *\n   * @type {Boolean}\n   */\n  bound: false,\n\n  /**\n   * Minimal swipe distance needed to change the slide. Use `false` for turning off a swiping.\n   *\n   * @type {Number|Boolean}\n   */\n  swipeThreshold: 80,\n\n  /**\n   * Minimal mouse drag distance needed to change the slide. Use `false` for turning off a dragging.\n   *\n   * @type {Number|Boolean}\n   */\n  dragThreshold: 120,\n\n  /**\n   * A maximum number of slides to which movement will be made on swiping or dragging. Use `false` for unlimited.\n   *\n   * @type {Number|Boolean}\n   */\n  perTouch: false,\n\n  /**\n   * Moving distance ratio of the slides on a swiping and dragging.\n   *\n   * @type {Number}\n   */\n  touchRatio: 0.5,\n\n  /**\n   * Angle required to activate slides moving on swiping or dragging.\n   *\n   * @type {Number}\n   */\n  touchAngle: 45,\n\n  /**\n   * Duration of the animation in milliseconds.\n   *\n   * @type {Number}\n   */\n  animationDuration: 400,\n\n  /**\n   * Allows looping the `slider` type. Slider will rewind to the first/last slide when it's at the start/end.\n   *\n   * @type {Boolean}\n   */\n  rewind: true,\n\n  /**\n   * Duration of the rewinding animation of the `slider` type in milliseconds.\n   *\n   * @type {Number}\n   */\n  rewindDuration: 800,\n\n  /**\n   * Easing function for the animation.\n   *\n   * @type {String}\n   */\n  animationTimingFunc: 'cubic-bezier(.165, .840, .440, 1)',\n\n  /**\n   * Throttle costly events at most once per every wait milliseconds.\n   *\n   * @type {Number}\n   */\n  throttle: 10,\n\n  /**\n   * Moving direction mode.\n   *\n   * Available inputs:\n   * - 'ltr' - left to right movement,\n   * - 'rtl' - right to left movement.\n   *\n   * @type {String}\n   */\n  direction: 'ltr',\n\n  /**\n   * The distance value of the next and previous viewports which\n   * have to peek in the current view. Accepts number and\n   * pixels as a string. Left and right peeking can be\n   * set up separately with a directions object.\n   *\n   * For example:\n   * `100` - Peek 100px on the both sides.\n   * { before: 100, after: 50 }` - Peek 100px on the left side and 50px on the right side.\n   *\n   * @type {Number|String|Object}\n   */\n  peek: 0,\n\n  /**\n   * Collection of options applied at specified media breakpoints.\n   * For example: display two slides per view under 800px.\n   * `{\n   *   '800px': {\n   *     perView: 2\n   *   }\n   * }`\n   */\n  breakpoints: {},\n\n  /**\n   * Collection of internally used HTML classes.\n   *\n   * @todo Refactor `slider` and `carousel` properties to single `type: { slider: '', carousel: '' }` object\n   * @type {Object}\n   */\n  classes: {\n    direction: {\n      ltr: 'glide--ltr',\n      rtl: 'glide--rtl'\n    },\n    slider: 'glide--slider',\n    carousel: 'glide--carousel',\n    swipeable: 'glide--swipeable',\n    dragging: 'glide--dragging',\n    cloneSlide: 'glide__slide--clone',\n    activeNav: 'glide__bullet--active',\n    activeSlide: 'glide__slide--active',\n    disabledArrow: 'glide__arrow--disabled'\n  }\n};\n/**\n * Outputs warning message to the bowser console.\n *\n * @param  {String} msg\n * @return {Void}\n */\n\nfunction warn(msg) {\n  console.error(\"[Glide warn]: \" + msg);\n}\n\nvar _typeof = typeof Symbol === \"function\" && _typeof2(Symbol.iterator) === \"symbol\" ? function (obj) {\n  return _typeof2(obj);\n} : function (obj) {\n  return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : _typeof2(obj);\n};\n\nvar classCallCheck = function classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\nvar get = function get(object, property, receiver) {\n  if (object === null) object = Function.prototype;\n  var desc = Object.getOwnPropertyDescriptor(object, property);\n\n  if (desc === undefined) {\n    var parent = Object.getPrototypeOf(object);\n\n    if (parent === null) {\n      return undefined;\n    } else {\n      return get(parent, property, receiver);\n    }\n  } else if (\"value\" in desc) {\n    return desc.value;\n  } else {\n    var getter = desc.get;\n\n    if (getter === undefined) {\n      return undefined;\n    }\n\n    return getter.call(receiver);\n  }\n};\n\nvar inherits = function inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + _typeof2(superClass));\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar possibleConstructorReturn = function possibleConstructorReturn(self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (_typeof2(call) === \"object\" || typeof call === \"function\") ? call : self;\n};\n/**\n * Converts value entered as number\n * or string to integer value.\n *\n * @param {String} value\n * @returns {Number}\n */\n\n\nfunction toInt(value) {\n  return parseInt(value);\n}\n/**\n * Converts value entered as number\n * or string to flat value.\n *\n * @param {String} value\n * @returns {Number}\n */\n\n\nfunction toFloat(value) {\n  return parseFloat(value);\n}\n/**\n * Indicates whether the specified value is a string.\n *\n * @param  {*}   value\n * @return {Boolean}\n */\n\n\nfunction isString(value) {\n  return typeof value === 'string';\n}\n/**\n * Indicates whether the specified value is an object.\n *\n * @param  {*} value\n * @return {Boolean}\n *\n * @see https://github.com/jashkenas/underscore\n */\n\n\nfunction isObject(value) {\n  var type = typeof value === 'undefined' ? 'undefined' : _typeof(value);\n  return type === 'function' || type === 'object' && !!value; // eslint-disable-line no-mixed-operators\n}\n/**\n * Indicates whether the specified value is a number.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isNumber(value) {\n  return typeof value === 'number';\n}\n/**\n * Indicates whether the specified value is a function.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isFunction(value) {\n  return typeof value === 'function';\n}\n/**\n * Indicates whether the specified value is undefined.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isUndefined(value) {\n  return typeof value === 'undefined';\n}\n/**\n * Indicates whether the specified value is an array.\n *\n * @param  {*} value\n * @return {Boolean}\n */\n\n\nfunction isArray(value) {\n  return value.constructor === Array;\n}\n/**\n * Creates and initializes specified collection of extensions.\n * Each extension receives access to instance of glide and rest of components.\n *\n * @param {Object} glide\n * @param {Object} extensions\n *\n * @returns {Object}\n */\n\n\nfunction mount(glide, extensions, events) {\n  var components = {};\n\n  for (var name in extensions) {\n    if (isFunction(extensions[name])) {\n      components[name] = extensions[name](glide, components, events);\n    } else {\n      warn('Extension must be a function');\n    }\n  }\n\n  for (var _name in components) {\n    if (isFunction(components[_name].mount)) {\n      components[_name].mount();\n    }\n  }\n\n  return components;\n}\n/**\n * Defines getter and setter property on the specified object.\n *\n * @param  {Object} obj         Object where property has to be defined.\n * @param  {String} prop        Name of the defined property.\n * @param  {Object} definition  Get and set definitions for the property.\n * @return {Void}\n */\n\n\nfunction define(obj, prop, definition) {\n  Object.defineProperty(obj, prop, definition);\n}\n/**\n * Sorts aphabetically object keys.\n *\n * @param  {Object} obj\n * @return {Object}\n */\n\n\nfunction sortKeys(obj) {\n  return Object.keys(obj).sort().reduce(function (r, k) {\n    r[k] = obj[k];\n    return r[k], r;\n  }, {});\n}\n/**\n * Merges passed settings object with default options.\n *\n * @param  {Object} defaults\n * @param  {Object} settings\n * @return {Object}\n */\n\n\nfunction mergeOptions(defaults, settings) {\n  var options = _extends({}, defaults, settings); // `Object.assign` do not deeply merge objects, so we\n  // have to do it manually for every nested object\n  // in options. Although it does not look smart,\n  // it's smaller and faster than some fancy\n  // merging deep-merge algorithm script.\n\n\n  if (settings.hasOwnProperty('classes')) {\n    options.classes = _extends({}, defaults.classes, settings.classes);\n\n    if (settings.classes.hasOwnProperty('direction')) {\n      options.classes.direction = _extends({}, defaults.classes.direction, settings.classes.direction);\n    }\n  }\n\n  if (settings.hasOwnProperty('breakpoints')) {\n    options.breakpoints = _extends({}, defaults.breakpoints, settings.breakpoints);\n  }\n\n  return options;\n}\n\nvar EventsBus = function () {\n  /**\n   * Construct a EventBus instance.\n   *\n   * @param {Object} events\n   */\n  function EventsBus() {\n    var events = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    classCallCheck(this, EventsBus);\n    this.events = events;\n    this.hop = events.hasOwnProperty;\n  }\n  /**\n   * Adds listener to the specifed event.\n   *\n   * @param {String|Array} event\n   * @param {Function} handler\n   */\n\n\n  createClass(EventsBus, [{\n    key: 'on',\n    value: function on(event, handler) {\n      if (isArray(event)) {\n        for (var i = 0; i < event.length; i++) {\n          this.on(event[i], handler);\n        }\n      } // Create the event's object if not yet created\n\n\n      if (!this.hop.call(this.events, event)) {\n        this.events[event] = [];\n      } // Add the handler to queue\n\n\n      var index = this.events[event].push(handler) - 1; // Provide handle back for removal of event\n\n      return {\n        remove: function remove() {\n          delete this.events[event][index];\n        }\n      };\n    }\n    /**\n     * Runs registered handlers for specified event.\n     *\n     * @param {String|Array} event\n     * @param {Object=} context\n     */\n\n  }, {\n    key: 'emit',\n    value: function emit(event, context) {\n      if (isArray(event)) {\n        for (var i = 0; i < event.length; i++) {\n          this.emit(event[i], context);\n        }\n      } // If the event doesn't exist, or there's no handlers in queue, just leave\n\n\n      if (!this.hop.call(this.events, event)) {\n        return;\n      } // Cycle through events queue, fire!\n\n\n      this.events[event].forEach(function (item) {\n        item(context || {});\n      });\n    }\n  }]);\n  return EventsBus;\n}();\n\nvar Glide = function () {\n  /**\r\n   * Construct glide.\r\n   *\r\n   * @param  {String} selector\r\n   * @param  {Object} options\r\n   */\n  function Glide(selector) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    classCallCheck(this, Glide);\n    this._c = {};\n    this._t = [];\n    this._e = new EventsBus();\n    this.disabled = false;\n    this.selector = selector;\n    this.settings = mergeOptions(defaults, options);\n    this.index = this.settings.startAt;\n  }\n  /**\r\n   * Initializes glide.\r\n   *\r\n   * @param {Object} extensions Collection of extensions to initialize.\r\n   * @return {Glide}\r\n   */\n\n\n  createClass(Glide, [{\n    key: 'mount',\n    value: function mount$$1() {\n      var extensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n      this._e.emit('mount.before');\n\n      if (isObject(extensions)) {\n        this._c = mount(this, extensions, this._e);\n      } else {\n        warn('You need to provide a object on `mount()`');\n      }\n\n      this._e.emit('mount.after');\n\n      return this;\n    }\n    /**\r\n     * Collects an instance `translate` transformers.\r\n     *\r\n     * @param  {Array} transformers Collection of transformers.\r\n     * @return {Void}\r\n     */\n\n  }, {\n    key: 'mutate',\n    value: function mutate() {\n      var transformers = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n\n      if (isArray(transformers)) {\n        this._t = transformers;\n      } else {\n        warn('You need to provide a array on `mutate()`');\n      }\n\n      return this;\n    }\n    /**\r\n     * Updates glide with specified settings.\r\n     *\r\n     * @param {Object} settings\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'update',\n    value: function update() {\n      var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      this.settings = mergeOptions(this.settings, settings);\n\n      if (settings.hasOwnProperty('startAt')) {\n        this.index = settings.startAt;\n      }\n\n      this._e.emit('update');\n\n      return this;\n    }\n    /**\r\n     * Change slide with specified pattern. A pattern must be in the special format:\r\n     * `>` - Move one forward\r\n     * `<` - Move one backward\r\n     * `={i}` - Go to {i} zero-based slide (eq. '=1', will go to second slide)\r\n     * `>>` - Rewinds to end (last slide)\r\n     * `<<` - Rewinds to start (first slide)\r\n     *\r\n     * @param {String} pattern\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'go',\n    value: function go(pattern) {\n      this._c.Run.make(pattern);\n\n      return this;\n    }\n    /**\r\n     * Move track by specified distance.\r\n     *\r\n     * @param {String} distance\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'move',\n    value: function move(distance) {\n      this._c.Transition.disable();\n\n      this._c.Move.make(distance);\n\n      return this;\n    }\n    /**\r\n     * Destroy instance and revert all changes done by this._c.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      this._e.emit('destroy');\n\n      return this;\n    }\n    /**\r\n     * Start instance autoplaying.\r\n     *\r\n     * @param {Boolean|Number} interval Run autoplaying with passed interval regardless of `autoplay` settings\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'play',\n    value: function play() {\n      var interval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n      if (interval) {\n        this.settings.autoplay = interval;\n      }\n\n      this._e.emit('play');\n\n      return this;\n    }\n    /**\r\n     * Stop instance autoplaying.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'pause',\n    value: function pause() {\n      this._e.emit('pause');\n\n      return this;\n    }\n    /**\r\n     * Sets glide into a idle status.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'disable',\n    value: function disable() {\n      this.disabled = true;\n      return this;\n    }\n    /**\r\n     * Sets glide into a active status.\r\n     *\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'enable',\n    value: function enable() {\n      this.disabled = false;\n      return this;\n    }\n    /**\r\n     * Adds cuutom event listener with handler.\r\n     *\r\n     * @param  {String|Array} event\r\n     * @param  {Function} handler\r\n     * @return {Glide}\r\n     */\n\n  }, {\n    key: 'on',\n    value: function on(event, handler) {\n      this._e.on(event, handler);\n\n      return this;\n    }\n    /**\r\n     * Checks if glide is a precised type.\r\n     *\r\n     * @param  {String} name\r\n     * @return {Boolean}\r\n     */\n\n  }, {\n    key: 'isType',\n    value: function isType(name) {\n      return this.settings.type === name;\n    }\n    /**\r\n     * Gets value of the core options.\r\n     *\r\n     * @return {Object}\r\n     */\n\n  }, {\n    key: 'settings',\n    get: function get$$1() {\n      return this._o;\n    }\n    /**\r\n     * Sets value of the core options.\r\n     *\r\n     * @param  {Object} o\r\n     * @return {Void}\r\n     */\n    ,\n    set: function set$$1(o) {\n      if (isObject(o)) {\n        this._o = o;\n      } else {\n        warn('Options must be an `object` instance.');\n      }\n    }\n    /**\r\n     * Gets current index of the slider.\r\n     *\r\n     * @return {Object}\r\n     */\n\n  }, {\n    key: 'index',\n    get: function get$$1() {\n      return this._i;\n    }\n    /**\r\n     * Sets current index a slider.\r\n     *\r\n     * @return {Object}\r\n     */\n    ,\n    set: function set$$1(i) {\n      this._i = toInt(i);\n    }\n    /**\r\n     * Gets type name of the slider.\r\n     *\r\n     * @return {String}\r\n     */\n\n  }, {\n    key: 'type',\n    get: function get$$1() {\n      return this.settings.type;\n    }\n    /**\r\n     * Gets value of the idle status.\r\n     *\r\n     * @return {Boolean}\r\n     */\n\n  }, {\n    key: 'disabled',\n    get: function get$$1() {\n      return this._d;\n    }\n    /**\r\n     * Sets value of the idle status.\r\n     *\r\n     * @return {Boolean}\r\n     */\n    ,\n    set: function set$$1(status) {\n      this._d = !!status;\n    }\n  }]);\n  return Glide;\n}();\n\nfunction Run(Glide, Components, Events) {\n  var Run = {\n    /**\n     * Initializes autorunning of the glide.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this._o = false;\n    },\n\n    /**\n     * Makes glides running based on the passed moving schema.\n     *\n     * @param {String} move\n     */\n    make: function make(move) {\n      var _this = this;\n\n      if (!Glide.disabled) {\n        Glide.disable();\n        this.move = move;\n        Events.emit('run.before', this.move);\n        this.calculate();\n        Events.emit('run', this.move);\n        Components.Transition.after(function () {\n          if (_this.isStart()) {\n            Events.emit('run.start', _this.move);\n          }\n\n          if (_this.isEnd()) {\n            Events.emit('run.end', _this.move);\n          }\n\n          if (_this.isOffset('<') || _this.isOffset('>')) {\n            _this._o = false;\n            Events.emit('run.offset', _this.move);\n          }\n\n          Events.emit('run.after', _this.move);\n          Glide.enable();\n        });\n      }\n    },\n\n    /**\n     * Calculates current index based on defined move.\n     *\n     * @return {Void}\n     */\n    calculate: function calculate() {\n      var move = this.move,\n          length = this.length;\n      var steps = move.steps,\n          direction = move.direction;\n      var countableSteps = isNumber(toInt(steps)) && toInt(steps) !== 0;\n\n      switch (direction) {\n        case '>':\n          if (steps === '>') {\n            Glide.index = length;\n          } else if (this.isEnd()) {\n            if (!(Glide.isType('slider') && !Glide.settings.rewind)) {\n              this._o = true;\n              Glide.index = 0;\n            }\n          } else if (countableSteps) {\n            Glide.index += Math.min(length - Glide.index, -toInt(steps));\n          } else {\n            Glide.index++;\n          }\n\n          break;\n\n        case '<':\n          if (steps === '<') {\n            Glide.index = 0;\n          } else if (this.isStart()) {\n            if (!(Glide.isType('slider') && !Glide.settings.rewind)) {\n              this._o = true;\n              Glide.index = length;\n            }\n          } else if (countableSteps) {\n            Glide.index -= Math.min(Glide.index, toInt(steps));\n          } else {\n            Glide.index--;\n          }\n\n          break;\n\n        case '=':\n          Glide.index = steps;\n          break;\n\n        default:\n          warn('Invalid direction pattern [' + direction + steps + '] has been used');\n          break;\n      }\n    },\n\n    /**\n     * Checks if we are on the first slide.\n     *\n     * @return {Boolean}\n     */\n    isStart: function isStart() {\n      return Glide.index === 0;\n    },\n\n    /**\n     * Checks if we are on the last slide.\n     *\n     * @return {Boolean}\n     */\n    isEnd: function isEnd() {\n      return Glide.index === this.length;\n    },\n\n    /**\n     * Checks if we are making a offset run.\n     *\n     * @param {String} direction\n     * @return {Boolean}\n     */\n    isOffset: function isOffset(direction) {\n      return this._o && this.move.direction === direction;\n    }\n  };\n  define(Run, 'move', {\n    /**\n     * Gets value of the move schema.\n     *\n     * @returns {Object}\n     */\n    get: function get() {\n      return this._m;\n    },\n\n    /**\n     * Sets value of the move schema.\n     *\n     * @returns {Object}\n     */\n    set: function set(value) {\n      var step = value.substr(1);\n      this._m = {\n        direction: value.substr(0, 1),\n        steps: step ? toInt(step) ? toInt(step) : step : 0\n      };\n    }\n  });\n  define(Run, 'length', {\n    /**\n     * Gets value of the running distance based\n     * on zero-indexing number of slides.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var settings = Glide.settings;\n      var length = Components.Html.slides.length; // If the `bound` option is acitve, a maximum running distance should be\n      // reduced by `perView` and `focusAt` settings. Running distance\n      // should end before creating an empty space after instance.\n\n      if (Glide.isType('slider') && settings.focusAt !== 'center' && settings.bound) {\n        return length - 1 - (toInt(settings.perView) - 1) + toInt(settings.focusAt);\n      }\n\n      return length - 1;\n    }\n  });\n  define(Run, 'offset', {\n    /**\n     * Gets status of the offsetting flag.\n     *\n     * @return {Boolean}\n     */\n    get: function get() {\n      return this._o;\n    }\n  });\n  return Run;\n}\n/**\n * Returns a current time.\n *\n * @return {Number}\n */\n\n\nfunction now() {\n  return new Date().getTime();\n}\n/**\n * Returns a function, that, when invoked, will only be triggered\n * at most once during a given window of time.\n *\n * @param {Function} func\n * @param {Number} wait\n * @param {Object=} options\n * @return {Function}\n *\n * @see https://github.com/jashkenas/underscore\n */\n\n\nfunction throttle(func, wait, options) {\n  var timeout = void 0,\n      context = void 0,\n      args = void 0,\n      result = void 0;\n  var previous = 0;\n  if (!options) options = {};\n\n  var later = function later() {\n    previous = options.leading === false ? 0 : now();\n    timeout = null;\n    result = func.apply(context, args);\n    if (!timeout) context = args = null;\n  };\n\n  var throttled = function throttled() {\n    var at = now();\n    if (!previous && options.leading === false) previous = at;\n    var remaining = wait - (at - previous);\n    context = this;\n    args = arguments;\n\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n\n      previous = at;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    } else if (!timeout && options.trailing !== false) {\n      timeout = setTimeout(later, remaining);\n    }\n\n    return result;\n  };\n\n  throttled.cancel = function () {\n    clearTimeout(timeout);\n    previous = 0;\n    timeout = context = args = null;\n  };\n\n  return throttled;\n}\n\nvar MARGIN_TYPE = {\n  ltr: ['marginLeft', 'marginRight'],\n  rtl: ['marginRight', 'marginLeft']\n};\n\nfunction Gaps(Glide, Components, Events) {\n  var Gaps = {\n    /**\n     * Applies gaps between slides. First and last\n     * slides do not receive it's edge margins.\n     *\n     * @param {HTMLCollection} slides\n     * @return {Void}\n     */\n    apply: function apply(slides) {\n      for (var i = 0, len = slides.length; i < len; i++) {\n        var style = slides[i].style;\n        var direction = Components.Direction.value;\n\n        if (i !== 0) {\n          style[MARGIN_TYPE[direction][0]] = this.value / 2 + 'px';\n        } else {\n          style[MARGIN_TYPE[direction][0]] = '';\n        }\n\n        if (i !== slides.length - 1) {\n          style[MARGIN_TYPE[direction][1]] = this.value / 2 + 'px';\n        } else {\n          style[MARGIN_TYPE[direction][1]] = '';\n        }\n      }\n    },\n\n    /**\n     * Removes gaps from the slides.\n     *\n     * @param {HTMLCollection} slides\n     * @returns {Void}\n    */\n    remove: function remove(slides) {\n      for (var i = 0, len = slides.length; i < len; i++) {\n        var style = slides[i].style;\n        style.marginLeft = '';\n        style.marginRight = '';\n      }\n    }\n  };\n  define(Gaps, 'value', {\n    /**\n     * Gets value of the gap.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      return toInt(Glide.settings.gap);\n    }\n  });\n  define(Gaps, 'grow', {\n    /**\n     * Gets additional dimentions value caused by gaps.\n     * Used to increase width of the slides wrapper.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      return Gaps.value * (Components.Sizes.length - 1);\n    }\n  });\n  define(Gaps, 'reductor', {\n    /**\n     * Gets reduction value caused by gaps.\n     * Used to subtract width of the slides.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      var perView = Glide.settings.perView;\n      return Gaps.value * (perView - 1) / perView;\n    }\n  });\n  /**\n   * Apply calculated gaps:\n   * - after building, so slides (including clones) will receive proper margins\n   * - on updating via API, to recalculate gaps with new options\n   */\n\n  Events.on(['build.after', 'update'], throttle(function () {\n    Gaps.apply(Components.Html.wrapper.children);\n  }, 30));\n  /**\n   * Remove gaps:\n   * - on destroying to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Gaps.remove(Components.Html.wrapper.children);\n  });\n  return Gaps;\n}\n/**\n * Finds siblings nodes of the passed node.\n *\n * @param  {Element} node\n * @return {Array}\n */\n\n\nfunction siblings(node) {\n  if (node && node.parentNode) {\n    var n = node.parentNode.firstChild;\n    var matched = [];\n\n    for (; n; n = n.nextSibling) {\n      if (n.nodeType === 1 && n !== node) {\n        matched.push(n);\n      }\n    }\n\n    return matched;\n  }\n\n  return [];\n}\n/**\n * Checks if passed node exist and is a valid element.\n *\n * @param  {Element} node\n * @return {Boolean}\n */\n\n\nfunction exist(node) {\n  if (node && node instanceof window.HTMLElement) {\n    return true;\n  }\n\n  return false;\n}\n\nvar TRACK_SELECTOR = '[data-glide-el=\"track\"]';\n\nfunction Html(Glide, Components) {\n  var Html = {\n    /**\n     * Setup slider HTML nodes.\n     *\n     * @param {Glide} glide\n     */\n    mount: function mount() {\n      this.root = Glide.selector;\n      this.track = this.root.querySelector(TRACK_SELECTOR);\n      this.slides = Array.prototype.slice.call(this.wrapper.children).filter(function (slide) {\n        return !slide.classList.contains(Glide.settings.classes.cloneSlide);\n      });\n    }\n  };\n  define(Html, 'root', {\n    /**\n     * Gets node of the glide main element.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Html._r;\n    },\n\n    /**\n     * Sets node of the glide main element.\n     *\n     * @return {Object}\n     */\n    set: function set(r) {\n      if (isString(r)) {\n        r = document.querySelector(r);\n      }\n\n      if (exist(r)) {\n        Html._r = r;\n      } else {\n        warn('Root element must be a existing Html node');\n      }\n    }\n  });\n  define(Html, 'track', {\n    /**\n     * Gets node of the glide track with slides.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Html._t;\n    },\n\n    /**\n     * Sets node of the glide track with slides.\n     *\n     * @return {Object}\n     */\n    set: function set(t) {\n      if (exist(t)) {\n        Html._t = t;\n      } else {\n        warn('Could not find track element. Please use ' + TRACK_SELECTOR + ' attribute.');\n      }\n    }\n  });\n  define(Html, 'wrapper', {\n    /**\n     * Gets node of the slides wrapper.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Html.track.children[0];\n    }\n  });\n  return Html;\n}\n\nfunction Peek(Glide, Components, Events) {\n  var Peek = {\n    /**\n     * Setups how much to peek based on settings.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.value = Glide.settings.peek;\n    }\n  };\n  define(Peek, 'value', {\n    /**\n     * Gets value of the peek.\n     *\n     * @returns {Number|Object}\n     */\n    get: function get() {\n      return Peek._v;\n    },\n\n    /**\n     * Sets value of the peek.\n     *\n     * @param {Number|Object} value\n     * @return {Void}\n     */\n    set: function set(value) {\n      if (isObject(value)) {\n        value.before = toInt(value.before);\n        value.after = toInt(value.after);\n      } else {\n        value = toInt(value);\n      }\n\n      Peek._v = value;\n    }\n  });\n  define(Peek, 'reductor', {\n    /**\n     * Gets reduction value caused by peek.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      var value = Peek.value;\n      var perView = Glide.settings.perView;\n\n      if (isObject(value)) {\n        return value.before / perView + value.after / perView;\n      }\n\n      return value * 2 / perView;\n    }\n  });\n  /**\n   * Recalculate peeking sizes on:\n   * - when resizing window to update to proper percents\n   */\n\n  Events.on(['resize', 'update'], function () {\n    Peek.mount();\n  });\n  return Peek;\n}\n\nfunction Move(Glide, Components, Events) {\n  var Move = {\n    /**\n     * Constructs move component.\n     *\n     * @returns {Void}\n     */\n    mount: function mount() {\n      this._o = 0;\n    },\n\n    /**\n     * Calculates a movement value based on passed offset and currently active index.\n     *\n     * @param  {Number} offset\n     * @return {Void}\n     */\n    make: function make() {\n      var _this = this;\n\n      var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n      this.offset = offset;\n      Events.emit('move', {\n        movement: this.value\n      });\n      Components.Transition.after(function () {\n        Events.emit('move.after', {\n          movement: _this.value\n        });\n      });\n    }\n  };\n  define(Move, 'offset', {\n    /**\n     * Gets an offset value used to modify current translate.\n     *\n     * @return {Object}\n     */\n    get: function get() {\n      return Move._o;\n    },\n\n    /**\n     * Sets an offset value used to modify current translate.\n     *\n     * @return {Object}\n     */\n    set: function set(value) {\n      Move._o = !isUndefined(value) ? toInt(value) : 0;\n    }\n  });\n  define(Move, 'translate', {\n    /**\n     * Gets a raw movement value.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Components.Sizes.slideWidth * Glide.index;\n    }\n  });\n  define(Move, 'value', {\n    /**\n     * Gets an actual movement value corrected by offset.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var offset = this.offset;\n      var translate = this.translate;\n\n      if (Components.Direction.is('rtl')) {\n        return translate + offset;\n      }\n\n      return translate - offset;\n    }\n  });\n  /**\n   * Make movement to proper slide on:\n   * - before build, so glide will start at `startAt` index\n   * - on each standard run to move to newly calculated index\n   */\n\n  Events.on(['build.before', 'run'], function () {\n    Move.make();\n  });\n  return Move;\n}\n\nfunction Sizes(Glide, Components, Events) {\n  var Sizes = {\n    /**\n     * Setups dimentions of slides.\n     *\n     * @return {Void}\n     */\n    setupSlides: function setupSlides() {\n      var width = this.slideWidth + 'px';\n      var slides = Components.Html.slides;\n\n      for (var i = 0; i < slides.length; i++) {\n        slides[i].style.width = width;\n      }\n    },\n\n    /**\n     * Setups dimentions of slides wrapper.\n     *\n     * @return {Void}\n     */\n    setupWrapper: function setupWrapper(dimention) {\n      Components.Html.wrapper.style.width = this.wrapperSize + 'px';\n    },\n\n    /**\n     * Removes applied styles from HTML elements.\n     *\n     * @returns {Void}\n     */\n    remove: function remove() {\n      var slides = Components.Html.slides;\n\n      for (var i = 0; i < slides.length; i++) {\n        slides[i].style.width = '';\n      }\n\n      Components.Html.wrapper.style.width = '';\n    }\n  };\n  define(Sizes, 'length', {\n    /**\n     * Gets count number of the slides.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Components.Html.slides.length;\n    }\n  });\n  define(Sizes, 'width', {\n    /**\n     * Gets width value of the glide.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Components.Html.root.offsetWidth;\n    }\n  });\n  define(Sizes, 'wrapperSize', {\n    /**\n     * Gets size of the slides wrapper.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Sizes.slideWidth * Sizes.length + Components.Gaps.grow + Components.Clones.grow;\n    }\n  });\n  define(Sizes, 'slideWidth', {\n    /**\n     * Gets width value of the single slide.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return Sizes.width / Glide.settings.perView - Components.Peek.reductor - Components.Gaps.reductor;\n    }\n  });\n  /**\n   * Apply calculated glide's dimensions:\n   * - before building, so other dimentions (e.g. translate) will be calculated propertly\n   * - when resizing window to recalculate sildes dimensions\n   * - on updating via API, to calculate dimensions based on new options\n   */\n\n  Events.on(['build.before', 'resize', 'update'], function () {\n    Sizes.setupSlides();\n    Sizes.setupWrapper();\n  });\n  /**\n   * Remove calculated glide's dimensions:\n   * - on destoting to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Sizes.remove();\n  });\n  return Sizes;\n}\n\nfunction Build(Glide, Components, Events) {\n  var Build = {\n    /**\n     * Init glide building. Adds classes, sets\n     * dimensions and setups initial state.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      Events.emit('build.before');\n      this.typeClass();\n      this.activeClass();\n      Events.emit('build.after');\n    },\n\n    /**\n     * Adds `type` class to the glide element.\n     *\n     * @return {Void}\n     */\n    typeClass: function typeClass() {\n      Components.Html.root.classList.add(Glide.settings.classes[Glide.settings.type]);\n    },\n\n    /**\n     * Sets active class to current slide.\n     *\n     * @return {Void}\n     */\n    activeClass: function activeClass() {\n      var classes = Glide.settings.classes;\n      var slide = Components.Html.slides[Glide.index];\n\n      if (slide) {\n        slide.classList.add(classes.activeSlide);\n        siblings(slide).forEach(function (sibling) {\n          sibling.classList.remove(classes.activeSlide);\n        });\n      }\n    },\n\n    /**\n     * Removes HTML classes applied at building.\n     *\n     * @return {Void}\n     */\n    removeClasses: function removeClasses() {\n      var classes = Glide.settings.classes;\n      Components.Html.root.classList.remove(classes[Glide.settings.type]);\n      Components.Html.slides.forEach(function (sibling) {\n        sibling.classList.remove(classes.activeSlide);\n      });\n    }\n  };\n  /**\n   * Clear building classes:\n   * - on destroying to bring HTML to its initial state\n   * - on updating to remove classes before remounting component\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Build.removeClasses();\n  });\n  /**\n   * Remount component:\n   * - on resizing of the window to calculate new dimentions\n   * - on updating settings via API\n   */\n\n  Events.on(['resize', 'update'], function () {\n    Build.mount();\n  });\n  /**\n   * Swap active class of current slide:\n   * - after each move to the new index\n   */\n\n  Events.on('move.after', function () {\n    Build.activeClass();\n  });\n  return Build;\n}\n\nfunction Clones(Glide, Components, Events) {\n  var Clones = {\n    /**\n     * Create pattern map and collect slides to be cloned.\n     */\n    mount: function mount() {\n      this.items = [];\n\n      if (Glide.isType('carousel')) {\n        this.items = this.collect();\n      }\n    },\n\n    /**\n     * Collect clones with pattern.\n     *\n     * @return {Void}\n     */\n    collect: function collect() {\n      var items = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n      var slides = Components.Html.slides;\n      var _Glide$settings = Glide.settings,\n          perView = _Glide$settings.perView,\n          classes = _Glide$settings.classes;\n      var peekIncrementer = +!!Glide.settings.peek;\n      var part = perView + peekIncrementer;\n      var start = slides.slice(0, part);\n      var end = slides.slice(-part);\n\n      for (var r = 0; r < Math.max(1, Math.floor(perView / slides.length)); r++) {\n        for (var i = 0; i < start.length; i++) {\n          var clone = start[i].cloneNode(true);\n          clone.classList.add(classes.cloneSlide);\n          items.push(clone);\n        }\n\n        for (var _i = 0; _i < end.length; _i++) {\n          var _clone = end[_i].cloneNode(true);\n\n          _clone.classList.add(classes.cloneSlide);\n\n          items.unshift(_clone);\n        }\n      }\n\n      return items;\n    },\n\n    /**\n     * Append cloned slides with generated pattern.\n     *\n     * @return {Void}\n     */\n    append: function append() {\n      var items = this.items;\n      var _Components$Html = Components.Html,\n          wrapper = _Components$Html.wrapper,\n          slides = _Components$Html.slides;\n      var half = Math.floor(items.length / 2);\n      var prepend = items.slice(0, half).reverse();\n      var append = items.slice(half, items.length);\n      var width = Components.Sizes.slideWidth + 'px';\n\n      for (var i = 0; i < append.length; i++) {\n        wrapper.appendChild(append[i]);\n      }\n\n      for (var _i2 = 0; _i2 < prepend.length; _i2++) {\n        wrapper.insertBefore(prepend[_i2], slides[0]);\n      }\n\n      for (var _i3 = 0; _i3 < items.length; _i3++) {\n        items[_i3].style.width = width;\n      }\n    },\n\n    /**\n     * Remove all cloned slides.\n     *\n     * @return {Void}\n     */\n    remove: function remove() {\n      var items = this.items;\n\n      for (var i = 0; i < items.length; i++) {\n        Components.Html.wrapper.removeChild(items[i]);\n      }\n    }\n  };\n  define(Clones, 'grow', {\n    /**\n     * Gets additional dimentions value caused by clones.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      return (Components.Sizes.slideWidth + Components.Gaps.value) * Clones.items.length;\n    }\n  });\n  /**\n   * Append additional slide's clones:\n   * - while glide's type is `carousel`\n   */\n\n  Events.on('update', function () {\n    Clones.remove();\n    Clones.mount();\n    Clones.append();\n  });\n  /**\n   * Append additional slide's clones:\n   * - while glide's type is `carousel`\n   */\n\n  Events.on('build.before', function () {\n    if (Glide.isType('carousel')) {\n      Clones.append();\n    }\n  });\n  /**\n   * Remove clones HTMLElements:\n   * - on destroying, to bring HTML to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Clones.remove();\n  });\n  return Clones;\n}\n\nvar EventsBinder = function () {\n  /**\n   * Construct a EventsBinder instance.\n   */\n  function EventsBinder() {\n    var listeners = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    classCallCheck(this, EventsBinder);\n    this.listeners = listeners;\n  }\n  /**\n   * Adds events listeners to arrows HTML elements.\n   *\n   * @param  {String|Array} events\n   * @param  {Element|Window|Document} el\n   * @param  {Function} closure\n   * @param  {Boolean|Object} capture\n   * @return {Void}\n   */\n\n\n  createClass(EventsBinder, [{\n    key: 'on',\n    value: function on(events, el, closure) {\n      var capture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n\n      if (isString(events)) {\n        events = [events];\n      }\n\n      for (var i = 0; i < events.length; i++) {\n        this.listeners[events[i]] = closure;\n        el.addEventListener(events[i], this.listeners[events[i]], capture);\n      }\n    }\n    /**\n     * Removes event listeners from arrows HTML elements.\n     *\n     * @param  {String|Array} events\n     * @param  {Element|Window|Document} el\n     * @param  {Boolean|Object} capture\n     * @return {Void}\n     */\n\n  }, {\n    key: 'off',\n    value: function off(events, el) {\n      var capture = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n      if (isString(events)) {\n        events = [events];\n      }\n\n      for (var i = 0; i < events.length; i++) {\n        el.removeEventListener(events[i], this.listeners[events[i]], capture);\n      }\n    }\n    /**\n     * Destroy collected listeners.\n     *\n     * @returns {Void}\n     */\n\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      delete this.listeners;\n    }\n  }]);\n  return EventsBinder;\n}();\n\nfunction Resize(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Resize = {\n    /**\n     * Initializes window bindings.\n     */\n    mount: function mount() {\n      this.bind();\n    },\n\n    /**\n     * Binds `rezsize` listener to the window.\n     * It's a costly event, so we are debouncing it.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('resize', window, throttle(function () {\n        Events.emit('resize');\n      }, Glide.settings.throttle));\n    },\n\n    /**\n     * Unbinds listeners from the window.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('resize', window);\n    }\n  };\n  /**\n   * Remove bindings from window:\n   * - on destroying, to remove added EventListener\n   */\n\n  Events.on('destroy', function () {\n    Resize.unbind();\n    Binder.destroy();\n  });\n  return Resize;\n}\n\nvar VALID_DIRECTIONS = ['ltr', 'rtl'];\nvar FLIPED_MOVEMENTS = {\n  '>': '<',\n  '<': '>',\n  '=': '='\n};\n\nfunction Direction(Glide, Components, Events) {\n  var Direction = {\n    /**\n     * Setups gap value based on settings.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.value = Glide.settings.direction;\n    },\n\n    /**\n     * Resolves pattern based on direction value\n     *\n     * @param {String} pattern\n     * @returns {String}\n     */\n    resolve: function resolve(pattern) {\n      var token = pattern.slice(0, 1);\n\n      if (this.is('rtl')) {\n        return pattern.split(token).join(FLIPED_MOVEMENTS[token]);\n      }\n\n      return pattern;\n    },\n\n    /**\n     * Checks value of direction mode.\n     *\n     * @param {String} direction\n     * @returns {Boolean}\n     */\n    is: function is(direction) {\n      return this.value === direction;\n    },\n\n    /**\n     * Applies direction class to the root HTML element.\n     *\n     * @return {Void}\n     */\n    addClass: function addClass() {\n      Components.Html.root.classList.add(Glide.settings.classes.direction[this.value]);\n    },\n\n    /**\n     * Removes direction class from the root HTML element.\n     *\n     * @return {Void}\n     */\n    removeClass: function removeClass() {\n      Components.Html.root.classList.remove(Glide.settings.classes.direction[this.value]);\n    }\n  };\n  define(Direction, 'value', {\n    /**\n     * Gets value of the direction.\n     *\n     * @returns {Number}\n     */\n    get: function get() {\n      return Direction._v;\n    },\n\n    /**\n     * Sets value of the direction.\n     *\n     * @param {String} value\n     * @return {Void}\n     */\n    set: function set(value) {\n      if (VALID_DIRECTIONS.indexOf(value) > -1) {\n        Direction._v = value;\n      } else {\n        warn('Direction value must be `ltr` or `rtl`');\n      }\n    }\n  });\n  /**\n   * Clear direction class:\n   * - on destroy to bring HTML to its initial state\n   * - on update to remove class before reappling bellow\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Direction.removeClass();\n  });\n  /**\n   * Remount component:\n   * - on update to reflect changes in direction value\n   */\n\n  Events.on('update', function () {\n    Direction.mount();\n  });\n  /**\n   * Apply direction class:\n   * - before building to apply class for the first time\n   * - on updating to reapply direction class that may changed\n   */\n\n  Events.on(['build.before', 'update'], function () {\n    Direction.addClass();\n  });\n  return Direction;\n}\n/**\n * Reflects value of glide movement.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Rtl(Glide, Components) {\n  return {\n    /**\n     * Negates the passed translate if glide is in RTL option.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      if (Components.Direction.is('rtl')) {\n        return -translate;\n      }\n\n      return translate;\n    }\n  };\n}\n/**\n * Updates glide movement with a `gap` settings.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Gap(Glide, Components) {\n  return {\n    /**\n     * Modifies passed translate value with number in the `gap` settings.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      return translate + Components.Gaps.value * Glide.index;\n    }\n  };\n}\n/**\n * Updates glide movement with width of additional clones width.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Grow(Glide, Components) {\n  return {\n    /**\n     * Adds to the passed translate width of the half of clones.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      return translate + Components.Clones.grow / 2;\n    }\n  };\n}\n/**\n * Updates glide movement with a `peek` settings.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Peeking(Glide, Components) {\n  return {\n    /**\n     * Modifies passed translate value with a `peek` setting.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      if (Glide.settings.focusAt >= 0) {\n        var peek = Components.Peek.value;\n\n        if (isObject(peek)) {\n          return translate - peek.before;\n        }\n\n        return translate - peek;\n      }\n\n      return translate;\n    }\n  };\n}\n/**\n * Updates glide movement with a `focusAt` settings.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction Focusing(Glide, Components) {\n  return {\n    /**\n     * Modifies passed translate value with index in the `focusAt` setting.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    modify: function modify(translate) {\n      var gap = Components.Gaps.value;\n      var width = Components.Sizes.width;\n      var focusAt = Glide.settings.focusAt;\n      var slideWidth = Components.Sizes.slideWidth;\n\n      if (focusAt === 'center') {\n        return translate - (width / 2 - slideWidth / 2);\n      }\n\n      return translate - slideWidth * focusAt - gap * focusAt;\n    }\n  };\n}\n/**\n * Applies diffrent transformers on translate value.\n *\n * @param  {Object} Glide\n * @param  {Object} Components\n * @return {Object}\n */\n\n\nfunction mutator(Glide, Components, Events) {\n  /**\n   * Merge instance transformers with collection of default transformers.\n   * It's important that the Rtl component be last on the list,\n   * so it reflects all previous transformations.\n   *\n   * @type {Array}\n   */\n  var TRANSFORMERS = [Gap, Grow, Peeking, Focusing].concat(Glide._t, [Rtl]);\n  return {\n    /**\n     * Piplines translate value with registered transformers.\n     *\n     * @param  {Number} translate\n     * @return {Number}\n     */\n    mutate: function mutate(translate) {\n      for (var i = 0; i < TRANSFORMERS.length; i++) {\n        var transformer = TRANSFORMERS[i];\n\n        if (isFunction(transformer) && isFunction(transformer().modify)) {\n          translate = transformer(Glide, Components, Events).modify(translate);\n        } else {\n          warn('Transformer should be a function that returns an object with `modify()` method');\n        }\n      }\n\n      return translate;\n    }\n  };\n}\n\nfunction Translate(Glide, Components, Events) {\n  var Translate = {\n    /**\n     * Sets value of translate on HTML element.\n     *\n     * @param {Number} value\n     * @return {Void}\n     */\n    set: function set(value) {\n      var transform = mutator(Glide, Components).mutate(value);\n      Components.Html.wrapper.style.transform = 'translate3d(' + -1 * transform + 'px, 0px, 0px)';\n    },\n\n    /**\n     * Removes value of translate from HTML element.\n     *\n     * @return {Void}\n     */\n    remove: function remove() {\n      Components.Html.wrapper.style.transform = '';\n    }\n  };\n  /**\n   * Set new translate value:\n   * - on move to reflect index change\n   * - on updating via API to reflect possible changes in options\n   */\n\n  Events.on('move', function (context) {\n    var gap = Components.Gaps.value;\n    var length = Components.Sizes.length;\n    var width = Components.Sizes.slideWidth;\n\n    if (Glide.isType('carousel') && Components.Run.isOffset('<')) {\n      Components.Transition.after(function () {\n        Events.emit('translate.jump');\n        Translate.set(width * (length - 1));\n      });\n      return Translate.set(-width - gap * length);\n    }\n\n    if (Glide.isType('carousel') && Components.Run.isOffset('>')) {\n      Components.Transition.after(function () {\n        Events.emit('translate.jump');\n        Translate.set(0);\n      });\n      return Translate.set(width * length + gap * length);\n    }\n\n    return Translate.set(context.movement);\n  });\n  /**\n   * Remove translate:\n   * - on destroying to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Translate.remove();\n  });\n  return Translate;\n}\n\nfunction Transition(Glide, Components, Events) {\n  /**\n   * Holds inactivity status of transition.\n   * When true transition is not applied.\n   *\n   * @type {Boolean}\n   */\n  var disabled = false;\n  var Transition = {\n    /**\n     * Composes string of the CSS transition.\n     *\n     * @param {String} property\n     * @return {String}\n     */\n    compose: function compose(property) {\n      var settings = Glide.settings;\n\n      if (!disabled) {\n        return property + ' ' + this.duration + 'ms ' + settings.animationTimingFunc;\n      }\n\n      return property + ' 0ms ' + settings.animationTimingFunc;\n    },\n\n    /**\n     * Sets value of transition on HTML element.\n     *\n     * @param {String=} property\n     * @return {Void}\n     */\n    set: function set() {\n      var property = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'transform';\n      Components.Html.wrapper.style.transition = this.compose(property);\n    },\n\n    /**\n     * Removes value of transition from HTML element.\n     *\n     * @return {Void}\n     */\n    remove: function remove() {\n      Components.Html.wrapper.style.transition = '';\n    },\n\n    /**\n     * Runs callback after animation.\n     *\n     * @param  {Function} callback\n     * @return {Void}\n     */\n    after: function after(callback) {\n      setTimeout(function () {\n        callback();\n      }, this.duration);\n    },\n\n    /**\n     * Enable transition.\n     *\n     * @return {Void}\n     */\n    enable: function enable() {\n      disabled = false;\n      this.set();\n    },\n\n    /**\n     * Disable transition.\n     *\n     * @return {Void}\n     */\n    disable: function disable() {\n      disabled = true;\n      this.set();\n    }\n  };\n  define(Transition, 'duration', {\n    /**\n     * Gets duration of the transition based\n     * on currently running animation type.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var settings = Glide.settings;\n\n      if (Glide.isType('slider') && Components.Run.offset) {\n        return settings.rewindDuration;\n      }\n\n      return settings.animationDuration;\n    }\n  });\n  /**\n   * Set transition `style` value:\n   * - on each moving, because it may be cleared by offset move\n   */\n\n  Events.on('move', function () {\n    Transition.set();\n  });\n  /**\n   * Disable transition:\n   * - before initial build to avoid transitioning from `0` to `startAt` index\n   * - while resizing window and recalculating dimentions\n   * - on jumping from offset transition at start and end edges in `carousel` type\n   */\n\n  Events.on(['build.before', 'resize', 'translate.jump'], function () {\n    Transition.disable();\n  });\n  /**\n   * Enable transition:\n   * - on each running, because it may be disabled by offset move\n   */\n\n  Events.on('run', function () {\n    Transition.enable();\n  });\n  /**\n   * Remove transition:\n   * - on destroying to bring markup to its inital state\n   */\n\n  Events.on('destroy', function () {\n    Transition.remove();\n  });\n  return Transition;\n}\n/**\n * Test via a getter in the options object to see\n * if the passive property is accessed.\n *\n * @see https://github.com/WICG/EventListenerOptions/blob/gh-pages/explainer.md#feature-detection\n */\n\n\nvar supportsPassive = false;\n\ntry {\n  var opts = Object.defineProperty({}, 'passive', {\n    get: function get() {\n      supportsPassive = true;\n    }\n  });\n  window.addEventListener('testPassive', null, opts);\n  window.removeEventListener('testPassive', null, opts);\n} catch (e) {}\n\nvar supportsPassive$1 = supportsPassive;\nvar START_EVENTS = ['touchstart', 'mousedown'];\nvar MOVE_EVENTS = ['touchmove', 'mousemove'];\nvar END_EVENTS = ['touchend', 'touchcancel', 'mouseup', 'mouseleave'];\nvar MOUSE_EVENTS = ['mousedown', 'mousemove', 'mouseup', 'mouseleave'];\n\nfunction Swipe(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var swipeSin = 0;\n  var swipeStartX = 0;\n  var swipeStartY = 0;\n  var disabled = false;\n  var capture = supportsPassive$1 ? {\n    passive: true\n  } : false;\n  var Swipe = {\n    /**\n     * Initializes swipe bindings.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.bindSwipeStart();\n    },\n\n    /**\n     * Handler for `swipestart` event. Calculates entry points of the user's tap.\n     *\n     * @param {Object} event\n     * @return {Void}\n     */\n    start: function start(event) {\n      if (!disabled && !Glide.disabled) {\n        this.disable();\n        var swipe = this.touches(event);\n        swipeSin = null;\n        swipeStartX = toInt(swipe.pageX);\n        swipeStartY = toInt(swipe.pageY);\n        this.bindSwipeMove();\n        this.bindSwipeEnd();\n        Events.emit('swipe.start');\n      }\n    },\n\n    /**\n     * Handler for `swipemove` event. Calculates user's tap angle and distance.\n     *\n     * @param {Object} event\n     */\n    move: function move(event) {\n      if (!Glide.disabled) {\n        var _Glide$settings = Glide.settings,\n            touchAngle = _Glide$settings.touchAngle,\n            touchRatio = _Glide$settings.touchRatio,\n            classes = _Glide$settings.classes;\n        var swipe = this.touches(event);\n        var subExSx = toInt(swipe.pageX) - swipeStartX;\n        var subEySy = toInt(swipe.pageY) - swipeStartY;\n        var powEX = Math.abs(subExSx << 2);\n        var powEY = Math.abs(subEySy << 2);\n        var swipeHypotenuse = Math.sqrt(powEX + powEY);\n        var swipeCathetus = Math.sqrt(powEY);\n        swipeSin = Math.asin(swipeCathetus / swipeHypotenuse);\n\n        if (swipeSin * 180 / Math.PI < touchAngle) {\n          event.stopPropagation();\n          Components.Move.make(subExSx * toFloat(touchRatio));\n          Components.Html.root.classList.add(classes.dragging);\n          Events.emit('swipe.move');\n        } else {\n          return false;\n        }\n      }\n    },\n\n    /**\n     * Handler for `swipeend` event. Finitializes user's tap and decides about glide move.\n     *\n     * @param {Object} event\n     * @return {Void}\n     */\n    end: function end(event) {\n      if (!Glide.disabled) {\n        var settings = Glide.settings;\n        var swipe = this.touches(event);\n        var threshold = this.threshold(event);\n        var swipeDistance = swipe.pageX - swipeStartX;\n        var swipeDeg = swipeSin * 180 / Math.PI;\n        var steps = Math.round(swipeDistance / Components.Sizes.slideWidth);\n        this.enable();\n\n        if (swipeDistance > threshold && swipeDeg < settings.touchAngle) {\n          // While swipe is positive and greater than threshold move backward.\n          if (settings.perTouch) {\n            steps = Math.min(steps, toInt(settings.perTouch));\n          }\n\n          if (Components.Direction.is('rtl')) {\n            steps = -steps;\n          }\n\n          Components.Run.make(Components.Direction.resolve('<' + steps));\n        } else if (swipeDistance < -threshold && swipeDeg < settings.touchAngle) {\n          // While swipe is negative and lower than negative threshold move forward.\n          if (settings.perTouch) {\n            steps = Math.max(steps, -toInt(settings.perTouch));\n          }\n\n          if (Components.Direction.is('rtl')) {\n            steps = -steps;\n          }\n\n          Components.Run.make(Components.Direction.resolve('>' + steps));\n        } else {\n          // While swipe don't reach distance apply previous transform.\n          Components.Move.make();\n        }\n\n        Components.Html.root.classList.remove(settings.classes.dragging);\n        this.unbindSwipeMove();\n        this.unbindSwipeEnd();\n        Events.emit('swipe.end');\n      }\n    },\n\n    /**\n     * Binds swipe's starting event.\n     *\n     * @return {Void}\n     */\n    bindSwipeStart: function bindSwipeStart() {\n      var _this = this;\n\n      var settings = Glide.settings;\n\n      if (settings.swipeThreshold) {\n        Binder.on(START_EVENTS[0], Components.Html.wrapper, function (event) {\n          _this.start(event);\n        }, capture);\n      }\n\n      if (settings.dragThreshold) {\n        Binder.on(START_EVENTS[1], Components.Html.wrapper, function (event) {\n          _this.start(event);\n        }, capture);\n      }\n    },\n\n    /**\n     * Unbinds swipe's starting event.\n     *\n     * @return {Void}\n     */\n    unbindSwipeStart: function unbindSwipeStart() {\n      Binder.off(START_EVENTS[0], Components.Html.wrapper, capture);\n      Binder.off(START_EVENTS[1], Components.Html.wrapper, capture);\n    },\n\n    /**\n     * Binds swipe's moving event.\n     *\n     * @return {Void}\n     */\n    bindSwipeMove: function bindSwipeMove() {\n      var _this2 = this;\n\n      Binder.on(MOVE_EVENTS, Components.Html.wrapper, throttle(function (event) {\n        _this2.move(event);\n      }, Glide.settings.throttle), capture);\n    },\n\n    /**\n     * Unbinds swipe's moving event.\n     *\n     * @return {Void}\n     */\n    unbindSwipeMove: function unbindSwipeMove() {\n      Binder.off(MOVE_EVENTS, Components.Html.wrapper, capture);\n    },\n\n    /**\n     * Binds swipe's ending event.\n     *\n     * @return {Void}\n     */\n    bindSwipeEnd: function bindSwipeEnd() {\n      var _this3 = this;\n\n      Binder.on(END_EVENTS, Components.Html.wrapper, function (event) {\n        _this3.end(event);\n      });\n    },\n\n    /**\n     * Unbinds swipe's ending event.\n     *\n     * @return {Void}\n     */\n    unbindSwipeEnd: function unbindSwipeEnd() {\n      Binder.off(END_EVENTS, Components.Html.wrapper);\n    },\n\n    /**\n     * Normalizes event touches points accorting to different types.\n     *\n     * @param {Object} event\n     */\n    touches: function touches(event) {\n      if (MOUSE_EVENTS.indexOf(event.type) > -1) {\n        return event;\n      }\n\n      return event.touches[0] || event.changedTouches[0];\n    },\n\n    /**\n     * Gets value of minimum swipe distance settings based on event type.\n     *\n     * @return {Number}\n     */\n    threshold: function threshold(event) {\n      var settings = Glide.settings;\n\n      if (MOUSE_EVENTS.indexOf(event.type) > -1) {\n        return settings.dragThreshold;\n      }\n\n      return settings.swipeThreshold;\n    },\n\n    /**\n     * Enables swipe event.\n     *\n     * @return {self}\n     */\n    enable: function enable() {\n      disabled = false;\n      Components.Transition.enable();\n      return this;\n    },\n\n    /**\n     * Disables swipe event.\n     *\n     * @return {self}\n     */\n    disable: function disable() {\n      disabled = true;\n      Components.Transition.disable();\n      return this;\n    }\n  };\n  /**\n   * Add component class:\n   * - after initial building\n   */\n\n  Events.on('build.after', function () {\n    Components.Html.root.classList.add(Glide.settings.classes.swipeable);\n  });\n  /**\n   * Remove swiping bindings:\n   * - on destroying, to remove added EventListeners\n   */\n\n  Events.on('destroy', function () {\n    Swipe.unbindSwipeStart();\n    Swipe.unbindSwipeMove();\n    Swipe.unbindSwipeEnd();\n    Binder.destroy();\n  });\n  return Swipe;\n}\n\nfunction Images(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Images = {\n    /**\n     * Binds listener to glide wrapper.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.bind();\n    },\n\n    /**\n     * Binds `dragstart` event on wrapper to prevent dragging images.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('dragstart', Components.Html.wrapper, this.dragstart);\n    },\n\n    /**\n     * Unbinds `dragstart` event on wrapper.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('dragstart', Components.Html.wrapper);\n    },\n\n    /**\n     * Event handler. Prevents dragging.\n     *\n     * @return {Void}\n     */\n    dragstart: function dragstart(event) {\n      event.preventDefault();\n    }\n  };\n  /**\n   * Remove bindings from images:\n   * - on destroying, to remove added EventListeners\n   */\n\n  Events.on('destroy', function () {\n    Images.unbind();\n    Binder.destroy();\n  });\n  return Images;\n}\n\nfunction Anchors(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  /**\n   * Holds detaching status of anchors.\n   * Prevents detaching of already detached anchors.\n   *\n   * @private\n   * @type {Boolean}\n   */\n\n  var detached = false;\n  /**\n   * Holds preventing status of anchors.\n   * If `true` redirection after click will be disabled.\n   *\n   * @private\n   * @type {Boolean}\n   */\n\n  var prevented = false;\n  var Anchors = {\n    /**\n     * Setups a initial state of anchors component.\n     *\n     * @returns {Void}\n     */\n    mount: function mount() {\n      /**\n       * Holds collection of anchors elements.\n       *\n       * @private\n       * @type {HTMLCollection}\n       */\n      this._a = Components.Html.wrapper.querySelectorAll('a');\n      this.bind();\n    },\n\n    /**\n     * Binds events to anchors inside a track.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('click', Components.Html.wrapper, this.click);\n    },\n\n    /**\n     * Unbinds events attached to anchors inside a track.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('click', Components.Html.wrapper);\n    },\n\n    /**\n     * Handler for click event. Prevents clicks when glide is in `prevent` status.\n     *\n     * @param  {Object} event\n     * @return {Void}\n     */\n    click: function click(event) {\n      if (prevented) {\n        event.stopPropagation();\n        event.preventDefault();\n      }\n    },\n\n    /**\n     * Detaches anchors click event inside glide.\n     *\n     * @return {self}\n     */\n    detach: function detach() {\n      prevented = true;\n\n      if (!detached) {\n        for (var i = 0; i < this.items.length; i++) {\n          this.items[i].draggable = false;\n          this.items[i].setAttribute('data-href', this.items[i].getAttribute('href'));\n          this.items[i].removeAttribute('href');\n        }\n\n        detached = true;\n      }\n\n      return this;\n    },\n\n    /**\n     * Attaches anchors click events inside glide.\n     *\n     * @return {self}\n     */\n    attach: function attach() {\n      prevented = false;\n\n      if (detached) {\n        for (var i = 0; i < this.items.length; i++) {\n          this.items[i].draggable = true;\n          this.items[i].setAttribute('href', this.items[i].getAttribute('data-href'));\n        }\n\n        detached = false;\n      }\n\n      return this;\n    }\n  };\n  define(Anchors, 'items', {\n    /**\n     * Gets collection of the arrows HTML elements.\n     *\n     * @return {HTMLElement[]}\n     */\n    get: function get() {\n      return Anchors._a;\n    }\n  });\n  /**\n   * Detach anchors inside slides:\n   * - on swiping, so they won't redirect to its `href` attributes\n   */\n\n  Events.on('swipe.move', function () {\n    Anchors.detach();\n  });\n  /**\n   * Attach anchors inside slides:\n   * - after swiping and transitions ends, so they can redirect after click again\n   */\n\n  Events.on('swipe.end', function () {\n    Components.Transition.after(function () {\n      Anchors.attach();\n    });\n  });\n  /**\n   * Unbind anchors inside slides:\n   * - on destroying, to bring anchors to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Anchors.attach();\n    Anchors.unbind();\n    Binder.destroy();\n  });\n  return Anchors;\n}\n\nvar NAV_SELECTOR = '[data-glide-el=\"controls[nav]\"]';\nvar CONTROLS_SELECTOR = '[data-glide-el^=\"controls\"]';\n\nfunction Controls(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var capture = supportsPassive$1 ? {\n    passive: true\n  } : false;\n  var Controls = {\n    /**\n     * Inits arrows. Binds events listeners\n     * to the arrows HTML elements.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      /**\n       * Collection of navigation HTML elements.\n       *\n       * @private\n       * @type {HTMLCollection}\n       */\n      this._n = Components.Html.root.querySelectorAll(NAV_SELECTOR);\n      /**\n       * Collection of controls HTML elements.\n       *\n       * @private\n       * @type {HTMLCollection}\n       */\n\n      this._c = Components.Html.root.querySelectorAll(CONTROLS_SELECTOR);\n      this.addBindings();\n    },\n\n    /**\n     * Sets active class to current slide.\n     *\n     * @return {Void}\n     */\n    setActive: function setActive() {\n      for (var i = 0; i < this._n.length; i++) {\n        this.addClass(this._n[i].children);\n      }\n    },\n\n    /**\n     * Removes active class to current slide.\n     *\n     * @return {Void}\n     */\n    removeActive: function removeActive() {\n      for (var i = 0; i < this._n.length; i++) {\n        this.removeClass(this._n[i].children);\n      }\n    },\n\n    /**\n     * Toggles active class on items inside navigation.\n     *\n     * @param  {HTMLElement} controls\n     * @return {Void}\n     */\n    addClass: function addClass(controls) {\n      var settings = Glide.settings;\n      var item = controls[Glide.index];\n\n      if (item) {\n        item.classList.add(settings.classes.activeNav);\n        siblings(item).forEach(function (sibling) {\n          sibling.classList.remove(settings.classes.activeNav);\n        });\n      }\n    },\n\n    /**\n     * Removes active class from active control.\n     *\n     * @param  {HTMLElement} controls\n     * @return {Void}\n     */\n    removeClass: function removeClass(controls) {\n      var item = controls[Glide.index];\n\n      if (item) {\n        item.classList.remove(Glide.settings.classes.activeNav);\n      }\n    },\n\n    /**\n     * Adds handles to the each group of controls.\n     *\n     * @return {Void}\n     */\n    addBindings: function addBindings() {\n      for (var i = 0; i < this._c.length; i++) {\n        this.bind(this._c[i].children);\n      }\n    },\n\n    /**\n     * Removes handles from the each group of controls.\n     *\n     * @return {Void}\n     */\n    removeBindings: function removeBindings() {\n      for (var i = 0; i < this._c.length; i++) {\n        this.unbind(this._c[i].children);\n      }\n    },\n\n    /**\n     * Binds events to arrows HTML elements.\n     *\n     * @param {HTMLCollection} elements\n     * @return {Void}\n     */\n    bind: function bind(elements) {\n      for (var i = 0; i < elements.length; i++) {\n        Binder.on('click', elements[i], this.click);\n        Binder.on('touchstart', elements[i], this.click, capture);\n      }\n    },\n\n    /**\n     * Unbinds events binded to the arrows HTML elements.\n     *\n     * @param {HTMLCollection} elements\n     * @return {Void}\n     */\n    unbind: function unbind(elements) {\n      for (var i = 0; i < elements.length; i++) {\n        Binder.off(['click', 'touchstart'], elements[i]);\n      }\n    },\n\n    /**\n     * Handles `click` event on the arrows HTML elements.\n     * Moves slider in driection precised in\n     * `data-glide-dir` attribute.\n     *\n     * @param {Object} event\n     * @return {Void}\n     */\n    click: function click(event) {\n      event.preventDefault();\n      Components.Run.make(Components.Direction.resolve(event.currentTarget.getAttribute('data-glide-dir')));\n    }\n  };\n  define(Controls, 'items', {\n    /**\n     * Gets collection of the controls HTML elements.\n     *\n     * @return {HTMLElement[]}\n     */\n    get: function get() {\n      return Controls._c;\n    }\n  });\n  /**\n   * Swap active class of current navigation item:\n   * - after mounting to set it to initial index\n   * - after each move to the new index\n   */\n\n  Events.on(['mount.after', 'move.after'], function () {\n    Controls.setActive();\n  });\n  /**\n   * Remove bindings and HTML Classes:\n   * - on destroying, to bring markup to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Controls.removeBindings();\n    Controls.removeActive();\n    Binder.destroy();\n  });\n  return Controls;\n}\n\nfunction Keyboard(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Keyboard = {\n    /**\n     * Binds keyboard events on component mount.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      if (Glide.settings.keyboard) {\n        this.bind();\n      }\n    },\n\n    /**\n     * Adds keyboard press events.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      Binder.on('keyup', document, this.press);\n    },\n\n    /**\n     * Removes keyboard press events.\n     *\n     * @return {Void}\n     */\n    unbind: function unbind() {\n      Binder.off('keyup', document);\n    },\n\n    /**\n     * Handles keyboard's arrows press and moving glide foward and backward.\n     *\n     * @param  {Object} event\n     * @return {Void}\n     */\n    press: function press(event) {\n      if (event.keyCode === 39) {\n        Components.Run.make(Components.Direction.resolve('>'));\n      }\n\n      if (event.keyCode === 37) {\n        Components.Run.make(Components.Direction.resolve('<'));\n      }\n    }\n  };\n  /**\n   * Remove bindings from keyboard:\n   * - on destroying to remove added events\n   * - on updating to remove events before remounting\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Keyboard.unbind();\n  });\n  /**\n   * Remount component\n   * - on updating to reflect potential changes in settings\n   */\n\n  Events.on('update', function () {\n    Keyboard.mount();\n  });\n  /**\n   * Destroy binder:\n   * - on destroying to remove listeners\n   */\n\n  Events.on('destroy', function () {\n    Binder.destroy();\n  });\n  return Keyboard;\n}\n\nfunction Autoplay(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  var Autoplay = {\n    /**\n     * Initializes autoplaying and events.\n     *\n     * @return {Void}\n     */\n    mount: function mount() {\n      this.start();\n\n      if (Glide.settings.hoverpause) {\n        this.bind();\n      }\n    },\n\n    /**\n     * Starts autoplaying in configured interval.\n     *\n     * @param {Boolean|Number} force Run autoplaying with passed interval regardless of `autoplay` settings\n     * @return {Void}\n     */\n    start: function start() {\n      var _this = this;\n\n      if (Glide.settings.autoplay) {\n        if (isUndefined(this._i)) {\n          this._i = setInterval(function () {\n            _this.stop();\n\n            Components.Run.make('>');\n\n            _this.start();\n          }, this.time);\n        }\n      }\n    },\n\n    /**\n     * Stops autorunning of the glide.\n     *\n     * @return {Void}\n     */\n    stop: function stop() {\n      this._i = clearInterval(this._i);\n    },\n\n    /**\n     * Stops autoplaying while mouse is over glide's area.\n     *\n     * @return {Void}\n     */\n    bind: function bind() {\n      var _this2 = this;\n\n      Binder.on('mouseover', Components.Html.root, function () {\n        _this2.stop();\n      });\n      Binder.on('mouseout', Components.Html.root, function () {\n        _this2.start();\n      });\n    },\n\n    /**\n     * Unbind mouseover events.\n     *\n     * @returns {Void}\n     */\n    unbind: function unbind() {\n      Binder.off(['mouseover', 'mouseout'], Components.Html.root);\n    }\n  };\n  define(Autoplay, 'time', {\n    /**\n     * Gets time period value for the autoplay interval. Prioritizes\n     * times in `data-glide-autoplay` attrubutes over options.\n     *\n     * @return {Number}\n     */\n    get: function get() {\n      var autoplay = Components.Html.slides[Glide.index].getAttribute('data-glide-autoplay');\n\n      if (autoplay) {\n        return toInt(autoplay);\n      }\n\n      return toInt(Glide.settings.autoplay);\n    }\n  });\n  /**\n   * Stop autoplaying and unbind events:\n   * - on destroying, to clear defined interval\n   * - on updating via API to reset interval that may changed\n   */\n\n  Events.on(['destroy', 'update'], function () {\n    Autoplay.unbind();\n  });\n  /**\n   * Stop autoplaying:\n   * - before each run, to restart autoplaying\n   * - on pausing via API\n   * - on destroying, to clear defined interval\n   * - while starting a swipe\n   * - on updating via API to reset interval that may changed\n   */\n\n  Events.on(['run.before', 'pause', 'destroy', 'swipe.start', 'update'], function () {\n    Autoplay.stop();\n  });\n  /**\n   * Start autoplaying:\n   * - after each run, to restart autoplaying\n   * - on playing via API\n   * - while ending a swipe\n   */\n\n  Events.on(['run.after', 'play', 'swipe.end'], function () {\n    Autoplay.start();\n  });\n  /**\n   * Remount autoplaying:\n   * - on updating via API to reset interval that may changed\n   */\n\n  Events.on('update', function () {\n    Autoplay.mount();\n  });\n  /**\n   * Destroy a binder:\n   * - on destroying glide instance to clearup listeners\n   */\n\n  Events.on('destroy', function () {\n    Binder.destroy();\n  });\n  return Autoplay;\n}\n/**\n * Sorts keys of breakpoint object so they will be ordered from lower to bigger.\n *\n * @param {Object} points\n * @returns {Object}\n */\n\n\nfunction sortBreakpoints(points) {\n  if (isObject(points)) {\n    return sortKeys(points);\n  } else {\n    warn('Breakpoints option must be an object');\n  }\n\n  return {};\n}\n\nfunction Breakpoints(Glide, Components, Events) {\n  /**\n   * Instance of the binder for DOM Events.\n   *\n   * @type {EventsBinder}\n   */\n  var Binder = new EventsBinder();\n  /**\n   * Holds reference to settings.\n   *\n   * @type {Object}\n   */\n\n  var settings = Glide.settings;\n  /**\n   * Holds reference to breakpoints object in settings. Sorts breakpoints\n   * from smaller to larger. It is required in order to proper\n   * matching currently active breakpoint settings.\n   *\n   * @type {Object}\n   */\n\n  var points = sortBreakpoints(settings.breakpoints);\n  /**\n   * Cache initial settings before overwritting.\n   *\n   * @type {Object}\n   */\n\n  var defaults = _extends({}, settings);\n\n  var Breakpoints = {\n    /**\n     * Matches settings for currectly matching media breakpoint.\n     *\n     * @param {Object} points\n     * @returns {Object}\n     */\n    match: function match(points) {\n      if (typeof window.matchMedia !== 'undefined') {\n        for (var point in points) {\n          if (points.hasOwnProperty(point)) {\n            if (window.matchMedia('(max-width: ' + point + 'px)').matches) {\n              return points[point];\n            }\n          }\n        }\n      }\n\n      return defaults;\n    }\n  };\n  /**\n   * Overwrite instance settings with currently matching breakpoint settings.\n   * This happens right after component initialization.\n   */\n\n  _extends(settings, Breakpoints.match(points));\n  /**\n   * Update glide with settings of matched brekpoint:\n   * - window resize to update slider\n   */\n\n\n  Binder.on('resize', window, throttle(function () {\n    Glide.settings = mergeOptions(settings, Breakpoints.match(points));\n  }, Glide.settings.throttle));\n  /**\n   * Resort and update default settings:\n   * - on reinit via API, so breakpoint matching will be performed with options\n   */\n\n  Events.on('update', function () {\n    points = sortBreakpoints(points);\n    defaults = _extends({}, settings);\n  });\n  /**\n   * Unbind resize listener:\n   * - on destroying, to bring markup to its initial state\n   */\n\n  Events.on('destroy', function () {\n    Binder.off('resize', window);\n  });\n  return Breakpoints;\n}\n\nvar COMPONENTS = {\n  // Required\n  Html: Html,\n  Translate: Translate,\n  Transition: Transition,\n  Direction: Direction,\n  Peek: Peek,\n  Sizes: Sizes,\n  Gaps: Gaps,\n  Move: Move,\n  Clones: Clones,\n  Resize: Resize,\n  Build: Build,\n  Run: Run,\n  // Optional\n  Swipe: Swipe,\n  Images: Images,\n  Anchors: Anchors,\n  Controls: Controls,\n  Keyboard: Keyboard,\n  Autoplay: Autoplay,\n  Breakpoints: Breakpoints\n};\n\nvar Glide$1 = function (_Core) {\n  inherits(Glide$$1, _Core);\n\n  function Glide$$1() {\n    classCallCheck(this, Glide$$1);\n    return possibleConstructorReturn(this, (Glide$$1.__proto__ || Object.getPrototypeOf(Glide$$1)).apply(this, arguments));\n  }\n\n  createClass(Glide$$1, [{\n    key: 'mount',\n    value: function mount() {\n      var extensions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n      return get(Glide$$1.prototype.__proto__ || Object.getPrototypeOf(Glide$$1.prototype), 'mount', this).call(this, _extends({}, COMPONENTS, extensions));\n    }\n  }]);\n  return Glide$$1;\n}(Glide);\n\nexport default Glide$1;","module.exports = function (module) {\n  if (!module.webpackPolyfill) {\n    module.deprecate = function () {};\n\n    module.paths = []; // module.parent = undefined by default\n\n    if (!module.children) module.children = [];\n    Object.defineProperty(module, \"loaded\", {\n      enumerable: true,\n      get: function get() {\n        return module.l;\n      }\n    });\n    Object.defineProperty(module, \"id\", {\n      enumerable: true,\n      get: function get() {\n        return module.i;\n      }\n    });\n    module.webpackPolyfill = 1;\n  }\n\n  return module;\n};","// This file is automatically compiled by Webpack, along with any other files\n// present in this directory. You're encouraged to place your actual application logic in\n// a relevant structure within app/javascript and only use these pack files to reference\n// that code so it'll be compiled.\n\nrequire(\"@rails/ujs\").start()\nrequire(\"@rails/activestorage\").start()\nrequire(\"channels\")\nglobal.$ = require('jquery')\nwindow.jQuery = $;\nwindow.$ = $;\n\nimport Glide from '@glidejs/glide'\n\n\ndocument.addEventListener(\"DOMContentLoaded\", function() {\n\n    $('.form_with_ok_modal').on(\"successed\", function (e) {\n        $(this).parent().find(\"#modal_form_successed\").modal(\"show\");\n    });\n\n    var mainCarousel = new Glide('.glide_carousel', {\n        type: 'carousel',\n        perView: 1,\n        autoplay: 5000\n    })\n\n    var refList = new Glide('.glide_ref_list', {\n        type: 'carousel',\n        perView: 1,\n        autoplay: 5000\n    })\n\n    mainCarousel.mount()\n    refList.mount()\n});\n","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar g; // This works in non-strict mode\n\ng = function () {\n  return this;\n}();\n\ntry {\n  // This works if eval is allowed (see CSP)\n  g = g || new Function(\"return this\")();\n} catch (e) {\n  // This works if the window reference is available\n  if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) === \"object\") g = window;\n} // g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\n\nmodule.exports = g;","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*\nUnobtrusive JavaScript\nhttps://github.com/rails/rails/blob/main/actionview/app/assets/javascripts\nReleased under the MIT license\n */\n;\n(function () {\n  var context = this;\n  (function () {\n    (function () {\n      this.Rails = {\n        linkClickSelector: 'a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]',\n        buttonClickSelector: {\n          selector: 'button[data-remote]:not([form]), button[data-confirm]:not([form])',\n          exclude: 'form button'\n        },\n        inputChangeSelector: 'select[data-remote], input[data-remote], textarea[data-remote]',\n        formSubmitSelector: 'form',\n        formInputClickSelector: 'form input[type=submit], form input[type=image], form button[type=submit], form button:not([type]), input[type=submit][form], input[type=image][form], button[type=submit][form], button[form]:not([type])',\n        formDisableSelector: 'input[data-disable-with]:enabled, button[data-disable-with]:enabled, textarea[data-disable-with]:enabled, input[data-disable]:enabled, button[data-disable]:enabled, textarea[data-disable]:enabled',\n        formEnableSelector: 'input[data-disable-with]:disabled, button[data-disable-with]:disabled, textarea[data-disable-with]:disabled, input[data-disable]:disabled, button[data-disable]:disabled, textarea[data-disable]:disabled',\n        fileInputSelector: 'input[name][type=file]:not([disabled])',\n        linkDisableSelector: 'a[data-disable-with], a[data-disable]',\n        buttonDisableSelector: 'button[data-remote][data-disable-with], button[data-remote][data-disable]'\n      };\n    }).call(this);\n  }).call(context);\n  var Rails = context.Rails;\n  (function () {\n    (function () {\n      var nonce;\n      nonce = null;\n\n      Rails.loadCSPNonce = function () {\n        var ref;\n        return nonce = (ref = document.querySelector(\"meta[name=csp-nonce]\")) != null ? ref.content : void 0;\n      };\n\n      Rails.cspNonce = function () {\n        return nonce != null ? nonce : Rails.loadCSPNonce();\n      };\n    }).call(this);\n    (function () {\n      var expando, m;\n      m = Element.prototype.matches || Element.prototype.matchesSelector || Element.prototype.mozMatchesSelector || Element.prototype.msMatchesSelector || Element.prototype.oMatchesSelector || Element.prototype.webkitMatchesSelector;\n\n      Rails.matches = function (element, selector) {\n        if (selector.exclude != null) {\n          return m.call(element, selector.selector) && !m.call(element, selector.exclude);\n        } else {\n          return m.call(element, selector);\n        }\n      };\n\n      expando = '_ujsData';\n\n      Rails.getData = function (element, key) {\n        var ref;\n        return (ref = element[expando]) != null ? ref[key] : void 0;\n      };\n\n      Rails.setData = function (element, key, value) {\n        if (element[expando] == null) {\n          element[expando] = {};\n        }\n\n        return element[expando][key] = value;\n      };\n\n      Rails.$ = function (selector) {\n        return Array.prototype.slice.call(document.querySelectorAll(selector));\n      };\n    }).call(this);\n    (function () {\n      var $, csrfParam, csrfToken;\n      $ = Rails.$;\n\n      csrfToken = Rails.csrfToken = function () {\n        var meta;\n        meta = document.querySelector('meta[name=csrf-token]');\n        return meta && meta.content;\n      };\n\n      csrfParam = Rails.csrfParam = function () {\n        var meta;\n        meta = document.querySelector('meta[name=csrf-param]');\n        return meta && meta.content;\n      };\n\n      Rails.CSRFProtection = function (xhr) {\n        var token;\n        token = csrfToken();\n\n        if (token != null) {\n          return xhr.setRequestHeader('X-CSRF-Token', token);\n        }\n      };\n\n      Rails.refreshCSRFTokens = function () {\n        var param, token;\n        token = csrfToken();\n        param = csrfParam();\n\n        if (token != null && param != null) {\n          return $('form input[name=\"' + param + '\"]').forEach(function (input) {\n            return input.value = token;\n          });\n        }\n      };\n    }).call(this);\n    (function () {\n      var CustomEvent, fire, matches, preventDefault;\n      matches = Rails.matches;\n      CustomEvent = window.CustomEvent;\n\n      if (typeof CustomEvent !== 'function') {\n        CustomEvent = function CustomEvent(event, params) {\n          var evt;\n          evt = document.createEvent('CustomEvent');\n          evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);\n          return evt;\n        };\n\n        CustomEvent.prototype = window.Event.prototype;\n        preventDefault = CustomEvent.prototype.preventDefault;\n\n        CustomEvent.prototype.preventDefault = function () {\n          var result;\n          result = preventDefault.call(this);\n\n          if (this.cancelable && !this.defaultPrevented) {\n            Object.defineProperty(this, 'defaultPrevented', {\n              get: function get() {\n                return true;\n              }\n            });\n          }\n\n          return result;\n        };\n      }\n\n      fire = Rails.fire = function (obj, name, data) {\n        var event;\n        event = new CustomEvent(name, {\n          bubbles: true,\n          cancelable: true,\n          detail: data\n        });\n        obj.dispatchEvent(event);\n        return !event.defaultPrevented;\n      };\n\n      Rails.stopEverything = function (e) {\n        fire(e.target, 'ujs:everythingStopped');\n        e.preventDefault();\n        e.stopPropagation();\n        return e.stopImmediatePropagation();\n      };\n\n      Rails.delegate = function (element, selector, eventType, handler) {\n        return element.addEventListener(eventType, function (e) {\n          var target;\n          target = e.target;\n\n          while (!(!(target instanceof Element) || matches(target, selector))) {\n            target = target.parentNode;\n          }\n\n          if (target instanceof Element && handler.call(target, e) === false) {\n            e.preventDefault();\n            return e.stopPropagation();\n          }\n        });\n      };\n    }).call(this);\n    (function () {\n      var AcceptHeaders, CSRFProtection, createXHR, cspNonce, fire, prepareOptions, processResponse;\n      cspNonce = Rails.cspNonce, CSRFProtection = Rails.CSRFProtection, fire = Rails.fire;\n      AcceptHeaders = {\n        '*': '*/*',\n        text: 'text/plain',\n        html: 'text/html',\n        xml: 'application/xml, text/xml',\n        json: 'application/json, text/javascript',\n        script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript'\n      };\n\n      Rails.ajax = function (options) {\n        var xhr;\n        options = prepareOptions(options);\n        xhr = createXHR(options, function () {\n          var ref, response;\n          response = processResponse((ref = xhr.response) != null ? ref : xhr.responseText, xhr.getResponseHeader('Content-Type'));\n\n          if (Math.floor(xhr.status / 100) === 2) {\n            if (typeof options.success === \"function\") {\n              options.success(response, xhr.statusText, xhr);\n            }\n          } else {\n            if (typeof options.error === \"function\") {\n              options.error(response, xhr.statusText, xhr);\n            }\n          }\n\n          return typeof options.complete === \"function\" ? options.complete(xhr, xhr.statusText) : void 0;\n        });\n\n        if (options.beforeSend != null && !options.beforeSend(xhr, options)) {\n          return false;\n        }\n\n        if (xhr.readyState === XMLHttpRequest.OPENED) {\n          return xhr.send(options.data);\n        }\n      };\n\n      prepareOptions = function prepareOptions(options) {\n        options.url = options.url || location.href;\n        options.type = options.type.toUpperCase();\n\n        if (options.type === 'GET' && options.data) {\n          if (options.url.indexOf('?') < 0) {\n            options.url += '?' + options.data;\n          } else {\n            options.url += '&' + options.data;\n          }\n        }\n\n        if (AcceptHeaders[options.dataType] == null) {\n          options.dataType = '*';\n        }\n\n        options.accept = AcceptHeaders[options.dataType];\n\n        if (options.dataType !== '*') {\n          options.accept += ', */*; q=0.01';\n        }\n\n        return options;\n      };\n\n      createXHR = function createXHR(options, done) {\n        var xhr;\n        xhr = new XMLHttpRequest();\n        xhr.open(options.type, options.url, true);\n        xhr.setRequestHeader('Accept', options.accept);\n\n        if (typeof options.data === 'string') {\n          xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');\n        }\n\n        if (!options.crossDomain) {\n          xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');\n          CSRFProtection(xhr);\n        }\n\n        xhr.withCredentials = !!options.withCredentials;\n\n        xhr.onreadystatechange = function () {\n          if (xhr.readyState === XMLHttpRequest.DONE) {\n            return done(xhr);\n          }\n        };\n\n        return xhr;\n      };\n\n      processResponse = function processResponse(response, type) {\n        var parser, script;\n\n        if (typeof response === 'string' && typeof type === 'string') {\n          if (type.match(/\\bjson\\b/)) {\n            try {\n              response = JSON.parse(response);\n            } catch (error) {}\n          } else if (type.match(/\\b(?:java|ecma)script\\b/)) {\n            script = document.createElement('script');\n            script.setAttribute('nonce', cspNonce());\n            script.text = response;\n            document.head.appendChild(script).parentNode.removeChild(script);\n          } else if (type.match(/\\b(xml|html|svg)\\b/)) {\n            parser = new DOMParser();\n            type = type.replace(/;.+/, '');\n\n            try {\n              response = parser.parseFromString(response, type);\n            } catch (error) {}\n          }\n        }\n\n        return response;\n      };\n\n      Rails.href = function (element) {\n        return element.href;\n      };\n\n      Rails.isCrossDomain = function (url) {\n        var e, originAnchor, urlAnchor;\n        originAnchor = document.createElement('a');\n        originAnchor.href = location.href;\n        urlAnchor = document.createElement('a');\n\n        try {\n          urlAnchor.href = url;\n          return !((!urlAnchor.protocol || urlAnchor.protocol === ':') && !urlAnchor.host || originAnchor.protocol + '//' + originAnchor.host === urlAnchor.protocol + '//' + urlAnchor.host);\n        } catch (error) {\n          e = error;\n          return true;\n        }\n      };\n    }).call(this);\n    (function () {\n      var matches, toArray;\n      matches = Rails.matches;\n\n      toArray = function toArray(e) {\n        return Array.prototype.slice.call(e);\n      };\n\n      Rails.serializeElement = function (element, additionalParam) {\n        var inputs, params;\n        inputs = [element];\n\n        if (matches(element, 'form')) {\n          inputs = toArray(element.elements);\n        }\n\n        params = [];\n        inputs.forEach(function (input) {\n          if (!input.name || input.disabled) {\n            return;\n          }\n\n          if (matches(input, 'fieldset[disabled] *')) {\n            return;\n          }\n\n          if (matches(input, 'select')) {\n            return toArray(input.options).forEach(function (option) {\n              if (option.selected) {\n                return params.push({\n                  name: input.name,\n                  value: option.value\n                });\n              }\n            });\n          } else if (input.checked || ['radio', 'checkbox', 'submit'].indexOf(input.type) === -1) {\n            return params.push({\n              name: input.name,\n              value: input.value\n            });\n          }\n        });\n\n        if (additionalParam) {\n          params.push(additionalParam);\n        }\n\n        return params.map(function (param) {\n          if (param.name != null) {\n            return encodeURIComponent(param.name) + \"=\" + encodeURIComponent(param.value);\n          } else {\n            return param;\n          }\n        }).join('&');\n      };\n\n      Rails.formElements = function (form, selector) {\n        if (matches(form, 'form')) {\n          return toArray(form.elements).filter(function (el) {\n            return matches(el, selector);\n          });\n        } else {\n          return toArray(form.querySelectorAll(selector));\n        }\n      };\n    }).call(this);\n    (function () {\n      var allowAction, fire, stopEverything;\n      fire = Rails.fire, stopEverything = Rails.stopEverything;\n\n      Rails.handleConfirm = function (e) {\n        if (!allowAction(this)) {\n          return stopEverything(e);\n        }\n      };\n\n      Rails.confirm = function (message, element) {\n        return confirm(message);\n      };\n\n      allowAction = function allowAction(element) {\n        var answer, callback, message;\n        message = element.getAttribute('data-confirm');\n\n        if (!message) {\n          return true;\n        }\n\n        answer = false;\n\n        if (fire(element, 'confirm')) {\n          try {\n            answer = Rails.confirm(message, element);\n          } catch (error) {}\n\n          callback = fire(element, 'confirm:complete', [answer]);\n        }\n\n        return answer && callback;\n      };\n    }).call(this);\n    (function () {\n      var disableFormElement, disableFormElements, disableLinkElement, enableFormElement, enableFormElements, enableLinkElement, formElements, getData, isXhrRedirect, matches, setData, stopEverything;\n      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, stopEverything = Rails.stopEverything, formElements = Rails.formElements;\n\n      Rails.handleDisabledElement = function (e) {\n        var element;\n        element = this;\n\n        if (element.disabled) {\n          return stopEverything(e);\n        }\n      };\n\n      Rails.enableElement = function (e) {\n        var element;\n\n        if (e instanceof Event) {\n          if (isXhrRedirect(e)) {\n            return;\n          }\n\n          element = e.target;\n        } else {\n          element = e;\n        }\n\n        if (matches(element, Rails.linkDisableSelector)) {\n          return enableLinkElement(element);\n        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formEnableSelector)) {\n          return enableFormElement(element);\n        } else if (matches(element, Rails.formSubmitSelector)) {\n          return enableFormElements(element);\n        }\n      };\n\n      Rails.disableElement = function (e) {\n        var element;\n        element = e instanceof Event ? e.target : e;\n\n        if (matches(element, Rails.linkDisableSelector)) {\n          return disableLinkElement(element);\n        } else if (matches(element, Rails.buttonDisableSelector) || matches(element, Rails.formDisableSelector)) {\n          return disableFormElement(element);\n        } else if (matches(element, Rails.formSubmitSelector)) {\n          return disableFormElements(element);\n        }\n      };\n\n      disableLinkElement = function disableLinkElement(element) {\n        var replacement;\n\n        if (getData(element, 'ujs:disabled')) {\n          return;\n        }\n\n        replacement = element.getAttribute('data-disable-with');\n\n        if (replacement != null) {\n          setData(element, 'ujs:enable-with', element.innerHTML);\n          element.innerHTML = replacement;\n        }\n\n        element.addEventListener('click', stopEverything);\n        return setData(element, 'ujs:disabled', true);\n      };\n\n      enableLinkElement = function enableLinkElement(element) {\n        var originalText;\n        originalText = getData(element, 'ujs:enable-with');\n\n        if (originalText != null) {\n          element.innerHTML = originalText;\n          setData(element, 'ujs:enable-with', null);\n        }\n\n        element.removeEventListener('click', stopEverything);\n        return setData(element, 'ujs:disabled', null);\n      };\n\n      disableFormElements = function disableFormElements(form) {\n        return formElements(form, Rails.formDisableSelector).forEach(disableFormElement);\n      };\n\n      disableFormElement = function disableFormElement(element) {\n        var replacement;\n\n        if (getData(element, 'ujs:disabled')) {\n          return;\n        }\n\n        replacement = element.getAttribute('data-disable-with');\n\n        if (replacement != null) {\n          if (matches(element, 'button')) {\n            setData(element, 'ujs:enable-with', element.innerHTML);\n            element.innerHTML = replacement;\n          } else {\n            setData(element, 'ujs:enable-with', element.value);\n            element.value = replacement;\n          }\n        }\n\n        element.disabled = true;\n        return setData(element, 'ujs:disabled', true);\n      };\n\n      enableFormElements = function enableFormElements(form) {\n        return formElements(form, Rails.formEnableSelector).forEach(enableFormElement);\n      };\n\n      enableFormElement = function enableFormElement(element) {\n        var originalText;\n        originalText = getData(element, 'ujs:enable-with');\n\n        if (originalText != null) {\n          if (matches(element, 'button')) {\n            element.innerHTML = originalText;\n          } else {\n            element.value = originalText;\n          }\n\n          setData(element, 'ujs:enable-with', null);\n        }\n\n        element.disabled = false;\n        return setData(element, 'ujs:disabled', null);\n      };\n\n      isXhrRedirect = function isXhrRedirect(event) {\n        var ref, xhr;\n        xhr = (ref = event.detail) != null ? ref[0] : void 0;\n        return (xhr != null ? xhr.getResponseHeader(\"X-Xhr-Redirect\") : void 0) != null;\n      };\n    }).call(this);\n    (function () {\n      var stopEverything;\n      stopEverything = Rails.stopEverything;\n\n      Rails.handleMethod = function (e) {\n        var csrfParam, csrfToken, form, formContent, href, link, method;\n        link = this;\n        method = link.getAttribute('data-method');\n\n        if (!method) {\n          return;\n        }\n\n        href = Rails.href(link);\n        csrfToken = Rails.csrfToken();\n        csrfParam = Rails.csrfParam();\n        form = document.createElement('form');\n        formContent = \"<input name='_method' value='\" + method + \"' type='hidden' />\";\n\n        if (csrfParam != null && csrfToken != null && !Rails.isCrossDomain(href)) {\n          formContent += \"<input name='\" + csrfParam + \"' value='\" + csrfToken + \"' type='hidden' />\";\n        }\n\n        formContent += '<input type=\"submit\" />';\n        form.method = 'post';\n        form.action = href;\n        form.target = link.target;\n        form.innerHTML = formContent;\n        form.style.display = 'none';\n        document.body.appendChild(form);\n        form.querySelector('[type=\"submit\"]').click();\n        return stopEverything(e);\n      };\n    }).call(this);\n    (function () {\n      var ajax,\n          fire,\n          getData,\n          isCrossDomain,\n          isRemote,\n          matches,\n          serializeElement,\n          setData,\n          stopEverything,\n          slice = [].slice;\n      matches = Rails.matches, getData = Rails.getData, setData = Rails.setData, fire = Rails.fire, stopEverything = Rails.stopEverything, ajax = Rails.ajax, isCrossDomain = Rails.isCrossDomain, serializeElement = Rails.serializeElement;\n\n      isRemote = function isRemote(element) {\n        var value;\n        value = element.getAttribute('data-remote');\n        return value != null && value !== 'false';\n      };\n\n      Rails.handleRemote = function (e) {\n        var button, data, dataType, element, method, url, withCredentials;\n        element = this;\n\n        if (!isRemote(element)) {\n          return true;\n        }\n\n        if (!fire(element, 'ajax:before')) {\n          fire(element, 'ajax:stopped');\n          return false;\n        }\n\n        withCredentials = element.getAttribute('data-with-credentials');\n        dataType = element.getAttribute('data-type') || 'script';\n\n        if (matches(element, Rails.formSubmitSelector)) {\n          button = getData(element, 'ujs:submit-button');\n          method = getData(element, 'ujs:submit-button-formmethod') || element.method;\n          url = getData(element, 'ujs:submit-button-formaction') || element.getAttribute('action') || location.href;\n\n          if (method.toUpperCase() === 'GET') {\n            url = url.replace(/\\?.*$/, '');\n          }\n\n          if (element.enctype === 'multipart/form-data') {\n            data = new FormData(element);\n\n            if (button != null) {\n              data.append(button.name, button.value);\n            }\n          } else {\n            data = serializeElement(element, button);\n          }\n\n          setData(element, 'ujs:submit-button', null);\n          setData(element, 'ujs:submit-button-formmethod', null);\n          setData(element, 'ujs:submit-button-formaction', null);\n        } else if (matches(element, Rails.buttonClickSelector) || matches(element, Rails.inputChangeSelector)) {\n          method = element.getAttribute('data-method');\n          url = element.getAttribute('data-url');\n          data = serializeElement(element, element.getAttribute('data-params'));\n        } else {\n          method = element.getAttribute('data-method');\n          url = Rails.href(element);\n          data = element.getAttribute('data-params');\n        }\n\n        ajax({\n          type: method || 'GET',\n          url: url,\n          data: data,\n          dataType: dataType,\n          beforeSend: function beforeSend(xhr, options) {\n            if (fire(element, 'ajax:beforeSend', [xhr, options])) {\n              return fire(element, 'ajax:send', [xhr]);\n            } else {\n              fire(element, 'ajax:stopped');\n              return false;\n            }\n          },\n          success: function success() {\n            var args;\n            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n            return fire(element, 'ajax:success', args);\n          },\n          error: function error() {\n            var args;\n            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n            return fire(element, 'ajax:error', args);\n          },\n          complete: function complete() {\n            var args;\n            args = 1 <= arguments.length ? slice.call(arguments, 0) : [];\n            return fire(element, 'ajax:complete', args);\n          },\n          crossDomain: isCrossDomain(url),\n          withCredentials: withCredentials != null && withCredentials !== 'false'\n        });\n        return stopEverything(e);\n      };\n\n      Rails.formSubmitButtonClick = function (e) {\n        var button, form;\n        button = this;\n        form = button.form;\n\n        if (!form) {\n          return;\n        }\n\n        if (button.name) {\n          setData(form, 'ujs:submit-button', {\n            name: button.name,\n            value: button.value\n          });\n        }\n\n        setData(form, 'ujs:formnovalidate-button', button.formNoValidate);\n        setData(form, 'ujs:submit-button-formaction', button.getAttribute('formaction'));\n        return setData(form, 'ujs:submit-button-formmethod', button.getAttribute('formmethod'));\n      };\n\n      Rails.preventInsignificantClick = function (e) {\n        var data, insignificantMetaClick, link, metaClick, method, nonPrimaryMouseClick;\n        link = this;\n        method = (link.getAttribute('data-method') || 'GET').toUpperCase();\n        data = link.getAttribute('data-params');\n        metaClick = e.metaKey || e.ctrlKey;\n        insignificantMetaClick = metaClick && method === 'GET' && !data;\n        nonPrimaryMouseClick = e.button != null && e.button !== 0;\n\n        if (nonPrimaryMouseClick || insignificantMetaClick) {\n          return e.stopImmediatePropagation();\n        }\n      };\n    }).call(this);\n    (function () {\n      var $, CSRFProtection, delegate, disableElement, enableElement, fire, formSubmitButtonClick, getData, handleConfirm, handleDisabledElement, handleMethod, handleRemote, loadCSPNonce, preventInsignificantClick, refreshCSRFTokens;\n      fire = Rails.fire, delegate = Rails.delegate, getData = Rails.getData, $ = Rails.$, refreshCSRFTokens = Rails.refreshCSRFTokens, CSRFProtection = Rails.CSRFProtection, loadCSPNonce = Rails.loadCSPNonce, enableElement = Rails.enableElement, disableElement = Rails.disableElement, handleDisabledElement = Rails.handleDisabledElement, handleConfirm = Rails.handleConfirm, preventInsignificantClick = Rails.preventInsignificantClick, handleRemote = Rails.handleRemote, formSubmitButtonClick = Rails.formSubmitButtonClick, handleMethod = Rails.handleMethod;\n\n      if (typeof jQuery !== \"undefined\" && jQuery !== null && jQuery.ajax != null) {\n        if (jQuery.rails) {\n          throw new Error('If you load both jquery_ujs and rails-ujs, use rails-ujs only.');\n        }\n\n        jQuery.rails = Rails;\n        jQuery.ajaxPrefilter(function (options, originalOptions, xhr) {\n          if (!options.crossDomain) {\n            return CSRFProtection(xhr);\n          }\n        });\n      }\n\n      Rails.start = function () {\n        if (window._rails_loaded) {\n          throw new Error('rails-ujs has already been loaded!');\n        }\n\n        window.addEventListener('pageshow', function () {\n          $(Rails.formEnableSelector).forEach(function (el) {\n            if (getData(el, 'ujs:disabled')) {\n              return enableElement(el);\n            }\n          });\n          return $(Rails.linkDisableSelector).forEach(function (el) {\n            if (getData(el, 'ujs:disabled')) {\n              return enableElement(el);\n            }\n          });\n        });\n        delegate(document, Rails.linkDisableSelector, 'ajax:complete', enableElement);\n        delegate(document, Rails.linkDisableSelector, 'ajax:stopped', enableElement);\n        delegate(document, Rails.buttonDisableSelector, 'ajax:complete', enableElement);\n        delegate(document, Rails.buttonDisableSelector, 'ajax:stopped', enableElement);\n        delegate(document, Rails.linkClickSelector, 'click', preventInsignificantClick);\n        delegate(document, Rails.linkClickSelector, 'click', handleDisabledElement);\n        delegate(document, Rails.linkClickSelector, 'click', handleConfirm);\n        delegate(document, Rails.linkClickSelector, 'click', disableElement);\n        delegate(document, Rails.linkClickSelector, 'click', handleRemote);\n        delegate(document, Rails.linkClickSelector, 'click', handleMethod);\n        delegate(document, Rails.buttonClickSelector, 'click', preventInsignificantClick);\n        delegate(document, Rails.buttonClickSelector, 'click', handleDisabledElement);\n        delegate(document, Rails.buttonClickSelector, 'click', handleConfirm);\n        delegate(document, Rails.buttonClickSelector, 'click', disableElement);\n        delegate(document, Rails.buttonClickSelector, 'click', handleRemote);\n        delegate(document, Rails.inputChangeSelector, 'change', handleDisabledElement);\n        delegate(document, Rails.inputChangeSelector, 'change', handleConfirm);\n        delegate(document, Rails.inputChangeSelector, 'change', handleRemote);\n        delegate(document, Rails.formSubmitSelector, 'submit', handleDisabledElement);\n        delegate(document, Rails.formSubmitSelector, 'submit', handleConfirm);\n        delegate(document, Rails.formSubmitSelector, 'submit', handleRemote);\n        delegate(document, Rails.formSubmitSelector, 'submit', function (e) {\n          return setTimeout(function () {\n            return disableElement(e);\n          }, 13);\n        });\n        delegate(document, Rails.formSubmitSelector, 'ajax:send', disableElement);\n        delegate(document, Rails.formSubmitSelector, 'ajax:complete', enableElement);\n        delegate(document, Rails.formInputClickSelector, 'click', preventInsignificantClick);\n        delegate(document, Rails.formInputClickSelector, 'click', handleDisabledElement);\n        delegate(document, Rails.formInputClickSelector, 'click', handleConfirm);\n        delegate(document, Rails.formInputClickSelector, 'click', formSubmitButtonClick);\n        document.addEventListener('DOMContentLoaded', refreshCSRFTokens);\n        document.addEventListener('DOMContentLoaded', loadCSPNonce);\n        return window._rails_loaded = true;\n      };\n\n      if (window.Rails === Rails && fire(document, 'rails:attachBindings')) {\n        Rails.start();\n      }\n    }).call(this);\n  }).call(this);\n\n  if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === \"object\" && module.exports) {\n    module.exports = Rails;\n  } else if (typeof define === \"function\" && define.amd) {\n    define(Rails);\n  }\n}).call(this);","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n(function (global, factory) {\n  (typeof exports === \"undefined\" ? \"undefined\" : _typeof(exports)) === \"object\" && typeof module !== \"undefined\" ? factory(exports) : typeof define === \"function\" && define.amd ? define([\"exports\"], factory) : factory(global.ActiveStorage = {});\n})(this, function (exports) {\n  \"use strict\";\n\n  function createCommonjsModule(fn, module) {\n    return module = {\n      exports: {}\n    }, fn(module, module.exports), module.exports;\n  }\n\n  var sparkMd5 = createCommonjsModule(function (module, exports) {\n    (function (factory) {\n      {\n        module.exports = factory();\n      }\n    })(function (undefined) {\n      var hex_chr = [\"0\", \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"a\", \"b\", \"c\", \"d\", \"e\", \"f\"];\n\n      function md5cycle(x, k) {\n        var a = x[0],\n            b = x[1],\n            c = x[2],\n            d = x[3];\n        a += (b & c | ~b & d) + k[0] - 680876936 | 0;\n        a = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[1] - 389564586 | 0;\n        d = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[2] + 606105819 | 0;\n        c = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[3] - 1044525330 | 0;\n        b = (b << 22 | b >>> 10) + c | 0;\n        a += (b & c | ~b & d) + k[4] - 176418897 | 0;\n        a = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[5] + 1200080426 | 0;\n        d = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[6] - 1473231341 | 0;\n        c = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[7] - 45705983 | 0;\n        b = (b << 22 | b >>> 10) + c | 0;\n        a += (b & c | ~b & d) + k[8] + 1770035416 | 0;\n        a = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[9] - 1958414417 | 0;\n        d = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[10] - 42063 | 0;\n        c = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[11] - 1990404162 | 0;\n        b = (b << 22 | b >>> 10) + c | 0;\n        a += (b & c | ~b & d) + k[12] + 1804603682 | 0;\n        a = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[13] - 40341101 | 0;\n        d = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[14] - 1502002290 | 0;\n        c = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[15] + 1236535329 | 0;\n        b = (b << 22 | b >>> 10) + c | 0;\n        a += (b & d | c & ~d) + k[1] - 165796510 | 0;\n        a = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[6] - 1069501632 | 0;\n        d = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[11] + 643717713 | 0;\n        c = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[0] - 373897302 | 0;\n        b = (b << 20 | b >>> 12) + c | 0;\n        a += (b & d | c & ~d) + k[5] - 701558691 | 0;\n        a = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[10] + 38016083 | 0;\n        d = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[15] - 660478335 | 0;\n        c = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[4] - 405537848 | 0;\n        b = (b << 20 | b >>> 12) + c | 0;\n        a += (b & d | c & ~d) + k[9] + 568446438 | 0;\n        a = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[14] - 1019803690 | 0;\n        d = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[3] - 187363961 | 0;\n        c = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[8] + 1163531501 | 0;\n        b = (b << 20 | b >>> 12) + c | 0;\n        a += (b & d | c & ~d) + k[13] - 1444681467 | 0;\n        a = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[2] - 51403784 | 0;\n        d = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[7] + 1735328473 | 0;\n        c = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[12] - 1926607734 | 0;\n        b = (b << 20 | b >>> 12) + c | 0;\n        a += (b ^ c ^ d) + k[5] - 378558 | 0;\n        a = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[8] - 2022574463 | 0;\n        d = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[11] + 1839030562 | 0;\n        c = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[14] - 35309556 | 0;\n        b = (b << 23 | b >>> 9) + c | 0;\n        a += (b ^ c ^ d) + k[1] - 1530992060 | 0;\n        a = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[4] + 1272893353 | 0;\n        d = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[7] - 155497632 | 0;\n        c = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[10] - 1094730640 | 0;\n        b = (b << 23 | b >>> 9) + c | 0;\n        a += (b ^ c ^ d) + k[13] + 681279174 | 0;\n        a = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[0] - 358537222 | 0;\n        d = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[3] - 722521979 | 0;\n        c = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[6] + 76029189 | 0;\n        b = (b << 23 | b >>> 9) + c | 0;\n        a += (b ^ c ^ d) + k[9] - 640364487 | 0;\n        a = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[12] - 421815835 | 0;\n        d = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[15] + 530742520 | 0;\n        c = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[2] - 995338651 | 0;\n        b = (b << 23 | b >>> 9) + c | 0;\n        a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;\n        a = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;\n        d = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;\n        c = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;\n        b = (b << 21 | b >>> 11) + c | 0;\n        a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;\n        a = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;\n        d = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;\n        c = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;\n        b = (b << 21 | b >>> 11) + c | 0;\n        a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;\n        a = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;\n        d = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;\n        c = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;\n        b = (b << 21 | b >>> 11) + c | 0;\n        a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;\n        a = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;\n        d = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;\n        c = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;\n        b = (b << 21 | b >>> 11) + c | 0;\n        x[0] = a + x[0] | 0;\n        x[1] = b + x[1] | 0;\n        x[2] = c + x[2] | 0;\n        x[3] = d + x[3] | 0;\n      }\n\n      function md5blk(s) {\n        var md5blks = [],\n            i;\n\n        for (i = 0; i < 64; i += 4) {\n          md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);\n        }\n\n        return md5blks;\n      }\n\n      function md5blk_array(a) {\n        var md5blks = [],\n            i;\n\n        for (i = 0; i < 64; i += 4) {\n          md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);\n        }\n\n        return md5blks;\n      }\n\n      function md51(s) {\n        var n = s.length,\n            state = [1732584193, -271733879, -1732584194, 271733878],\n            i,\n            length,\n            tail,\n            tmp,\n            lo,\n            hi;\n\n        for (i = 64; i <= n; i += 64) {\n          md5cycle(state, md5blk(s.substring(i - 64, i)));\n        }\n\n        s = s.substring(i - 64);\n        length = s.length;\n        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n        for (i = 0; i < length; i += 1) {\n          tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);\n        }\n\n        tail[i >> 2] |= 128 << (i % 4 << 3);\n\n        if (i > 55) {\n          md5cycle(state, tail);\n\n          for (i = 0; i < 16; i += 1) {\n            tail[i] = 0;\n          }\n        }\n\n        tmp = n * 8;\n        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n        lo = parseInt(tmp[2], 16);\n        hi = parseInt(tmp[1], 16) || 0;\n        tail[14] = lo;\n        tail[15] = hi;\n        md5cycle(state, tail);\n        return state;\n      }\n\n      function md51_array(a) {\n        var n = a.length,\n            state = [1732584193, -271733879, -1732584194, 271733878],\n            i,\n            length,\n            tail,\n            tmp,\n            lo,\n            hi;\n\n        for (i = 64; i <= n; i += 64) {\n          md5cycle(state, md5blk_array(a.subarray(i - 64, i)));\n        }\n\n        a = i - 64 < n ? a.subarray(i - 64) : new Uint8Array(0);\n        length = a.length;\n        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n        for (i = 0; i < length; i += 1) {\n          tail[i >> 2] |= a[i] << (i % 4 << 3);\n        }\n\n        tail[i >> 2] |= 128 << (i % 4 << 3);\n\n        if (i > 55) {\n          md5cycle(state, tail);\n\n          for (i = 0; i < 16; i += 1) {\n            tail[i] = 0;\n          }\n        }\n\n        tmp = n * 8;\n        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n        lo = parseInt(tmp[2], 16);\n        hi = parseInt(tmp[1], 16) || 0;\n        tail[14] = lo;\n        tail[15] = hi;\n        md5cycle(state, tail);\n        return state;\n      }\n\n      function rhex(n) {\n        var s = \"\",\n            j;\n\n        for (j = 0; j < 4; j += 1) {\n          s += hex_chr[n >> j * 8 + 4 & 15] + hex_chr[n >> j * 8 & 15];\n        }\n\n        return s;\n      }\n\n      function hex(x) {\n        var i;\n\n        for (i = 0; i < x.length; i += 1) {\n          x[i] = rhex(x[i]);\n        }\n\n        return x.join(\"\");\n      }\n\n      if (hex(md51(\"hello\")) !== \"5d41402abc4b2a76b9719d911017c592\") ;\n\n      if (typeof ArrayBuffer !== \"undefined\" && !ArrayBuffer.prototype.slice) {\n        (function () {\n          function clamp(val, length) {\n            val = val | 0 || 0;\n\n            if (val < 0) {\n              return Math.max(val + length, 0);\n            }\n\n            return Math.min(val, length);\n          }\n\n          ArrayBuffer.prototype.slice = function (from, to) {\n            var length = this.byteLength,\n                begin = clamp(from, length),\n                end = length,\n                num,\n                target,\n                targetArray,\n                sourceArray;\n\n            if (to !== undefined) {\n              end = clamp(to, length);\n            }\n\n            if (begin > end) {\n              return new ArrayBuffer(0);\n            }\n\n            num = end - begin;\n            target = new ArrayBuffer(num);\n            targetArray = new Uint8Array(target);\n            sourceArray = new Uint8Array(this, begin, num);\n            targetArray.set(sourceArray);\n            return target;\n          };\n        })();\n      }\n\n      function toUtf8(str) {\n        if (/[\\u0080-\\uFFFF]/.test(str)) {\n          str = unescape(encodeURIComponent(str));\n        }\n\n        return str;\n      }\n\n      function utf8Str2ArrayBuffer(str, returnUInt8Array) {\n        var length = str.length,\n            buff = new ArrayBuffer(length),\n            arr = new Uint8Array(buff),\n            i;\n\n        for (i = 0; i < length; i += 1) {\n          arr[i] = str.charCodeAt(i);\n        }\n\n        return returnUInt8Array ? arr : buff;\n      }\n\n      function arrayBuffer2Utf8Str(buff) {\n        return String.fromCharCode.apply(null, new Uint8Array(buff));\n      }\n\n      function concatenateArrayBuffers(first, second, returnUInt8Array) {\n        var result = new Uint8Array(first.byteLength + second.byteLength);\n        result.set(new Uint8Array(first));\n        result.set(new Uint8Array(second), first.byteLength);\n        return returnUInt8Array ? result : result.buffer;\n      }\n\n      function hexToBinaryString(hex) {\n        var bytes = [],\n            length = hex.length,\n            x;\n\n        for (x = 0; x < length - 1; x += 2) {\n          bytes.push(parseInt(hex.substr(x, 2), 16));\n        }\n\n        return String.fromCharCode.apply(String, bytes);\n      }\n\n      function SparkMD5() {\n        this.reset();\n      }\n\n      SparkMD5.prototype.append = function (str) {\n        this.appendBinary(toUtf8(str));\n        return this;\n      };\n\n      SparkMD5.prototype.appendBinary = function (contents) {\n        this._buff += contents;\n        this._length += contents.length;\n        var length = this._buff.length,\n            i;\n\n        for (i = 64; i <= length; i += 64) {\n          md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));\n        }\n\n        this._buff = this._buff.substring(i - 64);\n        return this;\n      };\n\n      SparkMD5.prototype.end = function (raw) {\n        var buff = this._buff,\n            length = buff.length,\n            i,\n            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n            ret;\n\n        for (i = 0; i < length; i += 1) {\n          tail[i >> 2] |= buff.charCodeAt(i) << (i % 4 << 3);\n        }\n\n        this._finish(tail, length);\n\n        ret = hex(this._hash);\n\n        if (raw) {\n          ret = hexToBinaryString(ret);\n        }\n\n        this.reset();\n        return ret;\n      };\n\n      SparkMD5.prototype.reset = function () {\n        this._buff = \"\";\n        this._length = 0;\n        this._hash = [1732584193, -271733879, -1732584194, 271733878];\n        return this;\n      };\n\n      SparkMD5.prototype.getState = function () {\n        return {\n          buff: this._buff,\n          length: this._length,\n          hash: this._hash\n        };\n      };\n\n      SparkMD5.prototype.setState = function (state) {\n        this._buff = state.buff;\n        this._length = state.length;\n        this._hash = state.hash;\n        return this;\n      };\n\n      SparkMD5.prototype.destroy = function () {\n        delete this._hash;\n        delete this._buff;\n        delete this._length;\n      };\n\n      SparkMD5.prototype._finish = function (tail, length) {\n        var i = length,\n            tmp,\n            lo,\n            hi;\n        tail[i >> 2] |= 128 << (i % 4 << 3);\n\n        if (i > 55) {\n          md5cycle(this._hash, tail);\n\n          for (i = 0; i < 16; i += 1) {\n            tail[i] = 0;\n          }\n        }\n\n        tmp = this._length * 8;\n        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n        lo = parseInt(tmp[2], 16);\n        hi = parseInt(tmp[1], 16) || 0;\n        tail[14] = lo;\n        tail[15] = hi;\n        md5cycle(this._hash, tail);\n      };\n\n      SparkMD5.hash = function (str, raw) {\n        return SparkMD5.hashBinary(toUtf8(str), raw);\n      };\n\n      SparkMD5.hashBinary = function (content, raw) {\n        var hash = md51(content),\n            ret = hex(hash);\n        return raw ? hexToBinaryString(ret) : ret;\n      };\n\n      SparkMD5.ArrayBuffer = function () {\n        this.reset();\n      };\n\n      SparkMD5.ArrayBuffer.prototype.append = function (arr) {\n        var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),\n            length = buff.length,\n            i;\n        this._length += arr.byteLength;\n\n        for (i = 64; i <= length; i += 64) {\n          md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));\n        }\n\n        this._buff = i - 64 < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);\n        return this;\n      };\n\n      SparkMD5.ArrayBuffer.prototype.end = function (raw) {\n        var buff = this._buff,\n            length = buff.length,\n            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n            i,\n            ret;\n\n        for (i = 0; i < length; i += 1) {\n          tail[i >> 2] |= buff[i] << (i % 4 << 3);\n        }\n\n        this._finish(tail, length);\n\n        ret = hex(this._hash);\n\n        if (raw) {\n          ret = hexToBinaryString(ret);\n        }\n\n        this.reset();\n        return ret;\n      };\n\n      SparkMD5.ArrayBuffer.prototype.reset = function () {\n        this._buff = new Uint8Array(0);\n        this._length = 0;\n        this._hash = [1732584193, -271733879, -1732584194, 271733878];\n        return this;\n      };\n\n      SparkMD5.ArrayBuffer.prototype.getState = function () {\n        var state = SparkMD5.prototype.getState.call(this);\n        state.buff = arrayBuffer2Utf8Str(state.buff);\n        return state;\n      };\n\n      SparkMD5.ArrayBuffer.prototype.setState = function (state) {\n        state.buff = utf8Str2ArrayBuffer(state.buff, true);\n        return SparkMD5.prototype.setState.call(this, state);\n      };\n\n      SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;\n      SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;\n\n      SparkMD5.ArrayBuffer.hash = function (arr, raw) {\n        var hash = md51_array(new Uint8Array(arr)),\n            ret = hex(hash);\n        return raw ? hexToBinaryString(ret) : ret;\n      };\n\n      return SparkMD5;\n    });\n  });\n\n  var classCallCheck = function classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  };\n\n  var createClass = function () {\n    function defineProperties(target, props) {\n      for (var i = 0; i < props.length; i++) {\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n      }\n    }\n\n    return function (Constructor, protoProps, staticProps) {\n      if (protoProps) defineProperties(Constructor.prototype, protoProps);\n      if (staticProps) defineProperties(Constructor, staticProps);\n      return Constructor;\n    };\n  }();\n\n  var fileSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice;\n\n  var FileChecksum = function () {\n    createClass(FileChecksum, null, [{\n      key: \"create\",\n      value: function create(file, callback) {\n        var instance = new FileChecksum(file);\n        instance.create(callback);\n      }\n    }]);\n\n    function FileChecksum(file) {\n      classCallCheck(this, FileChecksum);\n      this.file = file;\n      this.chunkSize = 2097152;\n      this.chunkCount = Math.ceil(this.file.size / this.chunkSize);\n      this.chunkIndex = 0;\n    }\n\n    createClass(FileChecksum, [{\n      key: \"create\",\n      value: function create(callback) {\n        var _this = this;\n\n        this.callback = callback;\n        this.md5Buffer = new sparkMd5.ArrayBuffer();\n        this.fileReader = new FileReader();\n        this.fileReader.addEventListener(\"load\", function (event) {\n          return _this.fileReaderDidLoad(event);\n        });\n        this.fileReader.addEventListener(\"error\", function (event) {\n          return _this.fileReaderDidError(event);\n        });\n        this.readNextChunk();\n      }\n    }, {\n      key: \"fileReaderDidLoad\",\n      value: function fileReaderDidLoad(event) {\n        this.md5Buffer.append(event.target.result);\n\n        if (!this.readNextChunk()) {\n          var binaryDigest = this.md5Buffer.end(true);\n          var base64digest = btoa(binaryDigest);\n          this.callback(null, base64digest);\n        }\n      }\n    }, {\n      key: \"fileReaderDidError\",\n      value: function fileReaderDidError(event) {\n        this.callback(\"Error reading \" + this.file.name);\n      }\n    }, {\n      key: \"readNextChunk\",\n      value: function readNextChunk() {\n        if (this.chunkIndex < this.chunkCount || this.chunkIndex == 0 && this.chunkCount == 0) {\n          var start = this.chunkIndex * this.chunkSize;\n          var end = Math.min(start + this.chunkSize, this.file.size);\n          var bytes = fileSlice.call(this.file, start, end);\n          this.fileReader.readAsArrayBuffer(bytes);\n          this.chunkIndex++;\n          return true;\n        } else {\n          return false;\n        }\n      }\n    }]);\n    return FileChecksum;\n  }();\n\n  function getMetaValue(name) {\n    var element = findElement(document.head, 'meta[name=\"' + name + '\"]');\n\n    if (element) {\n      return element.getAttribute(\"content\");\n    }\n  }\n\n  function findElements(root, selector) {\n    if (typeof root == \"string\") {\n      selector = root;\n      root = document;\n    }\n\n    var elements = root.querySelectorAll(selector);\n    return toArray$1(elements);\n  }\n\n  function findElement(root, selector) {\n    if (typeof root == \"string\") {\n      selector = root;\n      root = document;\n    }\n\n    return root.querySelector(selector);\n  }\n\n  function dispatchEvent(element, type) {\n    var eventInit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var disabled = element.disabled;\n    var bubbles = eventInit.bubbles,\n        cancelable = eventInit.cancelable,\n        detail = eventInit.detail;\n    var event = document.createEvent(\"Event\");\n    event.initEvent(type, bubbles || true, cancelable || true);\n    event.detail = detail || {};\n\n    try {\n      element.disabled = false;\n      element.dispatchEvent(event);\n    } finally {\n      element.disabled = disabled;\n    }\n\n    return event;\n  }\n\n  function toArray$1(value) {\n    if (Array.isArray(value)) {\n      return value;\n    } else if (Array.from) {\n      return Array.from(value);\n    } else {\n      return [].slice.call(value);\n    }\n  }\n\n  var BlobRecord = function () {\n    function BlobRecord(file, checksum, url) {\n      var _this = this;\n\n      classCallCheck(this, BlobRecord);\n      this.file = file;\n      this.attributes = {\n        filename: file.name,\n        content_type: file.type || \"application/octet-stream\",\n        byte_size: file.size,\n        checksum: checksum\n      };\n      this.xhr = new XMLHttpRequest();\n      this.xhr.open(\"POST\", url, true);\n      this.xhr.responseType = \"json\";\n      this.xhr.setRequestHeader(\"Content-Type\", \"application/json\");\n      this.xhr.setRequestHeader(\"Accept\", \"application/json\");\n      this.xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n      var csrfToken = getMetaValue(\"csrf-token\");\n\n      if (csrfToken != undefined) {\n        this.xhr.setRequestHeader(\"X-CSRF-Token\", csrfToken);\n      }\n\n      this.xhr.addEventListener(\"load\", function (event) {\n        return _this.requestDidLoad(event);\n      });\n      this.xhr.addEventListener(\"error\", function (event) {\n        return _this.requestDidError(event);\n      });\n    }\n\n    createClass(BlobRecord, [{\n      key: \"create\",\n      value: function create(callback) {\n        this.callback = callback;\n        this.xhr.send(JSON.stringify({\n          blob: this.attributes\n        }));\n      }\n    }, {\n      key: \"requestDidLoad\",\n      value: function requestDidLoad(event) {\n        if (this.status >= 200 && this.status < 300) {\n          var response = this.response;\n          var direct_upload = response.direct_upload;\n          delete response.direct_upload;\n          this.attributes = response;\n          this.directUploadData = direct_upload;\n          this.callback(null, this.toJSON());\n        } else {\n          this.requestDidError(event);\n        }\n      }\n    }, {\n      key: \"requestDidError\",\n      value: function requestDidError(event) {\n        this.callback('Error creating Blob for \"' + this.file.name + '\". Status: ' + this.status);\n      }\n    }, {\n      key: \"toJSON\",\n      value: function toJSON() {\n        var result = {};\n\n        for (var key in this.attributes) {\n          result[key] = this.attributes[key];\n        }\n\n        return result;\n      }\n    }, {\n      key: \"status\",\n      get: function get$$1() {\n        return this.xhr.status;\n      }\n    }, {\n      key: \"response\",\n      get: function get$$1() {\n        var _xhr = this.xhr,\n            responseType = _xhr.responseType,\n            response = _xhr.response;\n\n        if (responseType == \"json\") {\n          return response;\n        } else {\n          return JSON.parse(response);\n        }\n      }\n    }]);\n    return BlobRecord;\n  }();\n\n  var BlobUpload = function () {\n    function BlobUpload(blob) {\n      var _this = this;\n\n      classCallCheck(this, BlobUpload);\n      this.blob = blob;\n      this.file = blob.file;\n      var _blob$directUploadDat = blob.directUploadData,\n          url = _blob$directUploadDat.url,\n          headers = _blob$directUploadDat.headers;\n      this.xhr = new XMLHttpRequest();\n      this.xhr.open(\"PUT\", url, true);\n      this.xhr.responseType = \"text\";\n\n      for (var key in headers) {\n        this.xhr.setRequestHeader(key, headers[key]);\n      }\n\n      this.xhr.addEventListener(\"load\", function (event) {\n        return _this.requestDidLoad(event);\n      });\n      this.xhr.addEventListener(\"error\", function (event) {\n        return _this.requestDidError(event);\n      });\n    }\n\n    createClass(BlobUpload, [{\n      key: \"create\",\n      value: function create(callback) {\n        this.callback = callback;\n        this.xhr.send(this.file.slice());\n      }\n    }, {\n      key: \"requestDidLoad\",\n      value: function requestDidLoad(event) {\n        var _xhr = this.xhr,\n            status = _xhr.status,\n            response = _xhr.response;\n\n        if (status >= 200 && status < 300) {\n          this.callback(null, response);\n        } else {\n          this.requestDidError(event);\n        }\n      }\n    }, {\n      key: \"requestDidError\",\n      value: function requestDidError(event) {\n        this.callback('Error storing \"' + this.file.name + '\". Status: ' + this.xhr.status);\n      }\n    }]);\n    return BlobUpload;\n  }();\n\n  var id = 0;\n\n  var DirectUpload = function () {\n    function DirectUpload(file, url, delegate) {\n      classCallCheck(this, DirectUpload);\n      this.id = ++id;\n      this.file = file;\n      this.url = url;\n      this.delegate = delegate;\n    }\n\n    createClass(DirectUpload, [{\n      key: \"create\",\n      value: function create(callback) {\n        var _this = this;\n\n        FileChecksum.create(this.file, function (error, checksum) {\n          if (error) {\n            callback(error);\n            return;\n          }\n\n          var blob = new BlobRecord(_this.file, checksum, _this.url);\n          notify(_this.delegate, \"directUploadWillCreateBlobWithXHR\", blob.xhr);\n          blob.create(function (error) {\n            if (error) {\n              callback(error);\n            } else {\n              var upload = new BlobUpload(blob);\n              notify(_this.delegate, \"directUploadWillStoreFileWithXHR\", upload.xhr);\n              upload.create(function (error) {\n                if (error) {\n                  callback(error);\n                } else {\n                  callback(null, blob.toJSON());\n                }\n              });\n            }\n          });\n        });\n      }\n    }]);\n    return DirectUpload;\n  }();\n\n  function notify(object, methodName) {\n    if (object && typeof object[methodName] == \"function\") {\n      for (var _len = arguments.length, messages = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n        messages[_key - 2] = arguments[_key];\n      }\n\n      return object[methodName].apply(object, messages);\n    }\n  }\n\n  var DirectUploadController = function () {\n    function DirectUploadController(input, file) {\n      classCallCheck(this, DirectUploadController);\n      this.input = input;\n      this.file = file;\n      this.directUpload = new DirectUpload(this.file, this.url, this);\n      this.dispatch(\"initialize\");\n    }\n\n    createClass(DirectUploadController, [{\n      key: \"start\",\n      value: function start(callback) {\n        var _this = this;\n\n        var hiddenInput = document.createElement(\"input\");\n        hiddenInput.type = \"hidden\";\n        hiddenInput.name = this.input.name;\n        this.input.insertAdjacentElement(\"beforebegin\", hiddenInput);\n        this.dispatch(\"start\");\n        this.directUpload.create(function (error, attributes) {\n          if (error) {\n            hiddenInput.parentNode.removeChild(hiddenInput);\n\n            _this.dispatchError(error);\n          } else {\n            hiddenInput.value = attributes.signed_id;\n          }\n\n          _this.dispatch(\"end\");\n\n          callback(error);\n        });\n      }\n    }, {\n      key: \"uploadRequestDidProgress\",\n      value: function uploadRequestDidProgress(event) {\n        var progress = event.loaded / event.total * 100;\n\n        if (progress) {\n          this.dispatch(\"progress\", {\n            progress: progress\n          });\n        }\n      }\n    }, {\n      key: \"dispatch\",\n      value: function dispatch(name) {\n        var detail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        detail.file = this.file;\n        detail.id = this.directUpload.id;\n        return dispatchEvent(this.input, \"direct-upload:\" + name, {\n          detail: detail\n        });\n      }\n    }, {\n      key: \"dispatchError\",\n      value: function dispatchError(error) {\n        var event = this.dispatch(\"error\", {\n          error: error\n        });\n\n        if (!event.defaultPrevented) {\n          alert(error);\n        }\n      }\n    }, {\n      key: \"directUploadWillCreateBlobWithXHR\",\n      value: function directUploadWillCreateBlobWithXHR(xhr) {\n        this.dispatch(\"before-blob-request\", {\n          xhr: xhr\n        });\n      }\n    }, {\n      key: \"directUploadWillStoreFileWithXHR\",\n      value: function directUploadWillStoreFileWithXHR(xhr) {\n        var _this2 = this;\n\n        this.dispatch(\"before-storage-request\", {\n          xhr: xhr\n        });\n        xhr.upload.addEventListener(\"progress\", function (event) {\n          return _this2.uploadRequestDidProgress(event);\n        });\n      }\n    }, {\n      key: \"url\",\n      get: function get$$1() {\n        return this.input.getAttribute(\"data-direct-upload-url\");\n      }\n    }]);\n    return DirectUploadController;\n  }();\n\n  var inputSelector = \"input[type=file][data-direct-upload-url]:not([disabled])\";\n\n  var DirectUploadsController = function () {\n    function DirectUploadsController(form) {\n      classCallCheck(this, DirectUploadsController);\n      this.form = form;\n      this.inputs = findElements(form, inputSelector).filter(function (input) {\n        return input.files.length;\n      });\n    }\n\n    createClass(DirectUploadsController, [{\n      key: \"start\",\n      value: function start(callback) {\n        var _this = this;\n\n        var controllers = this.createDirectUploadControllers();\n\n        var startNextController = function startNextController() {\n          var controller = controllers.shift();\n\n          if (controller) {\n            controller.start(function (error) {\n              if (error) {\n                callback(error);\n\n                _this.dispatch(\"end\");\n              } else {\n                startNextController();\n              }\n            });\n          } else {\n            callback();\n\n            _this.dispatch(\"end\");\n          }\n        };\n\n        this.dispatch(\"start\");\n        startNextController();\n      }\n    }, {\n      key: \"createDirectUploadControllers\",\n      value: function createDirectUploadControllers() {\n        var controllers = [];\n        this.inputs.forEach(function (input) {\n          toArray$1(input.files).forEach(function (file) {\n            var controller = new DirectUploadController(input, file);\n            controllers.push(controller);\n          });\n        });\n        return controllers;\n      }\n    }, {\n      key: \"dispatch\",\n      value: function dispatch(name) {\n        var detail = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        return dispatchEvent(this.form, \"direct-uploads:\" + name, {\n          detail: detail\n        });\n      }\n    }]);\n    return DirectUploadsController;\n  }();\n\n  var processingAttribute = \"data-direct-uploads-processing\";\n  var submitButtonsByForm = new WeakMap();\n  var started = false;\n\n  function start() {\n    if (!started) {\n      started = true;\n      document.addEventListener(\"click\", didClick, true);\n      document.addEventListener(\"submit\", didSubmitForm);\n      document.addEventListener(\"ajax:before\", didSubmitRemoteElement);\n    }\n  }\n\n  function didClick(event) {\n    var target = event.target;\n\n    if ((target.tagName == \"INPUT\" || target.tagName == \"BUTTON\") && target.type == \"submit\" && target.form) {\n      submitButtonsByForm.set(target.form, target);\n    }\n  }\n\n  function didSubmitForm(event) {\n    handleFormSubmissionEvent(event);\n  }\n\n  function didSubmitRemoteElement(event) {\n    if (event.target.tagName == \"FORM\") {\n      handleFormSubmissionEvent(event);\n    }\n  }\n\n  function handleFormSubmissionEvent(event) {\n    var form = event.target;\n\n    if (form.hasAttribute(processingAttribute)) {\n      event.preventDefault();\n      return;\n    }\n\n    var controller = new DirectUploadsController(form);\n    var inputs = controller.inputs;\n\n    if (inputs.length) {\n      event.preventDefault();\n      form.setAttribute(processingAttribute, \"\");\n      inputs.forEach(disable);\n      controller.start(function (error) {\n        form.removeAttribute(processingAttribute);\n\n        if (error) {\n          inputs.forEach(enable);\n        } else {\n          submitForm(form);\n        }\n      });\n    }\n  }\n\n  function submitForm(form) {\n    var button = submitButtonsByForm.get(form) || findElement(form, \"input[type=submit], button[type=submit]\");\n\n    if (button) {\n      var _button = button,\n          disabled = _button.disabled;\n      button.disabled = false;\n      button.focus();\n      button.click();\n      button.disabled = disabled;\n    } else {\n      button = document.createElement(\"input\");\n      button.type = \"submit\";\n      button.style.display = \"none\";\n      form.appendChild(button);\n      button.click();\n      form.removeChild(button);\n    }\n\n    submitButtonsByForm.delete(form);\n  }\n\n  function disable(input) {\n    input.disabled = true;\n  }\n\n  function enable(input) {\n    input.disabled = false;\n  }\n\n  function autostart() {\n    if (window.ActiveStorage) {\n      start();\n    }\n  }\n\n  setTimeout(autostart, 1);\n  exports.start = start;\n  exports.DirectUpload = DirectUpload;\n  Object.defineProperty(exports, \"__esModule\", {\n    value: true\n  });\n});","// Load all the channels within this directory and all subdirectories.\n// Channel files must be named *_channel.js.\n\nconst channels = require.context('.', true, /_channel\\.js$/)\nchannels.keys().forEach(channels)\n","function webpackEmptyContext(req) {\n\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\te.code = 'MODULE_NOT_FOUND';\n\tthrow e;\n}\nwebpackEmptyContext.keys = function() { return []; };\nwebpackEmptyContext.resolve = webpackEmptyContext;\nmodule.exports = webpackEmptyContext;\nwebpackEmptyContext.id = 7;","function _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/*!\n * jQuery JavaScript Library v3.6.0\n * https://jquery.com/\n *\n * Includes Sizzle.js\n * https://sizzlejs.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2021-03-02T17:08Z\n */\n(function (global, factory) {\n  \"use strict\";\n\n  if ((typeof module === \"undefined\" ? \"undefined\" : _typeof(module)) === \"object\" && _typeof(module.exports) === \"object\") {\n    // For CommonJS and CommonJS-like environments where a proper `window`\n    // is present, execute the factory and get jQuery.\n    // For environments that do not have a `window` with a `document`\n    // (such as Node.js), expose a factory as module.exports.\n    // This accentuates the need for the creation of a real `window`.\n    // e.g. var jQuery = require(\"jquery\")(window);\n    // See ticket #14549 for more info.\n    module.exports = global.document ? factory(global, true) : function (w) {\n      if (!w.document) {\n        throw new Error(\"jQuery requires a window with a document\");\n      }\n\n      return factory(w);\n    };\n  } else {\n    factory(global);\n  } // Pass this if window is not defined yet\n\n})(typeof window !== \"undefined\" ? window : this, function (window, noGlobal) {\n  // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n  // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n  // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n  // enough that all such attempts are guarded in a try block.\n  \"use strict\";\n\n  var arr = [];\n  var getProto = Object.getPrototypeOf;\n  var _slice = arr.slice;\n  var flat = arr.flat ? function (array) {\n    return arr.flat.call(array);\n  } : function (array) {\n    return arr.concat.apply([], array);\n  };\n  var push = arr.push;\n  var indexOf = arr.indexOf;\n  var class2type = {};\n  var toString = class2type.toString;\n  var hasOwn = class2type.hasOwnProperty;\n  var fnToString = hasOwn.toString;\n  var ObjectFunctionString = fnToString.call(Object);\n  var support = {};\n\n  var isFunction = function isFunction(obj) {\n    // Support: Chrome <=57, Firefox <=52\n    // In some browsers, typeof returns \"function\" for HTML <object> elements\n    // (i.e., `typeof document.createElement( \"object\" ) === \"function\"`).\n    // We don't want to classify *any* DOM node as a function.\n    // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5\n    // Plus for old WebKit, typeof returns \"function\" for HTML collections\n    // (e.g., `typeof document.getElementsByTagName(\"div\") === \"function\"`). (gh-4756)\n    return typeof obj === \"function\" && typeof obj.nodeType !== \"number\" && typeof obj.item !== \"function\";\n  };\n\n  var isWindow = function isWindow(obj) {\n    return obj != null && obj === obj.window;\n  };\n\n  var document = window.document;\n  var preservedScriptAttributes = {\n    type: true,\n    src: true,\n    nonce: true,\n    noModule: true\n  };\n\n  function DOMEval(code, node, doc) {\n    doc = doc || document;\n    var i,\n        val,\n        script = doc.createElement(\"script\");\n    script.text = code;\n\n    if (node) {\n      for (i in preservedScriptAttributes) {\n        // Support: Firefox 64+, Edge 18+\n        // Some browsers don't support the \"nonce\" property on scripts.\n        // On the other hand, just using `getAttribute` is not enough as\n        // the `nonce` attribute is reset to an empty string whenever it\n        // becomes browsing-context connected.\n        // See https://github.com/whatwg/html/issues/2369\n        // See https://html.spec.whatwg.org/#nonce-attributes\n        // The `node.getAttribute` check was added for the sake of\n        // `jQuery.globalEval` so that it can fake a nonce-containing node\n        // via an object.\n        val = node[i] || node.getAttribute && node.getAttribute(i);\n\n        if (val) {\n          script.setAttribute(i, val);\n        }\n      }\n    }\n\n    doc.head.appendChild(script).parentNode.removeChild(script);\n  }\n\n  function toType(obj) {\n    if (obj == null) {\n      return obj + \"\";\n    } // Support: Android <=2.3 only (functionish RegExp)\n\n\n    return _typeof(obj) === \"object\" || typeof obj === \"function\" ? class2type[toString.call(obj)] || \"object\" : _typeof(obj);\n  }\n  /* global Symbol */\n  // Defining this global in .eslintrc.json would create a danger of using the global\n  // unguarded in another place, it seems safer to define global only for this module\n\n\n  var version = \"3.6.0\",\n      // Define a local copy of jQuery\n  jQuery = function jQuery(selector, context) {\n    // The jQuery object is actually just the init constructor 'enhanced'\n    // Need init if jQuery is called (just allow error to be thrown if not included)\n    return new jQuery.fn.init(selector, context);\n  };\n\n  jQuery.fn = jQuery.prototype = {\n    // The current version of jQuery being used\n    jquery: version,\n    constructor: jQuery,\n    // The default length of a jQuery object is 0\n    length: 0,\n    toArray: function toArray() {\n      return _slice.call(this);\n    },\n    // Get the Nth element in the matched element set OR\n    // Get the whole matched element set as a clean array\n    get: function get(num) {\n      // Return all the elements in a clean array\n      if (num == null) {\n        return _slice.call(this);\n      } // Return just the one element from the set\n\n\n      return num < 0 ? this[num + this.length] : this[num];\n    },\n    // Take an array of elements and push it onto the stack\n    // (returning the new matched element set)\n    pushStack: function pushStack(elems) {\n      // Build a new jQuery matched element set\n      var ret = jQuery.merge(this.constructor(), elems); // Add the old object onto the stack (as a reference)\n\n      ret.prevObject = this; // Return the newly-formed element set\n\n      return ret;\n    },\n    // Execute a callback for every element in the matched set.\n    each: function each(callback) {\n      return jQuery.each(this, callback);\n    },\n    map: function map(callback) {\n      return this.pushStack(jQuery.map(this, function (elem, i) {\n        return callback.call(elem, i, elem);\n      }));\n    },\n    slice: function slice() {\n      return this.pushStack(_slice.apply(this, arguments));\n    },\n    first: function first() {\n      return this.eq(0);\n    },\n    last: function last() {\n      return this.eq(-1);\n    },\n    even: function even() {\n      return this.pushStack(jQuery.grep(this, function (_elem, i) {\n        return (i + 1) % 2;\n      }));\n    },\n    odd: function odd() {\n      return this.pushStack(jQuery.grep(this, function (_elem, i) {\n        return i % 2;\n      }));\n    },\n    eq: function eq(i) {\n      var len = this.length,\n          j = +i + (i < 0 ? len : 0);\n      return this.pushStack(j >= 0 && j < len ? [this[j]] : []);\n    },\n    end: function end() {\n      return this.prevObject || this.constructor();\n    },\n    // For internal use only.\n    // Behaves like an Array's method, not like a jQuery method.\n    push: push,\n    sort: arr.sort,\n    splice: arr.splice\n  };\n\n  jQuery.extend = jQuery.fn.extend = function () {\n    var options,\n        name,\n        src,\n        copy,\n        copyIsArray,\n        clone,\n        target = arguments[0] || {},\n        i = 1,\n        length = arguments.length,\n        deep = false; // Handle a deep copy situation\n\n    if (typeof target === \"boolean\") {\n      deep = target; // Skip the boolean and the target\n\n      target = arguments[i] || {};\n      i++;\n    } // Handle case when target is a string or something (possible in deep copy)\n\n\n    if (_typeof(target) !== \"object\" && !isFunction(target)) {\n      target = {};\n    } // Extend jQuery itself if only one argument is passed\n\n\n    if (i === length) {\n      target = this;\n      i--;\n    }\n\n    for (; i < length; i++) {\n      // Only deal with non-null/undefined values\n      if ((options = arguments[i]) != null) {\n        // Extend the base object\n        for (name in options) {\n          copy = options[name]; // Prevent Object.prototype pollution\n          // Prevent never-ending loop\n\n          if (name === \"__proto__\" || target === copy) {\n            continue;\n          } // Recurse if we're merging plain objects or arrays\n\n\n          if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {\n            src = target[name]; // Ensure proper type for the source value\n\n            if (copyIsArray && !Array.isArray(src)) {\n              clone = [];\n            } else if (!copyIsArray && !jQuery.isPlainObject(src)) {\n              clone = {};\n            } else {\n              clone = src;\n            }\n\n            copyIsArray = false; // Never move original objects, clone them\n\n            target[name] = jQuery.extend(deep, clone, copy); // Don't bring in undefined values\n          } else if (copy !== undefined) {\n            target[name] = copy;\n          }\n        }\n      }\n    } // Return the modified object\n\n\n    return target;\n  };\n\n  jQuery.extend({\n    // Unique for each copy of jQuery on the page\n    expando: \"jQuery\" + (version + Math.random()).replace(/\\D/g, \"\"),\n    // Assume jQuery is ready without the ready module\n    isReady: true,\n    error: function error(msg) {\n      throw new Error(msg);\n    },\n    noop: function noop() {},\n    isPlainObject: function isPlainObject(obj) {\n      var proto, Ctor; // Detect obvious negatives\n      // Use toString instead of jQuery.type to catch host objects\n\n      if (!obj || toString.call(obj) !== \"[object Object]\") {\n        return false;\n      }\n\n      proto = getProto(obj); // Objects with no prototype (e.g., `Object.create( null )`) are plain\n\n      if (!proto) {\n        return true;\n      } // Objects with prototype are plain iff they were constructed by a global Object function\n\n\n      Ctor = hasOwn.call(proto, \"constructor\") && proto.constructor;\n      return typeof Ctor === \"function\" && fnToString.call(Ctor) === ObjectFunctionString;\n    },\n    isEmptyObject: function isEmptyObject(obj) {\n      var name;\n\n      for (name in obj) {\n        return false;\n      }\n\n      return true;\n    },\n    // Evaluates a script in a provided context; falls back to the global one\n    // if not specified.\n    globalEval: function globalEval(code, options, doc) {\n      DOMEval(code, {\n        nonce: options && options.nonce\n      }, doc);\n    },\n    each: function each(obj, callback) {\n      var length,\n          i = 0;\n\n      if (isArrayLike(obj)) {\n        length = obj.length;\n\n        for (; i < length; i++) {\n          if (callback.call(obj[i], i, obj[i]) === false) {\n            break;\n          }\n        }\n      } else {\n        for (i in obj) {\n          if (callback.call(obj[i], i, obj[i]) === false) {\n            break;\n          }\n        }\n      }\n\n      return obj;\n    },\n    // results is for internal usage only\n    makeArray: function makeArray(arr, results) {\n      var ret = results || [];\n\n      if (arr != null) {\n        if (isArrayLike(Object(arr))) {\n          jQuery.merge(ret, typeof arr === \"string\" ? [arr] : arr);\n        } else {\n          push.call(ret, arr);\n        }\n      }\n\n      return ret;\n    },\n    inArray: function inArray(elem, arr, i) {\n      return arr == null ? -1 : indexOf.call(arr, elem, i);\n    },\n    // Support: Android <=4.0 only, PhantomJS 1 only\n    // push.apply(_, arraylike) throws on ancient WebKit\n    merge: function merge(first, second) {\n      var len = +second.length,\n          j = 0,\n          i = first.length;\n\n      for (; j < len; j++) {\n        first[i++] = second[j];\n      }\n\n      first.length = i;\n      return first;\n    },\n    grep: function grep(elems, callback, invert) {\n      var callbackInverse,\n          matches = [],\n          i = 0,\n          length = elems.length,\n          callbackExpect = !invert; // Go through the array, only saving the items\n      // that pass the validator function\n\n      for (; i < length; i++) {\n        callbackInverse = !callback(elems[i], i);\n\n        if (callbackInverse !== callbackExpect) {\n          matches.push(elems[i]);\n        }\n      }\n\n      return matches;\n    },\n    // arg is for internal usage only\n    map: function map(elems, callback, arg) {\n      var length,\n          value,\n          i = 0,\n          ret = []; // Go through the array, translating each of the items to their new values\n\n      if (isArrayLike(elems)) {\n        length = elems.length;\n\n        for (; i < length; i++) {\n          value = callback(elems[i], i, arg);\n\n          if (value != null) {\n            ret.push(value);\n          }\n        } // Go through every key on the object,\n\n      } else {\n        for (i in elems) {\n          value = callback(elems[i], i, arg);\n\n          if (value != null) {\n            ret.push(value);\n          }\n        }\n      } // Flatten any nested arrays\n\n\n      return flat(ret);\n    },\n    // A global GUID counter for objects\n    guid: 1,\n    // jQuery.support is not used in Core but other projects attach their\n    // properties to it so it needs to exist.\n    support: support\n  });\n\n  if (typeof Symbol === \"function\") {\n    jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];\n  } // Populate the class2type map\n\n\n  jQuery.each(\"Boolean Number String Function Array Date RegExp Object Error Symbol\".split(\" \"), function (_i, name) {\n    class2type[\"[object \" + name + \"]\"] = name.toLowerCase();\n  });\n\n  function isArrayLike(obj) {\n    // Support: real iOS 8.2 only (not reproducible in simulator)\n    // `in` check used to prevent JIT error (gh-2145)\n    // hasOwn isn't used here due to false negatives\n    // regarding Nodelist length in IE\n    var length = !!obj && \"length\" in obj && obj.length,\n        type = toType(obj);\n\n    if (isFunction(obj) || isWindow(obj)) {\n      return false;\n    }\n\n    return type === \"array\" || length === 0 || typeof length === \"number\" && length > 0 && length - 1 in obj;\n  }\n\n  var Sizzle =\n  /*!\n   * Sizzle CSS Selector Engine v2.3.6\n   * https://sizzlejs.com/\n   *\n   * Copyright JS Foundation and other contributors\n   * Released under the MIT license\n   * https://js.foundation/\n   *\n   * Date: 2021-02-16\n   */\n  function (window) {\n    var i,\n        support,\n        Expr,\n        getText,\n        isXML,\n        tokenize,\n        compile,\n        select,\n        outermostContext,\n        sortInput,\n        hasDuplicate,\n        // Local document vars\n    setDocument,\n        document,\n        docElem,\n        documentIsHTML,\n        rbuggyQSA,\n        rbuggyMatches,\n        matches,\n        contains,\n        // Instance-specific data\n    expando = \"sizzle\" + 1 * new Date(),\n        preferredDoc = window.document,\n        dirruns = 0,\n        done = 0,\n        classCache = createCache(),\n        tokenCache = createCache(),\n        compilerCache = createCache(),\n        nonnativeSelectorCache = createCache(),\n        sortOrder = function sortOrder(a, b) {\n      if (a === b) {\n        hasDuplicate = true;\n      }\n\n      return 0;\n    },\n        // Instance methods\n    hasOwn = {}.hasOwnProperty,\n        arr = [],\n        pop = arr.pop,\n        pushNative = arr.push,\n        push = arr.push,\n        slice = arr.slice,\n        // Use a stripped-down indexOf as it's faster than native\n    // https://jsperf.com/thor-indexof-vs-for/5\n    indexOf = function indexOf(list, elem) {\n      var i = 0,\n          len = list.length;\n\n      for (; i < len; i++) {\n        if (list[i] === elem) {\n          return i;\n        }\n      }\n\n      return -1;\n    },\n        booleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|\" + \"ismap|loop|multiple|open|readonly|required|scoped\",\n        // Regular expressions\n    // http://www.w3.org/TR/css3-selectors/#whitespace\n    whitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n        // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n    identifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n        // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n    attributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace + // Operator (capture 2)\n    \"*([*^$|!~]?=)\" + whitespace + // \"Attribute values must be CSS identifiers [capture 5]\n    // or strings [capture 3 or capture 4]\"\n    \"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace + \"*\\\\]\",\n        pseudos = \":(\" + identifier + \")(?:\\\\((\" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n    // 1. quoted (capture 3; capture 4 or capture 5)\n    \"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" + // 2. simple (capture 6)\n    \"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" + // 3. anything else (capture 2)\n    \".*\" + \")\\\\)|)\",\n        // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n    rwhitespace = new RegExp(whitespace + \"+\", \"g\"),\n        rtrim = new RegExp(\"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\"),\n        rcomma = new RegExp(\"^\" + whitespace + \"*,\" + whitespace + \"*\"),\n        rcombinators = new RegExp(\"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\"),\n        rdescend = new RegExp(whitespace + \"|>\"),\n        rpseudo = new RegExp(pseudos),\n        ridentifier = new RegExp(\"^\" + identifier + \"$\"),\n        matchExpr = {\n      \"ID\": new RegExp(\"^#(\" + identifier + \")\"),\n      \"CLASS\": new RegExp(\"^\\\\.(\" + identifier + \")\"),\n      \"TAG\": new RegExp(\"^(\" + identifier + \"|[*])\"),\n      \"ATTR\": new RegExp(\"^\" + attributes),\n      \"PSEUDO\": new RegExp(\"^\" + pseudos),\n      \"CHILD\": new RegExp(\"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\"),\n      \"bool\": new RegExp(\"^(?:\" + booleans + \")$\", \"i\"),\n      // For use in libraries implementing .is()\n      // We use this for POS matching in `select`\n      \"needsContext\": new RegExp(\"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\")\n    },\n        rhtml = /HTML$/i,\n        rinputs = /^(?:input|select|textarea|button)$/i,\n        rheader = /^h\\d$/i,\n        rnative = /^[^{]+\\{\\s*\\[native \\w/,\n        // Easily-parseable/retrievable ID or TAG or CLASS selectors\n    rquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n        rsibling = /[+~]/,\n        // CSS escapes\n    // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n    runescape = new RegExp(\"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\"),\n        funescape = function funescape(escape, nonHex) {\n      var high = \"0x\" + escape.slice(1) - 0x10000;\n      return nonHex ? // Strip the backslash prefix from a non-hex escape sequence\n      nonHex : // Replace a hexadecimal escape sequence with the encoded Unicode code point\n      // Support: IE <=11+\n      // For values outside the Basic Multilingual Plane (BMP), manually construct a\n      // surrogate pair\n      high < 0 ? String.fromCharCode(high + 0x10000) : String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);\n    },\n        // CSS string/identifier serialization\n    // https://drafts.csswg.org/cssom/#common-serializing-idioms\n    rcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n        fcssescape = function fcssescape(ch, asCodePoint) {\n      if (asCodePoint) {\n        // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n        if (ch === \"\\0\") {\n          return \"\\uFFFD\";\n        } // Control characters and (dependent upon position) numbers get escaped as code points\n\n\n        return ch.slice(0, -1) + \"\\\\\" + ch.charCodeAt(ch.length - 1).toString(16) + \" \";\n      } // Other potentially-special ASCII characters get backslash-escaped\n\n\n      return \"\\\\\" + ch;\n    },\n        // Used for iframes\n    // See setDocument()\n    // Removing the function wrapper causes a \"Permission Denied\"\n    // error in IE\n    unloadHandler = function unloadHandler() {\n      setDocument();\n    },\n        inDisabledFieldset = addCombinator(function (elem) {\n      return elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\n    }, {\n      dir: \"parentNode\",\n      next: \"legend\"\n    }); // Optimize for push.apply( _, NodeList )\n\n\n    try {\n      push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes); // Support: Android<4.0\n      // Detect silently failing push.apply\n      // eslint-disable-next-line no-unused-expressions\n\n      arr[preferredDoc.childNodes.length].nodeType;\n    } catch (e) {\n      push = {\n        apply: arr.length ? // Leverage slice if possible\n        function (target, els) {\n          pushNative.apply(target, slice.call(els));\n        } : // Support: IE<9\n        // Otherwise append directly\n        function (target, els) {\n          var j = target.length,\n              i = 0; // Can't trust NodeList.length\n\n          while (target[j++] = els[i++]) {}\n\n          target.length = j - 1;\n        }\n      };\n    }\n\n    function Sizzle(selector, context, results, seed) {\n      var m,\n          i,\n          elem,\n          nid,\n          match,\n          groups,\n          newSelector,\n          newContext = context && context.ownerDocument,\n          // nodeType defaults to 9, since context defaults to document\n      nodeType = context ? context.nodeType : 9;\n      results = results || []; // Return early from calls with invalid selector or context\n\n      if (typeof selector !== \"string\" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {\n        return results;\n      } // Try to shortcut find operations (as opposed to filters) in HTML documents\n\n\n      if (!seed) {\n        setDocument(context);\n        context = context || document;\n\n        if (documentIsHTML) {\n          // If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n          // (excepting DocumentFragment context, where the methods don't exist)\n          if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {\n            // ID selector\n            if (m = match[1]) {\n              // Document context\n              if (nodeType === 9) {\n                if (elem = context.getElementById(m)) {\n                  // Support: IE, Opera, Webkit\n                  // TODO: identify versions\n                  // getElementById can match elements by name instead of ID\n                  if (elem.id === m) {\n                    results.push(elem);\n                    return results;\n                  }\n                } else {\n                  return results;\n                } // Element context\n\n              } else {\n                // Support: IE, Opera, Webkit\n                // TODO: identify versions\n                // getElementById can match elements by name instead of ID\n                if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {\n                  results.push(elem);\n                  return results;\n                }\n              } // Type selector\n\n            } else if (match[2]) {\n              push.apply(results, context.getElementsByTagName(selector));\n              return results; // Class selector\n            } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {\n              push.apply(results, context.getElementsByClassName(m));\n              return results;\n            }\n          } // Take advantage of querySelectorAll\n\n\n          if (support.qsa && !nonnativeSelectorCache[selector + \" \"] && (!rbuggyQSA || !rbuggyQSA.test(selector)) && ( // Support: IE 8 only\n          // Exclude object elements\n          nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\")) {\n            newSelector = selector;\n            newContext = context; // qSA considers elements outside a scoping root when evaluating child or\n            // descendant combinators, which is not what we want.\n            // In such cases, we work around the behavior by prefixing every selector in the\n            // list with an ID selector referencing the scope context.\n            // The technique has to be used as well when a leading combinator is used\n            // as such selectors are not recognized by querySelectorAll.\n            // Thanks to Andrew Dupont for this technique.\n\n            if (nodeType === 1 && (rdescend.test(selector) || rcombinators.test(selector))) {\n              // Expand context for sibling selectors\n              newContext = rsibling.test(selector) && testContext(context.parentNode) || context; // We can use :scope instead of the ID hack if the browser\n              // supports it & if we're not changing the context.\n\n              if (newContext !== context || !support.scope) {\n                // Capture the context ID, setting it first if necessary\n                if (nid = context.getAttribute(\"id\")) {\n                  nid = nid.replace(rcssescape, fcssescape);\n                } else {\n                  context.setAttribute(\"id\", nid = expando);\n                }\n              } // Prefix every selector in the list\n\n\n              groups = tokenize(selector);\n              i = groups.length;\n\n              while (i--) {\n                groups[i] = (nid ? \"#\" + nid : \":scope\") + \" \" + toSelector(groups[i]);\n              }\n\n              newSelector = groups.join(\",\");\n            }\n\n            try {\n              push.apply(results, newContext.querySelectorAll(newSelector));\n              return results;\n            } catch (qsaError) {\n              nonnativeSelectorCache(selector, true);\n            } finally {\n              if (nid === expando) {\n                context.removeAttribute(\"id\");\n              }\n            }\n          }\n        }\n      } // All others\n\n\n      return select(selector.replace(rtrim, \"$1\"), context, results, seed);\n    }\n    /**\n     * Create key-value caches of limited size\n     * @returns {function(string, object)} Returns the Object data after storing it on itself with\n     *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n     *\tdeleting the oldest entry\n     */\n\n\n    function createCache() {\n      var keys = [];\n\n      function cache(key, value) {\n        // Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n        if (keys.push(key + \" \") > Expr.cacheLength) {\n          // Only keep the most recent entries\n          delete cache[keys.shift()];\n        }\n\n        return cache[key + \" \"] = value;\n      }\n\n      return cache;\n    }\n    /**\n     * Mark a function for special use by Sizzle\n     * @param {Function} fn The function to mark\n     */\n\n\n    function markFunction(fn) {\n      fn[expando] = true;\n      return fn;\n    }\n    /**\n     * Support testing using an element\n     * @param {Function} fn Passed the created element and returns a boolean result\n     */\n\n\n    function assert(fn) {\n      var el = document.createElement(\"fieldset\");\n\n      try {\n        return !!fn(el);\n      } catch (e) {\n        return false;\n      } finally {\n        // Remove from its parent by default\n        if (el.parentNode) {\n          el.parentNode.removeChild(el);\n        } // release memory in IE\n\n\n        el = null;\n      }\n    }\n    /**\n     * Adds the same handler for all of the specified attrs\n     * @param {String} attrs Pipe-separated list of attributes\n     * @param {Function} handler The method that will be applied\n     */\n\n\n    function addHandle(attrs, handler) {\n      var arr = attrs.split(\"|\"),\n          i = arr.length;\n\n      while (i--) {\n        Expr.attrHandle[arr[i]] = handler;\n      }\n    }\n    /**\n     * Checks document order of two siblings\n     * @param {Element} a\n     * @param {Element} b\n     * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n     */\n\n\n    function siblingCheck(a, b) {\n      var cur = b && a,\n          diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes\n\n      if (diff) {\n        return diff;\n      } // Check if b follows a\n\n\n      if (cur) {\n        while (cur = cur.nextSibling) {\n          if (cur === b) {\n            return -1;\n          }\n        }\n      }\n\n      return a ? 1 : -1;\n    }\n    /**\n     * Returns a function to use in pseudos for input types\n     * @param {String} type\n     */\n\n\n    function createInputPseudo(type) {\n      return function (elem) {\n        var name = elem.nodeName.toLowerCase();\n        return name === \"input\" && elem.type === type;\n      };\n    }\n    /**\n     * Returns a function to use in pseudos for buttons\n     * @param {String} type\n     */\n\n\n    function createButtonPseudo(type) {\n      return function (elem) {\n        var name = elem.nodeName.toLowerCase();\n        return (name === \"input\" || name === \"button\") && elem.type === type;\n      };\n    }\n    /**\n     * Returns a function to use in pseudos for :enabled/:disabled\n     * @param {Boolean} disabled true for :disabled; false for :enabled\n     */\n\n\n    function createDisabledPseudo(disabled) {\n      // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n      return function (elem) {\n        // Only certain elements can match :enabled or :disabled\n        // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n        // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n        if (\"form\" in elem) {\n          // Check for inherited disabledness on relevant non-disabled elements:\n          // * listed form-associated elements in a disabled fieldset\n          //   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n          //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n          // * option elements in a disabled optgroup\n          //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n          // All such elements have a \"form\" property.\n          if (elem.parentNode && elem.disabled === false) {\n            // Option elements defer to a parent optgroup if present\n            if (\"label\" in elem) {\n              if (\"label\" in elem.parentNode) {\n                return elem.parentNode.disabled === disabled;\n              } else {\n                return elem.disabled === disabled;\n              }\n            } // Support: IE 6 - 11\n            // Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\n\n            return elem.isDisabled === disabled || // Where there is no isDisabled, check manually\n\n            /* jshint -W018 */\n            elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;\n          }\n\n          return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property.\n          // Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n          // even exist on them, let alone have a boolean value.\n        } else if (\"label\" in elem) {\n          return elem.disabled === disabled;\n        } // Remaining elements are neither :enabled nor :disabled\n\n\n        return false;\n      };\n    }\n    /**\n     * Returns a function to use in pseudos for positionals\n     * @param {Function} fn\n     */\n\n\n    function createPositionalPseudo(fn) {\n      return markFunction(function (argument) {\n        argument = +argument;\n        return markFunction(function (seed, matches) {\n          var j,\n              matchIndexes = fn([], seed.length, argument),\n              i = matchIndexes.length; // Match elements found at the specified indexes\n\n          while (i--) {\n            if (seed[j = matchIndexes[i]]) {\n              seed[j] = !(matches[j] = seed[j]);\n            }\n          }\n        });\n      });\n    }\n    /**\n     * Checks a node for validity as a Sizzle context\n     * @param {Element|Object=} context\n     * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n     */\n\n\n    function testContext(context) {\n      return context && typeof context.getElementsByTagName !== \"undefined\" && context;\n    } // Expose support vars for convenience\n\n\n    support = Sizzle.support = {};\n    /**\n     * Detects XML nodes\n     * @param {Element|Object} elem An element or a document\n     * @returns {Boolean} True iff elem is a non-HTML XML node\n     */\n\n    isXML = Sizzle.isXML = function (elem) {\n      var namespace = elem && elem.namespaceURI,\n          docElem = elem && (elem.ownerDocument || elem).documentElement; // Support: IE <=8\n      // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n      // https://bugs.jquery.com/ticket/4833\n\n      return !rhtml.test(namespace || docElem && docElem.nodeName || \"HTML\");\n    };\n    /**\n     * Sets document-related variables once based on the current document\n     * @param {Element|Object} [doc] An element or document object to use to set the document\n     * @returns {Object} Returns the current document\n     */\n\n\n    setDocument = Sizzle.setDocument = function (node) {\n      var hasCompare,\n          subWindow,\n          doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n\n      if (doc == document || doc.nodeType !== 9 || !doc.documentElement) {\n        return document;\n      } // Update global variables\n\n\n      document = doc;\n      docElem = document.documentElement;\n      documentIsHTML = !isXML(document); // Support: IE 9 - 11+, Edge 12 - 18+\n      // Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n\n      if (preferredDoc != document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {\n        // Support: IE 11, Edge\n        if (subWindow.addEventListener) {\n          subWindow.addEventListener(\"unload\", unloadHandler, false); // Support: IE 9 - 10 only\n        } else if (subWindow.attachEvent) {\n          subWindow.attachEvent(\"onunload\", unloadHandler);\n        }\n      } // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\n      // Safari 4 - 5 only, Opera <=11.6 - 12.x only\n      // IE/Edge & older browsers don't support the :scope pseudo-class.\n      // Support: Safari 6.0 only\n      // Safari 6.0 supports :scope but it's an alias of :root there.\n\n\n      support.scope = assert(function (el) {\n        docElem.appendChild(el).appendChild(document.createElement(\"div\"));\n        return typeof el.querySelectorAll !== \"undefined\" && !el.querySelectorAll(\":scope fieldset div\").length;\n      });\n      /* Attributes\n      ---------------------------------------------------------------------- */\n      // Support: IE<8\n      // Verify that getAttribute really returns attributes and not properties\n      // (excepting IE8 booleans)\n\n      support.attributes = assert(function (el) {\n        el.className = \"i\";\n        return !el.getAttribute(\"className\");\n      });\n      /* getElement(s)By*\n      ---------------------------------------------------------------------- */\n      // Check if getElementsByTagName(\"*\") returns only elements\n\n      support.getElementsByTagName = assert(function (el) {\n        el.appendChild(document.createComment(\"\"));\n        return !el.getElementsByTagName(\"*\").length;\n      }); // Support: IE<9\n\n      support.getElementsByClassName = rnative.test(document.getElementsByClassName); // Support: IE<10\n      // Check if getElementById returns elements by name\n      // The broken getElementById methods don't pick up programmatically-set names,\n      // so use a roundabout getElementsByName test\n\n      support.getById = assert(function (el) {\n        docElem.appendChild(el).id = expando;\n        return !document.getElementsByName || !document.getElementsByName(expando).length;\n      }); // ID filter and find\n\n      if (support.getById) {\n        Expr.filter[\"ID\"] = function (id) {\n          var attrId = id.replace(runescape, funescape);\n          return function (elem) {\n            return elem.getAttribute(\"id\") === attrId;\n          };\n        };\n\n        Expr.find[\"ID\"] = function (id, context) {\n          if (typeof context.getElementById !== \"undefined\" && documentIsHTML) {\n            var elem = context.getElementById(id);\n            return elem ? [elem] : [];\n          }\n        };\n      } else {\n        Expr.filter[\"ID\"] = function (id) {\n          var attrId = id.replace(runescape, funescape);\n          return function (elem) {\n            var node = typeof elem.getAttributeNode !== \"undefined\" && elem.getAttributeNode(\"id\");\n            return node && node.value === attrId;\n          };\n        }; // Support: IE 6 - 7 only\n        // getElementById is not reliable as a find shortcut\n\n\n        Expr.find[\"ID\"] = function (id, context) {\n          if (typeof context.getElementById !== \"undefined\" && documentIsHTML) {\n            var node,\n                i,\n                elems,\n                elem = context.getElementById(id);\n\n            if (elem) {\n              // Verify the id attribute\n              node = elem.getAttributeNode(\"id\");\n\n              if (node && node.value === id) {\n                return [elem];\n              } // Fall back on getElementsByName\n\n\n              elems = context.getElementsByName(id);\n              i = 0;\n\n              while (elem = elems[i++]) {\n                node = elem.getAttributeNode(\"id\");\n\n                if (node && node.value === id) {\n                  return [elem];\n                }\n              }\n            }\n\n            return [];\n          }\n        };\n      } // Tag\n\n\n      Expr.find[\"TAG\"] = support.getElementsByTagName ? function (tag, context) {\n        if (typeof context.getElementsByTagName !== \"undefined\") {\n          return context.getElementsByTagName(tag); // DocumentFragment nodes don't have gEBTN\n        } else if (support.qsa) {\n          return context.querySelectorAll(tag);\n        }\n      } : function (tag, context) {\n        var elem,\n            tmp = [],\n            i = 0,\n            // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n        results = context.getElementsByTagName(tag); // Filter out possible comments\n\n        if (tag === \"*\") {\n          while (elem = results[i++]) {\n            if (elem.nodeType === 1) {\n              tmp.push(elem);\n            }\n          }\n\n          return tmp;\n        }\n\n        return results;\n      }; // Class\n\n      Expr.find[\"CLASS\"] = support.getElementsByClassName && function (className, context) {\n        if (typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML) {\n          return context.getElementsByClassName(className);\n        }\n      };\n      /* QSA/matchesSelector\n      ---------------------------------------------------------------------- */\n      // QSA and matchesSelector support\n      // matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\n\n      rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21)\n      // We allow this because of a bug in IE8/9 that throws an error\n      // whenever `document.activeElement` is accessed on an iframe\n      // So, we allow :focus to pass through QSA all the time to avoid the IE error\n      // See https://bugs.jquery.com/ticket/13378\n\n      rbuggyQSA = [];\n\n      if (support.qsa = rnative.test(document.querySelectorAll)) {\n        // Build QSA regex\n        // Regex strategy adopted from Diego Perini\n        assert(function (el) {\n          var input; // Select is set to empty string on purpose\n          // This is to test IE's treatment of not explicitly\n          // setting a boolean content attribute,\n          // since its presence should be enough\n          // https://bugs.jquery.com/ticket/12359\n\n          docElem.appendChild(el).innerHTML = \"<a id='\" + expando + \"'></a>\" + \"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" + \"<option selected=''></option></select>\"; // Support: IE8, Opera 11-12.16\n          // Nothing should be selected when empty strings follow ^= or $= or *=\n          // The test attribute must be unknown in Opera but \"safe\" for WinRT\n          // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\n          if (el.querySelectorAll(\"[msallowcapture^='']\").length) {\n            rbuggyQSA.push(\"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\");\n          } // Support: IE8\n          // Boolean attributes and \"value\" are not treated correctly\n\n\n          if (!el.querySelectorAll(\"[selected]\").length) {\n            rbuggyQSA.push(\"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\");\n          } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\n\n          if (!el.querySelectorAll(\"[id~=\" + expando + \"-]\").length) {\n            rbuggyQSA.push(\"~=\");\n          } // Support: IE 11+, Edge 15 - 18+\n          // IE 11/Edge don't find elements on a `[name='']` query in some cases.\n          // Adding a temporary attribute to the document before the selection works\n          // around the issue.\n          // Interestingly, IE 10 & older don't seem to have the issue.\n\n\n          input = document.createElement(\"input\");\n          input.setAttribute(\"name\", \"\");\n          el.appendChild(input);\n\n          if (!el.querySelectorAll(\"[name='']\").length) {\n            rbuggyQSA.push(\"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" + whitespace + \"*(?:''|\\\"\\\")\");\n          } // Webkit/Opera - :checked should return selected option elements\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n          // IE8 throws error here and will not see later tests\n\n\n          if (!el.querySelectorAll(\":checked\").length) {\n            rbuggyQSA.push(\":checked\");\n          } // Support: Safari 8+, iOS 8+\n          // https://bugs.webkit.org/show_bug.cgi?id=136851\n          // In-page `selector#id sibling-combinator selector` fails\n\n\n          if (!el.querySelectorAll(\"a#\" + expando + \"+*\").length) {\n            rbuggyQSA.push(\".#.+[+~]\");\n          } // Support: Firefox <=3.6 - 5 only\n          // Old Firefox doesn't throw on a badly-escaped identifier.\n\n\n          el.querySelectorAll(\"\\\\\\f\");\n          rbuggyQSA.push(\"[\\\\r\\\\n\\\\f]\");\n        });\n        assert(function (el) {\n          el.innerHTML = \"<a href='' disabled='disabled'></a>\" + \"<select disabled='disabled'><option/></select>\"; // Support: Windows 8 Native Apps\n          // The type and name attributes are restricted during .innerHTML assignment\n\n          var input = document.createElement(\"input\");\n          input.setAttribute(\"type\", \"hidden\");\n          el.appendChild(input).setAttribute(\"name\", \"D\"); // Support: IE8\n          // Enforce case-sensitivity of name attribute\n\n          if (el.querySelectorAll(\"[name=d]\").length) {\n            rbuggyQSA.push(\"name\" + whitespace + \"*[*^$|!~]?=\");\n          } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n          // IE8 throws error here and will not see later tests\n\n\n          if (el.querySelectorAll(\":enabled\").length !== 2) {\n            rbuggyQSA.push(\":enabled\", \":disabled\");\n          } // Support: IE9-11+\n          // IE's :disabled selector does not pick up the children of disabled fieldsets\n\n\n          docElem.appendChild(el).disabled = true;\n\n          if (el.querySelectorAll(\":disabled\").length !== 2) {\n            rbuggyQSA.push(\":enabled\", \":disabled\");\n          } // Support: Opera 10 - 11 only\n          // Opera 10-11 does not throw on post-comma invalid pseudos\n\n\n          el.querySelectorAll(\"*,:x\");\n          rbuggyQSA.push(\",.*:\");\n        });\n      }\n\n      if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {\n        assert(function (el) {\n          // Check to see if it's possible to do matchesSelector\n          // on a disconnected node (IE 9)\n          support.disconnectedMatch = matches.call(el, \"*\"); // This should fail with an exception\n          // Gecko does not error, returns false instead\n\n          matches.call(el, \"[s!='']:x\");\n          rbuggyMatches.push(\"!=\", pseudos);\n        });\n      }\n\n      rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join(\"|\"));\n      rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join(\"|\"));\n      /* Contains\n      ---------------------------------------------------------------------- */\n\n      hasCompare = rnative.test(docElem.compareDocumentPosition); // Element contains another\n      // Purposefully self-exclusive\n      // As in, an element does not contain itself\n\n      contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {\n        var adown = a.nodeType === 9 ? a.documentElement : a,\n            bup = b && b.parentNode;\n        return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));\n      } : function (a, b) {\n        if (b) {\n          while (b = b.parentNode) {\n            if (b === a) {\n              return true;\n            }\n          }\n        }\n\n        return false;\n      };\n      /* Sorting\n      ---------------------------------------------------------------------- */\n      // Document order sorting\n\n      sortOrder = hasCompare ? function (a, b) {\n        // Flag for duplicate removal\n        if (a === b) {\n          hasDuplicate = true;\n          return 0;\n        } // Sort on method existence if only one input has compareDocumentPosition\n\n\n        var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\n        if (compare) {\n          return compare;\n        } // Calculate position if both inputs belong to the same document\n        // Support: IE 11+, Edge 17 - 18+\n        // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n        // two documents; shallow comparisons work.\n        // eslint-disable-next-line eqeqeq\n\n\n        compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : // Otherwise we know they are disconnected\n        1; // Disconnected nodes\n\n        if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {\n          // Choose the first element that is related to our preferred document\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          // eslint-disable-next-line eqeqeq\n          if (a == document || a.ownerDocument == preferredDoc && contains(preferredDoc, a)) {\n            return -1;\n          } // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          // eslint-disable-next-line eqeqeq\n\n\n          if (b == document || b.ownerDocument == preferredDoc && contains(preferredDoc, b)) {\n            return 1;\n          } // Maintain original order\n\n\n          return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;\n        }\n\n        return compare & 4 ? -1 : 1;\n      } : function (a, b) {\n        // Exit early if the nodes are identical\n        if (a === b) {\n          hasDuplicate = true;\n          return 0;\n        }\n\n        var cur,\n            i = 0,\n            aup = a.parentNode,\n            bup = b.parentNode,\n            ap = [a],\n            bp = [b]; // Parentless nodes are either documents or disconnected\n\n        if (!aup || !bup) {\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n\n          /* eslint-disable eqeqeq */\n          return a == document ? -1 : b == document ? 1 :\n          /* eslint-enable eqeqeq */\n          aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0; // If the nodes are siblings, we can do a quick check\n        } else if (aup === bup) {\n          return siblingCheck(a, b);\n        } // Otherwise we need full lists of their ancestors for comparison\n\n\n        cur = a;\n\n        while (cur = cur.parentNode) {\n          ap.unshift(cur);\n        }\n\n        cur = b;\n\n        while (cur = cur.parentNode) {\n          bp.unshift(cur);\n        } // Walk down the tree looking for a discrepancy\n\n\n        while (ap[i] === bp[i]) {\n          i++;\n        }\n\n        return i ? // Do a sibling check if the nodes have a common ancestor\n        siblingCheck(ap[i], bp[i]) : // Otherwise nodes in our document sort first\n        // Support: IE 11+, Edge 17 - 18+\n        // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n        // two documents; shallow comparisons work.\n\n        /* eslint-disable eqeqeq */\n        ap[i] == preferredDoc ? -1 : bp[i] == preferredDoc ? 1 :\n        /* eslint-enable eqeqeq */\n        0;\n      };\n      return document;\n    };\n\n    Sizzle.matches = function (expr, elements) {\n      return Sizzle(expr, null, null, elements);\n    };\n\n    Sizzle.matchesSelector = function (elem, expr) {\n      setDocument(elem);\n\n      if (support.matchesSelector && documentIsHTML && !nonnativeSelectorCache[expr + \" \"] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {\n        try {\n          var ret = matches.call(elem, expr); // IE 9's matchesSelector returns false on disconnected nodes\n\n          if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document\n          // fragment in IE 9\n          elem.document && elem.document.nodeType !== 11) {\n            return ret;\n          }\n        } catch (e) {\n          nonnativeSelectorCache(expr, true);\n        }\n      }\n\n      return Sizzle(expr, document, null, [elem]).length > 0;\n    };\n\n    Sizzle.contains = function (context, elem) {\n      // Set document vars if needed\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n      if ((context.ownerDocument || context) != document) {\n        setDocument(context);\n      }\n\n      return contains(context, elem);\n    };\n\n    Sizzle.attr = function (elem, name) {\n      // Set document vars if needed\n      // Support: IE 11+, Edge 17 - 18+\n      // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n      // two documents; shallow comparisons work.\n      // eslint-disable-next-line eqeqeq\n      if ((elem.ownerDocument || elem) != document) {\n        setDocument(elem);\n      }\n\n      var fn = Expr.attrHandle[name.toLowerCase()],\n          // Don't get fooled by Object.prototype properties (jQuery #13807)\n      val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;\n      return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;\n    };\n\n    Sizzle.escape = function (sel) {\n      return (sel + \"\").replace(rcssescape, fcssescape);\n    };\n\n    Sizzle.error = function (msg) {\n      throw new Error(\"Syntax error, unrecognized expression: \" + msg);\n    };\n    /**\n     * Document sorting and removing duplicates\n     * @param {ArrayLike} results\n     */\n\n\n    Sizzle.uniqueSort = function (results) {\n      var elem,\n          duplicates = [],\n          j = 0,\n          i = 0; // Unless we *know* we can detect duplicates, assume their presence\n\n      hasDuplicate = !support.detectDuplicates;\n      sortInput = !support.sortStable && results.slice(0);\n      results.sort(sortOrder);\n\n      if (hasDuplicate) {\n        while (elem = results[i++]) {\n          if (elem === results[i]) {\n            j = duplicates.push(i);\n          }\n        }\n\n        while (j--) {\n          results.splice(duplicates[j], 1);\n        }\n      } // Clear input after sorting to release objects\n      // See https://github.com/jquery/sizzle/pull/225\n\n\n      sortInput = null;\n      return results;\n    };\n    /**\n     * Utility function for retrieving the text value of an array of DOM nodes\n     * @param {Array|Element} elem\n     */\n\n\n    getText = Sizzle.getText = function (elem) {\n      var node,\n          ret = \"\",\n          i = 0,\n          nodeType = elem.nodeType;\n\n      if (!nodeType) {\n        // If no nodeType, this is expected to be an array\n        while (node = elem[i++]) {\n          // Do not traverse comment nodes\n          ret += getText(node);\n        }\n      } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {\n        // Use textContent for elements\n        // innerText usage removed for consistency of new lines (jQuery #11153)\n        if (typeof elem.textContent === \"string\") {\n          return elem.textContent;\n        } else {\n          // Traverse its children\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\n            ret += getText(elem);\n          }\n        }\n      } else if (nodeType === 3 || nodeType === 4) {\n        return elem.nodeValue;\n      } // Do not include comment or processing instruction nodes\n\n\n      return ret;\n    };\n\n    Expr = Sizzle.selectors = {\n      // Can be adjusted by the user\n      cacheLength: 50,\n      createPseudo: markFunction,\n      match: matchExpr,\n      attrHandle: {},\n      find: {},\n      relative: {\n        \">\": {\n          dir: \"parentNode\",\n          first: true\n        },\n        \" \": {\n          dir: \"parentNode\"\n        },\n        \"+\": {\n          dir: \"previousSibling\",\n          first: true\n        },\n        \"~\": {\n          dir: \"previousSibling\"\n        }\n      },\n      preFilter: {\n        \"ATTR\": function ATTR(match) {\n          match[1] = match[1].replace(runescape, funescape); // Move the given value to match[3] whether quoted or unquoted\n\n          match[3] = (match[3] || match[4] || match[5] || \"\").replace(runescape, funescape);\n\n          if (match[2] === \"~=\") {\n            match[3] = \" \" + match[3] + \" \";\n          }\n\n          return match.slice(0, 4);\n        },\n        \"CHILD\": function CHILD(match) {\n          /* matches from matchExpr[\"CHILD\"]\n          \t1 type (only|nth|...)\n          \t2 what (child|of-type)\n          \t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n          \t4 xn-component of xn+y argument ([+-]?\\d*n|)\n          \t5 sign of xn-component\n          \t6 x of xn-component\n          \t7 sign of y-component\n          \t8 y of y-component\n          */\n          match[1] = match[1].toLowerCase();\n\n          if (match[1].slice(0, 3) === \"nth\") {\n            // nth-* requires argument\n            if (!match[3]) {\n              Sizzle.error(match[0]);\n            } // numeric x and y parameters for Expr.filter.CHILD\n            // remember that false/true cast respectively to 0/1\n\n\n            match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === \"even\" || match[3] === \"odd\"));\n            match[5] = +(match[7] + match[8] || match[3] === \"odd\"); // other types prohibit arguments\n          } else if (match[3]) {\n            Sizzle.error(match[0]);\n          }\n\n          return match;\n        },\n        \"PSEUDO\": function PSEUDO(match) {\n          var excess,\n              unquoted = !match[6] && match[2];\n\n          if (matchExpr[\"CHILD\"].test(match[0])) {\n            return null;\n          } // Accept quoted arguments as-is\n\n\n          if (match[3]) {\n            match[2] = match[4] || match[5] || \"\"; // Strip excess characters from unquoted arguments\n          } else if (unquoted && rpseudo.test(unquoted) && ( // Get excess from tokenize (recursively)\n          excess = tokenize(unquoted, true)) && ( // advance to the next closing parenthesis\n          excess = unquoted.indexOf(\")\", unquoted.length - excess) - unquoted.length)) {\n            // excess is a negative index\n            match[0] = match[0].slice(0, excess);\n            match[2] = unquoted.slice(0, excess);\n          } // Return only captures needed by the pseudo filter method (type and argument)\n\n\n          return match.slice(0, 3);\n        }\n      },\n      filter: {\n        \"TAG\": function TAG(nodeNameSelector) {\n          var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();\n          return nodeNameSelector === \"*\" ? function () {\n            return true;\n          } : function (elem) {\n            return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n          };\n        },\n        \"CLASS\": function CLASS(className) {\n          var pattern = classCache[className + \" \"];\n          return pattern || (pattern = new RegExp(\"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\")) && classCache(className, function (elem) {\n            return pattern.test(typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== \"undefined\" && elem.getAttribute(\"class\") || \"\");\n          });\n        },\n        \"ATTR\": function ATTR(name, operator, check) {\n          return function (elem) {\n            var result = Sizzle.attr(elem, name);\n\n            if (result == null) {\n              return operator === \"!=\";\n            }\n\n            if (!operator) {\n              return true;\n            }\n\n            result += \"\";\n            /* eslint-disable max-len */\n\n            return operator === \"=\" ? result === check : operator === \"!=\" ? result !== check : operator === \"^=\" ? check && result.indexOf(check) === 0 : operator === \"*=\" ? check && result.indexOf(check) > -1 : operator === \"$=\" ? check && result.slice(-check.length) === check : operator === \"~=\" ? (\" \" + result.replace(rwhitespace, \" \") + \" \").indexOf(check) > -1 : operator === \"|=\" ? result === check || result.slice(0, check.length + 1) === check + \"-\" : false;\n            /* eslint-enable max-len */\n          };\n        },\n        \"CHILD\": function CHILD(type, what, _argument, first, last) {\n          var simple = type.slice(0, 3) !== \"nth\",\n              forward = type.slice(-4) !== \"last\",\n              ofType = what === \"of-type\";\n          return first === 1 && last === 0 ? // Shortcut for :nth-*(n)\n          function (elem) {\n            return !!elem.parentNode;\n          } : function (elem, _context, xml) {\n            var cache,\n                uniqueCache,\n                outerCache,\n                node,\n                nodeIndex,\n                start,\n                dir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n                parent = elem.parentNode,\n                name = ofType && elem.nodeName.toLowerCase(),\n                useCache = !xml && !ofType,\n                diff = false;\n\n            if (parent) {\n              // :(first|last|only)-(child|of-type)\n              if (simple) {\n                while (dir) {\n                  node = elem;\n\n                  while (node = node[dir]) {\n                    if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {\n                      return false;\n                    }\n                  } // Reverse direction for :only-* (if we haven't yet done so)\n\n\n                  start = dir = type === \"only\" && !start && \"nextSibling\";\n                }\n\n                return true;\n              }\n\n              start = [forward ? parent.firstChild : parent.lastChild]; // non-xml :nth-child(...) stores cache data on `parent`\n\n              if (forward && useCache) {\n                // Seek `elem` from a previously-cached index\n                // ...in a gzip-friendly way\n                node = parent;\n                outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only\n                // Defend against cloned attroperties (jQuery gh-1709)\n\n                uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});\n                cache = uniqueCache[type] || [];\n                nodeIndex = cache[0] === dirruns && cache[1];\n                diff = nodeIndex && cache[2];\n                node = nodeIndex && parent.childNodes[nodeIndex];\n\n                while (node = ++nodeIndex && node && node[dir] || ( // Fallback to seeking `elem` from the start\n                diff = nodeIndex = 0) || start.pop()) {\n                  // When found, cache indexes on `parent` and break\n                  if (node.nodeType === 1 && ++diff && node === elem) {\n                    uniqueCache[type] = [dirruns, nodeIndex, diff];\n                    break;\n                  }\n                }\n              } else {\n                // Use previously-cached element index if available\n                if (useCache) {\n                  // ...in a gzip-friendly way\n                  node = elem;\n                  outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only\n                  // Defend against cloned attroperties (jQuery gh-1709)\n\n                  uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});\n                  cache = uniqueCache[type] || [];\n                  nodeIndex = cache[0] === dirruns && cache[1];\n                  diff = nodeIndex;\n                } // xml :nth-child(...)\n                // or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\n\n                if (diff === false) {\n                  // Use the same loop as above to seek `elem` from the start\n                  while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {\n                    if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {\n                      // Cache the index of each encountered element\n                      if (useCache) {\n                        outerCache = node[expando] || (node[expando] = {}); // Support: IE <9 only\n                        // Defend against cloned attroperties (jQuery gh-1709)\n\n                        uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});\n                        uniqueCache[type] = [dirruns, diff];\n                      }\n\n                      if (node === elem) {\n                        break;\n                      }\n                    }\n                  }\n                }\n              } // Incorporate the offset, then check against cycle size\n\n\n              diff -= last;\n              return diff === first || diff % first === 0 && diff / first >= 0;\n            }\n          };\n        },\n        \"PSEUDO\": function PSEUDO(pseudo, argument) {\n          // pseudo-class names are case-insensitive\n          // http://www.w3.org/TR/selectors/#pseudo-classes\n          // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n          // Remember that setFilters inherits from pseudos\n          var args,\n              fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error(\"unsupported pseudo: \" + pseudo); // The user may use createPseudo to indicate that\n          // arguments are needed to create the filter function\n          // just as Sizzle does\n\n          if (fn[expando]) {\n            return fn(argument);\n          } // But maintain support for old signatures\n\n\n          if (fn.length > 1) {\n            args = [pseudo, pseudo, \"\", argument];\n            return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {\n              var idx,\n                  matched = fn(seed, argument),\n                  i = matched.length;\n\n              while (i--) {\n                idx = indexOf(seed, matched[i]);\n                seed[idx] = !(matches[idx] = matched[i]);\n              }\n            }) : function (elem) {\n              return fn(elem, 0, args);\n            };\n          }\n\n          return fn;\n        }\n      },\n      pseudos: {\n        // Potentially complex pseudos\n        \"not\": markFunction(function (selector) {\n          // Trim the selector passed to compile\n          // to avoid treating leading and trailing\n          // spaces as combinators\n          var input = [],\n              results = [],\n              matcher = compile(selector.replace(rtrim, \"$1\"));\n          return matcher[expando] ? markFunction(function (seed, matches, _context, xml) {\n            var elem,\n                unmatched = matcher(seed, null, xml, []),\n                i = seed.length; // Match elements unmatched by `matcher`\n\n            while (i--) {\n              if (elem = unmatched[i]) {\n                seed[i] = !(matches[i] = elem);\n              }\n            }\n          }) : function (elem, _context, xml) {\n            input[0] = elem;\n            matcher(input, null, xml, results); // Don't keep the element (issue #299)\n\n            input[0] = null;\n            return !results.pop();\n          };\n        }),\n        \"has\": markFunction(function (selector) {\n          return function (elem) {\n            return Sizzle(selector, elem).length > 0;\n          };\n        }),\n        \"contains\": markFunction(function (text) {\n          text = text.replace(runescape, funescape);\n          return function (elem) {\n            return (elem.textContent || getText(elem)).indexOf(text) > -1;\n          };\n        }),\n        // \"Whether an element is represented by a :lang() selector\n        // is based solely on the element's language value\n        // being equal to the identifier C,\n        // or beginning with the identifier C immediately followed by \"-\".\n        // The matching of C against the element's language value is performed case-insensitively.\n        // The identifier C does not have to be a valid language name.\"\n        // http://www.w3.org/TR/selectors/#lang-pseudo\n        \"lang\": markFunction(function (lang) {\n          // lang value must be a valid identifier\n          if (!ridentifier.test(lang || \"\")) {\n            Sizzle.error(\"unsupported lang: \" + lang);\n          }\n\n          lang = lang.replace(runescape, funescape).toLowerCase();\n          return function (elem) {\n            var elemLang;\n\n            do {\n              if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) {\n                elemLang = elemLang.toLowerCase();\n                return elemLang === lang || elemLang.indexOf(lang + \"-\") === 0;\n              }\n            } while ((elem = elem.parentNode) && elem.nodeType === 1);\n\n            return false;\n          };\n        }),\n        // Miscellaneous\n        \"target\": function target(elem) {\n          var hash = window.location && window.location.hash;\n          return hash && hash.slice(1) === elem.id;\n        },\n        \"root\": function root(elem) {\n          return elem === docElem;\n        },\n        \"focus\": function focus(elem) {\n          return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n        },\n        // Boolean properties\n        \"enabled\": createDisabledPseudo(false),\n        \"disabled\": createDisabledPseudo(true),\n        \"checked\": function checked(elem) {\n          // In CSS3, :checked should return both checked and selected elements\n          // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n          var nodeName = elem.nodeName.toLowerCase();\n          return nodeName === \"input\" && !!elem.checked || nodeName === \"option\" && !!elem.selected;\n        },\n        \"selected\": function selected(elem) {\n          // Accessing this property makes selected-by-default\n          // options in Safari work properly\n          if (elem.parentNode) {\n            // eslint-disable-next-line no-unused-expressions\n            elem.parentNode.selectedIndex;\n          }\n\n          return elem.selected === true;\n        },\n        // Contents\n        \"empty\": function empty(elem) {\n          // http://www.w3.org/TR/selectors/#empty-pseudo\n          // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n          //   but not by others (comment: 8; processing instruction: 7; etc.)\n          // nodeType < 6 works because attributes (2) do not appear as children\n          for (elem = elem.firstChild; elem; elem = elem.nextSibling) {\n            if (elem.nodeType < 6) {\n              return false;\n            }\n          }\n\n          return true;\n        },\n        \"parent\": function parent(elem) {\n          return !Expr.pseudos[\"empty\"](elem);\n        },\n        // Element/input types\n        \"header\": function header(elem) {\n          return rheader.test(elem.nodeName);\n        },\n        \"input\": function input(elem) {\n          return rinputs.test(elem.nodeName);\n        },\n        \"button\": function button(elem) {\n          var name = elem.nodeName.toLowerCase();\n          return name === \"input\" && elem.type === \"button\" || name === \"button\";\n        },\n        \"text\": function text(elem) {\n          var attr;\n          return elem.nodeName.toLowerCase() === \"input\" && elem.type === \"text\" && ( // Support: IE<8\n          // New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n          (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\");\n        },\n        // Position-in-collection\n        \"first\": createPositionalPseudo(function () {\n          return [0];\n        }),\n        \"last\": createPositionalPseudo(function (_matchIndexes, length) {\n          return [length - 1];\n        }),\n        \"eq\": createPositionalPseudo(function (_matchIndexes, length, argument) {\n          return [argument < 0 ? argument + length : argument];\n        }),\n        \"even\": createPositionalPseudo(function (matchIndexes, length) {\n          var i = 0;\n\n          for (; i < length; i += 2) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        }),\n        \"odd\": createPositionalPseudo(function (matchIndexes, length) {\n          var i = 1;\n\n          for (; i < length; i += 2) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        }),\n        \"lt\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          var i = argument < 0 ? argument + length : argument > length ? length : argument;\n\n          for (; --i >= 0;) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        }),\n        \"gt\": createPositionalPseudo(function (matchIndexes, length, argument) {\n          var i = argument < 0 ? argument + length : argument;\n\n          for (; ++i < length;) {\n            matchIndexes.push(i);\n          }\n\n          return matchIndexes;\n        })\n      }\n    };\n    Expr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"]; // Add button/input type pseudos\n\n    for (i in {\n      radio: true,\n      checkbox: true,\n      file: true,\n      password: true,\n      image: true\n    }) {\n      Expr.pseudos[i] = createInputPseudo(i);\n    }\n\n    for (i in {\n      submit: true,\n      reset: true\n    }) {\n      Expr.pseudos[i] = createButtonPseudo(i);\n    } // Easy API for creating new setFilters\n\n\n    function setFilters() {}\n\n    setFilters.prototype = Expr.filters = Expr.pseudos;\n    Expr.setFilters = new setFilters();\n\n    tokenize = Sizzle.tokenize = function (selector, parseOnly) {\n      var matched,\n          match,\n          tokens,\n          type,\n          soFar,\n          groups,\n          preFilters,\n          cached = tokenCache[selector + \" \"];\n\n      if (cached) {\n        return parseOnly ? 0 : cached.slice(0);\n      }\n\n      soFar = selector;\n      groups = [];\n      preFilters = Expr.preFilter;\n\n      while (soFar) {\n        // Comma and first run\n        if (!matched || (match = rcomma.exec(soFar))) {\n          if (match) {\n            // Don't consume trailing commas as valid\n            soFar = soFar.slice(match[0].length) || soFar;\n          }\n\n          groups.push(tokens = []);\n        }\n\n        matched = false; // Combinators\n\n        if (match = rcombinators.exec(soFar)) {\n          matched = match.shift();\n          tokens.push({\n            value: matched,\n            // Cast descendant combinators to space\n            type: match[0].replace(rtrim, \" \")\n          });\n          soFar = soFar.slice(matched.length);\n        } // Filters\n\n\n        for (type in Expr.filter) {\n          if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {\n            matched = match.shift();\n            tokens.push({\n              value: matched,\n              type: type,\n              matches: match\n            });\n            soFar = soFar.slice(matched.length);\n          }\n        }\n\n        if (!matched) {\n          break;\n        }\n      } // Return the length of the invalid excess\n      // if we're just parsing\n      // Otherwise, throw an error or return tokens\n\n\n      return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : // Cache the tokens\n      tokenCache(selector, groups).slice(0);\n    };\n\n    function toSelector(tokens) {\n      var i = 0,\n          len = tokens.length,\n          selector = \"\";\n\n      for (; i < len; i++) {\n        selector += tokens[i].value;\n      }\n\n      return selector;\n    }\n\n    function addCombinator(matcher, combinator, base) {\n      var dir = combinator.dir,\n          skip = combinator.next,\n          key = skip || dir,\n          checkNonElements = base && key === \"parentNode\",\n          doneName = done++;\n      return combinator.first ? // Check against closest ancestor/preceding element\n      function (elem, context, xml) {\n        while (elem = elem[dir]) {\n          if (elem.nodeType === 1 || checkNonElements) {\n            return matcher(elem, context, xml);\n          }\n        }\n\n        return false;\n      } : // Check against all ancestor/preceding elements\n      function (elem, context, xml) {\n        var oldCache,\n            uniqueCache,\n            outerCache,\n            newCache = [dirruns, doneName]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\n        if (xml) {\n          while (elem = elem[dir]) {\n            if (elem.nodeType === 1 || checkNonElements) {\n              if (matcher(elem, context, xml)) {\n                return true;\n              }\n            }\n          }\n        } else {\n          while (elem = elem[dir]) {\n            if (elem.nodeType === 1 || checkNonElements) {\n              outerCache = elem[expando] || (elem[expando] = {}); // Support: IE <9 only\n              // Defend against cloned attroperties (jQuery gh-1709)\n\n              uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});\n\n              if (skip && skip === elem.nodeName.toLowerCase()) {\n                elem = elem[dir] || elem;\n              } else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {\n                // Assign to newCache so results back-propagate to previous elements\n                return newCache[2] = oldCache[2];\n              } else {\n                // Reuse newcache so results back-propagate to previous elements\n                uniqueCache[key] = newCache; // A match means we're done; a fail means we have to keep checking\n\n                if (newCache[2] = matcher(elem, context, xml)) {\n                  return true;\n                }\n              }\n            }\n          }\n        }\n\n        return false;\n      };\n    }\n\n    function elementMatcher(matchers) {\n      return matchers.length > 1 ? function (elem, context, xml) {\n        var i = matchers.length;\n\n        while (i--) {\n          if (!matchers[i](elem, context, xml)) {\n            return false;\n          }\n        }\n\n        return true;\n      } : matchers[0];\n    }\n\n    function multipleContexts(selector, contexts, results) {\n      var i = 0,\n          len = contexts.length;\n\n      for (; i < len; i++) {\n        Sizzle(selector, contexts[i], results);\n      }\n\n      return results;\n    }\n\n    function condense(unmatched, map, filter, context, xml) {\n      var elem,\n          newUnmatched = [],\n          i = 0,\n          len = unmatched.length,\n          mapped = map != null;\n\n      for (; i < len; i++) {\n        if (elem = unmatched[i]) {\n          if (!filter || filter(elem, context, xml)) {\n            newUnmatched.push(elem);\n\n            if (mapped) {\n              map.push(i);\n            }\n          }\n        }\n      }\n\n      return newUnmatched;\n    }\n\n    function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {\n      if (postFilter && !postFilter[expando]) {\n        postFilter = setMatcher(postFilter);\n      }\n\n      if (postFinder && !postFinder[expando]) {\n        postFinder = setMatcher(postFinder, postSelector);\n      }\n\n      return markFunction(function (seed, results, context, xml) {\n        var temp,\n            i,\n            elem,\n            preMap = [],\n            postMap = [],\n            preexisting = results.length,\n            // Get initial elements from seed or context\n        elems = seed || multipleContexts(selector || \"*\", context.nodeType ? [context] : context, []),\n            // Prefilter to get matcher input, preserving a map for seed-results synchronization\n        matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,\n            matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n        postFinder || (seed ? preFilter : preexisting || postFilter) ? // ...intermediate processing is necessary\n        [] : // ...otherwise use results directly\n        results : matcherIn; // Find primary matches\n\n        if (matcher) {\n          matcher(matcherIn, matcherOut, context, xml);\n        } // Apply postFilter\n\n\n        if (postFilter) {\n          temp = condense(matcherOut, postMap);\n          postFilter(temp, [], context, xml); // Un-match failing elements by moving them back to matcherIn\n\n          i = temp.length;\n\n          while (i--) {\n            if (elem = temp[i]) {\n              matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);\n            }\n          }\n        }\n\n        if (seed) {\n          if (postFinder || preFilter) {\n            if (postFinder) {\n              // Get the final matcherOut by condensing this intermediate into postFinder contexts\n              temp = [];\n              i = matcherOut.length;\n\n              while (i--) {\n                if (elem = matcherOut[i]) {\n                  // Restore matcherIn since elem is not yet a final match\n                  temp.push(matcherIn[i] = elem);\n                }\n              }\n\n              postFinder(null, matcherOut = [], temp, xml);\n            } // Move matched elements from seed to results to keep them synchronized\n\n\n            i = matcherOut.length;\n\n            while (i--) {\n              if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {\n                seed[temp] = !(results[temp] = elem);\n              }\n            }\n          } // Add elements to results, through postFinder if defined\n\n        } else {\n          matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);\n\n          if (postFinder) {\n            postFinder(null, results, matcherOut, xml);\n          } else {\n            push.apply(results, matcherOut);\n          }\n        }\n      });\n    }\n\n    function matcherFromTokens(tokens) {\n      var checkContext,\n          matcher,\n          j,\n          len = tokens.length,\n          leadingRelative = Expr.relative[tokens[0].type],\n          implicitRelative = leadingRelative || Expr.relative[\" \"],\n          i = leadingRelative ? 1 : 0,\n          // The foundational matcher ensures that elements are reachable from top-level context(s)\n      matchContext = addCombinator(function (elem) {\n        return elem === checkContext;\n      }, implicitRelative, true),\n          matchAnyContext = addCombinator(function (elem) {\n        return indexOf(checkContext, elem) > -1;\n      }, implicitRelative, true),\n          matchers = [function (elem, context, xml) {\n        var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml)); // Avoid hanging onto element (issue #299)\n\n        checkContext = null;\n        return ret;\n      }];\n\n      for (; i < len; i++) {\n        if (matcher = Expr.relative[tokens[i].type]) {\n          matchers = [addCombinator(elementMatcher(matchers), matcher)];\n        } else {\n          matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches); // Return special upon seeing a positional matcher\n\n          if (matcher[expando]) {\n            // Find the next relative operator (if any) for proper handling\n            j = ++i;\n\n            for (; j < len; j++) {\n              if (Expr.relative[tokens[j].type]) {\n                break;\n              }\n            }\n\n            return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*`\n            tokens.slice(0, i - 1).concat({\n              value: tokens[i - 2].type === \" \" ? \"*\" : \"\"\n            })).replace(rtrim, \"$1\"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));\n          }\n\n          matchers.push(matcher);\n        }\n      }\n\n      return elementMatcher(matchers);\n    }\n\n    function matcherFromGroupMatchers(elementMatchers, setMatchers) {\n      var bySet = setMatchers.length > 0,\n          byElement = elementMatchers.length > 0,\n          superMatcher = function superMatcher(seed, context, xml, results, outermost) {\n        var elem,\n            j,\n            matcher,\n            matchedCount = 0,\n            i = \"0\",\n            unmatched = seed && [],\n            setMatched = [],\n            contextBackup = outermostContext,\n            // We must always have either seed elements or outermost context\n        elems = seed || byElement && Expr.find[\"TAG\"](\"*\", outermost),\n            // Use integer dirruns iff this is the outermost matcher\n        dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,\n            len = elems.length;\n\n        if (outermost) {\n          // Support: IE 11+, Edge 17 - 18+\n          // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n          // two documents; shallow comparisons work.\n          // eslint-disable-next-line eqeqeq\n          outermostContext = context == document || context || outermost;\n        } // Add elements passing elementMatchers directly to results\n        // Support: IE<9, Safari\n        // Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\n\n        for (; i !== len && (elem = elems[i]) != null; i++) {\n          if (byElement && elem) {\n            j = 0; // Support: IE 11+, Edge 17 - 18+\n            // IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n            // two documents; shallow comparisons work.\n            // eslint-disable-next-line eqeqeq\n\n            if (!context && elem.ownerDocument != document) {\n              setDocument(elem);\n              xml = !documentIsHTML;\n            }\n\n            while (matcher = elementMatchers[j++]) {\n              if (matcher(elem, context || document, xml)) {\n                results.push(elem);\n                break;\n              }\n            }\n\n            if (outermost) {\n              dirruns = dirrunsUnique;\n            }\n          } // Track unmatched elements for set filters\n\n\n          if (bySet) {\n            // They will have gone through all possible matchers\n            if (elem = !matcher && elem) {\n              matchedCount--;\n            } // Lengthen the array for every element, matched or not\n\n\n            if (seed) {\n              unmatched.push(elem);\n            }\n          }\n        } // `i` is now the count of elements visited above, and adding it to `matchedCount`\n        // makes the latter nonnegative.\n\n\n        matchedCount += i; // Apply set filters to unmatched elements\n        // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n        // equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n        // no element matchers and no seed.\n        // Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n        // case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n        // numerically zero.\n\n        if (bySet && i !== matchedCount) {\n          j = 0;\n\n          while (matcher = setMatchers[j++]) {\n            matcher(unmatched, setMatched, context, xml);\n          }\n\n          if (seed) {\n            // Reintegrate element matches to eliminate the need for sorting\n            if (matchedCount > 0) {\n              while (i--) {\n                if (!(unmatched[i] || setMatched[i])) {\n                  setMatched[i] = pop.call(results);\n                }\n              }\n            } // Discard index placeholder values to get only actual matches\n\n\n            setMatched = condense(setMatched);\n          } // Add matches to results\n\n\n          push.apply(results, setMatched); // Seedless set matches succeeding multiple successful matchers stipulate sorting\n\n          if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {\n            Sizzle.uniqueSort(results);\n          }\n        } // Override manipulation of globals by nested matchers\n\n\n        if (outermost) {\n          dirruns = dirrunsUnique;\n          outermostContext = contextBackup;\n        }\n\n        return unmatched;\n      };\n\n      return bySet ? markFunction(superMatcher) : superMatcher;\n    }\n\n    compile = Sizzle.compile = function (selector, match\n    /* Internal Use Only */\n    ) {\n      var i,\n          setMatchers = [],\n          elementMatchers = [],\n          cached = compilerCache[selector + \" \"];\n\n      if (!cached) {\n        // Generate a function of recursive functions that can be used to check each element\n        if (!match) {\n          match = tokenize(selector);\n        }\n\n        i = match.length;\n\n        while (i--) {\n          cached = matcherFromTokens(match[i]);\n\n          if (cached[expando]) {\n            setMatchers.push(cached);\n          } else {\n            elementMatchers.push(cached);\n          }\n        } // Cache the compiled function\n\n\n        cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers)); // Save selector and tokenization\n\n        cached.selector = selector;\n      }\n\n      return cached;\n    };\n    /**\n     * A low-level selection function that works with Sizzle's compiled\n     *  selector functions\n     * @param {String|Function} selector A selector or a pre-compiled\n     *  selector function built with Sizzle.compile\n     * @param {Element} context\n     * @param {Array} [results]\n     * @param {Array} [seed] A set of elements to match against\n     */\n\n\n    select = Sizzle.select = function (selector, context, results, seed) {\n      var i,\n          tokens,\n          token,\n          type,\n          find,\n          compiled = typeof selector === \"function\" && selector,\n          match = !seed && tokenize(selector = compiled.selector || selector);\n      results = results || []; // Try to minimize operations if there is only one selector in the list and no seed\n      // (the latter of which guarantees us context)\n\n      if (match.length === 1) {\n        // Reduce context if the leading compound selector is an ID\n        tokens = match[0] = match[0].slice(0);\n\n        if (tokens.length > 2 && (token = tokens[0]).type === \"ID\" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {\n          context = (Expr.find[\"ID\"](token.matches[0].replace(runescape, funescape), context) || [])[0];\n\n          if (!context) {\n            return results; // Precompiled matchers will still verify ancestry, so step up a level\n          } else if (compiled) {\n            context = context.parentNode;\n          }\n\n          selector = selector.slice(tokens.shift().value.length);\n        } // Fetch a seed set for right-to-left matching\n\n\n        i = matchExpr[\"needsContext\"].test(selector) ? 0 : tokens.length;\n\n        while (i--) {\n          token = tokens[i]; // Abort if we hit a combinator\n\n          if (Expr.relative[type = token.type]) {\n            break;\n          }\n\n          if (find = Expr.find[type]) {\n            // Search, expanding context for leading sibling combinators\n            if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {\n              // If seed is empty or no tokens remain, we can return early\n              tokens.splice(i, 1);\n              selector = seed.length && toSelector(tokens);\n\n              if (!selector) {\n                push.apply(results, seed);\n                return results;\n              }\n\n              break;\n            }\n          }\n        }\n      } // Compile and execute a filtering function if one is not provided\n      // Provide `match` to avoid retokenization if we modified the selector above\n\n\n      (compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);\n      return results;\n    }; // One-time assignments\n    // Sort stability\n\n\n    support.sortStable = expando.split(\"\").sort(sortOrder).join(\"\") === expando; // Support: Chrome 14-35+\n    // Always assume duplicates if they aren't passed to the comparison function\n\n    support.detectDuplicates = !!hasDuplicate; // Initialize against the default document\n\n    setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n    // Detached nodes confoundingly follow *each other*\n\n    support.sortDetached = assert(function (el) {\n      // Should return 1, but returns 4 (following)\n      return el.compareDocumentPosition(document.createElement(\"fieldset\")) & 1;\n    }); // Support: IE<8\n    // Prevent attribute/property \"interpolation\"\n    // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\n\n    if (!assert(function (el) {\n      el.innerHTML = \"<a href='#'></a>\";\n      return el.firstChild.getAttribute(\"href\") === \"#\";\n    })) {\n      addHandle(\"type|href|height|width\", function (elem, name, isXML) {\n        if (!isXML) {\n          return elem.getAttribute(name, name.toLowerCase() === \"type\" ? 1 : 2);\n        }\n      });\n    } // Support: IE<9\n    // Use defaultValue in place of getAttribute(\"value\")\n\n\n    if (!support.attributes || !assert(function (el) {\n      el.innerHTML = \"<input/>\";\n      el.firstChild.setAttribute(\"value\", \"\");\n      return el.firstChild.getAttribute(\"value\") === \"\";\n    })) {\n      addHandle(\"value\", function (elem, _name, isXML) {\n        if (!isXML && elem.nodeName.toLowerCase() === \"input\") {\n          return elem.defaultValue;\n        }\n      });\n    } // Support: IE<9\n    // Use getAttributeNode to fetch booleans when getAttribute lies\n\n\n    if (!assert(function (el) {\n      return el.getAttribute(\"disabled\") == null;\n    })) {\n      addHandle(booleans, function (elem, name, isXML) {\n        var val;\n\n        if (!isXML) {\n          return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;\n        }\n      });\n    }\n\n    return Sizzle;\n  }(window);\n\n  jQuery.find = Sizzle;\n  jQuery.expr = Sizzle.selectors; // Deprecated\n\n  jQuery.expr[\":\"] = jQuery.expr.pseudos;\n  jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\n  jQuery.text = Sizzle.getText;\n  jQuery.isXMLDoc = Sizzle.isXML;\n  jQuery.contains = Sizzle.contains;\n  jQuery.escapeSelector = Sizzle.escape;\n\n  var dir = function dir(elem, _dir, until) {\n    var matched = [],\n        truncate = until !== undefined;\n\n    while ((elem = elem[_dir]) && elem.nodeType !== 9) {\n      if (elem.nodeType === 1) {\n        if (truncate && jQuery(elem).is(until)) {\n          break;\n        }\n\n        matched.push(elem);\n      }\n    }\n\n    return matched;\n  };\n\n  var _siblings = function siblings(n, elem) {\n    var matched = [];\n\n    for (; n; n = n.nextSibling) {\n      if (n.nodeType === 1 && n !== elem) {\n        matched.push(n);\n      }\n    }\n\n    return matched;\n  };\n\n  var rneedsContext = jQuery.expr.match.needsContext;\n\n  function nodeName(elem, name) {\n    return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n  }\n\n  var rsingleTag = /^<([a-z][^\\/\\0>:\\x20\\t\\r\\n\\f]*)[\\x20\\t\\r\\n\\f]*\\/?>(?:<\\/\\1>|)$/i; // Implement the identical functionality for filter and not\n\n  function winnow(elements, qualifier, not) {\n    if (isFunction(qualifier)) {\n      return jQuery.grep(elements, function (elem, i) {\n        return !!qualifier.call(elem, i, elem) !== not;\n      });\n    } // Single element\n\n\n    if (qualifier.nodeType) {\n      return jQuery.grep(elements, function (elem) {\n        return elem === qualifier !== not;\n      });\n    } // Arraylike of elements (jQuery, arguments, Array)\n\n\n    if (typeof qualifier !== \"string\") {\n      return jQuery.grep(elements, function (elem) {\n        return indexOf.call(qualifier, elem) > -1 !== not;\n      });\n    } // Filtered directly for both simple and complex selectors\n\n\n    return jQuery.filter(qualifier, elements, not);\n  }\n\n  jQuery.filter = function (expr, elems, not) {\n    var elem = elems[0];\n\n    if (not) {\n      expr = \":not(\" + expr + \")\";\n    }\n\n    if (elems.length === 1 && elem.nodeType === 1) {\n      return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];\n    }\n\n    return jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {\n      return elem.nodeType === 1;\n    }));\n  };\n\n  jQuery.fn.extend({\n    find: function find(selector) {\n      var i,\n          ret,\n          len = this.length,\n          self = this;\n\n      if (typeof selector !== \"string\") {\n        return this.pushStack(jQuery(selector).filter(function () {\n          for (i = 0; i < len; i++) {\n            if (jQuery.contains(self[i], this)) {\n              return true;\n            }\n          }\n        }));\n      }\n\n      ret = this.pushStack([]);\n\n      for (i = 0; i < len; i++) {\n        jQuery.find(selector, self[i], ret);\n      }\n\n      return len > 1 ? jQuery.uniqueSort(ret) : ret;\n    },\n    filter: function filter(selector) {\n      return this.pushStack(winnow(this, selector || [], false));\n    },\n    not: function not(selector) {\n      return this.pushStack(winnow(this, selector || [], true));\n    },\n    is: function is(selector) {\n      return !!winnow(this, // If this is a positional/relative selector, check membership in the returned set\n      // so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n      typeof selector === \"string\" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;\n    }\n  }); // Initialize a jQuery object\n  // A central reference to the root jQuery(document)\n\n  var rootjQuery,\n      // A simple way to check for HTML strings\n  // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n  // Strict HTML recognition (#11290: must start with <)\n  // Shortcut simple #id case for speed\n  rquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]+))$/,\n      init = jQuery.fn.init = function (selector, context, root) {\n    var match, elem; // HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\n    if (!selector) {\n      return this;\n    } // Method init() accepts an alternate rootjQuery\n    // so migrate can support jQuery.sub (gh-2101)\n\n\n    root = root || rootjQuery; // Handle HTML strings\n\n    if (typeof selector === \"string\") {\n      if (selector[0] === \"<\" && selector[selector.length - 1] === \">\" && selector.length >= 3) {\n        // Assume that strings that start and end with <> are HTML and skip the regex check\n        match = [null, selector, null];\n      } else {\n        match = rquickExpr.exec(selector);\n      } // Match html or make sure no context is specified for #id\n\n\n      if (match && (match[1] || !context)) {\n        // HANDLE: $(html) -> $(array)\n        if (match[1]) {\n          context = context instanceof jQuery ? context[0] : context; // Option to run scripts is true for back-compat\n          // Intentionally let the error be thrown if parseHTML is not present\n\n          jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true)); // HANDLE: $(html, props)\n\n          if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {\n            for (match in context) {\n              // Properties of context are called as methods if possible\n              if (isFunction(this[match])) {\n                this[match](context[match]); // ...and otherwise set as attributes\n              } else {\n                this.attr(match, context[match]);\n              }\n            }\n          }\n\n          return this; // HANDLE: $(#id)\n        } else {\n          elem = document.getElementById(match[2]);\n\n          if (elem) {\n            // Inject the element directly into the jQuery object\n            this[0] = elem;\n            this.length = 1;\n          }\n\n          return this;\n        } // HANDLE: $(expr, $(...))\n\n      } else if (!context || context.jquery) {\n        return (context || root).find(selector); // HANDLE: $(expr, context)\n        // (which is just equivalent to: $(context).find(expr)\n      } else {\n        return this.constructor(context).find(selector);\n      } // HANDLE: $(DOMElement)\n\n    } else if (selector.nodeType) {\n      this[0] = selector;\n      this.length = 1;\n      return this; // HANDLE: $(function)\n      // Shortcut for document ready\n    } else if (isFunction(selector)) {\n      return root.ready !== undefined ? root.ready(selector) : // Execute immediately if ready is not present\n      selector(jQuery);\n    }\n\n    return jQuery.makeArray(selector, this);\n  }; // Give the init function the jQuery prototype for later instantiation\n\n\n  init.prototype = jQuery.fn; // Initialize central reference\n\n  rootjQuery = jQuery(document);\n  var rparentsprev = /^(?:parents|prev(?:Until|All))/,\n      // Methods guaranteed to produce a unique set when starting from a unique set\n  guaranteedUnique = {\n    children: true,\n    contents: true,\n    next: true,\n    prev: true\n  };\n  jQuery.fn.extend({\n    has: function has(target) {\n      var targets = jQuery(target, this),\n          l = targets.length;\n      return this.filter(function () {\n        var i = 0;\n\n        for (; i < l; i++) {\n          if (jQuery.contains(this, targets[i])) {\n            return true;\n          }\n        }\n      });\n    },\n    closest: function closest(selectors, context) {\n      var cur,\n          i = 0,\n          l = this.length,\n          matched = [],\n          targets = typeof selectors !== \"string\" && jQuery(selectors); // Positional selectors never match, since there's no _selection_ context\n\n      if (!rneedsContext.test(selectors)) {\n        for (; i < l; i++) {\n          for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {\n            // Always skip document fragments\n            if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : // Don't pass non-elements to Sizzle\n            cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {\n              matched.push(cur);\n              break;\n            }\n          }\n        }\n      }\n\n      return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);\n    },\n    // Determine the position of an element within the set\n    index: function index(elem) {\n      // No argument, return index in parent\n      if (!elem) {\n        return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;\n      } // Index in selector\n\n\n      if (typeof elem === \"string\") {\n        return indexOf.call(jQuery(elem), this[0]);\n      } // Locate the position of the desired element\n\n\n      return indexOf.call(this, // If it receives a jQuery object, the first element is used\n      elem.jquery ? elem[0] : elem);\n    },\n    add: function add(selector, context) {\n      return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));\n    },\n    addBack: function addBack(selector) {\n      return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));\n    }\n  });\n\n  function sibling(cur, dir) {\n    while ((cur = cur[dir]) && cur.nodeType !== 1) {}\n\n    return cur;\n  }\n\n  jQuery.each({\n    parent: function parent(elem) {\n      var parent = elem.parentNode;\n      return parent && parent.nodeType !== 11 ? parent : null;\n    },\n    parents: function parents(elem) {\n      return dir(elem, \"parentNode\");\n    },\n    parentsUntil: function parentsUntil(elem, _i, until) {\n      return dir(elem, \"parentNode\", until);\n    },\n    next: function next(elem) {\n      return sibling(elem, \"nextSibling\");\n    },\n    prev: function prev(elem) {\n      return sibling(elem, \"previousSibling\");\n    },\n    nextAll: function nextAll(elem) {\n      return dir(elem, \"nextSibling\");\n    },\n    prevAll: function prevAll(elem) {\n      return dir(elem, \"previousSibling\");\n    },\n    nextUntil: function nextUntil(elem, _i, until) {\n      return dir(elem, \"nextSibling\", until);\n    },\n    prevUntil: function prevUntil(elem, _i, until) {\n      return dir(elem, \"previousSibling\", until);\n    },\n    siblings: function siblings(elem) {\n      return _siblings((elem.parentNode || {}).firstChild, elem);\n    },\n    children: function children(elem) {\n      return _siblings(elem.firstChild);\n    },\n    contents: function contents(elem) {\n      if (elem.contentDocument != null && // Support: IE 11+\n      // <object> elements with no `data` attribute has an object\n      // `contentDocument` with a `null` prototype.\n      getProto(elem.contentDocument)) {\n        return elem.contentDocument;\n      } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only\n      // Treat the template element as a regular one in browsers that\n      // don't support it.\n\n\n      if (nodeName(elem, \"template\")) {\n        elem = elem.content || elem;\n      }\n\n      return jQuery.merge([], elem.childNodes);\n    }\n  }, function (name, fn) {\n    jQuery.fn[name] = function (until, selector) {\n      var matched = jQuery.map(this, fn, until);\n\n      if (name.slice(-5) !== \"Until\") {\n        selector = until;\n      }\n\n      if (selector && typeof selector === \"string\") {\n        matched = jQuery.filter(selector, matched);\n      }\n\n      if (this.length > 1) {\n        // Remove duplicates\n        if (!guaranteedUnique[name]) {\n          jQuery.uniqueSort(matched);\n        } // Reverse order for parents* and prev-derivatives\n\n\n        if (rparentsprev.test(name)) {\n          matched.reverse();\n        }\n      }\n\n      return this.pushStack(matched);\n    };\n  });\n  var rnothtmlwhite = /[^\\x20\\t\\r\\n\\f]+/g; // Convert String-formatted options into Object-formatted ones\n\n  function createOptions(options) {\n    var object = {};\n    jQuery.each(options.match(rnothtmlwhite) || [], function (_, flag) {\n      object[flag] = true;\n    });\n    return object;\n  }\n  /*\n   * Create a callback list using the following parameters:\n   *\n   *\toptions: an optional list of space-separated options that will change how\n   *\t\t\tthe callback list behaves or a more traditional option object\n   *\n   * By default a callback list will act like an event callback list and can be\n   * \"fired\" multiple times.\n   *\n   * Possible options:\n   *\n   *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n   *\n   *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n   *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n   *\t\t\t\t\tvalues (like a Deferred)\n   *\n   *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n   *\n   *\tstopOnFalse:\tinterrupt callings when a callback returns false\n   *\n   */\n\n\n  jQuery.Callbacks = function (options) {\n    // Convert options from String-formatted to Object-formatted if needed\n    // (we check in cache first)\n    options = typeof options === \"string\" ? createOptions(options) : jQuery.extend({}, options);\n\n    var // Flag to know if list is currently firing\n    firing,\n        // Last fire value for non-forgettable lists\n    memory,\n        // Flag to know if list was already fired\n    _fired,\n        // Flag to prevent firing\n    _locked,\n        // Actual callback list\n    list = [],\n        // Queue of execution data for repeatable lists\n    queue = [],\n        // Index of currently firing callback (modified by add/remove as needed)\n    firingIndex = -1,\n        // Fire callbacks\n    fire = function fire() {\n      // Enforce single-firing\n      _locked = _locked || options.once; // Execute callbacks for all pending executions,\n      // respecting firingIndex overrides and runtime changes\n\n      _fired = firing = true;\n\n      for (; queue.length; firingIndex = -1) {\n        memory = queue.shift();\n\n        while (++firingIndex < list.length) {\n          // Run callback and check for early termination\n          if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {\n            // Jump to end and forget the data so .add doesn't re-fire\n            firingIndex = list.length;\n            memory = false;\n          }\n        }\n      } // Forget the data if we're done with it\n\n\n      if (!options.memory) {\n        memory = false;\n      }\n\n      firing = false; // Clean up if we're done firing for good\n\n      if (_locked) {\n        // Keep an empty list if we have data for future add calls\n        if (memory) {\n          list = []; // Otherwise, this object is spent\n        } else {\n          list = \"\";\n        }\n      }\n    },\n        // Actual Callbacks object\n    self = {\n      // Add a callback or a collection of callbacks to the list\n      add: function add() {\n        if (list) {\n          // If we have memory from a past run, we should fire after adding\n          if (memory && !firing) {\n            firingIndex = list.length - 1;\n            queue.push(memory);\n          }\n\n          (function add(args) {\n            jQuery.each(args, function (_, arg) {\n              if (isFunction(arg)) {\n                if (!options.unique || !self.has(arg)) {\n                  list.push(arg);\n                }\n              } else if (arg && arg.length && toType(arg) !== \"string\") {\n                // Inspect recursively\n                add(arg);\n              }\n            });\n          })(arguments);\n\n          if (memory && !firing) {\n            fire();\n          }\n        }\n\n        return this;\n      },\n      // Remove a callback from the list\n      remove: function remove() {\n        jQuery.each(arguments, function (_, arg) {\n          var index;\n\n          while ((index = jQuery.inArray(arg, list, index)) > -1) {\n            list.splice(index, 1); // Handle firing indexes\n\n            if (index <= firingIndex) {\n              firingIndex--;\n            }\n          }\n        });\n        return this;\n      },\n      // Check if a given callback is in the list.\n      // If no argument is given, return whether or not list has callbacks attached.\n      has: function has(fn) {\n        return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;\n      },\n      // Remove all callbacks from the list\n      empty: function empty() {\n        if (list) {\n          list = [];\n        }\n\n        return this;\n      },\n      // Disable .fire and .add\n      // Abort any current/pending executions\n      // Clear all callbacks and values\n      disable: function disable() {\n        _locked = queue = [];\n        list = memory = \"\";\n        return this;\n      },\n      disabled: function disabled() {\n        return !list;\n      },\n      // Disable .fire\n      // Also disable .add unless we have memory (since it would have no effect)\n      // Abort any pending executions\n      lock: function lock() {\n        _locked = queue = [];\n\n        if (!memory && !firing) {\n          list = memory = \"\";\n        }\n\n        return this;\n      },\n      locked: function locked() {\n        return !!_locked;\n      },\n      // Call all callbacks with the given context and arguments\n      fireWith: function fireWith(context, args) {\n        if (!_locked) {\n          args = args || [];\n          args = [context, args.slice ? args.slice() : args];\n          queue.push(args);\n\n          if (!firing) {\n            fire();\n          }\n        }\n\n        return this;\n      },\n      // Call all the callbacks with the given arguments\n      fire: function fire() {\n        self.fireWith(this, arguments);\n        return this;\n      },\n      // To know if the callbacks have already been called at least once\n      fired: function fired() {\n        return !!_fired;\n      }\n    };\n\n    return self;\n  };\n\n  function Identity(v) {\n    return v;\n  }\n\n  function Thrower(ex) {\n    throw ex;\n  }\n\n  function adoptValue(value, resolve, reject, noValue) {\n    var method;\n\n    try {\n      // Check for promise aspect first to privilege synchronous behavior\n      if (value && isFunction(method = value.promise)) {\n        method.call(value).done(resolve).fail(reject); // Other thenables\n      } else if (value && isFunction(method = value.then)) {\n        method.call(value, resolve, reject); // Other non-thenables\n      } else {\n        // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:\n        // * false: [ value ].slice( 0 ) => resolve( value )\n        // * true: [ value ].slice( 1 ) => resolve()\n        resolve.apply(undefined, [value].slice(noValue));\n      } // For Promises/A+, convert exceptions into rejections\n      // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in\n      // Deferred#then to conditionally suppress rejection.\n\n    } catch (value) {\n      // Support: Android 4.0 only\n      // Strict mode functions invoked without .call/.apply get global-object context\n      reject.apply(undefined, [value]);\n    }\n  }\n\n  jQuery.extend({\n    Deferred: function Deferred(func) {\n      var tuples = [// action, add listener, callbacks,\n      // ... .then handlers, argument index, [final state]\n      [\"notify\", \"progress\", jQuery.Callbacks(\"memory\"), jQuery.Callbacks(\"memory\"), 2], [\"resolve\", \"done\", jQuery.Callbacks(\"once memory\"), jQuery.Callbacks(\"once memory\"), 0, \"resolved\"], [\"reject\", \"fail\", jQuery.Callbacks(\"once memory\"), jQuery.Callbacks(\"once memory\"), 1, \"rejected\"]],\n          _state = \"pending\",\n          _promise = {\n        state: function state() {\n          return _state;\n        },\n        always: function always() {\n          deferred.done(arguments).fail(arguments);\n          return this;\n        },\n        \"catch\": function _catch(fn) {\n          return _promise.then(null, fn);\n        },\n        // Keep pipe for back-compat\n        pipe: function pipe()\n        /* fnDone, fnFail, fnProgress */\n        {\n          var fns = arguments;\n          return jQuery.Deferred(function (newDefer) {\n            jQuery.each(tuples, function (_i, tuple) {\n              // Map tuples (progress, done, fail) to arguments (done, fail, progress)\n              var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]]; // deferred.progress(function() { bind to newDefer or newDefer.notify })\n              // deferred.done(function() { bind to newDefer or newDefer.resolve })\n              // deferred.fail(function() { bind to newDefer or newDefer.reject })\n\n              deferred[tuple[1]](function () {\n                var returned = fn && fn.apply(this, arguments);\n\n                if (returned && isFunction(returned.promise)) {\n                  returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);\n                } else {\n                  newDefer[tuple[0] + \"With\"](this, fn ? [returned] : arguments);\n                }\n              });\n            });\n            fns = null;\n          }).promise();\n        },\n        then: function then(onFulfilled, onRejected, onProgress) {\n          var maxDepth = 0;\n\n          function resolve(depth, deferred, handler, special) {\n            return function () {\n              var that = this,\n                  args = arguments,\n                  mightThrow = function mightThrow() {\n                var returned, then; // Support: Promises/A+ section 2.3.3.3.3\n                // https://promisesaplus.com/#point-59\n                // Ignore double-resolution attempts\n\n                if (depth < maxDepth) {\n                  return;\n                }\n\n                returned = handler.apply(that, args); // Support: Promises/A+ section 2.3.1\n                // https://promisesaplus.com/#point-48\n\n                if (returned === deferred.promise()) {\n                  throw new TypeError(\"Thenable self-resolution\");\n                } // Support: Promises/A+ sections 2.3.3.1, 3.5\n                // https://promisesaplus.com/#point-54\n                // https://promisesaplus.com/#point-75\n                // Retrieve `then` only once\n\n\n                then = returned && ( // Support: Promises/A+ section 2.3.4\n                // https://promisesaplus.com/#point-64\n                // Only check objects and functions for thenability\n                _typeof(returned) === \"object\" || typeof returned === \"function\") && returned.then; // Handle a returned thenable\n\n                if (isFunction(then)) {\n                  // Special processors (notify) just wait for resolution\n                  if (special) {\n                    then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special)); // Normal processors (resolve) also hook into progress\n                  } else {\n                    // ...and disregard older resolution values\n                    maxDepth++;\n                    then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));\n                  } // Handle all other returned values\n\n                } else {\n                  // Only substitute handlers pass on context\n                  // and multiple values (non-spec behavior)\n                  if (handler !== Identity) {\n                    that = undefined;\n                    args = [returned];\n                  } // Process the value(s)\n                  // Default process is resolve\n\n\n                  (special || deferred.resolveWith)(that, args);\n                }\n              },\n                  // Only normal processors (resolve) catch and reject exceptions\n              process = special ? mightThrow : function () {\n                try {\n                  mightThrow();\n                } catch (e) {\n                  if (jQuery.Deferred.exceptionHook) {\n                    jQuery.Deferred.exceptionHook(e, process.stackTrace);\n                  } // Support: Promises/A+ section 2.3.3.3.4.1\n                  // https://promisesaplus.com/#point-61\n                  // Ignore post-resolution exceptions\n\n\n                  if (depth + 1 >= maxDepth) {\n                    // Only substitute handlers pass on context\n                    // and multiple values (non-spec behavior)\n                    if (handler !== Thrower) {\n                      that = undefined;\n                      args = [e];\n                    }\n\n                    deferred.rejectWith(that, args);\n                  }\n                }\n              }; // Support: Promises/A+ section 2.3.3.3.1\n              // https://promisesaplus.com/#point-57\n              // Re-resolve promises immediately to dodge false rejection from\n              // subsequent errors\n\n\n              if (depth) {\n                process();\n              } else {\n                // Call an optional hook to record the stack, in case of exception\n                // since it's otherwise lost when execution goes async\n                if (jQuery.Deferred.getStackHook) {\n                  process.stackTrace = jQuery.Deferred.getStackHook();\n                }\n\n                window.setTimeout(process);\n              }\n            };\n          }\n\n          return jQuery.Deferred(function (newDefer) {\n            // progress_handlers.add( ... )\n            tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith)); // fulfilled_handlers.add( ... )\n\n            tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity)); // rejected_handlers.add( ... )\n\n            tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower));\n          }).promise();\n        },\n        // Get a promise for this deferred\n        // If obj is provided, the promise aspect is added to the object\n        promise: function promise(obj) {\n          return obj != null ? jQuery.extend(obj, _promise) : _promise;\n        }\n      },\n          deferred = {}; // Add list-specific methods\n\n      jQuery.each(tuples, function (i, tuple) {\n        var list = tuple[2],\n            stateString = tuple[5]; // promise.progress = list.add\n        // promise.done = list.add\n        // promise.fail = list.add\n\n        _promise[tuple[1]] = list.add; // Handle state\n\n        if (stateString) {\n          list.add(function () {\n            // state = \"resolved\" (i.e., fulfilled)\n            // state = \"rejected\"\n            _state = stateString;\n          }, // rejected_callbacks.disable\n          // fulfilled_callbacks.disable\n          tuples[3 - i][2].disable, // rejected_handlers.disable\n          // fulfilled_handlers.disable\n          tuples[3 - i][3].disable, // progress_callbacks.lock\n          tuples[0][2].lock, // progress_handlers.lock\n          tuples[0][3].lock);\n        } // progress_handlers.fire\n        // fulfilled_handlers.fire\n        // rejected_handlers.fire\n\n\n        list.add(tuple[3].fire); // deferred.notify = function() { deferred.notifyWith(...) }\n        // deferred.resolve = function() { deferred.resolveWith(...) }\n        // deferred.reject = function() { deferred.rejectWith(...) }\n\n        deferred[tuple[0]] = function () {\n          deferred[tuple[0] + \"With\"](this === deferred ? undefined : this, arguments);\n          return this;\n        }; // deferred.notifyWith = list.fireWith\n        // deferred.resolveWith = list.fireWith\n        // deferred.rejectWith = list.fireWith\n\n\n        deferred[tuple[0] + \"With\"] = list.fireWith;\n      }); // Make the deferred a promise\n\n      _promise.promise(deferred); // Call given func if any\n\n\n      if (func) {\n        func.call(deferred, deferred);\n      } // All done!\n\n\n      return deferred;\n    },\n    // Deferred helper\n    when: function when(singleValue) {\n      var // count of uncompleted subordinates\n      remaining = arguments.length,\n          // count of unprocessed arguments\n      i = remaining,\n          // subordinate fulfillment data\n      resolveContexts = Array(i),\n          resolveValues = _slice.call(arguments),\n          // the primary Deferred\n      primary = jQuery.Deferred(),\n          // subordinate callback factory\n      updateFunc = function updateFunc(i) {\n        return function (value) {\n          resolveContexts[i] = this;\n          resolveValues[i] = arguments.length > 1 ? _slice.call(arguments) : value;\n\n          if (! --remaining) {\n            primary.resolveWith(resolveContexts, resolveValues);\n          }\n        };\n      }; // Single- and empty arguments are adopted like Promise.resolve\n\n\n      if (remaining <= 1) {\n        adoptValue(singleValue, primary.done(updateFunc(i)).resolve, primary.reject, !remaining); // Use .then() to unwrap secondary thenables (cf. gh-3000)\n\n        if (primary.state() === \"pending\" || isFunction(resolveValues[i] && resolveValues[i].then)) {\n          return primary.then();\n        }\n      } // Multiple arguments are aggregated like Promise.all array elements\n\n\n      while (i--) {\n        adoptValue(resolveValues[i], updateFunc(i), primary.reject);\n      }\n\n      return primary.promise();\n    }\n  }); // These usually indicate a programmer mistake during development,\n  // warn about them ASAP rather than swallowing them by default.\n\n  var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;\n\n  jQuery.Deferred.exceptionHook = function (error, stack) {\n    // Support: IE 8 - 9 only\n    // Console exists when dev tools are open, which can happen at any time\n    if (window.console && window.console.warn && error && rerrorNames.test(error.name)) {\n      window.console.warn(\"jQuery.Deferred exception: \" + error.message, error.stack, stack);\n    }\n  };\n\n  jQuery.readyException = function (error) {\n    window.setTimeout(function () {\n      throw error;\n    });\n  }; // The deferred used on DOM ready\n\n\n  var readyList = jQuery.Deferred();\n\n  jQuery.fn.ready = function (fn) {\n    readyList.then(fn) // Wrap jQuery.readyException in a function so that the lookup\n    // happens at the time of error handling instead of callback\n    // registration.\n    .catch(function (error) {\n      jQuery.readyException(error);\n    });\n    return this;\n  };\n\n  jQuery.extend({\n    // Is the DOM ready to be used? Set to true once it occurs.\n    isReady: false,\n    // A counter to track how many items to wait for before\n    // the ready event fires. See #6781\n    readyWait: 1,\n    // Handle when the DOM is ready\n    ready: function ready(wait) {\n      // Abort if there are pending holds or we're already ready\n      if (wait === true ? --jQuery.readyWait : jQuery.isReady) {\n        return;\n      } // Remember that the DOM is ready\n\n\n      jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be\n\n      if (wait !== true && --jQuery.readyWait > 0) {\n        return;\n      } // If there are functions bound, to execute\n\n\n      readyList.resolveWith(document, [jQuery]);\n    }\n  });\n  jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method\n\n  function completed() {\n    document.removeEventListener(\"DOMContentLoaded\", completed);\n    window.removeEventListener(\"load\", completed);\n    jQuery.ready();\n  } // Catch cases where $(document).ready() is called\n  // after the browser event has already occurred.\n  // Support: IE <=9 - 10 only\n  // Older IE sometimes signals \"interactive\" too soon\n\n\n  if (document.readyState === \"complete\" || document.readyState !== \"loading\" && !document.documentElement.doScroll) {\n    // Handle it asynchronously to allow scripts the opportunity to delay ready\n    window.setTimeout(jQuery.ready);\n  } else {\n    // Use the handy event callback\n    document.addEventListener(\"DOMContentLoaded\", completed); // A fallback to window.onload, that will always work\n\n    window.addEventListener(\"load\", completed);\n  } // Multifunctional method to get and set values of a collection\n  // The value/s can optionally be executed if it's a function\n\n\n  var access = function access(elems, fn, key, value, chainable, emptyGet, raw) {\n    var i = 0,\n        len = elems.length,\n        bulk = key == null; // Sets many values\n\n    if (toType(key) === \"object\") {\n      chainable = true;\n\n      for (i in key) {\n        access(elems, fn, i, key[i], true, emptyGet, raw);\n      } // Sets one value\n\n    } else if (value !== undefined) {\n      chainable = true;\n\n      if (!isFunction(value)) {\n        raw = true;\n      }\n\n      if (bulk) {\n        // Bulk operations run against the entire set\n        if (raw) {\n          fn.call(elems, value);\n          fn = null; // ...except when executing function values\n        } else {\n          bulk = fn;\n\n          fn = function fn(elem, _key, value) {\n            return bulk.call(jQuery(elem), value);\n          };\n        }\n      }\n\n      if (fn) {\n        for (; i < len; i++) {\n          fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));\n        }\n      }\n    }\n\n    if (chainable) {\n      return elems;\n    } // Gets\n\n\n    if (bulk) {\n      return fn.call(elems);\n    }\n\n    return len ? fn(elems[0], key) : emptyGet;\n  }; // Matches dashed string for camelizing\n\n\n  var rmsPrefix = /^-ms-/,\n      rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace()\n\n  function fcamelCase(_all, letter) {\n    return letter.toUpperCase();\n  } // Convert dashed to camelCase; used by the css and data modules\n  // Support: IE <=9 - 11, Edge 12 - 15\n  // Microsoft forgot to hump their vendor prefix (#9572)\n\n\n  function camelCase(string) {\n    return string.replace(rmsPrefix, \"ms-\").replace(rdashAlpha, fcamelCase);\n  }\n\n  var acceptData = function acceptData(owner) {\n    // Accepts only:\n    //  - Node\n    //    - Node.ELEMENT_NODE\n    //    - Node.DOCUMENT_NODE\n    //  - Object\n    //    - Any\n    return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;\n  };\n\n  function Data() {\n    this.expando = jQuery.expando + Data.uid++;\n  }\n\n  Data.uid = 1;\n  Data.prototype = {\n    cache: function cache(owner) {\n      // Check if the owner object already has a cache\n      var value = owner[this.expando]; // If not, create one\n\n      if (!value) {\n        value = {}; // We can accept data for non-element nodes in modern browsers,\n        // but we should not, see #8335.\n        // Always return an empty object.\n\n        if (acceptData(owner)) {\n          // If it is a node unlikely to be stringify-ed or looped over\n          // use plain assignment\n          if (owner.nodeType) {\n            owner[this.expando] = value; // Otherwise secure it in a non-enumerable property\n            // configurable must be true to allow the property to be\n            // deleted when data is removed\n          } else {\n            Object.defineProperty(owner, this.expando, {\n              value: value,\n              configurable: true\n            });\n          }\n        }\n      }\n\n      return value;\n    },\n    set: function set(owner, data, value) {\n      var prop,\n          cache = this.cache(owner); // Handle: [ owner, key, value ] args\n      // Always use camelCase key (gh-2257)\n\n      if (typeof data === \"string\") {\n        cache[camelCase(data)] = value; // Handle: [ owner, { properties } ] args\n      } else {\n        // Copy the properties one-by-one to the cache object\n        for (prop in data) {\n          cache[camelCase(prop)] = data[prop];\n        }\n      }\n\n      return cache;\n    },\n    get: function get(owner, key) {\n      return key === undefined ? this.cache(owner) : // Always use camelCase key (gh-2257)\n      owner[this.expando] && owner[this.expando][camelCase(key)];\n    },\n    access: function access(owner, key, value) {\n      // In cases where either:\n      //\n      //   1. No key was specified\n      //   2. A string key was specified, but no value provided\n      //\n      // Take the \"read\" path and allow the get method to determine\n      // which value to return, respectively either:\n      //\n      //   1. The entire cache object\n      //   2. The data stored at the key\n      //\n      if (key === undefined || key && typeof key === \"string\" && value === undefined) {\n        return this.get(owner, key);\n      } // When the key is not a string, or both a key and value\n      // are specified, set or extend (existing objects) with either:\n      //\n      //   1. An object of properties\n      //   2. A key and value\n      //\n\n\n      this.set(owner, key, value); // Since the \"set\" path can have two possible entry points\n      // return the expected data based on which path was taken[*]\n\n      return value !== undefined ? value : key;\n    },\n    remove: function remove(owner, key) {\n      var i,\n          cache = owner[this.expando];\n\n      if (cache === undefined) {\n        return;\n      }\n\n      if (key !== undefined) {\n        // Support array or space separated string of keys\n        if (Array.isArray(key)) {\n          // If key is an array of keys...\n          // We always set camelCase keys, so remove that.\n          key = key.map(camelCase);\n        } else {\n          key = camelCase(key); // If a key with the spaces exists, use it.\n          // Otherwise, create an array by matching non-whitespace\n\n          key = key in cache ? [key] : key.match(rnothtmlwhite) || [];\n        }\n\n        i = key.length;\n\n        while (i--) {\n          delete cache[key[i]];\n        }\n      } // Remove the expando if there's no more data\n\n\n      if (key === undefined || jQuery.isEmptyObject(cache)) {\n        // Support: Chrome <=35 - 45\n        // Webkit & Blink performance suffers when deleting properties\n        // from DOM nodes, so set to undefined instead\n        // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)\n        if (owner.nodeType) {\n          owner[this.expando] = undefined;\n        } else {\n          delete owner[this.expando];\n        }\n      }\n    },\n    hasData: function hasData(owner) {\n      var cache = owner[this.expando];\n      return cache !== undefined && !jQuery.isEmptyObject(cache);\n    }\n  };\n  var dataPriv = new Data();\n  var dataUser = new Data(); //\tImplementation Summary\n  //\n  //\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n  //\t2. Improve the module's maintainability by reducing the storage\n  //\t\tpaths to a single mechanism.\n  //\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n  //\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n  //\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n  //\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\n  var rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n      rmultiDash = /[A-Z]/g;\n\n  function getData(data) {\n    if (data === \"true\") {\n      return true;\n    }\n\n    if (data === \"false\") {\n      return false;\n    }\n\n    if (data === \"null\") {\n      return null;\n    } // Only convert to a number if it doesn't change the string\n\n\n    if (data === +data + \"\") {\n      return +data;\n    }\n\n    if (rbrace.test(data)) {\n      return JSON.parse(data);\n    }\n\n    return data;\n  }\n\n  function dataAttr(elem, key, data) {\n    var name; // If nothing was found internally, try to fetch any\n    // data from the HTML5 data-* attribute\n\n    if (data === undefined && elem.nodeType === 1) {\n      name = \"data-\" + key.replace(rmultiDash, \"-$&\").toLowerCase();\n      data = elem.getAttribute(name);\n\n      if (typeof data === \"string\") {\n        try {\n          data = getData(data);\n        } catch (e) {} // Make sure we set the data so it isn't changed later\n\n\n        dataUser.set(elem, key, data);\n      } else {\n        data = undefined;\n      }\n    }\n\n    return data;\n  }\n\n  jQuery.extend({\n    hasData: function hasData(elem) {\n      return dataUser.hasData(elem) || dataPriv.hasData(elem);\n    },\n    data: function data(elem, name, _data) {\n      return dataUser.access(elem, name, _data);\n    },\n    removeData: function removeData(elem, name) {\n      dataUser.remove(elem, name);\n    },\n    // TODO: Now that all calls to _data and _removeData have been replaced\n    // with direct calls to dataPriv methods, these can be deprecated.\n    _data: function _data(elem, name, data) {\n      return dataPriv.access(elem, name, data);\n    },\n    _removeData: function _removeData(elem, name) {\n      dataPriv.remove(elem, name);\n    }\n  });\n  jQuery.fn.extend({\n    data: function data(key, value) {\n      var i,\n          name,\n          data,\n          elem = this[0],\n          attrs = elem && elem.attributes; // Gets all values\n\n      if (key === undefined) {\n        if (this.length) {\n          data = dataUser.get(elem);\n\n          if (elem.nodeType === 1 && !dataPriv.get(elem, \"hasDataAttrs\")) {\n            i = attrs.length;\n\n            while (i--) {\n              // Support: IE 11 only\n              // The attrs elements can be null (#14894)\n              if (attrs[i]) {\n                name = attrs[i].name;\n\n                if (name.indexOf(\"data-\") === 0) {\n                  name = camelCase(name.slice(5));\n                  dataAttr(elem, name, data[name]);\n                }\n              }\n            }\n\n            dataPriv.set(elem, \"hasDataAttrs\", true);\n          }\n        }\n\n        return data;\n      } // Sets multiple values\n\n\n      if (_typeof(key) === \"object\") {\n        return this.each(function () {\n          dataUser.set(this, key);\n        });\n      }\n\n      return access(this, function (value) {\n        var data; // The calling jQuery object (element matches) is not empty\n        // (and therefore has an element appears at this[ 0 ]) and the\n        // `value` parameter was not undefined. An empty jQuery object\n        // will result in `undefined` for elem = this[ 0 ] which will\n        // throw an exception if an attempt to read a data cache is made.\n\n        if (elem && value === undefined) {\n          // Attempt to get data from the cache\n          // The key will always be camelCased in Data\n          data = dataUser.get(elem, key);\n\n          if (data !== undefined) {\n            return data;\n          } // Attempt to \"discover\" the data in\n          // HTML5 custom data-* attrs\n\n\n          data = dataAttr(elem, key);\n\n          if (data !== undefined) {\n            return data;\n          } // We tried really hard, but the data doesn't exist.\n\n\n          return;\n        } // Set the data...\n\n\n        this.each(function () {\n          // We always store the camelCased key\n          dataUser.set(this, key, value);\n        });\n      }, null, value, arguments.length > 1, null, true);\n    },\n    removeData: function removeData(key) {\n      return this.each(function () {\n        dataUser.remove(this, key);\n      });\n    }\n  });\n  jQuery.extend({\n    queue: function queue(elem, type, data) {\n      var queue;\n\n      if (elem) {\n        type = (type || \"fx\") + \"queue\";\n        queue = dataPriv.get(elem, type); // Speed up dequeue by getting out quickly if this is just a lookup\n\n        if (data) {\n          if (!queue || Array.isArray(data)) {\n            queue = dataPriv.access(elem, type, jQuery.makeArray(data));\n          } else {\n            queue.push(data);\n          }\n        }\n\n        return queue || [];\n      }\n    },\n    dequeue: function dequeue(elem, type) {\n      type = type || \"fx\";\n\n      var queue = jQuery.queue(elem, type),\n          startLength = queue.length,\n          fn = queue.shift(),\n          hooks = jQuery._queueHooks(elem, type),\n          next = function next() {\n        jQuery.dequeue(elem, type);\n      }; // If the fx queue is dequeued, always remove the progress sentinel\n\n\n      if (fn === \"inprogress\") {\n        fn = queue.shift();\n        startLength--;\n      }\n\n      if (fn) {\n        // Add a progress sentinel to prevent the fx queue from being\n        // automatically dequeued\n        if (type === \"fx\") {\n          queue.unshift(\"inprogress\");\n        } // Clear up the last queue stop function\n\n\n        delete hooks.stop;\n        fn.call(elem, next, hooks);\n      }\n\n      if (!startLength && hooks) {\n        hooks.empty.fire();\n      }\n    },\n    // Not public - generate a queueHooks object, or return the current one\n    _queueHooks: function _queueHooks(elem, type) {\n      var key = type + \"queueHooks\";\n      return dataPriv.get(elem, key) || dataPriv.access(elem, key, {\n        empty: jQuery.Callbacks(\"once memory\").add(function () {\n          dataPriv.remove(elem, [type + \"queue\", key]);\n        })\n      });\n    }\n  });\n  jQuery.fn.extend({\n    queue: function queue(type, data) {\n      var setter = 2;\n\n      if (typeof type !== \"string\") {\n        data = type;\n        type = \"fx\";\n        setter--;\n      }\n\n      if (arguments.length < setter) {\n        return jQuery.queue(this[0], type);\n      }\n\n      return data === undefined ? this : this.each(function () {\n        var queue = jQuery.queue(this, type, data); // Ensure a hooks for this queue\n\n        jQuery._queueHooks(this, type);\n\n        if (type === \"fx\" && queue[0] !== \"inprogress\") {\n          jQuery.dequeue(this, type);\n        }\n      });\n    },\n    dequeue: function dequeue(type) {\n      return this.each(function () {\n        jQuery.dequeue(this, type);\n      });\n    },\n    clearQueue: function clearQueue(type) {\n      return this.queue(type || \"fx\", []);\n    },\n    // Get a promise resolved when queues of a certain type\n    // are emptied (fx is the type by default)\n    promise: function promise(type, obj) {\n      var tmp,\n          count = 1,\n          defer = jQuery.Deferred(),\n          elements = this,\n          i = this.length,\n          resolve = function resolve() {\n        if (! --count) {\n          defer.resolveWith(elements, [elements]);\n        }\n      };\n\n      if (typeof type !== \"string\") {\n        obj = type;\n        type = undefined;\n      }\n\n      type = type || \"fx\";\n\n      while (i--) {\n        tmp = dataPriv.get(elements[i], type + \"queueHooks\");\n\n        if (tmp && tmp.empty) {\n          count++;\n          tmp.empty.add(resolve);\n        }\n      }\n\n      resolve();\n      return defer.promise(obj);\n    }\n  });\n  var pnum = /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/.source;\n  var rcssNum = new RegExp(\"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\");\n  var cssExpand = [\"Top\", \"Right\", \"Bottom\", \"Left\"];\n  var documentElement = document.documentElement;\n\n  var isAttached = function isAttached(elem) {\n    return jQuery.contains(elem.ownerDocument, elem);\n  },\n      composed = {\n    composed: true\n  }; // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only\n  // Check attachment across shadow DOM boundaries when possible (gh-3504)\n  // Support: iOS 10.0-10.2 only\n  // Early iOS 10 versions support `attachShadow` but not `getRootNode`,\n  // leading to errors. We need to check for `getRootNode`.\n\n\n  if (documentElement.getRootNode) {\n    isAttached = function isAttached(elem) {\n      return jQuery.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument;\n    };\n  }\n\n  var isHiddenWithinTree = function isHiddenWithinTree(elem, el) {\n    // isHiddenWithinTree might be called from jQuery#filter function;\n    // in that case, element will be second argument\n    elem = el || elem; // Inline style trumps all\n\n    return elem.style.display === \"none\" || elem.style.display === \"\" && // Otherwise, check computed style\n    // Support: Firefox <=43 - 45\n    // Disconnected elements can have computed display: none, so first confirm that elem is\n    // in the document.\n    isAttached(elem) && jQuery.css(elem, \"display\") === \"none\";\n  };\n\n  function adjustCSS(elem, prop, valueParts, tween) {\n    var adjusted,\n        scale,\n        maxIterations = 20,\n        currentValue = tween ? function () {\n      return tween.cur();\n    } : function () {\n      return jQuery.css(elem, prop, \"\");\n    },\n        initial = currentValue(),\n        unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? \"\" : \"px\"),\n        // Starting value computation is required for potential unit mismatches\n    initialInUnit = elem.nodeType && (jQuery.cssNumber[prop] || unit !== \"px\" && +initial) && rcssNum.exec(jQuery.css(elem, prop));\n\n    if (initialInUnit && initialInUnit[3] !== unit) {\n      // Support: Firefox <=54\n      // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)\n      initial = initial / 2; // Trust units reported by jQuery.css\n\n      unit = unit || initialInUnit[3]; // Iteratively approximate from a nonzero starting point\n\n      initialInUnit = +initial || 1;\n\n      while (maxIterations--) {\n        // Evaluate and update our best guess (doubling guesses that zero out).\n        // Finish if the scale equals or crosses 1 (making the old*new product non-positive).\n        jQuery.style(elem, prop, initialInUnit + unit);\n\n        if ((1 - scale) * (1 - (scale = currentValue() / initial || 0.5)) <= 0) {\n          maxIterations = 0;\n        }\n\n        initialInUnit = initialInUnit / scale;\n      }\n\n      initialInUnit = initialInUnit * 2;\n      jQuery.style(elem, prop, initialInUnit + unit); // Make sure we update the tween properties later on\n\n      valueParts = valueParts || [];\n    }\n\n    if (valueParts) {\n      initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified\n\n      adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];\n\n      if (tween) {\n        tween.unit = unit;\n        tween.start = initialInUnit;\n        tween.end = adjusted;\n      }\n    }\n\n    return adjusted;\n  }\n\n  var defaultDisplayMap = {};\n\n  function getDefaultDisplay(elem) {\n    var temp,\n        doc = elem.ownerDocument,\n        nodeName = elem.nodeName,\n        display = defaultDisplayMap[nodeName];\n\n    if (display) {\n      return display;\n    }\n\n    temp = doc.body.appendChild(doc.createElement(nodeName));\n    display = jQuery.css(temp, \"display\");\n    temp.parentNode.removeChild(temp);\n\n    if (display === \"none\") {\n      display = \"block\";\n    }\n\n    defaultDisplayMap[nodeName] = display;\n    return display;\n  }\n\n  function showHide(elements, show) {\n    var display,\n        elem,\n        values = [],\n        index = 0,\n        length = elements.length; // Determine new display value for elements that need to change\n\n    for (; index < length; index++) {\n      elem = elements[index];\n\n      if (!elem.style) {\n        continue;\n      }\n\n      display = elem.style.display;\n\n      if (show) {\n        // Since we force visibility upon cascade-hidden elements, an immediate (and slow)\n        // check is required in this first loop unless we have a nonempty display value (either\n        // inline or about-to-be-restored)\n        if (display === \"none\") {\n          values[index] = dataPriv.get(elem, \"display\") || null;\n\n          if (!values[index]) {\n            elem.style.display = \"\";\n          }\n        }\n\n        if (elem.style.display === \"\" && isHiddenWithinTree(elem)) {\n          values[index] = getDefaultDisplay(elem);\n        }\n      } else {\n        if (display !== \"none\") {\n          values[index] = \"none\"; // Remember what we're overwriting\n\n          dataPriv.set(elem, \"display\", display);\n        }\n      }\n    } // Set the display of the elements in a second loop to avoid constant reflow\n\n\n    for (index = 0; index < length; index++) {\n      if (values[index] != null) {\n        elements[index].style.display = values[index];\n      }\n    }\n\n    return elements;\n  }\n\n  jQuery.fn.extend({\n    show: function show() {\n      return showHide(this, true);\n    },\n    hide: function hide() {\n      return showHide(this);\n    },\n    toggle: function toggle(state) {\n      if (typeof state === \"boolean\") {\n        return state ? this.show() : this.hide();\n      }\n\n      return this.each(function () {\n        if (isHiddenWithinTree(this)) {\n          jQuery(this).show();\n        } else {\n          jQuery(this).hide();\n        }\n      });\n    }\n  });\n  var rcheckableType = /^(?:checkbox|radio)$/i;\n  var rtagName = /<([a-z][^\\/\\0>\\x20\\t\\r\\n\\f]*)/i;\n  var rscriptType = /^$|^module$|\\/(?:java|ecma)script/i;\n\n  (function () {\n    var fragment = document.createDocumentFragment(),\n        div = fragment.appendChild(document.createElement(\"div\")),\n        input = document.createElement(\"input\"); // Support: Android 4.0 - 4.3 only\n    // Check state lost if the name is set (#11217)\n    // Support: Windows Web Apps (WWA)\n    // `name` and `type` must use .setAttribute for WWA (#14901)\n\n    input.setAttribute(\"type\", \"radio\");\n    input.setAttribute(\"checked\", \"checked\");\n    input.setAttribute(\"name\", \"t\");\n    div.appendChild(input); // Support: Android <=4.1 only\n    // Older WebKit doesn't clone checked state correctly in fragments\n\n    support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked; // Support: IE <=11 only\n    // Make sure textarea (and checkbox) defaultValue is properly cloned\n\n    div.innerHTML = \"<textarea>x</textarea>\";\n    support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue; // Support: IE <=9 only\n    // IE <=9 replaces <option> tags with their contents when inserted outside of\n    // the select element.\n\n    div.innerHTML = \"<option></option>\";\n    support.option = !!div.lastChild;\n  })(); // We have to close these tags to support XHTML (#13200)\n\n\n  var wrapMap = {\n    // XHTML parsers do not magically insert elements in the\n    // same way that tag soup parsers do. So we cannot shorten\n    // this by omitting <tbody> or other required elements.\n    thead: [1, \"<table>\", \"</table>\"],\n    col: [2, \"<table><colgroup>\", \"</colgroup></table>\"],\n    tr: [2, \"<table><tbody>\", \"</tbody></table>\"],\n    td: [3, \"<table><tbody><tr>\", \"</tr></tbody></table>\"],\n    _default: [0, \"\", \"\"]\n  };\n  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\n  wrapMap.th = wrapMap.td; // Support: IE <=9 only\n\n  if (!support.option) {\n    wrapMap.optgroup = wrapMap.option = [1, \"<select multiple='multiple'>\", \"</select>\"];\n  }\n\n  function getAll(context, tag) {\n    // Support: IE <=9 - 11 only\n    // Use typeof to avoid zero-argument method invocation on host objects (#15151)\n    var ret;\n\n    if (typeof context.getElementsByTagName !== \"undefined\") {\n      ret = context.getElementsByTagName(tag || \"*\");\n    } else if (typeof context.querySelectorAll !== \"undefined\") {\n      ret = context.querySelectorAll(tag || \"*\");\n    } else {\n      ret = [];\n    }\n\n    if (tag === undefined || tag && nodeName(context, tag)) {\n      return jQuery.merge([context], ret);\n    }\n\n    return ret;\n  } // Mark scripts as having already been evaluated\n\n\n  function setGlobalEval(elems, refElements) {\n    var i = 0,\n        l = elems.length;\n\n    for (; i < l; i++) {\n      dataPriv.set(elems[i], \"globalEval\", !refElements || dataPriv.get(refElements[i], \"globalEval\"));\n    }\n  }\n\n  var rhtml = /<|&#?\\w+;/;\n\n  function buildFragment(elems, context, scripts, selection, ignored) {\n    var elem,\n        tmp,\n        tag,\n        wrap,\n        attached,\n        j,\n        fragment = context.createDocumentFragment(),\n        nodes = [],\n        i = 0,\n        l = elems.length;\n\n    for (; i < l; i++) {\n      elem = elems[i];\n\n      if (elem || elem === 0) {\n        // Add nodes directly\n        if (toType(elem) === \"object\") {\n          // Support: Android <=4.0 only, PhantomJS 1 only\n          // push.apply(_, arraylike) throws on ancient WebKit\n          jQuery.merge(nodes, elem.nodeType ? [elem] : elem); // Convert non-html into a text node\n        } else if (!rhtml.test(elem)) {\n          nodes.push(context.createTextNode(elem)); // Convert html into DOM nodes\n        } else {\n          tmp = tmp || fragment.appendChild(context.createElement(\"div\")); // Deserialize a standard representation\n\n          tag = (rtagName.exec(elem) || [\"\", \"\"])[1].toLowerCase();\n          wrap = wrapMap[tag] || wrapMap._default;\n          tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2]; // Descend through wrappers to the right content\n\n          j = wrap[0];\n\n          while (j--) {\n            tmp = tmp.lastChild;\n          } // Support: Android <=4.0 only, PhantomJS 1 only\n          // push.apply(_, arraylike) throws on ancient WebKit\n\n\n          jQuery.merge(nodes, tmp.childNodes); // Remember the top-level container\n\n          tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392)\n\n          tmp.textContent = \"\";\n        }\n      }\n    } // Remove wrapper from fragment\n\n\n    fragment.textContent = \"\";\n    i = 0;\n\n    while (elem = nodes[i++]) {\n      // Skip elements already in the context collection (trac-4087)\n      if (selection && jQuery.inArray(elem, selection) > -1) {\n        if (ignored) {\n          ignored.push(elem);\n        }\n\n        continue;\n      }\n\n      attached = isAttached(elem); // Append to fragment\n\n      tmp = getAll(fragment.appendChild(elem), \"script\"); // Preserve script evaluation history\n\n      if (attached) {\n        setGlobalEval(tmp);\n      } // Capture executables\n\n\n      if (scripts) {\n        j = 0;\n\n        while (elem = tmp[j++]) {\n          if (rscriptType.test(elem.type || \"\")) {\n            scripts.push(elem);\n          }\n        }\n      }\n    }\n\n    return fragment;\n  }\n\n  var rtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\n  function returnTrue() {\n    return true;\n  }\n\n  function returnFalse() {\n    return false;\n  } // Support: IE <=9 - 11+\n  // focus() and blur() are asynchronous, except when they are no-op.\n  // So expect focus to be synchronous when the element is already active,\n  // and blur to be synchronous when the element is not already active.\n  // (focus and blur are always synchronous in other supported browsers,\n  // this just defines when we can count on it).\n\n\n  function expectSync(elem, type) {\n    return elem === safeActiveElement() === (type === \"focus\");\n  } // Support: IE <=9 only\n  // Accessing document.activeElement can throw unexpectedly\n  // https://bugs.jquery.com/ticket/13393\n\n\n  function safeActiveElement() {\n    try {\n      return document.activeElement;\n    } catch (err) {}\n  }\n\n  function _on(elem, types, selector, data, fn, one) {\n    var origFn, type; // Types can be a map of types/handlers\n\n    if (_typeof(types) === \"object\") {\n      // ( types-Object, selector, data )\n      if (typeof selector !== \"string\") {\n        // ( types-Object, data )\n        data = data || selector;\n        selector = undefined;\n      }\n\n      for (type in types) {\n        _on(elem, type, selector, data, types[type], one);\n      }\n\n      return elem;\n    }\n\n    if (data == null && fn == null) {\n      // ( types, fn )\n      fn = selector;\n      data = selector = undefined;\n    } else if (fn == null) {\n      if (typeof selector === \"string\") {\n        // ( types, selector, fn )\n        fn = data;\n        data = undefined;\n      } else {\n        // ( types, data, fn )\n        fn = data;\n        data = selector;\n        selector = undefined;\n      }\n    }\n\n    if (fn === false) {\n      fn = returnFalse;\n    } else if (!fn) {\n      return elem;\n    }\n\n    if (one === 1) {\n      origFn = fn;\n\n      fn = function fn(event) {\n        // Can use an empty set, since event contains the info\n        jQuery().off(event);\n        return origFn.apply(this, arguments);\n      }; // Use same guid so caller can remove using origFn\n\n\n      fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);\n    }\n\n    return elem.each(function () {\n      jQuery.event.add(this, types, fn, data, selector);\n    });\n  }\n  /*\n   * Helper functions for managing events -- not part of the public interface.\n   * Props to Dean Edwards' addEvent library for many of the ideas.\n   */\n\n\n  jQuery.event = {\n    global: {},\n    add: function add(elem, types, handler, data, selector) {\n      var handleObjIn,\n          eventHandle,\n          tmp,\n          events,\n          t,\n          handleObj,\n          special,\n          handlers,\n          type,\n          namespaces,\n          origType,\n          elemData = dataPriv.get(elem); // Only attach events to objects that accept data\n\n      if (!acceptData(elem)) {\n        return;\n      } // Caller can pass in an object of custom data in lieu of the handler\n\n\n      if (handler.handler) {\n        handleObjIn = handler;\n        handler = handleObjIn.handler;\n        selector = handleObjIn.selector;\n      } // Ensure that invalid selectors throw exceptions at attach time\n      // Evaluate against documentElement in case elem is a non-element node (e.g., document)\n\n\n      if (selector) {\n        jQuery.find.matchesSelector(documentElement, selector);\n      } // Make sure that the handler has a unique ID, used to find/remove it later\n\n\n      if (!handler.guid) {\n        handler.guid = jQuery.guid++;\n      } // Init the element's event structure and main handler, if this is the first\n\n\n      if (!(events = elemData.events)) {\n        events = elemData.events = Object.create(null);\n      }\n\n      if (!(eventHandle = elemData.handle)) {\n        eventHandle = elemData.handle = function (e) {\n          // Discard the second event of a jQuery.event.trigger() and\n          // when an event is called after a page has unloaded\n          return typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined;\n        };\n      } // Handle multiple events separated by a space\n\n\n      types = (types || \"\").match(rnothtmlwhite) || [\"\"];\n      t = types.length;\n\n      while (t--) {\n        tmp = rtypenamespace.exec(types[t]) || [];\n        type = origType = tmp[1];\n        namespaces = (tmp[2] || \"\").split(\".\").sort(); // There *must* be a type, no attaching namespace-only handlers\n\n        if (!type) {\n          continue;\n        } // If event changes its type, use the special event handlers for the changed type\n\n\n        special = jQuery.event.special[type] || {}; // If selector defined, determine special event api type, otherwise given type\n\n        type = (selector ? special.delegateType : special.bindType) || type; // Update special based on newly reset type\n\n        special = jQuery.event.special[type] || {}; // handleObj is passed to all event handlers\n\n        handleObj = jQuery.extend({\n          type: type,\n          origType: origType,\n          data: data,\n          handler: handler,\n          guid: handler.guid,\n          selector: selector,\n          needsContext: selector && jQuery.expr.match.needsContext.test(selector),\n          namespace: namespaces.join(\".\")\n        }, handleObjIn); // Init the event handler queue if we're the first\n\n        if (!(handlers = events[type])) {\n          handlers = events[type] = [];\n          handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false\n\n          if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {\n            if (elem.addEventListener) {\n              elem.addEventListener(type, eventHandle);\n            }\n          }\n        }\n\n        if (special.add) {\n          special.add.call(elem, handleObj);\n\n          if (!handleObj.handler.guid) {\n            handleObj.handler.guid = handler.guid;\n          }\n        } // Add to the element's handler list, delegates in front\n\n\n        if (selector) {\n          handlers.splice(handlers.delegateCount++, 0, handleObj);\n        } else {\n          handlers.push(handleObj);\n        } // Keep track of which events have ever been used, for event optimization\n\n\n        jQuery.event.global[type] = true;\n      }\n    },\n    // Detach an event or set of events from an element\n    remove: function remove(elem, types, handler, selector, mappedTypes) {\n      var j,\n          origCount,\n          tmp,\n          events,\n          t,\n          handleObj,\n          special,\n          handlers,\n          type,\n          namespaces,\n          origType,\n          elemData = dataPriv.hasData(elem) && dataPriv.get(elem);\n\n      if (!elemData || !(events = elemData.events)) {\n        return;\n      } // Once for each type.namespace in types; type may be omitted\n\n\n      types = (types || \"\").match(rnothtmlwhite) || [\"\"];\n      t = types.length;\n\n      while (t--) {\n        tmp = rtypenamespace.exec(types[t]) || [];\n        type = origType = tmp[1];\n        namespaces = (tmp[2] || \"\").split(\".\").sort(); // Unbind all events (on this namespace, if provided) for the element\n\n        if (!type) {\n          for (type in events) {\n            jQuery.event.remove(elem, type + types[t], handler, selector, true);\n          }\n\n          continue;\n        }\n\n        special = jQuery.event.special[type] || {};\n        type = (selector ? special.delegateType : special.bindType) || type;\n        handlers = events[type] || [];\n        tmp = tmp[2] && new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\"); // Remove matching events\n\n        origCount = j = handlers.length;\n\n        while (j--) {\n          handleObj = handlers[j];\n\n          if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === \"**\" && handleObj.selector)) {\n            handlers.splice(j, 1);\n\n            if (handleObj.selector) {\n              handlers.delegateCount--;\n            }\n\n            if (special.remove) {\n              special.remove.call(elem, handleObj);\n            }\n          }\n        } // Remove generic event handler if we removed something and no more handlers exist\n        // (avoids potential for endless recursion during removal of special event handlers)\n\n\n        if (origCount && !handlers.length) {\n          if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {\n            jQuery.removeEvent(elem, type, elemData.handle);\n          }\n\n          delete events[type];\n        }\n      } // Remove data and the expando if it's no longer used\n\n\n      if (jQuery.isEmptyObject(events)) {\n        dataPriv.remove(elem, \"handle events\");\n      }\n    },\n    dispatch: function dispatch(nativeEvent) {\n      var i,\n          j,\n          ret,\n          matched,\n          handleObj,\n          handlerQueue,\n          args = new Array(arguments.length),\n          // Make a writable jQuery.Event from the native event object\n      event = jQuery.event.fix(nativeEvent),\n          handlers = (dataPriv.get(this, \"events\") || Object.create(null))[event.type] || [],\n          special = jQuery.event.special[event.type] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event\n\n      args[0] = event;\n\n      for (i = 1; i < arguments.length; i++) {\n        args[i] = arguments[i];\n      }\n\n      event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired\n\n      if (special.preDispatch && special.preDispatch.call(this, event) === false) {\n        return;\n      } // Determine handlers\n\n\n      handlerQueue = jQuery.event.handlers.call(this, event, handlers); // Run delegates first; they may want to stop propagation beneath us\n\n      i = 0;\n\n      while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {\n        event.currentTarget = matched.elem;\n        j = 0;\n\n        while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {\n          // If the event is namespaced, then each handler is only invoked if it is\n          // specially universal or its namespaces are a superset of the event's.\n          if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) {\n            event.handleObj = handleObj;\n            event.data = handleObj.data;\n            ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);\n\n            if (ret !== undefined) {\n              if ((event.result = ret) === false) {\n                event.preventDefault();\n                event.stopPropagation();\n              }\n            }\n          }\n        }\n      } // Call the postDispatch hook for the mapped type\n\n\n      if (special.postDispatch) {\n        special.postDispatch.call(this, event);\n      }\n\n      return event.result;\n    },\n    handlers: function handlers(event, _handlers) {\n      var i,\n          handleObj,\n          sel,\n          matchedHandlers,\n          matchedSelectors,\n          handlerQueue = [],\n          delegateCount = _handlers.delegateCount,\n          cur = event.target; // Find delegate handlers\n\n      if (delegateCount && // Support: IE <=9\n      // Black-hole SVG <use> instance trees (trac-13180)\n      cur.nodeType && // Support: Firefox <=42\n      // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)\n      // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click\n      // Support: IE 11 only\n      // ...but not arrow key \"clicks\" of radio inputs, which can have `button` -1 (gh-2343)\n      !(event.type === \"click\" && event.button >= 1)) {\n        for (; cur !== this; cur = cur.parentNode || this) {\n          // Don't check non-elements (#13208)\n          // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n          if (cur.nodeType === 1 && !(event.type === \"click\" && cur.disabled === true)) {\n            matchedHandlers = [];\n            matchedSelectors = {};\n\n            for (i = 0; i < delegateCount; i++) {\n              handleObj = _handlers[i]; // Don't conflict with Object.prototype properties (#13203)\n\n              sel = handleObj.selector + \" \";\n\n              if (matchedSelectors[sel] === undefined) {\n                matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;\n              }\n\n              if (matchedSelectors[sel]) {\n                matchedHandlers.push(handleObj);\n              }\n            }\n\n            if (matchedHandlers.length) {\n              handlerQueue.push({\n                elem: cur,\n                handlers: matchedHandlers\n              });\n            }\n          }\n        }\n      } // Add the remaining (directly-bound) handlers\n\n\n      cur = this;\n\n      if (delegateCount < _handlers.length) {\n        handlerQueue.push({\n          elem: cur,\n          handlers: _handlers.slice(delegateCount)\n        });\n      }\n\n      return handlerQueue;\n    },\n    addProp: function addProp(name, hook) {\n      Object.defineProperty(jQuery.Event.prototype, name, {\n        enumerable: true,\n        configurable: true,\n        get: isFunction(hook) ? function () {\n          if (this.originalEvent) {\n            return hook(this.originalEvent);\n          }\n        } : function () {\n          if (this.originalEvent) {\n            return this.originalEvent[name];\n          }\n        },\n        set: function set(value) {\n          Object.defineProperty(this, name, {\n            enumerable: true,\n            configurable: true,\n            writable: true,\n            value: value\n          });\n        }\n      });\n    },\n    fix: function fix(originalEvent) {\n      return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);\n    },\n    special: {\n      load: {\n        // Prevent triggered image.load events from bubbling to window.load\n        noBubble: true\n      },\n      click: {\n        // Utilize native event to ensure correct state for checkable inputs\n        setup: function setup(data) {\n          // For mutual compressibility with _default, replace `this` access with a local var.\n          // `|| data` is dead code meant only to preserve the variable through minification.\n          var el = this || data; // Claim the first handler\n\n          if (rcheckableType.test(el.type) && el.click && nodeName(el, \"input\")) {\n            // dataPriv.set( el, \"click\", ... )\n            leverageNative(el, \"click\", returnTrue);\n          } // Return false to allow normal processing in the caller\n\n\n          return false;\n        },\n        trigger: function trigger(data) {\n          // For mutual compressibility with _default, replace `this` access with a local var.\n          // `|| data` is dead code meant only to preserve the variable through minification.\n          var el = this || data; // Force setup before triggering a click\n\n          if (rcheckableType.test(el.type) && el.click && nodeName(el, \"input\")) {\n            leverageNative(el, \"click\");\n          } // Return non-false to allow normal event-path propagation\n\n\n          return true;\n        },\n        // For cross-browser consistency, suppress native .click() on links\n        // Also prevent it if we're currently inside a leveraged native-event stack\n        _default: function _default(event) {\n          var target = event.target;\n          return rcheckableType.test(target.type) && target.click && nodeName(target, \"input\") && dataPriv.get(target, \"click\") || nodeName(target, \"a\");\n        }\n      },\n      beforeunload: {\n        postDispatch: function postDispatch(event) {\n          // Support: Firefox 20+\n          // Firefox doesn't alert if the returnValue field is not set.\n          if (event.result !== undefined && event.originalEvent) {\n            event.originalEvent.returnValue = event.result;\n          }\n        }\n      }\n    }\n  }; // Ensure the presence of an event listener that handles manually-triggered\n  // synthetic events by interrupting progress until reinvoked in response to\n  // *native* events that it fires directly, ensuring that state changes have\n  // already occurred before other listeners are invoked.\n\n  function leverageNative(el, type, expectSync) {\n    // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add\n    if (!expectSync) {\n      if (dataPriv.get(el, type) === undefined) {\n        jQuery.event.add(el, type, returnTrue);\n      }\n\n      return;\n    } // Register the controller as a special universal handler for all event namespaces\n\n\n    dataPriv.set(el, type, false);\n    jQuery.event.add(el, type, {\n      namespace: false,\n      handler: function handler(event) {\n        var notAsync,\n            result,\n            saved = dataPriv.get(this, type);\n\n        if (event.isTrigger & 1 && this[type]) {\n          // Interrupt processing of the outer synthetic .trigger()ed event\n          // Saved data should be false in such cases, but might be a leftover capture object\n          // from an async native handler (gh-4350)\n          if (!saved.length) {\n            // Store arguments for use when handling the inner native event\n            // There will always be at least one argument (an event object), so this array\n            // will not be confused with a leftover capture object.\n            saved = _slice.call(arguments);\n            dataPriv.set(this, type, saved); // Trigger the native event and capture its result\n            // Support: IE <=9 - 11+\n            // focus() and blur() are asynchronous\n\n            notAsync = expectSync(this, type);\n            this[type]();\n            result = dataPriv.get(this, type);\n\n            if (saved !== result || notAsync) {\n              dataPriv.set(this, type, false);\n            } else {\n              result = {};\n            }\n\n            if (saved !== result) {\n              // Cancel the outer synthetic event\n              event.stopImmediatePropagation();\n              event.preventDefault(); // Support: Chrome 86+\n              // In Chrome, if an element having a focusout handler is blurred by\n              // clicking outside of it, it invokes the handler synchronously. If\n              // that handler calls `.remove()` on the element, the data is cleared,\n              // leaving `result` undefined. We need to guard against this.\n\n              return result && result.value;\n            } // If this is an inner synthetic event for an event with a bubbling surrogate\n            // (focus or blur), assume that the surrogate already propagated from triggering the\n            // native event and prevent that from happening again here.\n            // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the\n            // bubbling surrogate propagates *after* the non-bubbling base), but that seems\n            // less bad than duplication.\n\n          } else if ((jQuery.event.special[type] || {}).delegateType) {\n            event.stopPropagation();\n          } // If this is a native event triggered above, everything is now in order\n          // Fire an inner synthetic event with the original arguments\n\n        } else if (saved.length) {\n          // ...and capture the result\n          dataPriv.set(this, type, {\n            value: jQuery.event.trigger( // Support: IE <=9 - 11+\n            // Extend with the prototype to reset the above stopImmediatePropagation()\n            jQuery.extend(saved[0], jQuery.Event.prototype), saved.slice(1), this)\n          }); // Abort handling of the native event\n\n          event.stopImmediatePropagation();\n        }\n      }\n    });\n  }\n\n  jQuery.removeEvent = function (elem, type, handle) {\n    // This \"if\" is needed for plain objects\n    if (elem.removeEventListener) {\n      elem.removeEventListener(type, handle);\n    }\n  };\n\n  jQuery.Event = function (src, props) {\n    // Allow instantiation without the 'new' keyword\n    if (!(this instanceof jQuery.Event)) {\n      return new jQuery.Event(src, props);\n    } // Event object\n\n\n    if (src && src.type) {\n      this.originalEvent = src;\n      this.type = src.type; // Events bubbling up the document may have been marked as prevented\n      // by a handler lower down the tree; reflect the correct value.\n\n      this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android <=2.3 only\n      src.returnValue === false ? returnTrue : returnFalse; // Create target properties\n      // Support: Safari <=6 - 7 only\n      // Target should not be a text node (#504, #13143)\n\n      this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;\n      this.currentTarget = src.currentTarget;\n      this.relatedTarget = src.relatedTarget; // Event type\n    } else {\n      this.type = src;\n    } // Put explicitly provided properties onto the event object\n\n\n    if (props) {\n      jQuery.extend(this, props);\n    } // Create a timestamp if incoming event doesn't have one\n\n\n    this.timeStamp = src && src.timeStamp || Date.now(); // Mark it as fixed\n\n    this[jQuery.expando] = true;\n  }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n  // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\n\n\n  jQuery.Event.prototype = {\n    constructor: jQuery.Event,\n    isDefaultPrevented: returnFalse,\n    isPropagationStopped: returnFalse,\n    isImmediatePropagationStopped: returnFalse,\n    isSimulated: false,\n    preventDefault: function preventDefault() {\n      var e = this.originalEvent;\n      this.isDefaultPrevented = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.preventDefault();\n      }\n    },\n    stopPropagation: function stopPropagation() {\n      var e = this.originalEvent;\n      this.isPropagationStopped = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.stopPropagation();\n      }\n    },\n    stopImmediatePropagation: function stopImmediatePropagation() {\n      var e = this.originalEvent;\n      this.isImmediatePropagationStopped = returnTrue;\n\n      if (e && !this.isSimulated) {\n        e.stopImmediatePropagation();\n      }\n\n      this.stopPropagation();\n    }\n  }; // Includes all common event props including KeyEvent and MouseEvent specific props\n\n  jQuery.each({\n    altKey: true,\n    bubbles: true,\n    cancelable: true,\n    changedTouches: true,\n    ctrlKey: true,\n    detail: true,\n    eventPhase: true,\n    metaKey: true,\n    pageX: true,\n    pageY: true,\n    shiftKey: true,\n    view: true,\n    \"char\": true,\n    code: true,\n    charCode: true,\n    key: true,\n    keyCode: true,\n    button: true,\n    buttons: true,\n    clientX: true,\n    clientY: true,\n    offsetX: true,\n    offsetY: true,\n    pointerId: true,\n    pointerType: true,\n    screenX: true,\n    screenY: true,\n    targetTouches: true,\n    toElement: true,\n    touches: true,\n    which: true\n  }, jQuery.event.addProp);\n  jQuery.each({\n    focus: \"focusin\",\n    blur: \"focusout\"\n  }, function (type, delegateType) {\n    jQuery.event.special[type] = {\n      // Utilize native event if possible so blur/focus sequence is correct\n      setup: function setup() {\n        // Claim the first handler\n        // dataPriv.set( this, \"focus\", ... )\n        // dataPriv.set( this, \"blur\", ... )\n        leverageNative(this, type, expectSync); // Return false to allow normal processing in the caller\n\n        return false;\n      },\n      trigger: function trigger() {\n        // Force setup before trigger\n        leverageNative(this, type); // Return non-false to allow normal event-path propagation\n\n        return true;\n      },\n      // Suppress native focus or blur as it's already being fired\n      // in leverageNative.\n      _default: function _default() {\n        return true;\n      },\n      delegateType: delegateType\n    };\n  }); // Create mouseenter/leave events using mouseover/out and event-time checks\n  // so that event delegation works in jQuery.\n  // Do the same for pointerenter/pointerleave and pointerover/pointerout\n  //\n  // Support: Safari 7 only\n  // Safari sends mouseenter too often; see:\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=470258\n  // for the description of the bug (it existed in older Chrome versions as well).\n\n  jQuery.each({\n    mouseenter: \"mouseover\",\n    mouseleave: \"mouseout\",\n    pointerenter: \"pointerover\",\n    pointerleave: \"pointerout\"\n  }, function (orig, fix) {\n    jQuery.event.special[orig] = {\n      delegateType: fix,\n      bindType: fix,\n      handle: function handle(event) {\n        var ret,\n            target = this,\n            related = event.relatedTarget,\n            handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target.\n        // NB: No relatedTarget if the mouse left/entered the browser window\n\n        if (!related || related !== target && !jQuery.contains(target, related)) {\n          event.type = handleObj.origType;\n          ret = handleObj.handler.apply(this, arguments);\n          event.type = fix;\n        }\n\n        return ret;\n      }\n    };\n  });\n  jQuery.fn.extend({\n    on: function on(types, selector, data, fn) {\n      return _on(this, types, selector, data, fn);\n    },\n    one: function one(types, selector, data, fn) {\n      return _on(this, types, selector, data, fn, 1);\n    },\n    off: function off(types, selector, fn) {\n      var handleObj, type;\n\n      if (types && types.preventDefault && types.handleObj) {\n        // ( event )  dispatched jQuery.Event\n        handleObj = types.handleObj;\n        jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + \".\" + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);\n        return this;\n      }\n\n      if (_typeof(types) === \"object\") {\n        // ( types-object [, selector] )\n        for (type in types) {\n          this.off(type, selector, types[type]);\n        }\n\n        return this;\n      }\n\n      if (selector === false || typeof selector === \"function\") {\n        // ( types [, fn] )\n        fn = selector;\n        selector = undefined;\n      }\n\n      if (fn === false) {\n        fn = returnFalse;\n      }\n\n      return this.each(function () {\n        jQuery.event.remove(this, types, fn, selector);\n      });\n    }\n  });\n  var // Support: IE <=10 - 11, Edge 12 - 13 only\n  // In IE/Edge using regex groups here causes severe slowdowns.\n  // See https://connect.microsoft.com/IE/feedback/details/1736512/\n  rnoInnerhtml = /<script|<style|<link/i,\n      // checked=\"checked\" or checked\n  rchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n      rcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g; // Prefer a tbody over its parent table for containing new rows\n\n  function manipulationTarget(elem, content) {\n    if (nodeName(elem, \"table\") && nodeName(content.nodeType !== 11 ? content : content.firstChild, \"tr\")) {\n      return jQuery(elem).children(\"tbody\")[0] || elem;\n    }\n\n    return elem;\n  } // Replace/restore the type attribute of script elements for safe DOM manipulation\n\n\n  function disableScript(elem) {\n    elem.type = (elem.getAttribute(\"type\") !== null) + \"/\" + elem.type;\n    return elem;\n  }\n\n  function restoreScript(elem) {\n    if ((elem.type || \"\").slice(0, 5) === \"true/\") {\n      elem.type = elem.type.slice(5);\n    } else {\n      elem.removeAttribute(\"type\");\n    }\n\n    return elem;\n  }\n\n  function cloneCopyEvent(src, dest) {\n    var i, l, type, pdataOld, udataOld, udataCur, events;\n\n    if (dest.nodeType !== 1) {\n      return;\n    } // 1. Copy private data: events, handlers, etc.\n\n\n    if (dataPriv.hasData(src)) {\n      pdataOld = dataPriv.get(src);\n      events = pdataOld.events;\n\n      if (events) {\n        dataPriv.remove(dest, \"handle events\");\n\n        for (type in events) {\n          for (i = 0, l = events[type].length; i < l; i++) {\n            jQuery.event.add(dest, type, events[type][i]);\n          }\n        }\n      }\n    } // 2. Copy user data\n\n\n    if (dataUser.hasData(src)) {\n      udataOld = dataUser.access(src);\n      udataCur = jQuery.extend({}, udataOld);\n      dataUser.set(dest, udataCur);\n    }\n  } // Fix IE bugs, see support tests\n\n\n  function fixInput(src, dest) {\n    var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button.\n\n    if (nodeName === \"input\" && rcheckableType.test(src.type)) {\n      dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options\n    } else if (nodeName === \"input\" || nodeName === \"textarea\") {\n      dest.defaultValue = src.defaultValue;\n    }\n  }\n\n  function domManip(collection, args, callback, ignored) {\n    // Flatten any nested arrays\n    args = flat(args);\n    var fragment,\n        first,\n        scripts,\n        hasScripts,\n        node,\n        doc,\n        i = 0,\n        l = collection.length,\n        iNoClone = l - 1,\n        value = args[0],\n        valueIsFunction = isFunction(value); // We can't cloneNode fragments that contain checked, in WebKit\n\n    if (valueIsFunction || l > 1 && typeof value === \"string\" && !support.checkClone && rchecked.test(value)) {\n      return collection.each(function (index) {\n        var self = collection.eq(index);\n\n        if (valueIsFunction) {\n          args[0] = value.call(this, index, self.html());\n        }\n\n        domManip(self, args, callback, ignored);\n      });\n    }\n\n    if (l) {\n      fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);\n      first = fragment.firstChild;\n\n      if (fragment.childNodes.length === 1) {\n        fragment = first;\n      } // Require either new content or an interest in ignored elements to invoke the callback\n\n\n      if (first || ignored) {\n        scripts = jQuery.map(getAll(fragment, \"script\"), disableScript);\n        hasScripts = scripts.length; // Use the original fragment for the last item\n        // instead of the first because it can end up\n        // being emptied incorrectly in certain situations (#8070).\n\n        for (; i < l; i++) {\n          node = fragment;\n\n          if (i !== iNoClone) {\n            node = jQuery.clone(node, true, true); // Keep references to cloned scripts for later restoration\n\n            if (hasScripts) {\n              // Support: Android <=4.0 only, PhantomJS 1 only\n              // push.apply(_, arraylike) throws on ancient WebKit\n              jQuery.merge(scripts, getAll(node, \"script\"));\n            }\n          }\n\n          callback.call(collection[i], node, i);\n        }\n\n        if (hasScripts) {\n          doc = scripts[scripts.length - 1].ownerDocument; // Reenable scripts\n\n          jQuery.map(scripts, restoreScript); // Evaluate executable scripts on first document insertion\n\n          for (i = 0; i < hasScripts; i++) {\n            node = scripts[i];\n\n            if (rscriptType.test(node.type || \"\") && !dataPriv.access(node, \"globalEval\") && jQuery.contains(doc, node)) {\n              if (node.src && (node.type || \"\").toLowerCase() !== \"module\") {\n                // Optional AJAX dependency, but won't run scripts if not present\n                if (jQuery._evalUrl && !node.noModule) {\n                  jQuery._evalUrl(node.src, {\n                    nonce: node.nonce || node.getAttribute(\"nonce\")\n                  }, doc);\n                }\n              } else {\n                DOMEval(node.textContent.replace(rcleanScript, \"\"), node, doc);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return collection;\n  }\n\n  function _remove(elem, selector, keepData) {\n    var node,\n        nodes = selector ? jQuery.filter(selector, elem) : elem,\n        i = 0;\n\n    for (; (node = nodes[i]) != null; i++) {\n      if (!keepData && node.nodeType === 1) {\n        jQuery.cleanData(getAll(node));\n      }\n\n      if (node.parentNode) {\n        if (keepData && isAttached(node)) {\n          setGlobalEval(getAll(node, \"script\"));\n        }\n\n        node.parentNode.removeChild(node);\n      }\n    }\n\n    return elem;\n  }\n\n  jQuery.extend({\n    htmlPrefilter: function htmlPrefilter(html) {\n      return html;\n    },\n    clone: function clone(elem, dataAndEvents, deepDataAndEvents) {\n      var i,\n          l,\n          srcElements,\n          destElements,\n          clone = elem.cloneNode(true),\n          inPage = isAttached(elem); // Fix IE cloning issues\n\n      if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {\n        // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2\n        destElements = getAll(clone);\n        srcElements = getAll(elem);\n\n        for (i = 0, l = srcElements.length; i < l; i++) {\n          fixInput(srcElements[i], destElements[i]);\n        }\n      } // Copy the events from the original to the clone\n\n\n      if (dataAndEvents) {\n        if (deepDataAndEvents) {\n          srcElements = srcElements || getAll(elem);\n          destElements = destElements || getAll(clone);\n\n          for (i = 0, l = srcElements.length; i < l; i++) {\n            cloneCopyEvent(srcElements[i], destElements[i]);\n          }\n        } else {\n          cloneCopyEvent(elem, clone);\n        }\n      } // Preserve script evaluation history\n\n\n      destElements = getAll(clone, \"script\");\n\n      if (destElements.length > 0) {\n        setGlobalEval(destElements, !inPage && getAll(elem, \"script\"));\n      } // Return the cloned set\n\n\n      return clone;\n    },\n    cleanData: function cleanData(elems) {\n      var data,\n          elem,\n          type,\n          special = jQuery.event.special,\n          i = 0;\n\n      for (; (elem = elems[i]) !== undefined; i++) {\n        if (acceptData(elem)) {\n          if (data = elem[dataPriv.expando]) {\n            if (data.events) {\n              for (type in data.events) {\n                if (special[type]) {\n                  jQuery.event.remove(elem, type); // This is a shortcut to avoid jQuery.event.remove's overhead\n                } else {\n                  jQuery.removeEvent(elem, type, data.handle);\n                }\n              }\n            } // Support: Chrome <=35 - 45+\n            // Assign undefined instead of using delete, see Data#remove\n\n\n            elem[dataPriv.expando] = undefined;\n          }\n\n          if (elem[dataUser.expando]) {\n            // Support: Chrome <=35 - 45+\n            // Assign undefined instead of using delete, see Data#remove\n            elem[dataUser.expando] = undefined;\n          }\n        }\n      }\n    }\n  });\n  jQuery.fn.extend({\n    detach: function detach(selector) {\n      return _remove(this, selector, true);\n    },\n    remove: function remove(selector) {\n      return _remove(this, selector);\n    },\n    text: function text(value) {\n      return access(this, function (value) {\n        return value === undefined ? jQuery.text(this) : this.empty().each(function () {\n          if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n            this.textContent = value;\n          }\n        });\n      }, null, value, arguments.length);\n    },\n    append: function append() {\n      return domManip(this, arguments, function (elem) {\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n          var target = manipulationTarget(this, elem);\n          target.appendChild(elem);\n        }\n      });\n    },\n    prepend: function prepend() {\n      return domManip(this, arguments, function (elem) {\n        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {\n          var target = manipulationTarget(this, elem);\n          target.insertBefore(elem, target.firstChild);\n        }\n      });\n    },\n    before: function before() {\n      return domManip(this, arguments, function (elem) {\n        if (this.parentNode) {\n          this.parentNode.insertBefore(elem, this);\n        }\n      });\n    },\n    after: function after() {\n      return domManip(this, arguments, function (elem) {\n        if (this.parentNode) {\n          this.parentNode.insertBefore(elem, this.nextSibling);\n        }\n      });\n    },\n    empty: function empty() {\n      var elem,\n          i = 0;\n\n      for (; (elem = this[i]) != null; i++) {\n        if (elem.nodeType === 1) {\n          // Prevent memory leaks\n          jQuery.cleanData(getAll(elem, false)); // Remove any remaining nodes\n\n          elem.textContent = \"\";\n        }\n      }\n\n      return this;\n    },\n    clone: function clone(dataAndEvents, deepDataAndEvents) {\n      dataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n      deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n      return this.map(function () {\n        return jQuery.clone(this, dataAndEvents, deepDataAndEvents);\n      });\n    },\n    html: function html(value) {\n      return access(this, function (value) {\n        var elem = this[0] || {},\n            i = 0,\n            l = this.length;\n\n        if (value === undefined && elem.nodeType === 1) {\n          return elem.innerHTML;\n        } // See if we can take a shortcut and just use innerHTML\n\n\n        if (typeof value === \"string\" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || [\"\", \"\"])[1].toLowerCase()]) {\n          value = jQuery.htmlPrefilter(value);\n\n          try {\n            for (; i < l; i++) {\n              elem = this[i] || {}; // Remove element nodes and prevent memory leaks\n\n              if (elem.nodeType === 1) {\n                jQuery.cleanData(getAll(elem, false));\n                elem.innerHTML = value;\n              }\n            }\n\n            elem = 0; // If using innerHTML throws an exception, use the fallback method\n          } catch (e) {}\n        }\n\n        if (elem) {\n          this.empty().append(value);\n        }\n      }, null, value, arguments.length);\n    },\n    replaceWith: function replaceWith() {\n      var ignored = []; // Make the changes, replacing each non-ignored context element with the new content\n\n      return domManip(this, arguments, function (elem) {\n        var parent = this.parentNode;\n\n        if (jQuery.inArray(this, ignored) < 0) {\n          jQuery.cleanData(getAll(this));\n\n          if (parent) {\n            parent.replaceChild(elem, this);\n          }\n        } // Force callback invocation\n\n      }, ignored);\n    }\n  });\n  jQuery.each({\n    appendTo: \"append\",\n    prependTo: \"prepend\",\n    insertBefore: \"before\",\n    insertAfter: \"after\",\n    replaceAll: \"replaceWith\"\n  }, function (name, original) {\n    jQuery.fn[name] = function (selector) {\n      var elems,\n          ret = [],\n          insert = jQuery(selector),\n          last = insert.length - 1,\n          i = 0;\n\n      for (; i <= last; i++) {\n        elems = i === last ? this : this.clone(true);\n        jQuery(insert[i])[original](elems); // Support: Android <=4.0 only, PhantomJS 1 only\n        // .get() because push.apply(_, arraylike) throws on ancient WebKit\n\n        push.apply(ret, elems.get());\n      }\n\n      return this.pushStack(ret);\n    };\n  });\n  var rnumnonpx = new RegExp(\"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\");\n\n  var getStyles = function getStyles(elem) {\n    // Support: IE <=11 only, Firefox <=30 (#15098, #14150)\n    // IE throws on elements created in popups\n    // FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n    var view = elem.ownerDocument.defaultView;\n\n    if (!view || !view.opener) {\n      view = window;\n    }\n\n    return view.getComputedStyle(elem);\n  };\n\n  var swap = function swap(elem, options, callback) {\n    var ret,\n        name,\n        old = {}; // Remember the old values, and insert the new ones\n\n    for (name in options) {\n      old[name] = elem.style[name];\n      elem.style[name] = options[name];\n    }\n\n    ret = callback.call(elem); // Revert the old values\n\n    for (name in options) {\n      elem.style[name] = old[name];\n    }\n\n    return ret;\n  };\n\n  var rboxStyle = new RegExp(cssExpand.join(\"|\"), \"i\");\n\n  (function () {\n    // Executing both pixelPosition & boxSizingReliable tests require only one layout\n    // so they're executed at the same time to save the second computation.\n    function computeStyleTests() {\n      // This is a singleton, we need to execute it only once\n      if (!div) {\n        return;\n      }\n\n      container.style.cssText = \"position:absolute;left:-11111px;width:60px;\" + \"margin-top:1px;padding:0;border:0\";\n      div.style.cssText = \"position:relative;display:block;box-sizing:border-box;overflow:scroll;\" + \"margin:auto;border:1px;padding:1px;\" + \"width:60%;top:1%\";\n      documentElement.appendChild(container).appendChild(div);\n      var divStyle = window.getComputedStyle(div);\n      pixelPositionVal = divStyle.top !== \"1%\"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44\n\n      reliableMarginLeftVal = roundPixelMeasures(divStyle.marginLeft) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3\n      // Some styles come back with percentage values, even though they shouldn't\n\n      div.style.right = \"60%\";\n      pixelBoxStylesVal = roundPixelMeasures(divStyle.right) === 36; // Support: IE 9 - 11 only\n      // Detect misreporting of content dimensions for box-sizing:border-box elements\n\n      boxSizingReliableVal = roundPixelMeasures(divStyle.width) === 36; // Support: IE 9 only\n      // Detect overflow:scroll screwiness (gh-3699)\n      // Support: Chrome <=64\n      // Don't get tricked when zoom affects offsetWidth (gh-4029)\n\n      div.style.position = \"absolute\";\n      scrollboxSizeVal = roundPixelMeasures(div.offsetWidth / 3) === 12;\n      documentElement.removeChild(container); // Nullify the div so it wouldn't be stored in the memory and\n      // it will also be a sign that checks already performed\n\n      div = null;\n    }\n\n    function roundPixelMeasures(measure) {\n      return Math.round(parseFloat(measure));\n    }\n\n    var pixelPositionVal,\n        boxSizingReliableVal,\n        scrollboxSizeVal,\n        pixelBoxStylesVal,\n        reliableTrDimensionsVal,\n        reliableMarginLeftVal,\n        container = document.createElement(\"div\"),\n        div = document.createElement(\"div\"); // Finish early in limited (non-browser) environments\n\n    if (!div.style) {\n      return;\n    } // Support: IE <=9 - 11 only\n    // Style of cloned element affects source element cloned (#8908)\n\n\n    div.style.backgroundClip = \"content-box\";\n    div.cloneNode(true).style.backgroundClip = \"\";\n    support.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n    jQuery.extend(support, {\n      boxSizingReliable: function boxSizingReliable() {\n        computeStyleTests();\n        return boxSizingReliableVal;\n      },\n      pixelBoxStyles: function pixelBoxStyles() {\n        computeStyleTests();\n        return pixelBoxStylesVal;\n      },\n      pixelPosition: function pixelPosition() {\n        computeStyleTests();\n        return pixelPositionVal;\n      },\n      reliableMarginLeft: function reliableMarginLeft() {\n        computeStyleTests();\n        return reliableMarginLeftVal;\n      },\n      scrollboxSize: function scrollboxSize() {\n        computeStyleTests();\n        return scrollboxSizeVal;\n      },\n      // Support: IE 9 - 11+, Edge 15 - 18+\n      // IE/Edge misreport `getComputedStyle` of table rows with width/height\n      // set in CSS while `offset*` properties report correct values.\n      // Behavior in IE 9 is more subtle than in newer versions & it passes\n      // some versions of this test; make sure not to make it pass there!\n      //\n      // Support: Firefox 70+\n      // Only Firefox includes border widths\n      // in computed dimensions. (gh-4529)\n      reliableTrDimensions: function reliableTrDimensions() {\n        var table, tr, trChild, trStyle;\n\n        if (reliableTrDimensionsVal == null) {\n          table = document.createElement(\"table\");\n          tr = document.createElement(\"tr\");\n          trChild = document.createElement(\"div\");\n          table.style.cssText = \"position:absolute;left:-11111px;border-collapse:separate\";\n          tr.style.cssText = \"border:1px solid\"; // Support: Chrome 86+\n          // Height set through cssText does not get applied.\n          // Computed height then comes back as 0.\n\n          tr.style.height = \"1px\";\n          trChild.style.height = \"9px\"; // Support: Android 8 Chrome 86+\n          // In our bodyBackground.html iframe,\n          // display for all div elements is set to \"inline\",\n          // which causes a problem only in Android 8 Chrome 86.\n          // Ensuring the div is display: block\n          // gets around this issue.\n\n          trChild.style.display = \"block\";\n          documentElement.appendChild(table).appendChild(tr).appendChild(trChild);\n          trStyle = window.getComputedStyle(tr);\n          reliableTrDimensionsVal = parseInt(trStyle.height, 10) + parseInt(trStyle.borderTopWidth, 10) + parseInt(trStyle.borderBottomWidth, 10) === tr.offsetHeight;\n          documentElement.removeChild(table);\n        }\n\n        return reliableTrDimensionsVal;\n      }\n    });\n  })();\n\n  function curCSS(elem, name, computed) {\n    var width,\n        minWidth,\n        maxWidth,\n        ret,\n        // Support: Firefox 51+\n    // Retrieving style before computed somehow\n    // fixes an issue with getting wrong values\n    // on detached elements\n    style = elem.style;\n    computed = computed || getStyles(elem); // getPropertyValue is needed for:\n    //   .css('filter') (IE 9 only, #12537)\n    //   .css('--customProperty) (#3144)\n\n    if (computed) {\n      ret = computed.getPropertyValue(name) || computed[name];\n\n      if (ret === \"\" && !isAttached(elem)) {\n        ret = jQuery.style(elem, name);\n      } // A tribute to the \"awesome hack by Dean Edwards\"\n      // Android Browser returns percentage for some values,\n      // but width seems to be reliably pixels.\n      // This is against the CSSOM draft spec:\n      // https://drafts.csswg.org/cssom/#resolved-values\n\n\n      if (!support.pixelBoxStyles() && rnumnonpx.test(ret) && rboxStyle.test(name)) {\n        // Remember the original values\n        width = style.width;\n        minWidth = style.minWidth;\n        maxWidth = style.maxWidth; // Put in the new values to get a computed value out\n\n        style.minWidth = style.maxWidth = style.width = ret;\n        ret = computed.width; // Revert the changed values\n\n        style.width = width;\n        style.minWidth = minWidth;\n        style.maxWidth = maxWidth;\n      }\n    }\n\n    return ret !== undefined ? // Support: IE <=9 - 11 only\n    // IE returns zIndex value as an integer.\n    ret + \"\" : ret;\n  }\n\n  function addGetHookIf(conditionFn, hookFn) {\n    // Define the hook, we'll check on the first run if it's really needed.\n    return {\n      get: function get() {\n        if (conditionFn()) {\n          // Hook not needed (or it's not possible to use it due\n          // to missing dependency), remove it.\n          delete this.get;\n          return;\n        } // Hook needed; redefine it so that the support test is not executed again.\n\n\n        return (this.get = hookFn).apply(this, arguments);\n      }\n    };\n  }\n\n  var cssPrefixes = [\"Webkit\", \"Moz\", \"ms\"],\n      emptyStyle = document.createElement(\"div\").style,\n      vendorProps = {}; // Return a vendor-prefixed property or undefined\n\n  function vendorPropName(name) {\n    // Check for vendor prefixed names\n    var capName = name[0].toUpperCase() + name.slice(1),\n        i = cssPrefixes.length;\n\n    while (i--) {\n      name = cssPrefixes[i] + capName;\n\n      if (name in emptyStyle) {\n        return name;\n      }\n    }\n  } // Return a potentially-mapped jQuery.cssProps or vendor prefixed property\n\n\n  function finalPropName(name) {\n    var final = jQuery.cssProps[name] || vendorProps[name];\n\n    if (final) {\n      return final;\n    }\n\n    if (name in emptyStyle) {\n      return name;\n    }\n\n    return vendorProps[name] = vendorPropName(name) || name;\n  }\n\n  var // Swappable if display is none or starts with table\n  // except \"table\", \"table-cell\", or \"table-caption\"\n  // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n  rdisplayswap = /^(none|table(?!-c[ea]).+)/,\n      rcustomProp = /^--/,\n      cssShow = {\n    position: \"absolute\",\n    visibility: \"hidden\",\n    display: \"block\"\n  },\n      cssNormalTransform = {\n    letterSpacing: \"0\",\n    fontWeight: \"400\"\n  };\n\n  function setPositiveNumber(_elem, value, subtract) {\n    // Any relative (+/-) values have already been\n    // normalized at this point\n    var matches = rcssNum.exec(value);\n    return matches ? // Guard against undefined \"subtract\", e.g., when used as in cssHooks\n    Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || \"px\") : value;\n  }\n\n  function boxModelAdjustment(elem, dimension, box, isBorderBox, styles, computedVal) {\n    var i = dimension === \"width\" ? 1 : 0,\n        extra = 0,\n        delta = 0; // Adjustment may not be necessary\n\n    if (box === (isBorderBox ? \"border\" : \"content\")) {\n      return 0;\n    }\n\n    for (; i < 4; i += 2) {\n      // Both box models exclude margin\n      if (box === \"margin\") {\n        delta += jQuery.css(elem, box + cssExpand[i], true, styles);\n      } // If we get here with a content-box, we're seeking \"padding\" or \"border\" or \"margin\"\n\n\n      if (!isBorderBox) {\n        // Add padding\n        delta += jQuery.css(elem, \"padding\" + cssExpand[i], true, styles); // For \"border\" or \"margin\", add border\n\n        if (box !== \"padding\") {\n          delta += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles); // But still keep track of it otherwise\n        } else {\n          extra += jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n        } // If we get here with a border-box (content + padding + border), we're seeking \"content\" or\n        // \"padding\" or \"margin\"\n\n      } else {\n        // For \"content\", subtract padding\n        if (box === \"content\") {\n          delta -= jQuery.css(elem, \"padding\" + cssExpand[i], true, styles);\n        } // For \"content\" or \"padding\", subtract border\n\n\n        if (box !== \"margin\") {\n          delta -= jQuery.css(elem, \"border\" + cssExpand[i] + \"Width\", true, styles);\n        }\n      }\n    } // Account for positive content-box scroll gutter when requested by providing computedVal\n\n\n    if (!isBorderBox && computedVal >= 0) {\n      // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border\n      // Assuming integer scroll gutter, subtract the rest and round down\n      delta += Math.max(0, Math.ceil(elem[\"offset\" + dimension[0].toUpperCase() + dimension.slice(1)] - computedVal - delta - extra - 0.5 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter\n      // Use an explicit zero to avoid NaN (gh-3964)\n      )) || 0;\n    }\n\n    return delta;\n  }\n\n  function getWidthOrHeight(elem, dimension, extra) {\n    // Start with computed style\n    var styles = getStyles(elem),\n        // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).\n    // Fake content-box until we know it's needed to know the true value.\n    boxSizingNeeded = !support.boxSizingReliable() || extra,\n        isBorderBox = boxSizingNeeded && jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\n        valueIsBorderBox = isBorderBox,\n        val = curCSS(elem, dimension, styles),\n        offsetProp = \"offset\" + dimension[0].toUpperCase() + dimension.slice(1); // Support: Firefox <=54\n    // Return a confounding non-pixel value or feign ignorance, as appropriate.\n\n    if (rnumnonpx.test(val)) {\n      if (!extra) {\n        return val;\n      }\n\n      val = \"auto\";\n    } // Support: IE 9 - 11 only\n    // Use offsetWidth/offsetHeight for when box sizing is unreliable.\n    // In those cases, the computed value can be trusted to be border-box.\n\n\n    if ((!support.boxSizingReliable() && isBorderBox || // Support: IE 10 - 11+, Edge 15 - 18+\n    // IE/Edge misreport `getComputedStyle` of table rows with width/height\n    // set in CSS while `offset*` properties report correct values.\n    // Interestingly, in some cases IE 9 doesn't suffer from this issue.\n    !support.reliableTrDimensions() && nodeName(elem, \"tr\") || // Fall back to offsetWidth/offsetHeight when value is \"auto\"\n    // This happens for inline elements with no explicit setting (gh-3571)\n    val === \"auto\" || // Support: Android <=4.1 - 4.3 only\n    // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)\n    !parseFloat(val) && jQuery.css(elem, \"display\", false, styles) === \"inline\") && // Make sure the element is visible & connected\n    elem.getClientRects().length) {\n      isBorderBox = jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\"; // Where available, offsetWidth/offsetHeight approximate border box dimensions.\n      // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the\n      // retrieved value as a content box dimension.\n\n      valueIsBorderBox = offsetProp in elem;\n\n      if (valueIsBorderBox) {\n        val = elem[offsetProp];\n      }\n    } // Normalize \"\" and auto\n\n\n    val = parseFloat(val) || 0; // Adjust for the element's box model\n\n    return val + boxModelAdjustment(elem, dimension, extra || (isBorderBox ? \"border\" : \"content\"), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589)\n    val) + \"px\";\n  }\n\n  jQuery.extend({\n    // Add in style property hooks for overriding the default\n    // behavior of getting and setting a style property\n    cssHooks: {\n      opacity: {\n        get: function get(elem, computed) {\n          if (computed) {\n            // We should always get a number back from opacity\n            var ret = curCSS(elem, \"opacity\");\n            return ret === \"\" ? \"1\" : ret;\n          }\n        }\n      }\n    },\n    // Don't automatically add \"px\" to these possibly-unitless properties\n    cssNumber: {\n      \"animationIterationCount\": true,\n      \"columnCount\": true,\n      \"fillOpacity\": true,\n      \"flexGrow\": true,\n      \"flexShrink\": true,\n      \"fontWeight\": true,\n      \"gridArea\": true,\n      \"gridColumn\": true,\n      \"gridColumnEnd\": true,\n      \"gridColumnStart\": true,\n      \"gridRow\": true,\n      \"gridRowEnd\": true,\n      \"gridRowStart\": true,\n      \"lineHeight\": true,\n      \"opacity\": true,\n      \"order\": true,\n      \"orphans\": true,\n      \"widows\": true,\n      \"zIndex\": true,\n      \"zoom\": true\n    },\n    // Add in properties whose names you wish to fix before\n    // setting or getting the value\n    cssProps: {},\n    // Get and set the style property on a DOM Node\n    style: function style(elem, name, value, extra) {\n      // Don't set styles on text and comment nodes\n      if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {\n        return;\n      } // Make sure that we're working with the right name\n\n\n      var ret,\n          type,\n          hooks,\n          origName = camelCase(name),\n          isCustomProp = rcustomProp.test(name),\n          style = elem.style; // Make sure that we're working with the right name. We don't\n      // want to query the value if it is a CSS custom property\n      // since they are user-defined.\n\n      if (!isCustomProp) {\n        name = finalPropName(origName);\n      } // Gets hook for the prefixed version, then unprefixed version\n\n\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // Check if we're setting a value\n\n      if (value !== undefined) {\n        type = _typeof(value); // Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\n        if (type === \"string\" && (ret = rcssNum.exec(value)) && ret[1]) {\n          value = adjustCSS(elem, name, ret); // Fixes bug #9237\n\n          type = \"number\";\n        } // Make sure that null and NaN values aren't set (#7116)\n\n\n        if (value == null || value !== value) {\n          return;\n        } // If a number was passed in, add the unit (except for certain CSS properties)\n        // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append\n        // \"px\" to a few hardcoded values.\n\n\n        if (type === \"number\" && !isCustomProp) {\n          value += ret && ret[3] || (jQuery.cssNumber[origName] ? \"\" : \"px\");\n        } // background-* props affect original clone's values\n\n\n        if (!support.clearCloneStyle && value === \"\" && name.indexOf(\"background\") === 0) {\n          style[name] = \"inherit\";\n        } // If a hook was provided, use that value, otherwise just set the specified value\n\n\n        if (!hooks || !(\"set\" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {\n          if (isCustomProp) {\n            style.setProperty(name, value);\n          } else {\n            style[name] = value;\n          }\n        }\n      } else {\n        // If a hook was provided get the non-computed value from there\n        if (hooks && \"get\" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {\n          return ret;\n        } // Otherwise just get the value from the style object\n\n\n        return style[name];\n      }\n    },\n    css: function css(elem, name, extra, styles) {\n      var val,\n          num,\n          hooks,\n          origName = camelCase(name),\n          isCustomProp = rcustomProp.test(name); // Make sure that we're working with the right name. We don't\n      // want to modify the value if it is a CSS custom property\n      // since they are user-defined.\n\n      if (!isCustomProp) {\n        name = finalPropName(origName);\n      } // Try prefixed name followed by the unprefixed name\n\n\n      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName]; // If a hook was provided get the computed value from there\n\n      if (hooks && \"get\" in hooks) {\n        val = hooks.get(elem, true, extra);\n      } // Otherwise, if a way to get the computed value exists, use that\n\n\n      if (val === undefined) {\n        val = curCSS(elem, name, styles);\n      } // Convert \"normal\" to computed value\n\n\n      if (val === \"normal\" && name in cssNormalTransform) {\n        val = cssNormalTransform[name];\n      } // Make numeric if forced or a qualifier was provided and val looks numeric\n\n\n      if (extra === \"\" || extra) {\n        num = parseFloat(val);\n        return extra === true || isFinite(num) ? num || 0 : val;\n      }\n\n      return val;\n    }\n  });\n  jQuery.each([\"height\", \"width\"], function (_i, dimension) {\n    jQuery.cssHooks[dimension] = {\n      get: function get(elem, computed, extra) {\n        if (computed) {\n          // Certain elements can have dimension info if we invisibly show them\n          // but it must have a current display style that would benefit\n          return rdisplayswap.test(jQuery.css(elem, \"display\")) && ( // Support: Safari 8+\n          // Table columns in Safari have non-zero offsetWidth & zero\n          // getBoundingClientRect().width unless display is changed.\n          // Support: IE <=11 only\n          // Running getBoundingClientRect on a disconnected node\n          // in IE throws an error.\n          !elem.getClientRects().length || !elem.getBoundingClientRect().width) ? swap(elem, cssShow, function () {\n            return getWidthOrHeight(elem, dimension, extra);\n          }) : getWidthOrHeight(elem, dimension, extra);\n        }\n      },\n      set: function set(elem, value, extra) {\n        var matches,\n            styles = getStyles(elem),\n            // Only read styles.position if the test has a chance to fail\n        // to avoid forcing a reflow.\n        scrollboxSizeBuggy = !support.scrollboxSize() && styles.position === \"absolute\",\n            // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)\n        boxSizingNeeded = scrollboxSizeBuggy || extra,\n            isBorderBox = boxSizingNeeded && jQuery.css(elem, \"boxSizing\", false, styles) === \"border-box\",\n            subtract = extra ? boxModelAdjustment(elem, dimension, extra, isBorderBox, styles) : 0; // Account for unreliable border-box dimensions by comparing offset* to computed and\n        // faking a content-box to get border and padding (gh-3699)\n\n        if (isBorderBox && scrollboxSizeBuggy) {\n          subtract -= Math.ceil(elem[\"offset\" + dimension[0].toUpperCase() + dimension.slice(1)] - parseFloat(styles[dimension]) - boxModelAdjustment(elem, dimension, \"border\", false, styles) - 0.5);\n        } // Convert to pixels if value adjustment is needed\n\n\n        if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || \"px\") !== \"px\") {\n          elem.style[dimension] = value;\n          value = jQuery.css(elem, dimension);\n        }\n\n        return setPositiveNumber(elem, value, subtract);\n      }\n    };\n  });\n  jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {\n    if (computed) {\n      return (parseFloat(curCSS(elem, \"marginLeft\")) || elem.getBoundingClientRect().left - swap(elem, {\n        marginLeft: 0\n      }, function () {\n        return elem.getBoundingClientRect().left;\n      })) + \"px\";\n    }\n  }); // These hooks are used by animate to expand properties\n\n  jQuery.each({\n    margin: \"\",\n    padding: \"\",\n    border: \"Width\"\n  }, function (prefix, suffix) {\n    jQuery.cssHooks[prefix + suffix] = {\n      expand: function expand(value) {\n        var i = 0,\n            expanded = {},\n            // Assumes a single number if not a string\n        parts = typeof value === \"string\" ? value.split(\" \") : [value];\n\n        for (; i < 4; i++) {\n          expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];\n        }\n\n        return expanded;\n      }\n    };\n\n    if (prefix !== \"margin\") {\n      jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;\n    }\n  });\n  jQuery.fn.extend({\n    css: function css(name, value) {\n      return access(this, function (elem, name, value) {\n        var styles,\n            len,\n            map = {},\n            i = 0;\n\n        if (Array.isArray(name)) {\n          styles = getStyles(elem);\n          len = name.length;\n\n          for (; i < len; i++) {\n            map[name[i]] = jQuery.css(elem, name[i], false, styles);\n          }\n\n          return map;\n        }\n\n        return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);\n      }, name, value, arguments.length > 1);\n    }\n  });\n\n  function Tween(elem, options, prop, end, easing) {\n    return new Tween.prototype.init(elem, options, prop, end, easing);\n  }\n\n  jQuery.Tween = Tween;\n  Tween.prototype = {\n    constructor: Tween,\n    init: function init(elem, options, prop, end, easing, unit) {\n      this.elem = elem;\n      this.prop = prop;\n      this.easing = easing || jQuery.easing._default;\n      this.options = options;\n      this.start = this.now = this.cur();\n      this.end = end;\n      this.unit = unit || (jQuery.cssNumber[prop] ? \"\" : \"px\");\n    },\n    cur: function cur() {\n      var hooks = Tween.propHooks[this.prop];\n      return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);\n    },\n    run: function run(percent) {\n      var eased,\n          hooks = Tween.propHooks[this.prop];\n\n      if (this.options.duration) {\n        this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);\n      } else {\n        this.pos = eased = percent;\n      }\n\n      this.now = (this.end - this.start) * eased + this.start;\n\n      if (this.options.step) {\n        this.options.step.call(this.elem, this.now, this);\n      }\n\n      if (hooks && hooks.set) {\n        hooks.set(this);\n      } else {\n        Tween.propHooks._default.set(this);\n      }\n\n      return this;\n    }\n  };\n  Tween.prototype.init.prototype = Tween.prototype;\n  Tween.propHooks = {\n    _default: {\n      get: function get(tween) {\n        var result; // Use a property on the element directly when it is not a DOM element,\n        // or when there is no matching style property that exists.\n\n        if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {\n          return tween.elem[tween.prop];\n        } // Passing an empty string as a 3rd parameter to .css will automatically\n        // attempt a parseFloat and fallback to a string if the parse fails.\n        // Simple values such as \"10px\" are parsed to Float;\n        // complex values such as \"rotate(1rad)\" are returned as-is.\n\n\n        result = jQuery.css(tween.elem, tween.prop, \"\"); // Empty strings, null, undefined and \"auto\" are converted to 0.\n\n        return !result || result === \"auto\" ? 0 : result;\n      },\n      set: function set(tween) {\n        // Use step hook for back compat.\n        // Use cssHook if its there.\n        // Use .style if available and use plain properties where available.\n        if (jQuery.fx.step[tween.prop]) {\n          jQuery.fx.step[tween.prop](tween);\n        } else if (tween.elem.nodeType === 1 && (jQuery.cssHooks[tween.prop] || tween.elem.style[finalPropName(tween.prop)] != null)) {\n          jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);\n        } else {\n          tween.elem[tween.prop] = tween.now;\n        }\n      }\n    }\n  }; // Support: IE <=9 only\n  // Panic based approach to setting things on disconnected nodes\n\n  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n    set: function set(tween) {\n      if (tween.elem.nodeType && tween.elem.parentNode) {\n        tween.elem[tween.prop] = tween.now;\n      }\n    }\n  };\n  jQuery.easing = {\n    linear: function linear(p) {\n      return p;\n    },\n    swing: function swing(p) {\n      return 0.5 - Math.cos(p * Math.PI) / 2;\n    },\n    _default: \"swing\"\n  };\n  jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point\n\n  jQuery.fx.step = {};\n  var fxNow,\n      inProgress,\n      rfxtypes = /^(?:toggle|show|hide)$/,\n      rrun = /queueHooks$/;\n\n  function schedule() {\n    if (inProgress) {\n      if (document.hidden === false && window.requestAnimationFrame) {\n        window.requestAnimationFrame(schedule);\n      } else {\n        window.setTimeout(schedule, jQuery.fx.interval);\n      }\n\n      jQuery.fx.tick();\n    }\n  } // Animations created synchronously will run synchronously\n\n\n  function createFxNow() {\n    window.setTimeout(function () {\n      fxNow = undefined;\n    });\n    return fxNow = Date.now();\n  } // Generate parameters to create a standard animation\n\n\n  function genFx(type, includeWidth) {\n    var which,\n        i = 0,\n        attrs = {\n      height: type\n    }; // If we include width, step value is 1 to do all cssExpand values,\n    // otherwise step value is 2 to skip over Left and Right\n\n    includeWidth = includeWidth ? 1 : 0;\n\n    for (; i < 4; i += 2 - includeWidth) {\n      which = cssExpand[i];\n      attrs[\"margin\" + which] = attrs[\"padding\" + which] = type;\n    }\n\n    if (includeWidth) {\n      attrs.opacity = attrs.width = type;\n    }\n\n    return attrs;\n  }\n\n  function createTween(value, prop, animation) {\n    var tween,\n        collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners[\"*\"]),\n        index = 0,\n        length = collection.length;\n\n    for (; index < length; index++) {\n      if (tween = collection[index].call(animation, prop, value)) {\n        // We're done with this property\n        return tween;\n      }\n    }\n  }\n\n  function defaultPrefilter(elem, props, opts) {\n    var prop,\n        value,\n        toggle,\n        hooks,\n        oldfire,\n        propTween,\n        restoreDisplay,\n        display,\n        isBox = \"width\" in props || \"height\" in props,\n        anim = this,\n        orig = {},\n        style = elem.style,\n        hidden = elem.nodeType && isHiddenWithinTree(elem),\n        dataShow = dataPriv.get(elem, \"fxshow\"); // Queue-skipping animations hijack the fx hooks\n\n    if (!opts.queue) {\n      hooks = jQuery._queueHooks(elem, \"fx\");\n\n      if (hooks.unqueued == null) {\n        hooks.unqueued = 0;\n        oldfire = hooks.empty.fire;\n\n        hooks.empty.fire = function () {\n          if (!hooks.unqueued) {\n            oldfire();\n          }\n        };\n      }\n\n      hooks.unqueued++;\n      anim.always(function () {\n        // Ensure the complete handler is called before this completes\n        anim.always(function () {\n          hooks.unqueued--;\n\n          if (!jQuery.queue(elem, \"fx\").length) {\n            hooks.empty.fire();\n          }\n        });\n      });\n    } // Detect show/hide animations\n\n\n    for (prop in props) {\n      value = props[prop];\n\n      if (rfxtypes.test(value)) {\n        delete props[prop];\n        toggle = toggle || value === \"toggle\";\n\n        if (value === (hidden ? \"hide\" : \"show\")) {\n          // Pretend to be hidden if this is a \"show\" and\n          // there is still data from a stopped show/hide\n          if (value === \"show\" && dataShow && dataShow[prop] !== undefined) {\n            hidden = true; // Ignore all other no-op show/hide data\n          } else {\n            continue;\n          }\n        }\n\n        orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);\n      }\n    } // Bail out if this is a no-op like .hide().hide()\n\n\n    propTween = !jQuery.isEmptyObject(props);\n\n    if (!propTween && jQuery.isEmptyObject(orig)) {\n      return;\n    } // Restrict \"overflow\" and \"display\" styles during box animations\n\n\n    if (isBox && elem.nodeType === 1) {\n      // Support: IE <=9 - 11, Edge 12 - 15\n      // Record all 3 overflow attributes because IE does not infer the shorthand\n      // from identically-valued overflowX and overflowY and Edge just mirrors\n      // the overflowX value there.\n      opts.overflow = [style.overflow, style.overflowX, style.overflowY]; // Identify a display type, preferring old show/hide data over the CSS cascade\n\n      restoreDisplay = dataShow && dataShow.display;\n\n      if (restoreDisplay == null) {\n        restoreDisplay = dataPriv.get(elem, \"display\");\n      }\n\n      display = jQuery.css(elem, \"display\");\n\n      if (display === \"none\") {\n        if (restoreDisplay) {\n          display = restoreDisplay;\n        } else {\n          // Get nonempty value(s) by temporarily forcing visibility\n          showHide([elem], true);\n          restoreDisplay = elem.style.display || restoreDisplay;\n          display = jQuery.css(elem, \"display\");\n          showHide([elem]);\n        }\n      } // Animate inline elements as inline-block\n\n\n      if (display === \"inline\" || display === \"inline-block\" && restoreDisplay != null) {\n        if (jQuery.css(elem, \"float\") === \"none\") {\n          // Restore the original display value at the end of pure show/hide animations\n          if (!propTween) {\n            anim.done(function () {\n              style.display = restoreDisplay;\n            });\n\n            if (restoreDisplay == null) {\n              display = style.display;\n              restoreDisplay = display === \"none\" ? \"\" : display;\n            }\n          }\n\n          style.display = \"inline-block\";\n        }\n      }\n    }\n\n    if (opts.overflow) {\n      style.overflow = \"hidden\";\n      anim.always(function () {\n        style.overflow = opts.overflow[0];\n        style.overflowX = opts.overflow[1];\n        style.overflowY = opts.overflow[2];\n      });\n    } // Implement show/hide animations\n\n\n    propTween = false;\n\n    for (prop in orig) {\n      // General show/hide setup for this element animation\n      if (!propTween) {\n        if (dataShow) {\n          if (\"hidden\" in dataShow) {\n            hidden = dataShow.hidden;\n          }\n        } else {\n          dataShow = dataPriv.access(elem, \"fxshow\", {\n            display: restoreDisplay\n          });\n        } // Store hidden/visible for toggle so `.stop().toggle()` \"reverses\"\n\n\n        if (toggle) {\n          dataShow.hidden = !hidden;\n        } // Show elements before animating them\n\n\n        if (hidden) {\n          showHide([elem], true);\n        }\n        /* eslint-disable no-loop-func */\n\n\n        anim.done(function () {\n          /* eslint-enable no-loop-func */\n          // The final step of a \"hide\" animation is actually hiding the element\n          if (!hidden) {\n            showHide([elem]);\n          }\n\n          dataPriv.remove(elem, \"fxshow\");\n\n          for (prop in orig) {\n            jQuery.style(elem, prop, orig[prop]);\n          }\n        });\n      } // Per-property setup\n\n\n      propTween = createTween(hidden ? dataShow[prop] : 0, prop, anim);\n\n      if (!(prop in dataShow)) {\n        dataShow[prop] = propTween.start;\n\n        if (hidden) {\n          propTween.end = propTween.start;\n          propTween.start = 0;\n        }\n      }\n    }\n  }\n\n  function propFilter(props, specialEasing) {\n    var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass\n\n    for (index in props) {\n      name = camelCase(index);\n      easing = specialEasing[name];\n      value = props[index];\n\n      if (Array.isArray(value)) {\n        easing = value[1];\n        value = props[index] = value[0];\n      }\n\n      if (index !== name) {\n        props[name] = value;\n        delete props[index];\n      }\n\n      hooks = jQuery.cssHooks[name];\n\n      if (hooks && \"expand\" in hooks) {\n        value = hooks.expand(value);\n        delete props[name]; // Not quite $.extend, this won't overwrite existing keys.\n        // Reusing 'index' because we have the correct \"name\"\n\n        for (index in value) {\n          if (!(index in props)) {\n            props[index] = value[index];\n            specialEasing[index] = easing;\n          }\n        }\n      } else {\n        specialEasing[name] = easing;\n      }\n    }\n  }\n\n  function Animation(elem, properties, options) {\n    var result,\n        stopped,\n        index = 0,\n        length = Animation.prefilters.length,\n        deferred = jQuery.Deferred().always(function () {\n      // Don't match elem in the :animated selector\n      delete tick.elem;\n    }),\n        tick = function tick() {\n      if (stopped) {\n        return false;\n      }\n\n      var currentTime = fxNow || createFxNow(),\n          remaining = Math.max(0, animation.startTime + animation.duration - currentTime),\n          // Support: Android 2.3 only\n      // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n      temp = remaining / animation.duration || 0,\n          percent = 1 - temp,\n          index = 0,\n          length = animation.tweens.length;\n\n      for (; index < length; index++) {\n        animation.tweens[index].run(percent);\n      }\n\n      deferred.notifyWith(elem, [animation, percent, remaining]); // If there's more to do, yield\n\n      if (percent < 1 && length) {\n        return remaining;\n      } // If this was an empty animation, synthesize a final progress notification\n\n\n      if (!length) {\n        deferred.notifyWith(elem, [animation, 1, 0]);\n      } // Resolve the animation and report its conclusion\n\n\n      deferred.resolveWith(elem, [animation]);\n      return false;\n    },\n        animation = deferred.promise({\n      elem: elem,\n      props: jQuery.extend({}, properties),\n      opts: jQuery.extend(true, {\n        specialEasing: {},\n        easing: jQuery.easing._default\n      }, options),\n      originalProperties: properties,\n      originalOptions: options,\n      startTime: fxNow || createFxNow(),\n      duration: options.duration,\n      tweens: [],\n      createTween: function createTween(prop, end) {\n        var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);\n        animation.tweens.push(tween);\n        return tween;\n      },\n      stop: function stop(gotoEnd) {\n        var index = 0,\n            // If we are going to the end, we want to run all the tweens\n        // otherwise we skip this part\n        length = gotoEnd ? animation.tweens.length : 0;\n\n        if (stopped) {\n          return this;\n        }\n\n        stopped = true;\n\n        for (; index < length; index++) {\n          animation.tweens[index].run(1);\n        } // Resolve when we played the last frame; otherwise, reject\n\n\n        if (gotoEnd) {\n          deferred.notifyWith(elem, [animation, 1, 0]);\n          deferred.resolveWith(elem, [animation, gotoEnd]);\n        } else {\n          deferred.rejectWith(elem, [animation, gotoEnd]);\n        }\n\n        return this;\n      }\n    }),\n        props = animation.props;\n\n    propFilter(props, animation.opts.specialEasing);\n\n    for (; index < length; index++) {\n      result = Animation.prefilters[index].call(animation, elem, props, animation.opts);\n\n      if (result) {\n        if (isFunction(result.stop)) {\n          jQuery._queueHooks(animation.elem, animation.opts.queue).stop = result.stop.bind(result);\n        }\n\n        return result;\n      }\n    }\n\n    jQuery.map(props, createTween, animation);\n\n    if (isFunction(animation.opts.start)) {\n      animation.opts.start.call(elem, animation);\n    } // Attach callbacks from options\n\n\n    animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);\n    jQuery.fx.timer(jQuery.extend(tick, {\n      elem: elem,\n      anim: animation,\n      queue: animation.opts.queue\n    }));\n    return animation;\n  }\n\n  jQuery.Animation = jQuery.extend(Animation, {\n    tweeners: {\n      \"*\": [function (prop, value) {\n        var tween = this.createTween(prop, value);\n        adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);\n        return tween;\n      }]\n    },\n    tweener: function tweener(props, callback) {\n      if (isFunction(props)) {\n        callback = props;\n        props = [\"*\"];\n      } else {\n        props = props.match(rnothtmlwhite);\n      }\n\n      var prop,\n          index = 0,\n          length = props.length;\n\n      for (; index < length; index++) {\n        prop = props[index];\n        Animation.tweeners[prop] = Animation.tweeners[prop] || [];\n        Animation.tweeners[prop].unshift(callback);\n      }\n    },\n    prefilters: [defaultPrefilter],\n    prefilter: function prefilter(callback, prepend) {\n      if (prepend) {\n        Animation.prefilters.unshift(callback);\n      } else {\n        Animation.prefilters.push(callback);\n      }\n    }\n  });\n\n  jQuery.speed = function (speed, easing, fn) {\n    var opt = speed && _typeof(speed) === \"object\" ? jQuery.extend({}, speed) : {\n      complete: fn || !fn && easing || isFunction(speed) && speed,\n      duration: speed,\n      easing: fn && easing || easing && !isFunction(easing) && easing\n    }; // Go to the end state if fx are off\n\n    if (jQuery.fx.off) {\n      opt.duration = 0;\n    } else {\n      if (typeof opt.duration !== \"number\") {\n        if (opt.duration in jQuery.fx.speeds) {\n          opt.duration = jQuery.fx.speeds[opt.duration];\n        } else {\n          opt.duration = jQuery.fx.speeds._default;\n        }\n      }\n    } // Normalize opt.queue - true/undefined/null -> \"fx\"\n\n\n    if (opt.queue == null || opt.queue === true) {\n      opt.queue = \"fx\";\n    } // Queueing\n\n\n    opt.old = opt.complete;\n\n    opt.complete = function () {\n      if (isFunction(opt.old)) {\n        opt.old.call(this);\n      }\n\n      if (opt.queue) {\n        jQuery.dequeue(this, opt.queue);\n      }\n    };\n\n    return opt;\n  };\n\n  jQuery.fn.extend({\n    fadeTo: function fadeTo(speed, to, easing, callback) {\n      // Show any hidden elements after setting opacity to 0\n      return this.filter(isHiddenWithinTree).css(\"opacity\", 0).show() // Animate to the value specified\n      .end().animate({\n        opacity: to\n      }, speed, easing, callback);\n    },\n    animate: function animate(prop, speed, easing, callback) {\n      var empty = jQuery.isEmptyObject(prop),\n          optall = jQuery.speed(speed, easing, callback),\n          doAnimation = function doAnimation() {\n        // Operate on a copy of prop so per-property easing won't be lost\n        var anim = Animation(this, jQuery.extend({}, prop), optall); // Empty animations, or finishing resolves immediately\n\n        if (empty || dataPriv.get(this, \"finish\")) {\n          anim.stop(true);\n        }\n      };\n\n      doAnimation.finish = doAnimation;\n      return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);\n    },\n    stop: function stop(type, clearQueue, gotoEnd) {\n      var stopQueue = function stopQueue(hooks) {\n        var stop = hooks.stop;\n        delete hooks.stop;\n        stop(gotoEnd);\n      };\n\n      if (typeof type !== \"string\") {\n        gotoEnd = clearQueue;\n        clearQueue = type;\n        type = undefined;\n      }\n\n      if (clearQueue) {\n        this.queue(type || \"fx\", []);\n      }\n\n      return this.each(function () {\n        var dequeue = true,\n            index = type != null && type + \"queueHooks\",\n            timers = jQuery.timers,\n            data = dataPriv.get(this);\n\n        if (index) {\n          if (data[index] && data[index].stop) {\n            stopQueue(data[index]);\n          }\n        } else {\n          for (index in data) {\n            if (data[index] && data[index].stop && rrun.test(index)) {\n              stopQueue(data[index]);\n            }\n          }\n        }\n\n        for (index = timers.length; index--;) {\n          if (timers[index].elem === this && (type == null || timers[index].queue === type)) {\n            timers[index].anim.stop(gotoEnd);\n            dequeue = false;\n            timers.splice(index, 1);\n          }\n        } // Start the next in the queue if the last step wasn't forced.\n        // Timers currently will call their complete callbacks, which\n        // will dequeue but only if they were gotoEnd.\n\n\n        if (dequeue || !gotoEnd) {\n          jQuery.dequeue(this, type);\n        }\n      });\n    },\n    finish: function finish(type) {\n      if (type !== false) {\n        type = type || \"fx\";\n      }\n\n      return this.each(function () {\n        var index,\n            data = dataPriv.get(this),\n            queue = data[type + \"queue\"],\n            hooks = data[type + \"queueHooks\"],\n            timers = jQuery.timers,\n            length = queue ? queue.length : 0; // Enable finishing flag on private data\n\n        data.finish = true; // Empty the queue first\n\n        jQuery.queue(this, type, []);\n\n        if (hooks && hooks.stop) {\n          hooks.stop.call(this, true);\n        } // Look for any active animations, and finish them\n\n\n        for (index = timers.length; index--;) {\n          if (timers[index].elem === this && timers[index].queue === type) {\n            timers[index].anim.stop(true);\n            timers.splice(index, 1);\n          }\n        } // Look for any animations in the old queue and finish them\n\n\n        for (index = 0; index < length; index++) {\n          if (queue[index] && queue[index].finish) {\n            queue[index].finish.call(this);\n          }\n        } // Turn off finishing flag\n\n\n        delete data.finish;\n      });\n    }\n  });\n  jQuery.each([\"toggle\", \"show\", \"hide\"], function (_i, name) {\n    var cssFn = jQuery.fn[name];\n\n    jQuery.fn[name] = function (speed, easing, callback) {\n      return speed == null || typeof speed === \"boolean\" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);\n    };\n  }); // Generate shortcuts for custom animations\n\n  jQuery.each({\n    slideDown: genFx(\"show\"),\n    slideUp: genFx(\"hide\"),\n    slideToggle: genFx(\"toggle\"),\n    fadeIn: {\n      opacity: \"show\"\n    },\n    fadeOut: {\n      opacity: \"hide\"\n    },\n    fadeToggle: {\n      opacity: \"toggle\"\n    }\n  }, function (name, props) {\n    jQuery.fn[name] = function (speed, easing, callback) {\n      return this.animate(props, speed, easing, callback);\n    };\n  });\n  jQuery.timers = [];\n\n  jQuery.fx.tick = function () {\n    var timer,\n        i = 0,\n        timers = jQuery.timers;\n    fxNow = Date.now();\n\n    for (; i < timers.length; i++) {\n      timer = timers[i]; // Run the timer and safely remove it when done (allowing for external removal)\n\n      if (!timer() && timers[i] === timer) {\n        timers.splice(i--, 1);\n      }\n    }\n\n    if (!timers.length) {\n      jQuery.fx.stop();\n    }\n\n    fxNow = undefined;\n  };\n\n  jQuery.fx.timer = function (timer) {\n    jQuery.timers.push(timer);\n    jQuery.fx.start();\n  };\n\n  jQuery.fx.interval = 13;\n\n  jQuery.fx.start = function () {\n    if (inProgress) {\n      return;\n    }\n\n    inProgress = true;\n    schedule();\n  };\n\n  jQuery.fx.stop = function () {\n    inProgress = null;\n  };\n\n  jQuery.fx.speeds = {\n    slow: 600,\n    fast: 200,\n    // Default speed\n    _default: 400\n  }; // Based off of the plugin by Clint Helfers, with permission.\n  // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\n\n  jQuery.fn.delay = function (time, type) {\n    time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;\n    type = type || \"fx\";\n    return this.queue(type, function (next, hooks) {\n      var timeout = window.setTimeout(next, time);\n\n      hooks.stop = function () {\n        window.clearTimeout(timeout);\n      };\n    });\n  };\n\n  (function () {\n    var input = document.createElement(\"input\"),\n        select = document.createElement(\"select\"),\n        opt = select.appendChild(document.createElement(\"option\"));\n    input.type = \"checkbox\"; // Support: Android <=4.3 only\n    // Default value for a checkbox should be \"on\"\n\n    support.checkOn = input.value !== \"\"; // Support: IE <=11 only\n    // Must access selectedIndex to make default options select\n\n    support.optSelected = opt.selected; // Support: IE <=11 only\n    // An input loses its value after becoming a radio\n\n    input = document.createElement(\"input\");\n    input.value = \"t\";\n    input.type = \"radio\";\n    support.radioValue = input.value === \"t\";\n  })();\n\n  var boolHook,\n      attrHandle = jQuery.expr.attrHandle;\n  jQuery.fn.extend({\n    attr: function attr(name, value) {\n      return access(this, jQuery.attr, name, value, arguments.length > 1);\n    },\n    removeAttr: function removeAttr(name) {\n      return this.each(function () {\n        jQuery.removeAttr(this, name);\n      });\n    }\n  });\n  jQuery.extend({\n    attr: function attr(elem, name, value) {\n      var ret,\n          hooks,\n          nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes\n\n      if (nType === 3 || nType === 8 || nType === 2) {\n        return;\n      } // Fallback to prop when attributes are not supported\n\n\n      if (typeof elem.getAttribute === \"undefined\") {\n        return jQuery.prop(elem, name, value);\n      } // Attribute hooks are determined by the lowercase version\n      // Grab necessary hook if one is defined\n\n\n      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {\n        hooks = jQuery.attrHooks[name.toLowerCase()] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);\n      }\n\n      if (value !== undefined) {\n        if (value === null) {\n          jQuery.removeAttr(elem, name);\n          return;\n        }\n\n        if (hooks && \"set\" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {\n          return ret;\n        }\n\n        elem.setAttribute(name, value + \"\");\n        return value;\n      }\n\n      if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\n        return ret;\n      }\n\n      ret = jQuery.find.attr(elem, name); // Non-existent attributes return null, we normalize to undefined\n\n      return ret == null ? undefined : ret;\n    },\n    attrHooks: {\n      type: {\n        set: function set(elem, value) {\n          if (!support.radioValue && value === \"radio\" && nodeName(elem, \"input\")) {\n            var val = elem.value;\n            elem.setAttribute(\"type\", value);\n\n            if (val) {\n              elem.value = val;\n            }\n\n            return value;\n          }\n        }\n      }\n    },\n    removeAttr: function removeAttr(elem, value) {\n      var name,\n          i = 0,\n          // Attribute names can contain non-HTML whitespace characters\n      // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2\n      attrNames = value && value.match(rnothtmlwhite);\n\n      if (attrNames && elem.nodeType === 1) {\n        while (name = attrNames[i++]) {\n          elem.removeAttribute(name);\n        }\n      }\n    }\n  }); // Hooks for boolean attributes\n\n  boolHook = {\n    set: function set(elem, value, name) {\n      if (value === false) {\n        // Remove boolean attributes when set to false\n        jQuery.removeAttr(elem, name);\n      } else {\n        elem.setAttribute(name, name);\n      }\n\n      return name;\n    }\n  };\n  jQuery.each(jQuery.expr.match.bool.source.match(/\\w+/g), function (_i, name) {\n    var getter = attrHandle[name] || jQuery.find.attr;\n\n    attrHandle[name] = function (elem, name, isXML) {\n      var ret,\n          handle,\n          lowercaseName = name.toLowerCase();\n\n      if (!isXML) {\n        // Avoid an infinite loop by temporarily removing this function from the getter\n        handle = attrHandle[lowercaseName];\n        attrHandle[lowercaseName] = ret;\n        ret = getter(elem, name, isXML) != null ? lowercaseName : null;\n        attrHandle[lowercaseName] = handle;\n      }\n\n      return ret;\n    };\n  });\n  var rfocusable = /^(?:input|select|textarea|button)$/i,\n      rclickable = /^(?:a|area)$/i;\n  jQuery.fn.extend({\n    prop: function prop(name, value) {\n      return access(this, jQuery.prop, name, value, arguments.length > 1);\n    },\n    removeProp: function removeProp(name) {\n      return this.each(function () {\n        delete this[jQuery.propFix[name] || name];\n      });\n    }\n  });\n  jQuery.extend({\n    prop: function prop(elem, name, value) {\n      var ret,\n          hooks,\n          nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes\n\n      if (nType === 3 || nType === 8 || nType === 2) {\n        return;\n      }\n\n      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {\n        // Fix name and attach hooks\n        name = jQuery.propFix[name] || name;\n        hooks = jQuery.propHooks[name];\n      }\n\n      if (value !== undefined) {\n        if (hooks && \"set\" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {\n          return ret;\n        }\n\n        return elem[name] = value;\n      }\n\n      if (hooks && \"get\" in hooks && (ret = hooks.get(elem, name)) !== null) {\n        return ret;\n      }\n\n      return elem[name];\n    },\n    propHooks: {\n      tabIndex: {\n        get: function get(elem) {\n          // Support: IE <=9 - 11 only\n          // elem.tabIndex doesn't always return the\n          // correct value when it hasn't been explicitly set\n          // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n          // Use proper attribute retrieval(#12072)\n          var tabindex = jQuery.find.attr(elem, \"tabindex\");\n\n          if (tabindex) {\n            return parseInt(tabindex, 10);\n          }\n\n          if (rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href) {\n            return 0;\n          }\n\n          return -1;\n        }\n      }\n    },\n    propFix: {\n      \"for\": \"htmlFor\",\n      \"class\": \"className\"\n    }\n  }); // Support: IE <=11 only\n  // Accessing the selectedIndex property\n  // forces the browser to respect setting selected\n  // on the option\n  // The getter ensures a default option is selected\n  // when in an optgroup\n  // eslint rule \"no-unused-expressions\" is disabled for this code\n  // since it considers such accessions noop\n\n  if (!support.optSelected) {\n    jQuery.propHooks.selected = {\n      get: function get(elem) {\n        /* eslint no-unused-expressions: \"off\" */\n        var parent = elem.parentNode;\n\n        if (parent && parent.parentNode) {\n          parent.parentNode.selectedIndex;\n        }\n\n        return null;\n      },\n      set: function set(elem) {\n        /* eslint no-unused-expressions: \"off\" */\n        var parent = elem.parentNode;\n\n        if (parent) {\n          parent.selectedIndex;\n\n          if (parent.parentNode) {\n            parent.parentNode.selectedIndex;\n          }\n        }\n      }\n    };\n  }\n\n  jQuery.each([\"tabIndex\", \"readOnly\", \"maxLength\", \"cellSpacing\", \"cellPadding\", \"rowSpan\", \"colSpan\", \"useMap\", \"frameBorder\", \"contentEditable\"], function () {\n    jQuery.propFix[this.toLowerCase()] = this;\n  }); // Strip and collapse whitespace according to HTML spec\n  // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace\n\n  function stripAndCollapse(value) {\n    var tokens = value.match(rnothtmlwhite) || [];\n    return tokens.join(\" \");\n  }\n\n  function getClass(elem) {\n    return elem.getAttribute && elem.getAttribute(\"class\") || \"\";\n  }\n\n  function classesToArray(value) {\n    if (Array.isArray(value)) {\n      return value;\n    }\n\n    if (typeof value === \"string\") {\n      return value.match(rnothtmlwhite) || [];\n    }\n\n    return [];\n  }\n\n  jQuery.fn.extend({\n    addClass: function addClass(value) {\n      var classes,\n          elem,\n          cur,\n          curValue,\n          clazz,\n          j,\n          finalValue,\n          i = 0;\n\n      if (isFunction(value)) {\n        return this.each(function (j) {\n          jQuery(this).addClass(value.call(this, j, getClass(this)));\n        });\n      }\n\n      classes = classesToArray(value);\n\n      if (classes.length) {\n        while (elem = this[i++]) {\n          curValue = getClass(elem);\n          cur = elem.nodeType === 1 && \" \" + stripAndCollapse(curValue) + \" \";\n\n          if (cur) {\n            j = 0;\n\n            while (clazz = classes[j++]) {\n              if (cur.indexOf(\" \" + clazz + \" \") < 0) {\n                cur += clazz + \" \";\n              }\n            } // Only assign if different to avoid unneeded rendering.\n\n\n            finalValue = stripAndCollapse(cur);\n\n            if (curValue !== finalValue) {\n              elem.setAttribute(\"class\", finalValue);\n            }\n          }\n        }\n      }\n\n      return this;\n    },\n    removeClass: function removeClass(value) {\n      var classes,\n          elem,\n          cur,\n          curValue,\n          clazz,\n          j,\n          finalValue,\n          i = 0;\n\n      if (isFunction(value)) {\n        return this.each(function (j) {\n          jQuery(this).removeClass(value.call(this, j, getClass(this)));\n        });\n      }\n\n      if (!arguments.length) {\n        return this.attr(\"class\", \"\");\n      }\n\n      classes = classesToArray(value);\n\n      if (classes.length) {\n        while (elem = this[i++]) {\n          curValue = getClass(elem); // This expression is here for better compressibility (see addClass)\n\n          cur = elem.nodeType === 1 && \" \" + stripAndCollapse(curValue) + \" \";\n\n          if (cur) {\n            j = 0;\n\n            while (clazz = classes[j++]) {\n              // Remove *all* instances\n              while (cur.indexOf(\" \" + clazz + \" \") > -1) {\n                cur = cur.replace(\" \" + clazz + \" \", \" \");\n              }\n            } // Only assign if different to avoid unneeded rendering.\n\n\n            finalValue = stripAndCollapse(cur);\n\n            if (curValue !== finalValue) {\n              elem.setAttribute(\"class\", finalValue);\n            }\n          }\n        }\n      }\n\n      return this;\n    },\n    toggleClass: function toggleClass(value, stateVal) {\n      var type = _typeof(value),\n          isValidValue = type === \"string\" || Array.isArray(value);\n\n      if (typeof stateVal === \"boolean\" && isValidValue) {\n        return stateVal ? this.addClass(value) : this.removeClass(value);\n      }\n\n      if (isFunction(value)) {\n        return this.each(function (i) {\n          jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);\n        });\n      }\n\n      return this.each(function () {\n        var className, i, self, classNames;\n\n        if (isValidValue) {\n          // Toggle individual class names\n          i = 0;\n          self = jQuery(this);\n          classNames = classesToArray(value);\n\n          while (className = classNames[i++]) {\n            // Check each className given, space separated list\n            if (self.hasClass(className)) {\n              self.removeClass(className);\n            } else {\n              self.addClass(className);\n            }\n          } // Toggle whole class name\n\n        } else if (value === undefined || type === \"boolean\") {\n          className = getClass(this);\n\n          if (className) {\n            // Store className if set\n            dataPriv.set(this, \"__className__\", className);\n          } // If the element has a class name or if we're passed `false`,\n          // then remove the whole classname (if there was one, the above saved it).\n          // Otherwise bring back whatever was previously saved (if anything),\n          // falling back to the empty string if nothing was stored.\n\n\n          if (this.setAttribute) {\n            this.setAttribute(\"class\", className || value === false ? \"\" : dataPriv.get(this, \"__className__\") || \"\");\n          }\n        }\n      });\n    },\n    hasClass: function hasClass(selector) {\n      var className,\n          elem,\n          i = 0;\n      className = \" \" + selector + \" \";\n\n      while (elem = this[i++]) {\n        if (elem.nodeType === 1 && (\" \" + stripAndCollapse(getClass(elem)) + \" \").indexOf(className) > -1) {\n          return true;\n        }\n      }\n\n      return false;\n    }\n  });\n  var rreturn = /\\r/g;\n  jQuery.fn.extend({\n    val: function val(value) {\n      var hooks,\n          ret,\n          valueIsFunction,\n          elem = this[0];\n\n      if (!arguments.length) {\n        if (elem) {\n          hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];\n\n          if (hooks && \"get\" in hooks && (ret = hooks.get(elem, \"value\")) !== undefined) {\n            return ret;\n          }\n\n          ret = elem.value; // Handle most common string cases\n\n          if (typeof ret === \"string\") {\n            return ret.replace(rreturn, \"\");\n          } // Handle cases where value is null/undef or number\n\n\n          return ret == null ? \"\" : ret;\n        }\n\n        return;\n      }\n\n      valueIsFunction = isFunction(value);\n      return this.each(function (i) {\n        var val;\n\n        if (this.nodeType !== 1) {\n          return;\n        }\n\n        if (valueIsFunction) {\n          val = value.call(this, i, jQuery(this).val());\n        } else {\n          val = value;\n        } // Treat null/undefined as \"\"; convert numbers to string\n\n\n        if (val == null) {\n          val = \"\";\n        } else if (typeof val === \"number\") {\n          val += \"\";\n        } else if (Array.isArray(val)) {\n          val = jQuery.map(val, function (value) {\n            return value == null ? \"\" : value + \"\";\n          });\n        }\n\n        hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()]; // If set returns undefined, fall back to normal setting\n\n        if (!hooks || !(\"set\" in hooks) || hooks.set(this, val, \"value\") === undefined) {\n          this.value = val;\n        }\n      });\n    }\n  });\n  jQuery.extend({\n    valHooks: {\n      option: {\n        get: function get(elem) {\n          var val = jQuery.find.attr(elem, \"value\");\n          return val != null ? val : // Support: IE <=10 - 11 only\n          // option.text throws exceptions (#14686, #14858)\n          // Strip and collapse whitespace\n          // https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n          stripAndCollapse(jQuery.text(elem));\n        }\n      },\n      select: {\n        get: function get(elem) {\n          var value,\n              option,\n              i,\n              options = elem.options,\n              index = elem.selectedIndex,\n              one = elem.type === \"select-one\",\n              values = one ? null : [],\n              max = one ? index + 1 : options.length;\n\n          if (index < 0) {\n            i = max;\n          } else {\n            i = one ? index : 0;\n          } // Loop through all the selected options\n\n\n          for (; i < max; i++) {\n            option = options[i]; // Support: IE <=9 only\n            // IE8-9 doesn't update selected after form reset (#2551)\n\n            if ((option.selected || i === index) && // Don't return options that are disabled or in a disabled optgroup\n            !option.disabled && (!option.parentNode.disabled || !nodeName(option.parentNode, \"optgroup\"))) {\n              // Get the specific value for the option\n              value = jQuery(option).val(); // We don't need an array for one selects\n\n              if (one) {\n                return value;\n              } // Multi-Selects return an array\n\n\n              values.push(value);\n            }\n          }\n\n          return values;\n        },\n        set: function set(elem, value) {\n          var optionSet,\n              option,\n              options = elem.options,\n              values = jQuery.makeArray(value),\n              i = options.length;\n\n          while (i--) {\n            option = options[i];\n            /* eslint-disable no-cond-assign */\n\n            if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {\n              optionSet = true;\n            }\n            /* eslint-enable no-cond-assign */\n\n          } // Force browsers to behave consistently when non-matching value is set\n\n\n          if (!optionSet) {\n            elem.selectedIndex = -1;\n          }\n\n          return values;\n        }\n      }\n    }\n  }); // Radios and checkboxes getter/setter\n\n  jQuery.each([\"radio\", \"checkbox\"], function () {\n    jQuery.valHooks[this] = {\n      set: function set(elem, value) {\n        if (Array.isArray(value)) {\n          return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;\n        }\n      }\n    };\n\n    if (!support.checkOn) {\n      jQuery.valHooks[this].get = function (elem) {\n        return elem.getAttribute(\"value\") === null ? \"on\" : elem.value;\n      };\n    }\n  }); // Return jQuery for attributes-only inclusion\n\n  support.focusin = \"onfocusin\" in window;\n\n  var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\n      stopPropagationCallback = function stopPropagationCallback(e) {\n    e.stopPropagation();\n  };\n\n  jQuery.extend(jQuery.event, {\n    trigger: function trigger(event, data, elem, onlyHandlers) {\n      var i,\n          cur,\n          tmp,\n          bubbleType,\n          ontype,\n          handle,\n          special,\n          lastElement,\n          eventPath = [elem || document],\n          type = hasOwn.call(event, \"type\") ? event.type : event,\n          namespaces = hasOwn.call(event, \"namespace\") ? event.namespace.split(\".\") : [];\n      cur = lastElement = tmp = elem = elem || document; // Don't do events on text and comment nodes\n\n      if (elem.nodeType === 3 || elem.nodeType === 8) {\n        return;\n      } // focus/blur morphs to focusin/out; ensure we're not firing them right now\n\n\n      if (rfocusMorph.test(type + jQuery.event.triggered)) {\n        return;\n      }\n\n      if (type.indexOf(\".\") > -1) {\n        // Namespaced trigger; create a regexp to match event type in handle()\n        namespaces = type.split(\".\");\n        type = namespaces.shift();\n        namespaces.sort();\n      }\n\n      ontype = type.indexOf(\":\") < 0 && \"on\" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string\n\n      event = event[jQuery.expando] ? event : new jQuery.Event(type, _typeof(event) === \"object\" && event); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\n      event.isTrigger = onlyHandlers ? 2 : 3;\n      event.namespace = namespaces.join(\".\");\n      event.rnamespace = event.namespace ? new RegExp(\"(^|\\\\.)\" + namespaces.join(\"\\\\.(?:.*\\\\.|)\") + \"(\\\\.|$)\") : null; // Clean up the event in case it is being reused\n\n      event.result = undefined;\n\n      if (!event.target) {\n        event.target = elem;\n      } // Clone any incoming data and prepend the event, creating the handler arg list\n\n\n      data = data == null ? [event] : jQuery.makeArray(data, [event]); // Allow special events to draw outside the lines\n\n      special = jQuery.event.special[type] || {};\n\n      if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {\n        return;\n      } // Determine event propagation path in advance, per W3C events spec (#9951)\n      // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\n\n      if (!onlyHandlers && !special.noBubble && !isWindow(elem)) {\n        bubbleType = special.delegateType || type;\n\n        if (!rfocusMorph.test(bubbleType + type)) {\n          cur = cur.parentNode;\n        }\n\n        for (; cur; cur = cur.parentNode) {\n          eventPath.push(cur);\n          tmp = cur;\n        } // Only add window if we got to document (e.g., not plain obj or detached DOM)\n\n\n        if (tmp === (elem.ownerDocument || document)) {\n          eventPath.push(tmp.defaultView || tmp.parentWindow || window);\n        }\n      } // Fire handlers on the event path\n\n\n      i = 0;\n\n      while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {\n        lastElement = cur;\n        event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler\n\n        handle = (dataPriv.get(cur, \"events\") || Object.create(null))[event.type] && dataPriv.get(cur, \"handle\");\n\n        if (handle) {\n          handle.apply(cur, data);\n        } // Native handler\n\n\n        handle = ontype && cur[ontype];\n\n        if (handle && handle.apply && acceptData(cur)) {\n          event.result = handle.apply(cur, data);\n\n          if (event.result === false) {\n            event.preventDefault();\n          }\n        }\n      }\n\n      event.type = type; // If nobody prevented the default action, do it now\n\n      if (!onlyHandlers && !event.isDefaultPrevented()) {\n        if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {\n          // Call a native DOM method on the target with the same name as the event.\n          // Don't do default actions on window, that's where global variables be (#6170)\n          if (ontype && isFunction(elem[type]) && !isWindow(elem)) {\n            // Don't re-trigger an onFOO event when we call its FOO() method\n            tmp = elem[ontype];\n\n            if (tmp) {\n              elem[ontype] = null;\n            } // Prevent re-triggering of the same event, since we already bubbled it above\n\n\n            jQuery.event.triggered = type;\n\n            if (event.isPropagationStopped()) {\n              lastElement.addEventListener(type, stopPropagationCallback);\n            }\n\n            elem[type]();\n\n            if (event.isPropagationStopped()) {\n              lastElement.removeEventListener(type, stopPropagationCallback);\n            }\n\n            jQuery.event.triggered = undefined;\n\n            if (tmp) {\n              elem[ontype] = tmp;\n            }\n          }\n        }\n      }\n\n      return event.result;\n    },\n    // Piggyback on a donor event to simulate a different one\n    // Used only for `focus(in | out)` events\n    simulate: function simulate(type, elem, event) {\n      var e = jQuery.extend(new jQuery.Event(), event, {\n        type: type,\n        isSimulated: true\n      });\n      jQuery.event.trigger(e, null, elem);\n    }\n  });\n  jQuery.fn.extend({\n    trigger: function trigger(type, data) {\n      return this.each(function () {\n        jQuery.event.trigger(type, data, this);\n      });\n    },\n    triggerHandler: function triggerHandler(type, data) {\n      var elem = this[0];\n\n      if (elem) {\n        return jQuery.event.trigger(type, data, elem, true);\n      }\n    }\n  }); // Support: Firefox <=44\n  // Firefox doesn't have focus(in | out) events\n  // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n  //\n  // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1\n  // focus(in | out) events fire after focus & blur events,\n  // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n  // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857\n\n  if (!support.focusin) {\n    jQuery.each({\n      focus: \"focusin\",\n      blur: \"focusout\"\n    }, function (orig, fix) {\n      // Attach a single capturing handler on the document while someone wants focusin/focusout\n      var handler = function handler(event) {\n        jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));\n      };\n\n      jQuery.event.special[fix] = {\n        setup: function setup() {\n          // Handle: regular nodes (via `this.ownerDocument`), window\n          // (via `this.document`) & document (via `this`).\n          var doc = this.ownerDocument || this.document || this,\n              attaches = dataPriv.access(doc, fix);\n\n          if (!attaches) {\n            doc.addEventListener(orig, handler, true);\n          }\n\n          dataPriv.access(doc, fix, (attaches || 0) + 1);\n        },\n        teardown: function teardown() {\n          var doc = this.ownerDocument || this.document || this,\n              attaches = dataPriv.access(doc, fix) - 1;\n\n          if (!attaches) {\n            doc.removeEventListener(orig, handler, true);\n            dataPriv.remove(doc, fix);\n          } else {\n            dataPriv.access(doc, fix, attaches);\n          }\n        }\n      };\n    });\n  }\n\n  var location = window.location;\n  var nonce = {\n    guid: Date.now()\n  };\n  var rquery = /\\?/; // Cross-browser xml parsing\n\n  jQuery.parseXML = function (data) {\n    var xml, parserErrorElem;\n\n    if (!data || typeof data !== \"string\") {\n      return null;\n    } // Support: IE 9 - 11 only\n    // IE throws on parseFromString with invalid input.\n\n\n    try {\n      xml = new window.DOMParser().parseFromString(data, \"text/xml\");\n    } catch (e) {}\n\n    parserErrorElem = xml && xml.getElementsByTagName(\"parsererror\")[0];\n\n    if (!xml || parserErrorElem) {\n      jQuery.error(\"Invalid XML: \" + (parserErrorElem ? jQuery.map(parserErrorElem.childNodes, function (el) {\n        return el.textContent;\n      }).join(\"\\n\") : data));\n    }\n\n    return xml;\n  };\n\n  var rbracket = /\\[\\]$/,\n      rCRLF = /\\r?\\n/g,\n      rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n      rsubmittable = /^(?:input|select|textarea|keygen)/i;\n\n  function buildParams(prefix, obj, traditional, add) {\n    var name;\n\n    if (Array.isArray(obj)) {\n      // Serialize array item.\n      jQuery.each(obj, function (i, v) {\n        if (traditional || rbracket.test(prefix)) {\n          // Treat each array item as a scalar.\n          add(prefix, v);\n        } else {\n          // Item is non-scalar (array or object), encode its numeric index.\n          buildParams(prefix + \"[\" + (_typeof(v) === \"object\" && v != null ? i : \"\") + \"]\", v, traditional, add);\n        }\n      });\n    } else if (!traditional && toType(obj) === \"object\") {\n      // Serialize object item.\n      for (name in obj) {\n        buildParams(prefix + \"[\" + name + \"]\", obj[name], traditional, add);\n      }\n    } else {\n      // Serialize scalar item.\n      add(prefix, obj);\n    }\n  } // Serialize an array of form elements or a set of\n  // key/values into a query string\n\n\n  jQuery.param = function (a, traditional) {\n    var prefix,\n        s = [],\n        add = function add(key, valueOrFunction) {\n      // If value is a function, invoke it and use its return value\n      var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;\n      s[s.length] = encodeURIComponent(key) + \"=\" + encodeURIComponent(value == null ? \"\" : value);\n    };\n\n    if (a == null) {\n      return \"\";\n    } // If an array was passed in, assume that it is an array of form elements.\n\n\n    if (Array.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {\n      // Serialize the form elements\n      jQuery.each(a, function () {\n        add(this.name, this.value);\n      });\n    } else {\n      // If traditional, encode the \"old\" way (the way 1.3.2 or older\n      // did it), otherwise encode params recursively.\n      for (prefix in a) {\n        buildParams(prefix, a[prefix], traditional, add);\n      }\n    } // Return the resulting serialization\n\n\n    return s.join(\"&\");\n  };\n\n  jQuery.fn.extend({\n    serialize: function serialize() {\n      return jQuery.param(this.serializeArray());\n    },\n    serializeArray: function serializeArray() {\n      return this.map(function () {\n        // Can add propHook for \"elements\" to filter or add form elements\n        var elements = jQuery.prop(this, \"elements\");\n        return elements ? jQuery.makeArray(elements) : this;\n      }).filter(function () {\n        var type = this.type; // Use .is( \":disabled\" ) so that fieldset[disabled] works\n\n        return this.name && !jQuery(this).is(\":disabled\") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));\n      }).map(function (_i, elem) {\n        var val = jQuery(this).val();\n\n        if (val == null) {\n          return null;\n        }\n\n        if (Array.isArray(val)) {\n          return jQuery.map(val, function (val) {\n            return {\n              name: elem.name,\n              value: val.replace(rCRLF, \"\\r\\n\")\n            };\n          });\n        }\n\n        return {\n          name: elem.name,\n          value: val.replace(rCRLF, \"\\r\\n\")\n        };\n      }).get();\n    }\n  });\n  var r20 = /%20/g,\n      rhash = /#.*$/,\n      rantiCache = /([?&])_=[^&]*/,\n      rheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n      // #7653, #8125, #8152: local protocol detection\n  rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n      rnoContent = /^(?:GET|HEAD)$/,\n      rprotocol = /^\\/\\//,\n\n  /* Prefilters\n   * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n   * 2) These are called:\n   *    - BEFORE asking for a transport\n   *    - AFTER param serialization (s.data is a string if s.processData is true)\n   * 3) key is the dataType\n   * 4) the catchall symbol \"*\" can be used\n   * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n   */\n  prefilters = {},\n\n  /* Transports bindings\n   * 1) key is the dataType\n   * 2) the catchall symbol \"*\" can be used\n   * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n   */\n  transports = {},\n      // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n  allTypes = \"*/\".concat(\"*\"),\n      // Anchor tag for parsing the document origin\n  originAnchor = document.createElement(\"a\");\n  originAnchor.href = location.href; // Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\n\n  function addToPrefiltersOrTransports(structure) {\n    // dataTypeExpression is optional and defaults to \"*\"\n    return function (dataTypeExpression, func) {\n      if (typeof dataTypeExpression !== \"string\") {\n        func = dataTypeExpression;\n        dataTypeExpression = \"*\";\n      }\n\n      var dataType,\n          i = 0,\n          dataTypes = dataTypeExpression.toLowerCase().match(rnothtmlwhite) || [];\n\n      if (isFunction(func)) {\n        // For each dataType in the dataTypeExpression\n        while (dataType = dataTypes[i++]) {\n          // Prepend if requested\n          if (dataType[0] === \"+\") {\n            dataType = dataType.slice(1) || \"*\";\n            (structure[dataType] = structure[dataType] || []).unshift(func); // Otherwise append\n          } else {\n            (structure[dataType] = structure[dataType] || []).push(func);\n          }\n        }\n      }\n    };\n  } // Base inspection function for prefilters and transports\n\n\n  function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {\n    var inspected = {},\n        seekingTransport = structure === transports;\n\n    function inspect(dataType) {\n      var selected;\n      inspected[dataType] = true;\n      jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {\n        var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);\n\n        if (typeof dataTypeOrTransport === \"string\" && !seekingTransport && !inspected[dataTypeOrTransport]) {\n          options.dataTypes.unshift(dataTypeOrTransport);\n          inspect(dataTypeOrTransport);\n          return false;\n        } else if (seekingTransport) {\n          return !(selected = dataTypeOrTransport);\n        }\n      });\n      return selected;\n    }\n\n    return inspect(options.dataTypes[0]) || !inspected[\"*\"] && inspect(\"*\");\n  } // A special extend for ajax options\n  // that takes \"flat\" options (not to be deep extended)\n  // Fixes #9887\n\n\n  function ajaxExtend(target, src) {\n    var key,\n        deep,\n        flatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n    for (key in src) {\n      if (src[key] !== undefined) {\n        (flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];\n      }\n    }\n\n    if (deep) {\n      jQuery.extend(true, target, deep);\n    }\n\n    return target;\n  }\n  /* Handles responses to an ajax request:\n   * - finds the right dataType (mediates between content-type and expected dataType)\n   * - returns the corresponding response\n   */\n\n\n  function ajaxHandleResponses(s, jqXHR, responses) {\n    var ct,\n        type,\n        finalDataType,\n        firstDataType,\n        contents = s.contents,\n        dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process\n\n    while (dataTypes[0] === \"*\") {\n      dataTypes.shift();\n\n      if (ct === undefined) {\n        ct = s.mimeType || jqXHR.getResponseHeader(\"Content-Type\");\n      }\n    } // Check if we're dealing with a known content-type\n\n\n    if (ct) {\n      for (type in contents) {\n        if (contents[type] && contents[type].test(ct)) {\n          dataTypes.unshift(type);\n          break;\n        }\n      }\n    } // Check to see if we have a response for the expected dataType\n\n\n    if (dataTypes[0] in responses) {\n      finalDataType = dataTypes[0];\n    } else {\n      // Try convertible dataTypes\n      for (type in responses) {\n        if (!dataTypes[0] || s.converters[type + \" \" + dataTypes[0]]) {\n          finalDataType = type;\n          break;\n        }\n\n        if (!firstDataType) {\n          firstDataType = type;\n        }\n      } // Or just use first one\n\n\n      finalDataType = finalDataType || firstDataType;\n    } // If we found a dataType\n    // We add the dataType to the list if needed\n    // and return the corresponding response\n\n\n    if (finalDataType) {\n      if (finalDataType !== dataTypes[0]) {\n        dataTypes.unshift(finalDataType);\n      }\n\n      return responses[finalDataType];\n    }\n  }\n  /* Chain conversions given the request and the original response\n   * Also sets the responseXXX fields on the jqXHR instance\n   */\n\n\n  function ajaxConvert(s, response, jqXHR, isSuccess) {\n    var conv2,\n        current,\n        conv,\n        tmp,\n        prev,\n        converters = {},\n        // Work with a copy of dataTypes in case we need to modify it for conversion\n    dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys\n\n    if (dataTypes[1]) {\n      for (conv in s.converters) {\n        converters[conv.toLowerCase()] = s.converters[conv];\n      }\n    }\n\n    current = dataTypes.shift(); // Convert to each sequential dataType\n\n    while (current) {\n      if (s.responseFields[current]) {\n        jqXHR[s.responseFields[current]] = response;\n      } // Apply the dataFilter if provided\n\n\n      if (!prev && isSuccess && s.dataFilter) {\n        response = s.dataFilter(response, s.dataType);\n      }\n\n      prev = current;\n      current = dataTypes.shift();\n\n      if (current) {\n        // There's only work to do if current dataType is non-auto\n        if (current === \"*\") {\n          current = prev; // Convert response if prev dataType is non-auto and differs from current\n        } else if (prev !== \"*\" && prev !== current) {\n          // Seek a direct converter\n          conv = converters[prev + \" \" + current] || converters[\"* \" + current]; // If none found, seek a pair\n\n          if (!conv) {\n            for (conv2 in converters) {\n              // If conv2 outputs current\n              tmp = conv2.split(\" \");\n\n              if (tmp[1] === current) {\n                // If prev can be converted to accepted input\n                conv = converters[prev + \" \" + tmp[0]] || converters[\"* \" + tmp[0]];\n\n                if (conv) {\n                  // Condense equivalence converters\n                  if (conv === true) {\n                    conv = converters[conv2]; // Otherwise, insert the intermediate dataType\n                  } else if (converters[conv2] !== true) {\n                    current = tmp[0];\n                    dataTypes.unshift(tmp[1]);\n                  }\n\n                  break;\n                }\n              }\n            }\n          } // Apply converter (if not an equivalence)\n\n\n          if (conv !== true) {\n            // Unless errors are allowed to bubble, catch and return them\n            if (conv && s.throws) {\n              response = conv(response);\n            } else {\n              try {\n                response = conv(response);\n              } catch (e) {\n                return {\n                  state: \"parsererror\",\n                  error: conv ? e : \"No conversion from \" + prev + \" to \" + current\n                };\n              }\n            }\n          }\n        }\n      }\n    }\n\n    return {\n      state: \"success\",\n      data: response\n    };\n  }\n\n  jQuery.extend({\n    // Counter for holding the number of active queries\n    active: 0,\n    // Last-Modified header cache for next request\n    lastModified: {},\n    etag: {},\n    ajaxSettings: {\n      url: location.href,\n      type: \"GET\",\n      isLocal: rlocalProtocol.test(location.protocol),\n      global: true,\n      processData: true,\n      async: true,\n      contentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\n      /*\n      timeout: 0,\n      data: null,\n      dataType: null,\n      username: null,\n      password: null,\n      cache: null,\n      throws: false,\n      traditional: false,\n      headers: {},\n      */\n      accepts: {\n        \"*\": allTypes,\n        text: \"text/plain\",\n        html: \"text/html\",\n        xml: \"application/xml, text/xml\",\n        json: \"application/json, text/javascript\"\n      },\n      contents: {\n        xml: /\\bxml\\b/,\n        html: /\\bhtml/,\n        json: /\\bjson\\b/\n      },\n      responseFields: {\n        xml: \"responseXML\",\n        text: \"responseText\",\n        json: \"responseJSON\"\n      },\n      // Data converters\n      // Keys separate source (or catchall \"*\") and destination types with a single space\n      converters: {\n        // Convert anything to text\n        \"* text\": String,\n        // Text to html (true = no transformation)\n        \"text html\": true,\n        // Evaluate text as a json expression\n        \"text json\": JSON.parse,\n        // Parse text as xml\n        \"text xml\": jQuery.parseXML\n      },\n      // For options that shouldn't be deep extended:\n      // you can add your own custom options here if\n      // and when you create one that shouldn't be\n      // deep extended (see ajaxExtend)\n      flatOptions: {\n        url: true,\n        context: true\n      }\n    },\n    // Creates a full fledged settings object into target\n    // with both ajaxSettings and settings fields.\n    // If target is omitted, writes into ajaxSettings.\n    ajaxSetup: function ajaxSetup(target, settings) {\n      return settings ? // Building a settings object\n      ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : // Extending ajaxSettings\n      ajaxExtend(jQuery.ajaxSettings, target);\n    },\n    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),\n    ajaxTransport: addToPrefiltersOrTransports(transports),\n    // Main method\n    ajax: function ajax(url, options) {\n      // If url is an object, simulate pre-1.5 signature\n      if (_typeof(url) === \"object\") {\n        options = url;\n        url = undefined;\n      } // Force options to be an object\n\n\n      options = options || {};\n\n      var transport,\n          // URL without anti-cache param\n      cacheURL,\n          // Response headers\n      responseHeadersString,\n          responseHeaders,\n          // timeout handle\n      timeoutTimer,\n          // Url cleanup var\n      urlAnchor,\n          // Request state (becomes false upon send and true upon completion)\n      completed,\n          // To know if global events are to be dispatched\n      fireGlobals,\n          // Loop variable\n      i,\n          // uncached part of the url\n      uncached,\n          // Create the final options object\n      s = jQuery.ajaxSetup({}, options),\n          // Callbacks context\n      callbackContext = s.context || s,\n          // Context for global events is callbackContext if it is a DOM node or jQuery collection\n      globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event,\n          // Deferreds\n      deferred = jQuery.Deferred(),\n          completeDeferred = jQuery.Callbacks(\"once memory\"),\n          // Status-dependent callbacks\n      _statusCode = s.statusCode || {},\n          // Headers (they are sent all at once)\n      requestHeaders = {},\n          requestHeadersNames = {},\n          // Default abort message\n      strAbort = \"canceled\",\n          // Fake xhr\n      jqXHR = {\n        readyState: 0,\n        // Builds headers hashtable if needed\n        getResponseHeader: function getResponseHeader(key) {\n          var match;\n\n          if (completed) {\n            if (!responseHeaders) {\n              responseHeaders = {};\n\n              while (match = rheaders.exec(responseHeadersString)) {\n                responseHeaders[match[1].toLowerCase() + \" \"] = (responseHeaders[match[1].toLowerCase() + \" \"] || []).concat(match[2]);\n              }\n            }\n\n            match = responseHeaders[key.toLowerCase() + \" \"];\n          }\n\n          return match == null ? null : match.join(\", \");\n        },\n        // Raw string\n        getAllResponseHeaders: function getAllResponseHeaders() {\n          return completed ? responseHeadersString : null;\n        },\n        // Caches the header\n        setRequestHeader: function setRequestHeader(name, value) {\n          if (completed == null) {\n            name = requestHeadersNames[name.toLowerCase()] = requestHeadersNames[name.toLowerCase()] || name;\n            requestHeaders[name] = value;\n          }\n\n          return this;\n        },\n        // Overrides response content-type header\n        overrideMimeType: function overrideMimeType(type) {\n          if (completed == null) {\n            s.mimeType = type;\n          }\n\n          return this;\n        },\n        // Status-dependent callbacks\n        statusCode: function statusCode(map) {\n          var code;\n\n          if (map) {\n            if (completed) {\n              // Execute the appropriate callbacks\n              jqXHR.always(map[jqXHR.status]);\n            } else {\n              // Lazy-add the new callbacks in a way that preserves old ones\n              for (code in map) {\n                _statusCode[code] = [_statusCode[code], map[code]];\n              }\n            }\n          }\n\n          return this;\n        },\n        // Cancel the request\n        abort: function abort(statusText) {\n          var finalText = statusText || strAbort;\n\n          if (transport) {\n            transport.abort(finalText);\n          }\n\n          done(0, finalText);\n          return this;\n        }\n      }; // Attach deferreds\n\n\n      deferred.promise(jqXHR); // Add protocol if not provided (prefilters might expect it)\n      // Handle falsy url in the settings object (#10093: consistency with old signature)\n      // We also use the url parameter if available\n\n      s.url = ((url || s.url || location.href) + \"\").replace(rprotocol, location.protocol + \"//\"); // Alias method option to type as per ticket #12004\n\n      s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list\n\n      s.dataTypes = (s.dataType || \"*\").toLowerCase().match(rnothtmlwhite) || [\"\"]; // A cross-domain request is in order when the origin doesn't match the current origin.\n\n      if (s.crossDomain == null) {\n        urlAnchor = document.createElement(\"a\"); // Support: IE <=8 - 11, Edge 12 - 15\n        // IE throws exception on accessing the href property if url is malformed,\n        // e.g. http://example.com:80x/\n\n        try {\n          urlAnchor.href = s.url; // Support: IE <=8 - 11 only\n          // Anchor's host property isn't correctly set when s.url is relative\n\n          urlAnchor.href = urlAnchor.href;\n          s.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !== urlAnchor.protocol + \"//\" + urlAnchor.host;\n        } catch (e) {\n          // If there is an error parsing the URL, assume it is crossDomain,\n          // it can be rejected by the transport if it is invalid\n          s.crossDomain = true;\n        }\n      } // Convert data if not already a string\n\n\n      if (s.data && s.processData && typeof s.data !== \"string\") {\n        s.data = jQuery.param(s.data, s.traditional);\n      } // Apply prefilters\n\n\n      inspectPrefiltersOrTransports(prefilters, s, options, jqXHR); // If request was aborted inside a prefilter, stop there\n\n      if (completed) {\n        return jqXHR;\n      } // We can fire global events as of now if asked to\n      // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\n\n      fireGlobals = jQuery.event && s.global; // Watch for a new set of requests\n\n      if (fireGlobals && jQuery.active++ === 0) {\n        jQuery.event.trigger(\"ajaxStart\");\n      } // Uppercase the type\n\n\n      s.type = s.type.toUpperCase(); // Determine if request has content\n\n      s.hasContent = !rnoContent.test(s.type); // Save the URL in case we're toying with the If-Modified-Since\n      // and/or If-None-Match header later on\n      // Remove hash to simplify url manipulation\n\n      cacheURL = s.url.replace(rhash, \"\"); // More options handling for requests with no content\n\n      if (!s.hasContent) {\n        // Remember the hash so we can put it back\n        uncached = s.url.slice(cacheURL.length); // If data is available and should be processed, append data to url\n\n        if (s.data && (s.processData || typeof s.data === \"string\")) {\n          cacheURL += (rquery.test(cacheURL) ? \"&\" : \"?\") + s.data; // #9682: remove data so that it's not used in an eventual retry\n\n          delete s.data;\n        } // Add or update anti-cache param if needed\n\n\n        if (s.cache === false) {\n          cacheURL = cacheURL.replace(rantiCache, \"$1\");\n          uncached = (rquery.test(cacheURL) ? \"&\" : \"?\") + \"_=\" + nonce.guid++ + uncached;\n        } // Put hash and anti-cache on the URL that will be requested (gh-1732)\n\n\n        s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658)\n      } else if (s.data && s.processData && (s.contentType || \"\").indexOf(\"application/x-www-form-urlencoded\") === 0) {\n        s.data = s.data.replace(r20, \"+\");\n      } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\n\n      if (s.ifModified) {\n        if (jQuery.lastModified[cacheURL]) {\n          jqXHR.setRequestHeader(\"If-Modified-Since\", jQuery.lastModified[cacheURL]);\n        }\n\n        if (jQuery.etag[cacheURL]) {\n          jqXHR.setRequestHeader(\"If-None-Match\", jQuery.etag[cacheURL]);\n        }\n      } // Set the correct header, if data is being sent\n\n\n      if (s.data && s.hasContent && s.contentType !== false || options.contentType) {\n        jqXHR.setRequestHeader(\"Content-Type\", s.contentType);\n      } // Set the Accepts header for the server, depending on the dataType\n\n\n      jqXHR.setRequestHeader(\"Accept\", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\") : s.accepts[\"*\"]); // Check for headers option\n\n      for (i in s.headers) {\n        jqXHR.setRequestHeader(i, s.headers[i]);\n      } // Allow custom headers/mimetypes and early abort\n\n\n      if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || completed)) {\n        // Abort if not done already and return\n        return jqXHR.abort();\n      } // Aborting is no longer a cancellation\n\n\n      strAbort = \"abort\"; // Install callbacks on deferreds\n\n      completeDeferred.add(s.complete);\n      jqXHR.done(s.success);\n      jqXHR.fail(s.error); // Get transport\n\n      transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR); // If no transport, we auto-abort\n\n      if (!transport) {\n        done(-1, \"No Transport\");\n      } else {\n        jqXHR.readyState = 1; // Send global event\n\n        if (fireGlobals) {\n          globalEventContext.trigger(\"ajaxSend\", [jqXHR, s]);\n        } // If request was aborted inside ajaxSend, stop there\n\n\n        if (completed) {\n          return jqXHR;\n        } // Timeout\n\n\n        if (s.async && s.timeout > 0) {\n          timeoutTimer = window.setTimeout(function () {\n            jqXHR.abort(\"timeout\");\n          }, s.timeout);\n        }\n\n        try {\n          completed = false;\n          transport.send(requestHeaders, done);\n        } catch (e) {\n          // Rethrow post-completion exceptions\n          if (completed) {\n            throw e;\n          } // Propagate others as results\n\n\n          done(-1, e);\n        }\n      } // Callback for when everything is done\n\n\n      function done(status, nativeStatusText, responses, headers) {\n        var isSuccess,\n            success,\n            error,\n            response,\n            modified,\n            statusText = nativeStatusText; // Ignore repeat invocations\n\n        if (completed) {\n          return;\n        }\n\n        completed = true; // Clear timeout if it exists\n\n        if (timeoutTimer) {\n          window.clearTimeout(timeoutTimer);\n        } // Dereference transport for early garbage collection\n        // (no matter how long the jqXHR object will be used)\n\n\n        transport = undefined; // Cache response headers\n\n        responseHeadersString = headers || \"\"; // Set readyState\n\n        jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful\n\n        isSuccess = status >= 200 && status < 300 || status === 304; // Get response data\n\n        if (responses) {\n          response = ajaxHandleResponses(s, jqXHR, responses);\n        } // Use a noop converter for missing script but not if jsonp\n\n\n        if (!isSuccess && jQuery.inArray(\"script\", s.dataTypes) > -1 && jQuery.inArray(\"json\", s.dataTypes) < 0) {\n          s.converters[\"text script\"] = function () {};\n        } // Convert no matter what (that way responseXXX fields are always set)\n\n\n        response = ajaxConvert(s, response, jqXHR, isSuccess); // If successful, handle type chaining\n\n        if (isSuccess) {\n          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n          if (s.ifModified) {\n            modified = jqXHR.getResponseHeader(\"Last-Modified\");\n\n            if (modified) {\n              jQuery.lastModified[cacheURL] = modified;\n            }\n\n            modified = jqXHR.getResponseHeader(\"etag\");\n\n            if (modified) {\n              jQuery.etag[cacheURL] = modified;\n            }\n          } // if no content\n\n\n          if (status === 204 || s.type === \"HEAD\") {\n            statusText = \"nocontent\"; // if not modified\n          } else if (status === 304) {\n            statusText = \"notmodified\"; // If we have data, let's convert it\n          } else {\n            statusText = response.state;\n            success = response.data;\n            error = response.error;\n            isSuccess = !error;\n          }\n        } else {\n          // Extract error from statusText and normalize for non-aborts\n          error = statusText;\n\n          if (status || !statusText) {\n            statusText = \"error\";\n\n            if (status < 0) {\n              status = 0;\n            }\n          }\n        } // Set data for the fake xhr object\n\n\n        jqXHR.status = status;\n        jqXHR.statusText = (nativeStatusText || statusText) + \"\"; // Success/Error\n\n        if (isSuccess) {\n          deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);\n        } else {\n          deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);\n        } // Status-dependent callbacks\n\n\n        jqXHR.statusCode(_statusCode);\n        _statusCode = undefined;\n\n        if (fireGlobals) {\n          globalEventContext.trigger(isSuccess ? \"ajaxSuccess\" : \"ajaxError\", [jqXHR, s, isSuccess ? success : error]);\n        } // Complete\n\n\n        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);\n\n        if (fireGlobals) {\n          globalEventContext.trigger(\"ajaxComplete\", [jqXHR, s]); // Handle the global AJAX counter\n\n          if (! --jQuery.active) {\n            jQuery.event.trigger(\"ajaxStop\");\n          }\n        }\n      }\n\n      return jqXHR;\n    },\n    getJSON: function getJSON(url, data, callback) {\n      return jQuery.get(url, data, callback, \"json\");\n    },\n    getScript: function getScript(url, callback) {\n      return jQuery.get(url, undefined, callback, \"script\");\n    }\n  });\n  jQuery.each([\"get\", \"post\"], function (_i, method) {\n    jQuery[method] = function (url, data, callback, type) {\n      // Shift arguments if data argument was omitted\n      if (isFunction(data)) {\n        type = type || callback;\n        callback = data;\n        data = undefined;\n      } // The url can be an options object (which then must have .url)\n\n\n      return jQuery.ajax(jQuery.extend({\n        url: url,\n        type: method,\n        dataType: type,\n        data: data,\n        success: callback\n      }, jQuery.isPlainObject(url) && url));\n    };\n  });\n  jQuery.ajaxPrefilter(function (s) {\n    var i;\n\n    for (i in s.headers) {\n      if (i.toLowerCase() === \"content-type\") {\n        s.contentType = s.headers[i] || \"\";\n      }\n    }\n  });\n\n  jQuery._evalUrl = function (url, options, doc) {\n    return jQuery.ajax({\n      url: url,\n      // Make this explicit, since user can override this through ajaxSetup (#11264)\n      type: \"GET\",\n      dataType: \"script\",\n      cache: true,\n      async: false,\n      global: false,\n      // Only evaluate the response if it is successful (gh-4126)\n      // dataFilter is not invoked for failure responses, so using it instead\n      // of the default converter is kludgy but it works.\n      converters: {\n        \"text script\": function textScript() {}\n      },\n      dataFilter: function dataFilter(response) {\n        jQuery.globalEval(response, options, doc);\n      }\n    });\n  };\n\n  jQuery.fn.extend({\n    wrapAll: function wrapAll(html) {\n      var wrap;\n\n      if (this[0]) {\n        if (isFunction(html)) {\n          html = html.call(this[0]);\n        } // The elements to wrap the target around\n\n\n        wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);\n\n        if (this[0].parentNode) {\n          wrap.insertBefore(this[0]);\n        }\n\n        wrap.map(function () {\n          var elem = this;\n\n          while (elem.firstElementChild) {\n            elem = elem.firstElementChild;\n          }\n\n          return elem;\n        }).append(this);\n      }\n\n      return this;\n    },\n    wrapInner: function wrapInner(html) {\n      if (isFunction(html)) {\n        return this.each(function (i) {\n          jQuery(this).wrapInner(html.call(this, i));\n        });\n      }\n\n      return this.each(function () {\n        var self = jQuery(this),\n            contents = self.contents();\n\n        if (contents.length) {\n          contents.wrapAll(html);\n        } else {\n          self.append(html);\n        }\n      });\n    },\n    wrap: function wrap(html) {\n      var htmlIsFunction = isFunction(html);\n      return this.each(function (i) {\n        jQuery(this).wrapAll(htmlIsFunction ? html.call(this, i) : html);\n      });\n    },\n    unwrap: function unwrap(selector) {\n      this.parent(selector).not(\"body\").each(function () {\n        jQuery(this).replaceWith(this.childNodes);\n      });\n      return this;\n    }\n  });\n\n  jQuery.expr.pseudos.hidden = function (elem) {\n    return !jQuery.expr.pseudos.visible(elem);\n  };\n\n  jQuery.expr.pseudos.visible = function (elem) {\n    return !!(elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length);\n  };\n\n  jQuery.ajaxSettings.xhr = function () {\n    try {\n      return new window.XMLHttpRequest();\n    } catch (e) {}\n  };\n\n  var xhrSuccessStatus = {\n    // File protocol always yields status code 0, assume 200\n    0: 200,\n    // Support: IE <=9 only\n    // #1450: sometimes IE returns 1223 when it should be 204\n    1223: 204\n  },\n      xhrSupported = jQuery.ajaxSettings.xhr();\n  support.cors = !!xhrSupported && \"withCredentials\" in xhrSupported;\n  support.ajax = xhrSupported = !!xhrSupported;\n  jQuery.ajaxTransport(function (options) {\n    var _callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest\n\n\n    if (support.cors || xhrSupported && !options.crossDomain) {\n      return {\n        send: function send(headers, complete) {\n          var i,\n              xhr = options.xhr();\n          xhr.open(options.type, options.url, options.async, options.username, options.password); // Apply custom fields if provided\n\n          if (options.xhrFields) {\n            for (i in options.xhrFields) {\n              xhr[i] = options.xhrFields[i];\n            }\n          } // Override mime type if needed\n\n\n          if (options.mimeType && xhr.overrideMimeType) {\n            xhr.overrideMimeType(options.mimeType);\n          } // X-Requested-With header\n          // For cross-domain requests, seeing as conditions for a preflight are\n          // akin to a jigsaw puzzle, we simply never set it to be sure.\n          // (it can always be set on a per-request basis or even using ajaxSetup)\n          // For same-domain requests, won't change header if already provided.\n\n\n          if (!options.crossDomain && !headers[\"X-Requested-With\"]) {\n            headers[\"X-Requested-With\"] = \"XMLHttpRequest\";\n          } // Set headers\n\n\n          for (i in headers) {\n            xhr.setRequestHeader(i, headers[i]);\n          } // Callback\n\n\n          _callback = function callback(type) {\n            return function () {\n              if (_callback) {\n                _callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null;\n\n                if (type === \"abort\") {\n                  xhr.abort();\n                } else if (type === \"error\") {\n                  // Support: IE <=9 only\n                  // On a manual native abort, IE9 throws\n                  // errors on any property access that is not readyState\n                  if (typeof xhr.status !== \"number\") {\n                    complete(0, \"error\");\n                  } else {\n                    complete( // File: protocol always yields status 0; see #8605, #14207\n                    xhr.status, xhr.statusText);\n                  }\n                } else {\n                  complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, // Support: IE <=9 only\n                  // IE9 has no XHR2 but throws on binary (trac-11426)\n                  // For XHR2 non-text, let the caller handle it (gh-2498)\n                  (xhr.responseType || \"text\") !== \"text\" || typeof xhr.responseText !== \"string\" ? {\n                    binary: xhr.response\n                  } : {\n                    text: xhr.responseText\n                  }, xhr.getAllResponseHeaders());\n                }\n              }\n            };\n          }; // Listen to events\n\n\n          xhr.onload = _callback();\n          errorCallback = xhr.onerror = xhr.ontimeout = _callback(\"error\"); // Support: IE 9 only\n          // Use onreadystatechange to replace onabort\n          // to handle uncaught aborts\n\n          if (xhr.onabort !== undefined) {\n            xhr.onabort = errorCallback;\n          } else {\n            xhr.onreadystatechange = function () {\n              // Check readyState before timeout as it changes\n              if (xhr.readyState === 4) {\n                // Allow onerror to be called first,\n                // but that will not handle a native abort\n                // Also, save errorCallback to a variable\n                // as xhr.onerror cannot be accessed\n                window.setTimeout(function () {\n                  if (_callback) {\n                    errorCallback();\n                  }\n                });\n              }\n            };\n          } // Create the abort callback\n\n\n          _callback = _callback(\"abort\");\n\n          try {\n            // Do send the request (this may raise an exception)\n            xhr.send(options.hasContent && options.data || null);\n          } catch (e) {\n            // #14683: Only rethrow if this hasn't been notified as an error yet\n            if (_callback) {\n              throw e;\n            }\n          }\n        },\n        abort: function abort() {\n          if (_callback) {\n            _callback();\n          }\n        }\n      };\n    }\n  }); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)\n\n  jQuery.ajaxPrefilter(function (s) {\n    if (s.crossDomain) {\n      s.contents.script = false;\n    }\n  }); // Install script dataType\n\n  jQuery.ajaxSetup({\n    accepts: {\n      script: \"text/javascript, application/javascript, \" + \"application/ecmascript, application/x-ecmascript\"\n    },\n    contents: {\n      script: /\\b(?:java|ecma)script\\b/\n    },\n    converters: {\n      \"text script\": function textScript(text) {\n        jQuery.globalEval(text);\n        return text;\n      }\n    }\n  }); // Handle cache's special case and crossDomain\n\n  jQuery.ajaxPrefilter(\"script\", function (s) {\n    if (s.cache === undefined) {\n      s.cache = false;\n    }\n\n    if (s.crossDomain) {\n      s.type = \"GET\";\n    }\n  }); // Bind script tag hack transport\n\n  jQuery.ajaxTransport(\"script\", function (s) {\n    // This transport only deals with cross domain or forced-by-attrs requests\n    if (s.crossDomain || s.scriptAttrs) {\n      var script, _callback2;\n\n      return {\n        send: function send(_, complete) {\n          script = jQuery(\"<script>\").attr(s.scriptAttrs || {}).prop({\n            charset: s.scriptCharset,\n            src: s.url\n          }).on(\"load error\", _callback2 = function callback(evt) {\n            script.remove();\n            _callback2 = null;\n\n            if (evt) {\n              complete(evt.type === \"error\" ? 404 : 200, evt.type);\n            }\n          }); // Use native DOM manipulation to avoid our domManip AJAX trickery\n\n          document.head.appendChild(script[0]);\n        },\n        abort: function abort() {\n          if (_callback2) {\n            _callback2();\n          }\n        }\n      };\n    }\n  });\n  var oldCallbacks = [],\n      rjsonp = /(=)\\?(?=&|$)|\\?\\?/; // Default jsonp settings\n\n  jQuery.ajaxSetup({\n    jsonp: \"callback\",\n    jsonpCallback: function jsonpCallback() {\n      var callback = oldCallbacks.pop() || jQuery.expando + \"_\" + nonce.guid++;\n      this[callback] = true;\n      return callback;\n    }\n  }); // Detect, normalize options and install callbacks for jsonp requests\n\n  jQuery.ajaxPrefilter(\"json jsonp\", function (s, originalSettings, jqXHR) {\n    var callbackName,\n        overwritten,\n        responseContainer,\n        jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? \"url\" : typeof s.data === \"string\" && (s.contentType || \"\").indexOf(\"application/x-www-form-urlencoded\") === 0 && rjsonp.test(s.data) && \"data\"); // Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\n    if (jsonProp || s.dataTypes[0] === \"jsonp\") {\n      // Get callback name, remembering preexisting value associated with it\n      callbackName = s.jsonpCallback = isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback; // Insert callback into url or form data\n\n      if (jsonProp) {\n        s[jsonProp] = s[jsonProp].replace(rjsonp, \"$1\" + callbackName);\n      } else if (s.jsonp !== false) {\n        s.url += (rquery.test(s.url) ? \"&\" : \"?\") + s.jsonp + \"=\" + callbackName;\n      } // Use data converter to retrieve json after script execution\n\n\n      s.converters[\"script json\"] = function () {\n        if (!responseContainer) {\n          jQuery.error(callbackName + \" was not called\");\n        }\n\n        return responseContainer[0];\n      }; // Force json dataType\n\n\n      s.dataTypes[0] = \"json\"; // Install callback\n\n      overwritten = window[callbackName];\n\n      window[callbackName] = function () {\n        responseContainer = arguments;\n      }; // Clean-up function (fires after converters)\n\n\n      jqXHR.always(function () {\n        // If previous value didn't exist - remove it\n        if (overwritten === undefined) {\n          jQuery(window).removeProp(callbackName); // Otherwise restore preexisting value\n        } else {\n          window[callbackName] = overwritten;\n        } // Save back as free\n\n\n        if (s[callbackName]) {\n          // Make sure that re-using the options doesn't screw things around\n          s.jsonpCallback = originalSettings.jsonpCallback; // Save the callback name for future use\n\n          oldCallbacks.push(callbackName);\n        } // Call if it was a function and we have a response\n\n\n        if (responseContainer && isFunction(overwritten)) {\n          overwritten(responseContainer[0]);\n        }\n\n        responseContainer = overwritten = undefined;\n      }); // Delegate to script\n\n      return \"script\";\n    }\n  }); // Support: Safari 8 only\n  // In Safari 8 documents created via document.implementation.createHTMLDocument\n  // collapse sibling forms: the second one becomes a child of the first one.\n  // Because of that, this security measure has to be disabled in Safari 8.\n  // https://bugs.webkit.org/show_bug.cgi?id=137337\n\n  support.createHTMLDocument = function () {\n    var body = document.implementation.createHTMLDocument(\"\").body;\n    body.innerHTML = \"<form></form><form></form>\";\n    return body.childNodes.length === 2;\n  }(); // Argument \"data\" should be string of html\n  // context (optional): If specified, the fragment will be created in this context,\n  // defaults to document\n  // keepScripts (optional): If true, will include scripts passed in the html string\n\n\n  jQuery.parseHTML = function (data, context, keepScripts) {\n    if (typeof data !== \"string\") {\n      return [];\n    }\n\n    if (typeof context === \"boolean\") {\n      keepScripts = context;\n      context = false;\n    }\n\n    var base, parsed, scripts;\n\n    if (!context) {\n      // Stop scripts or inline event handlers from being executed immediately\n      // by using document.implementation\n      if (support.createHTMLDocument) {\n        context = document.implementation.createHTMLDocument(\"\"); // Set the base href for the created document\n        // so any parsed elements with URLs\n        // are based on the document's URL (gh-2965)\n\n        base = context.createElement(\"base\");\n        base.href = document.location.href;\n        context.head.appendChild(base);\n      } else {\n        context = document;\n      }\n    }\n\n    parsed = rsingleTag.exec(data);\n    scripts = !keepScripts && []; // Single tag\n\n    if (parsed) {\n      return [context.createElement(parsed[1])];\n    }\n\n    parsed = buildFragment([data], context, scripts);\n\n    if (scripts && scripts.length) {\n      jQuery(scripts).remove();\n    }\n\n    return jQuery.merge([], parsed.childNodes);\n  };\n  /**\n   * Load a url into a page\n   */\n\n\n  jQuery.fn.load = function (url, params, callback) {\n    var selector,\n        type,\n        response,\n        self = this,\n        off = url.indexOf(\" \");\n\n    if (off > -1) {\n      selector = stripAndCollapse(url.slice(off));\n      url = url.slice(0, off);\n    } // If it's a function\n\n\n    if (isFunction(params)) {\n      // We assume that it's the callback\n      callback = params;\n      params = undefined; // Otherwise, build a param string\n    } else if (params && _typeof(params) === \"object\") {\n      type = \"POST\";\n    } // If we have elements to modify, make the request\n\n\n    if (self.length > 0) {\n      jQuery.ajax({\n        url: url,\n        // If \"type\" variable is undefined, then \"GET\" method will be used.\n        // Make value of this field explicit since\n        // user can override it through ajaxSetup method\n        type: type || \"GET\",\n        dataType: \"html\",\n        data: params\n      }).done(function (responseText) {\n        // Save response for use in complete callback\n        response = arguments;\n        self.html(selector ? // If a selector was specified, locate the right elements in a dummy div\n        // Exclude scripts to avoid IE 'Permission Denied' errors\n        jQuery(\"<div>\").append(jQuery.parseHTML(responseText)).find(selector) : // Otherwise use the full result\n        responseText); // If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n        // but they are ignored because response was set above.\n        // If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n      }).always(callback && function (jqXHR, status) {\n        self.each(function () {\n          callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);\n        });\n      });\n    }\n\n    return this;\n  };\n\n  jQuery.expr.pseudos.animated = function (elem) {\n    return jQuery.grep(jQuery.timers, function (fn) {\n      return elem === fn.elem;\n    }).length;\n  };\n\n  jQuery.offset = {\n    setOffset: function setOffset(elem, options, i) {\n      var curPosition,\n          curLeft,\n          curCSSTop,\n          curTop,\n          curOffset,\n          curCSSLeft,\n          calculatePosition,\n          position = jQuery.css(elem, \"position\"),\n          curElem = jQuery(elem),\n          props = {}; // Set position first, in-case top/left are set even on static elem\n\n      if (position === \"static\") {\n        elem.style.position = \"relative\";\n      }\n\n      curOffset = curElem.offset();\n      curCSSTop = jQuery.css(elem, \"top\");\n      curCSSLeft = jQuery.css(elem, \"left\");\n      calculatePosition = (position === \"absolute\" || position === \"fixed\") && (curCSSTop + curCSSLeft).indexOf(\"auto\") > -1; // Need to be able to calculate position if either\n      // top or left is auto and position is either absolute or fixed\n\n      if (calculatePosition) {\n        curPosition = curElem.position();\n        curTop = curPosition.top;\n        curLeft = curPosition.left;\n      } else {\n        curTop = parseFloat(curCSSTop) || 0;\n        curLeft = parseFloat(curCSSLeft) || 0;\n      }\n\n      if (isFunction(options)) {\n        // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n        options = options.call(elem, i, jQuery.extend({}, curOffset));\n      }\n\n      if (options.top != null) {\n        props.top = options.top - curOffset.top + curTop;\n      }\n\n      if (options.left != null) {\n        props.left = options.left - curOffset.left + curLeft;\n      }\n\n      if (\"using\" in options) {\n        options.using.call(elem, props);\n      } else {\n        curElem.css(props);\n      }\n    }\n  };\n  jQuery.fn.extend({\n    // offset() relates an element's border box to the document origin\n    offset: function offset(options) {\n      // Preserve chaining for setter\n      if (arguments.length) {\n        return options === undefined ? this : this.each(function (i) {\n          jQuery.offset.setOffset(this, options, i);\n        });\n      }\n\n      var rect,\n          win,\n          elem = this[0];\n\n      if (!elem) {\n        return;\n      } // Return zeros for disconnected and hidden (display: none) elements (gh-2310)\n      // Support: IE <=11 only\n      // Running getBoundingClientRect on a\n      // disconnected node in IE throws an error\n\n\n      if (!elem.getClientRects().length) {\n        return {\n          top: 0,\n          left: 0\n        };\n      } // Get document-relative position by adding viewport scroll to viewport-relative gBCR\n\n\n      rect = elem.getBoundingClientRect();\n      win = elem.ownerDocument.defaultView;\n      return {\n        top: rect.top + win.pageYOffset,\n        left: rect.left + win.pageXOffset\n      };\n    },\n    // position() relates an element's margin box to its offset parent's padding box\n    // This corresponds to the behavior of CSS absolute positioning\n    position: function position() {\n      if (!this[0]) {\n        return;\n      }\n\n      var offsetParent,\n          offset,\n          doc,\n          elem = this[0],\n          parentOffset = {\n        top: 0,\n        left: 0\n      }; // position:fixed elements are offset from the viewport, which itself always has zero offset\n\n      if (jQuery.css(elem, \"position\") === \"fixed\") {\n        // Assume position:fixed implies availability of getBoundingClientRect\n        offset = elem.getBoundingClientRect();\n      } else {\n        offset = this.offset(); // Account for the *real* offset parent, which can be the document or its root element\n        // when a statically positioned element is identified\n\n        doc = elem.ownerDocument;\n        offsetParent = elem.offsetParent || doc.documentElement;\n\n        while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && jQuery.css(offsetParent, \"position\") === \"static\") {\n          offsetParent = offsetParent.parentNode;\n        }\n\n        if (offsetParent && offsetParent !== elem && offsetParent.nodeType === 1) {\n          // Incorporate borders into its offset, since they are outside its content origin\n          parentOffset = jQuery(offsetParent).offset();\n          parentOffset.top += jQuery.css(offsetParent, \"borderTopWidth\", true);\n          parentOffset.left += jQuery.css(offsetParent, \"borderLeftWidth\", true);\n        }\n      } // Subtract parent offsets and element margins\n\n\n      return {\n        top: offset.top - parentOffset.top - jQuery.css(elem, \"marginTop\", true),\n        left: offset.left - parentOffset.left - jQuery.css(elem, \"marginLeft\", true)\n      };\n    },\n    // This method will return documentElement in the following cases:\n    // 1) For the element inside the iframe without offsetParent, this method will return\n    //    documentElement of the parent window\n    // 2) For the hidden or detached element\n    // 3) For body or html element, i.e. in case of the html node - it will return itself\n    //\n    // but those exceptions were never presented as a real life use-cases\n    // and might be considered as more preferable results.\n    //\n    // This logic, however, is not guaranteed and can change at any point in the future\n    offsetParent: function offsetParent() {\n      return this.map(function () {\n        var offsetParent = this.offsetParent;\n\n        while (offsetParent && jQuery.css(offsetParent, \"position\") === \"static\") {\n          offsetParent = offsetParent.offsetParent;\n        }\n\n        return offsetParent || documentElement;\n      });\n    }\n  }); // Create scrollLeft and scrollTop methods\n\n  jQuery.each({\n    scrollLeft: \"pageXOffset\",\n    scrollTop: \"pageYOffset\"\n  }, function (method, prop) {\n    var top = \"pageYOffset\" === prop;\n\n    jQuery.fn[method] = function (val) {\n      return access(this, function (elem, method, val) {\n        // Coalesce documents and windows\n        var win;\n\n        if (isWindow(elem)) {\n          win = elem;\n        } else if (elem.nodeType === 9) {\n          win = elem.defaultView;\n        }\n\n        if (val === undefined) {\n          return win ? win[prop] : elem[method];\n        }\n\n        if (win) {\n          win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);\n        } else {\n          elem[method] = val;\n        }\n      }, method, val, arguments.length);\n    };\n  }); // Support: Safari <=7 - 9.1, Chrome <=37 - 49\n  // Add the top/left cssHooks using jQuery.fn.position\n  // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n  // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347\n  // getComputedStyle returns percent when specified for top/left/bottom/right;\n  // rather than make the css module depend on the offset module, just check for it here\n\n  jQuery.each([\"top\", \"left\"], function (_i, prop) {\n    jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {\n      if (computed) {\n        computed = curCSS(elem, prop); // If curCSS returns percentage, fallback to offset\n\n        return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + \"px\" : computed;\n      }\n    });\n  }); // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\n\n  jQuery.each({\n    Height: \"height\",\n    Width: \"width\"\n  }, function (name, type) {\n    jQuery.each({\n      padding: \"inner\" + name,\n      content: type,\n      \"\": \"outer\" + name\n    }, function (defaultExtra, funcName) {\n      // Margin is only for outerHeight, outerWidth\n      jQuery.fn[funcName] = function (margin, value) {\n        var chainable = arguments.length && (defaultExtra || typeof margin !== \"boolean\"),\n            extra = defaultExtra || (margin === true || value === true ? \"margin\" : \"border\");\n        return access(this, function (elem, type, value) {\n          var doc;\n\n          if (isWindow(elem)) {\n            // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)\n            return funcName.indexOf(\"outer\") === 0 ? elem[\"inner\" + name] : elem.document.documentElement[\"client\" + name];\n          } // Get document width or height\n\n\n          if (elem.nodeType === 9) {\n            doc = elem.documentElement; // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n            // whichever is greatest\n\n            return Math.max(elem.body[\"scroll\" + name], doc[\"scroll\" + name], elem.body[\"offset\" + name], doc[\"offset\" + name], doc[\"client\" + name]);\n          }\n\n          return value === undefined ? // Get width or height on the element, requesting but not forcing parseFloat\n          jQuery.css(elem, type, extra) : // Set width or height on the element\n          jQuery.style(elem, type, value, extra);\n        }, type, chainable ? margin : undefined, chainable);\n      };\n    });\n  });\n  jQuery.each([\"ajaxStart\", \"ajaxStop\", \"ajaxComplete\", \"ajaxError\", \"ajaxSuccess\", \"ajaxSend\"], function (_i, type) {\n    jQuery.fn[type] = function (fn) {\n      return this.on(type, fn);\n    };\n  });\n  jQuery.fn.extend({\n    bind: function bind(types, data, fn) {\n      return this.on(types, null, data, fn);\n    },\n    unbind: function unbind(types, fn) {\n      return this.off(types, null, fn);\n    },\n    delegate: function delegate(selector, types, data, fn) {\n      return this.on(types, selector, data, fn);\n    },\n    undelegate: function undelegate(selector, types, fn) {\n      // ( namespace ) or ( selector, types [, fn] )\n      return arguments.length === 1 ? this.off(selector, \"**\") : this.off(types, selector || \"**\", fn);\n    },\n    hover: function hover(fnOver, fnOut) {\n      return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);\n    }\n  });\n  jQuery.each((\"blur focus focusin focusout resize scroll click dblclick \" + \"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" + \"change select submit keydown keypress keyup contextmenu\").split(\" \"), function (_i, name) {\n    // Handle event binding\n    jQuery.fn[name] = function (data, fn) {\n      return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);\n    };\n  }); // Support: Android <=4.0 only\n  // Make sure we trim BOM and NBSP\n\n  var rtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g; // Bind a function to a context, optionally partially applying any\n  // arguments.\n  // jQuery.proxy is deprecated to promote standards (specifically Function#bind)\n  // However, it is not slated for removal any time soon\n\n  jQuery.proxy = function (fn, context) {\n    var tmp, args, proxy;\n\n    if (typeof context === \"string\") {\n      tmp = fn[context];\n      context = fn;\n      fn = tmp;\n    } // Quick check to determine if target is callable, in the spec\n    // this throws a TypeError, but we will just return undefined.\n\n\n    if (!isFunction(fn)) {\n      return undefined;\n    } // Simulated bind\n\n\n    args = _slice.call(arguments, 2);\n\n    proxy = function proxy() {\n      return fn.apply(context || this, args.concat(_slice.call(arguments)));\n    }; // Set the guid of unique handler to the same of original handler, so it can be removed\n\n\n    proxy.guid = fn.guid = fn.guid || jQuery.guid++;\n    return proxy;\n  };\n\n  jQuery.holdReady = function (hold) {\n    if (hold) {\n      jQuery.readyWait++;\n    } else {\n      jQuery.ready(true);\n    }\n  };\n\n  jQuery.isArray = Array.isArray;\n  jQuery.parseJSON = JSON.parse;\n  jQuery.nodeName = nodeName;\n  jQuery.isFunction = isFunction;\n  jQuery.isWindow = isWindow;\n  jQuery.camelCase = camelCase;\n  jQuery.type = toType;\n  jQuery.now = Date.now;\n\n  jQuery.isNumeric = function (obj) {\n    // As of jQuery 3.0, isNumeric is limited to\n    // strings and numbers (primitives or objects)\n    // that can be coerced to finite numbers (gh-2662)\n    var type = jQuery.type(obj);\n    return (type === \"number\" || type === \"string\") && // parseFloat NaNs numeric-cast false positives (\"\")\n    // ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n    // subtraction forces infinities to NaN\n    !isNaN(obj - parseFloat(obj));\n  };\n\n  jQuery.trim = function (text) {\n    return text == null ? \"\" : (text + \"\").replace(rtrim, \"\");\n  }; // Register as a named AMD module, since jQuery can be concatenated with other\n  // files that may use define, but not via a proper concatenation script that\n  // understands anonymous AMD modules. A named AMD is safest and most robust\n  // way to register. Lowercase jquery is used because AMD module names are\n  // derived from file names, and jQuery is normally delivered in a lowercase\n  // file name. Do this after creating the global so that if an AMD module wants\n  // to call noConflict to hide this version of jQuery, it will work.\n  // Note that for maximum portability, libraries that are not jQuery should\n  // declare themselves as anonymous modules, and avoid setting a global if an\n  // AMD loader is present. jQuery is a special case. For more information, see\n  // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\n\n  if (typeof define === \"function\" && define.amd) {\n    define(\"jquery\", [], function () {\n      return jQuery;\n    });\n  }\n\n  var // Map over jQuery in case of overwrite\n  _jQuery = window.jQuery,\n      // Map over the $ in case of overwrite\n  _$ = window.$;\n\n  jQuery.noConflict = function (deep) {\n    if (window.$ === jQuery) {\n      window.$ = _$;\n    }\n\n    if (deep && window.jQuery === jQuery) {\n      window.jQuery = _jQuery;\n    }\n\n    return jQuery;\n  }; // Expose jQuery and $ identifiers, even in AMD\n  // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n  // and CommonJS for browser emulators (#13566)\n\n\n  if (typeof noGlobal === \"undefined\") {\n    window.jQuery = window.$ = jQuery;\n  }\n\n  return jQuery;\n});"],"sourceRoot":""}