{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/mixitup/dist/mixitup.js","webpack:///./src/js/important/mixitup-multifilter.min.js","webpack:///./config/index.js","webpack:///./src/js/components/swiper-sliders.js","webpack:///./src/js/components/tabs.js","webpack:///./src/js/components/fixed-navigation.js","webpack:///./src/js/components/table-hover.js","webpack:///./src/js/important/object-fit.js","webpack:///./src/js/components/mixitup.js","webpack:///./src/js/app.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","window","mixitup","h","ElementPrototype","hasDontEnumBug","dontEnums","dontEnumsLength","Temp","VENDORS","canary","document","createElement","length","requestAnimationFrame","nextElementSibling","Element","el","this","nextSibling","nodeType","matches","machesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","webkitMatchesSelector","selector","Array","indexOf","parentElement","querySelectorAll","keys","toString","propertyIsEnumerable","obj","result","prop","TypeError","push","isArray","arg","propertiesObject","defineProperties","__proto__","String","trim","replace","searchElement","k","len","arguments","Number","Infinity","Math","floor","abs","max","Function","oThis","aArgs","self","FNOP","fBound","slice","apply","concat","dispatchEvent","event","fireEvent","type","err","container","config","foreignDoc","returnCollection","instance","facade","doc","instances","id","elements","isElement","Error","messages","errorFactoryInvalidContainer","errorFactoryContainerNotFound","randomHex","Mixer","debug","showWarnings","console","warn","warningFactoryPreexistingInstance","attach","Facade","enable","Collection","use","extension","Base","callActions","TYPE","extensions","NAME","fn","jquery","libraries","$","hasClass","cls","className","match","RegExp","addClass","removeClass","reg","extend","destination","source","deep","handleErrors","sourceKeys","handleExtendError","erroneous","message","suggestion","probableMatch","mostMatchingChars","exec","charAt","errorConfigInvalidPropertySuggestion","errorConfigInvalidProperty","template","str","re","dynamics","data","output","on","useCapture","addEventListener","attachEvent","off","removeEventListener","detachEvent","getCustomEvent","eventType","detail","CustomEvent","bubbles","cancelable","createEvent","initCustomEvent","createEventObject","returnValue","cancelBubble","getOriginalEvent","e","touches","changedTouches","index","previousElementSibling","camelCase","toLowerCase","$1","toUpperCase","pascalCase","dashCase","HTMLElement","defaultView","nodeName","htmlString","frag","temp","createDocumentFragment","innerHTML","firstChild","appendChild","removeWhitespace","node","deleting","previousSibling","removeChild","isEqualArray","a","b","deepEquals","arrayShuffle","oldArray","newArray","random","arrayFromList","list","debounce","func","wait","immediate","timeout","later","args","callNow","clearTimeout","setTimeout","position","element","xPosition","yPosition","offsetParent","scrollLeft","scrollTop","offsetLeft","offsetTop","x","y","getHypotenuse","node1","node2","distanceX","distanceY","sqrt","pow","getIntersectionRatio","box1","box2","intersectionX","controlArea","width","height","min","left","top","closestParent","includeSelf","parent","parentNode","body","children","tempId","randomHexKey","removeAttribute","clean","originalArray","cleanArray","defer","deferred","promiseWrapper","Deferred","features","has","promises","promise","Promise","resolve","reject","jQuery","warningNoPromiseImplementation","all","tasks","when","done","getPrefix","vendors","prefix","style","substr","getDocumentState","pageYOffset","pageXOffset","docHeight","documentElement","scrollHeight","docWidth","scrollWidth","viewportHeight","clientHeight","viewportWidth","clientWidth","isVisible","styles","getComputedStyle","visibility","opacity","seal","freeze","compareVersions","control","specimen","controlParts","split","specimenParts","controlPart","specimenPart","parseInt","isEmptyObject","getClassname","classNames","elementName","modifier","classname","block","delineatorElement","delineatorModifier","getProperty","stringKey","returnCurrent","parts","current","constructor","actionName","hooks","actions","extensionName","callFilters","filterName","input","filters","unshift","BaseStatic","registerAction","hookName","registerFilter","Features","boxSizingPrefix","transformPrefix","transitionPrefix","transformProp","transformRule","transitionProp","perspectiveProp","perspectiveOriginProp","Has","BOX_SIZING_PROP","TRANSITION_PROP","TRANSFORM_PROP","PERSPECTIVE_PROP","PERSPECTIVE_ORIGIN_PROP","TWEENABLE","init","setPrefixes","runTests","transitions","boxSizingProp","ConfigAnimation","effects","effectsIn","effectsOut","duration","easing","applyPerspective","perspectiveDistance","perspectiveOrigin","queue","queueLimit","animateResizeContainer","animateResizeTargets","staggerSequence","reverseOut","nudge","clampHeight","clampWidth","ConfigBehavior","liveSort","ConfigCallbacks","onMixStart","onMixBusy","onMixEnd","onMixFail","onMixClick","ConfigControls","live","scope","toggleLogic","toggleDefault","ConfigClassNames","elementContainer","elementFilter","elementSort","elementMultimix","elementToggle","modifierActive","modifierDisabled","modifierFailed","ConfigData","uidKey","dirtyCheck","ConfigDebug","fauxAsync","ConfigLayout","allowNestedTargets","containerClassName","siblingBefore","siblingAfter","ConfigLoad","filter","sort","dataset","ConfigSelectors","target","ConfigRender","ConfigTemplates","Config","animation","behavior","callbacks","controls","layout","load","selectors","render","templates","MixerDom","targets","UiClassNames","base","active","disabled","CommandDataset","CommandMultimix","insert","remove","changeLayout","CommandFilter","collection","action","CommandSort","sortString","attribute","order","next","CommandInsert","sibling","CommandRemove","CommandChangeLayout","ControlDefinition","controlDefinitions","Control","bound","pending","status","canDisable","handler","disable","getAttribute","bindClick","isBound","mixer","addBinding","removeBinding","removeIndex","splice","unbindClick","renderStatus","handleClick","button","isActive","command","clone","commands","dom","lastClicked","events","fire","state","originalEvent","toggleOff","toggleOn","multimix","update","toggleArray","updateLive","parseStatusChange","controlButtons","alias","StyleData","right","bottom","marginRight","marginBottom","scale","TransformData","translateX","translateY","translateZ","rotateX","rotateY","rotateZ","unit","TransformDefaults","transformDefaults","EventDetail","futureState","Events","mixStart","mixBusy","mixEnd","mixFail","mixClick","eventDetail","State","QueueItem","instruction","triggerElement","isToggling","isBusy","incPadding","origOrder","cache","targetsMoved","targetsImmovable","targetsBound","targetsDone","staggerDuration","transformIn","transformOut","lastOperation","userCallback","userDeferred","sanitizeConfig","cacheDom","indexTargets","getInitialState","toHide","hide","initControls","buildToggleArray","updateControls","activeFilter","activeSort","parseEffects","operation","Operation","activeContainerClassName","errorConfigDataUidKeyNotSet","startDataset","newDataset","activeDataset","startContainerClassName","newContainerClassName","show","parseFilterArgs","parseSortArgs","totalTargets","newSort","sortOperation","printSort","newOrder","startOrder","startFilter","newFilter","startSort","filterOperation","buildState","querySelector","errorDatasetPrerenderedMismatch","Target","isInDom","definition","controlElements","delagators","j","errorConfigInvalidControlsScope","getControl","getToggleSelector","delineator","toggleSelector","join","activeFilterSelector","splitCompoundSelector","compoundSelector","partials","shift","buildSortString","insertTargets","insertionIndex","getNextSibling","errorInsertPreexistingElement","display","createTextNode","insertBefore","testResult","evaluateHideShow","toRemove","toShow","matching","hasFailed","filteredTestResult","isShown","errorSortNonExistentElement","reverse","compare","willSort","attrA","getAttributeValue","attrB","isNaN","warningInconsistentSortingAttributes","isResetting","whitespace","lastChild","childNodes","parseSortString","rules","rule","transformName","parseEffect","effectName","effectString","transform","isOut","propIndex","val","units","errorConfigInvalidAnimationEffects","substring","parseFloat","totalShow","totalHide","totalMatching","goMix","shouldAnimate","willChangeLayout","startState","newState","docState","scrollTo","startHeight","newHeight","viewportDeltaY","startWidth","newWidth","viewportDeltaX","overflow","moveTargets","cleanUp","getStartMixData","parentStyle","parentRect","getBoundingClientRect","boxSizing","getPosData","showPosData","startPosData","toHidePosData","startX","startY","paddingTop","paddingBottom","borderTop","borderBottom","paddingLeft","paddingRight","borderLeft","borderRight","setInter","getInterMixData","interPosData","setFinal","getFinalMixData","finalPosData","newX","newY","getTweenData","posData","effectNames","getOwnPropertyNames","effect","widthChange","heightChange","posIn","posOut","tweenData","moveData","statusChange","willTransition","staggerIndex","checkProgress","IMoveData","hasEffect","callback","move","ContainerClassName","EFFECTABLES","marginTop","whitespaceBefore","whitespaceAfter","nextInQueue","parseMultimixArgs","UserInstruction","animate","parseInsertArgs","parseRemoveArgs","parseChangeLayoutArgs","errorFilterInvalidArguments","errorInsertInvalidArguments","warningInsertNoElements","warningRemoveNoElements","parseDatasetArgs","queueMix","queueItem","warningMultimixInstanceQueueFull","getDataOperation","errorDatasetNotSet","diffDatasets","persistantStartIds","persistantNewIds","insertedTargets","nextEl","uids","errorDatasetInvalidUidKey","errorDatasetDuplicateUid","uid","unbindEvents","replaceChild","bindEvents","lastElementChild","insertDatasetFrag","insertAt","sortCommandA","sortCommandB","isMixing","selectorIndex","getOperation","multimixCommand","sortCommand","filterCommand","changeLayoutCommand","removeCommand","insertCommand","warningGetOperationInstanceBusy","tween","multiplier","toHideIndex","applyTween","insertAfter","prepend","append","getConfig","configure","getState","forceRefresh","forceRender","destroy","TargetDom","isExcluded","errorDatasetRendererNotSet","firstElementChild","getSortString","attributeName","applyStylesIn","applyStylesOut","propertyName","currentTransformValues","currentValues","isFading","transformValues","transitionRules","isResizing","writeTransitionRule","applyTransition","delay","getDelay","transitionString","handleTransitionEnd","propName","canResize","eventBus","transitionEndEvent","getBox","rect","methodName","toMove","startDisplay","newDisplay","Messages","ERROR_FACTORY_INVALID_CONTAINER","ERROR_FACTORY_CONTAINER_NOT_FOUND","ERROR_CONFIG_INVALID_ANIMATION_EFFECTS","ERROR_CONFIG_INVALID_CONTROLS_SCOPE","ERROR_CONFIG_INVALID_PROPERTY","ERROR_CONFIG_INVALID_PROPERTY_SUGGESTION","ERROR_CONFIG_DATA_UID_KEY_NOT_SET","ERROR_DATASET_INVALID_UID_KEY","ERROR_DATASET_DUPLICATE_UID","ERROR_INSERT_INVALID_ARGUMENTS","ERROR_INSERT_PREEXISTING_ELEMENT","ERROR_FILTER_INVALID_ARGUMENTS","ERROR_DATASET_NOT_SET","ERROR_DATASET_PRERENDERED_MISMATCH","ERROR_DATASET_RENDERER_NOT_SET","ERROR_SORT_NON_EXISTENT_ELEMENT","WARNING_FACTORY_PREEXISTING_INSTANCE","WARNING_INSERT_NO_ELEMENTS","WARNING_REMOVE_NO_ELEMENTS","WARNING_MULTIMIX_INSTANCE_QUEUE_FULL","WARNING_GET_OPERATION_INSTANCE_BUSY","WARNING_NO_PROMISE_IMPLEMENTATION","WARNING_INCONSISTENT_SORTING_ATTRIBUTES","compileTemplates","errorKey","errorMessage","CORE_VERSION","u","REQUIRE_CORE_VERSION","EXTENSION_VERSION","onParseFilterGroups","ConfigMultifilter","logicWithinGroup","logicBetweenGroups","minSearchLength","parseOn","keyupThrottleDuration","multifilter","MultifilterFormEventTracker","form","totalBound","totalHandled","FilterGroupDom","FilterGroup","activeSelectors","activeFilters","activeToggles","logic","keyupTimeout","enableButtons","handleFormEvent","E","stopPropagation","parseFilterGroups","handleChange","getSingleValue","getMultipleValues","handleKeyup","preventDefault","multifilterFormEventTracker","filterGroups","checked","selected","Boolean","updateControl","updateUi","tagName","filterGroupsHash","indexFilterGroups","parseParseFilterGroupsArgs","getFilterGroupPaths","buildSelectorFromPaths","setFilterGroupSelectors","getFilterGroupSelectors","define","proxyUrl","port","Swiper","loop","slidesPerView","spaceBetween","navigation","prevEl","breakpoints","btn","getElementsByClassName","content","classList","add","activeTab","currentTarget","tab","activeContent","activeBtn","tabs","navigationHeight","offsetHeight","navigationOffset","scroll","mediaQuery","matchMedia","clickHandler","navItemsWithSubmenu","navItemWithSubmenu","navItemWithSubmenuHeight","navItemSubmenu","sectionField","enterField","innerWidth","mouseFollow","mouseHoverSrc","clientX","clientY","imageSrc","attr","documentMode","test","navigator","userAgent","each","bgSize","css","containerEl","mixitupMultifilter","filterSelectZero","filterSelectOne","courseFilter","toggle","nav","mobileMenu","overlay","getElementsByTagName","src","YtOverlay"],"mappings":";aACE,IAAIA,EAAmB,CAAC,EAGxB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,CAAC,GAUX,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,OACf,CAIAF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,GAEhE,EAGAZ,EAAoBkB,EAAI,SAAShB,GACX,oBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,GACvD,EAOArB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,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,EAAM,EAAEC,KAAK,KAAMD,IAC9I,OAAOF,CACR,EAGAzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,OAAG,EAClD,WAA8B,OAAOA,CAAQ,EAE9C,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,CACR,EAGAZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,EAAW,EAGpH/B,EAAoBkC,EAAI,GAIjBlC,EAAoBA,EAAoBmC,EAAI,E,oBClErD,SAAUC,GACN,aAEA,IAAIC,EAAU,KACVC,EAAU,MAEd,WACI,IAgCUC,EAmBEC,EACAC,EACAC,EAHAT,EAgEAU,EAlHRC,EAAU,CAAC,SAAU,MAAO,IAAK,MACjCC,EAAUT,EAAOU,SAASC,cAAc,OACxC3C,GAAW,EAIf,IAAKA,EAAI,EAAGA,EAAIwC,EAAQI,SAAWZ,EAAOa,sBAAuB7C,IAC7DgC,EAAOa,sBAAwBb,EAAOQ,EAAQxC,GAAK,8BAKd,IAA9ByC,EAAOK,oBACdpC,OAAOC,eAAeqB,EAAOe,QAAQnB,UAAW,qBAAsB,CAClEf,IAAK,WAGD,IAFA,IAAImC,EAAKC,KAAKC,YAEPF,GAAI,CACP,GAAoB,IAAhBA,EAAGG,SACH,OAAOH,EAGXA,EAAKA,EAAGE,WACZ,CAEA,OAAO,IACX,KAMEf,EAWPH,EAAOe,QAAQnB,WAVGwB,QACbjB,EAAiBiB,SACjBjB,EAAiBkB,gBACjBlB,EAAiBmB,oBACjBnB,EAAiBoB,mBACjBpB,EAAiBqB,kBACjBrB,EAAiBsB,uBACjB,SAAUC,GACN,OAAOC,MAAM/B,UAAUgC,QAAQzD,KAAK8C,KAAKY,cAAcC,iBAAiBJ,GAAWT,OAAS,CAChG,EAMHvC,OAAOqD,OACRrD,OAAOqD,MACClC,EAAsBnB,OAAOkB,UAAUC,eAK3CO,GAAkB,CACd4B,SAAU,MAETC,qBAAqB,YAY1B3B,GAVAD,EAAY,CACR,WACA,iBACA,UACA,iBACA,gBACA,uBACA,gBAGwBO,OAErB,SAASsB,GACZ,IAAIC,EAAU,GACVC,EAAU,GACVpE,GAAW,EAEf,GAAmB,iBAARkE,IAAoC,mBAARA,GAA8B,OAARA,GACzD,MAAM,IAAIG,UAAU,oCAGxB,IAAKD,KAAQF,EACLrC,EAAe1B,KAAK+D,EAAKE,IACzBD,EAAOG,KAAKF,GAIpB,GAAIhC,EACA,IAAKpC,EAAI,EAAGA,EAAIsC,EAAiBtC,IACzB6B,EAAe1B,KAAK+D,EAAK7B,EAAUrC,KACnCmE,EAAOG,KAAKjC,EAAUrC,IAKlC,OAAOmE,CACX,IAOHR,MAAMY,UACPZ,MAAMY,QAAU,SAASC,GACrB,MAA+C,mBAAxC9D,OAAOkB,UAAUoC,SAAS7D,KAAKqE,EAC1C,GAMyB,mBAAlB9D,OAAOY,SACdZ,OAAOY,QACCiB,EAAO,WAAY,EAEhB,SAAUX,EAAW6C,GACxB,GAAI7C,IAAclB,OAAOkB,IAA4B,OAAdA,EACnC,MAAMyC,UAAU,uCAGpB9B,EAAKX,UAAYA,GAAa,CAAC,EAE/B,IAAIuC,EAAS,IAAI5B,EAcjB,OAZAA,EAAKX,UAAY,UAZT,IAcJ6C,GACA/D,OAAOgE,iBAAiBP,EAAQM,GAGlB,OAAd7C,IAEAuC,EAAOQ,UAAY,MAIhBR,CACX,IAMHS,OAAOhD,UAAUiD,OAClBD,OAAOhD,UAAUiD,KAAO,WACpB,OAAO5B,KAAK6B,QAAQ,qCAAsC,GAC9D,GAMCnB,MAAM/B,UAAUgC,UACjBD,MAAM/B,UAAUgC,QAAU,SAASmB,GAC/B,IAAItD,EAAGuD,EAAG9D,EAAG+D,EAEb,GAAa,OAAThC,KACA,MAAM,IAAIoB,UAOd,GAAY,KAFZY,GAFA/D,EAAIR,OAAOuC,OAEHL,SAAW,GAGf,OAAQ,EAeZ,GAZAnB,EAAI,EAEAyD,UAAUtC,OAAS,KACnBnB,EAAI0D,OAAOD,UAAU,MAEXzD,EACNA,EAAI,EACS,IAANA,GAAWA,IAAM2D,KAAY3D,KAAO2D,MAC3C3D,GAAKA,EAAI,IAAM,GAAK4D,KAAKC,MAAMD,KAAKE,IAAI9D,MAI5CA,GAAKwD,EACL,OAAQ,EAGZ,IAAKD,EAAIvD,GAAK,EAAIA,EAAI4D,KAAKG,IAAIP,EAAMI,KAAKE,IAAI9D,GAAI,GAAIuD,EAAIC,EAAKD,IAC3D,GAAIA,KAAK9D,GAAKA,EAAE8D,KAAOD,EACnB,OAAOC,EAIf,OAAQ,CACZ,GAMCS,SAAS7D,UAAUJ,OACpBiE,SAAS7D,UAAUJ,KAAO,SAASkE,GAC/B,IAAIC,EAAOC,EAAMC,EAAMC,EAEvB,GAAoB,mBAAT7C,KACP,MAAM,IAAIoB,UAmBd,OAhBAsB,EAAQhC,MAAM/B,UAAUmE,MAAM5F,KAAK+E,UAAW,GAE9CU,EAAO3C,KAEP4C,EAAO,WAAY,EAEnBC,EAAS,WACL,OAAOF,EAAKI,MAAM/C,gBAAgB4C,EAAO5C,KAAOyC,EAAOC,EAAMM,OAAOtC,MAAM/B,UAAUmE,MAAM5F,KAAK+E,YACnG,EAEIjC,KAAKrB,YACLiE,EAAKjE,UAAYqB,KAAKrB,WAG1BkE,EAAOlE,UAAY,IAAIiE,EAEhBC,CACX,GAKC9D,EAAOe,QAAQnB,UAAUsE,gBAC1BlE,EAAOe,QAAQnB,UAAUsE,cAAgB,SAASC,GAC9C,IACI,OAAOlD,KAAKmD,UAAU,KAAOD,EAAME,KAAMF,EAC7C,CAAE,MAAOG,GAAM,CACnB,EAEP,CA5OD,GA2RArE,EAAU,SAASsE,EAAWC,EAAQC,GAClC,IAAIzD,EAAsB,KACtB0D,GAAsB,EACtBC,EAAsB,KACtBC,EAAsB,KACtBC,EAAsB,KAEtBC,EAAsB,GACtBC,EAAsB,GACtBC,EAAsB,GACtBhH,GAAuB,EAU3B,GARA6G,EAAMJ,GAAczE,EAAOU,UAEvBgE,EAAmBxB,UAAU,MAG7BwB,EAA+C,kBAArBA,GAGL,iBAAdH,EACPS,EAAWH,EAAI/C,iBAAiByC,QAC7B,GAAIA,GAAkC,iBAAdA,GAA0BrE,EAAE+E,UAAUV,EAAWM,GAC5EG,EAAW,CAACT,OACT,KAAIA,GAAkC,iBAAdA,IAA0BA,EAAU3D,OAM/D,MAAM,IAAIsE,MAAMjF,EAAQkF,SAASC,gCAFjCJ,EAAWT,CAGf,CAEA,GAAIS,EAASpE,OAAS,EAClB,MAAM,IAAIsE,MAAMjF,EAAQkF,SAASE,iCAGrC,IAAKrH,EAAI,GAAGgD,EAAKgE,EAAShH,QAClBA,EAAI,IAAM0G,GADY1G,IAGrBgD,EAAG+D,GAKJA,EAAK/D,EAAG+D,IAJRA,EAAK,UAAY7E,EAAEoF,YAEnBtE,EAAG+D,GAAKA,GAKR9E,EAAQ6E,UAAUC,aAAe9E,EAAQsF,OACzCZ,EAAW1E,EAAQ6E,UAAUC,KAExBP,GAAWA,GAAUA,EAAOgB,QAAuC,IAA9BhB,EAAOgB,MAAMC,eACnDC,QAAQC,KAAK1F,EAAQkF,SAASS,wCAGlCjB,EAAW,IAAI1E,EAAQsF,OAEdM,OAAO7E,EAAI6D,EAAKE,EAAIP,GAE7BvE,EAAQ6E,UAAUC,GAAMJ,GAG5BC,EAAS,IAAI3E,EAAQ6F,OAAOnB,GAExBH,GAAUA,EAAOgB,OAAShB,EAAOgB,MAAMO,OACvCjB,EAAUxC,KAAKqC,GAEfG,EAAUxC,KAAKsC,GAYvB,OARIF,EACS,IAAIzE,EAAQ+F,WAAWlB,GAIvBA,EAAU,EAI3B,EAkCA7E,EAAQgG,IAAM,SAASC,GACnBjG,EAAQkG,KAAKvG,UAAUwG,YAAYjI,KAAK8B,EAAS,YAAaiD,WAKrC,mBAAdgD,GAA+C,sBAAnBA,EAAUG,UAGK,IAAvCpG,EAAQqG,WAAWJ,EAAUK,QACpCL,EAAUjG,GAEVA,EAAQqG,WAAWJ,EAAUK,MAAQL,GAElCA,EAAUM,IAAMN,EAAUM,GAAGC,SAGpCxG,EAAQyG,UAAUC,EAAIT,GAG1BjG,EAAQkG,KAAKvG,UAAUwG,YAAYjI,KAAK8B,EAAS,WAAYiD,UACjE,EAEAjD,EAAQ6E,UAAc,CAAC,EACvB7E,EAAQqG,WAAc,CAAC,EACvBrG,EAAQyG,UAAc,CAAC,EAMvBxG,EAAI,CASA0G,SAAU,SAAS5F,EAAI6F,GACnB,QAAS7F,EAAG8F,UAAUC,MAAM,IAAIC,OAAO,UAAYH,EAAM,WAC7D,EASAI,SAAU,SAASjG,EAAI6F,GACd5F,KAAK2F,SAAS5F,EAAI6F,KAAM7F,EAAG8F,WAAa9F,EAAG8F,UAAY,IAAMD,EAAMA,EAC5E,EASAK,YAAa,SAASlG,EAAI6F,GACtB,GAAI5F,KAAK2F,SAAS5F,EAAI6F,GAAM,CACxB,IAAIM,EAAM,IAAIH,OAAO,UAAYH,EAAM,WAEvC7F,EAAG8F,UAAY9F,EAAG8F,UAAUhE,QAAQqE,EAAK,KAAKtE,MAClD,CACJ,EAcAuE,OAAQ,SAASC,EAAaC,EAAQC,EAAMC,GACxC,IAAIC,EAAc,GACdlI,EAAc,GACdvB,GAAe,EAEnBuJ,EAAOA,IAAQ,EACfC,EAAeA,IAAgB,EAE/B,IACI,GAAI7F,MAAMY,QAAQ+E,GACd,IAAKtJ,EAAI,EAAGA,EAAIsJ,EAAO1G,OAAQ5C,IAC3ByJ,EAAWnF,KAAKtE,QAEbsJ,IACPG,EAAa/I,OAAOqD,KAAKuF,IAG7B,IAAKtJ,EAAI,EAAGA,EAAIyJ,EAAW7G,OAAQ5C,IAC/BuB,EAAMkI,EAAWzJ,IAEZuJ,GAA+B,iBAAhBD,EAAO/H,IAAqB0B,KAAKgE,UAAUqC,EAAO/H,IAGlE8H,EAAY9H,GAAO+H,EAAO/H,GACnBoC,MAAMY,QAAQ+E,EAAO/H,KAGvB8H,EAAY9H,KACb8H,EAAY9H,GAAO,IAGvB0B,KAAKmG,OAAOC,EAAY9H,GAAM+H,EAAO/H,GAAMgI,EAAMC,KAI5CH,EAAY9H,KACb8H,EAAY9H,GAAO,CAAC,GAGxB0B,KAAKmG,OAAOC,EAAY9H,GAAM+H,EAAO/H,GAAMgI,EAAMC,GAG7D,CAAE,MAAMlD,GACJ,IAAIkD,EAGA,MAAMlD,EAFNrD,KAAKyG,kBAAkBpD,EAAK+C,EAIpC,CAEA,OAAOA,CACX,EASAK,kBAAmB,SAASpD,EAAK+C,GAC7B,IACIjG,EAAsB,KACtBuG,EAAsB,GACtBC,EAAsB,GACtBC,EAAsB,GACtBC,EAAsB,GACtBvI,EAAsB,GACtBwI,GAAuB,EACvB/J,GAAuB,EAE3B,GAAIsG,aAAejC,YAAcjB,EAVP,iCAUoB4G,KAAK1D,EAAIsD,UAAW,CAG9D,IAAKrI,KAFLoI,EAAYvG,EAAQ,GAERiG,EAAa,CAGrB,IAFArJ,EAAI,EAEGA,EAAI2J,EAAU/G,QAAU+G,EAAUM,OAAOjK,KAAOuB,EAAI0I,OAAOjK,IAC9DA,IAGAA,EAAI+J,IACJA,EAAoB/J,EACpB8J,EAAgBvI,EAExB,CAaA,MAXIwI,EAAoB,IACpBF,EAAa5H,EAAQkF,SAAS+C,qCAAqC,CAC/DJ,cAAeA,KAIvBF,EAAU3H,EAAQkF,SAASgD,2BAA2B,CAClDR,UAAWA,EACXE,WAAYA,IAGV,IAAIxF,UAAUuF,EACxB,CAEA,MAAMtD,CACV,EAQA8D,SAAU,SAASC,GAKf,IAJA,IAAIC,EAAc,eACdC,EAAc,CAAC,EACfnH,EAAc,KAEVA,EAAUkH,EAAGN,KAAKK,IACtBE,EAASnH,EAAQ,IAAM,IAAI4F,OAAO,OAAS5F,EAAQ,GAAK,IAAK,KAGjE,OAAO,SAASoH,GACZ,IAAIjJ,EAAU,GACVkJ,EAAUJ,EAId,IAAK9I,KAFLiJ,EAAOA,GAAQ,CAAC,EAEJD,EACRE,EAASA,EAAO3F,QAAQyF,EAAShJ,QAA2B,IAAdiJ,EAAKjJ,GAAuBiJ,EAAKjJ,GAAO,IAG1F,OAAOkJ,CACX,CACJ,EAWAC,GAAI,SAAS1H,EAAIqD,EAAMmC,EAAImC,GAClB3H,IAEDA,EAAG4H,iBACH5H,EAAG4H,iBAAiBvE,EAAMmC,EAAImC,GACvB3H,EAAG6H,cACV7H,EAAG,IAAMqD,EAAOmC,GAAMA,EAEtBxF,EAAGqD,EAAOmC,GAAM,WACZxF,EAAG,IAAMqD,EAAOmC,GAAIxG,EAAOmE,MAC/B,EAEAnD,EAAG6H,YAAY,KAAOxE,EAAMrD,EAAGqD,EAAOmC,KAE9C,EAUAsC,IAAK,SAAS9H,EAAIqD,EAAMmC,GACfxF,IAEDA,EAAG+H,oBACH/H,EAAG+H,oBAAoB1E,EAAMmC,GAAI,GAC1BxF,EAAGgI,cACVhI,EAAGgI,YAAY,KAAO3E,EAAMrD,EAAGqD,EAAOmC,IACtCxF,EAAGqD,EAAOmC,GAAM,MAExB,EAUAyC,eAAgB,SAASC,EAAWC,EAAQtE,GACxC,IAAIV,EAAQ,KAsBZ,OApBAU,EAAMA,GAAO7E,EAAOU,SAEc,mBAAvBV,EAAOoJ,YACdjF,EAAQ,IAAInE,EAAOoJ,YAAYF,EAAW,CACtCC,OAAQA,EACRE,SAAS,EACTC,YAAY,IAEkB,mBAApBzE,EAAI0E,aAClBpF,EAAQU,EAAI0E,YAAY,gBAClBC,gBAAgBN,GAAW,GAAM,EAAMC,KAE7ChF,EAAQU,EAAI4E,qBACNpF,KAAO6E,EAEb/E,EAAMuF,aAAc,EACpBvF,EAAMwF,cAAe,EACrBxF,EAAMgF,OAASA,GAGZhF,CACX,EAQAyF,iBAAkB,SAASC,GACvB,OAAIA,EAAEC,SAAWD,EAAEC,QAAQlJ,OAChBiJ,EAAEC,QAAQ,GACVD,EAAEE,gBAAkBF,EAAEE,eAAenJ,OACrCiJ,EAAEE,eAAe,GAEjBF,CAEf,EASAG,MAAO,SAAShJ,EAAIU,GAGhB,IAFA,IAAI1D,EAAI,EAEoC,QAApCgD,EAAKA,EAAGiJ,yBACPvI,IAAYV,EAAGI,QAAQM,MACtB1D,EAIV,OAAOA,CACX,EAWAkM,UAAW,SAAS7B,GAChB,OAAOA,EAAI8B,cAAcrH,QAAQ,gBAAgB,SAASsH,GACtD,OAAOA,EAAGC,cAAcvH,QAAQ,OAAQ,GAC5C,GACJ,EAWAwH,WAAY,SAASjC,GACjB,OAAQA,EAAMpH,KAAKiJ,UAAU7B,IAAMJ,OAAO,GAAGoC,cAAgBhC,EAAItE,MAAM,EAC3E,EAUAwG,SAAU,SAASlC,GACf,OAAOA,EAAIvF,QAAQ,WAAY,OAAOA,QAAQ,KAAM,IAAIqH,aAC5D,EASAlF,UAAW,SAASjE,EAAI6D,GAGpB,OAFAA,EAAMA,GAAO7E,EAAOU,YAGhBV,EAAOwK,aACPxJ,aAAchB,EAAOwK,kBAIrB3F,EAAI4F,aACJ5F,EAAI4F,YAAYD,aAChBxJ,aAAc6D,EAAI4F,YAAYD,cAKnB,OAAPxJ,GACgB,IAAhBA,EAAGG,UACoB,iBAAhBH,EAAG0J,SAGtB,EASA/J,cAAe,SAASgK,EAAY9F,GAChC,IAAI+F,EAAO,KACPC,EAAO,KASX,IALAD,GAFA/F,EAAMA,GAAO7E,EAAOU,UAEToK,0BACXD,EAAOhG,EAAIlE,cAAc,QAEpBoK,UAAYJ,EAAW9H,OAErBgI,EAAKG,YACRJ,EAAKK,YAAYJ,EAAKG,YAG1B,OAAOJ,CACX,EAQAM,iBAAkB,SAASC,GAGvB,IAFA,IAAIC,EAEGD,GAA0B,UAAlBA,EAAKT,UAChBU,EAAWD,EAEXA,EAAOA,EAAKE,gBAEZD,EAASvJ,eAAiBuJ,EAASvJ,cAAcyJ,YAAYF,EAErE,EASAG,aAAc,SAASC,EAAGC,GACtB,IAAIzN,EAAIwN,EAAE5K,OAEV,GAAI5C,IAAMyN,EAAE7K,OAAQ,OAAO,EAE3B,KAAO5C,KACH,GAAIwN,EAAExN,KAAOyN,EAAEzN,GAAI,OAAO,EAG9B,OAAO,CACX,EASA0N,WAAY,SAASF,EAAGC,GACpB,IAAIlM,EAEJ,GAAiB,iBAANiM,GAAkBA,GAAkB,iBAANC,GAAkBA,EAAG,CAC1D,GAAI/M,OAAOqD,KAAKyJ,GAAG5K,SAAWlC,OAAOqD,KAAK0J,GAAG7K,OAAQ,OAAO,EAE5D,IAAKrB,KAAOiM,EACR,IAAKC,EAAE5L,eAAeN,KAAS0B,KAAKyK,WAAWF,EAAEjM,GAAMkM,EAAElM,IAAO,OAAO,CAE/E,MAAO,GAAIiM,IAAMC,EACb,OAAO,EAGX,OAAO,CACX,EAQAE,aAAc,SAASC,GAOnB,IANA,IAAIC,EAAcD,EAAS7H,QACvBd,EAAc4I,EAASjL,OACvB5C,EAAciF,EACdnD,GAAe,EACfZ,EAAc,GAEXlB,KACH8B,KAAOuD,KAAKyI,SAAW7I,GACvB/D,EAAI2M,EAAS7N,GAEb6N,EAAS7N,GAAK6N,EAAS/L,GACvB+L,EAAS/L,GAAKZ,EAGlB,OAAO2M,CACX,EAOAE,cAAe,SAASC,GACpB,IAAIvD,EAAQzK,EAEZ,IACI,OAAO2D,MAAM/B,UAAUmE,MAAM5F,KAAK6N,EACtC,CAAE,MAAM1H,GAGJ,IAFAmE,EAAS,GAEJzK,EAAI,EAAGA,EAAIgO,EAAKpL,OAAQ5C,IACzByK,EAAOnG,KAAK0J,EAAKhO,IAGrB,OAAOyK,CACX,CACJ,EAUAwD,SAAU,SAASC,EAAMC,EAAMC,GAC3B,IAAIC,EAEJ,OAAO,WACH,IAGIC,EAHA1I,EAAW3C,KACXsL,EAAWrJ,UACXsJ,EAAWJ,IAAcC,EAG7BC,EAAQ,WACJD,EAAW,KAEND,GACDF,EAAKlI,MAAMJ,EAAM2I,EAEzB,EAEAE,aAAaJ,GAEbA,EAAUK,WAAWJ,EAAOH,GAExBK,GAASN,EAAKlI,MAAMJ,EAAM2I,EAClC,CACJ,EAQAI,SAAU,SAASC,GAKf,IAJA,IAAIC,EAAkB,EAClBC,EAAkB,EAClBC,EAAkBH,EAEfA,GACHC,GAAaD,EAAQI,WACrBF,GAAaF,EAAQK,UAEjBL,IAAYG,IACZF,GAAaD,EAAQM,WACrBJ,GAAaF,EAAQO,UAErBJ,EAAeH,EAAQG,cAG3BH,EAAUA,EAAQ/K,cAGtB,MAAO,CACHuL,EAAGP,EACHQ,EAAGP,EAEX,EASAQ,cAAe,SAASC,EAAOC,GAC3B,IAAIC,EAAYF,EAAMH,EAAII,EAAMJ,EAC5BM,EAAYH,EAAMF,EAAIG,EAAMH,EAKhC,OAHAI,EAAYA,EAAY,GAAiB,EAAbA,EAAiBA,EAC7CC,EAAYA,EAAY,GAAiB,EAAbA,EAAiBA,EAEtCrK,KAAKsK,KAAKtK,KAAKuK,IAAIH,EAAW,GAAKpK,KAAKuK,IAAIF,EAAW,GAClE,EAYAG,qBAAsB,SAASC,EAAMC,GACjC,IACIC,EADAC,EAAsBH,EAAKI,MAAQJ,EAAKK,OAgB5C,OAVAH,EACI3K,KAAKG,IAAI,EAAGH,KAAK+K,IAAIN,EAAKO,KAAOP,EAAKI,MAAOH,EAAKM,KAAON,EAAKG,OAAS7K,KAAKG,IAAIsK,EAAKO,KAAMN,EAAKM,OAGhGhL,KAAKG,IAAI,EAAGH,KAAK+K,IAAIN,EAAKQ,IAAMR,EAAKK,OAAQJ,EAAKO,IAAMP,EAAKI,QAAU9K,KAAKG,IAAIsK,EAAKQ,IAAKP,EAAKO,MAEhEN,EAERC,CAG/B,EAWAM,cAAe,SAASvN,EAAIU,EAAU8M,EAAa3J,GAC/C,IAAI4J,EAAUzN,EAAG0N,WAIjB,GAFA7J,EAAMA,GAAO7E,EAAOU,SAEhB8N,GAAexN,EAAGI,QAAQM,GAC1B,OAAOV,EAGX,KAAOyN,GAAUA,GAAU5J,EAAI8J,MAAM,CACjC,GAAIF,EAAOrN,SAAWqN,EAAOrN,QAAQM,GACjC,OAAO+M,EACJ,IAAIA,EAAOC,WAGd,OAAO,KAFPD,EAASA,EAAOC,UAIxB,CAEA,OAAO,IACX,EAUAE,SAAU,SAAS5N,EAAIU,EAAUmD,GAC7B,IAAI+J,EAAc,GACdC,EAAc,GAkBlB,OAhBAhK,EAAMA,GAAO7E,EAAO6E,IAEhB7D,IACKA,EAAG+D,KACJ8J,EAAS,OAAS5N,KAAK6N,eAEvB9N,EAAG+D,GAAK8J,GAGZD,EAAW/J,EAAI/C,iBAAiB,IAAMd,EAAG+D,GAAK,MAAQrD,GAElDmN,GACA7N,EAAG+N,gBAAgB,OAIpBH,CACX,EAUAI,MAAO,SAASC,GACZ,IAAIC,EAAa,GACblR,GAAK,EAET,IAAKA,EAAI,EAAGA,EAAIiR,EAAcrO,OAAQ5C,IACT,KAArBiR,EAAcjR,IACdkR,EAAW5M,KAAK2M,EAAcjR,IAItC,OAAOkR,CACX,EAUAC,MAAO,SAASzI,GACZ,IAAI0I,EAAiB,KACjBC,EAAiB,KACjB1I,EAAiB,KAyBrB,OAvBA0I,EAAiB,IAAIpO,KAAKqO,SAEtBrP,EAAQsP,SAASC,IAAIC,SAGrBJ,EAAeK,QAAU,IAAIC,SAAQ,SAASC,EAASC,GACnDR,EAAeO,QAAUA,EACzBP,EAAeQ,OAAUA,CAC7B,KACQlJ,EAAK3G,EAAO8P,QAAUpJ,EAAUC,IAA6B,mBAAfA,EAAE2I,UAGxDF,EAAWzI,EAAE2I,WAEbD,EAAeK,QAAUN,EAASM,UAClCL,EAAeO,QAAUR,EAASQ,QAClCP,EAAeQ,OAAUT,EAASS,QAC3B7P,EAAO0F,SAGdA,QAAQC,KAAK1F,EAAQkF,SAAS4K,kCAG3BV,CACX,EASAW,IAAK,SAASC,EAAOvJ,GACjB,IAAIC,EAAI,KAER,OAAI1G,EAAQsP,SAASC,IAAIC,SACdE,QAAQK,IAAIC,IACXtJ,EAAK3G,EAAO8P,QAAUpJ,EAAUC,IAAyB,mBAAXA,EAAEuJ,KACjDvJ,EAAEuJ,KAAKlM,MAAM2C,EAAGsJ,GAClBE,MAAK,WAGF,OAAOjN,SACX,KAKJlD,EAAO0F,SACPA,QAAQC,KAAK1F,EAAQkF,SAAS4K,kCAG3B,GACX,EAUAK,UAAW,SAASpP,EAAIrB,EAAU0Q,GAC9B,IAAIrS,GAAW,EACXsS,EAAU,GAEd,GAAIpQ,EAAEqK,SAAS5K,KAAaqB,EAAGuP,MAAO,MAAO,GAE7C,IAAKvS,EAAI,EAAGsS,EAASD,EAAQrS,GAAIA,IAC7B,GAAIsS,EAAS3Q,KAAYqB,EAAGuP,MACxB,OAAOD,EAAOnG,cAItB,MAAO,aACX,EAOA7E,UAAW,WACP,OAAQ,SAA2B,SAAhBjC,KAAKyI,UAAuB,GAAG9J,SAAS,KAAKwO,QAAQ,GAAGnG,aAC/E,EAQAoG,iBAAkB,SAAS5L,GAGvB,OAFAA,EAA0B,iBAAbA,EAAI8J,KAAoB9J,EAAM7E,EAAOU,SAE3C,CACHuM,UAAWjN,EAAO0Q,YAClB1D,WAAYhN,EAAO2Q,YACnBC,UAAW/L,EAAIgM,gBAAgBC,aAC/BC,SAAUlM,EAAIgM,gBAAgBG,YAC9BC,eAAgBpM,EAAIgM,gBAAgBK,aACpCC,cAAetM,EAAIgM,gBAAgBO,YAE3C,EASA5R,KAAM,SAAS0C,EAAKsE,GAChB,OAAO,WACH,OAAOA,EAAGxC,MAAM9B,EAAKgB,UACzB,CACJ,EAQAmO,UAAW,SAASrQ,GAChB,IAAIsQ,EAEJ,QAAItQ,EAAG+L,cAKiB,WAHxBuE,EAAStR,EAAOuR,iBAAiBvQ,IAGtB2L,UACe,WAAtB2E,EAAOE,YACY,MAAnBF,EAAOG,OASf,EAOAC,KAAM,SAASxP,GACgB,mBAAhBxD,OAAOgT,MACdhT,OAAOgT,KAAKxP,EAEpB,EAOAyP,OAAQ,SAASzP,GACgB,mBAAlBxD,OAAOiT,QACdjT,OAAOiT,OAAOzP,EAEtB,EASA0P,gBAAiB,SAASC,EAASC,GAC/B,IAAIC,EAAkBF,EAAQG,MAAM,KAChCC,EAAkBH,EAASE,MAAM,KACjCE,GAAmB,EACnBC,GAAmB,EACnBnU,GAAmB,EAEvB,IAAKA,EAAI,EAAGA,EAAI+T,EAAanR,OAAQ5C,IAAK,CAItC,GAHAkU,EAAkBE,SAASL,EAAa/T,GAAG8E,QAAQ,UAAW,MAC9DqP,EAAkBC,SAASH,EAAcjU,GAAG8E,QAAQ,UAAW,KAAO,IAEnDoP,EACf,OAAO,EACJ,GAAIC,EAAeD,EACtB,OAAO,CAEf,CAEA,OAAO,CACX,EAOA5C,SAAU,WACNrO,KAAKyO,QAAa,KAClBzO,KAAK2O,QAAa,KAClB3O,KAAK4O,OAAa,KAClB5O,KAAK8D,GAAa7E,EAAEoF,WACxB,EAQA+M,cAAe,SAASnQ,GACpB,IAAI3C,EAAM,GAEV,GAA2B,mBAAhBb,OAAOqD,KACd,OAAmC,IAA5BrD,OAAOqD,KAAKG,GAAKtB,OAG5B,IAAKrB,KAAO2C,EACR,GAAIA,EAAIrC,eAAeN,GACnB,OAAO,EAIf,OAAO,CACX,EASA+S,aAAc,SAASC,EAAYC,EAAaC,GAC5C,IAAIC,EAAY,GAUhB,OARAA,GAAaH,EAAWI,OAEV/R,SACV8R,GAAaH,EAAWK,mBAG5BF,GAAaH,EAAW,UAAYtR,KAAKqJ,WAAWkI,IAE/CC,GAEDC,EAAU9R,SACV8R,GAAaH,EAAWM,oBAG5BH,GAAaD,GANSC,CAS1B,EAUAI,YAAa,SAAS5Q,EAAK6Q,GACvB,IACIC,EADAC,EAAkBF,EAAUf,MAAM,KAElCkB,EAAkB,GAClBlV,EAAkB,EAEtB,IAAK+U,EACD,OAAO7Q,EAWX,IARA8Q,EAAgB,SAAS9Q,GACrB,OAAKA,EAGMA,EAAIgR,GAFJ,IAIf,EAEOlV,EAAIiV,EAAMrS,QACbsS,EAAUD,EAAMjV,GAEhBkE,EAAM8Q,EAAc9Q,GAEpBlE,IAGJ,YAAmB,IAARkE,EACAA,EAEA,IAEf,GAGJjC,EAAQC,EAAIA,EAaZD,EAAQkG,KAAO,WAAY,EAE3BlG,EAAQkG,KAAKvG,UAAY,CACrBuT,YAAalT,EAAQkG,KAcrBC,YAAa,SAASgN,EAAY7G,GAC9B,IACI8G,EADkBpS,KACKkS,YAAYG,QAAQF,GAC3CG,EAAkB,GAEtB,GAAKF,IAASnT,EAAEmS,cAAcgB,GAE9B,IAAKE,KAAiBF,EAClBA,EAAME,GAAevP,MAPH/C,KAOesL,EAEzC,EAeAiH,YAAa,SAASC,EAAYC,EAAOnH,GACrC,IACI8G,EADkBpS,KACKkS,YAAYQ,QAAQF,GAC3ChL,EAAkBiL,EAClBH,EAAkB,GAEtB,IAAKF,GAASnT,EAAEmS,cAAcgB,GAAQ,OAAO5K,EAI7C,IAAK8K,KAFLhH,EAAOA,GAAQ,GAEO8G,GAClB9G,EAAOrM,EAAE6L,cAAcQ,IAElBqH,QAAQnL,GAEbA,EAAS4K,EAAME,GAAevP,MAdZ/C,KAcwBsL,GAG9C,OAAO9D,CACX,GAeJxI,EAAQ4T,WAAa,WACjB5S,KAAKqS,QAAU,CAAC,EAChBrS,KAAK0S,QAAU,CAAC,EAchB1S,KAAKmG,OAAS,SAASlB,GACnBhG,EAAEkH,OAAOnG,KAAKrB,UAAWsG,EAC7B,EAeAjF,KAAK6S,eAAiB,SAASC,EAAUR,EAAerH,IACnDjL,KAAKqS,QAAQS,GAAY9S,KAAKqS,QAAQS,IAAa,CAAC,GAAGR,GAAiBrH,CAC7E,EAeAjL,KAAK+S,eAAiB,SAASD,EAAUR,EAAerH,IACnDjL,KAAK0S,QAAQI,GAAY9S,KAAK0S,QAAQI,IAAa,CAAC,GAAGR,GAAiBrH,CAC7E,CACJ,EAeAjM,EAAQgU,SAAW,WACfhU,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKiT,gBAA6B,GAClCjT,KAAKkT,gBAA6B,GAClClT,KAAKmT,iBAA6B,GAElCnT,KAAKiT,gBAA6B,GAClCjT,KAAKoT,cAA6B,GAClCpT,KAAKqT,cAA6B,GAClCrT,KAAKsT,eAA6B,GAClCtT,KAAKuT,gBAA6B,GAClCvT,KAAKwT,sBAA6B,GAElCxT,KAAKuO,IAA6B,IAAIvP,EAAQyU,IAE9CzT,KAAKR,OAA6B,KAElCQ,KAAK0T,gBAA6B,YAClC1T,KAAK2T,gBAA6B,aAClC3T,KAAK4T,eAA6B,YAClC5T,KAAK6T,iBAA6B,cAClC7T,KAAK8T,wBAA6B,oBAClC9T,KAAKT,QAA6B,CAAC,SAAU,MAAO,IAAK,MAEzDS,KAAK+T,UAAY,CACb,UACA,QAAS,SACT,cAAe,eACf,IAAK,IACL,QACA,aAAc,aAAc,aAC5B,UAAW,UAAW,WAG1B/T,KAAKmF,YAAY,iBACrB,EAEAnG,EAAQ4T,WAAW1V,KAAK8B,EAAQgU,UAEhChU,EAAQgU,SAASrU,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAExDM,EAAEkH,OAAOnH,EAAQgU,SAASrU,UAE1B,CACIuT,YAAalT,EAAQgU,SAOrBgB,KAAM,WACF,IAAIrR,EAAO3C,KAEX2C,EAAKwC,YAAY,aAAclD,WAE/BU,EAAKnD,OAASC,SAASC,cAAc,OAErCiD,EAAKsR,cACLtR,EAAKuR,WAELvR,EAAKwC,YAAY,aAAclD,UACnC,EAOAiS,SAAU,WACN,IAAIvR,EAAO3C,KAEX2C,EAAKwC,YAAY,iBAAkBlD,WAEnCU,EAAK4L,IAAIC,SAA2C,mBAAnBzP,EAAO2P,QACxC/L,EAAK4L,IAAI4F,YAA2C,gBAA1BxR,EAAKwQ,iBAE/BxQ,EAAKwC,YAAY,gBAAiBlD,WAElChD,EAAEyR,OAAO/N,EAAK4L,IAClB,EAOA0F,YAAa,WACT,IAAItR,EAAO3C,KAEX2C,EAAKwC,YAAY,oBAAqBlD,WAEtCU,EAAKwQ,iBAAqBlU,EAAEkQ,UAAUxM,EAAKnD,OAAQ,aAAcmD,EAAKpD,SACtEoD,EAAKuQ,gBAAqBjU,EAAEkQ,UAAUxM,EAAKnD,OAAQ,YAAamD,EAAKpD,SACrEoD,EAAKsQ,gBAAqBhU,EAAEkQ,UAAUxM,EAAKnD,OAAQ,YAAamD,EAAKpD,SAErEoD,EAAKyR,cAAgBzR,EAAKsQ,gBACtBtQ,EAAKsQ,gBAAkBhU,EAAEoK,WAAW1G,EAAK+Q,iBAAmB/Q,EAAK+Q,gBAErE/Q,EAAK2Q,eAAiB3Q,EAAKwQ,iBACvBxQ,EAAKwQ,iBAAmBlU,EAAEoK,WAAW1G,EAAKgR,iBAAmBhR,EAAKgR,gBAEtEhR,EAAKyQ,cAAgBzQ,EAAKuQ,gBACtBvQ,EAAKuQ,gBAAkBjU,EAAEoK,WAAW1G,EAAKiR,gBAAkBjR,EAAKiR,eAEpEjR,EAAK0Q,cAAgB1Q,EAAKuQ,gBACtB,IAAMvQ,EAAKuQ,gBAAkB,IAAMvQ,EAAKiR,eAAiBjR,EAAKiR,eAElEjR,EAAK4Q,gBAAkB5Q,EAAKuQ,gBACxBvQ,EAAKuQ,gBAAkBjU,EAAEoK,WAAW1G,EAAKkR,kBAAoBlR,EAAKkR,iBAEtElR,EAAK6Q,sBAAwB7Q,EAAKuQ,gBAC9BvQ,EAAKuQ,gBAAkBjU,EAAEoK,WAAW1G,EAAKmR,yBACzCnR,EAAKmR,wBAETnR,EAAKwC,YAAY,mBAAoBlD,UACzC,IAUJjD,EAAQyU,IAAM,WACVzT,KAAKmU,aAAiB,EACtBnU,KAAKwO,UAAiB,EAEtBvP,EAAEwR,KAAKzQ,KACX,EAIAhB,EAAQsP,SAAW,IAAItP,EAAQgU,SAE/BhU,EAAQsP,SAAS0F,OAajBhV,EAAQqV,gBAAkB,WACtBrV,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAqBjBnF,KAAK8E,QAAS,EA8Bd9E,KAAKsU,QAAU,aAqBftU,KAAKuU,UAAY,GAqBjBvU,KAAKwU,WAAa,GAqBlBxU,KAAKyU,SAAW,IA4BhBzU,KAAK0U,OAAS,OAwBd1U,KAAK2U,kBAAmB,EAqBxB3U,KAAK4U,oBAAsB,SAqB3B5U,KAAK6U,kBAAoB,UA0BzB7U,KAAK8U,OAAQ,EAoBb9U,KAAK+U,WAAa,EA+BlB/U,KAAKgV,wBAAyB,EA4B9BhV,KAAKiV,sBAAuB,EAwC5BjV,KAAKkV,gBAAkB,KAgCvBlV,KAAKmV,YAAa,EA0BlBnV,KAAKoV,OAAQ,EA0BbpV,KAAKqV,aAAc,EA0BnBrV,KAAKsV,YAAa,EAElBtV,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQqV,iBAEhCrV,EAAQqV,gBAAgB1V,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE/DK,EAAQqV,gBAAgB1V,UAAUuT,YAAclT,EAAQqV,gBAaxDrV,EAAQuW,eAAiB,WACrBvW,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBA6CjBnF,KAAKwV,UAAW,EAEhBxV,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQuW,gBAEhCvW,EAAQuW,eAAe5W,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE9DK,EAAQuW,eAAe5W,UAAUuT,YAAclT,EAAQuW,eAoBvDvW,EAAQyW,gBAAkB,WACtBzW,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAyBjBnF,KAAK0V,WAAa,KAuBlB1V,KAAK2V,UAAa,KAsBlB3V,KAAK4V,SAAa,KAsBlB5V,KAAK6V,UAAa,KAyDlB7V,KAAK8V,WAAa,KAElB9V,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQyW,iBAEhCzW,EAAQyW,gBAAgB9W,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE/DK,EAAQyW,gBAAgB9W,UAAUuT,YAAclT,EAAQyW,gBAaxDzW,EAAQ+W,eAAiB,WACrB/W,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAkCjBnF,KAAK8E,QAAS,EAoCd9E,KAAKgW,MAAO,EAuCZhW,KAAKiW,MAAQ,SA6BbjW,KAAKkW,YAAc,KAsDnBlW,KAAKmW,cAAgB,MAErBnW,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ+W,gBAEhC/W,EAAQ+W,eAAepX,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE9DK,EAAQ+W,eAAepX,UAAUuT,YAAclT,EAAQ+W,eAyBvD/W,EAAQoX,iBAAmB,WACvBpX,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBA8BjBnF,KAAK0R,MAAQ,UAYb1R,KAAKqW,iBAAmB,YAkCxBrW,KAAKsW,cAAgB,UAkCrBtW,KAAKuW,YAAc,UAkCnBvW,KAAKwW,gBAAkB,UAkCvBxW,KAAKyW,cAAgB,UAWrBzW,KAAK0W,eAAiB,SAYtB1W,KAAK2W,iBAAmB,WAYxB3W,KAAK4W,eAAiB,SAuBtB5W,KAAK2R,kBAAoB,IAwBzB3R,KAAK4R,mBAAqB,IAE1B5R,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQoX,kBAEhCpX,EAAQoX,iBAAiBzX,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEhEK,EAAQoX,iBAAiBzX,UAAUuT,YAAclT,EAAQoX,iBAazDpX,EAAQ6X,WAAa,WACjB7X,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAwBjBnF,KAAK8W,OAAS,GAkEd9W,KAAK+W,YAAa,EAElB/W,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ6X,YAEhC7X,EAAQ6X,WAAWlY,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE1DK,EAAQ6X,WAAWlY,UAAUuT,YAAclT,EAAQ6X,WAanD7X,EAAQgY,YAAc,WAClBhY,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBA6BjBnF,KAAK8E,QAAS,EAoCd9E,KAAKwE,cAAe,EAapBxE,KAAKiX,WAAY,EAEjBjX,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQgY,aAEhChY,EAAQgY,YAAYrY,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE3DK,EAAQgY,YAAYrY,UAAUuT,YAAclT,EAAQgY,YAapDhY,EAAQkY,aAAe,WACnBlY,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBA+BjBnF,KAAKmX,oBAAqB,EAuC1BnX,KAAKoX,mBAAqB,GAuB1BpX,KAAKqX,cAAgB,KAuBrBrX,KAAKsX,aAAe,KAEpBtX,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQkY,cAEhClY,EAAQkY,aAAavY,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE5DK,EAAQkY,aAAavY,UAAUuT,YAAclT,EAAQkY,aAarDlY,EAAQuY,WAAa,WACjBvY,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAkCjBnF,KAAKwX,OAAS,MA0BdxX,KAAKyX,KAAO,cAuCZzX,KAAK0X,QAAU,KAEf1X,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQuY,YAEhCvY,EAAQuY,WAAW5Y,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE1DK,EAAQuY,WAAW5Y,UAAUuT,YAAclT,EAAQuY,WAanDvY,EAAQ2Y,gBAAkB,WACtB3Y,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAiCjBnF,KAAK4X,OAAS,OAgCd5X,KAAK4Q,QAAU,GAEf5Q,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ2Y,iBAEhC3Y,EAAQ2Y,gBAAgBhZ,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE/DK,EAAQ2Y,gBAAgBhZ,UAAUuT,YAAclT,EAAQ2Y,gBAexD3Y,EAAQ6Y,aAAe,WACnB7Y,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAsEjBnF,KAAK4X,OAAS,KAEd5X,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ6Y,cAEhC7Y,EAAQ6Y,aAAalZ,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE5DK,EAAQ6Y,aAAalZ,UAAUuT,YAAclT,EAAQ6Y,aASrD7Y,EAAQ8Y,gBAAkB,WACtB9Y,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ8Y,iBAEhC9Y,EAAQ8Y,gBAAgBnZ,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE/DK,EAAQ8Y,gBAAgBnZ,UAAUuT,YAAclT,EAAQ8Y,gBAiDxD9Y,EAAQ+Y,OAAS,WACb/Y,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKgY,UAAqB,IAAIhZ,EAAQqV,gBACtCrU,KAAKiY,SAAqB,IAAIjZ,EAAQuW,eACtCvV,KAAKkY,UAAqB,IAAIlZ,EAAQyW,gBACtCzV,KAAKmY,SAAqB,IAAInZ,EAAQ+W,eACtC/V,KAAKsR,WAAqB,IAAItS,EAAQoX,iBACtCpW,KAAKuH,KAAqB,IAAIvI,EAAQ6X,WACtC7W,KAAKuE,MAAqB,IAAIvF,EAAQgY,YACtChX,KAAKoY,OAAqB,IAAIpZ,EAAQkY,aACtClX,KAAKqY,KAAqB,IAAIrZ,EAAQuY,WACtCvX,KAAKsY,UAAqB,IAAItZ,EAAQ2Y,gBACtC3X,KAAKuY,OAAqB,IAAIvZ,EAAQ6Y,aACtC7X,KAAKwY,UAAqB,IAAIxZ,EAAQ8Y,gBAEtC9X,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ+Y,QAEhC/Y,EAAQ+Y,OAAOpZ,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEtDK,EAAQ+Y,OAAOpZ,UAAUuT,YAAclT,EAAQ+Y,OAS/C/Y,EAAQyZ,SAAW,WACfzZ,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKP,SAAyB,KAC9BO,KAAK0N,KAAyB,KAC9B1N,KAAKsD,UAAyB,KAC9BtD,KAAKwN,OAAyB,KAC9BxN,KAAK0Y,QAAyB,GAE9B1Y,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQyZ,UAEhCzZ,EAAQyZ,SAAS9Z,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAExDK,EAAQyZ,SAAS9Z,UAAUuT,YAAclT,EAAQyZ,SASjDzZ,EAAQ2Z,aAAe,WACnB3Z,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK4Y,KAAa,GAClB5Y,KAAK6Y,OAAa,GAClB7Y,KAAK8Y,SAAa,GAElB9Y,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ2Z,cAEhC3Z,EAAQ2Z,aAAaha,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE5DK,EAAQ2Z,aAAaha,UAAUuT,YAAclT,EAAQ2Z,aAWrD3Z,EAAQ+Z,eAAiB,WACrB/Z,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK0X,QAAU,KAEf1X,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ+Z,gBAEhC/Z,EAAQ+Z,eAAepa,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE9DK,EAAQ+Z,eAAepa,UAAUuT,YAAclT,EAAQ+Z,eAWvD/Z,EAAQga,gBAAkB,WACtBha,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKwX,OAAe,KACpBxX,KAAKyX,KAAe,KACpBzX,KAAKiZ,OAAe,KACpBjZ,KAAKkZ,OAAe,KACpBlZ,KAAKmZ,aAAe,KAEpBnZ,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQga,iBAEhCha,EAAQga,gBAAgBra,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE/DK,EAAQga,gBAAgBra,UAAUuT,YAAclT,EAAQga,gBAWxDha,EAAQoa,cAAgB,WACpBpa,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKS,SAAa,GAClBT,KAAKqZ,WAAa,KAClBrZ,KAAKsZ,OAAa,OAElBtZ,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQoa,eAEhCpa,EAAQoa,cAAcza,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE7DK,EAAQoa,cAAcza,UAAUuT,YAAclT,EAAQoa,cAWtDpa,EAAQua,YAAc,WAClBva,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKwZ,WAAa,GAClBxZ,KAAKyZ,UAAa,GAClBzZ,KAAK0Z,MAAa,MAClB1Z,KAAKqZ,WAAa,KAClBrZ,KAAK2Z,KAAa,KAElB3Z,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQua,aAEhCva,EAAQua,YAAY5a,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE3DK,EAAQua,YAAY5a,UAAUuT,YAAclT,EAAQua,YAWpDva,EAAQ4a,cAAgB,WACpB5a,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK+I,MAAa,EAClB/I,KAAKqZ,WAAa,GAClBrZ,KAAK0L,SAAa,SAClB1L,KAAK6Z,QAAa,KAElB7Z,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ4a,eAEhC5a,EAAQ4a,cAAcjb,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE7DK,EAAQ4a,cAAcjb,UAAUuT,YAAclT,EAAQ4a,cAWtD5a,EAAQ8a,cAAgB,WACpB9a,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK0Y,QAAa,GAClB1Y,KAAKqZ,WAAa,GAElBrZ,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ8a,eAEhC9a,EAAQ8a,cAAcnb,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE7DK,EAAQ8a,cAAcnb,UAAUuT,YAAclT,EAAQ8a,cAWtD9a,EAAQ+a,oBAAsB,WAC1B/a,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKoX,mBAAqB,GAE1BpX,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ+a,qBAEhC/a,EAAQ+a,oBAAoBpb,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEnEK,EAAQ+a,oBAAoBpb,UAAUuT,YAAclT,EAAQ+a,oBAc5D/a,EAAQgb,kBAAoB,SAAS5W,EAAM3C,EAAUuV,EAAMxI,GACvDxO,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKoD,KAAUA,EACfpD,KAAKS,SAAYA,EACjBT,KAAKgW,KAAYA,IAAQ,EACzBhW,KAAKwN,OAAYA,GAAU,GAE3BxN,KAAKmF,YAAY,kBAEjBlG,EAAEyR,OAAO1Q,MACTf,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQgb,mBAEhChb,EAAQgb,kBAAkBrb,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEjEK,EAAQgb,kBAAkBrb,UAAUuT,YAAclT,EAAQgb,kBAE1Dhb,EAAQib,mBAAqB,GAE7Bjb,EAAQib,mBAAmB5Y,KAAK,IAAIrC,EAAQgb,kBAAkB,WAAY,6BAC1Ehb,EAAQib,mBAAmB5Y,KAAK,IAAIrC,EAAQgb,kBAAkB,SAAU,kBACxEhb,EAAQib,mBAAmB5Y,KAAK,IAAIrC,EAAQgb,kBAAkB,OAAQ,gBACtEhb,EAAQib,mBAAmB5Y,KAAK,IAAIrC,EAAQgb,kBAAkB,SAAU,kBASxEhb,EAAQkb,QAAU,WACdlb,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKD,GAAa,KAClBC,KAAKS,SAAa,GAClBT,KAAKma,MAAa,GAClBna,KAAKoa,SAAc,EACnBpa,KAAKoD,KAAa,GAClBpD,KAAKqa,OAAa,WAClBra,KAAKwX,OAAa,GAClBxX,KAAKyX,KAAa,GAClBzX,KAAKsa,YAAa,EAClBta,KAAKua,QAAa,KAClBva,KAAKsR,WAAa,IAAItS,EAAQ2Z,aAE9B3Y,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQkb,SAEhClb,EAAQkb,QAAQvb,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEvDM,EAAEkH,OAAOnH,EAAQkb,QAAQvb,UAEzB,CACIuT,YAAalT,EAAQkb,QASrBlG,KAAM,SAASjU,EAAIqD,EAAM3C,GACrB,IAAIkC,EAAO3C,KAQX,GANAA,KAAKmF,YAAY,aAAclD,WAE/BU,EAAK5C,GAAaA,EAClB4C,EAAKS,KAAaA,EAClBT,EAAKlC,SAAaA,EAEdkC,EAAKlC,SACLkC,EAAK0X,OAAS,YAId,OAFA1X,EAAK2X,WAAwC,kBAApB3X,EAAK5C,GAAGya,QAEzB7X,EAAKS,MACT,IAAK,SACDT,EAAK6U,OAAS7U,EAAK5C,GAAG0a,aAAa,eAEnC,MACJ,IAAK,SACD9X,EAAK6U,OAAS7U,EAAK5C,GAAG0a,aAAa,eAEnC,MACJ,IAAK,OACD9X,EAAK8U,KAAS9U,EAAK5C,GAAG0a,aAAa,aAEnC,MACJ,IAAK,WACD9X,EAAK6U,OAAS7U,EAAK5C,GAAG0a,aAAa,eACnC9X,EAAK8U,KAAS9U,EAAK5C,GAAG0a,aAAa,aAM/C9X,EAAK+X,YAEL1b,EAAQmZ,SAAS9W,KAAKsB,GAEtB3C,KAAKmF,YAAY,YAAalD,UAClC,EAQA0Y,QAAS,SAASC,GACd,IACID,EAMJ,OAJA3a,KAAKmF,YAAY,gBAAiBlD,WAElC0Y,EALc3a,KAKCma,MAAMxZ,QAAQia,IAAU,EALzB5a,KAOFuS,YAAY,eAAgBoI,EAAS1Y,UACrD,EAQA4Y,WAAY,SAASD,GAGjB5a,KAAKmF,YAAY,mBAAoBlD,WAF1BjC,KAID2a,WAJC3a,KAKFma,MAAM9Y,KAAKuZ,GAGpB5a,KAAKmF,YAAY,kBAAmBlD,UACxC,EAQA6Y,cAAe,SAASF,GACpB,IAAIjY,EAAc3C,KACd+a,GAAe,EAEnB/a,KAAKmF,YAAY,sBAAuBlD,YAEnC8Y,EAAcpY,EAAKwX,MAAMxZ,QAAQia,KAAW,GAC7CjY,EAAKwX,MAAMa,OAAOD,EAAa,GAG/BpY,EAAKwX,MAAMxa,OAAS,IAGpBgD,EAAKsY,cAILF,EAAc/b,EAAQmZ,SAASxX,QAAQgC,GAEvC3D,EAAQmZ,SAAS6C,OAAOD,EAAa,GAEjB,WAAhBpY,EAAK0X,QACL1X,EAAKuY,aAAavY,EAAK5C,GAAI,aAInCC,KAAKmF,YAAY,qBAAsBlD,UAC3C,EAOAyY,UAAW,WACP,IAAI/X,EAAO3C,KAEXA,KAAKmF,YAAY,kBAAmBlD,WAEpCU,EAAK4X,QAAU,SAAS3R,GACpBjG,EAAKwY,YAAYvS,EACrB,EAEA3J,EAAEwI,GAAG9E,EAAK5C,GAAI,QAAS4C,EAAK4X,SAE5Bva,KAAKmF,YAAY,iBAAkBlD,UACvC,EAOAgZ,YAAa,WACT,IAAItY,EAAO3C,KAEXA,KAAKmF,YAAY,oBAAqBlD,WAEtChD,EAAE4I,IAAIlF,EAAK5C,GAAI,QAAS4C,EAAK4X,SAE7B5X,EAAK4X,QAAU,KAEfva,KAAKmF,YAAY,mBAAoBlD,UACzC,EAQAkZ,YAAa,SAASvS,GAClB,IAAIjG,EAAc3C,KACdob,EAAc,KACdR,EAAc,KACdS,GAAc,EAEdC,EAAc,CAAC,EACfC,EAAc,KACdC,EAAc,GACdze,GAAe,EAcnB,GAZAiD,KAAKmF,YAAY,oBAAqBlD,WAEtCjC,KAAKoa,QAAU,EAEfQ,EAAQjY,EAAKwX,MAAM,GAKfiB,EAHCzY,EAAKlC,SAGGxB,EAAEqO,cAAc1E,EAAEgP,OAAQgD,EAAMrX,OAAO+U,UAAU1H,QAAUjO,EAAKlC,UAAU,EAAMma,EAAMa,IAAIhc,UAF1FkD,EAAK5C,GAKlB,CAMA,OAAQ4C,EAAKS,MACT,IAAK,SACDkY,EAAQ9D,OAAS7U,EAAK6U,QAAU4D,EAAOX,aAAa,eAEpD,MACJ,IAAK,OACDa,EAAQ7D,KAAO9U,EAAK8U,MAAQ2D,EAAOX,aAAa,aAEhD,MACJ,IAAK,WACDa,EAAQ9D,OAAU7U,EAAK6U,QAAU4D,EAAOX,aAAa,eACrDa,EAAQ7D,KAAU9U,EAAK8U,MAAQ2D,EAAOX,aAAa,aAEnD,MACJ,IAAK,SACDa,EAAQ9D,OAAU7U,EAAK6U,QAAU4D,EAAOX,aAAa,eAGjDY,EADgB,SAAhB1Y,EAAK0X,OACMpb,EAAE0G,SAASyV,EAAQzY,EAAK2O,WAAWuH,QAEnB,WAAhBlW,EAAK0X,OAM5B,IAAKtd,EAAI,EAAGA,EAAI4F,EAAKwX,MAAMxa,OAAQ5C,IAG/Bwe,EAAQ,IAAIvc,EAAQga,gBAEpB/Z,EAAEkH,OAAOoV,EAAOD,GAEhBE,EAASna,KAAKka,GAOlB,IAJAC,EAAW7Y,EAAK4P,YAAY,sBAAuBiJ,EAAUvZ,WAE7DU,EAAKyX,QAAUzX,EAAKwX,MAAMxa,OAErB5C,EAAI,EAAG6d,EAAQjY,EAAKwX,MAAMpd,GAAIA,KAC/Bue,EAAUE,EAASze,MAQd6d,EAAMc,cACPd,EAAMc,YAAcN,GAGxBpc,EAAQ2c,OAAOC,KAAK,WAAYhB,EAAMa,IAAInY,UAAW,CACjDuY,MAAOjB,EAAMiB,MACbnY,SAAUkX,EACVkB,cAAelT,EACfgI,QAASgK,EAAMc,aAChBd,EAAMa,IAAIhc,UAEoC,mBAAtCmb,EAAMrX,OAAO2U,UAAUpC,aAGV,IAFN8E,EAAMrX,OAAO2U,UAAUpC,WAAW5Y,KAAK0d,EAAMc,YAAad,EAAMiB,MAAOjT,EAAGgS,KAS1E,WAAdjY,EAAKS,KACLiY,EAAWT,EAAMmB,UAAUT,EAAQ9D,QAAUoD,EAAMoB,SAASV,EAAQ9D,QAEpEoD,EAAMqB,SAASX,KAIvBtb,KAAKmF,YAAY,mBAAoBlD,UA/ErC,MAHIU,EAAKwC,YAAY,mBAAoBlD,UAmF7C,EAQAia,OAAQ,SAASZ,EAASa,GACtB,IAAIxZ,EAAU3C,KACVqS,EAAU,IAAIrT,EAAQga,gBAE1BrW,EAAKwC,YAAY,eAAgBlD,WAEjCU,EAAKyX,UAELzX,EAAKyX,QAAUhY,KAAKG,IAAI,EAAGI,EAAKyX,SAE5BzX,EAAKyX,QAAU,IAEC,SAAhBzX,EAAK0X,OAGL1X,EAAKyZ,WAAWd,EAASa,IAIzB9J,EAAQoF,KAAU9U,EAAK8U,KACvBpF,EAAQmF,OAAU7U,EAAK6U,OAEvB7U,EAAK4P,YAAY,gBAAiBF,EAASpQ,WAE3CU,EAAK0Z,kBAAkB1Z,EAAK5C,GAAIub,EAASjJ,EAAS8J,IAGtDxZ,EAAKwC,YAAY,cAAelD,WACpC,EAQAma,WAAY,SAASd,EAASa,GAC1B,IACIG,EADA3Z,EAAkB3C,KAElBqS,EAAkB,KAClB+I,EAAkB,KAClBre,GAAmB,EAIvB,GAFA4F,EAAKwC,YAAY,mBAAoBlD,WAEhCU,EAAK5C,GAAV,CAIA,IAFAuc,EAAiB3Z,EAAK5C,GAAGc,iBAAiB8B,EAAKlC,UAE1C1D,EAAI,EAAGqe,EAASkB,EAAevf,GAAIA,IAAK,CAGzC,OAFAsV,EAAU,IAAIrT,EAAQga,gBAEdrW,EAAKS,MACT,IAAK,SACDiP,EAAQmF,OAAS4D,EAAOX,aAAa,eAErC,MACJ,IAAK,OACDpI,EAAQoF,KAAO2D,EAAOX,aAAa,aAEnC,MACJ,IAAK,WACDpI,EAAQmF,OAAU4D,EAAOX,aAAa,eACtCpI,EAAQoF,KAAU2D,EAAOX,aAAa,aAEtC,MACJ,IAAK,SACDpI,EAAQmF,OAAU4D,EAAOX,aAAa,eAK9CpI,EAAU1P,EAAK4P,YAAY,oBAAqBF,EAASpQ,WAEzDU,EAAK0Z,kBAAkBjB,EAAQE,EAASjJ,EAAS8J,EACrD,CAEAxZ,EAAKwC,YAAY,kBAAmBlD,UAhChB,CAiCxB,EAUAoa,kBAAmB,SAASjB,EAAQE,EAASjJ,EAAS8J,GAClD,IAAIxZ,EAAU3C,KACVuc,EAAU,GAEVxf,GAAW,EAIf,OAFA4F,EAAKwC,YAAY,0BAA2BlD,WAEpCU,EAAKS,MACT,IAAK,SACGkY,EAAQ9D,SAAWnF,EAAQmF,OAC3B7U,EAAKuY,aAAaE,EAAQ,UAE1BzY,EAAKuY,aAAaE,EAAQ,YAG9B,MACJ,IAAK,WACGE,EAAQ7D,OAASpF,EAAQoF,MAAQ6D,EAAQ9D,SAAWnF,EAAQmF,OAC5D7U,EAAKuY,aAAaE,EAAQ,UAE1BzY,EAAKuY,aAAaE,EAAQ,YAG9B,MACJ,IAAK,OACGE,EAAQ7D,KAAK3R,MAAM,WACnByW,EAAQjB,EAAQ7D,KAAK5V,QAAQ,QAAS,KAGtCyZ,EAAQ7D,OAASpF,EAAQoF,MAAQ8E,IAAUlK,EAAQoF,KACnD9U,EAAKuY,aAAaE,EAAQ,UAE1BzY,EAAKuY,aAAaE,EAAQ,YAG9B,MACJ,IAAK,SAOD,IANIe,EAAYxc,OAAS,GAAGgD,EAAKuY,aAAaE,EAAQ,YAElDE,EAAQ9D,SAAWnF,EAAQmF,QAC3B7U,EAAKuY,aAAaE,EAAQ,UAGzBre,EAAI,EAAGA,EAAIof,EAAYxc,OAAQ5C,IAAK,CAGrC,GAFSof,EAAYpf,KAENsV,EAAQmF,OAAQ,CAG3B7U,EAAKuY,aAAaE,EAAQ,UAE1B,KACJ,CAEAzY,EAAKuY,aAAaE,EAAQ,WAC9B,EAKRzY,EAAKwC,YAAY,yBAA0BlD,UAC/C,EAQAiZ,aAAc,SAASE,EAAQf,GAC3B,IAAI1X,EAAO3C,KAIX,OAFA2C,EAAKwC,YAAY,qBAAsBlD,WAE/BoY,GACJ,IAAK,SACDpb,EAAE+G,SAASoV,EAAQzY,EAAK2O,WAAWuH,QACnC5Z,EAAEgH,YAAYmV,EAAQzY,EAAK2O,WAAWwH,UAElCnW,EAAK2X,aAAY3X,EAAK5C,GAAG+Y,UAAW,GAExC,MACJ,IAAK,WACD7Z,EAAEgH,YAAYmV,EAAQzY,EAAK2O,WAAWuH,QACtC5Z,EAAEgH,YAAYmV,EAAQzY,EAAK2O,WAAWwH,UAElCnW,EAAK2X,aAAY3X,EAAK5C,GAAG+Y,UAAW,GAExC,MACJ,IAAK,WACGnW,EAAK2X,aAAY3X,EAAK5C,GAAG+Y,UAAW,GAExC7Z,EAAE+G,SAASoV,EAAQzY,EAAK2O,WAAWwH,UACnC7Z,EAAEgH,YAAYmV,EAAQzY,EAAK2O,WAAWuH,QAK1B,SAAhBlW,EAAK0X,SAGL1X,EAAK0X,OAASA,GAGlB1X,EAAKwC,YAAY,oBAAqBlD,UAC1C,IAGJjD,EAAQmZ,SAAW,GASnBnZ,EAAQwd,UAAY,WAChBxd,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKmM,EAAiB,EACtBnM,KAAKoM,EAAiB,EACtBpM,KAAKqN,IAAiB,EACtBrN,KAAKyc,MAAiB,EACtBzc,KAAK0c,OAAiB,EACtB1c,KAAKoN,KAAiB,EACtBpN,KAAKiN,MAAiB,EACtBjN,KAAKkN,OAAiB,EACtBlN,KAAK2c,YAAiB,EACtB3c,KAAK4c,aAAiB,EACtB5c,KAAKwQ,QAAiB,EACtBxQ,KAAK6c,MAAiB,IAAI7d,EAAQ8d,cAClC9c,KAAK+c,WAAiB,IAAI/d,EAAQ8d,cAClC9c,KAAKgd,WAAiB,IAAIhe,EAAQ8d,cAClC9c,KAAKid,WAAiB,IAAIje,EAAQ8d,cAClC9c,KAAKkd,QAAiB,IAAIle,EAAQ8d,cAClC9c,KAAKmd,QAAiB,IAAIne,EAAQ8d,cAClC9c,KAAKod,QAAiB,IAAIpe,EAAQ8d,cAElC9c,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQwd,WAEhCxd,EAAQwd,UAAU7d,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEzDK,EAAQwd,UAAU7d,UAAUuT,YAAclT,EAAQwd,UASlDxd,EAAQ8d,cAAgB,WACpB9d,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKhC,MAAS,EACdgC,KAAKqd,KAAS,GAEdrd,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ8d,eAEhC9d,EAAQ8d,cAAcne,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE7DK,EAAQ8d,cAAcne,UAAUuT,YAAclT,EAAQ8d,cAStD9d,EAAQse,kBAAoB,WACxBte,EAAQwd,UAAUzZ,MAAM/C,MAExBA,KAAKmF,YAAY,mBAEjBnF,KAAK6c,MAAM7e,MAAe,IAC1BgC,KAAK6c,MAAMQ,KAAe,GAE1Brd,KAAK+c,WAAW/e,MAAU,GAC1BgC,KAAK+c,WAAWM,KAAU,KAE1Brd,KAAKgd,WAAWhf,MAAU,GAC1BgC,KAAKgd,WAAWK,KAAU,KAE1Brd,KAAKid,WAAWjf,MAAU,GAC1BgC,KAAKid,WAAWI,KAAU,KAE1Brd,KAAKkd,QAAQlf,MAAa,GAC1BgC,KAAKkd,QAAQG,KAAa,MAE1Brd,KAAKmd,QAAQnf,MAAa,GAC1BgC,KAAKmd,QAAQE,KAAa,MAE1Brd,KAAKkd,QAAQlf,MAAa,GAC1BgC,KAAKkd,QAAQG,KAAa,MAE1Brd,KAAKod,QAAQpf,MAAa,IAC1BgC,KAAKod,QAAQC,KAAa,MAE1Brd,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQse,mBAEhCte,EAAQse,kBAAkB3e,UAAYlB,OAAOY,OAAOW,EAAQwd,UAAU7d,WAEtEK,EAAQse,kBAAkB3e,UAAUuT,YAAclT,EAAQse,kBAS1Dte,EAAQue,kBAAoB,IAAIve,EAAQse,kBASxCte,EAAQwe,YAAc,WAClBxd,KAAK6b,MAAiB,KACtB7b,KAAKyd,YAAiB,KACtBzd,KAAK0D,SAAiB,KACtB1D,KAAK8b,cAAiB,IAC1B,EAuBA9c,EAAQ0e,OAAS,WACb1e,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAgBjBnF,KAAK2d,SAAW,KAahB3d,KAAK4d,QAAU,KAYf5d,KAAK6d,OAAS,KAYd7d,KAAK8d,QAAU,KAef9d,KAAK+d,SAAW,KAEhB/d,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ0e,QAEhC1e,EAAQ0e,OAAO/e,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEtDK,EAAQ0e,OAAO/e,UAAUuT,YAAclT,EAAQ0e,OAU/C1e,EAAQ0e,OAAO/e,UAAUid,KAAO,SAAS3T,EAAWlI,EAAImI,EAAQtE,GAC5D,IACIV,EADAP,EAAc3C,KAEdge,EAAc,IAAIhf,EAAQwe,YAI9B,GAFA7a,EAAKwC,YAAY,aAAclD,gBAEA,IAApBU,EAAKsF,GACZ,MAAM,IAAIhE,MAAM,eAAiBgE,EAAY,gBAGjD+V,EAAYnC,MAAQ,IAAI7c,EAAQif,MAEhChf,EAAEkH,OAAO6X,EAAYnC,MAAO3T,EAAO2T,OAE/B3T,EAAOuV,cACPO,EAAYP,YAAc,IAAIze,EAAQif,MAEtChf,EAAEkH,OAAO6X,EAAYP,YAAavV,EAAOuV,cAG7CO,EAAYta,SAAWwE,EAAOxE,SAE1BwE,EAAO4T,gBACPkC,EAAYlC,cAAgB5T,EAAO4T,eAGvC5Y,EAAQjE,EAAE+I,eAAeC,EAAW+V,EAAapa,GAEjDjB,EAAK4P,YAAY,YAAarP,EAAOjB,WAErClC,EAAGkD,cAAcC,EACrB,EAIAlE,EAAQ2c,OAAS,IAAI3c,EAAQ0e,OAS7B1e,EAAQkf,UAAY,WAChBlf,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKsL,KAAiB,GACtBtL,KAAKme,YAAiB,KACtBne,KAAKoe,eAAiB,KACtBpe,KAAKmO,SAAiB,KACtBnO,KAAKqe,YAAiB,EAEtBre,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQkf,WAEhClf,EAAQkf,UAAUvf,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEzDK,EAAQkf,UAAUvf,UAAUuT,YAAclT,EAAQkf,UAiBlDlf,EAAQsF,MAAQ,WACZtF,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKuD,OAAoB,IAAIvE,EAAQ+Y,OAErC/X,KAAK8D,GAAoB,GAEzB9D,KAAKse,QAAoB,EACzBte,KAAKqe,YAAoB,EACzBre,KAAKue,YAAoB,EAEzBve,KAAKmY,SAAoB,GACzBnY,KAAK0Y,QAAoB,GACzB1Y,KAAKwe,UAAoB,GACzBxe,KAAKye,MAAoB,CAAC,EAE1Bze,KAAKmc,YAAoB,GAEzBnc,KAAK0e,aAAoB,EACzB1e,KAAK2e,iBAAoB,EACzB3e,KAAK4e,aAAoB,EACzB5e,KAAK6e,YAAoB,EAEzB7e,KAAK8e,gBAAoB,EACzB9e,KAAKuU,UAAoB,KACzBvU,KAAKwU,WAAoB,KACzBxU,KAAK+e,YAAoB,GACzB/e,KAAKgf,aAAoB,GACzBhf,KAAK8U,MAAoB,GAEzB9U,KAAK6b,MAAoB,KACzB7b,KAAKif,cAAoB,KACzBjf,KAAK0b,YAAoB,KACzB1b,KAAKkf,aAAoB,KACzBlf,KAAKmf,aAAoB,KAEzBnf,KAAKyb,IAAoB,IAAIzc,EAAQyZ,SAErCzY,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQsF,OAEhCtF,EAAQsF,MAAM3F,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAErDM,EAAEkH,OAAOnH,EAAQsF,MAAM3F,UAEvB,CACIuT,YAAalT,EAAQsF,MAYrBM,OAAQ,SAAStB,EAAW7D,EAAUqE,EAAIP,GACtC,IAAIZ,EAAU3C,KACV4X,EAAU,KACV7a,GAAW,EAoCf,IAlCA4F,EAAKwC,YAAY,eAAgBlD,WAEjCU,EAAKmB,GAAKA,EAENP,GACAtE,EAAEkH,OAAOxD,EAAKY,OAAQA,GAAQ,GAAM,GAGxCZ,EAAKyc,iBAELzc,EAAK0c,SAAS/b,EAAW7D,GAErBkD,EAAKY,OAAO6U,OAAOhB,oBACnBnY,EAAE+G,SAASrD,EAAK8Y,IAAInY,UAAWX,EAAKY,OAAO6U,OAAOhB,oBAGjDpY,EAAQsP,SAASC,IAAI4F,cACtBxR,EAAKY,OAAOyU,UAAUlT,QAAS,QAGL,IAAnB/F,EAAO0F,UACd9B,EAAKY,OAAOgB,MAAMC,cAAe,GAGjC7B,EAAKY,OAAOgE,KAAKuP,SAGjBnU,EAAKY,OAAO4U,SAASrT,QAAS,GAGlCnC,EAAK2c,eAEL3c,EAAKkZ,MAAQlZ,EAAK4c,kBAEbxiB,EAAI,EAAG6a,EAASjV,EAAKsc,cAAcO,OAAOziB,GAAIA,IAC/C6a,EAAO6H,OAGP9c,EAAKY,OAAO4U,SAASrT,SACrBnC,EAAK+c,eAEL/c,EAAKgd,iBAAiB,KAAMhd,EAAKkZ,OAEjClZ,EAAKid,eAAe,CAChBpI,OAAQ7U,EAAKkZ,MAAMgE,aACnBpI,KAAM9U,EAAKkZ,MAAMiE,cAIzBnd,EAAKod,eAELpd,EAAKwC,YAAY,cAAelD,UACpC,EASAmd,eAAgB,WACZ,IAAIzc,EAAO3C,KAEX2C,EAAKwC,YAAY,uBAAwBlD,WAIzCU,EAAKY,OAAO4U,SAASlC,MAAiBtT,EAAKY,OAAO4U,SAASlC,MAAM/M,cAActH,OAC/Ee,EAAKY,OAAO4U,SAASjC,YAAiBvT,EAAKY,OAAO4U,SAASjC,YAAYhN,cAActH,OACrFe,EAAKY,OAAO4U,SAAShC,cAAiBxT,EAAKY,OAAO4U,SAAShC,cAAcjN,cAActH,OAEvFe,EAAKY,OAAOyU,UAAU1D,QAAgB3R,EAAKY,OAAOyU,UAAU1D,QAAQ1S,OAEpEe,EAAKwC,YAAY,sBAAuBlD,UAC5C,EASAsd,gBAAiB,WACb,IAAI5c,EAAc3C,KACd6b,EAAc,IAAI7c,EAAQif,MAC1B+B,EAAc,IAAIhhB,EAAQihB,UAQ9B,GANAtd,EAAKwC,YAAY,wBAAyBlD,WAI1C4Z,EAAMqE,yBAA2Bvd,EAAKY,OAAO6U,OAAOhB,mBAEhDzU,EAAKY,OAAO8U,KAAKX,QAAS,CAG1B,IAAK/U,EAAKY,OAAOgE,KAAKuP,QAA6C,iBAA5BnU,EAAKY,OAAOgE,KAAKuP,OACpD,MAAM,IAAI1V,UAAUpC,EAAQkF,SAASic,+BAGzCH,EAAUI,aAAeJ,EAAUK,WAAaxE,EAAMyE,cAAgB3d,EAAKY,OAAO8U,KAAKX,QAAQ5U,QAC/Fkd,EAAUO,wBAA0BP,EAAUQ,sBAAwB3E,EAAMqE,yBAC5EF,EAAUS,KAAO9d,EAAK+V,QAAQ5V,QAE9B+Y,EAAQlZ,EAAK4P,YAAY,uBAAwBsJ,EAAO5Z,UAC5D,MAGI4Z,EAAMgE,aAA4Bld,EAAK+d,gBAAgB,CAAC/d,EAAKY,OAAO8U,KAAKb,SAAS8D,QAClFO,EAAMiE,WAA4Bnd,EAAKge,cAAc,CAAChe,EAAKY,OAAO8U,KAAKZ,OAAO6D,QAC9EO,EAAM+E,aAA4Bje,EAAK+V,QAAQ/Y,QAE/Ckc,EAAQlZ,EAAK4P,YAAY,uBAAwBsJ,EAAO5Z,YAG9C6d,WAAWzG,YAAcwC,EAAMiE,WAAWrG,WACrB,WAA3BoC,EAAMiE,WAAWpG,OAAiD,SAA3BmC,EAAMiE,WAAWpG,OAIxDsG,EAAUa,QAAUhF,EAAMiE,WAE1Bnd,EAAKme,cAAcd,GAEnBrd,EAAKoe,WAAU,EAAOf,GAEtBrd,EAAK+V,QAAUsH,EAAUgB,UAEzBhB,EAAUiB,WAAajB,EAAUgB,SAAWre,EAAK+V,QAGrDsH,EAAUkB,YAA4BlB,EAAUmB,UAA0BtF,EAAMgE,aAChFG,EAAUoB,UAA4BpB,EAAUa,QAA0BhF,EAAMiE,WAChFE,EAAUO,wBAA4BP,EAAUQ,sBAA0B3E,EAAMqE,yBAE3C,QAAjCF,EAAUmB,UAAU1gB,SACpBuf,EAAUmB,UAAU1gB,SAAWkC,EAAKY,OAAO+U,UAAUV,OACb,SAAjCoI,EAAUmB,UAAU1gB,WAC3Buf,EAAUmB,UAAU1gB,SAAW,IAcvC,OAVAuf,EAAYrd,EAAK4P,YAAY,2BAA4ByN,EAAW,CAACnE,IAErElZ,EAAKsc,cAAgBe,EAEjBA,EAAUmB,WACVxe,EAAK0e,gBAAgBrB,GAGzBnE,EAAQlZ,EAAK2e,WAAWtB,EAG5B,EAaAX,SAAU,SAAStf,EAAIN,GACnB,IAAIkD,EAAU3C,KAEd2C,EAAKwC,YAAY,iBAAkBlD,WAEnCU,EAAK8Y,IAAIhc,SAAYA,EACrBkD,EAAK8Y,IAAI/N,KAAY/K,EAAK8Y,IAAIhc,SAAS8hB,cAAc,QACrD5e,EAAK8Y,IAAInY,UAAYvD,EACrB4C,EAAK8Y,IAAIjO,OAAYzN,EAErB4C,EAAKwC,YAAY,gBAAiBlD,UACtC,EAYAqd,aAAc,WACV,IAGI5H,EAHA/U,EAAkB3C,KAClB4X,EAAkB,KAClB7X,EAAkB,KAElBhD,GAAmB,EAYvB,GAVA4F,EAAKwC,YAAY,qBAAsBlD,WAEvCU,EAAK8Y,IAAI/C,QAAU/V,EAAKY,OAAO6U,OAAOjB,mBAClCxU,EAAK8Y,IAAInY,UAAUzC,iBAAiB8B,EAAKY,OAAO+U,UAAUV,QAC1D3Y,EAAE0O,SAAShL,EAAK8Y,IAAInY,UAAWX,EAAKY,OAAO+U,UAAUV,OAAQjV,EAAK8Y,IAAIhc,UAE1EkD,EAAK8Y,IAAI/C,QAAUzZ,EAAE6L,cAAcnI,EAAK8Y,IAAI/C,SAE5C/V,EAAK+V,QAAU,IAEVhB,EAAU/U,EAAKY,OAAO8U,KAAKX,UAAYA,EAAQ/X,SAAWgD,EAAK8Y,IAAI/C,QAAQ/Y,OAC5E,MAAM,IAAIsE,MAAMjF,EAAQkF,SAASsd,mCAGrC,GAAI7e,EAAK8Y,IAAI/C,QAAQ/Y,OAAQ,CACzB,IAAK5C,EAAI,EAAGgD,EAAK4C,EAAK8Y,IAAI/C,QAAQ3b,GAAIA,KAClC6a,EAAS,IAAI5Y,EAAQyiB,QAEdzN,KAAKjU,EAAI4C,EAAM+U,EAAUA,EAAQ3a,QAAK,GAE7C6a,EAAO8J,SAAU,EAEjB/e,EAAK+V,QAAQrX,KAAKuW,GAGtBjV,EAAK8Y,IAAIjO,OAAS7K,EAAK8Y,IAAI/C,QAAQ,GAAG9X,gBAAkB+B,EAAK8Y,IAAInY,UAC7DX,EAAK8Y,IAAInY,UACTX,EAAK8Y,IAAI/C,QAAQ,GAAG9X,aAC5B,CAEA+B,EAAK6b,UAAY7b,EAAK+V,QAEtB/V,EAAKwC,YAAY,oBAAqBlD,UAC1C,EAEAyd,aAAc,WACV,IAAI/c,EAAsB3C,KACtB2hB,EAAsB,GACtBC,EAAsB,KACtB7hB,EAAsB,KACtByN,EAAsB,KACtBqU,EAAsB,KACtBjR,EAAsB,KACtB7T,GAAuB,EACvB+kB,GAAuB,EAI3B,OAFAnf,EAAKwC,YAAY,qBAAsBlD,WAE/BU,EAAKY,OAAO4U,SAASlC,OACzB,IAAK,QACDzI,EAAS7K,EAAK8Y,IAAInY,UAElB,MACJ,IAAK,SACDkK,EAAS7K,EAAK8Y,IAAIhc,SAElB,MACJ,QACI,MAAM,IAAIwE,MAAMjF,EAAQkF,SAAS6d,mCAGzC,IAAKhlB,EAAI,EAAG4kB,EAAa3iB,EAAQib,mBAAmBld,GAAIA,IACpD,GAAI4F,EAAKY,OAAO4U,SAASnC,MAAQ2L,EAAW3L,KAAM,CAC9C,GAAI2L,EAAWnU,OAAQ,CAGnB,KAFAqU,EAAalf,EAAK8Y,IAAIkG,EAAWnU,UAEdqU,EAAWliB,OAAS,EAAG,SAET,iBAAtBkiB,EAAWliB,SAClBkiB,EAAa,CAACA,GAEtB,MACIA,EAAa,CAACrU,GAGlB,IAAKsU,EAAI,EAAI/hB,EAAK8hB,EAAWC,GAAKA,IAC9BlR,EAAUjO,EAAKqf,WAAWjiB,EAAK4hB,EAAWve,KAAMue,EAAWlhB,UAE3DkC,EAAKwV,SAAS9W,KAAKuP,EAE3B,MAGI,IAFAgR,EAAkBpU,EAAO3M,iBAAiB8B,EAAKY,OAAO+U,UAAU1H,QAAU+Q,EAAWlhB,UAEhFqhB,EAAI,EAAI/hB,EAAK6hB,EAAgBE,GAAKA,KACnClR,EAAUjO,EAAKqf,WAAWjiB,EAAI4hB,EAAWve,KAAM,MAI/CT,EAAKwV,SAAS9W,KAAKuP,GAK/BjO,EAAKwC,YAAY,oBAAqBlD,UAC1C,EAYA+f,WAAY,SAASjiB,EAAIqD,EAAM3C,GAC3B,IAAIkC,EAAU3C,KACV4Q,EAAU,KACV7T,GAAW,EAIf,GAFA4F,EAAKwC,YAAY,mBAAoBlD,YAEhCxB,EAGD,IAAK1D,EAAI,EAAG6T,EAAU5R,EAAQmZ,SAASpb,GAAIA,IAAK,CAC5C,GAAI6T,EAAQ7Q,KAAOA,GAAM6Q,EAAQ+J,QAAQhY,GAMrC,OAAOA,EAAK4P,YAAY,oBAAqB,KAAMtQ,WAChD,GAAI2O,EAAQ7Q,KAAOA,GAAM6Q,EAAQxN,OAASA,GAAQwN,EAAQnQ,WAAaA,EAK1E,OAFAmQ,EAAQiK,WAAWlY,GAEZA,EAAK4P,YAAY,oBAAqB3B,EAAS3O,UAE9D,CAiBJ,OAZA2O,EAAU,IAAI5R,EAAQkb,SAEdlG,KAAKjU,EAAIqD,EAAM3C,GAEvBmQ,EAAQU,WAAWsH,KAAW3Z,EAAEoS,aAAa1O,EAAKY,OAAO+N,WAAYlO,GACrEwN,EAAQU,WAAWuH,OAAW5Z,EAAEoS,aAAa1O,EAAKY,OAAO+N,WAAYlO,EAAMT,EAAKY,OAAO+N,WAAWoF,gBAClG9F,EAAQU,WAAWwH,SAAW7Z,EAAEoS,aAAa1O,EAAKY,OAAO+N,WAAYlO,EAAMT,EAAKY,OAAO+N,WAAWqF,kBAIlG/F,EAAQiK,WAAWlY,GAEZA,EAAK4P,YAAY,oBAAqB3B,EAAS3O,UAC1D,EAYAggB,kBAAmB,WACf,IAAItf,EAAkB3C,KAClBkiB,EAAuD,OAArCvf,EAAKY,OAAO4U,SAASjC,YAAuB,KAAO,GACrEiM,EAAkB,GAYtB,OAVAxf,EAAKwC,YAAY,0BAA2BlD,WAE5CU,EAAKwZ,YAAcld,EAAE8O,MAAMpL,EAAKwZ,aAIT,MAFvBgG,EAAiBxf,EAAKwZ,YAAYiG,KAAKF,MAGnCC,EAAiBxf,EAAKY,OAAO4U,SAAShC,eAGnCxT,EAAK4P,YAAY,4BAA6B4P,EAAgBlgB,UACzE,EAeA0d,iBAAkB,SAASrE,EAASO,GAChC,IAAIlZ,EAA0B3C,KAC1BqiB,EAA0B,GAI9B,GAFA1f,EAAKwC,YAAY,yBAA0BlD,WAEvCqZ,GAAWA,EAAQ9D,OACnB6K,EAAuB/G,EAAQ9D,OAAO/W,SAASoB,QAAQ,MAAO,QAC3D,KAAIga,EAGP,OAFAwG,EAAuBxG,EAAMgE,aAAapf,SAASoB,QAAQ,MAAO,GAGtE,CAEIwgB,IAAyB1f,EAAKY,OAAO+U,UAAUV,QAAmC,QAAzByK,IACzDA,EAAuB,IAGc,OAArC1f,EAAKY,OAAO4U,SAASjC,YACrBvT,EAAKwZ,YAAckG,EAAqBtR,MAAM,KAE9CpO,EAAKwZ,YAAcxZ,EAAK2f,sBAAsBD,GAGlD1f,EAAKwZ,YAAcld,EAAE8O,MAAMpL,EAAKwZ,aAEhCxZ,EAAKwC,YAAY,wBAAyBlD,UAC9C,EAaAqgB,sBAAuB,SAASC,GAG5B,IAAIC,EAAcD,EAAiBxR,MAAM,aACrCoL,EAAc,GACd1b,EAAc,GACd1D,GAAe,EAMnB,IAJoB,KAAhBylB,EAAS,IACTA,EAASC,QAGR1lB,EAAI,EAAGA,EAAIylB,EAAS7iB,OAAQ5C,IACzBA,EAAI,GAAM,IACV0D,EAAW,IAGfA,GAAY+hB,EAASzlB,GAEjBA,EAAI,GAAM,GACVof,EAAY9a,KAAKZ,GAIzB,OAAO0b,CACX,EAaAyD,eAAgB,SAAStE,GACrB,IAAI3Y,EAAU3C,KACV4Q,EAAU,KACVpJ,EAAU,IAAIxI,EAAQga,gBACtBjc,GAAW,EA4Bf,IA1BA4F,EAAKwC,YAAY,uBAAwBlD,WAIrCqZ,EAAQ9D,OACRhQ,EAAOgQ,OAAS8D,EAAQ9D,OAAO/W,SAE/B+G,EAAOgQ,OAAS7U,EAAKkZ,MAAMgE,aAAapf,SAGxC6a,EAAQ7D,KACRjQ,EAAOiQ,KAAO9U,EAAK+f,gBAAgBpH,EAAQ7D,MAE3CjQ,EAAOiQ,KAAO9U,EAAK+f,gBAAgB/f,EAAKkZ,MAAMiE,YAG9CtY,EAAOgQ,SAAW7U,EAAKY,OAAO+U,UAAUV,SACxCpQ,EAAOgQ,OAAS,OAGE,KAAlBhQ,EAAOgQ,SACPhQ,EAAOgQ,OAAS,QAGpBvY,EAAEyR,OAAOlJ,GAEJzK,EAAI,EAAG6T,EAAUjO,EAAKwV,SAASpb,GAAIA,IACpC6T,EAAQsL,OAAO1U,EAAQ7E,EAAKwZ,aAGhCxZ,EAAKwC,YAAY,sBAAuBlD,UAC5C,EAUAygB,gBAAiB,SAASpH,GACtB,IACI9T,EAAU,GAQd,OANAA,GAAU8T,EAAQ9B,WAEd8B,EAAQ3B,OACRnS,GAAU,IANAxH,KAMW0iB,gBAAgBpH,EAAQ3B,OAG1CnS,CACX,EAWAmb,cAAe,SAASrH,EAAS0E,GAC7B,IACI/f,EADA0C,EAAkB3C,KAElB4iB,GAAmB,EACnBjZ,EAAkB,KAClBiO,EAAkB,KAClB7X,EAAkB,KAClBhD,GAAmB,EAevB,GAbA4F,EAAKwC,YAAY,sBAAuBlD,gBAEX,IAAlBqZ,EAAQvS,QAAuBuS,EAAQvS,MAAQ,GAE1D9I,EAAc0C,EAAKkgB,eAAevH,EAAQvS,MAAOuS,EAAQzB,QAASyB,EAAQ5P,UAC1E/B,EAAchH,EAAK8Y,IAAIhc,SAASoK,yBAG5B+Y,EADA3iB,EACiBhB,EAAE8J,MAAM9I,EAAa0C,EAAKY,OAAO+U,UAAUV,QAE3CjV,EAAK+V,QAAQ/Y,OAG9B2b,EAAQjC,WAAY,CACpB,IAAKtc,EAAI,EAAGgD,EAAKub,EAAQjC,WAAWtc,GAAIA,IAAK,CACzC,GAAI4F,EAAK8Y,IAAI/C,QAAQ/X,QAAQZ,IAAO,EAChC,MAAM,IAAIkE,MAAMjF,EAAQkF,SAAS4e,iCAMrC/iB,EAAGuP,MAAMyT,QAAU,OAEnBpZ,EAAKK,YAAYjK,GACjB4J,EAAKK,YAAYrH,EAAK8Y,IAAIhc,SAASujB,eAAe,MAE7C/jB,EAAE+E,UAAUjE,EAAI4C,EAAK8Y,IAAIhc,WAAcM,EAAGI,QAAQwC,EAAKY,OAAO+U,UAAUV,WAE7EA,EAAS,IAAI5Y,EAAQyiB,QAEdzN,KAAKjU,EAAI4C,GAEhBiV,EAAO8J,SAAU,EAEjB/e,EAAK+V,QAAQsC,OAAO4H,EAAgB,EAAGhL,GAEvCgL,IACJ,CAEAjgB,EAAK8Y,IAAIjO,OAAOyV,aAAatZ,EAAM1J,EACvC,CAIA+f,EAAUiB,WAAate,EAAK6b,UAAY7b,EAAK+V,QAE7C/V,EAAKwC,YAAY,qBAAsBlD,UAC3C,EAYA4gB,eAAgB,SAAS9Z,EAAO8Q,EAASnO,GACrC,IAAI/I,EAAU3C,KACV2L,EAAU,KAgCd,OA9BA5C,EAAQ3G,KAAKG,IAAIwG,EAAO,GAEpB8Q,GAAwB,WAAbnO,EAGXC,EAAUkO,EACHA,GAAwB,UAAbnO,EAGlBC,EAAUkO,EAAQha,oBAAsB,KACjC8C,EAAK+V,QAAQ/Y,OAAS,QAAsB,IAAVoJ,EAGzC4C,EAAW5C,EAAQpG,EAAK+V,QAAQ/Y,SAAWgD,EAAK+V,QAAQ/Y,OACpDgD,EAAK+V,QAAQ3P,GAAO0S,IAAI1b,GACxB4C,EAAK+V,QAAQ/V,EAAK+V,QAAQ/Y,OAAS,GAAG8b,IAAI1b,GAAGF,mBAClB,IAAxB8C,EAAK+V,QAAQ/Y,QAAgBgD,EAAK8Y,IAAIjO,OAAOG,SAAShO,OAAS,IAGlEgD,EAAKY,OAAO6U,OAAOd,aACnB3L,EAAUhJ,EAAKY,OAAO6U,OAAOd,aACtB3U,EAAKY,OAAO6U,OAAOf,cAC1B1L,EAAUhJ,EAAKY,OAAO6U,OAAOf,cAAcxX,mBAE3C8C,EAAK8Y,IAAIjO,OAAOG,SAAS,IAM1BhL,EAAK4P,YAAY,wBAAyB5G,EAAS1J,UAC9D,EAUAof,gBAAiB,SAASrB,GACtB,IAGI1G,EAHA3W,EAAc3C,KACdkjB,GAAc,EACdna,GAAe,EAEf6O,EAAc,KACd7a,GAAe,EAMnB,IAJA4F,EAAKwC,YAAY,wBAAyBlD,WAE1CqX,EAAS0G,EAAUmB,UAAU7H,OAExBvc,EAAI,EAAG6a,EAASoI,EAAUgB,SAASjkB,GAAIA,IAIpCmmB,EAHAlD,EAAUmB,UAAU9H,WAGP2G,EAAUmB,UAAU9H,WAAW1Y,QAAQiX,EAAO6D,IAAI1b,KAAO,EAIjC,KAAjCigB,EAAUmB,UAAU1gB,UAGPmX,EAAO6D,IAAI1b,GAAGI,QAAQ6f,EAAUmB,UAAU1gB,UAI/DkC,EAAKwgB,iBAAiBD,EAAYtL,EAAQ0B,EAAQ0G,GAGtD,GAAIA,EAAUoD,SAASzjB,OACnB,IAAK5C,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IAChCijB,EAAUoD,SAASziB,QAAQiX,IAAW,IAGtCoI,EAAUS,KAAKzF,OAAOje,EAAG,IAEpBgM,EAAQiX,EAAUqD,OAAO1iB,QAAQiX,KAAY,GAC9CoI,EAAUqD,OAAOrI,OAAOjS,EAAO,GAGnCiX,EAAUR,OAAOne,KAAKuW,GACtBoI,EAAUP,KAAKpe,KAAKuW,GAEpB7a,KAKZijB,EAAUsD,SAAWtD,EAAUS,KAAK3d,QAEN,IAA1Bkd,EAAUS,KAAK9gB,QAAiD,KAAjCqgB,EAAUmB,UAAU1gB,UAA2C,IAAxBkC,EAAK+V,QAAQ/Y,SACnFqgB,EAAUuD,WAAY,GAG1B5gB,EAAKwC,YAAY,uBAAwBlD,UAC7C,EAaAkhB,iBAAkB,SAASD,EAAYtL,EAAQ0B,EAAQ0G,GACnD,IACIwD,EADA7gB,EAAO3C,KAEPsL,EAAO5K,MAAM/B,UAAUmE,MAAM5F,KAAK+E,UAAW,GAEjDuhB,EAAqB7gB,EAAK4P,YAAY,6BAA8B2Q,EAAY5X,GAEhF3I,EAAKwC,YAAY,yBAA0BlD,YAGhB,IAAvBuhB,GAA0C,SAAXlK,IACR,IAAvBkK,GAA2C,SAAXlK,GAEhC0G,EAAUS,KAAKpf,KAAKuW,IAEnBA,EAAO6L,SAAWzD,EAAUqD,OAAOhiB,KAAKuW,KAEzCoI,EAAUP,KAAKpe,KAAKuW,GAEpBA,EAAO6L,SAAWzD,EAAUR,OAAOne,KAAKuW,IAG5CjV,EAAKwC,YAAY,wBAAyBlD,UAC9C,EAUA6e,cAAe,SAASd,GACpB,IAAIrd,EAAW3C,KACXghB,EAAW,GACXpJ,EAAW,KACX7X,EAAW,KACXhD,GAAY,EAMhB,GAJA4F,EAAKwC,YAAY,sBAAuBlD,WAExC+d,EAAUiB,WAAate,EAAK+V,QAExBsH,EAAUa,QAAQxH,WAAY,CAK9B,IAFA2H,EAAW,GAENjkB,EAAI,EAAIgD,EAAKigB,EAAUa,QAAQxH,WAAWtc,GAAKA,IAAK,CACrD,GAAI4F,EAAK8Y,IAAI/C,QAAQ/X,QAAQZ,GAAM,EAC/B,MAAM,IAAIkE,MAAMjF,EAAQkF,SAASwf,gCAGrC9L,EAAS,IAAI5Y,EAAQyiB,QAEdzN,KAAKjU,EAAI4C,GAEhBiV,EAAO8J,SAAU,EAEjBV,EAAS3f,KAAKuW,EAClB,CAEAoI,EAAUgB,SAAWA,CACzB,KAAuC,WAA5BhB,EAAUa,QAAQnH,MAGzBsG,EAAUgB,SAAW/hB,EAAEyL,aAAasV,EAAUiB,YACP,KAAhCjB,EAAUa,QAAQpH,WAGzBuG,EAAUgB,SAAWre,EAAK6b,UAAU1b,QAEJ,SAA5Bkd,EAAUa,QAAQnH,OAClBsG,EAAUgB,SAAS2C,YAKvB3D,EAAUgB,SAAWhB,EAAUiB,WAAWne,QAE1Ckd,EAAUgB,SAASvJ,MAAK,SAASlN,EAAGC,GAChC,OAAO7H,EAAKihB,QAAQrZ,EAAGC,EAAGwV,EAAUa,QACxC,KAGA5hB,EAAEqL,aAAa0V,EAAUgB,SAAUhB,EAAUiB,cAC7CjB,EAAU6D,UAAW,GAGzBlhB,EAAKwC,YAAY,qBAAsBlD,UAC3C,EAYA2hB,QAAS,SAASrZ,EAAGC,EAAG8Q,GACpB,IAAI3Y,EAAc3C,KACd0Z,EAAc4B,EAAQ5B,MACtBoK,EAAcnhB,EAAKohB,kBAAkBxZ,EAAG+Q,EAAQ7B,WAChDuK,EAAcrhB,EAAKohB,kBAAkBvZ,EAAG8Q,EAAQ7B,WAUpD,OARIwK,MAAc,EAARH,IAAcG,MAAc,EAARD,IAC1BF,EAAQA,EAAM5a,cACd8a,EAAQA,EAAM9a,gBAEd4a,GAAgB,EAChBE,GAAgB,GAGhBF,EAAQE,EACS,QAAVtK,GAAmB,EAAI,EAG9BoK,EAAQE,EACS,QAAVtK,EAAkB,GAAK,EAG9BoK,IAAUE,GAAS1I,EAAQ3B,KACpBhX,EAAKihB,QAAQrZ,EAAGC,EAAG8Q,EAAQ3B,MAG/B,CACX,EAcAoK,kBAAmB,SAASnM,EAAQ6B,GAChC,IACIzb,EAiBJ,OAbc,QAFdA,EAAQ4Z,EAAO6D,IAAI1b,GAAG0a,aAAa,QAAUhB,KAH/BzZ,KAMDuD,OAAOgB,MAAMC,cAIlBC,QAAQC,KAAK1F,EAAQkF,SAASggB,qCAAqC,CAC/DzK,UAAW,QAAUA,KAXnBzZ,KAkBFuS,YAAY,yBAA0BvU,GAAS,EAAGiE,UAClE,EAeA8e,UAAW,SAASoD,EAAanE,GAC7B,IAKIoE,EALAzhB,EAAc3C,KACdihB,EAAckD,EAAcnE,EAAUgB,SAAWhB,EAAUiB,WAC3DD,EAAcmD,EAAcnE,EAAUiB,WAAajB,EAAUgB,SAC7D/gB,EAAcghB,EAAWthB,OAASshB,EAAWA,EAAWthB,OAAS,GAAG8b,IAAI1b,GAAGF,mBAAqB,KAChG8J,EAAc5K,EAAOU,SAASoK,yBAE9B+N,EAAc,KACd7X,EAAc,KACdhD,GAAe,EAMnB,IAJA4F,EAAKwC,YAAY,kBAAmBlD,WAI/BlF,EAAI,EAAG6a,EAASqJ,EAAWlkB,GAAIA,IAGN,cAF1BgD,EAAK6X,EAAO6D,IAAI1b,IAETuP,MAAM5D,WAEbzM,EAAEgL,iBAAiBlK,EAAGqK,iBAEtBrK,EAAGa,cAAcyJ,YAAYtK,IASjC,KANAqkB,EAAankB,EAAcA,EAAYmK,gBAAkBzH,EAAK8Y,IAAIjO,OAAO6W,YAE/B,UAAxBD,EAAW3a,UACzBxK,EAAEgL,iBAAiBma,GAGlBrnB,EAAI,EAAG6a,EAASoJ,EAASjkB,GAAIA,IAG9BgD,EAAK6X,EAAO6D,IAAI1b,GAEZd,EAAE+E,UAAU2F,EAAK0a,YACjB1a,EAAKK,YAAYjL,EAAOU,SAASujB,eAAe,MAGpDrZ,EAAKK,YAAYjK,GAMjB4C,EAAK8Y,IAAIjO,OAAOzD,YAAcpH,EAAK8Y,IAAIjO,OAAOzD,aAAe9J,GAC7D0J,EAAKsZ,aAAalkB,EAAOU,SAASujB,eAAe,KAAMrZ,EAAK2a,WAAW,IAGvErkB,GACA0J,EAAKK,YAAYjL,EAAOU,SAASujB,eAAe,MAEhDrgB,EAAK8Y,IAAIjO,OAAOyV,aAAatZ,EAAM1J,IAEnC0C,EAAK8Y,IAAIjO,OAAOxD,YAAYL,GAGhChH,EAAKwC,YAAY,iBAAkBlD,UACvC,EAaAsiB,gBAAiB,SAAS/K,EAAY8B,GAClC,IACIkJ,EAAchL,EAAWzI,MAAM,KAC/BkB,EAAcqJ,EACdmJ,EAAc,GACd1nB,GAAe,EAInB,IAAKA,EAAI,EAAGA,EAAIynB,EAAM7kB,OAAQ5C,IAAK,CAO/B,OANA0nB,EAAOD,EAAMznB,GAAGgU,MAAM,KAEtBkB,EAAQuH,WAAcgL,EAAMznB,GAC5BkV,EAAQwH,UAAcxa,EAAEqK,SAASmb,EAAK,IACtCxS,EAAQyH,MAAc+K,EAAK,IAAM,MAEzBxS,EAAQwH,WACZ,IAAK,UAGDxH,EAAQwH,UAAY,GAEpB,MACJ,IAAK,SAGDxH,EAAQwH,UAAc,GACtBxH,EAAQyH,MAAc,SAK9B,IAAKzH,EAAQwH,WAA+B,WAAlBxH,EAAQyH,MAAoB,MAElD3c,EAAIynB,EAAM7kB,OAAS,IAGnBsS,EAAQ0H,KAAO,IAAI3a,EAAQua,YAE3Bta,EAAEyR,OAAOuB,GAETA,EAAUA,EAAQ0H,KAE1B,CAEA,OA5CkB3Z,KA4CNuS,YAAY,oBAAqB+I,EAASrZ,UAC1D,EAYA8d,aAAc,WACV,IAAIpd,EAAkB3C,KAClB0kB,EAAkB,GAClBnQ,EAAkB5R,EAAKY,OAAOyU,UAAUzD,WAAa5R,EAAKY,OAAOyU,UAAU1D,QAC3EE,EAAkB7R,EAAKY,OAAOyU,UAAUxD,YAAc7R,EAAKY,OAAOyU,UAAU1D,QAchF,IAAKoQ,KAZL/hB,EAAKwC,YAAY,qBAAsBlD,WAEvCU,EAAK4R,UAAiB,IAAIvV,EAAQwd,UAClC7Z,EAAK6R,WAAiB,IAAIxV,EAAQwd,UAClC7Z,EAAKoc,YAAiB,GACtBpc,EAAKqc,aAAiB,GAEtBrc,EAAK4R,UAAU/D,QAAU7N,EAAK6R,WAAWhE,QAAU,EAEnD7N,EAAKgiB,YAAY,OAAQpQ,EAAW5R,EAAK4R,UAAW5R,EAAKoc,aACzDpc,EAAKgiB,YAAY,OAAQnQ,EAAY7R,EAAK6R,WAAY7R,EAAKqc,cAAc,GAEnDhgB,EAAQue,kBACpBve,EAAQue,kBAAkBmH,aAA0B1lB,EAAQ8d,gBAIlEna,EAAKgiB,YAAYD,EAAenQ,EAAW5R,EAAK4R,UAAW5R,EAAKoc,aAChEpc,EAAKgiB,YAAYD,EAAelQ,EAAY7R,EAAK6R,WAAY7R,EAAKqc,cAAc,IAGpFrc,EAAKgiB,YAAY,UAAWpQ,EAAW5R,EAAK4R,UAAW5R,EAAKoc,aAC5Dpc,EAAKgiB,YAAY,UAAWnQ,EAAY7R,EAAK6R,WAAY7R,EAAKqc,cAAc,GAE5Erc,EAAKwC,YAAY,oBAAqBlD,UAC1C,EAaA0iB,YAAa,SAASC,EAAYC,EAAcvQ,EAASwQ,EAAWC,GAChE,IAEIC,EAFAriB,EAAc3C,KAGdoH,EAAc,GAEd6d,EAAc,GACdC,EAAc,CAAC,IAAK,KAAM,KAAM,MAAO,KAAM,KAAM,OACnD7H,EAAc,GACdtgB,GAAe,EAInB,GAFA4F,EAAKwC,YAAY,oBAAqBlD,WAEV,iBAAjB4iB,EACP,MAAM,IAAIzjB,UAAUpC,EAAQkF,SAASihB,sCAGzC,GAAIN,EAAalkB,QAAQikB,GAAc,EAGhB,YAAfA,IAGAjiB,EAAKmc,gBAAkB,OAN/B,CA8BA,QAhBAkG,EAAYH,EAAalkB,QAAQikB,EAAa,OAE7B,IAKbxd,EAAMyd,EAAaO,UAAUJ,GAM7BC,EA1Cc,cAwCHle,KAAKK,GAEJ,IAGRwd,GACJ,IAAK,OACDtQ,EAAQ9D,QAAUyU,EAAMI,WAAWJ,GAAO,EAE1C,MACJ,IAAK,UACDtiB,EAAKmc,gBAAkBmG,EAAMI,WAAWJ,GAAO,IAM/C,MACJ,QAWI,GARIF,GAASpiB,EAAKY,OAAOyU,UAAU7C,YAA6B,UAAfyP,EAC7CtQ,EAAQsQ,GAAY5mB,OACyD,GAAxEinB,EAAMI,WAAWJ,GAAOjmB,EAAQue,kBAAkBqH,GAAY5mB,OAEnEsW,EAAQsQ,GAAY5mB,MACfinB,EAAMI,WAAWJ,GAAOjmB,EAAQue,kBAAkBqH,GAAY5mB,MAGnEinB,GACA,IAAKloB,EAAI,EAAGsgB,EAAO6H,EAAMnoB,GAAIA,IACzB,GAAIkoB,EAAItkB,QAAQ0c,IAAS,EAAG,CACxB/I,EAAQsQ,GAAYvH,KAAOA,EAE3B,KACJ,OAGJ/I,EAAQsQ,GAAYvH,KAAOre,EAAQue,kBAAkBqH,GAAYvH,KAGrEyH,EAAUzjB,KACNujB,EACA,IACAtQ,EAAQsQ,GAAY5mB,MACpBsW,EAAQsQ,GAAYvH,KACpB,KAIZ1a,EAAKwC,YAAY,mBAAoBlD,UAjErC,CAkEJ,EAUAqf,WAAY,SAAStB,GACjB,IAAIrd,EAAc3C,KACd6b,EAAc,IAAI7c,EAAQif,MAC1BrG,EAAc,KACd7a,GAAe,EAOnB,IALA4F,EAAKwC,YAAY,mBAAoBlD,WAKhClF,EAAI,EAAG6a,EAASjV,EAAK+V,QAAQ3b,GAAIA,MAC7BijB,EAAUoD,SAASzjB,QAAUqgB,EAAUoD,SAASziB,QAAQiX,GAAU,IACnEiE,EAAMnD,QAAQrX,KAAKuW,EAAO6D,IAAI1b,IAItC,IAAKhD,EAAI,EAAG6a,EAASoI,EAAUsD,SAASvmB,GAAIA,IACxC8e,EAAMyH,SAASjiB,KAAKuW,EAAO6D,IAAI1b,IAGnC,IAAKhD,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpC8e,EAAM4E,KAAKpf,KAAKuW,EAAO6D,IAAI1b,IAG/B,IAAKhD,EAAI,EAAG6a,EAASoI,EAAUP,KAAK1iB,GAAIA,MAC/BijB,EAAUoD,SAASzjB,QAAUqgB,EAAUoD,SAASziB,QAAQiX,GAAU,IACnEiE,EAAM4D,KAAKpe,KAAKuW,EAAO6D,IAAI1b,IAiBnC,OAbA8b,EAAM/X,GAA4BnB,EAAKmB,GACvC+X,EAAMvY,UAA4BX,EAAK8Y,IAAInY,UAC3CuY,EAAMgE,aAA4BG,EAAUmB,UAC5CtF,EAAMiE,WAA4BE,EAAUa,QAC5ChF,EAAMyE,cAA4BN,EAAUK,WAC5CxE,EAAMqE,yBAA4BF,EAAUQ,sBAC5C3E,EAAM0H,UAA4BvD,EAAUuD,UAC5C1H,EAAM+E,aAA4Bje,EAAK+V,QAAQ/Y,OAC/Ckc,EAAMyJ,UAA4BtF,EAAUS,KAAK9gB,OACjDkc,EAAM0J,UAA4BvF,EAAUP,KAAK9f,OACjDkc,EAAM2J,cAA4BxF,EAAUsD,SAAS3jB,OACrDkc,EAAMuC,eAA4B4B,EAAU5B,eAErCzb,EAAK4P,YAAY,kBAAmBsJ,EAAO5Z,UACtD,EAWAwjB,MAAO,SAASC,EAAe1F,GAC3B,IAAIrd,EAAc3C,KACdmO,EAAc,KAiElB,OA/DAxL,EAAKwC,YAAY,cAAelD,WAQ3BU,EAAKY,OAAOyU,UAAUvD,UAAa9R,EAAKY,OAAOyU,UAAU1D,SAAYrV,EAAEmR,UAAUzN,EAAK8Y,IAAInY,aAE3FoiB,GAAgB,GAIf1F,EAAUqD,OAAO1jB,QACjBqgB,EAAUR,OAAO7f,QACjBqgB,EAAU6D,UACV7D,EAAU2F,mBAKXD,GAAgB,GAIf1F,EAAU4F,WAAWnF,KAAK9gB,QAC1BqgB,EAAUS,KAAK9gB,SAIhB+lB,GAAgB,GAGpB1mB,EAAQ2c,OAAOC,KAAK,WAAYjZ,EAAK8Y,IAAInY,UAAW,CAChDuY,MAAOmE,EAAU4F,WACjBnI,YAAauC,EAAU6F,SACvBniB,SAAUf,GACXA,EAAK8Y,IAAIhc,UAEoC,mBAArCkD,EAAKY,OAAO2U,UAAUxC,YAC7B/S,EAAKY,OAAO2U,UAAUxC,WAAWxY,KAC7ByF,EAAK8Y,IAAInY,UACT0c,EAAU4F,WACV5F,EAAU6F,SACVljB,GAIR1D,EAAEgH,YAAYtD,EAAK8Y,IAAInY,UAAWrE,EAAEoS,aAAa1O,EAAKY,OAAO+N,WAAY,YAAa3O,EAAKY,OAAO+N,WAAWsF,iBASzGzI,EAPCxL,EAAKwc,aAOKxc,EAAKwc,aAJLxc,EAAKwc,aAAelgB,EAAEiP,MAAMlP,EAAQyG,WAOnD9C,EAAK2b,QAAS,EAEToH,GAAkB1mB,EAAQsP,SAASC,IAAI4F,aAgBxCpV,EAAO0Q,cAAgBuQ,EAAU8F,SAAS9Z,WAC1CjN,EAAOgnB,SAAS/F,EAAU8F,SAAS/Z,WAAYiU,EAAU8F,SAAS9Z,WAGlErJ,EAAKY,OAAOyU,UAAUrD,mBACtBhS,EAAK8Y,IAAIjO,OAAO8B,MAAMtQ,EAAQsP,SAASiF,iBACnC5Q,EAAKY,OAAOyU,UAAUpD,oBAE1BjS,EAAK8Y,IAAIjO,OAAO8B,MAAMtQ,EAAQsP,SAASkF,uBACnC7Q,EAAKY,OAAOyU,UAAUnD,mBAI1BlS,EAAKY,OAAOyU,UAAUhD,wBACtBgL,EAAUgG,cAAgBhG,EAAUiG,WACpCjG,EAAUkG,iBAAmBlG,EAAUgG,YAAchG,EAAUiG,YAE/DtjB,EAAK8Y,IAAIjO,OAAO8B,MAAMpC,OAAS8S,EAAUgG,YAAc,MAIvDrjB,EAAKY,OAAOyU,UAAUhD,wBACtBgL,EAAUmG,aAAenG,EAAUoG,UACnCpG,EAAUqG,iBAAmBrG,EAAUmG,WAAanG,EAAUoG,WAE9DzjB,EAAK8Y,IAAIjO,OAAO8B,MAAMrC,MAAQ+S,EAAUmG,WAAa,MAGrDnG,EAAUgG,cAAgBhG,EAAUiG,YACpCtjB,EAAK8Y,IAAIjO,OAAO8B,MAAMpC,OAAS8S,EAAUgG,YAAc,MAGvDhG,EAAUmG,aAAenG,EAAUoG,WACnCzjB,EAAK8Y,IAAIjO,OAAO8B,MAAMrC,MAAQ+S,EAAUmG,WAAa,MAGrDnG,EAAUgG,cAAgBhG,EAAUiG,WAAajG,EAAUmG,aAAenG,EAAUoG,WACpFzjB,EAAK8Y,IAAIjO,OAAO8B,MAAMgX,SAAW,UAGrC1mB,uBAAsB,WAClB+C,EAAK4jB,YAAYvG,EACrB,IAEOrd,EAAK4P,YAAY,eAAgBpE,EAASM,QAASxM,aAzDlDU,EAAKY,OAAOgB,MAAM0S,UAClBxL,YAAW,WACP9I,EAAK6jB,QAAQxG,EACjB,GAAGrd,EAAKY,OAAOyU,UAAUvD,UAEzB9R,EAAK6jB,QAAQxG,GAGVrd,EAAK4P,YAAY,eAAgBpE,EAASM,QAASxM,WAkDlE,EAUAwkB,gBAAiB,SAASzG,GACtB,IAAIrd,EAAc3C,KACd0mB,EAAc3nB,EAAOuR,iBAAiB3N,EAAK8Y,IAAIjO,QAC/CmZ,EAAchkB,EAAK8Y,IAAIjO,OAAOoZ,wBAC9BhP,EAAc,KACdrQ,EAAc,CAAC,EACfxK,GAAe,EACf8pB,EAAcH,EAAY1nB,EAAQsP,SAAS8F,eAM/C,IAJAzR,EAAK4b,WAA4B,eAAdsI,EAEnBlkB,EAAKwC,YAAY,wBAAyBlD,WAErClF,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpCwK,EAAOqQ,EAAOkP,aAEd9G,EAAU+G,YAAYhqB,GAAK,CACvBiqB,aAAczf,GAItB,IAAKxK,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtCwK,EAAOqQ,EAAOkP,aAEd9G,EAAUiH,cAAclqB,GAAK,CACzBiqB,aAAczf,GAItByY,EAAUkH,OAASP,EAAWvZ,KAC9B4S,EAAUmH,OAASR,EAAWtZ,IAE9B2S,EAAUgG,YAAcrjB,EAAK4b,WACzBoI,EAAWzZ,OACXyZ,EAAWzZ,OACPmY,WAAWqB,EAAYU,YACvB/B,WAAWqB,EAAYW,eACvBhC,WAAWqB,EAAYY,WACvBjC,WAAWqB,EAAYa,cAE/BvH,EAAUmG,WAAaxjB,EAAK4b,WACxBoI,EAAW1Z,MACX0Z,EAAW1Z,MACPoY,WAAWqB,EAAYc,aACvBnC,WAAWqB,EAAYe,cACvBpC,WAAWqB,EAAYgB,YACvBrC,WAAWqB,EAAYiB,aAE/BhlB,EAAKwC,YAAY,uBAAwBlD,UAC7C,EAUA2lB,SAAU,SAAS5H,GACf,IAAIrd,EAAU3C,KACV4X,EAAU,KACV7a,GAAW,EAgBf,IAdA4F,EAAKwC,YAAY,iBAAkBlD,WAI/BU,EAAKY,OAAOyU,UAAU3C,cACtB1S,EAAK8Y,IAAIjO,OAAO8B,MAAMpC,OAAY8S,EAAUgG,YAAc,KAC1DrjB,EAAK8Y,IAAIjO,OAAO8B,MAAMgX,SAAY,UAGlC3jB,EAAKY,OAAOyU,UAAU1C,aACtB3S,EAAK8Y,IAAIjO,OAAO8B,MAAMrC,MAAY+S,EAAUmG,WAAa,KACzDxjB,EAAK8Y,IAAIjO,OAAO8B,MAAMgX,SAAY,UAGjCvpB,EAAI,EAAG6a,EAASoI,EAAUqD,OAAOtmB,GAAIA,IACtC6a,EAAO6I,OAGPT,EAAU2F,mBACV1mB,EAAEgH,YAAYtD,EAAK8Y,IAAInY,UAAW0c,EAAUO,yBAC5CthB,EAAE+G,SAASrD,EAAK8Y,IAAInY,UAAW0c,EAAUQ,wBAG7C7d,EAAKwC,YAAY,gBAAiBlD,UACtC,EAUA4lB,gBAAiB,SAAS7H,GACtB,IACIpI,EAAU,KACV7a,GAAW,EAIf,IANciD,KAITmF,YAAY,wBAAyBlD,WAErClF,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpCijB,EAAU+G,YAAYhqB,GAAG+qB,aAAelQ,EAAOkP,aAGnD,IAAK/pB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtCijB,EAAUiH,cAAclqB,GAAG+qB,aAAelQ,EAAOkP,aAXvC9mB,KAcTmF,YAAY,uBAAwBlD,UAC7C,EAUA8lB,SAAU,SAAS/H,GACf,IAAIrd,EAAU3C,KACV4X,EAAU,KACV7a,GAAW,EAMf,IAJA4F,EAAKwC,YAAY,iBAAkBlD,WAEnC+d,EAAU6D,UAAYlhB,EAAKoe,WAAU,EAAOf,GAEvCjjB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtC6a,EAAO6H,OAGX9c,EAAKwC,YAAY,gBAAiBlD,UACtC,EAUA+lB,gBAAiB,SAAShI,GACtB,IAEI2G,EAFAhkB,EAAc3C,KACd0mB,EAAc,KAEd9O,EAAc,KACd7a,GAAe,EAInB,IAFA4F,EAAKwC,YAAY,wBAAyBlD,WAErClF,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpCijB,EAAU+G,YAAYhqB,GAAGkrB,aAAerQ,EAAOkP,aAGnD,IAAK/pB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtCijB,EAAUiH,cAAclqB,GAAGkrB,aAAerQ,EAAOkP,aA2CrD,KAtCInkB,EAAKY,OAAOyU,UAAU3C,aAAe1S,EAAKY,OAAOyU,UAAU1C,cAC3D3S,EAAK8Y,IAAIjO,OAAO8B,MAAMpC,OACtBvK,EAAK8Y,IAAIjO,OAAO8B,MAAMrC,MACtBtK,EAAK8Y,IAAIjO,OAAO8B,MAAMgX,SAAY,IAGjC3jB,EAAK4b,aACNmI,EAAc3nB,EAAOuR,iBAAiB3N,EAAK8Y,IAAIjO,SAGnDmZ,EAAchkB,EAAK8Y,IAAIjO,OAAOoZ,wBAE9B5G,EAAUkI,KAAOvB,EAAWvZ,KAC5B4S,EAAUmI,KAAOxB,EAAWtZ,IAE5B2S,EAAUiG,UAAYtjB,EAAK4b,WACvBoI,EAAWzZ,OACXyZ,EAAWzZ,OACPmY,WAAWqB,EAAYU,YACvB/B,WAAWqB,EAAYW,eACvBhC,WAAWqB,EAAYY,WACvBjC,WAAWqB,EAAYa,cAE/BvH,EAAUoG,SAAWzjB,EAAK4b,WACtBoI,EAAW1Z,MACX0Z,EAAW1Z,MACPoY,WAAWqB,EAAYc,aACvBnC,WAAWqB,EAAYe,cACvBpC,WAAWqB,EAAYgB,YACvBrC,WAAWqB,EAAYiB,aAE/B3H,EAAUqG,eAAiBrG,EAAU8F,SAAS5V,cAAgBlQ,KAAKyb,IAAIhc,SAASmQ,gBAAgBO,YAChG6P,EAAUkG,eAAiBlG,EAAU8F,SAAS9V,eAAiBhQ,KAAKyb,IAAIhc,SAASmQ,gBAAgBK,aAE7F+P,EAAU6D,UACVlhB,EAAKoe,WAAU,EAAMf,GAGpBjjB,EAAI,EAAG6a,EAASoI,EAAUqD,OAAOtmB,GAAIA,IACtC6a,EAAO6H,OAGX,IAAK1iB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtC6a,EAAO6I,OAGPT,EAAU2F,mBACV1mB,EAAEgH,YAAYtD,EAAK8Y,IAAInY,UAAW0c,EAAUQ,uBAC5CvhB,EAAE+G,SAASrD,EAAK8Y,IAAInY,UAAWX,EAAKY,OAAO6U,OAAOhB,qBAGtDzU,EAAKwC,YAAY,uBAAwBlD,UAC7C,EASAmmB,aAAc,SAASpI,GACnB,IAAIrd,EAAkB3C,KAClB4X,EAAkB,KAClByQ,EAAkB,KAClBC,EAAkB7qB,OAAO8qB,oBAAoB5lB,EAAK4R,WAClDqQ,EAAkB,GAClB4D,EAAkB,KAClBC,GAAmB,EACnBC,GAAmB,EACnB3rB,GAAmB,EACnB+kB,GAAmB,EAIvB,IAFAnf,EAAKwC,YAAY,qBAAsBlD,WAElClF,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IAqEpC,KApEAsrB,EAAsBrI,EAAU+G,YAAYhqB,IACpC4rB,MAAc,IAAI3pB,EAAQwd,UAClC6L,EAAQO,OAAc,IAAI5pB,EAAQwd,UAClC6L,EAAQQ,UAAc,IAAI7pB,EAAQwd,UAI9B5E,EAAO6L,SACP4E,EAAQM,MAAMxc,EAAIkc,EAAQrB,aAAa7a,EAAIkc,EAAQP,aAAa3b,EAChEkc,EAAQM,MAAMvc,EAAIic,EAAQrB,aAAa5a,EAAIic,EAAQP,aAAa1b,GAEhEic,EAAQM,MAAMxc,EAAIkc,EAAQM,MAAMvc,EAAI,EAGxCic,EAAQO,OAAOzc,EAAIkc,EAAQJ,aAAa9b,EAAIkc,EAAQP,aAAa3b,EACjEkc,EAAQO,OAAOxc,EAAIic,EAAQJ,aAAa7b,EAAIic,EAAQP,aAAa1b,EAIjEic,EAAQM,MAAMnY,QAAgBoH,EAAO6L,QAAU,EAAI9gB,EAAK4R,UAAU/D,QAClE6X,EAAQO,OAAOpY,QAAe,EAC9B6X,EAAQQ,UAAUrY,QAAY6X,EAAQO,OAAOpY,QAAU6X,EAAQM,MAAMnY,QAIhEoH,EAAO6L,SAAY9gB,EAAKY,OAAOyU,UAAU5C,QAC1CiT,EAAQM,MAAMxc,EAAIkc,EAAQO,OAAOzc,EACjCkc,EAAQM,MAAMvc,EAAIic,EAAQO,OAAOxc,GAGrCic,EAAQQ,UAAU1c,EAAIkc,EAAQO,OAAOzc,EAAIkc,EAAQM,MAAMxc,EACvDkc,EAAQQ,UAAUzc,EAAIic,EAAQO,OAAOxc,EAAIic,EAAQM,MAAMvc,EAInDzJ,EAAKY,OAAOyU,UAAU/C,uBACtBoT,EAAQM,MAAM1b,MAAYob,EAAQrB,aAAa/Z,MAC/Cob,EAAQM,MAAMzb,OAAYmb,EAAQrB,aAAa9Z,OAI/Cub,GAAeJ,EAAQrB,aAAa/Z,OAASob,EAAQJ,aAAahb,OAASob,EAAQP,aAAa7a,MAEhGob,EAAQM,MAAMhM,YAAc0L,EAAQrB,aAAarK,YAAc8L,EAE/DC,GAAgBL,EAAQrB,aAAa9Z,QAAUmb,EAAQJ,aAAa/a,QAAUmb,EAAQP,aAAa5a,OAEnGmb,EAAQM,MAAM/L,aAAeyL,EAAQrB,aAAapK,aAAe8L,EAEjEL,EAAQO,OAAO3b,MAAWob,EAAQJ,aAAahb,MAC/Cob,EAAQO,OAAO1b,OAAWmb,EAAQJ,aAAa/a,OAE/Cub,GAAeJ,EAAQJ,aAAahb,OAASob,EAAQrB,aAAa/Z,OAASob,EAAQP,aAAa7a,MAEhGob,EAAQO,OAAOjM,YAAc0L,EAAQJ,aAAatL,YAAc8L,EAEhEC,GAAgBL,EAAQJ,aAAa/a,QAAUmb,EAAQrB,aAAa9Z,QAAUmb,EAAQP,aAAa5a,OAEnGmb,EAAQO,OAAOhM,aAAeyL,EAAQJ,aAAarL,aAAe8L,EAElEL,EAAQQ,UAAU5b,MAAgBob,EAAQO,OAAO3b,MAAQob,EAAQM,MAAM1b,MACvEob,EAAQQ,UAAU3b,OAAgBmb,EAAQO,OAAO1b,OAASmb,EAAQM,MAAMzb,OACxEmb,EAAQQ,UAAUlM,YAAgB0L,EAAQO,OAAOjM,YAAc0L,EAAQM,MAAMhM,YAC7E0L,EAAQQ,UAAUjM,aAAgByL,EAAQO,OAAOhM,aAAeyL,EAAQM,MAAM/L,cAK7EkF,EAAI,EAAG8C,EAAa0D,EAAYxG,GAAIA,KACrC0G,EAAS7lB,EAAK4R,UAAUqQ,cAEA5lB,EAAQ8d,eAAmB0L,EAAOxqB,QAE1DqqB,EAAQM,MAAM/D,GAAY5mB,MAAYwqB,EAAOxqB,MAC7CqqB,EAAQO,OAAOhE,GAAY5mB,MAAW,EAEtCqqB,EAAQQ,UAAUjE,GAAY5mB,MAC1BqqB,EAAQO,OAAOhE,GAAY5mB,MAAQqqB,EAAQM,MAAM/D,GAAY5mB,MAEjEqqB,EAAQM,MAAM/D,GAAYvH,KACtBgL,EAAQO,OAAOhE,GAAYvH,KAC3BgL,EAAQQ,UAAUjE,GAAYvH,KAC9BmL,EAAOnL,MAInB,IAAKtgB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IAsCtC,KArCAsrB,EAAsBrI,EAAUiH,cAAclqB,IACtC4rB,MAAc,IAAI3pB,EAAQwd,UAClC6L,EAAQO,OAAc,IAAI5pB,EAAQwd,UAClC6L,EAAQQ,UAAc,IAAI7pB,EAAQwd,UAIlC6L,EAAQM,MAAMxc,EAAQyL,EAAO6L,QAAU4E,EAAQrB,aAAa7a,EAAIkc,EAAQP,aAAa3b,EAAI,EACzFkc,EAAQM,MAAMvc,EAAQwL,EAAO6L,QAAU4E,EAAQrB,aAAa5a,EAAIic,EAAQP,aAAa1b,EAAI,EACzFic,EAAQO,OAAOzc,EAAOxJ,EAAKY,OAAOyU,UAAU5C,MAAQ,EAAIiT,EAAQM,MAAMxc,EACtEkc,EAAQO,OAAOxc,EAAOzJ,EAAKY,OAAOyU,UAAU5C,MAAQ,EAAIiT,EAAQM,MAAMvc,EACtEic,EAAQQ,UAAU1c,EAAIkc,EAAQO,OAAOzc,EAAIkc,EAAQM,MAAMxc,EACvDkc,EAAQQ,UAAUzc,EAAIic,EAAQO,OAAOxc,EAAIic,EAAQM,MAAMvc,EAInDzJ,EAAKY,OAAOyU,UAAU/C,uBACtBoT,EAAQM,MAAM1b,MAAgBob,EAAQrB,aAAa/Z,MACnDob,EAAQM,MAAMzb,OAAgBmb,EAAQrB,aAAa9Z,OAEnDub,EAAcJ,EAAQrB,aAAa/Z,MAAQob,EAAQP,aAAa7a,MAEhEob,EAAQM,MAAMhM,YAAc0L,EAAQrB,aAAarK,YAAc8L,EAE/DC,EAAeL,EAAQrB,aAAa9Z,OAASmb,EAAQP,aAAa5a,OAElEmb,EAAQM,MAAM/L,aAAeyL,EAAQrB,aAAapK,aAAe8L,GAKrEL,EAAQM,MAAMnY,QAAgB,EAC9B6X,EAAQO,OAAOpY,QAAe7N,EAAK6R,WAAWhE,QAC9C6X,EAAQQ,UAAUrY,QAAY6X,EAAQO,OAAOpY,QAAU6X,EAAQM,MAAMnY,QAIhEsR,EAAI,EAAG8C,EAAa0D,EAAYxG,GAAIA,KACrC0G,EAAS7lB,EAAK6R,WAAWoQ,cAED5lB,EAAQ8d,eAAmB0L,EAAOxqB,QAE1DqqB,EAAQM,MAAM/D,GAAY5mB,MAAY,EACtCqqB,EAAQO,OAAOhE,GAAY5mB,MAAWwqB,EAAOxqB,MAE7CqqB,EAAQQ,UAAUjE,GAAY5mB,MAC1BqqB,EAAQO,OAAOhE,GAAY5mB,MAAQqqB,EAAQM,MAAM/D,GAAY5mB,MAEjEqqB,EAAQM,MAAM/D,GAAYvH,KACtBgL,EAAQO,OAAOhE,GAAYvH,KAC3BgL,EAAQQ,UAAUjE,GAAYvH,KAC9BmL,EAAOnL,MAInB1a,EAAKwC,YAAY,oBAAqBlD,UAC1C,EAUAskB,YAAa,SAASvG,GAClB,IAAIrd,EAAkB3C,KAClB4X,EAAkB,KAClBkR,EAAkB,KAClBT,EAAkB,KAClBU,EAAkB,GAClBC,GAAkB,EAClBC,GAAmB,EACnBlsB,GAAmB,EACnBmsB,EAAkBvmB,EAAKumB,cAAc3qB,KAAKoE,GAO9C,IALAA,EAAKwC,YAAY,oBAAqBlD,WAKjClF,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpC+rB,EAAc,IAAI9pB,EAAQmqB,UAC1Bd,EAAcrI,EAAU+G,YAAYhqB,GAEpCgsB,EAAenR,EAAO6L,QAAU,OAAS,QAEzCuF,EAAiBrmB,EAAKqmB,eAClBD,EACA/I,EAAUoJ,UACVf,EAAQM,MACRN,EAAQO,UAMRK,IAGJrR,EAAO6I,OAEPqI,EAASH,MAAiBN,EAAQM,MAClCG,EAASF,OAAiBP,EAAQO,OAClCE,EAASC,aAAiBA,EAC1BD,EAASG,aAAiBA,EAC1BH,EAAS9I,UAAiBA,EAC1B8I,EAASO,SAAiBL,EAAiBE,EAAgB,KAE3DtR,EAAO0R,KAAKR,GAGhB,IAAK/rB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtCsrB,EAAWrI,EAAUiH,cAAclqB,GACnC+rB,EAAW,IAAI9pB,EAAQmqB,UAEvBJ,EAAe,OAEfC,EAAiBrmB,EAAKqmB,eAAeD,EAAcV,EAAQM,MAAON,EAAQO,QAE1EE,EAASH,MAAiBN,EAAQM,MAClCG,EAASF,OAAiBP,EAAQO,OAClCE,EAASC,aAAiBA,EAC1BD,EAASG,aAAiBlsB,EAC1B+rB,EAAS9I,UAAiBA,EAC1B8I,EAASO,SAAiBL,EAAiBE,EAAgB,KAE3DtR,EAAO0R,KAAKR,GAGZnmB,EAAKY,OAAOyU,UAAUhD,yBACtBrS,EAAK8Y,IAAIjO,OAAO8B,MAAMtQ,EAAQsP,SAASgF,gBACnC,UAAY3Q,EAAKY,OAAOyU,UAAUvD,SAAlC,kBACW9R,EAAKY,OAAOyU,UAAUvD,SAAW,WAEhD7U,uBAAsB,WAEdogB,EAAUgG,cAAgBhG,EAAUiG,WACpCjG,EAAUkG,iBAAmBlG,EAAUgG,YAAchG,EAAUiG,YAE/DtjB,EAAK8Y,IAAIjO,OAAO8B,MAAMpC,OAAS8S,EAAUiG,UAAY,MAIrDjG,EAAUmG,aAAenG,EAAUoG,UACnCpG,EAAUqG,iBAAmBrG,EAAUmG,WAAanG,EAAUoG,WAE9DzjB,EAAK8Y,IAAIjO,OAAO8B,MAAMrC,MAAQ+S,EAAUoG,SAAW,KAE3D,KAGApG,EAAU2F,mBACV1mB,EAAEgH,YAAYtD,EAAK8Y,IAAInY,UAAWX,EAAKY,OAAO6U,OAAOmR,oBACrDtqB,EAAE+G,SAASrD,EAAK8Y,IAAInY,UAAW0c,EAAUQ,wBAG7C7d,EAAKwC,YAAY,mBAAoBlD,UACzC,EAQAmnB,UAAW,WACP,IAAIzmB,EAAc3C,KACdwpB,EAAc,CACV,QACA,aAAc,aAAc,aAC5B,UAAW,UAAW,WAE1B5E,EAAc,GACd4D,EAAc,KACdtnB,GAAc,EAEdnE,GAAe,EAEnB,GAA+B,IAA3B4F,EAAK4R,UAAU/D,QACf,OAAO7N,EAAK4P,YAAY,mBAAmB,EAAMtQ,WAGrD,IAAKlF,EAAI,EAAG6nB,EAAa4E,EAAYzsB,GAAIA,IAKrC,GAAc,KAH+B,eAD7CyrB,EAAU7lB,EAAK4R,UAAUqQ,IACU5mB,MAC/BwqB,EAAOxqB,MAAQwqB,GAEF,CACbtnB,GAAS,EAET,KACJ,CAGJ,OAAOyB,EAAK4P,YAAY,kBAAmBrR,EAAQe,UACvD,EAiBA+mB,eAAgB,SAASD,EAAcK,EAAWT,EAAOC,GACrD,IAAIjmB,EAAU3C,KACVkB,GAAU,EA4Bd,OAdIA,IAZCjC,EAAEmR,UAAUzN,EAAK8Y,IAAInY,gBAMJ,SAAjBylB,GAA2BK,GAC5BT,EAAMxc,IAAMyc,EAAOzc,GACnBwc,EAAMvc,IAAMwc,EAAOxc,MAKZzJ,EAAKY,OAAOyU,UAAU/C,uBAIzB0T,EAAM1b,QAAU2b,EAAO3b,OACvB0b,EAAMzb,SAAW0b,EAAO1b,QACxByb,EAAMhM,cAAgBiM,EAAOjM,aAC7BgM,EAAMc,YAAcb,EAAOa,YAM5B9mB,EAAK4P,YAAY,uBAAwBrR,EAAQe,UAC5D,EAUAinB,cAAe,SAASlJ,GACpB,IAAIrd,EAAO3C,KAEX2C,EAAKkc,cAEDlc,EAAKic,eAAiBjc,EAAKkc,aAC3Blc,EAAK6jB,QAAQxG,EAErB,EAUAwG,QAAS,SAASxG,GACd,IAAIrd,EAAsB3C,KACtB4X,EAAsB,KACtB8R,EAAsB,KACtBC,EAAsB,KACtBC,EAAsB,KACtB7sB,GAAuB,EAS3B,IAPA4F,EAAKwC,YAAY,gBAAiBlD,WAElCU,EAAK+b,aACD/b,EAAKgc,iBACLhc,EAAKic,aACLjc,EAAKkc,YAAoB,EAExB9hB,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpC6a,EAAO4O,UAEP5O,EAAO6I,OAGX,IAAK1jB,EAAI,EAAG6a,EAASoI,EAAUR,OAAOziB,GAAIA,IACtC6a,EAAO4O,UAEP5O,EAAO6H,OAqBX,GAlBIO,EAAU6D,UACVlhB,EAAKoe,WAAU,EAAOf,GAK1Brd,EAAK8Y,IAAIjO,OAAO8B,MAAMtQ,EAAQsP,SAASgF,gBACnC3Q,EAAK8Y,IAAIjO,OAAO8B,MAAMpC,OACtBvK,EAAK8Y,IAAIjO,OAAO8B,MAAMrC,MACtBtK,EAAK8Y,IAAIjO,OAAO8B,MAAMgX,SACtB3jB,EAAK8Y,IAAIjO,OAAO8B,MAAMtQ,EAAQsP,SAASiF,iBACvC5Q,EAAK8Y,IAAIjO,OAAO8B,MAAMtQ,EAAQsP,SAASkF,uBAA0B,GAEjEwM,EAAU2F,mBACV1mB,EAAEgH,YAAYtD,EAAK8Y,IAAInY,UAAW0c,EAAUO,yBAC5CthB,EAAE+G,SAASrD,EAAK8Y,IAAInY,UAAW0c,EAAUQ,wBAGzCR,EAAUoD,SAASzjB,OAAQ,CAC3B,IAAK5C,EAAI,EAAG6a,EAASjV,EAAK+V,QAAQ3b,GAAIA,IAC9BijB,EAAUoD,SAASziB,QAAQiX,IAAW,KAEjC8R,EAAmB9R,EAAO6D,IAAI1b,GAAGqK,kBAAkD,UAA9Bsf,EAAiBjgB,WACtEkgB,EAAkB/R,EAAO6D,IAAI1b,GAAGE,cAA6C,UAA7B0pB,EAAgBlgB,UAEjExK,EAAEgL,iBAAiByf,GAGlB1J,EAAU6D,UAGXlhB,EAAK8Y,IAAIjO,OAAOnD,YAAYuN,EAAO6D,IAAI1b,IAG3C4C,EAAK+V,QAAQsC,OAAOje,EAAG,GAEvB6a,EAAO8J,SAAU,EAEjB3kB,KAMR4F,EAAK6b,UAAY7b,EAAK+V,OAC1B,CAEIsH,EAAU6D,WACVlhB,EAAK+V,QAAUsH,EAAUgB,UAG7Bre,EAAKkZ,MAAQmE,EAAU6F,SACvBljB,EAAKsc,cAAgBe,EAErBrd,EAAK8Y,IAAI/C,QAAU/V,EAAKkZ,MAAMnD,QAI9B1Z,EAAQ2c,OAAOC,KAAK,SAAUjZ,EAAK8Y,IAAInY,UAAW,CAC9CuY,MAAOlZ,EAAKkZ,MACZnY,SAAUf,GACXA,EAAK8Y,IAAIhc,UAEkC,mBAAnCkD,EAAKY,OAAO2U,UAAUtC,UAC7BjT,EAAKY,OAAO2U,UAAUtC,SAAS1Y,KAAKyF,EAAK8Y,IAAInY,UAAWX,EAAKkZ,MAAOlZ,GAGpEqd,EAAUuD,YAGVvkB,EAAQ2c,OAAOC,KAAK,UAAWjZ,EAAK8Y,IAAInY,UAAW,CAC/CuY,MAAOlZ,EAAKkZ,MACZnY,SAAUf,GACXA,EAAK8Y,IAAIhc,UAEmC,mBAApCkD,EAAKY,OAAO2U,UAAUrC,WAC7BlT,EAAKY,OAAO2U,UAAUrC,UAAU3Y,KAAKyF,EAAK8Y,IAAInY,UAAWX,EAAKkZ,MAAOlZ,GAGzE1D,EAAE+G,SAASrD,EAAK8Y,IAAInY,UAAWrE,EAAEoS,aAAa1O,EAAKY,OAAO+N,WAAY,YAAa3O,EAAKY,OAAO+N,WAAWsF,kBAK7E,mBAAtBjU,EAAKuc,cACZvc,EAAKuc,aAAahiB,KAAKyF,EAAK8Y,IAAInY,UAAWX,EAAKkZ,MAAOlZ,GAGlB,mBAA9BA,EAAKwc,aAAaxQ,SACzBhM,EAAKwc,aAAaxQ,QAAQhM,EAAKkZ,OAGnClZ,EAAKuc,aAAgB,KACrBvc,EAAKwc,aAAgB,KACrBxc,EAAK+Y,YAAgB,KACrB/Y,EAAK0b,YAAgB,EACrB1b,EAAK2b,QAAgB,EAEjB3b,EAAKmS,MAAMnV,SACXgD,EAAKwC,YAAY,yBAA0BlD,WAE3C2nB,EAAcjnB,EAAKmS,MAAM2N,QAIzB9f,EAAKwc,aAAgByK,EAAYzb,SACjCxL,EAAK0b,WAAgBuL,EAAYvL,WACjC1b,EAAK+Y,YAAgBkO,EAAYxL,eAE7BwL,EAAYzL,YAAY7C,mBAAmBtc,EAAQga,gBACnDrW,EAAKsZ,SAASlZ,MAAMJ,EAAMinB,EAAYte,MAEtC3I,EAAK+U,QAAQ3U,MAAMJ,EAAMinB,EAAYte,OAI7C3I,EAAKwC,YAAY,eAAgBlD,UACrC,EAUA4nB,kBAAmB,SAASve,GACxB,IAAI3I,EAAc3C,KACdme,EAAc,IAAInf,EAAQ8qB,gBAC1BvoB,EAAc,KACdxE,GAAe,EAKnB,IAHAohB,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQga,gBAE7Bjc,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGb,QAFZwE,EAAM+J,EAAKvO,MAIQ,iBAARwE,EACPtC,EAAEkH,OAAOgY,EAAY7C,QAAS/Z,GACR,kBAARA,EACd4c,EAAY4L,QAAUxoB,EACA,mBAARA,IACd4c,EAAYkL,SAAW9nB,IA8B/B,OAxBI4c,EAAY7C,QAAQrC,QAAYkF,EAAY7C,QAAQrC,kBAAkBja,EAAQ4a,gBAC9EuE,EAAY7C,QAAQrC,OAAStW,EAAKqnB,gBAAgB,CAAC7L,EAAY7C,QAAQrC,SAASqC,UAGhF6C,EAAY7C,QAAQpC,QAAYiF,EAAY7C,QAAQpC,kBAAkBla,EAAQ8a,gBAC9EqE,EAAY7C,QAAQpC,OAASvW,EAAKsnB,gBAAgB,CAAC9L,EAAY7C,QAAQpC,SAASoC,UAGhF6C,EAAY7C,QAAQ9D,QAAY2G,EAAY7C,QAAQ9D,kBAAkBxY,EAAQoa,gBAC9E+E,EAAY7C,QAAQ9D,OAAS7U,EAAK+d,gBAAgB,CAACvC,EAAY7C,QAAQ9D,SAAS8D,UAGhF6C,EAAY7C,QAAQ7D,MAAU0G,EAAY7C,QAAQ7D,gBAAgBzY,EAAQua,cAC1E4E,EAAY7C,QAAQ7D,KAAO9U,EAAKge,cAAc,CAACxC,EAAY7C,QAAQ7D,OAAO6D,UAG1E6C,EAAY7C,QAAQnC,cAAkBgF,EAAY7C,QAAQnC,wBAAwBna,EAAQ+a,sBAC1FoE,EAAY7C,QAAQnC,aAAexW,EAAKunB,sBAAsB,CAAC/L,EAAY7C,QAAQnC,eAAemC,SAGtG6C,EAAcxb,EAAK4P,YAAY,+BAAgC4L,EAAalc,WAE5EhD,EAAEyR,OAAOyN,GAEFA,CACX,EAUAuC,gBAAiB,SAASpV,GACtB,IAAI3I,EAAc3C,KACdme,EAAc,IAAInf,EAAQ8qB,gBAC1BvoB,EAAc,KACdxE,GAAe,EAKnB,IAHAohB,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQoa,cAE7Brc,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGN,iBAFnBwE,EAAM+J,EAAKvO,IAKPohB,EAAY7C,QAAQ7a,SAAWc,EAChB,OAARA,EACP4c,EAAY7C,QAAQjC,WAAa,GACX,iBAAR9X,GAAoBtC,EAAE+E,UAAUzC,EAAKoB,EAAK8Y,IAAIhc,UAG5D0e,EAAY7C,QAAQjC,WAAa,CAAC9X,GACZ,iBAARA,QAA0C,IAAfA,EAAI5B,OAG7Cwe,EAAY7C,QAAQjC,WAAapa,EAAE6L,cAAcvJ,GAC3B,iBAARA,EAGdtC,EAAEkH,OAAOgY,EAAY7C,QAAS/Z,GACR,kBAARA,EACd4c,EAAY4L,QAAUxoB,EACA,mBAARA,IACd4c,EAAYkL,SAAW9nB,GAI/B,GAAI4c,EAAY7C,QAAQ7a,UAAY0d,EAAY7C,QAAQjC,WACpD,MAAM,IAAIpV,MAAMjF,EAAQkF,SAASimB,+BAOrC,OAJAhM,EAAcxb,EAAK4P,YAAY,6BAA8B4L,EAAalc,WAE1EhD,EAAEyR,OAAOyN,GAEFA,CACX,EAEAwC,cAAe,SAASrV,GACpB,IAAI3I,EAAc3C,KACdme,EAAc,IAAInf,EAAQ8qB,gBAC1BvoB,EAAc,KACdiY,EAAc,GACdzc,GAAe,EAKnB,IAHAohB,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQua,YAE7Bxc,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGzB,GAAY,QAFZwE,EAAM+J,EAAKvO,IAIX,cAAewE,GACX,IAAK,SAGDiY,EAAajY,EAEb,MACJ,IAAK,SAGGA,EAAI5B,SACJwe,EAAY7C,QAAQjC,WAAapa,EAAE6L,cAAcvJ,IAGrD,MACJ,IAAK,UACD4c,EAAY4L,QAAUxoB,EAEtB,MACJ,IAAK,WACD4c,EAAYkL,SAAW9nB,EAcnC,OARIiY,IACA2E,EAAY7C,QAAU3Y,EAAK4hB,gBAAgB/K,EAAY2E,EAAY7C,UAGvE6C,EAAcxb,EAAK4P,YAAY,2BAA4B4L,EAAalc,WAExEhD,EAAEyR,OAAOyN,GAEFA,CACX,EAUA6L,gBAAiB,SAAS1e,GACtB,IAAI3I,EAAc3C,KACdme,EAAc,IAAInf,EAAQ8qB,gBAC1BvoB,EAAc,KACdxE,GAAe,EAKnB,IAHAohB,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQ4a,cAE7B7c,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGb,QAFZwE,EAAM+J,EAAKvO,MAIQ,iBAARwE,EAGP4c,EAAY7C,QAAQvS,MAAQxH,EACN,iBAARA,GAAoB,CAAC,SAAU,SAASZ,QAAQY,IAAQ,EAGtE4c,EAAY7C,QAAQ5P,SAAWnK,EACT,iBAARA,EAGd4c,EAAY7C,QAAQjC,WAChBpa,EAAE6L,cAAc7L,EAAES,cAAc6B,GAAK+iB,YACnB,iBAAR/iB,GAAoBtC,EAAE+E,UAAUzC,EAAKoB,EAAK8Y,IAAIhc,UAG3D0e,EAAY7C,QAAQjC,WAAW1Z,OAE3Bwe,EAAY7C,QAAQzB,QAAUtY,EAD9B4c,EAAY7C,QAAQjC,WAAa,CAAC9X,GAEjB,iBAARA,GAAoBA,EAAI5B,OAGrCwe,EAAY7C,QAAQjC,WAAW1Z,OAE5Bwe,EAAY7C,QAAQzB,QAAUtY,EAAI,GADjC4c,EAAY7C,QAAQjC,WAAa9X,EAEhB,iBAARA,GAAoBA,EAAI+iB,YAAc/iB,EAAI+iB,WAAW3kB,OAGlEwe,EAAY7C,QAAQjC,WAAW1Z,OAE5Bwe,EAAY7C,QAAQzB,QAAUtY,EAAI+iB,WAAW,GAD7CnG,EAAY7C,QAAQjC,WAAapa,EAAE6L,cAAcvJ,EAAI+iB,YAEnC,iBAAR/iB,EAGdtC,EAAEkH,OAAOgY,EAAY7C,QAAS/Z,GACR,kBAARA,EACd4c,EAAY4L,QAAUxoB,EACA,mBAARA,IACd4c,EAAYkL,SAAW9nB,IAI/B,GAAI4c,EAAY7C,QAAQvS,OAASoV,EAAY7C,QAAQzB,QACjD,MAAM,IAAI5V,MAAMjF,EAAQkF,SAASkmB,+BAWrC,OARKjM,EAAY7C,QAAQjC,WAAW1Z,QAAUgD,EAAKY,OAAOgB,MAAMC,cAC5DC,QAAQC,KAAK1F,EAAQkF,SAASmmB,2BAGlClM,EAAcxb,EAAK4P,YAAY,6BAA8B4L,EAAalc,WAE1EhD,EAAEyR,OAAOyN,GAEFA,CACX,EAUA8L,gBAAiB,SAAS3e,GACtB,IAAI3I,EAAc3C,KACdme,EAAc,IAAInf,EAAQ8qB,gBAC1BlS,EAAc,KACdrW,EAAc,KACdxE,GAAe,EAKnB,IAHAohB,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQ8a,cAE7B/c,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGzB,GAAY,QAFZwE,EAAM+J,EAAKvO,IAIX,cAAewE,GACX,IAAK,SACGoB,EAAK+V,QAAQnX,KACb4c,EAAY7C,QAAQ5C,QAAQ,GAAK/V,EAAK+V,QAAQnX,IAGlD,MACJ,IAAK,SACD4c,EAAY7C,QAAQjC,WAAapa,EAAE6L,cAAcnI,EAAK8Y,IAAIjO,OAAO3M,iBAAiBU,IAElF,MACJ,IAAK,SACGA,GAAOA,EAAI5B,OACXwe,EAAY7C,QAAQjC,WAAa9X,EAC1BtC,EAAE+E,UAAUzC,EAAKoB,EAAK8Y,IAAIhc,UACjC0e,EAAY7C,QAAQjC,WAAa,CAAC9X,GAIlCtC,EAAEkH,OAAOgY,EAAY7C,QAAS/Z,GAGlC,MACJ,IAAK,UACD4c,EAAY4L,QAAUxoB,EAEtB,MACJ,IAAK,WACD4c,EAAYkL,SAAW9nB,EAMnC,GAAI4c,EAAY7C,QAAQjC,WAAW1Z,OAC/B,IAAK5C,EAAI,EAAG6a,EAASjV,EAAK+V,QAAQ3b,GAAIA,IAC9BohB,EAAY7C,QAAQjC,WAAW1Y,QAAQiX,EAAO6D,IAAI1b,KAAO,GACzDoe,EAAY7C,QAAQ5C,QAAQrX,KAAKuW,GAW7C,OANKuG,EAAY7C,QAAQ5C,QAAQ/Y,QAAUgD,EAAKY,OAAOgB,MAAMC,cACzDC,QAAQC,KAAK1F,EAAQkF,SAASomB,2BAGlCrrB,EAAEyR,OAAOyN,GAEFA,CACX,EAUAoM,iBAAkB,SAASjf,GACvB,IACI6S,EAAc,IAAInf,EAAQ8qB,gBAC1BvoB,EAAc,KACdxE,GAAe,EAKnB,IAHAohB,EAAY4L,QALM/pB,KAKSuD,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQ+Z,eAE7Bhc,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGzB,GAAY,QAFZwE,EAAM+J,EAAKvO,IAIX,cAAewE,GACX,IAAK,SACGb,MAAMY,QAAQC,IAA8B,iBAAfA,EAAI5B,OACjCwe,EAAY7C,QAAQ5D,QAAUnW,EAI9BtC,EAAEkH,OAAOgY,EAAY7C,QAAS/Z,GAGlC,MACJ,IAAK,UACD4c,EAAY4L,QAAUxoB,EAEtB,MACJ,IAAK,WACD4c,EAAYkL,SAAW9nB,EAQnC,OAFAtC,EAAEyR,OAAOyN,GAEFA,CACX,EAUA+L,sBAAuB,SAAS5e,GAC5B,IACI6S,EAAc,IAAInf,EAAQ8qB,gBAC1BvoB,EAAc,KACdxE,GAAe,EAKnB,IAHAohB,EAAY4L,QALM/pB,KAKSuD,OAAOyU,UAAUlT,OAC5CqZ,EAAY7C,QAAU,IAAItc,EAAQ+a,oBAE7Bhd,EAAI,EAAGA,EAAIuO,EAAK3L,OAAQ5C,IAGzB,GAAY,QAFZwE,EAAM+J,EAAKvO,IAIX,cAAewE,GACX,IAAK,SACD4c,EAAY7C,QAAQlE,mBAAqB7V,EAEzC,MACJ,IAAK,SAGDtC,EAAEkH,OAAOgY,EAAY7C,QAAS/Z,GAE9B,MACJ,IAAK,UACD4c,EAAY4L,QAAUxoB,EAEtB,MACJ,IAAK,WACD4c,EAAYkL,SAAW9nB,EAQnC,OAFAtC,EAAEyR,OAAOyN,GAEFA,CACX,EAUAqM,SAAU,SAASC,GACf,IAAI9nB,EAAkB3C,KAClBmO,EAAkB,KAClBgU,EAAkB,GA6CtB,OA3CAxf,EAAKwC,YAAY,iBAAkBlD,WAEnCkM,EAAWlP,EAAEiP,MAAMlP,EAAQyG,WAEvB9C,EAAKY,OAAOyU,UAAUlD,OAASnS,EAAKmS,MAAMnV,OAASgD,EAAKY,OAAOyU,UAAUjD,YACzE0V,EAAUtc,SAAWA,EAErBxL,EAAKmS,MAAMzT,KAAKopB,GAIZ9nB,EAAKY,OAAO4U,SAASrT,SACjBnC,EAAK0b,YACL1b,EAAKgd,iBAAiB8K,EAAUtM,YAAY7C,SAE5C6G,EAAiBxf,EAAKsf,oBAEtBtf,EAAKid,eAAe,CAChBpI,OAAQ,CACJ/W,SAAU0hB,MAIlBxf,EAAKid,eAAe6K,EAAUtM,YAAY7C,YAI9C3Y,EAAKY,OAAOgB,MAAMC,cAClBC,QAAQC,KAAK1F,EAAQkF,SAASwmB,oCAGlCvc,EAASQ,QAAQhM,EAAKkZ,OAEtB7c,EAAQ2c,OAAOC,KAAK,UAAWjZ,EAAK8Y,IAAInY,UAAW,CAC/CuY,MAAOlZ,EAAKkZ,MACZnY,SAAUf,GACXA,EAAK8Y,IAAIhc,UAEmC,mBAApCkD,EAAKY,OAAO2U,UAAUvC,WAC7BhT,EAAKY,OAAO2U,UAAUvC,UAAUzY,KAAKyF,EAAK8Y,IAAInY,UAAWX,EAAKkZ,MAAOlZ,IAItEA,EAAK4P,YAAY,kBAAmBpE,EAASM,QAASxM,UACjE,EAUA0oB,iBAAkB,SAAStK,GACvB,IAAI1d,EAAsB3C,KACtBggB,EAAsB,IAAIhhB,EAAQihB,UAClCG,EAAsB,GAI1B,GAFAJ,EAAYrd,EAAK4P,YAAY,oCAAqCyN,EAAW/d,WAEzEU,EAAK8Y,IAAI/C,QAAQ/Y,UAAYygB,EAAgBzd,EAAKkZ,MAAMyE,eAAiB,IAAK3gB,OAC9E,MAAM,IAAIsE,MAAMjF,EAAQkF,SAAS0mB,sBAyCrC,OAtCA5K,EAAUlc,GAAgB7E,EAAEoF,YAC5B2b,EAAU4F,WAAgBjjB,EAAKkZ,MAC/BmE,EAAUI,aAAgBA,EAC1BJ,EAAUK,WAAgBA,EAAWvd,QAErCH,EAAKkoB,aAAa7K,GAElBA,EAAUiB,WAAate,EAAK+V,QAC5BsH,EAAUgB,SAAWhB,EAAUS,KAE3B9d,EAAKY,OAAOyU,UAAUlT,SACtBnC,EAAK8jB,gBAAgBzG,GACrBrd,EAAKilB,SAAS5H,GAEdA,EAAU8F,SAAW7mB,EAAEuQ,iBAAiB7M,EAAK8Y,IAAIhc,UAEjDkD,EAAKklB,gBAAgB7H,GACrBrd,EAAKolB,SAAS/H,GACdrd,EAAKqlB,gBAAgBhI,GAErBrd,EAAKod,eAELC,EAAUoJ,UAAYzmB,EAAKymB,YAE3BzmB,EAAKylB,aAAapI,IAGtBrd,EAAK+V,QAAUsH,EAAUS,KAAK3d,QAE9Bkd,EAAU6F,SAAWljB,EAAK2e,WAAWtB,GAKrCtf,MAAM/B,UAAU0C,KAAK0B,MAAMJ,EAAK+V,QAASsH,EAAUoD,UAEnDpD,EAAYrd,EAAK4P,YAAY,kCAAmCyN,EAAW/d,UAG/E,EAUA4oB,aAAc,SAAS7K,GACnB,IAAIrd,EAAsB3C,KACtB8qB,EAAsB,GACtBC,EAAsB,GACtBC,EAAsB,GACtBzjB,EAAsB,KACtBqQ,EAAsB,KACtB7X,EAAsB,KACtB4J,EAAsB,KACtBshB,EAAsB,KACtBC,EAAsB,CAAC,EACvBpnB,EAAsB,GACtB/G,GAAuB,EAI3B,IAFA4F,EAAKwC,YAAY,qBAAsBlD,WAElClF,EAAI,EAAGwK,EAAOyY,EAAUK,WAAWtjB,GAAIA,IAAK,CAC7C,QAAoD,KAAxC+G,EAAKyD,EAAK5E,EAAKY,OAAOgE,KAAKuP,UAA4BhT,EAAG/C,WAAWpB,OAAS,EACtF,MAAM,IAAIyB,UAAUpC,EAAQkF,SAASinB,0BAA0B,CAC3DrU,OAAQnU,EAAKY,OAAOgE,KAAKuP,UAIjC,GAAKoU,EAAKpnB,GAGN,MAAM,IAAIG,MAAMjF,EAAQkF,SAASknB,yBAAyB,CACtDC,IAAKvnB,KAHTonB,EAAKpnB,IAAM,GAOV8T,EAASjV,EAAK8b,MAAM3a,cAAgB9E,EAAQyiB,QAGzC9e,EAAKY,OAAOgE,KAAKwP,aAAe9X,EAAEwL,WAAWlD,EAAMqQ,EAAOrQ,QAG1DxH,EAAK6X,EAAOW,OAAOhR,GAEnBqQ,EAAOrQ,KAAOA,EAEVxH,IAAO6X,EAAO6D,IAAI1b,KAGd6X,EAAO8J,UACP9J,EAAO0T,eAEP3oB,EAAK8Y,IAAIjO,OAAO+d,aAAaxrB,EAAI6X,EAAO6D,IAAI1b,KAG3C6X,EAAO6L,UACR1jB,EAAGuP,MAAMyT,QAAU,QAGvBnL,EAAO6D,IAAI1b,GAAKA,EAEZ6X,EAAO8J,SACP9J,EAAO4T,eAKnBzrB,EAAK6X,EAAO6D,IAAI1b,MAIhB6X,EAAS,IAAI5Y,EAAQyiB,QAEdzN,KAAK,KAAMrR,EAAM4E,GAExBqQ,EAAO6H,QAGN7H,EAAO8J,SA2BRuJ,EAASrT,EAAO6D,IAAI1b,GAAGF,mBAEvBkrB,EAAiB1pB,KAAKyC,GAElB6F,IAGIA,EAAK8hB,kBACL9hB,EAAKK,YAAYrH,EAAK8Y,IAAIhc,SAASujB,eAAe,MAGtDrgB,EAAK+oB,kBAAkB/hB,EAAMiO,EAAO6D,IAAI1b,GAAIirB,GAE5CrhB,EAAO,QArCNA,IAGDA,EAAOhH,EAAK8Y,IAAIhc,SAASoK,0BAGzBF,EAAK8hB,kBACL9hB,EAAKK,YAAYrH,EAAK8Y,IAAIhc,SAASujB,eAAe,MAGtDrZ,EAAKK,YAAY4N,EAAO6D,IAAI1b,IAE5B6X,EAAO8J,SAAU,EAEjB9J,EAAO0T,eACP1T,EAAO4T,aACP5T,EAAO6H,OAEPO,EAAUqD,OAAOhiB,KAAKuW,GAEtBoT,EAAgB3pB,KAAKuW,IAqBzBoI,EAAUS,KAAKpf,KAAKuW,EACxB,CAcA,IAZIjO,KAGAshB,EAASA,GAAUtoB,EAAKY,OAAO6U,OAAOd,eAGlC3N,EAAKK,YAAYrH,EAAK8Y,IAAIhc,SAASujB,eAAe,MAGtDrgB,EAAK+oB,kBAAkB/hB,EAAMshB,EAAQD,IAGpCjuB,EAAI,EAAGwK,EAAOyY,EAAUI,aAAarjB,GAAIA,IAC1C+G,EAAKyD,EAAK5E,EAAKY,OAAOgE,KAAKuP,QAE3Bc,EAASjV,EAAK8b,MAAM3a,GAEhBkc,EAAUS,KAAK9f,QAAQiX,GAAU,GAGjCoI,EAAUP,KAAKpe,KAAKuW,GACpBoI,EAAUR,OAAOne,KAAKuW,GACtBoI,EAAUoD,SAAS/hB,KAAKuW,IAExBkT,EAAmBzpB,KAAKyC,GAI3B7E,EAAEqL,aAAawgB,EAAoBC,KACpC/K,EAAU6D,UAAW,GAGzBlhB,EAAKwC,YAAY,oBAAqBlD,UAC1C,EAYAypB,kBAAmB,SAAS/hB,EAAMshB,EAAQvS,GACtC,IAAI/V,EAAO3C,KACP2rB,EAAWV,EAAShsB,EAAE6L,cAAcnI,EAAK8Y,IAAIjO,OAAOG,UAAUhN,QAAQsqB,GAAUtoB,EAAK+V,QAAQ/Y,OAIjG,IAFAgD,EAAK8Y,IAAIjO,OAAOyV,aAAatZ,EAAMshB,GAE5BvS,EAAQ/Y,QACXgD,EAAK+V,QAAQsC,OAAO2Q,EAAU,EAAGjT,EAAQ+J,SAEzCkJ,GAER,EAWA9H,SAAU,SAAS+H,EAAcC,GAC7B,IAAIlpB,EAAU3C,KACVkB,GAAU,EAkBd,OAPIA,KARAyB,EAAKY,OAAO0U,SAASzC,UACQ,WAA7BoW,EAAalS,OACbkS,EAAanS,YAAgBoS,EAAapS,WAC1CmS,EAAalS,QAAgBmS,EAAanS,OAC1CkS,EAAavS,aAAgBwS,EAAaxS,YACnB,OAAtBuS,EAAajS,MAAiBkS,EAAalS,MAC3CiS,EAAajS,MAA8B,OAAtBkS,EAAalS,UAG5BiS,EAAajS,OAAQkS,EAAalS,OAChChX,EAAKkhB,SAAS+H,EAAajS,KAAMkS,EAAalS,MAKpDhX,EAAK4P,YAAY,iBAAkBrR,EAAQe,UACtD,EAsBAwe,KAAM,WAGF,OAFWzgB,KAECwX,OAAO,MACvB,EAuBAiI,KAAM,WAGF,OAFWzf,KAECwX,OAAO,OACvB,EAwBAsU,SAAU,WAGN,OAFW9rB,KAECse,MAChB,EAmEA9G,OAAQ,WACJ,IACI2G,EADcne,KACK0gB,gBAAgBze,WAEvC,OAHkBjC,KAGNic,SAAS,CACjBzE,OAAQ2G,EAAY7C,SACrB6C,EAAY4L,QAAS5L,EAAYkL,SACxC,EAgCArN,SAAU,WACN,IAGImG,EAHAxf,EAAkB3C,KAClBme,EAAkBxb,EAAK+d,gBAAgBze,WACvCxB,EAAkB0d,EAAY7C,QAAQ7a,SAW1C,OARAkC,EAAK0b,YAAa,EAEd1b,EAAKwZ,YAAYxb,QAAQF,GAAY,GACrCkC,EAAKwZ,YAAY9a,KAAKZ,GAG1B0hB,EAAiBxf,EAAKsf,oBAEftf,EAAKsZ,SAAS,CACjBzE,OAAQ2K,GACThE,EAAY4L,QAAS5L,EAAYkL,SACxC,EA+BAtN,UAAW,WACP,IAIIoG,EAJAxf,EAAkB3C,KAClBme,EAAkBxb,EAAK+d,gBAAgBze,WACvCxB,EAAkB0d,EAAY7C,QAAQ7a,SACtCsrB,EAAkBppB,EAAKwZ,YAAYxb,QAAQF,GAW/C,OARAkC,EAAK0b,YAAa,EAEd0N,GAAiB,GACjBppB,EAAKwZ,YAAYnB,OAAO+Q,EAAe,GAG3C5J,EAAiBxf,EAAKsf,oBAEftf,EAAKsZ,SAAS,CACjBzE,OAAQ2K,GACThE,EAAY4L,QAAS5L,EAAYkL,SACxC,EAgFA5R,KAAM,WACF,IACI0G,EADcne,KACK2gB,cAAc1e,WAErC,OAHkBjC,KAGNic,SAAS,CACjBxE,KAAM0G,EAAY7C,SACnB6C,EAAY4L,QAAS5L,EAAYkL,SACxC,EAuCAlQ,aAAc,WACV,IACIgF,EADcne,KACKkqB,sBAAsBjoB,WAE7C,OAHkBjC,KAGNic,SAAS,CACjB9C,aAAcgF,EAAY7C,SAC3B6C,EAAY4L,QAAS5L,EAAYkL,SACxC,EAkEA3R,QAAS,WACL,IAAI/U,EAAc3C,KACdme,EAAcxb,EAAK4nB,iBAAiBtoB,WACpC+d,EAAc,KACdyK,EAAc,KACdV,GAAc,EAIlB,OAFApnB,EAAKwC,YAAY,gBAAiBlD,WAE7BU,EAAK2b,SASNmM,EAAY,IAAIzrB,EAAQkf,WAEd5S,KAAgBrJ,UAC1BwoB,EAAUtM,YAAgBA,EAEnBxb,EAAK6nB,SAASC,KAbjBtM,EAAYkL,WAAU1mB,EAAKuc,aAAef,EAAYkL,UAE1DU,EAAW5L,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAAUqZ,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OAE7Gkb,EAAYrd,EAAKgoB,iBAAiBxM,EAAY7C,QAAQ5D,SAE/C/U,EAAK8iB,MAAMsE,EAAS/J,GASnC,EAuDA/D,SAAU,WACN,IAAItZ,EAAc3C,KACdggB,EAAc,KACd+J,GAAc,EACdU,EAAc,KACdtM,EAAcxb,EAAKknB,kBAAkB5nB,WAIzC,OAFAU,EAAKwC,YAAY,iBAAkBlD,WAE9BU,EAAK2b,SA+BNmM,EAAY,IAAIzrB,EAAQkf,WAEd5S,KAAiBrJ,UAC3BwoB,EAAUtM,YAAiBA,EAC3BsM,EAAUrM,eAAiBzb,EAAK+Y,YAChC+O,EAAUpM,WAAiB1b,EAAK0b,WAEzB1b,EAAK6nB,SAASC,KArCrBzK,EAAYrd,EAAKqpB,aAAa7N,EAAY7C,SAEtC3Y,EAAKY,OAAO4U,SAASrT,SAGjBqZ,EAAY7C,QAAQ9D,SAAW7U,EAAK0b,aAIpC1b,EAAKwZ,YAAYxc,OAAS,EAC1BgD,EAAKgd,iBAAiBK,EAAU1E,UAGhC3Y,EAAKmS,MAAMnV,OAAS,GACpBgD,EAAKid,eAAeI,EAAU1E,UAIlC6C,EAAYkL,WAAU1mB,EAAKuc,aAAef,EAAYkL,UAI1DU,EAAW5L,EAAY4L,QAAUpnB,EAAKY,OAAOyU,UAAUlT,OACnDqZ,EAAY4L,QACZpnB,EAAKY,OAAOyU,UAAUlT,OAE1BnC,EAAK4P,YAAY,oBAAqByN,EAAW/d,WAE1CU,EAAK8iB,MAAMsE,EAAS/J,GAWnC,EAYAgM,aAAc,SAASC,GACnB,IAAItpB,EAAsB3C,KACtBksB,EAAsBD,EAAgBxU,KACtC0U,EAAsBF,EAAgBzU,OACtC4U,EAAsBH,EAAgB9S,aACtCkT,EAAsBJ,EAAgB/S,OACtCoT,EAAsBL,EAAgBhT,OACtC+G,EAAsB,IAAIhhB,EAAQihB,UAStC,OAPAD,EAAYrd,EAAK4P,YAAY,gCAAiCyN,EAAW/d,YAE/D6B,GAAoB7E,EAAEoF,YAChC2b,EAAU1E,QAAoB2Q,EAC9BjM,EAAU4F,WAAoBjjB,EAAKkZ,MACnCmE,EAAU5B,eAAoBzb,EAAK+Y,YAE/B/Y,EAAK2b,QACD3b,EAAKY,OAAOgB,MAAMC,cAClBC,QAAQC,KAAK1F,EAAQkF,SAASqoB,mCAG3B,OAGPD,GACA3pB,EAAKggB,cAAc2J,EAAetM,GAGlCqM,IACArM,EAAUoD,SAAWiJ,EAAc3T,SAGvCsH,EAAUoB,UAAYpB,EAAUa,QAAUb,EAAU4F,WAAW9F,WAC/DE,EAAUiB,WAAajB,EAAUgB,SAAWre,EAAK+V,QAE7CwT,IACAlM,EAAUoB,UAAYpB,EAAU4F,WAAW9F,WAC3CE,EAAUa,QAAYqL,EAEtBlM,EAAU6D,SAAWlhB,EAAKkhB,SAASqI,EAAalM,EAAU4F,WAAW9F,YAEjEE,EAAU6D,UACVlhB,EAAKme,cAAcd,IAI3BA,EAAUkB,YAAclB,EAAU4F,WAAW/F,aAGzCG,EAAUmB,UADVgL,GAGsBltB,EAAEkH,OAAO,IAAInH,EAAQoa,cAAiB4G,EAAUkB,aAGrC,QAAjClB,EAAUmB,UAAU1gB,SACpBuf,EAAUmB,UAAU1gB,SAAWkC,EAAKY,OAAO+U,UAAUV,OACb,SAAjCoI,EAAUmB,UAAU1gB,WAC3Buf,EAAUmB,UAAU1gB,SAAW,IAGnCkC,EAAK0e,gBAAgBrB,GAErBA,EAAUO,wBAA0BP,EAAU4F,WAAW1F,yBAErDkM,GACApM,EAAUQ,sBAAwB4L,EAAoBhV,mBAElD4I,EAAUQ,wBAA0BR,EAAUO,0BAC9CP,EAAU2F,kBAAmB,IAGjC3F,EAAUQ,sBAAwBR,EAAUO,wBAG5C5d,EAAKY,OAAOyU,UAAUlT,SAGtBnC,EAAK8jB,gBAAgBzG,GACrBrd,EAAKilB,SAAS5H,GAEdA,EAAU8F,SAAW7mB,EAAEuQ,iBAAiB7M,EAAK8Y,IAAIhc,UAEjDkD,EAAKklB,gBAAgB7H,GACrBrd,EAAKolB,SAAS/H,GACdrd,EAAKqlB,gBAAgBhI,GAErBrd,EAAKod,eAELC,EAAUoJ,UAAYzmB,EAAKymB,YAE3BzmB,EAAKylB,aAAapI,IAGlBA,EAAU6D,WACVlhB,EAAK+V,QAAUsH,EAAUgB,UAG7BhB,EAAU6F,SAAWljB,EAAK2e,WAAWtB,GAE9Brd,EAAK4P,YAAY,8BAA+ByN,EAAW/d,WACtE,EAoBAuqB,MAAO,SAASxM,EAAWyM,GACvB,IAAI7U,EAAkB,KAClByQ,EAAkB,KAClBqE,GAAmB,EACnB3vB,GAAmB,EAKvB,IAHA0vB,EAAarqB,KAAK+K,IAAIsf,EAAY,GAClCA,EAAarqB,KAAKG,IAAIkqB,EAAY,GAE7B1vB,EAAI,EAAG6a,EAASoI,EAAUS,KAAK1jB,GAAIA,IACpCsrB,EAAUrI,EAAU+G,YAAYhqB,GAEhC6a,EAAO+U,WAAWtE,EAASoE,GAG/B,IAAK1vB,EAAI,EAAG6a,EAASoI,EAAUP,KAAK1iB,GAAIA,IAChC6a,EAAO6L,SACP7L,EAAO6H,QAGNiN,EAAc1M,EAAUR,OAAO7e,QAAQiX,KAAY,IACpDyQ,EAAUrI,EAAUiH,cAAcyF,GAE7B9U,EAAO6L,SACR7L,EAAO6I,OAGX7I,EAAO+U,WAAWtE,EAASoE,GAGvC,EA+FAxT,OAAQ,WACJ,IACI3N,EADOtL,KACKgqB,gBAAgB/nB,WAEhC,OAHWjC,KAGCic,SAAS,CACjBhD,OAAQ3N,EAAKgQ,SACdhQ,EAAKye,QAASze,EAAK+d,SAC1B,EA8CApG,aAAc,WACV,IACI3X,EADOtL,KACKgqB,gBAAgB/nB,WAEhC,OAHWjC,KAGCiZ,OAAO3N,EAAKgQ,QAAQjC,WAAY,SAAU/N,EAAKgQ,QAAQzB,QAASvO,EAAKye,QAASze,EAAK+d,SACnG,EA0CAuD,YAAa,WACT,IACIthB,EADOtL,KACKgqB,gBAAgB/nB,WAEhC,OAHWjC,KAGCiZ,OAAO3N,EAAKgQ,QAAQjC,WAAY,QAAS/N,EAAKgQ,QAAQzB,QAASvO,EAAKye,QAASze,EAAK+d,SAClG,EAoCAwD,QAAS,WACL,IACIvhB,EADOtL,KACKgqB,gBAAgB/nB,WAEhC,OAHWjC,KAGCiZ,OAAO,EAAG3N,EAAKgQ,QAAQjC,WAAY/N,EAAKye,QAASze,EAAK+d,SACtE,EAoCAyD,OAAQ,WACJ,IAAInqB,EAAO3C,KACPsL,EAAO3I,EAAKqnB,gBAAgB/nB,WAEhC,OAAOU,EAAKsW,OAAOtW,EAAKkZ,MAAM+E,aAActV,EAAKgQ,QAAQjC,WAAY/N,EAAKye,QAASze,EAAK+d,SAC5F,EA8DAnQ,OAAQ,WACJ,IACI5N,EADOtL,KACKiqB,gBAAgBhoB,WAEhC,OAHWjC,KAGCic,SAAS,CACjB/C,OAAQ5N,EAAKgQ,SACdhQ,EAAKye,QAASze,EAAK+d,SAC1B,EA6BA0D,UAAW,SAASjb,GAChB,IAAInP,EAAU3C,KACVhC,EAAU,KAQd,OAHIA,EAHC8T,EAGO7S,EAAE4S,YAAYlP,EAAKY,OAAQuO,GAF3BnP,EAAKY,OAKVZ,EAAK4P,YAAY,iBAAkBvU,EAAOiE,UACrD,EAqDA+qB,UAAW,SAASzpB,GAChB,IAAIZ,EAAO3C,KAEX2C,EAAKwC,YAAY,kBAAmBlD,WAEpChD,EAAEkH,OAAOxD,EAAKY,OAAQA,GAAQ,GAAM,GAEpCZ,EAAKwC,YAAY,iBAAkBlD,UACvC,EAyBAgrB,SAAU,WACN,IACIpR,EAQJ,OANAA,EAAQ,IAAI7c,EAAQif,MAEpBhf,EAAEkH,OAAO0V,EALK7b,KAKO6b,OAErB5c,EAAEyR,OAAOmL,GAPK7b,KASFuS,YAAY,gBAAiBsJ,EAAO5Z,UACpD,EAwCAirB,aAAc,WACCltB,KAENsf,cACT,EAsCA6N,YAAa,WACT,IAAIxqB,EAAU3C,KACV4X,EAAU,KACV7X,EAAU,KACV+D,EAAU,GAEd,IAAKA,KAAMnB,EAAK8b,OAGZ1e,GAFA6X,EAASjV,EAAK8b,MAAM3a,IAERyU,OAAOX,EAAOrQ,SAEfqQ,EAAO6D,IAAI1b,KAGd6X,EAAO8J,UACP9J,EAAO0T,eAEP3oB,EAAK8Y,IAAIjO,OAAO+d,aAAaxrB,EAAI6X,EAAO6D,IAAI1b,KAG3C6X,EAAO6L,UACR1jB,EAAGuP,MAAMyT,QAAU,QAGvBnL,EAAO6D,IAAI1b,GAAKA,EAEZ6X,EAAO8J,SACP9J,EAAO4T,cAKnB7oB,EAAKkZ,MAAQlZ,EAAK2e,WAAW3e,EAAKsc,cACtC,EA6BAmO,QAAS,SAAS5G,GACd,IAAI7jB,EAAU3C,KACV4Q,EAAU,KACVgH,EAAU,KACV7a,EAAU,EAId,IAFA4F,EAAKwC,YAAY,gBAAiBlD,WAE7BlF,EAAI,EAAG6T,EAAUjO,EAAKwV,SAASpb,GAAIA,IACpC6T,EAAQkK,cAAcnY,GAG1B,IAAK5F,EAAI,EAAG6a,EAASjV,EAAK+V,QAAQ3b,GAAIA,IAC9BypB,GACA5O,EAAO6I,OAGX7I,EAAO0T,eAGP3oB,EAAK8Y,IAAInY,UAAUQ,GAAGgC,MAAM,aAC5BnD,EAAK8Y,IAAInY,UAAUwK,gBAAgB,aAGhC9O,EAAQ6E,UAAUlB,EAAKmB,IAE9BnB,EAAKwC,YAAY,eAAgBlD,UACrC,IAUJjD,EAAQmqB,UAAY,WAChBnqB,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK2oB,MAAiB,KACtB3oB,KAAK4oB,OAAiB,KACtB5oB,KAAKggB,UAAiB,KACtBhgB,KAAKqpB,SAAiB,KACtBrpB,KAAK+oB,aAAiB,GACtB/oB,KAAKyU,UAAkB,EACvBzU,KAAKipB,cAAkB,EAEvBjpB,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQmqB,WAEhCnqB,EAAQmqB,UAAUxqB,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEzDK,EAAQmqB,UAAUxqB,UAAUuT,YAAclT,EAAQmqB,UASlDnqB,EAAQquB,UAAY,WAChBruB,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKD,GAAK,KAEVC,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQquB,WAEhCruB,EAAQquB,UAAU1uB,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEzDK,EAAQquB,UAAU1uB,UAAUuT,YAAclT,EAAQquB,UAUlDruB,EAAQyiB,OAAS,WACbziB,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK8D,GAAa,GAClB9D,KAAKwZ,WAAa,GAClBxZ,KAAK4a,MAAa,KAClB5a,KAAKqpB,SAAa,KAClBrpB,KAAKyjB,SAAa,EAClBzjB,KAAK2a,SAAa,EAClB3a,KAAKstB,YAAa,EAClBttB,KAAK0hB,SAAa,EAClB1hB,KAAKua,QAAa,KAClBva,KAAKggB,UAAa,KAClBhgB,KAAKuH,KAAa,KAClBvH,KAAKyb,IAAa,IAAIzc,EAAQquB,UAE9BrtB,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQyiB,QAEhCziB,EAAQyiB,OAAO9iB,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEtDM,EAAEkH,OAAOnH,EAAQyiB,OAAO9iB,UAAW,CAC/BuT,YAAalT,EAAQyiB,OAcrBzN,KAAM,SAASjU,EAAI6a,EAAOrT,GACtB,IAAI5E,EAAO3C,KACP8D,EAAO,GAoBX,GAlBAnB,EAAKwC,YAAY,aAAclD,WAE/BU,EAAKiY,MAAQA,EAER7a,IAGDA,EAAK4C,EAAK4V,OAAOhR,IAGrB5E,EAAK0c,SAAStf,GAEd4C,EAAK6oB,aAE6B,SAA9B7oB,EAAK8Y,IAAI1b,GAAGuP,MAAMyT,UAClBpgB,EAAK8gB,SAAU,GAGflc,GAAQqT,EAAMrX,OAAOgE,KAAKuP,OAAQ,CAClC,QAAqD,KAAzChT,EAAKyD,EAAKqT,EAAMrX,OAAOgE,KAAKuP,UAA4BhT,EAAG/C,WAAWpB,OAAS,EACvF,MAAM,IAAIyB,UAAUpC,EAAQkF,SAASinB,0BAA0B,CAC3DrU,OAAQ8D,EAAMrX,OAAOgE,KAAKuP,UAIlCnU,EAAKmB,GAASA,EACdnB,EAAK4E,KAASA,EAEdqT,EAAM6D,MAAM3a,GAAMnB,CACtB,CAEAA,EAAKwC,YAAY,YAAalD,UAClC,EAYAsW,OAAQ,SAAShR,GACb,IAIIC,EAJA7E,EAAU3C,KACVuY,EAAU,KACVxY,EAAU,KACV6J,EAAU,KAOd,GAJAjH,EAAKwC,YAAY,eAAgBlD,WAIX,mBAFtBsW,EAAS5V,EAAK4P,YAAY,eAAgB5P,EAAKiY,MAAMrX,OAAOgV,OAAOX,OAAQ3V,YAGvE,MAAM,IAAIb,UAAUpC,EAAQkF,SAASqpB,8BAczC,OAXA/lB,EAAS+Q,EAAOhR,KAEgB,iBAAXC,GAAuBvI,EAAE+E,UAAUwD,GACpDzH,EAAKyH,EACoB,iBAAXA,KACdoC,EAAOnK,SAASC,cAAc,QACzBoK,UAAYtC,EAEjBzH,EAAK6J,EAAK4jB,mBAGP7qB,EAAK4P,YAAY,WAAYxS,EAAIkC,UAC5C,EAYAod,SAAU,SAAStf,GACf,IAAI4C,EAAO3C,KAEX2C,EAAKwC,YAAY,iBAAkBlD,WAEnCU,EAAK8Y,IAAI1b,GAAKA,EAEd4C,EAAKwC,YAAY,gBAAiBlD,UACtC,EAUAwrB,cAAe,SAASC,GACpB,IAAI/qB,EAAU3C,KACVhC,EAAU2E,EAAK8Y,IAAI1b,GAAG0a,aAAa,QAAUiT,IAAkB,GAEnE/qB,EAAKwC,YAAY,sBAAuBlD,WAExCjE,EAAQimB,MAAc,EAARjmB,GACVA,EAAMkL,cACE,EAARlL,EAEJ2E,EAAK6W,WAAaxb,EAElB2E,EAAKwC,YAAY,qBAAsBlD,UAC3C,EASAwe,KAAM,WACF,IAAI9d,EAAO3C,KAEX2C,EAAKwC,YAAY,aAAclD,WAE1BU,EAAK8gB,UACN9gB,EAAK8Y,IAAI1b,GAAGuP,MAAMyT,QAAU,GAE5BpgB,EAAK8gB,SAAU,GAGnB9gB,EAAKwC,YAAY,YAAalD,UAClC,EASAwd,KAAM,WACF,IAAI9c,EAAO3C,KAEX2C,EAAKwC,YAAY,aAAclD,WAE3BU,EAAK8gB,UACL9gB,EAAK8Y,IAAI1b,GAAGuP,MAAMyT,QAAU,OAE5BpgB,EAAK8gB,SAAU,GAGnB9gB,EAAKwC,YAAY,YAAalD,UAClC,EAUAqnB,KAAM,SAASR,GACX,IAAInmB,EAAO3C,KAEX2C,EAAKwC,YAAY,aAAclD,WAE1BU,EAAK2qB,YACN3qB,EAAKiY,MAAM8D,eAGf/b,EAAKgrB,cAAc7E,GAEnBlpB,uBAAsB,WAClB+C,EAAKirB,eAAe9E,EACxB,IAEAnmB,EAAKwC,YAAY,YAAalD,UAClC,EAWA0qB,WAAY,SAAStE,EAASoE,GAC1B,IAAI9pB,EAA0B3C,KAC1B6tB,EAA0B,GAC1BhF,EAA0B,KAC1BF,EAA0BN,EAAQM,MAClCmF,EAA0B,GAC1BC,EAA0B,IAAI/uB,EAAQwd,UACtCzf,GAA2B,EAa/B,IAXA4F,EAAKwC,YAAY,mBAAoBlD,WAErC8rB,EAAc5hB,EAAQwc,EAAMxc,EAC5B4hB,EAAc3hB,EAAQuc,EAAMvc,EAET,IAAfqgB,EACA9pB,EAAK8c,OACG9c,EAAK8gB,SACb9gB,EAAK8d,OAGJ1jB,EAAI,EAAG8wB,EAAe7uB,EAAQsP,SAASyF,UAAUhX,GAAIA,IAGtD,GAFA8rB,EAAYR,EAAQQ,UAAUgF,GAET,MAAjBA,EAAsB,CACtB,IAAKhF,EAAW,SAEhBkF,EAAc5hB,EAAIwc,EAAMxc,EAAK0c,EAAY4D,CAC7C,MAAO,GAAqB,MAAjBoB,EAAsB,CAC7B,IAAKhF,EAAW,SAEhBkF,EAAc3hB,EAAIuc,EAAMvc,EAAKyc,EAAY4D,CAC7C,MAAO,GAAI5D,aAAqB7pB,EAAQ8d,cAAe,CACnD,IAAK+L,EAAU7qB,MAAO,SAEtB+vB,EAAcF,GAAc7vB,MACxB2qB,EAAMkF,GAAc7vB,MAAS6qB,EAAU7qB,MAAQyuB,EAEnDsB,EAAcF,GAAcxQ,KAAQwL,EAAUxL,KAE9CyQ,EAAuBzsB,KACnBwsB,EAAe,IAAME,EAAcF,GAAc7vB,MAAQ6qB,EAAUxL,KAAO,IAElF,KAAO,CACH,IAAKwL,EAAW,SAEhBkF,EAAcF,GAAgBlF,EAAMkF,GAAiBhF,EAAY4D,EAEjE9pB,EAAK8Y,IAAI1b,GAAGuP,MAAMue,GAAgBE,EAAcF,EACpD,EAGAE,EAAc5hB,GAAK4hB,EAAc3hB,IACjC0hB,EAAuBnb,QAAQ,aAAeob,EAAc5hB,EAAI,OAAS4hB,EAAc3hB,EAAI,OAG3F0hB,EAAuBnuB,SACvBgD,EAAK8Y,IAAI1b,GAAGuP,MAAMtQ,EAAQsP,SAAS8E,eAAiB0a,EAAuB1L,KAAK,MAGpFzf,EAAKwC,YAAY,kBAAmBlD,UACxC,EAYA0rB,cAAe,SAAS7E,GACpB,IAAInmB,EAAkB3C,KAClB2oB,EAAkBG,EAASH,MAC3BqF,EAAmD,IAAjCrrB,EAAKiY,MAAMrG,UAAU/D,QACvCyd,EAAkB,GAEtBtrB,EAAKwC,YAAY,sBAAuBlD,WAExCgsB,EAAgB5sB,KAAK,aAAesnB,EAAMxc,EAAI,OAASwc,EAAMvc,EAAI,OAE7DzJ,EAAKiY,MAAMrX,OAAOyU,UAAU/C,uBACE,SAA1B6T,EAASC,eAGTpmB,EAAK8Y,IAAI1b,GAAGuP,MAAMrC,MAAS0b,EAAM1b,MAAQ,KACzCtK,EAAK8Y,IAAI1b,GAAGuP,MAAMpC,OAASyb,EAAMzb,OAAS,MAG9CvK,EAAK8Y,IAAI1b,GAAGuP,MAAMqN,YAAegM,EAAMhM,YAAc,KACrDha,EAAK8Y,IAAI1b,GAAGuP,MAAMsN,aAAe+L,EAAM/L,aAAe,MAG1DoR,IAAarrB,EAAK8Y,IAAI1b,GAAGuP,MAAMkB,QAAUmY,EAAMnY,SAEjB,SAA1BsY,EAASC,eACTkF,EAAkBA,EAAgBjrB,OAAOL,EAAKiY,MAAMmE,cAGxDpc,EAAK8Y,IAAI1b,GAAGuP,MAAMtQ,EAAQsP,SAAS8E,eAAiB6a,EAAgB7L,KAAK,KAEzEzf,EAAKwC,YAAY,qBAAsBlD,UAC3C,EAYA2rB,eAAgB,SAAS9E,GACrB,IAAInmB,EAAkB3C,KAClBkuB,EAAkB,GAClBD,EAAkB,GAClBE,EAAkBxrB,EAAKiY,MAAMrX,OAAOyU,UAAU/C,qBAC9C+Y,OAA0D,IAAjCrrB,EAAKiY,MAAMrG,UAAU/D,QA0ClD,GAxCA7N,EAAKwC,YAAY,uBAAwBlD,WAIzCisB,EAAgB7sB,KAAKsB,EAAKyrB,oBACtBpvB,EAAQsP,SAAS+E,cACjByV,EAASG,eAGiB,SAA1BH,EAASC,cACTmF,EAAgB7sB,KAAKsB,EAAKyrB,oBACtB,UACAtF,EAASG,aACTH,EAASrU,WAIb0Z,IACAD,EAAgB7sB,KAAKsB,EAAKyrB,oBACtB,QACAtF,EAASG,aACTH,EAASrU,WAGbyZ,EAAgB7sB,KAAKsB,EAAKyrB,oBACtB,SACAtF,EAASG,aACTH,EAASrU,WAGbyZ,EAAgB7sB,KAAKsB,EAAKyrB,oBACtB,SACAtF,EAASG,aACTH,EAASrU,aAOZqU,EAASO,SAWV,OAVA1mB,EAAKiY,MAAM+D,wBAEPhc,EAAKiY,MAAM8D,eAAiB/b,EAAKiY,MAAM+D,kBAKvChc,EAAKiY,MAAM4L,QAAQsC,EAAS9I,YA6CpC,OApCArd,EAAKqd,UAAY8I,EAAS9I,UAC1Brd,EAAK0mB,SAAWP,EAASO,UAKxB1mB,EAAK2qB,YAAc3qB,EAAKiY,MAAMgE,eAK/Bjc,EAAKgY,SAAU,EAIfhY,EAAK0rB,gBAAgBH,GAIjBC,GAAcrF,EAASF,OAAO3b,MAAQ,GAAK6b,EAASF,OAAO1b,OAAS,IACpEvK,EAAK8Y,IAAI1b,GAAGuP,MAAMrC,MAAe6b,EAASF,OAAO3b,MAAQ,KACzDtK,EAAK8Y,IAAI1b,GAAGuP,MAAMpC,OAAe4b,EAASF,OAAO1b,OAAS,KAC1DvK,EAAK8Y,IAAI1b,GAAGuP,MAAMqN,YAAemM,EAASF,OAAOjM,YAAc,KAC/Dha,EAAK8Y,IAAI1b,GAAGuP,MAAMsN,aAAekM,EAASF,OAAOhM,aAAe,MAG/Dja,EAAKiY,MAAMrX,OAAOyU,UAAU5C,OAAmC,SAA1B0T,EAASC,cAK/CkF,EAAgB5sB,KAAK,aAAeynB,EAASF,OAAOzc,EAAI,OAAS2c,EAASF,OAAOxc,EAAI,OAKjF0c,EAASC,cACb,IAAK,OACDiF,IAAarrB,EAAK8Y,IAAI1b,GAAGuP,MAAMkB,QAAU7N,EAAKiY,MAAMpG,WAAWhE,SAE/Dyd,EAAkBA,EAAgBjrB,OAAOL,EAAKiY,MAAMoE,cAEpD,MACJ,IAAK,OACDgP,IAAarrB,EAAK8Y,IAAI1b,GAAGuP,MAAMkB,QAAU,IAI7C7N,EAAKiY,MAAMrX,OAAOyU,UAAU5C,QAC1BzS,EAAKiY,MAAMrX,OAAOyU,UAAU5C,OAAmC,SAA1B0T,EAASC,eAKhDkF,EAAgB5sB,KAAK,aAAeynB,EAASF,OAAOzc,EAAI,OAAS2c,EAASF,OAAOxc,EAAI,OAKzFzJ,EAAK8Y,IAAI1b,GAAGuP,MAAMtQ,EAAQsP,SAAS8E,eAAiB6a,EAAgB7L,KAAK,KAEzEzf,EAAKwC,YAAY,sBAAuBlD,UAC5C,EAeAmsB,oBAAqB,SAAS1vB,EAAUuqB,EAAcxU,GAClD,IAEIgQ,EAFA9hB,EAAQ3C,KACRsuB,EAAQ3rB,EAAK4rB,SAAStF,GAQ1B,OALAxE,EAAO/lB,EAAW,KACb+V,EAAW,EAAIA,EAAW9R,EAAKiY,MAAMrX,OAAOyU,UAAUvD,UAAY,MACnE6Z,EAAQ,OACM,YAAb5vB,EAAyB,SAAWiE,EAAKiY,MAAMrX,OAAOyU,UAAUtD,QAE9D/R,EAAK4P,YAAY,0BAA2BkS,EAAMxiB,UAC7D,EAeAssB,SAAU,SAASxlB,GACf,IACIulB,EADA3rB,EAAU3C,KASd,MAN2D,mBAAhD2C,EAAKiY,MAAMrX,OAAOyU,UAAU9C,kBACnCnM,EAAQpG,EAAKiY,MAAMrX,OAAOyU,UAAU9C,gBAAgBhY,KAAKyF,EAAMoG,EAAOpG,EAAKkZ,QAG/EyS,EAAU3rB,EAAKiY,MAAMkE,gBAAkB/V,EAAQpG,EAAKiY,MAAMkE,gBAAkB,EAErEnc,EAAK4P,YAAY,gBAAiB+b,EAAOrsB,UACpD,EAUAosB,gBAAiB,SAAS7J,GACtB,IAAI7hB,EAAsB3C,KACtBwuB,EAAsBhK,EAAMpC,KAAK,MAErCzf,EAAKwC,YAAY,wBAAyBlD,WAE1CU,EAAK8Y,IAAI1b,GAAGuP,MAAMtQ,EAAQsP,SAASgF,gBAAkBkb,EAErD7rB,EAAKwC,YAAY,uBAAwBlD,UAC7C,EAUAwsB,oBAAqB,SAAS7lB,GAC1B,IAAIjG,EAAc3C,KACd0uB,EAAc9lB,EAAEilB,aAChBc,EAAchsB,EAAKiY,MAAMrX,OAAOyU,UAAU/C,qBAE9CtS,EAAKwC,YAAY,4BAA6BlD,WAG1CU,EAAKgY,SACL/R,EAAEgP,OAAOzX,QAAQwC,EAAKiY,MAAMrX,OAAO+U,UAAUV,UAEzC8W,EAAS/tB,QAAQ,cAAgB,GACjC+tB,EAAS/tB,QAAQ,YAAc,GAC/BguB,GAAaD,EAAS/tB,QAAQ,WAAa,GAC3CguB,GAAaD,EAAS/tB,QAAQ,UAAY,GAC1CguB,GAAaD,EAAS/tB,QAAQ,WAAa,KAG/CgC,EAAK0mB,SAASnsB,KAAKyF,EAAMA,EAAKqd,WAE9Brd,EAAKgY,SAAU,EACfhY,EAAK0mB,SAAW,KAChB1mB,EAAKqd,UAAY,MAGrBrd,EAAKwC,YAAY,2BAA4BlD,UACjD,EAUA2sB,SAAU,SAAShmB,GACf,IAAIjG,EAAO3C,KAIX,OAFA2C,EAAKwC,YAAY,iBAAkBlD,WAE3B2G,EAAExF,MACN,IAAK,sBACL,IAAK,gBACDT,EAAK8rB,oBAAoB7lB,GAGjCjG,EAAKwC,YAAY,gBAAiBlD,UACtC,EASAqpB,aAAc,WACV,IAAI3oB,EAAO3C,KAEX2C,EAAKwC,YAAY,qBAAsBlD,WAEvChD,EAAE4I,IAAIlF,EAAK8Y,IAAI1b,GAAI,sBAAuB4C,EAAK4X,SAC/Ctb,EAAE4I,IAAIlF,EAAK8Y,IAAI1b,GAAI,gBAAiB4C,EAAK4X,SAEzC5X,EAAKwC,YAAY,oBAAqBlD,UAC1C,EASAupB,WAAY,WACR,IACIqD,EADAlsB,EAAsB3C,KAG1B2C,EAAKwC,YAAY,mBAAoBlD,WAErC4sB,EAA2D,WAAtC7vB,EAAQsP,SAAS6E,iBAAgC,sBAAwB,gBAE9FxQ,EAAK4X,QAAU,SAAS3R,GACpB,OAAOjG,EAAKisB,SAAShmB,EACzB,EAEA3J,EAAEwI,GAAG9E,EAAK8Y,IAAI1b,GAAI8uB,EAAoBlsB,EAAK4X,SAE3C5X,EAAKwC,YAAY,kBAAmBlD,UACxC,EAUA6kB,WAAY,SAASgI,GACjB,IAAInsB,EAAU3C,KACVqQ,EAAU,CAAC,EACX0e,EAAU,KACV1G,EAAU,IAAIrpB,EAAQwd,UA0B1B,OAxBA7Z,EAAKwC,YAAY,mBAAoBlD,WAErComB,EAAQlc,EAAIxJ,EAAK8Y,IAAI1b,GAAGkM,WACxBoc,EAAQjc,EAAIzJ,EAAK8Y,IAAI1b,GAAGmM,WAEpBvJ,EAAKiY,MAAMrX,OAAOyU,UAAU/C,sBAAwB6Z,KACpDC,EAAOpsB,EAAK8Y,IAAI1b,GAAG6mB,wBAEnByB,EAAQhb,IAAU0hB,EAAK1hB,IACvBgb,EAAQ5L,MAAUsS,EAAKtS,MACvB4L,EAAQ3L,OAAUqS,EAAKrS,OACvB2L,EAAQjb,KAAU2hB,EAAK3hB,KAEvBib,EAAQpb,MAAS8hB,EAAK9hB,MACtBob,EAAQnb,OAAS6hB,EAAK7hB,QAGtBvK,EAAKiY,MAAMrX,OAAOyU,UAAU/C,uBAC5B5E,EAAStR,EAAOuR,iBAAiB3N,EAAK8Y,IAAI1b,IAE1CsoB,EAAQzL,aAAeyI,WAAWhV,EAAOuM,cACzCyL,EAAQ1L,YAAe0I,WAAWhV,EAAOsM,cAGtCha,EAAK4P,YAAY,oBAAqB8V,EAASpmB,UAC1D,EASAukB,QAAS,WACL,IAAI7jB,EAAO3C,KAEX2C,EAAKwC,YAAY,gBAAiBlD,WAElCU,EAAK8Y,IAAI1b,GAAGuP,MAAMtQ,EAAQsP,SAAS8E,eAAkB,GACrDzQ,EAAK8Y,IAAI1b,GAAGuP,MAAMtQ,EAAQsP,SAASgF,gBAAkB,GACrD3Q,EAAK8Y,IAAI1b,GAAGuP,MAAMkB,QAAmC,GAEjD7N,EAAKiY,MAAMrX,OAAOyU,UAAU/C,uBAC5BtS,EAAK8Y,IAAI1b,GAAGuP,MAAMrC,MAAe,GACjCtK,EAAK8Y,IAAI1b,GAAGuP,MAAMpC,OAAe,GACjCvK,EAAK8Y,IAAI1b,GAAGuP,MAAMqN,YAAe,GACjCha,EAAK8Y,IAAI1b,GAAGuP,MAAMsN,aAAe,IAGrCja,EAAKwC,YAAY,eAAgBlD,UACrC,IAkBJjD,EAAQ+F,WAAa,SAASlB,GAC1B,IAAIH,EAAc,KACd3G,GAAe,EAInB,IAFAiD,KAAKmF,YAAY,mBAEZpI,EAAI,EAAG2G,EAAWG,EAAU9G,GAAIA,IACjCiD,KAAKjD,GAAK2G,EAGd1D,KAAKL,OAASkE,EAAUlE,OAExBK,KAAKmF,YAAY,kBAEjBlG,EAAEyR,OAAO1Q,KACb,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ+F,YAEhC/F,EAAQ+F,WAAWpG,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE1DM,EAAEkH,OAAOnH,EAAQ+F,WAAWpG,UAE5B,CACIuT,YAAalT,EAAQ+F,WA2BrB/F,QAAS,SAASgwB,GACd,IACItrB,EAAc,KACd4H,EAAc5K,MAAM/B,UAAUmE,MAAM5F,KAAK+E,WACzC+M,EAAc,GACdjS,GAAe,EAMnB,IAJAiD,KAAKmF,YAAY,iBAEjBmG,EAAKmX,QAEA1lB,EAAI,EAAG2G,EAVM1D,KAUUjD,GAAIA,IAC5BiS,EAAM3N,KAAKqC,EAASsrB,GAAYjsB,MAAMW,EAAU4H,IAGpD,OAdkBtL,KAcNuS,YAAY,iBAAkBtT,EAAE8P,IAAIC,EAAOhQ,EAAQyG,WAAYxD,UAC/E,IAeJjD,EAAQihB,UAAY,WAChBjhB,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAK8D,GAA0B,GAE/B9D,KAAKsL,KAA0B,GAC/BtL,KAAKsb,QAA0B,KAC/Btb,KAAK+mB,YAA0B,GAC/B/mB,KAAKinB,cAA0B,GAE/BjnB,KAAK4lB,WAA0B,KAC/B5lB,KAAK6lB,SAA0B,KAC/B7lB,KAAK8lB,SAA0B,KAE/B9lB,KAAK6jB,UAA0B,EAC/B7jB,KAAK2lB,kBAA0B,EAC/B3lB,KAAKopB,WAA0B,EAC/BppB,KAAKujB,WAA0B,EAE/BvjB,KAAKoe,eAA0B,KAE/Bpe,KAAKygB,KAA0B,GAC/BzgB,KAAKyf,KAA0B,GAC/Bzf,KAAKsjB,SAA0B,GAC/BtjB,KAAKqjB,OAA0B,GAC/BrjB,KAAKwf,OAA0B,GAC/Bxf,KAAKivB,OAA0B,GAC/BjvB,KAAKojB,SAA0B,GAC/BpjB,KAAKihB,WAA0B,GAC/BjhB,KAAKghB,SAA0B,GAC/BhhB,KAAKohB,UAA0B,KAC/BphB,KAAK6gB,QAA0B,KAC/B7gB,KAAKkhB,YAA0B,KAC/BlhB,KAAKmhB,UAA0B,KAC/BnhB,KAAKogB,aAA0B,KAC/BpgB,KAAKqgB,WAA0B,KAC/BrgB,KAAKqmB,eAA0B,EAC/BrmB,KAAKkmB,eAA0B,EAC/BlmB,KAAKknB,OAA0B,EAC/BlnB,KAAKmnB,OAA0B,EAC/BnnB,KAAKgmB,YAA0B,EAC/BhmB,KAAKmmB,WAA0B,EAC/BnmB,KAAKkoB,KAA0B,EAC/BloB,KAAKmoB,KAA0B,EAC/BnoB,KAAKimB,UAA0B,EAC/BjmB,KAAKomB,SAA0B,EAC/BpmB,KAAKugB,wBAA0B,GAC/BvgB,KAAKkvB,aAA0B,GAC/BlvB,KAAKwgB,sBAA0B,GAC/BxgB,KAAKmvB,WAA0B,GAE/BnvB,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQihB,WAEhCjhB,EAAQihB,UAAUthB,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEzDK,EAAQihB,UAAUthB,UAAUuT,YAAclT,EAAQihB,UAelDjhB,EAAQif,MAAQ,WACZjf,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAYjBnF,KAAK8D,GAAK,GAYV9D,KAAK6f,aAAe,KAYpB7f,KAAK8f,WAAa,KAYlB9f,KAAKkgB,yBAA2B,GAYhClgB,KAAKsD,UAAY,KAYjBtD,KAAK0Y,QAAU,GAYf1Y,KAAKyf,KAAO,GAaZzf,KAAKygB,KAAO,GAaZzgB,KAAKsjB,SAAW,GAahBtjB,KAAK4gB,cAAgB,EAcrB5gB,KAAKslB,WAAa,EAalBtlB,KAAKulB,WAAa,EAclBvlB,KAAKwlB,eAAiB,EAatBxlB,KAAKujB,WAAY,EAajBvjB,KAAKoe,eAAiB,KAatBpe,KAAKsgB,cAAgB,KAErBtgB,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQif,OAEhCjf,EAAQif,MAAMtf,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAErDK,EAAQif,MAAMtf,UAAUuT,YAAclT,EAAQif,MAS9Cjf,EAAQ8qB,gBAAkB,WACtB9qB,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAEjBnF,KAAKsb,QAAa,CAAC,EACnBtb,KAAK+pB,SAAa,EAClB/pB,KAAKqpB,SAAa,KAElBrpB,KAAKmF,YAAY,kBAEjBlG,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ8qB,iBAEhC9qB,EAAQ8qB,gBAAgBnrB,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAE/DK,EAAQ8qB,gBAAgBnrB,UAAUuT,YAAclT,EAAQ8qB,gBASxD9qB,EAAQowB,SAAW,WACfpwB,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,mBAKjBnF,KAAKqvB,gCACD,gGAEJrvB,KAAKsvB,kCACD,+DAEJtvB,KAAKuvB,uCACD,kDAEJvvB,KAAKwvB,oCACD,+CAEJxvB,KAAKyvB,8BACD,8EAEJzvB,KAAK0vB,yCACD,qCAEJ1vB,KAAK2vB,kCACD,oFAEJ3vB,KAAK4vB,8BACD,0FAEJ5vB,KAAK6vB,4BACD,0FAEJ7vB,KAAK8vB,+BACD,0FAEJ9vB,KAAK+vB,iCACD,sEAEJ/vB,KAAKgwB,+BACD,iFAEJhwB,KAAKiwB,sBACD,kHAEJjwB,KAAKkwB,mCACD,+DAEJlwB,KAAKmwB,+BACD,qHAEJnwB,KAAKowB,gCACD,4EAKJpwB,KAAKqwB,qCACD,oNAGJrwB,KAAKswB,2BACD,kEAEJtwB,KAAKuwB,2BACD,kEAEJvwB,KAAKwwB,qCACD,gKAGJxwB,KAAKywB,oCACD,sFAEJzwB,KAAK0wB,kCACD,iJAGJ1wB,KAAK2wB,wCACD,iKAGJ3wB,KAAKmF,YAAY,kBAEjBnF,KAAK4wB,mBAEL3xB,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQowB,UAEhCpwB,EAAQowB,SAASzwB,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAExDK,EAAQowB,SAASzwB,UAAUuT,YAAclT,EAAQowB,SAMjDpwB,EAAQowB,SAASzwB,UAAUiyB,iBAAmB,WAC1C,IAAIC,EAAkB,GAClBC,EAAkB,GAEtB,IAAKD,KAAY7wB,KACkC,iBAAnC8wB,EAAe9wB,KAAK6wB,MAEhC7wB,KAAKf,EAAEgK,UAAU4nB,IAAa5xB,EAAEkI,SAAS2pB,GAEjD,EAEA9xB,EAAQkF,SAAW,IAAIlF,EAAQowB,SAU/BpwB,EAAQ6F,OAAS,SAAe+V,GAC5B5b,EAAQkG,KAAKhI,KAAK8C,MAElBA,KAAKmF,YAAY,kBAAmBlD,WAEpCjC,KAAKgtB,UAAqBpS,EAAMoS,UAAUzuB,KAAKqc,GAC/C5a,KAAKygB,KAAqB7F,EAAM6F,KAAKliB,KAAKqc,GAC1C5a,KAAKyf,KAAqB7E,EAAM6E,KAAKlhB,KAAKqc,GAC1C5a,KAAKwX,OAAqBoD,EAAMpD,OAAOjZ,KAAKqc,GAC5C5a,KAAKgc,SAAqBpB,EAAMoB,SAASzd,KAAKqc,GAC9C5a,KAAK+b,UAAqBnB,EAAMmB,UAAUxd,KAAKqc,GAC/C5a,KAAKyX,KAAqBmD,EAAMnD,KAAKlZ,KAAKqc,GAC1C5a,KAAKmZ,aAAqByB,EAAMzB,aAAa5a,KAAKqc,GAClD5a,KAAKic,SAAqBrB,EAAMqB,SAAS1d,KAAKqc,GAC9C5a,KAAK0X,QAAqBkD,EAAMlD,QAAQnZ,KAAKqc,GAC7C5a,KAAKwsB,MAAqB5R,EAAM4R,MAAMjuB,KAAKqc,GAC3C5a,KAAKiZ,OAAqB2B,EAAM3B,OAAO1a,KAAKqc,GAC5C5a,KAAKijB,aAAqBrI,EAAMqI,aAAa1kB,KAAKqc,GAClD5a,KAAK4sB,YAAqBhS,EAAMgS,YAAYruB,KAAKqc,GACjD5a,KAAK6sB,QAAqBjS,EAAMiS,QAAQtuB,KAAKqc,GAC7C5a,KAAK8sB,OAAqBlS,EAAMkS,OAAOvuB,KAAKqc,GAC5C5a,KAAKkZ,OAAqB0B,EAAM1B,OAAO3a,KAAKqc,GAC5C5a,KAAKotB,QAAqBxS,EAAMwS,QAAQ7uB,KAAKqc,GAC7C5a,KAAKktB,aAAqBtS,EAAMsS,aAAa3uB,KAAKqc,GAClD5a,KAAKmtB,YAAqBvS,EAAMuS,YAAY5uB,KAAKqc,GACjD5a,KAAK8rB,SAAqBlR,EAAMkR,SAASvtB,KAAKqc,GAC9C5a,KAAKgsB,aAAqBpR,EAAMoR,aAAaztB,KAAKqc,GAClD5a,KAAK+sB,UAAqBnS,EAAMmS,UAAUxuB,KAAKqc,GAC/C5a,KAAKitB,SAAqBrS,EAAMqS,SAAS1uB,KAAKqc,GAE9C5a,KAAKmF,YAAY,iBAAkBlD,WAEnChD,EAAEyR,OAAO1Q,MACTf,EAAEwR,KAAKzQ,KACX,EAEAhB,EAAQ4T,WAAW1V,KAAK8B,EAAQ6F,QAEhC7F,EAAQ6F,OAAOlG,UAAYlB,OAAOY,OAAOW,EAAQkG,KAAKvG,WAEtDK,EAAQ6F,OAAOlG,UAAUuT,YAAclT,EAAQ6F,OAG3C/H,EAAOD,QAAUmC,EAQrBA,EAAQ4T,WAAW1V,KAAK8B,EAAQkT,aAEhClT,EAAQsG,KAAO,UACftG,EAAQ+xB,aAAe,OAC1B,CAz6UD,CAy6UGhyB,O,kBCz7UH,OAiBC,SAASiyB,GAAG,aAAa,IAAIpoB,EAAE,SAASooB,GAAG,IAAI/yB,EAAElB,EAAEi0B,EAAE/xB,EAAE,GAAGhB,EAAE,CAAC,CAAC,IAAI,mNAAmN,CAAC,KAAK,aAAa,CAAC,KAAK,yBAAyB,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,KAAK,mBAAmB,CAAC,KAAK,aAAa,CAAC,IAAI,6DAA6D,CAAC,IAAI,+EAA+E,CAAC,IAAI,2FAA2F,CAAC,KAAK,mBAAmB,CAAC,KAAK,mBAAmB,CAAC,IAAI,2LAA2L,CAAC,IAAI,2CAA2C,CAAC,IAAI,iGAAiG,CAAC,IAAI,2FAA2F,CAAC,IAAI,+HAA+H,CAAC,IAAI,qCAAqC,CAAC,IAAI,2FAA2F,CAAC,IAAI,mHAAmH,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,IAAI,uDAAuD,CAAC,IAAI,uGAAuG,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,IAAI,yQAAyQ,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,IAAI,mEAAmE,CAAC,IAAI,2CAA2C,CAAC,IAAI,6GAA6G,CAAC,IAAI,6GAA6G,CAAC,IAAI,iGAAiG,CAAC,KAAK,aAAa,CAAC,IAAI,mNAAmN,CAAC,IAAI,uDAAuD,CAAC,KAAK,aAAa,CAAC,IAAI,mEAAmE,CAAC,IAAI,qCAAqC,CAAC,IAAI,iGAAiG,CAAC,IAAI,2FAA2F,CAAC,IAAI,yNAAyN,CAAC,KAAK,aAAa,CAAC,KAAK,yBAAyB,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,KAAK,mBAAmB,CAAC,KAAK,aAAa,CAAC,IAAI,6DAA6D,CAAC,IAAI,qFAAqF,CAAC,IAAI,2FAA2F,CAAC,KAAK,mBAAmB,CAAC,IAAI,iMAAiM,CAAC,IAAI,2CAA2C,CAAC,IAAI,iGAAiG,CAAC,IAAI,iGAAiG,CAAC,KAAK,aAAa,CAAC,IAAI,+HAA+H,CAAC,IAAI,2CAA2C,CAAC,IAAI,2FAA2F,CAAC,IAAI,yHAAyH,CAAC,KAAK,aAAa,CAAC,IAAI,uDAAuD,CAAC,IAAI,6GAA6G,CAAC,KAAK,aAAa,CAAC,IAAI,yQAAyQ,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,KAAK,aAAa,CAAC,IAAI,mEAAmE,CAAC,IAAI,2CAA2C,CAAC,IAAI,6GAA6G,CAAC,IAAI,mHAAmH,CAAC,IAAI,uGAAuG,CAAC,KAAK,aAAa,CAAC,IAAI,mNAAmN,CAAC,IAAI,uDAAuD,CAAC,KAAK,aAAa,CAAC,IAAI,yEAAyE,CAAC,IAAI,qCAAqC,CAAC,IAAI,uGAAuG,CAAC,IAAI,6FAA6F+yB,EAAED,eAAeh0B,EAAE4T,gBAAgB/H,EAAEqoB,qBAAqBD,EAAED,cAAc,MAAM,IAAI9sB,MAAM,8CAA8C2E,EAAEsoB,kBAAkB,+BAA+BtoB,EAAEqoB,sBAAsBD,EAAEvb,gBAAgB5C,eAAe,iBAAiB,eAAc,WAAW7S,KAAKmxB,oBAAoB,IAAI,IAAGH,EAAEI,kBAAkB,WAAWpxB,KAAK8E,QAAO,EAAG9E,KAAKqxB,iBAAiB,KAAKrxB,KAAKsxB,mBAAmB,MAAMtxB,KAAKuxB,gBAAgB,EAAEvxB,KAAKwxB,QAAQ,SAASxxB,KAAKyxB,sBAAsB,IAAI10B,EAAE0T,KAAKzQ,KAAK,EAAEgxB,EAAEjZ,OAAOlF,eAAe,kBAAkB,eAAc,WAAW7S,KAAK0xB,YAAY,IAAIV,EAAEI,iBAAiB,IAAGJ,EAAEW,4BAA4B,WAAW3xB,KAAK4xB,KAAK,KAAK5xB,KAAK6xB,WAAW,EAAE7xB,KAAK8xB,aAAa,EAAE/0B,EAAE0T,KAAKzQ,KAAK,EAAEgxB,EAAEe,eAAe,WAAW/xB,KAAKD,GAAG,KAAKC,KAAK4xB,KAAK,KAAK70B,EAAE0T,KAAKzQ,KAAK,EAAEgxB,EAAEgB,YAAY,WAAWhyB,KAAK1C,KAAK,GAAG0C,KAAKyb,IAAI,IAAIuV,EAAEe,eAAe/xB,KAAKiyB,gBAAgB,GAAGjyB,KAAKkyB,cAAc,GAAGlyB,KAAKmyB,cAAc,GAAGnyB,KAAKua,QAAQ,KAAKva,KAAK4a,MAAM,KAAK5a,KAAKoyB,MAAM,KAAKpyB,KAAKwxB,QAAQ,SAASxxB,KAAKqyB,cAAc,EAAEt1B,EAAE0T,KAAKzQ,KAAK,EAAEjD,EAAEoJ,OAAO6qB,EAAEgB,YAAYrzB,UAAU,CAACqV,KAAK,SAASgd,EAAEpoB,GAAG,IAAI3K,EAAE+B,KAAKjD,EAAEi0B,EAAEvW,aAAa,cAAcxc,EAAEwd,IAAI1b,GAAGixB,EAAEhxB,KAAK1C,KAAKW,EAAEwd,IAAI1b,GAAG0a,aAAa,sBAAsB,GAAGxc,EAAEohB,WAAWphB,EAAEwd,IAAImW,MAAM3zB,EAAEq0B,gBAAgBr0B,EAAE2c,MAAMhS,GAAG7L,GAAG,QAAQA,EAAEmM,eAAe,QAAQN,EAAErF,OAAOmuB,YAAYL,oBAAoBpzB,EAAEm0B,MAAM,OAAOn0B,EAAEutB,YAAY,EAAEnM,SAAS,WAAiBrf,KAAOyb,IAAImW,KAAK70B,EAAEuQ,cAAlBtN,KAAkCyb,IAAI1b,GAAG,QAAO,EAAG,EAAEuyB,cAAc,WAAW,IAAW1pB,EAAL5I,KAASyb,IAAImW,KAAK/wB,iBAAiB,kCAAkC5C,EAAE,KAAKlB,GAAG,EAAE,IAAIA,EAAE,EAAEkB,EAAE2K,EAAE7L,GAAGA,IAAIkB,EAAE6a,WAAW7a,EAAE6a,UAAS,EAAG,EAAE0S,WAAW,WAAW,IAAIwF,EAAEhxB,KAAKgxB,EAAEzW,QAAQ,SAAS3R,GAAG,OAAOA,EAAExF,MAAM,IAAI,QAAQ,IAAI,SAAS4tB,EAAEuB,gBAAgB3pB,GAAG,MAAM,QAAQooB,EAAE,SAASj0B,EAAEsM,WAAWT,EAAExF,OAAOwF,GAAG,EAAE7L,EAAE0K,GAAGupB,EAAEvV,IAAI1b,GAAG,QAAQixB,EAAEzW,SAASxd,EAAE0K,GAAGupB,EAAEvV,IAAI1b,GAAG,SAASixB,EAAEzW,SAASxd,EAAE0K,GAAGupB,EAAEvV,IAAI1b,GAAG,QAAQixB,EAAEzW,SAASyW,EAAEvV,IAAImW,OAAO70B,EAAE0K,GAAGupB,EAAEvV,IAAImW,KAAK,QAAQZ,EAAEzW,SAASxd,EAAE0K,GAAGupB,EAAEvV,IAAImW,KAAK,SAASZ,EAAEzW,SAAS,EAAE+Q,aAAa,WAAW,IAAI0F,EAAEhxB,KAAKjD,EAAE8K,IAAImpB,EAAEvV,IAAI1b,GAAG,QAAQixB,EAAEzW,SAASxd,EAAE8K,IAAImpB,EAAEvV,IAAI1b,GAAG,SAASixB,EAAEzW,SAASxd,EAAE8K,IAAImpB,EAAEvV,IAAI1b,GAAG,QAAQixB,EAAEzW,SAASyW,EAAEvV,IAAImW,OAAO70B,EAAE8K,IAAImpB,EAAEvV,IAAImW,KAAK,QAAQZ,EAAEzW,SAASxd,EAAE8K,IAAImpB,EAAEvV,IAAImW,KAAK,SAASZ,EAAEzW,UAAUyW,EAAEzW,QAAQ,IAAI,EAAEY,YAAY,SAAS6V,GAAG,IAAIpoB,EAAE5I,KAAK/B,EAAE2K,EAAEgS,MAAa5d,EAAED,EAAEuQ,cAAc0jB,EAAEpZ,OAAO,gCAA+B,GAAIpa,EAAE,GAAGgB,GAAG,EAAEg0B,EAAE,GAAGx1B,KAAKQ,EAAEoL,EAAEgS,MAAMrX,OAAO+U,UAAU1H,WAAW5T,EAAEmD,QAAQ3C,KAAKwzB,EAAEyB,kBAAkBx0B,EAAEyd,cAAczd,EAAEyd,YAAY1e,GAAG,mBAAmBiB,EAAEsF,OAAO2U,UAAUpC,aAAiF,IAAlE7X,EAAEsF,OAAO2U,UAAUpC,WAAW5Y,KAAKe,EAAEyd,YAAYzd,EAAE4d,MAAMmV,EAAEpoB,KAAa5L,EAAEmD,QAAQ,kBAAkBqyB,EAAEx1B,EAAEyd,aAAa,eAAe7R,EAAEupB,cAAc,GAAGvpB,EAAEqpB,gBAAgBrpB,EAAEspB,cAAc,CAACM,IAAIx1B,EAAEmD,QAAQ,mBAAmBqyB,EAAEx1B,EAAEyd,aAAa,eAAe7R,EAAEspB,cAAc,IAAI1zB,EAAEoK,EAAEupB,cAAcxxB,QAAQ6xB,KAAK,EAAE5pB,EAAEupB,cAAcnX,OAAOxc,EAAE,GAAGoK,EAAEupB,cAAc9wB,KAAKmxB,GAAG,QAAQ5pB,EAAEwpB,MAAMxpB,EAAEqpB,gBAAgB,CAACrpB,EAAEupB,eAAevpB,EAAEqpB,gBAAgBrpB,EAAEupB,eAAevpB,EAAEgX,iBAAiB,WAAWhX,EAAEgS,MAAMrX,OAAOmuB,YAAYF,SAAS5oB,EAAEgS,MAAM8X,sBAAsB,EAAEC,aAAa,SAAS3B,GAAG,IAAIpoB,EAAE5I,KAAK/B,EAAE+yB,EAAEpZ,OAAO,OAAOoZ,EAAEyB,kBAAkBx0B,EAAEmF,MAAM,IAAI,OAAO,IAAI,SAAS,IAAI,QAAQ,IAAI,aAAa,IAAI,QAAQwF,EAAEgqB,eAAe30B,GAAG,MAAM,IAAI,WAAW,IAAI,kBAAkB2K,EAAEiqB,kBAAkB50B,GAAG,WAAW2K,EAAEgS,MAAMrX,OAAOmuB,YAAYF,SAAS5oB,EAAEgS,MAAM8X,mBAAmB,EAAEI,YAAY,SAAS9B,GAAG,IAAIpoB,EAAE5I,KAAK/B,EAAE+yB,EAAEpZ,OAAO,KAAK,CAAC,OAAO,SAAS,SAASjX,QAAQ1C,EAAEmF,MAAM,GAAG,CAAC,GAAG,WAAWwF,EAAEgS,MAAMrX,OAAOmuB,YAAYF,QAAQ,YAAY5oB,EAAEgS,MAAMgY,eAAe30B,GAAGuN,aAAa5C,EAAEypB,cAAczpB,EAAEypB,aAAa5mB,YAAW,WAAW7C,EAAEgqB,eAAe30B,GAAG2K,EAAEgS,MAAM8X,mBAAmB,GAAE9pB,EAAEgS,MAAMrX,OAAOmuB,YAAYD,sBAAsB,CAAC,EAAEc,gBAAgB,SAAS3pB,GAAG,IAAI3K,EAAE+B,KAAKjD,EAAE,KAAKc,EAAE,KAAKb,GAAG,EAAE,GAAG,WAAW4L,EAAExF,MAAMwF,EAAEmqB,iBAAiB,UAAUnqB,EAAExF,OAAOnF,EAAEi0B,cAAcj0B,EAAEk0B,cAAcl0B,EAAEg0B,gBAAgB,GAAGh0B,EAAE2hB,kBAAkB3hB,EAAE2c,MAAMoY,4BAA4Bj2B,EAAEkB,EAAE2c,MAAMoY,iCAAiC,KAAIj2B,EAAEkB,EAAE2c,MAAMoY,4BAA4B,IAAIhC,EAAEW,6BAA8BC,KAAKhpB,EAAEgP,OAAO5a,EAAE,EAAEa,EAAEI,EAAE2c,MAAMqY,aAAaj2B,GAAGA,IAAIa,EAAE4d,IAAImW,OAAOhpB,EAAEgP,QAAQ7a,EAAE80B,aAAajpB,EAAEgP,SAAS7a,EAAE60B,OAAO70B,EAAE+0B,eAAe/0B,EAAE+0B,eAAe/0B,EAAE80B,aAAa5zB,EAAE2c,MAAMoY,4BAA4B,KAAK,WAAWpqB,EAAExF,MAAM,WAAWnF,EAAE2c,MAAMrX,OAAOmuB,YAAYF,SAASvzB,EAAE2c,MAAM8X,qBAAqB,EAAEE,eAAe,SAAS5B,GAAG,IAAIpoB,EAAE5I,KAAKjD,EAAE,KAAKc,EAAE,GAAGb,EAAE,GAAGQ,EAAE,GAAGgB,GAAG,EAAE,GAAGwyB,EAAE5tB,KAAK0C,MAAM,sBAAsB,CAAC,KAAGjI,EAAEmzB,EAAEvW,aAAa,0BAA4B,MAAM,IAAIxW,MAAM,wFAAwF,GAAG+sB,EAAEhzB,MAAM2B,OAAOiJ,EAAEgS,MAAMrX,OAAOmuB,YAAYH,gBAAgB,YAAY3oB,EAAEqpB,gBAAgBrpB,EAAEspB,cAActpB,EAAEupB,cAAc,CAAC,KAAK,IAAI30B,EAAEwzB,EAAEhzB,MAAMkL,cAActH,OAAOpD,EAAE,EAAEzB,EAAEkB,EAAEO,GAAGA,IAAIhB,EAAEA,EAAEqE,QAAQ9E,EAAE,GAAGA,EAAE,IAA4BC,EAAE,IAAIa,EAAE,OAAhCL,EAAEA,EAAEqE,QAAQ,OAAO,MAAqB,IAAI,MAAM7E,EAAEg0B,EAAEhzB,MAAM,iBAAiBgzB,EAAEhzB,QAAQ4K,EAAEqpB,gBAAgBrpB,EAAEupB,cAAcvpB,EAAEspB,cAAcl1B,EAAE,CAACA,GAAG,GAAG,EAAE61B,kBAAkB,SAAS7B,GAAG,IAA4Bh0B,EAAxB4L,EAAE5I,KAAK/B,EAAE,GAAGlB,EAAE,GAAGc,EAAE,KAAYL,GAAG,EAAE,OAAOwzB,EAAE5tB,MAAM,IAAI,WAAWrG,EAAE,yBAAyB,MAAM,IAAI,kBAAkBA,EAAE,SAAS,IAAIC,EAAE4L,EAAE6S,IAAI1b,GAAGc,iBAAiB9D,GAAGS,EAAE,EAAEK,EAAEb,EAAEQ,GAAGA,KAAKK,EAAEq1B,SAASr1B,EAAEs1B,WAAWt1B,EAAEG,OAAOC,EAAEoD,KAAKxD,EAAEG,OAAO4K,EAAEspB,cAAc,GAAGtpB,EAAEupB,cAAcl0B,EAAE,QAAQ2K,EAAEwpB,MAAMxpB,EAAEqpB,gBAAgB,CAACh0B,GAAG2K,EAAEqpB,gBAAgBh0B,CAAC,EAAE2hB,eAAe,SAASoR,GAAG,IAAkBj0B,EAAKc,EAAnB+K,EAAE5I,KAAK/B,EAAE,KAAejB,EAAE,GAAGQ,GAAG,EAAE,IAA8CK,EAAE,CAAC,iBAA7Cd,EAAE6L,EAAEgS,MAAMrX,OAAO+U,UAAU1H,QAAQhP,QAA4B,gBAAgB7E,GAAGqlB,KAAK,MAAM4O,EAAEA,GAAGpoB,EAAE6S,IAAI1b,GAAGc,iBAAiBhD,GAAGL,EAAE,EAAES,EAAE+yB,EAAExzB,GAAGA,IAAIR,EAAEo2B,QAAQn1B,EAAEwc,aAAa,gBAAgB,SAAS,SAAS7R,EAAEyqB,cAAcp1B,EAAEjB,EAAE,EAAEq2B,cAAc,SAASrC,EAAEpoB,GAAG,IAAiFpL,EAA7ES,EAAE+B,KAAKnC,EAAEmzB,EAAEvW,aAAa,QAAQ7R,GAAG5L,EAAEiB,EAAEk0B,cAAcnvB,OAAO/E,EAAEi0B,eAAoB10B,EAAET,EAAEsU,aAAapT,EAAE2c,MAAMrX,OAAO+N,WAAW1I,EAAE3K,EAAE2c,MAAMrX,OAAO+N,WAAWoF,gBAAgB1Z,EAAE2D,QAAQ9C,IAAI,EAAEd,EAAEiJ,SAASgrB,EAAExzB,GAAGT,EAAEkJ,YAAY+qB,EAAExzB,EAAE,EAAE81B,SAAS,WAAW,IAAItC,EAAEhxB,KAAK4I,EAAEooB,EAAEvV,IAAI1b,GAAGc,iBAAiB,gCAAgC5C,EAAE+yB,EAAEvV,IAAI1b,GAAGc,iBAAiB,uDAAuD9D,EAAEi0B,EAAEmB,cAAcnvB,OAAOguB,EAAEkB,eAAer0B,GAAE,EAAGb,EAAE,KAAKQ,GAAG,EAAE,IAAIoL,EAAEjJ,QAAQqxB,EAAEpR,eAAehX,GAAE,GAAIpL,EAAE,EAAER,EAAEiB,EAAET,GAAGA,IAAI,OAAOK,EAAEd,EAAE4D,QAAQ3D,EAAEgB,QAAQ,EAAEhB,EAAEu2B,QAAQrqB,eAAe,IAAI,SAASlM,EAAEm2B,SAASt1B,EAAE,MAAM,IAAI,QAAQb,EAAEk2B,QAAQr1B,EAAE,IAAImzB,EAAEvY,SAAS5F,eAAe,iBAAiB,eAAc,WAAW7S,KAAKizB,aAAa,EAAE,IAAGjC,EAAE1sB,MAAMuO,eAAe,iBAAiB,eAAc,WAAW7S,KAAKizB,aAAa,GAAGjzB,KAAKwzB,iBAAiB,CAAC,EAAExzB,KAAKgzB,4BAA4B,IAAI,IAAGhC,EAAE1sB,MAAMuO,eAAe,gBAAgB,eAAc,WAAW,IAAIjK,EAAE5I,KAAK/B,EAAE,KAAK,GAAG2K,EAAErF,OAAOmuB,YAAY5sB,OAAO,CAAC,OAAO8D,EAAErF,OAAO4U,SAASlC,OAAO,IAAI,QAAQhY,EAAE2K,EAAE6S,IAAInY,UAAU,MAAM,IAAI,SAASrF,EAAE2K,EAAE6S,IAAIhc,SAAS,MAAM,QAAQ,MAAM,IAAIwE,MAAM+sB,EAAE9sB,SAASsrB,qCAAqC5mB,EAAE6S,IAAIwX,aAAah1B,EAAE4C,iBAAiB,sBAAsB,CAAC,IAAGmwB,EAAE1sB,MAAMuO,eAAe,qBAAqB,eAAc,WAAiB7S,KAAOuD,OAAOmuB,YAAY5sB,SAA1B9E,KAAqCuD,OAAO4U,SAASnC,MAAK,EAAG,IAAGgb,EAAE1sB,MAAMuO,eAAe,sBAAsB,eAAc,WAAW,IAAIme,EAAEhxB,KAAKgxB,EAAEztB,OAAOmuB,YAAYJ,mBAAmBN,EAAEztB,OAAOmuB,YAAYJ,mBAAmBpoB,cAActH,OAAOovB,EAAEztB,OAAOmuB,YAAYL,iBAAiBL,EAAEztB,OAAOmuB,YAAYL,iBAAiBnoB,cAActH,MAAM,IAAGovB,EAAE1sB,MAAMuO,eAAe,cAAc,eAAc,WAAiB7S,KAAOyb,IAAIwX,aAAatzB,QAAxBK,KAAkCyzB,mBAAmB,IAAGzC,EAAE1sB,MAAMuO,eAAe,sBAAsB,eAAc,WAAW,IAAWjK,EAAE,KAAK3K,GAAG,EAAE,IAAIA,EAAE,EAAE2K,EAAzB5I,KAA6BizB,aAAah1B,GAAGA,IAAI2K,EAAEgX,gBAAgB,IAAGoR,EAAE1sB,MAAMuO,eAAe,gBAAgB,eAAc,WAAW,IAAWjK,EAAE,KAAK3K,GAAG,EAAE,IAAIA,EAAE,EAAE2K,EAAzB5I,KAA6BizB,aAAah1B,GAAGA,IAAI2K,EAAE0iB,cAAc,IAAG0F,EAAE1sB,MAAM6B,OAAO,CAACstB,kBAAkB,WAAW,IAAI7qB,EAAE5I,KAAK/B,EAAE,KAAKlB,EAAE,KAAKc,GAAG,EAAE,IAAIA,EAAE,EAAEd,EAAE6L,EAAE6S,IAAIwX,aAAap1B,GAAGA,IAAI,IAAGI,EAAE,IAAI+yB,EAAEgB,aAAche,KAAKjX,EAAE6L,GAAGA,EAAEqqB,aAAa5xB,KAAKpD,GAAGA,EAAEX,KAAK,CAAC,QAAG,IAAoBsL,EAAE4qB,iBAAiBv1B,EAAEX,MAAM,MAAM,IAAI2G,MAAM,mDAAmDhG,EAAEX,KAAK,oBAAoBsL,EAAE4qB,iBAAiBv1B,EAAEX,MAAMW,CAAC,CAAC,EAAEy1B,2BAA2B,SAAS9qB,GAAG,IAAW/K,EAAE,IAAImzB,EAAElH,gBAAgB9sB,EAAE,KAAKQ,GAAG,EAAE,IAAIK,EAAEksB,QAA/C/pB,KAAyDuD,OAAOyU,UAAUlT,OAAOjH,EAAEyd,QAAQ,IAAI0V,EAAE5X,cAAc5b,EAAE,EAAEA,EAAEoL,EAAEjJ,OAAOnC,IAAW,kBAAPR,EAAE4L,EAAEpL,IAAuBK,EAAEksB,QAAQ/sB,EAAE,mBAAmBA,IAAIa,EAAEwrB,SAASrsB,GAAG,OAAOD,EAAE2T,OAAO7S,GAAGA,CAAC,EAAE81B,oBAAoB,WAAW,IAAW/qB,EAAO3K,EAAE,KAAKJ,EAAE,KAAKb,EAAE,GAAGQ,EAAE,GAAGgB,EAAE,GAAGg0B,GAAG,EAAE,IAAIA,EAAE,EAAEA,EAAtDxyB,KAA0DizB,aAAatzB,OAAO6yB,KAAK30B,EAAnFmC,KAAuFizB,aAAaT,GAAGP,iBAAiBtyB,SAAS3C,EAAEqE,KAAKxD,GAAGW,EAAE6C,KAAK,IAAI,OAAOuH,EAAE,WAAW,IAAIooB,EAAE,KAAKpoB,EAAE,GAAG3K,GAAG,EAAE,IAAIA,EAAE,EAAEA,EAAEjB,EAAE2C,OAAO1B,IAAI+yB,EAAEh0B,EAAEiB,GAAGO,EAAEP,IAAIyC,MAAMY,QAAQ0vB,KAAKA,EAAEA,EAAE5O,KAAK,KAAKxZ,EAAEvH,KAAK2vB,GAAGpoB,EAAE7L,EAAEgR,MAAMnF,GAAGpL,EAAE6D,KAAKuH,EAAE,EAAE3K,EAAE,SAAS+yB,GAAU,IAAI,IAAIj0B,EAAEC,EAAjBg0B,EAAEA,GAAG,GAAiBxyB,EAAEwyB,GAAGj0B,EAAE4C,QAAQqxB,EAAEh0B,EAAE2C,OAAO,EAAE1B,EAAE+yB,EAAE,GAAGpoB,IAAIpK,EAAEwyB,KAAKxyB,EAAEwyB,GAAG,CAAC,EAAEh0B,EAAE2C,QAAQ1B,IAAIT,GAAG,EAAE,EAAEo2B,uBAAuB,SAAS5C,GAAG,IAAkBj0B,EAAE,GAAGc,EAAE,GAAGb,EAAE,GAAGQ,GAAG,EAAE,IAAIwzB,EAAErxB,OAAO,MAAM,GAAG,GAAG,OAAzDK,KAAkEuD,OAAOmuB,YAAYJ,qBAAqBt0B,EAAE,MAAMg0B,EAAErxB,OAAO,EAAE,CAAC,IAAInC,EAAE,EAAEA,EAAEwzB,EAAErxB,OAAOnC,IAAWK,EAALmzB,EAAExzB,GAAO4kB,KAAKplB,GAAGD,EAAE4D,QAAQ9C,GAAG,GAAGd,EAAEsE,KAAKxD,GAAG,OAAOd,EAAEqlB,KAAK,KAAK,CAAC,OAAO4O,EAAE,GAAG5O,KAAKplB,EAAE,EAAE01B,kBAAkB,WAAW,IAAI1B,EAAEhxB,KAAK4I,EAAEooB,EAAEtQ,gBAAgBze,WAAWhE,EAAE+yB,EAAE2C,sBAAsB52B,EAAEi0B,EAAE4C,uBAAuB31B,GAAGJ,EAAE,KAAKb,EAAE,CAAC,EAAE,MAAM,KAAKD,IAAIA,EAAEi0B,EAAEztB,OAAO4U,SAAShC,eAAevN,EAAE0S,QAAQ7a,SAAS1D,EAAEC,EAAEwa,OAAO5O,EAAE0S,QAAQ,mBAAmBzd,EAAEmzB,EAAEztB,OAAO2U,UAAUiZ,uBAAuBn0B,EAAEa,EAAEb,IAAIg0B,EAAE/U,SAASjf,EAAE4L,EAAEmhB,QAAQnhB,EAAEygB,SAAS,EAAEwK,wBAAwB,SAAS7C,EAAEpoB,GAAG,IAAW7L,EAAE,KAAK,GAAG6L,EAAElI,MAAMY,QAAQsH,GAAGA,EAAE,CAACA,QAAG,KAAoB7L,EAA5DiD,KAAgEwzB,iBAAiBxC,IAAI,MAAM,IAAI/sB,MAAM,uEAAuE+sB,EAAE,KAAKj0B,EAAEo1B,cAAcvpB,EAAE9F,QAAQ,QAAQ/F,EAAEq1B,MAAMr1B,EAAEk1B,gBAAgB,CAACl1B,EAAEo1B,eAAep1B,EAAEk1B,gBAAgBl1B,EAAEo1B,cAAcp1B,EAAEu2B,SAASv2B,EAAEo1B,cAAc,EAAE2B,wBAAwB,SAAS9C,GAAG,IAAW/yB,EAAE,KAAK,QAAG,KAAoBA,EAAnC+B,KAAuCwzB,iBAAiBxC,IAAI,MAAM,IAAI/sB,MAAM,uEAAuE+sB,EAAE,KAAK,OAAO/yB,EAAEg0B,gBAAgBnvB,OAAO,IAAIkuB,EAAEnsB,OAAOgO,eAAe,iBAAiB,eAAc,SAASme,GAAGhxB,KAAK0yB,kBAAkB1B,EAAE0B,kBAAkBn0B,KAAKyyB,GAAGhxB,KAAK6zB,wBAAwB7C,EAAE6C,wBAAwBt1B,KAAKyyB,GAAGhxB,KAAK8zB,wBAAwB9C,EAAE8C,wBAAwBv1B,KAAKyyB,EAAE,GAAE,EAAKpoB,EAAExD,KAAK,oBAAoBwD,EAAEtD,KAAK,sBAAsBsD,EAAEsoB,kBAAkB,QAAQtoB,EAAEqoB,qBAAqB,SAAmC,iBAAiBn0B,EAAOA,EAAOD,QAAQ+L,OAA2E,KAA3BmrB,aAAkB,OAAOnrB,CAAE,+BAAgI,CAA1ghB,CAA4ghB7J,O,iDCjB7ghBjC,EAAOD,QAAU,CAChBm3B,SAAU,mBACVC,KAAM,I,kCCFP,IAAIC,OAAO,wBAAyB,CAChCC,MAAM,EACNC,cAAe,EACfC,aAAc,GACdC,WAAY,CACRrJ,OAAQ,sBACRsJ,OAAQ,uBAGZC,YAAa,CAET,IAAM,CACFJ,cAAe,K,iBCZ3B,WACI,IAAIK,EAAMh1B,SAASi1B,uBAAuB,mBACtCC,EAAUl1B,SAASi1B,uBAAuB,uBAE9C,QAAuB,IAAXD,EAAI,IAAgC,MAAVA,EAAI,SAAoC,IAAfE,EAAQ,IAAoC,MAAdA,EAAQ,GAAY,CAC7GA,EAAQ,GAAGC,UAAUC,IAAI,+BACzBJ,EAAI,GAAGG,UAAUC,IAAI,2BAErB,IAAM,IAAI93B,EAAI,EAAGA,EAAI03B,EAAI90B,OAAQ5C,IAC7B03B,EAAI13B,GAAG4K,iBAAkB,SAAS,SAASzE,GACvC,IAAI4xB,EAAY5xB,EAAM6xB,cAAcrd,QAAQsd,IACxCC,EAAgBx1B,SAASi1B,uBAAwB,+BACjDQ,EAAYz1B,SAASi1B,uBAAwB,2BAE7CO,EAAct1B,SACds1B,EAAc,GAAGL,UAAU1b,OAAO,+BAClCgc,EAAU,GAAGN,UAAU1b,OAAO,4BAGlC,IAAM,IAAI1b,EAAI,EAAGA,EAAIm3B,EAAQh1B,OAAQnC,IAC7Bs3B,IAAcH,EAAQn3B,GAAGka,QAAQsd,MACjCL,EAAQn3B,GAAGo3B,UAAUC,IAAI,+BACzBJ,EAAIj3B,GAAGo3B,UAAUC,IAAI,2BAGjC,GAER,CACJ,CAEAM,E,gBC9BA,IAAIb,EAAa70B,SAASi1B,uBAAuB,cAC7CU,EAAmBd,EAAW,GAAGe,aACjCC,EAAmBhB,EAAW,GAAGpoB,UAErCxG,EAAE3G,QAAQw2B,QAAO,WACS91B,SAASi1B,uBAAuB,qBACzCj1B,SAASi1B,uBAAuB,UAE7C,GAAIhvB,EAAE3G,QAAQiN,aAAespB,EACzB,IAAK,IAAIv4B,EAAI,EAAGA,EAAIu3B,EAAW30B,OAAQ5C,IACnCu3B,EAAWv3B,GAAGuS,MAAMpC,OAASkoB,EAAmB,KAChDd,EAAWv3B,GAAG63B,UAAUC,IAAI,sBAIpC,GAAInvB,EAAE3G,QAAQiN,YAAcspB,EACxB,IAAK,IAAInpB,EAAI,EAAGA,EAAImoB,EAAW30B,OAAQwM,IACnCmoB,EAAWnoB,GAAGmD,MAAMpC,OAAS,OAC7BonB,EAAWnoB,GAAGyoB,UAAU1b,OAAO,qBAG3C,IAIAzZ,SAASkI,iBAAiB,oBAAoB,KAE7C,MAAM6tB,EAAaz2B,OAAO02B,WAAW,uBAG/BC,EAAgBxyB,IACrBA,EAAM6vB,gBAAgB,EAIjB4C,EAAsBl2B,SAASoB,iBAAiB,2BAGtD,IAAK,IAAI9D,EAAI,EAAGA,EAAI44B,EAAoBh2B,OAAQ5C,IAAK,CAGpD,IAAI64B,EAAqBD,EAAoB54B,GAG7C,MAAM84B,EAA2BD,EAAmBP,aAGzBO,EAAmBrU,cAAc,KAGzC5Z,iBAAiB,QAAS+tB,GAAc,GAG3D,MAAMI,EAAiBF,EAAmBrU,cAAc,MAErDiU,EAAWr1B,UAEb21B,EAAexmB,MAAMma,UAAeoM,EAA2B,EAAM,KAEvE,I,gBC3DD,IAAIE,EAAerwB,EAAE,4BACjBswB,EAAatwB,EAAE,oEACfgI,EAAOhI,EAAE,QAEb,QAAgC,IAApBqwB,EAAa,IAAyC,MAAnBA,EAAa,IAAch3B,OAAOk3B,WAAa,IAAM,CAEhGvoB,EAAK,GAAGknB,UAAUC,IAAI,yBAKtB,IAAIqB,EAAcxwB,EAAE,yCAChBywB,EAAgBzwB,EAAE,oDAEtBjG,SAASiO,KAAK/F,iBAAiB,aAAa,SAASiB,GAEjDstB,EAAY,GAAG5mB,MAAMlC,KAASxE,EAAEwtB,QAAU,GAAO,KACjDF,EAAY,GAAG5mB,MAAMjC,IAAQzE,EAAEytB,QAAUt3B,OAAO0Q,YAAgB,IAEpE,IAEA,IAAK,IAAItD,EAAI,EAAGA,EAAI6pB,EAAWr2B,OAAQwM,IACnC6pB,EAAW7pB,GAAGxE,iBAAiB,cAAc,WACzC,IAAI2uB,EAAWt2B,KAAKuhB,cAAc,2BAA2B9G,aAAa,kBAC1E0b,EAAcI,KAAK,MAAOD,GAC1BJ,EAAY,GAAGtB,UAAUC,IAAI,sBACjC,IAEAmB,EAAW7pB,GAAGxE,iBAAiB,cAAc,WACzCuuB,EAAY,GAAGtB,UAAU1b,OAAO,sBACpC,GAGR,C,iBCjCIzZ,SAAS+2B,cAAgB,OAAOC,KAAKC,UAAUC,aAC/C9nB,OAAO,mBAAmB+nB,MAAK,WAC3B,IAAI34B,EAAI4Q,OAAO7O,MACXlB,EAAI,OAASb,EAAEs4B,KAAK,OAAS,IAC7B13B,EAAIZ,EAAEuP,SACNnQ,EAAIwR,OAAO,gCACfhQ,EAAEiuB,OAAOzvB,GACf,IAAIw5B,EAAS,QACTh4B,EAAE8G,SAAS,yBACdkxB,EAAS,WAEJx5B,EAAEy5B,IAAI,CACF,SAAqB,WACrB,IAAiB,IACjB,KAAkB,IAClB,OAA0B,OAC1B,MAA0B,OAC1B,kBAA0BD,EAC1B,oBAA0B,YAC1B,sBAA0B,UAC1B,mBAA0B/3B,IAG9Bb,EAAEwhB,MACN,G,wGCrBJ,IAAIsX,EAAct3B,SAAS8hB,cAAc,sBAEzC,QAA4B,IAAhBwV,GAA8C,MAAfA,EAAsB,CAE7D/3B,IAAQgG,IAAIgyB,KAEZ,IAAIC,EAAmBx3B,SAAS8hB,cAAc,yBAC1C2V,EAAkBz3B,SAAS8hB,cAAc,yBAEzC4V,EAAen4B,IAAQ+3B,EAAa,CACpC/e,UAAW,CACPlT,QAAQ,GAEZ4sB,YAAa,CACT5sB,QAAQ,KAIhBmyB,EAAiBtvB,iBAAiB,UAAU,WACxCwvB,EAAa3f,OAAOxX,KAAKhC,MAC7B,IAEAk5B,EAAgBvvB,iBAAiB,UAAU,WACvCwvB,EAAa3f,OAAOxX,KAAKhC,MAC7B,GAEJ,C,KCXAyB,SAASkI,iBAAiB,oBAAoB,YAC1C,WACI,MAAMyvB,EAAS33B,SAASoB,iBAAkB,kBACpCw2B,EAAM53B,SAAS8hB,cAAe,SAC9B7T,EAAOjO,SAAS8hB,cAAe,QAErC6V,EAAO,GAAGzvB,iBAAkB,SAAS,WACjC0vB,EAAIzC,UAAUwC,OAAQ,gBACtB1pB,EAAKknB,UAAUwC,OAAQ,eAC3B,GACJ,CAEAE,GAGA,WACI,MAAMC,EAAU93B,SAASoB,iBAAkB,gBAE3C,IAAM,IAAI9D,EAAI,EAAGA,EAAIw6B,EAAQ53B,OAAQ5C,IACjCw6B,EAAQx6B,GAAG4K,iBAAkB,SAAS,WACnC3H,KAAK40B,UAAUwC,OAAQ,uBAER33B,SAAS+3B,qBAAsB,UAAWz6B,GAClD06B,KAAO,aACjB,GAER,CAEAC,EACJ,G","file":"bundle.2451ebfe.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 = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 2);\n","/**!\n * MixItUp v3.3.1\n * A high-performance, dependency-free library for animated filtering, sorting and more\n * Build 94e0fbf6-cd0b-4987-b3c0-14b59b67b8a0\n *\n * @copyright Copyright 2014-2018 KunkaLabs Limited.\n * @author    KunkaLabs Limited.\n * @link      https://www.kunkalabs.com/mixitup/\n *\n * @license   Commercial use requires a commercial license.\n *            https://www.kunkalabs.com/mixitup/licenses/\n *\n *            Non-commercial use permitted under same terms as CC BY-NC 3.0 license.\n *            http://creativecommons.org/licenses/by-nc/3.0/\n */\n\n(function(window) {\n    'use strict';\n\n    var mixitup = null,\n        h       = null;\n\n    (function() {\n        var VENDORS = ['webkit', 'moz', 'o', 'ms'],\n            canary  = window.document.createElement('div'),\n            i       = -1;\n\n        // window.requestAnimationFrame\n\n        for (i = 0; i < VENDORS.length && !window.requestAnimationFrame; i++) {\n            window.requestAnimationFrame = window[VENDORS[i] + 'RequestAnimationFrame'];\n        }\n\n        // Element.nextElementSibling\n\n        if (typeof canary.nextElementSibling === 'undefined') {\n            Object.defineProperty(window.Element.prototype, 'nextElementSibling', {\n                get: function() {\n                    var el = this.nextSibling;\n\n                    while (el) {\n                        if (el.nodeType === 1) {\n                            return el;\n                        }\n\n                        el = el.nextSibling;\n                    }\n\n                    return null;\n                }\n            });\n        }\n\n        // Element.matches\n\n        (function(ElementPrototype) {\n            ElementPrototype.matches =\n                ElementPrototype.matches ||\n                ElementPrototype.machesSelector ||\n                ElementPrototype.mozMatchesSelector ||\n                ElementPrototype.msMatchesSelector ||\n                ElementPrototype.oMatchesSelector ||\n                ElementPrototype.webkitMatchesSelector ||\n                function (selector) {\n                    return Array.prototype.indexOf.call(this.parentElement.querySelectorAll(selector), this) > -1;\n                };\n        })(window.Element.prototype);\n\n        // Object.keys\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys\n\n        if (!Object.keys) {\n            Object.keys = (function() {\n                var hasOwnProperty      = Object.prototype.hasOwnProperty,\n                    hasDontEnumBug      = false,\n                    dontEnums           = [],\n                    dontEnumsLength     = -1;\n\n                hasDontEnumBug = !({\n                    toString: null\n                })\n                    .propertyIsEnumerable('toString');\n\n                dontEnums = [\n                    'toString',\n                    'toLocaleString',\n                    'valueOf',\n                    'hasOwnProperty',\n                    'isPrototypeOf',\n                    'propertyIsEnumerable',\n                    'constructor'\n                ];\n\n                dontEnumsLength = dontEnums.length;\n\n                return function(obj) {\n                    var result  = [],\n                        prop    = '',\n                        i       = -1;\n\n                    if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {\n                        throw new TypeError('Object.keys called on non-object');\n                    }\n\n                    for (prop in obj) {\n                        if (hasOwnProperty.call(obj, prop)) {\n                            result.push(prop);\n                        }\n                    }\n\n                    if (hasDontEnumBug) {\n                        for (i = 0; i < dontEnumsLength; i++) {\n                            if (hasOwnProperty.call(obj, dontEnums[i])) {\n                                result.push(dontEnums[i]);\n                            }\n                        }\n                    }\n\n                    return result;\n                };\n            }());\n        }\n\n        // Array.isArray\n        // https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray\n\n        if (!Array.isArray) {\n            Array.isArray = function(arg) {\n                return Object.prototype.toString.call(arg) === '[object Array]';\n            };\n        }\n\n        // Object.create\n        // https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/create\n\n        if (typeof Object.create !== 'function') {\n            Object.create = (function(undefined) {\n                var Temp = function() {};\n\n                return function (prototype, propertiesObject) {\n                    if (prototype !== Object(prototype) && prototype !== null) {\n                        throw TypeError('Argument must be an object, or null');\n                    }\n\n                    Temp.prototype = prototype || {};\n\n                    var result = new Temp();\n\n                    Temp.prototype = null;\n\n                    if (propertiesObject !== undefined) {\n                        Object.defineProperties(result, propertiesObject);\n                    }\n\n                    if (prototype === null) {\n                        /* jshint ignore:start */\n                        result.__proto__ = null;\n                        /* jshint ignore:end */\n                    }\n\n                    return result;\n                };\n            })();\n        }\n\n        // String.prototyoe.trim\n\n        if (!String.prototype.trim) {\n            String.prototype.trim = function() {\n                return this.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n            };\n        }\n\n        // Array.prototype.indexOf\n        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf\n\n        if (!Array.prototype.indexOf) {\n            Array.prototype.indexOf = function(searchElement) {\n                var n, k, t, len;\n\n                if (this === null) {\n                    throw new TypeError();\n                }\n\n                t = Object(this);\n\n                len = t.length >>> 0;\n\n                if (len === 0) {\n                    return -1;\n                }\n\n                n = 0;\n\n                if (arguments.length > 1) {\n                    n = Number(arguments[1]);\n\n                    if (n !== n) {\n                        n = 0;\n                    } else if (n !== 0 && n !== Infinity && n !== -Infinity) {\n                        n = (n > 0 || -1) * Math.floor(Math.abs(n));\n                    }\n                }\n\n                if (n >= len) {\n                    return -1;\n                }\n\n                for (k = n >= 0 ? n : Math.max(len - Math.abs(n), 0); k < len; k++) {\n                    if (k in t && t[k] === searchElement) {\n                        return k;\n                    }\n                }\n\n                return -1;\n            };\n        }\n\n        // Function.prototype.bind\n        // https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_objects/Function/bind\n\n        if (!Function.prototype.bind) {\n            Function.prototype.bind = function(oThis) {\n                var aArgs, self, FNOP, fBound;\n\n                if (typeof this !== 'function') {\n                    throw new TypeError();\n                }\n\n                aArgs = Array.prototype.slice.call(arguments, 1);\n\n                self = this;\n\n                FNOP = function() {};\n\n                fBound = function() {\n                    return self.apply(this instanceof FNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments)));\n                };\n\n                if (this.prototype) {\n                    FNOP.prototype = this.prototype;\n                }\n\n                fBound.prototype = new FNOP();\n\n                return fBound;\n            };\n        }\n\n        // Element.prototype.dispatchEvent\n\n        if (!window.Element.prototype.dispatchEvent) {\n            window.Element.prototype.dispatchEvent = function(event) {\n                try {\n                    return this.fireEvent('on' + event.type, event);\n                } catch (err) {}\n            };\n        }\n    })();\n\n    /**\n     * The `mixitup()` \"factory\" function creates and returns individual instances\n     * of MixItUp, known as \"mixers\", on which API methods can be called.\n     *\n     * When loading MixItUp via a script tag, the factory function is accessed\n     * via the global variable `mixitup`. When using a module loading\n     * system (e.g. ES2015, CommonJS, RequireJS), the factory function is\n     * exported into your module when you require the MixItUp library.\n     *\n     * @example\n     * mixitup(container [,config] [,foreignDoc])\n     *\n     * @example <caption>Example 1: Creating a mixer instance with an element reference</caption>\n     * var containerEl = document.querySelector('.container');\n     *\n     * var mixer = mixitup(containerEl);\n     *\n     * @example <caption>Example 2: Creating a mixer instance with a selector string</caption>\n     * var mixer = mixitup('.container');\n     *\n     * @example <caption>Example 3: Passing a configuration object</caption>\n     * var mixer = mixitup(containerEl, {\n     *     animation: {\n     *         effects: 'fade scale(0.5)'\n     *     }\n     * });\n     *\n     * @example <caption>Example 4: Passing an iframe reference</caption>\n     * var mixer = mixitup(containerEl, config, foreignDocument);\n     *\n     * @global\n     * @namespace\n     * @public\n     * @kind        function\n     * @since       3.0.0\n     * @param       {(Element|string)}  container\n     *      A DOM element or selector string representing the container(s) on which to instantiate MixItUp.\n     * @param       {object}            [config]\n     *      An optional \"configuration object\" used to customize the behavior of the MixItUp instance.\n     * @param       {object}            [foreignDoc]\n     *      An optional reference to a `document`, which can be used to control a MixItUp instance in an iframe.\n     * @return      {mixitup.Mixer}\n     *      A \"mixer\" object holding the MixItUp instance.\n     */\n\n    mixitup = function(container, config, foreignDoc) {\n        var el                  = null,\n            returnCollection    = false,\n            instance            = null,\n            facade              = null,\n            doc                 = null,\n            output              = null,\n            instances           = [],\n            id                  = '',\n            elements            = [],\n            i                   = -1;\n\n        doc = foreignDoc || window.document;\n\n        if (returnCollection = arguments[3]) {\n            // A non-documented 4th paramater enabling control of multiple instances\n\n            returnCollection = typeof returnCollection === 'boolean';\n        }\n\n        if (typeof container === 'string') {\n            elements = doc.querySelectorAll(container);\n        } else if (container && typeof container === 'object' && h.isElement(container, doc)) {\n            elements = [container];\n        } else if (container && typeof container === 'object' && container.length) {\n            // Although not documented, the container may also be an array-like list of\n            // elements such as a NodeList or jQuery collection, is returnCollection is true\n\n            elements = container;\n        } else {\n            throw new Error(mixitup.messages.errorFactoryInvalidContainer());\n        }\n\n        if (elements.length < 1) {\n            throw new Error(mixitup.messages.errorFactoryContainerNotFound());\n        }\n\n        for (i = 0; el = elements[i]; i++) {\n            if (i > 0 && !returnCollection) break;\n\n            if (!el.id) {\n                id = 'MixItUp' + h.randomHex();\n\n                el.id = id;\n            } else {\n                id = el.id;\n            }\n\n            if (mixitup.instances[id] instanceof mixitup.Mixer) {\n                instance = mixitup.instances[id];\n\n                if (!config || (config && config.debug && config.debug.showWarnings !== false)) {\n                    console.warn(mixitup.messages.warningFactoryPreexistingInstance());\n                }\n            } else {\n                instance = new mixitup.Mixer();\n\n                instance.attach(el, doc, id, config);\n\n                mixitup.instances[id] = instance;\n            }\n\n            facade = new mixitup.Facade(instance);\n\n            if (config && config.debug && config.debug.enable) {\n                instances.push(instance);\n            } else {\n                instances.push(facade);\n            }\n        }\n\n        if (returnCollection) {\n            output = new mixitup.Collection(instances);\n        } else {\n            // Return the first instance regardless\n\n            output = instances[0];\n        }\n\n        return output;\n    };\n\n    /**\n     * The `.use()` static method is used to extend the functionality of mixitup with compatible\n     * extensions and libraries in an environment with modular scoping e.g. ES2015, CommonJS, or RequireJS.\n     *\n     * You need only call the `.use()` function once per project, per extension, as module loaders\n     * will cache a single reference to MixItUp inclusive of all changes made.\n     *\n     * @example\n     * mixitup.use(extension)\n     *\n     * @example <caption>Example 1: Extending MixItUp with the Pagination Extension</caption>\n     *\n     * import mixitup from 'mixitup';\n     * import mixitupPagination from 'mixitup-pagination';\n     *\n     * mixitup.use(mixitupPagination);\n     *\n     * // All mixers created by the factory function in all modules will now\n     * // have pagination functionality\n     *\n     * var mixer = mixitup('.container');\n     *\n     * @public\n     * @name     use\n     * @memberof mixitup\n     * @kind     function\n     * @static\n     * @since    3.0.0\n     * @param    {*}  extension   A reference to the extension or library to be used.\n     * @return   {void}\n     */\n\n    mixitup.use = function(extension) {\n        mixitup.Base.prototype.callActions.call(mixitup, 'beforeUse', arguments);\n\n        // Call the extension's factory function, passing\n        // the mixitup factory as a paramater\n\n        if (typeof extension === 'function' && extension.TYPE === 'mixitup-extension') {\n            // Mixitup extension\n\n            if (typeof mixitup.extensions[extension.NAME] === 'undefined') {\n                extension(mixitup);\n\n                mixitup.extensions[extension.NAME] = extension;\n            }\n        } else if (extension.fn && extension.fn.jquery) {\n            // jQuery\n\n            mixitup.libraries.$ = extension;\n        }\n\n        mixitup.Base.prototype.callActions.call(mixitup, 'afterUse', arguments);\n    };\n\n    mixitup.instances   = {};\n    mixitup.extensions  = {};\n    mixitup.libraries   = {};\n\n    /**\n     * @private\n     */\n\n    h = {\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        cls\n         * @return  {boolean}\n         */\n\n        hasClass: function(el, cls) {\n            return !!el.className.match(new RegExp('(\\\\s|^)' + cls + '(\\\\s|$)'));\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        cls\n         * @return  {void}\n         */\n\n        addClass: function(el, cls) {\n            if (!this.hasClass(el, cls)) el.className += el.className ? ' ' + cls : cls;\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        cls\n         * @return  {void}\n         */\n\n        removeClass: function(el, cls) {\n            if (this.hasClass(el, cls)) {\n                var reg = new RegExp('(\\\\s|^)' + cls + '(\\\\s|$)');\n\n                el.className = el.className.replace(reg, ' ').trim();\n            }\n        },\n\n        /**\n         * Merges the properties of the source object onto the\n         * target object. Alters the target object.\n         *\n         * @private\n         * @param   {object}    destination\n         * @param   {object}    source\n         * @param   {boolean}   [deep=false]\n         * @param   {boolean}   [handleErrors=false]\n         * @return  {void}\n         */\n\n        extend: function(destination, source, deep, handleErrors) {\n            var sourceKeys  = [],\n                key         = '',\n                i           = -1;\n\n            deep = deep || false;\n            handleErrors = handleErrors || false;\n\n            try {\n                if (Array.isArray(source)) {\n                    for (i = 0; i < source.length; i++) {\n                        sourceKeys.push(i);\n                    }\n                } else if (source) {\n                    sourceKeys = Object.keys(source);\n                }\n\n                for (i = 0; i < sourceKeys.length; i++) {\n                    key = sourceKeys[i];\n\n                    if (!deep || typeof source[key] !== 'object' || this.isElement(source[key])) {\n                        // All non-object properties, or all properties if shallow extend\n\n                        destination[key] = source[key];\n                    } else if (Array.isArray(source[key])) {\n                        // Arrays\n\n                        if (!destination[key]) {\n                            destination[key] = [];\n                        }\n\n                        this.extend(destination[key], source[key], deep, handleErrors);\n                    } else {\n                        // Objects\n\n                        if (!destination[key]) {\n                            destination[key] = {};\n                        }\n\n                        this.extend(destination[key], source[key], deep, handleErrors);\n                    }\n                }\n            } catch(err) {\n                if (handleErrors) {\n                    this.handleExtendError(err, destination);\n                } else {\n                    throw err;\n                }\n            }\n\n            return destination;\n        },\n\n        /**\n         * @private\n         * @param   {Error}  err\n         * @param   {object} destination\n         * @return  {void}\n         */\n\n        handleExtendError: function(err, destination) {\n            var re                  = /property \"?(\\w*)\"?[,:] object/i,\n                matches             = null,\n                erroneous           = '',\n                message             = '',\n                suggestion          = '',\n                probableMatch       = '',\n                key                 = '',\n                mostMatchingChars   = -1,\n                i                   = -1;\n\n            if (err instanceof TypeError && (matches = re.exec(err.message))) {\n                erroneous = matches[1];\n\n                for (key in destination) {\n                    i = 0;\n\n                    while (i < erroneous.length && erroneous.charAt(i) === key.charAt(i)) {\n                        i++;\n                    }\n\n                    if (i > mostMatchingChars) {\n                        mostMatchingChars = i;\n                        probableMatch = key;\n                    }\n                }\n\n                if (mostMatchingChars > 1) {\n                    suggestion = mixitup.messages.errorConfigInvalidPropertySuggestion({\n                        probableMatch: probableMatch\n                    });\n                }\n\n                message = mixitup.messages.errorConfigInvalidProperty({\n                    erroneous: erroneous,\n                    suggestion: suggestion\n                });\n\n                throw new TypeError(message);\n            }\n\n            throw err;\n        },\n\n        /**\n         * @private\n         * @param   {string} str\n         * @return  {function}\n         */\n\n        template: function(str) {\n            var re          = /\\${([\\w]*)}/g,\n                dynamics    = {},\n                matches     = null;\n\n            while ((matches = re.exec(str))) {\n                dynamics[matches[1]] = new RegExp('\\\\${' + matches[1] + '}', 'g');\n            }\n\n            return function(data) {\n                var key     = '',\n                    output  = str;\n\n                data = data || {};\n\n                for (key in dynamics) {\n                    output = output.replace(dynamics[key], typeof data[key] !== 'undefined' ? data[key] : '');\n                }\n\n                return output;\n            };\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        type\n         * @param   {function}      fn\n         * @param   {boolean}       useCapture\n         * @return  {void}\n         */\n\n        on: function(el, type, fn, useCapture) {\n            if (!el) return;\n\n            if (el.addEventListener) {\n                el.addEventListener(type, fn, useCapture);\n            } else if (el.attachEvent) {\n                el['e' + type + fn] = fn;\n\n                el[type + fn] = function() {\n                    el['e' + type + fn](window.event);\n                };\n\n                el.attachEvent('on' + type, el[type + fn]);\n            }\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        type\n         * @param   {function}      fn\n         * @return  {void}\n         */\n\n        off: function(el, type, fn) {\n            if (!el) return;\n\n            if (el.removeEventListener) {\n                el.removeEventListener(type, fn, false);\n            } else if (el.detachEvent) {\n                el.detachEvent('on' + type, el[type + fn]);\n                el[type + fn] = null;\n            }\n        },\n\n        /**\n         * @private\n         * @param   {string}      eventType\n         * @param   {object}      detail\n         * @param   {Document}    [doc]\n         * @return  {CustomEvent}\n         */\n\n        getCustomEvent: function(eventType, detail, doc) {\n            var event = null;\n\n            doc = doc || window.document;\n\n            if (typeof window.CustomEvent === 'function') {\n                event = new window.CustomEvent(eventType, {\n                    detail: detail,\n                    bubbles: true,\n                    cancelable: true\n                });\n            } else if (typeof doc.createEvent === 'function') {\n                event = doc.createEvent('CustomEvent');\n                event.initCustomEvent(eventType, true, true, detail);\n            } else {\n                event = doc.createEventObject(),\n                event.type = eventType;\n\n                event.returnValue = false;\n                event.cancelBubble = false;\n                event.detail = detail;\n            }\n\n            return event;\n        },\n\n        /**\n         * @private\n         * @param   {Event} e\n         * @return  {Event}\n         */\n\n        getOriginalEvent: function(e) {\n            if (e.touches && e.touches.length) {\n                return e.touches[0];\n            } else if (e.changedTouches && e.changedTouches.length) {\n                return e.changedTouches[0];\n            } else {\n                return e;\n            }\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        selector\n         * @return  {Number}\n         */\n\n        index: function(el, selector) {\n            var i = 0;\n\n            while ((el = el.previousElementSibling) !== null) {\n                if (!selector || el.matches(selector)) {\n                    ++i;\n                }\n            }\n\n            return i;\n        },\n\n        /**\n         * Converts a dash or snake-case string to camel case.\n         *\n         * @private\n         * @param   {string}    str\n         * @param   {boolean}   [isPascal]\n         * @return  {string}\n         */\n\n        camelCase: function(str) {\n            return str.toLowerCase().replace(/([_-][a-z])/g, function($1) {\n                return $1.toUpperCase().replace(/[_-]/, '');\n            });\n        },\n\n        /**\n         * Converts a dash or snake-case string to pascal case.\n         *\n         * @private\n         * @param   {string}    str\n         * @param   {boolean}   [isPascal]\n         * @return  {string}\n         */\n\n        pascalCase: function(str) {\n            return (str = this.camelCase(str)).charAt(0).toUpperCase() + str.slice(1);\n        },\n\n        /**\n         * Converts a camel or pascal-case string to dash case.\n         *\n         * @private\n         * @param   {string}    str\n         * @return  {string}\n         */\n\n        dashCase: function(str) {\n            return str.replace(/([A-Z])/g, '-$1').replace(/^-/, '').toLowerCase();\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}       el\n         * @param   {HTMLHtmlElement}   [doc]\n         * @return  {boolean}\n         */\n\n        isElement: function(el, doc) {\n            doc = doc || window.document;\n\n            if (\n                window.HTMLElement &&\n                el instanceof window.HTMLElement\n            ) {\n                return true;\n            } else if (\n                doc.defaultView &&\n                doc.defaultView.HTMLElement &&\n                el instanceof doc.defaultView.HTMLElement\n            ) {\n                return true;\n            } else {\n                return (\n                    el !== null &&\n                    el.nodeType === 1 &&\n                    typeof el.nodeName === 'string'\n                );\n            }\n        },\n\n        /**\n         * @private\n         * @param   {string}            htmlString\n         * @param   {HTMLHtmlElement}   [doc]\n         * @return  {DocumentFragment}\n         */\n\n        createElement: function(htmlString, doc) {\n            var frag = null,\n                temp = null;\n\n            doc = doc || window.document;\n\n            frag = doc.createDocumentFragment();\n            temp = doc.createElement('div');\n\n            temp.innerHTML = htmlString.trim();\n\n            while (temp.firstChild) {\n                frag.appendChild(temp.firstChild);\n            }\n\n            return frag;\n        },\n\n        /**\n         * @private\n         * @param   {Node} node\n         * @return  {void}\n         */\n\n        removeWhitespace: function(node) {\n            var deleting;\n\n            while (node && node.nodeName === '#text') {\n                deleting = node;\n\n                node = node.previousSibling;\n\n                deleting.parentElement && deleting.parentElement.removeChild(deleting);\n            }\n        },\n\n        /**\n         * @private\n         * @param   {Array<*>}  a\n         * @param   {Array<*>}  b\n         * @return  {boolean}\n         */\n\n        isEqualArray: function(a, b) {\n            var i = a.length;\n\n            if (i !== b.length) return false;\n\n            while (i--) {\n                if (a[i] !== b[i]) return false;\n            }\n\n            return true;\n        },\n\n        /**\n         * @private\n         * @param   {object}  a\n         * @param   {object}  b\n         * @return  {boolean}\n         */\n\n        deepEquals: function(a, b) {\n            var key;\n\n            if (typeof a === 'object' && a && typeof b === 'object' && b) {\n                if (Object.keys(a).length !== Object.keys(b).length) return false;\n\n                for (key in a) {\n                    if (!b.hasOwnProperty(key) || !this.deepEquals(a[key], b[key])) return false;\n                }\n            } else if (a !== b) {\n                return false;\n            }\n\n            return true;\n        },\n\n        /**\n         * @private\n         * @param   {Array<*>}  oldArray\n         * @return  {Array<*>}\n         */\n\n        arrayShuffle: function(oldArray) {\n            var newArray    = oldArray.slice(),\n                len         = newArray.length,\n                i           = len,\n                p           = -1,\n                t           = [];\n\n            while (i--) {\n                p = ~~(Math.random() * len);\n                t = newArray[i];\n\n                newArray[i] = newArray[p];\n                newArray[p] = t;\n            }\n\n            return newArray;\n        },\n\n        /**\n         * @private\n         * @param   {object}    list\n         */\n\n        arrayFromList: function(list) {\n            var output, i;\n\n            try {\n                return Array.prototype.slice.call(list);\n            } catch(err) {\n                output = [];\n\n                for (i = 0; i < list.length; i++) {\n                    output.push(list[i]);\n                }\n\n                return output;\n            }\n        },\n\n        /**\n         * @private\n         * @param   {function}  func\n         * @param   {Number}    wait\n         * @param   {boolean}   immediate\n         * @return  {function}\n         */\n\n        debounce: function(func, wait, immediate) {\n            var timeout;\n\n            return function() {\n                var self     = this,\n                    args     = arguments,\n                    callNow  = immediate && !timeout,\n                    later    = null;\n\n                later = function() {\n                    timeout  = null;\n\n                    if (!immediate) {\n                        func.apply(self, args);\n                    }\n                };\n\n                clearTimeout(timeout);\n\n                timeout = setTimeout(later, wait);\n\n                if (callNow) func.apply(self, args);\n            };\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   element\n         * @return  {object}\n         */\n\n        position: function(element) {\n            var xPosition       = 0,\n                yPosition       = 0,\n                offsetParent    = element;\n\n            while (element) {\n                xPosition -= element.scrollLeft;\n                yPosition -= element.scrollTop;\n\n                if (element === offsetParent) {\n                    xPosition += element.offsetLeft;\n                    yPosition += element.offsetTop;\n\n                    offsetParent = element.offsetParent;\n                }\n\n                element = element.parentElement;\n            }\n\n            return {\n                x: xPosition,\n                y: yPosition\n            };\n        },\n\n        /**\n         * @private\n         * @param   {object}    node1\n         * @param   {object}    node2\n         * @return  {Number}\n         */\n\n        getHypotenuse: function(node1, node2) {\n            var distanceX = node1.x - node2.x,\n                distanceY = node1.y - node2.y;\n\n            distanceX = distanceX < 0 ? distanceX * -1 : distanceX,\n            distanceY = distanceY < 0 ? distanceY * -1 : distanceY;\n\n            return Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));\n        },\n\n        /**\n         * Calcuates the area of intersection between two rectangles and expresses it as\n         * a ratio in comparison to the area of the first rectangle.\n         *\n         * @private\n         * @param   {Rect}  box1\n         * @param   {Rect}  box2\n         * @return  {number}\n         */\n\n        getIntersectionRatio: function(box1, box2) {\n            var controlArea         = box1.width * box1.height,\n                intersectionX       = -1,\n                intersectionY       = -1,\n                intersectionArea    = -1,\n                ratio               = -1;\n\n            intersectionX =\n                Math.max(0, Math.min(box1.left + box1.width, box2.left + box2.width) - Math.max(box1.left, box2.left));\n\n            intersectionY =\n                Math.max(0, Math.min(box1.top + box1.height, box2.top + box2.height) - Math.max(box1.top, box2.top));\n\n            intersectionArea = intersectionY * intersectionX;\n\n            ratio = intersectionArea / controlArea;\n\n            return ratio;\n        },\n\n        /**\n         * @private\n         * @param   {object}            el\n         * @param   {string}            selector\n         * @param   {boolean}           [includeSelf]\n         * @param   {HTMLHtmlElement}   [doc]\n         * @return  {Element|null}\n         */\n\n        closestParent: function(el, selector, includeSelf, doc) {\n            var parent  = el.parentNode;\n\n            doc = doc || window.document;\n\n            if (includeSelf && el.matches(selector)) {\n                return el;\n            }\n\n            while (parent && parent != doc.body) {\n                if (parent.matches && parent.matches(selector)) {\n                    return parent;\n                } else if (parent.parentNode) {\n                    parent = parent.parentNode;\n                } else {\n                    return null;\n                }\n            }\n\n            return null;\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}       el\n         * @param   {string}            selector\n         * @param   {HTMLHtmlElement}   [doc]\n         * @return  {NodeList}\n         */\n\n        children: function(el, selector, doc) {\n            var children    = [],\n                tempId      = '';\n\n            doc = doc || window.doc;\n\n            if (el) {\n                if (!el.id) {\n                    tempId = 'Temp' + this.randomHexKey();\n\n                    el.id = tempId;\n                }\n\n                children = doc.querySelectorAll('#' + el.id + ' > ' + selector);\n\n                if (tempId) {\n                    el.removeAttribute('id');\n                }\n            }\n\n            return children;\n        },\n\n        /**\n         * Creates a clone of a provided array, with any empty strings removed.\n         *\n         * @private\n         * @param   {Array<*>} originalArray\n         * @return  {Array<*>}\n         */\n\n        clean: function(originalArray) {\n            var cleanArray = [],\n                i = -1;\n\n            for (i = 0; i < originalArray.length; i++) {\n                if (originalArray[i] !== '') {\n                    cleanArray.push(originalArray[i]);\n                }\n            }\n\n            return cleanArray;\n        },\n\n        /**\n         * Abstracts an ES6 promise into a q-like deferred interface for storage and deferred resolution.\n         *\n         * @private\n         * @param  {object} libraries\n         * @return {h.Deferred}\n         */\n\n        defer: function(libraries) {\n            var deferred       = null,\n                promiseWrapper = null,\n                $              = null;\n\n            promiseWrapper = new this.Deferred();\n\n            if (mixitup.features.has.promises) {\n                // ES6 native promise or polyfill\n\n                promiseWrapper.promise = new Promise(function(resolve, reject) {\n                    promiseWrapper.resolve = resolve;\n                    promiseWrapper.reject  = reject;\n                });\n            } else if (($ = (window.jQuery || libraries.$)) && typeof $.Deferred === 'function') {\n                // jQuery\n\n                deferred = $.Deferred();\n\n                promiseWrapper.promise = deferred.promise();\n                promiseWrapper.resolve = deferred.resolve;\n                promiseWrapper.reject  = deferred.reject;\n            } else if (window.console) {\n                // No implementation\n\n                console.warn(mixitup.messages.warningNoPromiseImplementation());\n            }\n\n            return promiseWrapper;\n        },\n\n        /**\n         * @private\n         * @param   {Array<Promise>}    tasks\n         * @param   {object}            libraries\n         * @return  {Promise<Array>}\n         */\n\n        all: function(tasks, libraries) {\n            var $ = null;\n\n            if (mixitup.features.has.promises) {\n                return Promise.all(tasks);\n            } else if (($ = (window.jQuery || libraries.$)) && typeof $.when === 'function') {\n                return $.when.apply($, tasks)\n                    .done(function() {\n                        // jQuery when returns spread arguments rather than an array or resolutions\n\n                        return arguments;\n                    });\n            }\n\n            // No implementation\n\n            if (window.console) {\n                console.warn(mixitup.messages.warningNoPromiseImplementation());\n            }\n\n            return [];\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @param   {string}        property\n         * @param   {Array<string>} vendors\n         * @return  {string}\n         */\n\n        getPrefix: function(el, property, vendors) {\n            var i       = -1,\n                prefix  = '';\n\n            if (h.dashCase(property) in el.style) return '';\n\n            for (i = 0; prefix = vendors[i]; i++) {\n                if (prefix + property in el.style) {\n                    return prefix.toLowerCase();\n                }\n            }\n\n            return 'unsupported';\n        },\n\n        /**\n         * @private\n         * @return  {string}\n         */\n\n        randomHex: function() {\n            return ('00000' + (Math.random() * 16777216 << 0).toString(16)).substr(-6).toUpperCase();\n        },\n\n        /**\n         * @private\n         * @param   {HTMLDocument}  [doc]\n         * @return  {object}\n         */\n\n        getDocumentState: function(doc) {\n            doc = typeof doc.body === 'object' ? doc : window.document;\n\n            return {\n                scrollTop: window.pageYOffset,\n                scrollLeft: window.pageXOffset,\n                docHeight: doc.documentElement.scrollHeight,\n                docWidth: doc.documentElement.scrollWidth,\n                viewportHeight: doc.documentElement.clientHeight,\n                viewportWidth: doc.documentElement.clientWidth\n            };\n        },\n\n        /**\n         * @private\n         * @param   {object}    obj\n         * @param   {function}  fn\n         * @return  {function}\n         */\n\n        bind: function(obj, fn) {\n            return function() {\n                return fn.apply(obj, arguments);\n            };\n        },\n\n        /**\n         * @private\n         * @param   {HTMLElement}   el\n         * @return  {boolean}\n         */\n\n        isVisible: function(el) {\n            var styles = null;\n\n            if (el.offsetParent) return true;\n\n            styles = window.getComputedStyle(el);\n\n            if (\n                styles.position === 'fixed' &&\n                styles.visibility !== 'hidden' &&\n                styles.opacity !== '0'\n            ) {\n                // Fixed elements report no offsetParent,\n                // but may still be invisible\n\n                return true;\n            }\n\n            return false;\n        },\n\n        /**\n         * @private\n         * @param   {object}    obj\n         */\n\n        seal: function(obj) {\n            if (typeof Object.seal === 'function') {\n                Object.seal(obj);\n            }\n        },\n\n        /**\n         * @private\n         * @param   {object}    obj\n         */\n\n        freeze: function(obj) {\n            if (typeof Object.freeze === 'function') {\n                Object.freeze(obj);\n            }\n        },\n\n        /**\n         * @private\n         * @param   {string}    control\n         * @param   {string}    specimen\n         * @return  {boolean}\n         */\n\n        compareVersions: function(control, specimen) {\n            var controlParts    = control.split('.'),\n                specimenParts   = specimen.split('.'),\n                controlPart     = -1,\n                specimenPart    = -1,\n                i               = -1;\n\n            for (i = 0; i < controlParts.length; i++) {\n                controlPart     = parseInt(controlParts[i].replace(/[^\\d.]/g, ''));\n                specimenPart    = parseInt(specimenParts[i].replace(/[^\\d.]/g, '') || 0);\n\n                if (specimenPart < controlPart) {\n                    return false;\n                } else if (specimenPart > controlPart) {\n                    return true;\n                }\n            }\n\n            return true;\n        },\n\n        /**\n         * @private\n         * @constructor\n         */\n\n        Deferred: function() {\n            this.promise    = null;\n            this.resolve    = null;\n            this.reject     = null;\n            this.id         = h.randomHex();\n        },\n\n        /**\n         * @private\n         * @param   {object}  obj\n         * @return  {boolean}\n         */\n\n        isEmptyObject: function(obj) {\n            var key = '';\n\n            if (typeof Object.keys === 'function') {\n                return Object.keys(obj).length === 0;\n            }\n\n            for (key in obj) {\n                if (obj.hasOwnProperty(key)) {\n                    return false;\n                }\n            }\n\n            return true;\n        },\n\n        /**\n         * @param   {mixitup.Config.ClassNames}   classNames\n         * @param   {string}                      elementName\n         * @param   {string}                      [modifier]\n         * @return  {string}\n         */\n\n        getClassname: function(classNames, elementName, modifier) {\n            var classname = '';\n\n            classname += classNames.block;\n\n            if (classname.length) {\n                classname += classNames.delineatorElement;\n            }\n\n            classname += classNames['element' + this.pascalCase(elementName)];\n\n            if (!modifier) return classname;\n\n            if (classname.length) {\n                classname += classNames.delineatorModifier;\n            }\n\n            classname += modifier;\n\n            return classname;\n        },\n\n        /**\n         * Returns the value of a property on a given object via its string key.\n         *\n         * @param   {object}    obj\n         * @param   {string}    stringKey\n         * @return  {*} value\n         */\n\n        getProperty: function(obj, stringKey) {\n            var parts           = stringKey.split('.'),\n                returnCurrent   = null,\n                current         = '',\n                i               = 0;\n\n            if (!stringKey) {\n                return obj;\n            }\n\n            returnCurrent = function(obj) {\n                if (!obj) {\n                    return null;\n                } else {\n                    return obj[current];\n                }\n            };\n\n            while (i < parts.length) {\n                current = parts[i];\n\n                obj = returnCurrent(obj);\n\n                i++;\n            }\n\n            if (typeof obj !== 'undefined') {\n                return obj;\n            } else {\n                return null;\n            }\n        }\n    };\n\n    mixitup.h = h;\n\n    /**\n     * The Base class adds instance methods to all other extensible MixItUp classes,\n     * enabling the calling of any registered hooks.\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Base = function() {};\n\n    mixitup.Base.prototype = {\n        constructor: mixitup.Base,\n\n        /**\n         * Calls any registered hooks for the provided action.\n         *\n         * @memberof    mixitup.Base\n         * @private\n         * @instance\n         * @since       2.0.0\n         * @param       {string}    actionName\n         * @param       {Array<*>}  args\n         * @return      {void}\n         */\n\n        callActions: function(actionName, args) {\n            var self            = this,\n                hooks           = self.constructor.actions[actionName],\n                extensionName   = '';\n\n            if (!hooks || h.isEmptyObject(hooks)) return;\n\n            for (extensionName in hooks) {\n                hooks[extensionName].apply(self, args);\n            }\n        },\n\n        /**\n         * Calls any registered hooks for the provided filter.\n         *\n         * @memberof    mixitup.Base\n         * @private\n         * @instance\n         * @since       2.0.0\n         * @param       {string}    filterName\n         * @param       {*}         input\n         * @param       {Array<*>}  args\n         * @return      {*}\n         */\n\n        callFilters: function(filterName, input, args) {\n            var self            = this,\n                hooks           = self.constructor.filters[filterName],\n                output          = input,\n                extensionName   = '';\n\n            if (!hooks || h.isEmptyObject(hooks)) return output;\n\n            args = args || [];\n\n            for (extensionName in hooks) {\n                args = h.arrayFromList(args);\n\n                args.unshift(output);\n\n                output = hooks[extensionName].apply(self, args);\n            }\n\n            return output;\n        }\n    };\n\n    /**\n     * The BaseStatic class holds a set of static methods which are then added to all other\n     * extensible MixItUp classes as a means of integrating extensions via the addition of new\n     * methods and/or actions and hooks.\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.BaseStatic = function() {\n        this.actions = {};\n        this.filters = {};\n\n        /**\n         * Performs a shallow extend on the class's prototype, adding one or more new members to\n         * the class in a single operation.\n         *\n         * @memberof    mixitup.BaseStatic\n         * @public\n         * @static\n         * @since       2.1.0\n         * @param       {object} extension\n         * @return      {void}\n         */\n\n        this.extend = function(extension) {\n            h.extend(this.prototype, extension);\n        };\n\n        /**\n         * Registers a function to be called on the action hook of the provided name.\n         *\n         * @memberof    mixitup.BaseStatic\n         * @public\n         * @static\n         * @since       2.1.0\n         * @param       {string}    hookName\n         * @param       {string}    extensionName\n         * @param       {function}  func\n         * @return      {void}\n         */\n\n        this.registerAction = function(hookName, extensionName, func) {\n            (this.actions[hookName] = this.actions[hookName] || {})[extensionName] = func;\n        };\n\n        /**\n         * Registers a function to be called on the filter of the provided name.\n         *\n         * @memberof    mixitup.BaseStatic\n         * @public\n         * @static\n         * @since       2.1.0\n         * @param       {string}    hookName\n         * @param       {string}    extensionName\n         * @param       {function}  func\n         * @return      {void}\n         */\n\n        this.registerFilter = function(hookName, extensionName, func) {\n            (this.filters[hookName] = this.filters[hookName] || {})[extensionName] = func;\n        };\n    };\n\n    /**\n     * The `mixitup.Features` class performs all feature and CSS prefix detection\n     * neccessary for MixItUp to function correctly, as well as storing various\n     * string and array constants. All feature decection is on evaluation of the\n     * library and stored in a singleton instance for use by other internal classes.\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Features = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.boxSizingPrefix            = '';\n        this.transformPrefix            = '';\n        this.transitionPrefix           = '';\n\n        this.boxSizingPrefix            = '';\n        this.transformProp              = '';\n        this.transformRule              = '';\n        this.transitionProp             = '';\n        this.perspectiveProp            = '';\n        this.perspectiveOriginProp      = '';\n\n        this.has                        = new mixitup.Has();\n\n        this.canary                     = null;\n\n        this.BOX_SIZING_PROP            = 'boxSizing';\n        this.TRANSITION_PROP            = 'transition';\n        this.TRANSFORM_PROP             = 'transform';\n        this.PERSPECTIVE_PROP           = 'perspective';\n        this.PERSPECTIVE_ORIGIN_PROP    = 'perspectiveOrigin';\n        this.VENDORS                    = ['Webkit', 'moz', 'O', 'ms'];\n\n        this.TWEENABLE = [\n            'opacity',\n            'width', 'height',\n            'marginRight', 'marginBottom',\n            'x', 'y',\n            'scale',\n            'translateX', 'translateY', 'translateZ',\n            'rotateX', 'rotateY', 'rotateZ'\n        ];\n\n        this.callActions('afterConstruct');\n    };\n\n    mixitup.BaseStatic.call(mixitup.Features);\n\n    mixitup.Features.prototype = Object.create(mixitup.Base.prototype);\n\n    h.extend(mixitup.Features.prototype,\n    /** @lends mixitup.Features */\n    {\n        constructor: mixitup.Features,\n\n        /**\n         * @private\n         * @return  {void}\n         */\n\n        init: function() {\n            var self = this;\n\n            self.callActions('beforeInit', arguments);\n\n            self.canary = document.createElement('div');\n\n            self.setPrefixes();\n            self.runTests();\n\n            self.callActions('beforeInit', arguments);\n        },\n\n        /**\n         * @private\n         * @return  {void}\n         */\n\n        runTests: function() {\n            var self = this;\n\n            self.callActions('beforeRunTests', arguments);\n\n            self.has.promises       = typeof window.Promise === 'function';\n            self.has.transitions    = self.transitionPrefix !== 'unsupported';\n\n            self.callActions('afterRunTests', arguments);\n\n            h.freeze(self.has);\n        },\n\n        /**\n         * @private\n         * @return  {void}\n         */\n\n        setPrefixes: function() {\n            var self = this;\n\n            self.callActions('beforeSetPrefixes', arguments);\n\n            self.transitionPrefix   = h.getPrefix(self.canary, 'Transition', self.VENDORS);\n            self.transformPrefix    = h.getPrefix(self.canary, 'Transform', self.VENDORS);\n            self.boxSizingPrefix    = h.getPrefix(self.canary, 'BoxSizing', self.VENDORS);\n\n            self.boxSizingProp = self.boxSizingPrefix ?\n                self.boxSizingPrefix + h.pascalCase(self.BOX_SIZING_PROP) : self.BOX_SIZING_PROP;\n\n            self.transitionProp = self.transitionPrefix ?\n                self.transitionPrefix + h.pascalCase(self.TRANSITION_PROP) : self.TRANSITION_PROP;\n\n            self.transformProp = self.transformPrefix ?\n                self.transformPrefix + h.pascalCase(self.TRANSFORM_PROP) : self.TRANSFORM_PROP;\n\n            self.transformRule = self.transformPrefix ?\n                '-' + self.transformPrefix + '-' + self.TRANSFORM_PROP : self.TRANSFORM_PROP;\n\n            self.perspectiveProp = self.transformPrefix ?\n                self.transformPrefix + h.pascalCase(self.PERSPECTIVE_PROP) : self.PERSPECTIVE_PROP;\n\n            self.perspectiveOriginProp = self.transformPrefix ?\n                self.transformPrefix + h.pascalCase(self.PERSPECTIVE_ORIGIN_PROP) :\n                self.PERSPECTIVE_ORIGIN_PROP;\n\n            self.callActions('afterSetPrefixes', arguments);\n        }\n    });\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Has = function() {\n        this.transitions    = false;\n        this.promises       = false;\n\n        h.seal(this);\n    };\n\n    // Assign a singleton instance to `mixitup.features` and initialise:\n\n    mixitup.features = new mixitup.Features();\n\n    mixitup.features.init();\n\n    /**\n     * A group of properties defining the mixer's animation and effects settings.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        animation\n     * @namespace\n     * @public\n     * @since       2.0.0\n     */\n\n    mixitup.ConfigAnimation = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A boolean dictating whether or not animation should be enabled for the MixItUp instance.\n         * If `false`, all operations will occur instantly and syncronously, although callback\n         * functions and any returned promises will still be fulfilled.\n         *\n         * @example <caption>Example: Create a mixer with all animations disabled</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         enable: false\n         *     }\n         * });\n         *\n         * @name        enable\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.enable = true;\n\n        /**\n         * A string of one or more space-seperated properties to which transitions will be\n         * applied for all filtering animations.\n         *\n         * Properties can be listed any order or combination, although they will be applied in a specific\n         * predefined order to produce consistent results.\n         *\n         * To learn more about available effects, experiment with our <a href=\"https://www.kunkalabs.com/mixitup/\">\n         * sandbox demo</a> and try out the \"Export config\" button in the Animation options drop down.\n         *\n         * @example <caption>Example: Apply \"fade\" and \"translateZ\" effects to all animations</caption>\n         * // As targets are filtered in and out, they will fade between\n         * // opacity 1 and 0 and transform between translateZ(-100px) and\n         * // translateZ(0).\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effects: 'fade translateZ(-100px)'\n         *     }\n         * });\n         *\n         * @name        effects\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {string}\n         * @default     'fade scale'\n         */\n\n        this.effects = 'fade scale';\n\n        /**\n         * A string of one or more space-seperated effects to be applied only to filter-in\n         * animations, overriding `config.animation.effects` if set.\n         *\n         * @example <caption>Example: Apply downwards vertical translate to targets being filtered in</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effectsIn: 'fade translateY(-100%)'\n         *     }\n         * });\n         *\n         * @name        effectsIn\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {string}\n         * @default     ''\n         */\n\n        this.effectsIn = '';\n\n        /**\n         * A string of one or more space-seperated effects to be applied only to filter-out\n         * animations, overriding `config.animation.effects` if set.\n         *\n         * @example <caption>Example: Apply upwards vertical translate to targets being filtered out</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effectsOut: 'fade translateY(-100%)'\n         *     }\n         * });\n         *\n         * @name        effectsOut\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {string}\n         * @default     ''\n         */\n\n        this.effectsOut = '';\n\n        /**\n         * An integer dictating the duration of all MixItUp animations in milliseconds, not\n         * including any additional delay apllied via the `'stagger'` effect.\n         *\n         * @example <caption>Example: Apply an animation duration of 200ms to all mixitup animations</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         duration: 200\n         *     }\n         * });\n         *\n         * @name        duration\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {number}\n         * @default     600\n         */\n\n        this.duration = 600;\n\n        /**\n         * A valid CSS3 transition-timing function or shorthand. For a full list of accepted\n         * values, visit <a href=\"http://easings.net\" target=\"_blank\">easings.net</a>.\n         *\n         * @example <caption>Example 1: Apply \"ease-in-out\" easing to all animations</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         easing: 'ease-in-out'\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Apply a custom \"cubic-bezier\" easing function to all animations</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         easing: 'cubic-bezier(0.645, 0.045, 0.355, 1)'\n         *     }\n         * });\n         *\n         * @name        easing\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {string}\n         * @default     'ease'\n         */\n\n        this.easing = 'ease';\n\n        /**\n         * A boolean dictating whether or not to apply perspective to the MixItUp container\n         * during animations. By default, perspective is always applied and creates the\n         * illusion of three-dimensional space for effects such as `translateZ`, `rotateX`,\n         * and `rotateY`.\n         *\n         * You may wish to disable this and define your own perspective settings via CSS.\n         *\n         * @example <caption>Example: Prevent perspective from being applied to any 3D transforms</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         applyPerspective: false\n         *     }\n         * });\n         *\n         * @name        applyPerspective\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {bolean}\n         * @default     true\n         */\n\n        this.applyPerspective = true;\n\n        /**\n         * The perspective distance value to be applied to the container during animations,\n         * affecting any 3D-transform-based effects.\n         *\n         * @example <caption>Example: Set a perspective distance of 2000px</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effects: 'rotateY(-25deg)',\n         *         perspectiveDistance: '2000px'\n         *     }\n         * });\n         *\n         * @name        perspectiveDistance\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {string}\n         * @default     '3000px'\n         */\n\n        this.perspectiveDistance = '3000px';\n\n        /**\n         * The perspective-origin value to be applied to the container during animations,\n         * affecting any 3D-transform-based effects.\n         *\n         * @example <caption>Example: Set a perspective origin in the top-right of the container</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effects: 'transateZ(-200px)',\n         *         perspectiveOrigin: '100% 0'\n         *     }\n         * });\n         *\n         * @name        perspectiveOrigin\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {string}\n         * @default     '50% 50%'\n         */\n\n        this.perspectiveOrigin = '50% 50%';\n\n        /**\n         * A boolean dictating whether or not to enable the queuing of operations.\n         *\n         * If `true` (default), and a control is clicked or an API call is made while another\n         * operation is progress, the operation will go into the queue and will be automatically exectuted\n         * when the previous operaitons is finished.\n         *\n         * If `false`, any requested operations will be ignored, and the `onMixBusy` callback and `mixBusy`\n         * event will be fired. If `debug.showWarnings` is enabled, a console warning will also occur.\n         *\n         * @example <caption>Example: Disable queuing</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         queue: false\n         *     }\n         * });\n         *\n         * @name        queue\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.queue = true;\n\n        /**\n         * An integer dictacting the maximum number of operations allowed in the queue at\n         * any time, when queuing is enabled.\n         *\n         * @example <caption>Example: Allow a maximum of 5 operations in the queue at any time</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         queueLimit: 5\n         *     }\n         * });\n         *\n         * @name        queueLimit\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {number}\n         * @default     3\n         */\n\n        this.queueLimit = 3;\n\n        /**\n         * A boolean dictating whether or not to transition the height and width of the\n         * container as elements are filtered in and out. If disabled, the container height\n         * will change abruptly.\n         *\n         * It may be desirable to disable this on mobile devices as the CSS `height` and\n         * `width` properties do not receive GPU-acceleration and can therefore cause stuttering.\n         *\n         * @example <caption>Example 1: Disable the transitioning of the container height and/or width</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         animateResizeContainer: false\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Disable the transitioning of the container height and/or width for mobile devices only</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         animateResizeContainer: myFeatureTests.isMobile ? false : true\n         *     }\n         * });\n         *\n         * @name        animateResizeContainer\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.animateResizeContainer = true;\n\n        /**\n         * A boolean dictating whether or not to transition the height and width of target\n         * elements as they change throughout the course of an animation.\n         *\n         * This is often a must for flex-box grid layouts where the size of target elements may change\n         * depending on final their position in relation to their siblings, or for `.changeLayout()`\n         * operations where the size of targets change between layouts.\n         *\n         * NB: This feature requires additional calculations and manipulation to non-hardware-accelerated\n         * properties which may adversely affect performance on slower devices, and is therefore\n         * disabled by default.\n         *\n         * @example <caption>Example: Enable the transitioning of target widths and heights</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         animateResizeTargets: true\n         *     }\n         * });\n         *\n         * @name        animateResizeTargets\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.animateResizeTargets = false;\n\n        /**\n         * A custom function used to manipulate the order in which the stagger delay is\n         * incremented when using the ‘stagger’ effect.\n         *\n         * When using the 'stagger' effect, the delay applied to each target element is incremented\n         * based on its index. You may create a custom function to manipulate the order in which the\n         * delay is incremented and create engaging non-linear stagger effects.\n         *\n         * The function receives the index of the target element as a parameter, and must\n         * return an integer which serves as the multiplier for the stagger delay.\n         *\n         * @example <caption>Example 1: Stagger target elements by column in a 3-column grid</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effects: 'fade stagger(100ms)',\n         *         staggerSequence: function(i) {\n         *             return i % 3;\n         *         }\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Using an algorithm to produce a more complex sequence</caption>\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effects: 'fade stagger(100ms)',\n         *         staggerSequence: function(i) {\n         *             return (2*i) - (5*((i/3) - ((1/3) * (i%3))));\n         *         }\n         *     }\n         * });\n         *\n         * @name        staggerSequence\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {function}\n         * @default     null\n         */\n\n        this.staggerSequence = null;\n\n        /**\n         * A boolean dictating whether or not to reverse the direction of `translate`\n         * and `rotate` transforms for elements being filtered out.\n         *\n         * It can be used to create carousel-like animations where elements enter and exit\n         * from opposite directions. If enabled, the effect `translateX(-100%)` for elements\n         * being filtered in would become `translateX(100%)` for targets being filtered out.\n         *\n         * This functionality can also be achieved by providing seperate effects\n         * strings for `config.animation.effectsIn` and `config.animation.effectsOut`.\n         *\n         * @example <caption>Example: Reverse the desired direction on any translate/rotate effect for targets being filtered out</caption>\n         * // Elements being filtered in will be translated from '100%' to '0' while\n         * // elements being filtered out will be translated from 0 to '-100%'\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         effects: 'fade translateX(100%)',\n         *         reverseOut: true,\n         *         nudge: false // Disable nudging to create a carousel-like effect\n         *     }\n         * });\n         *\n         * @name        reverseOut\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.reverseOut = false;\n\n        /**\n         * A boolean dictating whether or not to \"nudge\" the animation path of targets\n         * when they are being filtered in and out simulatenously.\n         *\n         * This has been the default behavior of MixItUp since version 1, but it\n         * may be desirable to disable this effect when filtering directly from\n         * one exclusive set of targets to a different exclusive set of targets,\n         * to create a carousel-like effect, or a generally more subtle animation.\n         *\n         * @example <caption>Example: Disable the \"nudging\" of targets being filtered in and out simulatenously</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         nudge: false\n         *     }\n         * });\n         *\n         * @name        nudge\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.nudge = true;\n\n        /**\n         * A boolean dictating whether or not to clamp the height of the container while MixItUp's\n         * geometry tests are carried out before an operation.\n         *\n         * To prevent scroll-bar flicker, clamping is turned on by default. But in the case where the\n         * height of the container might affect its vertical positioning in the viewport\n         * (e.g. a vertically-centered container), this should be turned off to ensure accurate\n         * test results and a smooth animation.\n         *\n         * @example <caption>Example: Disable container height-clamping</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         clampHeight: false\n         *     }\n         * });\n         *\n         * @name        clampHeight\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.clampHeight = true;\n\n        /**\n         * A boolean dictating whether or not to clamp the width of the container while MixItUp's\n         * geometry tests are carried out before an operation.\n         *\n         * To prevent scroll-bar flicker, clamping is turned on by default. But in the case where the\n         * width of the container might affect its horitzontal positioning in the viewport\n         * (e.g. a horizontall-centered container), this should be turned off to ensure accurate\n         * test results and a smooth animation.\n         *\n         * @example <caption>Example: Disable container width-clamping</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     animation: {\n         *         clampWidth: false\n         *     }\n         * });\n         *\n         * @name        clampWidth\n         * @memberof    mixitup.Config.animation\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.clampWidth = true;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigAnimation);\n\n    mixitup.ConfigAnimation.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigAnimation.prototype.constructor = mixitup.ConfigAnimation;\n\n    /**\n     * A group of properties relating to the behavior of the Mixer.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        behavior\n     * @namespace\n     * @public\n     * @since       3.1.12\n     */\n\n    mixitup.ConfigBehavior = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A boolean dictating whether to allow \"live\" sorting of the mixer.\n         *\n         * Because of the expensive nature of sorting, MixItUp makes use of several\n         * internal optimizations to skip redundant sorting operations, such as when\n         * the newly requested sort command is the same as the active one. The caveat\n         * to this optimization is that \"live\" edits to the value of a target's sorting\n         * attribute will be ignored when requesting a re-sort by the same attribute.\n         *\n         * By setting to `behavior.liveSort` to `true`, the mixer will always re-sort\n         * regardless of whether or not the sorting attribute and order have changed.\n         *\n         * @example <caption>Example: Enabling `liveSort` to allow for re-sorting</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     behavior: {\n         *         liveSort: true\n         *     },\n         *     load: {\n         *         sort: 'edited:desc'\n         *     }\n         * });\n         *\n         * var target = containerEl.children[3];\n         *\n         * console.log(target.getAttribute('data-edited')); // '2015-04-24'\n         *\n         * target.setAttribute('data-edited', '2017-08-10'); // Update the target's edited date\n         *\n         * mixer.sort('edited:desc')\n         *     .then(function(state) {\n         *         // The target is now at the top of the list\n         *\n         *         console.log(state.targets[0] === target); // true\n         *     });\n         *\n         * @name        liveSort\n         * @memberof    mixitup.Config.behavior\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.liveSort = false;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigBehavior);\n\n    mixitup.ConfigBehavior.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigBehavior.prototype.constructor = mixitup.ConfigBehavior;\n\n    /**\n     * A group of optional callback functions to be invoked at various\n     * points within the lifecycle of a mixer operation.\n     *\n     * Each function is analogous to an event of the same name triggered from the\n     * container element, and is invoked immediately after it.\n     *\n     * All callback functions receive the current `state` object as their first\n     * argument, as well as other more specific arguments described below.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        callbacks\n     * @namespace\n     * @public\n     * @since       2.0.0\n     */\n\n    mixitup.ConfigCallbacks = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A callback function invoked immediately after any MixItUp operation is requested\n         * and before animations have begun.\n         *\n         * A second `futureState` argument is passed to the function which represents the final\n         * state of the mixer once the requested operation has completed.\n         *\n         * @example <caption>Example: Adding an `onMixStart` callback function</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixStart: function(state, futureState) {\n         *              console.log('Starting operation...');\n         *         }\n         *     }\n         * });\n         *\n         * @name        onMixStart\n         * @memberof    mixitup.Config.callbacks\n         * @instance\n         * @type        {function}\n         * @default     null\n         */\n\n        this.onMixStart = null;\n\n        /**\n         * A callback function invoked when a MixItUp operation is requested while another\n         * operation is in progress, and the animation queue is full, or queueing\n         * is disabled.\n         *\n         * @example <caption>Example: Adding an `onMixBusy` callback function</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixBusy: function(state) {\n         *              console.log('Mixer busy');\n         *         }\n         *     }\n         * });\n         *\n         * @name        onMixBusy\n         * @memberof    mixitup.Config.callbacks\n         * @instance\n         * @type        {function}\n         * @default     null\n         */\n\n        this.onMixBusy  = null;\n\n        /**\n         * A callback function invoked after any MixItUp operation has completed, and the\n         * state has been updated.\n         *\n         * @example <caption>Example: Adding an `onMixEnd` callback function</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixEnd: function(state) {\n         *              console.log('Operation complete');\n         *         }\n         *     }\n         * });\n         *\n         * @name        onMixEnd\n         * @memberof    mixitup.Config.callbacks\n         * @instance\n         * @type        {function}\n         * @default     null\n         */\n\n        this.onMixEnd   = null;\n\n        /**\n         * A callback function invoked whenever an operation \"fails\", i.e. no targets\n         * could be found matching the requested filter.\n         *\n         * @example <caption>Example: Adding an `onMixFail` callback function</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixFail: function(state) {\n         *              console.log('No items could be found matching the requested filter');\n         *         }\n         *     }\n         * });\n         *\n         * @name        onMixFail\n         * @memberof    mixitup.Config.callbacks\n         * @instance\n         * @type        {function}\n         * @default     null\n         */\n\n        this.onMixFail  = null;\n\n        /**\n         * A callback function invoked whenever a MixItUp control is clicked, and before its\n         * respective operation is requested.\n         *\n         * The clicked element is assigned to the `this` keyword within the function. The original\n         * click event is passed to the function as the second argument, which can be useful if\n         * using `<a>` tags as controls where the default behavior needs to be prevented.\n         *\n         * Returning `false` from the callback will prevent the control click from triggering\n         * an operation.\n         *\n         * @example <caption>Example 1: Adding an `onMixClick` callback function</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixClick: function(state, originalEvent) {\n         *              console.log('The control \"' + this.innerText + '\" was clicked');\n         *         }\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Using `onMixClick` to manipulate the original click event</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixClick: function(state, originalEvent) {\n         *              // Prevent original click event from bubbling up:\n         *              originalEvent.stopPropagation();\n         *\n         *              // Prevent default behavior of clicked element:\n         *              originalEvent.preventDefault();\n         *         }\n         *     }\n         * });\n         *\n         * @example <caption>Example 3: Using `onMixClick` to conditionally cancel operations</caption>\n         * var mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixClick: function(state, originalEvent) {\n         *              // Perform some conditional check:\n         *\n         *              if (myApp.isLoading) {\n         *                  // By returning false, we can prevent the control click from triggering an operation.\n         *\n         *                  return false;\n         *              }\n         *         }\n         *     }\n         * });\n         *\n         * @name        onMixClick\n         * @memberof    mixitup.Config.callbacks\n         * @instance\n         * @type        {function}\n         * @default     null\n         */\n\n        this.onMixClick = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigCallbacks);\n\n    mixitup.ConfigCallbacks.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigCallbacks.prototype.constructor = mixitup.ConfigCallbacks;\n\n    /**\n     * A group of properties relating to clickable control elements.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        controls\n     * @namespace\n     * @public\n     * @since       2.0.0\n     */\n\n    mixitup.ConfigControls = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A boolean dictating whether or not controls should be enabled for the mixer instance.\n         *\n         * If `true` (default behavior), MixItUp will search the DOM for any clickable elements with\n         * `data-filter`, `data-sort` or `data-toggle` attributes, and bind them for click events.\n         *\n         * If `false`, no click handlers will be bound, and all functionality must therefore be performed\n         * via the mixer's API methods.\n         *\n         * If you do not intend to use the default controls, setting this property to `false` will\n         * marginally improve the startup time of your mixer instance, and will also prevent any other active\n         * mixer instances in the DOM which are bound to controls from controlling the instance.\n         *\n         * @example <caption>Example: Disabling controls</caption>\n         * var mixer = mixitup(containerEl, {\n         *     controls: {\n         *         enable: false\n         *     }\n         * });\n         *\n         * // With the default controls disabled, we can only control\n         * // the mixer via its API methods, e.g.:\n         *\n         * mixer.filter('.cat-1');\n         *\n         * @name        enable\n         * @memberof    mixitup.Config.controls\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.enable = true;\n\n        /**\n         * A boolean dictating whether or not to use event delegation when binding click events\n         * to the default controls.\n         *\n         * If `false` (default behavior), each control button in the DOM will be found and\n         * individually bound when a mixer is instantiated, with their corresponding actions\n         * cached for performance.\n         *\n         * If `true`, a single click handler will be applied to the `window` (or container element - see\n         * `config.controls.scope`), and any click events triggered by elements with `data-filter`,\n         * `data-sort` or `data-toggle` attributes present will be handled as they propagate upwards.\n         *\n         * If you require a user interface where control buttons may be added, removed, or changed during the\n         * lifetime of a mixer, `controls.live` should be set to `true`. There is a marginal but unavoidable\n         * performance deficit when using live controls, as the value of each control button must be read\n         * from the DOM in real time once the click event has propagated.\n         *\n         * @example <caption>Example: Setting live controls</caption>\n         * var mixer = mixitup(containerEl, {\n         *     controls: {\n         *         live: true\n         *     }\n         * });\n         *\n         * // Control buttons can now be added, remove and changed without breaking\n         * // the mixer's UI\n         *\n         * @name        live\n         * @memberof    mixitup.Config.controls\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.live = false;\n\n        /**\n         * A string dictating the \"scope\" to use when binding or querying the default controls. The available\n         * values are `'global'` or `'local'`.\n         *\n         * When set to `'global'` (default behavior), MixItUp will query the entire document for control buttons\n         * to bind, or delegate click events from (see `config.controls.live`).\n         *\n         * When set to `'local'`, MixItUp will only query (or bind click events to) its own container element.\n         * This may be desireable if you require multiple active mixer instances within the same document, with\n         * controls that would otherwise intefere with each other if scoped globally.\n         *\n         * Conversely, if you wish to control multiple instances with a single UI, you would create one\n         * set of controls and keep the controls scope of each mixer set to `global`.\n         *\n         * @example <caption>Example: Setting 'local' scoped controls</caption>\n         * var mixerOne = mixitup(containerOne, {\n         *     controls: {\n         *         scope: 'local'\n         *     }\n         * });\n         *\n         * var mixerTwo = mixitup(containerTwo, {\n         *     controls: {\n         *         scope: 'local'\n         *     }\n         * });\n         *\n         * // Both mixers can now exist within the same document with\n         * // isolated controls placed within their container elements.\n         *\n         * @name        scope\n         * @memberof    mixitup.Config.controls\n         * @instance\n         * @type        {string}\n         * @default     'global'\n         */\n\n        this.scope = 'global'; // enum: ['local' ,'global']\n\n        /**\n         * A string dictating the type of logic to apply when concatenating the filter selectors of\n         * active toggle buttons (i.e. any clickable element with a `data-toggle` attribute).\n         *\n         * If set to `'or'` (default behavior), selectors will be concatenated together as\n         * a comma-seperated list. For example:\n         *\n         * `'.cat-1, .cat-2'` (shows any elements matching `'.cat-1'` OR `'.cat-2'`)\n         *\n         * If set to `'and'`, selectors will be directly concatenated together. For example:\n         *\n         * `'.cat-1.cat-2'` (shows any elements which match both `'.cat-1'` AND `'.cat-2'`)\n         *\n         * @example <caption>Example: Setting \"and\" toggle logic</caption>\n         * var mixer = mixitup(containerEl, {\n         *     controls: {\n         *         toggleLogic: 'and'\n         *     }\n         * });\n         *\n         * @name        toggleLogic\n         * @memberof    mixitup.Config.controls\n         * @instance\n         * @type        {string}\n         * @default     'or'\n         */\n\n        this.toggleLogic = 'or'; // enum: ['or', 'and']\n\n        /**\n         * A string dictating the filter behavior when all toggles are inactive.\n         *\n         * When set to `'all'` (default behavior), *all* targets will be shown by default\n         * when no toggles are active, or at the moment all active toggles are toggled off.\n         *\n         * When set to `'none'`, no targets will be shown by default when no toggles are\n         * active, or at the moment all active toggles are toggled off.\n         *\n         * @example <caption>Example 1: Setting the default toggle behavior to `'all'`</caption>\n         * var mixer = mixitup(containerEl, {\n         *     controls: {\n         *         toggleDefault: 'all'\n         *     }\n         * });\n         *\n         * mixer.toggleOn('.cat-2')\n         *     .then(function() {\n         *         // Deactivate all active toggles\n         *\n         *         return mixer.toggleOff('.cat-2')\n         *     })\n         *     .then(function(state) {\n         *          console.log(state.activeFilter.selector); // 'all'\n         *          console.log(state.totalShow); // 12\n         *     });\n         *\n         * @example <caption>Example 2: Setting the default toggle behavior to `'none'`</caption>\n         * var mixer = mixitup(containerEl, {\n         *     controls: {\n         *         toggleDefault: 'none'\n         *     }\n         * });\n         *\n         * mixer.toggleOn('.cat-2')\n         *     .then(function() {\n         *         // Deactivate all active toggles\n         *\n         *         return mixer.toggleOff('.cat-2')\n         *     })\n         *     .then(function(state) {\n         *          console.log(state.activeFilter.selector); // 'none'\n         *          console.log(state.totalShow); // 0\n         *     });\n         *\n         * @name        toggleDefault\n         * @memberof    mixitup.Config.controls\n         * @instance\n         * @type        {string}\n         * @default     'all'\n         */\n\n        this.toggleDefault = 'all'; // enum: ['all', 'none']\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigControls);\n\n    mixitup.ConfigControls.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigControls.prototype.constructor = mixitup.ConfigControls;\n\n    /**\n     * A group of properties defining the output and structure of class names programmatically\n     * added to controls and containers to reflect the state of the mixer.\n     *\n     * Most commonly, class names are added to controls by MixItUp to indicate that\n     * the control is active so that it can be styled accordingly - `'mixitup-control-active'` by default.\n     *\n     * Using a \"BEM\" like structure, each classname is broken into the three parts:\n     * a block namespace (`'mixitup'`), an element name (e.g. `'control'`), and an optional modifier\n     * name (e.g. `'active'`) reflecting the state of the element.\n     *\n     * By default, each part of the classname is concatenated together using single hyphens as\n     * delineators, but this can be easily customised to match the naming convention and style of\n     * your project.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        classNames\n     * @namespace\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigClassNames = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * The \"block\" portion, or top-level namespace added to the start of any class names created by MixItUp.\n         *\n         * @example <caption>Example 1: changing the `config.classNames.block` value</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         block: 'portfolio'\n         *     }\n         * });\n         *\n         * // Active control output: \"portfolio-control-active\"\n         *\n         * @example <caption>Example 2: Removing `config.classNames.block`</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         block: ''\n         *     }\n         * });\n         *\n         * // Active control output: \"control-active\"\n         *\n         * @name        block\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'mixitup'\n         */\n\n        this.block = 'mixitup';\n\n        /**\n         * The \"element\" portion of the class name added to container.\n         *\n         * @name        elementContainer\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'container'\n         */\n\n        this.elementContainer = 'container';\n\n        /**\n         * The \"element\" portion of the class name added to filter controls.\n         *\n         * By default, all filter, sort, multimix and toggle controls take the same element value of `'control'`, but\n         * each type's element value can be individually overwritten to match the unique classNames of your controls as needed.\n         *\n         * @example <caption>Example 1: changing the `config.classNames.elementFilter` value</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         elementFilter: 'filter'\n         *     }\n         * });\n         *\n         * // Active filter output: \"mixitup-filter-active\"\n         *\n         * @example <caption>Example 2: changing the `config.classNames.block` and `config.classNames.elementFilter` values</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         block: 'portfolio',\n         *         elementFilter: 'filter'\n         *     }\n         * });\n         *\n         * // Active filter output: \"portfolio-filter-active\"\n         *\n         * @name        elementFilter\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'control'\n         */\n\n        this.elementFilter = 'control';\n\n        /**\n         * The \"element\" portion of the class name added to sort controls.\n         *\n         * By default, all filter, sort, multimix and toggle controls take the same element value of `'control'`, but\n         * each type's element value can be individually overwritten to match the unique classNames of your controls as needed.\n         *\n         * @example <caption>Example 1: changing the `config.classNames.elementSort` value</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         elementSort: 'sort'\n         *     }\n         * });\n         *\n         * // Active sort output: \"mixitup-sort-active\"\n         *\n         * @example <caption>Example 2: changing the `config.classNames.block` and `config.classNames.elementSort` values</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         block: 'portfolio',\n         *         elementSort: 'sort'\n         *     }\n         * });\n         *\n         * // Active sort output: \"portfolio-sort-active\"\n         *\n         * @name        elementSort\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'control'\n         */\n\n        this.elementSort = 'control';\n\n        /**\n         * The \"element\" portion of the class name added to multimix controls.\n         *\n         * By default, all filter, sort, multimix and toggle controls take the same element value of `'control'`, but\n         * each type's element value can be individually overwritten to match the unique classNames of your controls as needed.\n         *\n         * @example <caption>Example 1: changing the `config.classNames.elementMultimix` value</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         elementMultimix: 'multimix'\n         *     }\n         * });\n         *\n         * // Active multimix output: \"mixitup-multimix-active\"\n         *\n         * @example <caption>Example 2: changing the `config.classNames.block` and `config.classNames.elementMultimix` values</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         block: 'portfolio',\n         *         elementSort: 'multimix'\n         *     }\n         * });\n         *\n         * // Active multimix output: \"portfolio-multimix-active\"\n         *\n         * @name        elementMultimix\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'control'\n         */\n\n        this.elementMultimix = 'control';\n\n        /**\n         * The \"element\" portion of the class name added to toggle controls.\n         *\n         * By default, all filter, sort, multimix and toggle controls take the same element value of `'control'`, but\n         * each type's element value can be individually overwritten to match the unique classNames of your controls as needed.\n         *\n         * @example <caption>Example 1: changing the `config.classNames.elementToggle` value</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         elementToggle: 'toggle'\n         *     }\n         * });\n         *\n         * // Active toggle output: \"mixitup-toggle-active\"\n         *\n         * @example <caption>Example 2: changing the `config.classNames.block` and `config.classNames.elementToggle` values</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         block: 'portfolio',\n         *         elementToggle: 'toggle'\n         *     }\n         * });\n         *\n         * // Active toggle output: \"portfolio-toggle-active\"\n         *\n         * @name        elementToggle\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'control'\n         */\n\n        this.elementToggle = 'control';\n\n        /**\n         * The \"modifier\" portion of the class name added to active controls.\n         * @name        modifierActive\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'active'\n         */\n\n        this.modifierActive = 'active';\n\n        /**\n         * The \"modifier\" portion of the class name added to disabled controls.\n         *\n         * @name        modifierDisabled\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'disabled'\n         */\n\n        this.modifierDisabled = 'disabled';\n\n        /**\n         * The \"modifier\" portion of the class name added to the container when in a \"failed\" state.\n         *\n         * @name        modifierFailed\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     'failed'\n         */\n\n        this.modifierFailed = 'failed';\n\n        /**\n         * The delineator used between the \"block\" and \"element\" portions of any class name added by MixItUp.\n         *\n         * If the block portion is ommited by setting it to an empty string, no delineator will be added.\n         *\n         * @example <caption>Example: changing the delineator to match BEM convention</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         delineatorElement: '__'\n         *     }\n         * });\n         *\n         * // example active control output: \"mixitup__control-active\"\n         *\n         * @name        delineatorElement\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     '-'\n         */\n\n        this.delineatorElement = '-';\n\n        /**\n         * The delineator used between the \"element\" and \"modifier\" portions of any class name added by MixItUp.\n         *\n         * If the element portion is ommited by setting it to an empty string, no delineator will be added.\n         *\n         * @example <caption>Example: changing both delineators to match BEM convention</caption>\n         * var mixer = mixitup(containerEl, {\n         *     classNames: {\n         *         delineatorElement: '__'\n         *         delineatorModifier: '--'\n         *     }\n         * });\n         *\n         * // Active control output: \"mixitup__control--active\"\n         *\n         * @name        delineatorModifier\n         * @memberof    mixitup.Config.classNames\n         * @instance\n         * @type        {string}\n         * @default     '-'\n         */\n\n        this.delineatorModifier = '-';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigClassNames);\n\n    mixitup.ConfigClassNames.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigClassNames.prototype.constructor = mixitup.ConfigClassNames;\n\n    /**\n     * A group of properties relating to MixItUp's dataset API.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        data\n     * @namespace\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigData = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A string specifying the name of the key containing your data model's unique\n         * identifier (UID). To use the dataset API, a UID key must be specified and\n         * be present and unique on all objects in the dataset you provide to MixItUp.\n         *\n         * For example, if your dataset is made up of MongoDB documents, the UID\n         * key would be `'id'` or `'_id'`.\n         *\n         * @example <caption>Example: Setting the UID to `'id'`</caption>\n         * var mixer = mixitup(containerEl, {\n         *     data: {\n         *         uidKey: 'id'\n         *     }\n         * });\n         *\n         * @name        uidKey\n         * @memberof    mixitup.Config.data\n         * @instance\n         * @type        {string}\n         * @default     ''\n         */\n\n        this.uidKey = '';\n\n        /**\n         * A boolean dictating whether or not MixItUp should \"dirty check\" each object in\n         * your dataset for changes whenever `.dataset()` is called, and re-render any targets\n         * for which a change is found.\n         *\n         * Depending on the complexity of your data model, dirty checking can be expensive\n         * and is therefore disabled by default.\n         *\n         * NB: For changes to be detected, a new immutable instance of the edited model must be\n         * provided to mixitup, rather than manipulating properties on the existing instance.\n         * If your changes are a result of a DB write and read, you will most likely be calling\n         * `.dataset()` with a clean set of objects each time, so this will not be an issue.\n         *\n         * @example <caption>Example: Enabling dirty checking</caption>\n         *\n         * var myDataset = [\n         *     {\n         *         id: 0,\n         *         title: \"Blog Post Title 0\"\n         *         ...\n         *     },\n         *     {\n         *         id: 1,\n         *         title: \"Blog Post Title 1\"\n         *         ...\n         *     }\n         * ];\n         *\n         * // Instantiate a mixer with a pre-loaded dataset, and a target renderer\n         * // function defined\n         *\n         * var mixer = mixitup(containerEl, {\n         *     data: {\n         *         uidKey: 'id',\n         *         dirtyCheck: true\n         *     },\n         *     load: {\n         *         dataset: myDataset\n         *     },\n         *     render: {\n         *         target: function() { ... }\n         *     }\n         * });\n         *\n         * // For illustration, we will clone and edit the second object in the dataset.\n         * // NB: this would typically be done server-side in response to a DB update,\n         * and then re-queried via an API.\n         *\n         * myDataset[1] = Object.assign({}, myDataset[1]);\n         *\n         * myDataset[1].title = 'Blog Post Title 11';\n         *\n         * mixer.dataset(myDataset)\n         *    .then(function() {\n         *        // the target with ID \"1\", will be re-rendered reflecting its new title\n         *    });\n         *\n         * @name        dirtyCheck\n         * @memberof    mixitup.Config.data\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.dirtyCheck = false;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigData);\n\n    mixitup.ConfigData.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigData.prototype.constructor = mixitup.ConfigData;\n\n    /**\n     * A group of properties allowing the toggling of various debug features.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        debug\n     * @namespace\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigDebug = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A boolean dictating whether or not the mixer instance returned by the\n         * `mixitup()` factory function should expose private properties and methods.\n         *\n         * By default, mixer instances only expose their public API, but enabling\n         * debug mode will give you access to various mixer internals which may aid\n         * in debugging, or the authoring of extensions.\n         *\n         * @example <caption>Example: Enabling debug mode</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     debug: {\n         *         enable: true\n         *     }\n         * });\n         *\n         * // Private properties and methods will now be visible on the mixer instance:\n         *\n         * console.log(mixer);\n         *\n         * @name        enable\n         * @memberof    mixitup.Config.debug\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.enable = false;\n\n        /**\n         * A boolean dictating whether or not warnings should be shown when various\n         * common gotchas occur.\n         *\n         * Warnings are intended to provide insights during development when something\n         * occurs that is not a fatal, but may indicate an issue with your integration,\n         * and are therefore turned on by default. However, you may wish to disable\n         * them in production.\n         *\n         * @example <caption>Example 1: Disabling warnings</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     debug: {\n         *         showWarnings: false\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Disabling warnings based on environment</caption>\n         *\n         * var showWarnings = myAppConfig.environment === 'development' ? true : false;\n         *\n         * var mixer = mixitup(containerEl, {\n         *     debug: {\n         *         showWarnings: showWarnings\n         *     }\n         * });\n         *\n         * @name        showWarnings\n         * @memberof    mixitup.Config.debug\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.showWarnings = true;\n\n        /**\n         * Used for server-side testing only.\n         *\n         * @private\n         * @name        fauxAsync\n         * @memberof    mixitup.Config.debug\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.fauxAsync = false;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigDebug);\n\n    mixitup.ConfigDebug.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigDebug.prototype.constructor = mixitup.ConfigDebug;\n\n    /**\n     * A group of properties relating to the layout of the container.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        layout\n     * @namespace\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigLayout = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A boolean dictating whether or not mixitup should query all descendants\n         * of the container for targets, or only immediate children.\n         *\n         * By default, mixitup will query all descendants matching the\n         * `selectors.target` selector when indexing targets upon instantiation.\n         * This allows for targets to be nested inside a sub-container which is\n         * useful when ring-fencing targets from locally scoped controls in your\n         * markup (see `controls.scope`).\n         *\n         * However, if you are building a more complex UI requiring the nesting\n         * of mixers within mixers, you will most likely want to limit targets to\n         * immediate children of the container by setting this property to `false`.\n         *\n         * @example <caption>Example: Restricting targets to immediate children</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     layout: {\n         *         allowNestedTargets: false\n         *     }\n         * });\n         *\n         * @name        allowNestedTargets\n         * @memberof    mixitup.Config.layout\n         * @instance\n         * @type        {boolean}\n         * @default     true\n         */\n\n        this.allowNestedTargets = true;\n\n        /**\n         * A string specifying an optional class name to apply to the container when in\n         * its default state.\n         *\n         * By changing this class name or adding a class name to the container via the\n         * `.changeLayout()` API method, the CSS layout of the container can be changed,\n         * and MixItUp will attemp to gracefully animate the container and its targets\n         * between states.\n         *\n         * @example <caption>Example 1: Specifying a container class name</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     layout: {\n         *         containerClassName: 'grid'\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Changing the default class name with `.changeLayout()`</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     layout: {\n         *         containerClassName: 'grid'\n         *     }\n         * });\n         *\n         * mixer.changeLayout('list')\n         *     .then(function(state) {\n         *          console.log(state.activeContainerClass); // \"list\"\n         *     });\n         *\n         * @name        containerClassName\n         * @memberof    mixitup.Config.layout\n         * @instance\n         * @type        {string}\n         * @default     ''\n         */\n\n        this.containerClassName = '';\n\n        /**\n         * A reference to a non-target sibling element after which to insert targets\n         * when there are no targets in the container.\n         *\n         * @example <caption>Example: Setting a `siblingBefore` reference element</caption>\n         *\n         * var addButton = containerEl.querySelector('button');\n         *\n         * var mixer = mixitup(containerEl, {\n         *     layout: {\n         *         siblingBefore: addButton\n         *     }\n         * });\n         *\n         * @name        siblingBefore\n         * @memberof    mixitup.Config.layout\n         * @instance\n         * @type        {HTMLElement}\n         * @default     null\n         */\n\n        this.siblingBefore = null;\n\n        /**\n         * A reference to a non-target sibling element before which to insert targets\n         * when there are no targets in the container.\n         *\n         * @example <caption>Example: Setting an `siblingAfter` reference element</caption>\n         *\n         * var gap = containerEl.querySelector('.gap');\n         *\n         * var mixer = mixitup(containerEl, {\n         *     layout: {\n         *         siblingAfter: gap\n         *     }\n         * });\n         *\n         * @name        siblingAfter\n         * @memberof    mixitup.Config.layout\n         * @instance\n         * @type        {HTMLElement}\n         * @default     null\n         */\n\n        this.siblingAfter = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigLayout);\n\n    mixitup.ConfigLayout.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigLayout.prototype.constructor = mixitup.ConfigLayout;\n\n    /**\n     * A group of properties defining the initial state of the mixer on load (instantiation).\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        load\n     * @namespace\n     * @public\n     * @since       2.0.0\n     */\n\n    mixitup.ConfigLoad = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A string defining any filtering to be statically applied to the mixer on load.\n         * As per the `.filter()` API, this can be any valid selector string, or the\n         * values `'all'` or `'none'`.\n         *\n         * @example <caption>Example 1: Defining an initial filter selector to be applied on load</caption>\n         *\n         * // The mixer will show only those targets matching '.category-a' on load.\n         *\n         * var mixer = mixitup(containerEl, {\n         *     load: {\n         *         filter: '.category-a'\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Hiding all targets on load</caption>\n         *\n         * // The mixer will show hide all targets on load.\n         *\n         * var mixer = mixitup(containerEl, {\n         *     load: {\n         *         filter: 'none'\n         *     }\n         * });\n         *\n         * @name        filter\n         * @memberof    mixitup.Config.load\n         * @instance\n         * @type        {string}\n         * @default     'all'\n         */\n\n        this.filter = 'all';\n\n        /**\n         * A string defining any sorting to be statically applied to the mixer on load.\n         * As per the `.sort()` API, this should be a valid \"sort string\" made up of\n         * an attribute to sort by (or `'default'`) followed by an optional sorting\n         * order, or the value `'random'`;\n         *\n         * @example <caption>Example: Defining sorting to be applied on load</caption>\n         *\n         * // The mixer will sort the container by the value of the `data-published-date`\n         * // attribute, in descending order.\n         *\n         * var mixer = mixitup(containerEl, {\n         *     load: {\n         *         sort: 'published-date:desc'\n         *     }\n         * });\n         *\n         * @name        sort\n         * @memberof    mixitup.Config.load\n         * @instance\n         * @type        {string}\n         * @default     'default:asc'\n         */\n\n        this.sort = 'default:asc';\n\n        /**\n         * An array of objects representing the underlying data of any pre-rendered targets,\n         * when using the `.dataset()` API.\n         *\n         * NB: If targets are pre-rendered when the mixer is instantiated, this must be set.\n         *\n         * @example <caption>Example: Defining the initial underyling dataset</caption>\n         *\n         * var myDataset = [\n         *     {\n         *         id: 0,\n         *         title: \"Blog Post Title 0\",\n         *         ...\n         *     },\n         *     {\n         *         id: 1,\n         *         title: \"Blog Post Title 1\",\n         *         ...\n         *     }\n         * ];\n         *\n         * var mixer = mixitup(containerEl, {\n         *     data: {\n         *         uidKey: 'id'\n         *     },\n         *     load: {\n         *         dataset: myDataset\n         *     }\n         * });\n         *\n         * @name        dataset\n         * @memberof    mixitup.Config.load\n         * @instance\n         * @type        {Array.<object>}\n         * @default     null\n         */\n\n        this.dataset = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigLoad);\n\n    mixitup.ConfigLoad.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigLoad.prototype.constructor = mixitup.ConfigLoad;\n\n    /**\n     * A group of properties defining the selectors used to query elements within a mixitup container.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        selectors\n     * @namespace\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigSelectors = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A selector string used to query and index target elements within the container.\n         *\n         * By default, the class selector `'.mix'` is used, but this can be changed to an\n         * attribute or element selector to match the style of your project.\n         *\n         * @example <caption>Example 1: Changing the target selector</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     selectors: {\n         *         target: '.portfolio-item'\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Using an attribute selector as a target selector</caption>\n         *\n         * // The mixer will search for any children with the attribute `data-ref=\"mix\"`\n         *\n         * var mixer = mixitup(containerEl, {\n         *     selectors: {\n         *         target: '[data-ref=\"mix\"]'\n         *     }\n         * });\n         *\n         * @name        target\n         * @memberof    mixitup.Config.selectors\n         * @instance\n         * @type        {string}\n         * @default     '.mix'\n         */\n\n        this.target = '.mix';\n\n        /**\n         * A optional selector string used to add further specificity to the querying of control elements,\n         * in addition to their mandatory data attribute (e.g. `data-filter`, `data-toggle`, `data-sort`).\n         *\n         * This can be used if other elements in your document must contain the above attributes\n         * (e.g. for use in third-party scripts), and would otherwise interfere with MixItUp. Adding\n         * an additional `control` selector of your choice allows MixItUp to restrict event handling\n         * to only those elements matching the defined selector.\n         *\n         * @name        control\n         * @memberof    mixitup.Config.selectors\n         * @instance\n         * @type        {string}\n         * @default     ''\n         *\n         * @example <caption>Example 1: Adding a `selectors.control` selector</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     selectors: {\n         *         control: '.mixitup-control'\n         *     }\n         * });\n         *\n         * // Will not be handled:\n         * // <button data-filter=\".category-a\"></button>\n         *\n         * // Will be handled:\n         * // <button class=\"mixitup-control\" data-filter=\".category-a\"></button>\n         */\n\n        this.control = '';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigSelectors);\n\n    mixitup.ConfigSelectors.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigSelectors.prototype.constructor = mixitup.ConfigSelectors;\n\n    /**\n     * A group of optional render functions for creating and updating elements.\n     *\n     * All render functions receive a data object, and should return a valid HTML string.\n     *\n     * @constructor\n     * @memberof    mixitup.Config\n     * @name        render\n     * @namespace\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigRender = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A function returning an HTML string representing a target element, or a reference to a\n         * single DOM element.\n         *\n         * The function is invoked as part of the `.dataset()` API, whenever a new item is added\n         * to the dataset, or an item in the dataset changes (if `dataset.dirtyCheck` is enabled).\n         *\n         * The function receives the relevant dataset item as its first parameter.\n         *\n         * @example <caption>Example 1: Using string concatenation</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     render: {\n         *         target: function(item) {\n         *             return (\n         *                 '&lt;div class=\"mix\"&gt;' +\n         *                     '&lt;h2&gt;' + item.title + '&lt;/h2&gt;' +\n         *                 '&lt;/div&gt;'\n         *             );\n         *         }\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Using an ES2015 template literal</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     render: {\n         *         target: function(item) {\n         *             return (\n         *                 `&lt;div class=\"mix\"&gt;\n         *                     &lt;h2&gt;${item.title}&lt;/h2&gt;\n         *                  &lt;/div&gt;`\n         *             );\n         *         }\n         *     }\n         * });\n         *\n         * @example <caption>Example 3: Using a Handlebars template</caption>\n         *\n         * var targetTemplate = Handlebars.compile('&lt;div class=\"mix\"&gt;&lt;h2&gt;{{title}}&lt;/h2&gt;&lt;/div&gt;');\n         *\n         * var mixer = mixitup(containerEl, {\n         *     render: {\n         *         target: targetTemplate\n         *     }\n         * });\n         *\n         * @example <caption>Example 4: Returning a DOM element</caption>\n         *\n         * var mixer = mixitup(containerEl, {\n         *     render: {\n         *         target: function(item) {\n         *              // Create a single element using your framework's built-in renderer\n         *\n         *              var el = ...\n         *\n         *              return el;\n         *         }\n         *     }\n         * });\n         *\n         * @name        target\n         * @memberof    mixitup.Config.render\n         * @instance\n         * @type        {function}\n         * @default     'null'\n         */\n\n        this.target = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigRender);\n\n    mixitup.ConfigRender.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigRender.prototype.constructor = mixitup.ConfigRender;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.ConfigTemplates = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ConfigTemplates);\n\n    mixitup.ConfigTemplates.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ConfigTemplates.prototype.constructor = mixitup.ConfigTemplates;\n\n    /**\n     * `mixitup.Config` is an interface used for customising the functionality of a\n     * mixer instance. It is organised into several semantically distinct sub-objects,\n     * each one pertaining to a particular aspect of MixItUp functionality.\n     *\n     * An object literal containing any or all of the available properies,\n     * known as the \"configuration object\", can be passed as the second parameter to\n     * the `mixitup` factory function when creating a mixer instance to customise its\n     * functionality as needed.\n     *\n     * If no configuration object is passed, the mixer instance will take on the default\n     * configuration values detailed below.\n     *\n     * @example <caption>Example 1: Creating and passing the configuration object</caption>\n     * // Create a configuration object with desired values\n     *\n     * var config = {\n     *     animation: {\n     *         enable: false\n     *     },\n     *     selectors: {\n     *         target: '.item'\n     *     }\n     * };\n     *\n     * // Pass the configuration object to the mixitup factory function\n     *\n     * var mixer = mixitup(containerEl, config);\n     *\n     * @example <caption>Example 2: Passing the configuration object inline</caption>\n     * // Typically, the configuration object is passed inline for brevity.\n     *\n     * var mixer = mixitup(containerEl, {\n     *     controls: {\n     *         live: true,\n     *         toggleLogic: 'and'\n     *     }\n     * });\n     *\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @namespace\n     * @public\n     * @since       2.0.0\n     */\n\n    mixitup.Config = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.animation          = new mixitup.ConfigAnimation();\n        this.behavior           = new mixitup.ConfigBehavior();\n        this.callbacks          = new mixitup.ConfigCallbacks();\n        this.controls           = new mixitup.ConfigControls();\n        this.classNames         = new mixitup.ConfigClassNames();\n        this.data               = new mixitup.ConfigData();\n        this.debug              = new mixitup.ConfigDebug();\n        this.layout             = new mixitup.ConfigLayout();\n        this.load               = new mixitup.ConfigLoad();\n        this.selectors          = new mixitup.ConfigSelectors();\n        this.render             = new mixitup.ConfigRender();\n        this.templates          = new mixitup.ConfigTemplates();\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Config);\n\n    mixitup.Config.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.Config.prototype.constructor = mixitup.Config;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.MixerDom = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.document               = null;\n        this.body                   = null;\n        this.container              = null;\n        this.parent                 = null;\n        this.targets                = [];\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.MixerDom);\n\n    mixitup.MixerDom.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.MixerDom.prototype.constructor = mixitup.MixerDom;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.UiClassNames = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.base       = '';\n        this.active     = '';\n        this.disabled   = '';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.UiClassNames);\n\n    mixitup.UiClassNames.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.UiClassNames.prototype.constructor = mixitup.UiClassNames;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.dataset()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandDataset = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.dataset = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandDataset);\n\n    mixitup.CommandDataset.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandDataset.prototype.constructor = mixitup.CommandDataset;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.multimix()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandMultimix = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.filter       = null;\n        this.sort         = null;\n        this.insert       = null;\n        this.remove       = null;\n        this.changeLayout = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandMultimix);\n\n    mixitup.CommandMultimix.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandMultimix.prototype.constructor = mixitup.CommandMultimix;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.filter()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandFilter = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.selector   = '';\n        this.collection = null;\n        this.action     = 'show'; // enum: ['show', 'hide']\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandFilter);\n\n    mixitup.CommandFilter.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandFilter.prototype.constructor = mixitup.CommandFilter;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.sort()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandSort = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.sortString = '';\n        this.attribute  = '';\n        this.order      = 'asc';\n        this.collection = null;\n        this.next       = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandSort);\n\n    mixitup.CommandSort.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandSort.prototype.constructor = mixitup.CommandSort;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.insert()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandInsert = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.index      = 0;\n        this.collection = [];\n        this.position   = 'before'; // enum: ['before', 'after']\n        this.sibling    = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandInsert);\n\n    mixitup.CommandInsert.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandInsert.prototype.constructor = mixitup.CommandInsert;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.remove()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandRemove = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.targets    = [];\n        this.collection = [];\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandRemove);\n\n    mixitup.CommandRemove.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandRemove.prototype.constructor = mixitup.CommandRemove;\n\n    /**\n     * An object into which all arbitrary arguments sent to '.changeLayout()' are mapped.\n     *\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.CommandChangeLayout = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.containerClassName = '';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.CommandChangeLayout);\n\n    mixitup.CommandChangeLayout.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.CommandChangeLayout.prototype.constructor = mixitup.CommandChangeLayout;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     * @param       {string}        type\n     * @param       {string}        selector\n     * @param       {boolean}       [live]\n     * @param       {string}        [parent]\n     *     An optional string representing the name of the mixer.dom property containing a reference to a parent element.\n     */\n\n    mixitup.ControlDefinition = function(type, selector, live, parent) {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.type    = type;\n        this.selector  = selector;\n        this.live      = live || false;\n        this.parent    = parent || '';\n\n        this.callActions('afterConstruct');\n\n        h.freeze(this);\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.ControlDefinition);\n\n    mixitup.ControlDefinition.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.ControlDefinition.prototype.constructor = mixitup.ControlDefinition;\n\n    mixitup.controlDefinitions = [];\n\n    mixitup.controlDefinitions.push(new mixitup.ControlDefinition('multimix', '[data-filter][data-sort]'));\n    mixitup.controlDefinitions.push(new mixitup.ControlDefinition('filter', '[data-filter]'));\n    mixitup.controlDefinitions.push(new mixitup.ControlDefinition('sort', '[data-sort]'));\n    mixitup.controlDefinitions.push(new mixitup.ControlDefinition('toggle', '[data-toggle]'));\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Control = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.el         = null;\n        this.selector   = '';\n        this.bound      = [];\n        this.pending    = -1;\n        this.type       = '';\n        this.status     = 'inactive'; // enum: ['inactive', 'active', 'disabled', 'live']\n        this.filter     = '';\n        this.sort       = '';\n        this.canDisable = false;\n        this.handler    = null;\n        this.classNames = new mixitup.UiClassNames();\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Control);\n\n    mixitup.Control.prototype = Object.create(mixitup.Base.prototype);\n\n    h.extend(mixitup.Control.prototype,\n    /** @lends mixitup.Control */\n    {\n        constructor: mixitup.Control,\n\n        /**\n         * @private\n         * @param {HTMLElement} el\n         * @param {string}      type\n         * @param {string}      selector\n         */\n\n        init: function(el, type, selector) {\n            var self = this;\n\n            this.callActions('beforeInit', arguments);\n\n            self.el         = el;\n            self.type       = type;\n            self.selector   = selector;\n\n            if (self.selector) {\n                self.status = 'live';\n            } else {\n                self.canDisable = typeof self.el.disable === 'boolean';\n\n                switch (self.type) {\n                    case 'filter':\n                        self.filter = self.el.getAttribute('data-filter');\n\n                        break;\n                    case 'toggle':\n                        self.filter = self.el.getAttribute('data-toggle');\n\n                        break;\n                    case 'sort':\n                        self.sort   = self.el.getAttribute('data-sort');\n\n                        break;\n                    case 'multimix':\n                        self.filter = self.el.getAttribute('data-filter');\n                        self.sort   = self.el.getAttribute('data-sort');\n\n                        break;\n                }\n            }\n\n            self.bindClick();\n\n            mixitup.controls.push(self);\n\n            this.callActions('afterInit', arguments);\n        },\n\n        /**\n         * @private\n         * @param  {mixitup.Mixer} mixer\n         * @return {boolean}\n         */\n\n        isBound: function(mixer) {\n            var self    = this,\n                isBound = false;\n\n            this.callActions('beforeIsBound', arguments);\n\n            isBound = self.bound.indexOf(mixer) > -1;\n\n            return self.callFilters('afterIsBound', isBound, arguments);\n        },\n\n        /**\n         * @private\n         * @param  {mixitup.Mixer} mixer\n         * @return {void}\n         */\n\n        addBinding: function(mixer) {\n            var self = this;\n\n            this.callActions('beforeAddBinding', arguments);\n\n            if (!self.isBound()) {\n                self.bound.push(mixer);\n            }\n\n            this.callActions('afterAddBinding', arguments);\n        },\n\n        /**\n         * @private\n         * @param  {mixitup.Mixer} mixer\n         * @return {void}\n         */\n\n        removeBinding: function(mixer) {\n            var self        = this,\n                removeIndex = -1;\n\n            this.callActions('beforeRemoveBinding', arguments);\n\n            if ((removeIndex = self.bound.indexOf(mixer)) > -1) {\n                self.bound.splice(removeIndex, 1);\n            }\n\n            if (self.bound.length < 1) {\n                // No bindings exist, unbind event click handlers\n\n                self.unbindClick();\n\n                // Remove from `mixitup.controls` list\n\n                removeIndex = mixitup.controls.indexOf(self);\n\n                mixitup.controls.splice(removeIndex, 1);\n\n                if (self.status === 'active') {\n                    self.renderStatus(self.el, 'inactive');\n                }\n            }\n\n            this.callActions('afterRemoveBinding', arguments);\n        },\n\n        /**\n         * @private\n         * @return {void}\n         */\n\n        bindClick: function() {\n            var self = this;\n\n            this.callActions('beforeBindClick', arguments);\n\n            self.handler = function(e) {\n                self.handleClick(e);\n            };\n\n            h.on(self.el, 'click', self.handler);\n\n            this.callActions('afterBindClick', arguments);\n        },\n\n        /**\n         * @private\n         * @return {void}\n         */\n\n        unbindClick: function() {\n            var self = this;\n\n            this.callActions('beforeUnbindClick', arguments);\n\n            h.off(self.el, 'click', self.handler);\n\n            self.handler = null;\n\n            this.callActions('afterUnbindClick', arguments);\n        },\n\n        /**\n         * @private\n         * @param   {MouseEvent} e\n         * @return  {void}\n         */\n\n        handleClick: function(e) {\n            var self        = this,\n                button      = null,\n                mixer       = null,\n                isActive    = false,\n                returnValue = void(0),\n                command     = {},\n                clone       = null,\n                commands    = [],\n                i           = -1;\n\n            this.callActions('beforeHandleClick', arguments);\n\n            this.pending = 0;\n\n            mixer = self.bound[0];\n\n            if (!self.selector) {\n                button = self.el;\n            } else {\n                button = h.closestParent(e.target, mixer.config.selectors.control + self.selector, true, mixer.dom.document);\n            }\n\n            if (!button) {\n                self.callActions('afterHandleClick', arguments);\n\n                return;\n            }\n\n            switch (self.type) {\n                case 'filter':\n                    command.filter = self.filter || button.getAttribute('data-filter');\n\n                    break;\n                case 'sort':\n                    command.sort = self.sort || button.getAttribute('data-sort');\n\n                    break;\n                case 'multimix':\n                    command.filter  = self.filter || button.getAttribute('data-filter');\n                    command.sort    = self.sort || button.getAttribute('data-sort');\n\n                    break;\n                case 'toggle':\n                    command.filter  = self.filter || button.getAttribute('data-toggle');\n\n                    if (self.status === 'live') {\n                        isActive = h.hasClass(button, self.classNames.active);\n                    } else {\n                        isActive = self.status === 'active';\n                    }\n\n                    break;\n            }\n\n            for (i = 0; i < self.bound.length; i++) {\n                // Create a clone of the command for each bound mixer instance\n\n                clone = new mixitup.CommandMultimix();\n\n                h.extend(clone, command);\n\n                commands.push(clone);\n            }\n\n            commands = self.callFilters('commandsHandleClick', commands, arguments);\n\n            self.pending = self.bound.length;\n\n            for (i = 0; mixer = self.bound[i]; i++) {\n                command = commands[i];\n\n                if (!command) {\n                    // An extension may set a command null to indicate that the click should not be handled\n\n                    continue;\n                }\n\n                if (!mixer.lastClicked) {\n                    mixer.lastClicked = button;\n                }\n\n                mixitup.events.fire('mixClick', mixer.dom.container, {\n                    state: mixer.state,\n                    instance: mixer,\n                    originalEvent: e,\n                    control: mixer.lastClicked\n                }, mixer.dom.document);\n\n                if (typeof mixer.config.callbacks.onMixClick === 'function') {\n                    returnValue = mixer.config.callbacks.onMixClick.call(mixer.lastClicked, mixer.state, e, mixer);\n\n                    if (returnValue === false) {\n                        // User has returned `false` from the callback, so do not handle click\n\n                        continue;\n                    }\n                }\n\n                if (self.type === 'toggle') {\n                    isActive ? mixer.toggleOff(command.filter) : mixer.toggleOn(command.filter);\n                } else {\n                    mixer.multimix(command);\n                }\n            }\n\n            this.callActions('afterHandleClick', arguments);\n        },\n\n        /**\n         * @param   {object}          command\n         * @param   {Array<string>}   toggleArray\n         * @return  {void}\n         */\n\n        update: function(command, toggleArray) {\n            var self    = this,\n                actions = new mixitup.CommandMultimix();\n\n            self.callActions('beforeUpdate', arguments);\n\n            self.pending--;\n\n            self.pending = Math.max(0, self.pending);\n\n            if (self.pending > 0) return;\n\n            if (self.status === 'live') {\n                // Live control (status unknown)\n\n                self.updateLive(command, toggleArray);\n            } else {\n                // Static control\n\n                actions.sort    = self.sort;\n                actions.filter  = self.filter;\n\n                self.callFilters('actionsUpdate', actions, arguments);\n\n                self.parseStatusChange(self.el, command, actions, toggleArray);\n            }\n\n            self.callActions('afterUpdate', arguments);\n        },\n\n        /**\n         * @param   {mixitup.CommandMultimix} command\n         * @param   {Array<string>}           toggleArray\n         * @return  {void}\n         */\n\n        updateLive: function(command, toggleArray) {\n            var self            = this,\n                controlButtons  = null,\n                actions         = null,\n                button          = null,\n                i               = -1;\n\n            self.callActions('beforeUpdateLive', arguments);\n\n            if (!self.el) return;\n\n            controlButtons = self.el.querySelectorAll(self.selector);\n\n            for (i = 0; button = controlButtons[i]; i++) {\n                actions = new mixitup.CommandMultimix();\n\n                switch (self.type) {\n                    case 'filter':\n                        actions.filter = button.getAttribute('data-filter');\n\n                        break;\n                    case 'sort':\n                        actions.sort = button.getAttribute('data-sort');\n\n                        break;\n                    case 'multimix':\n                        actions.filter  = button.getAttribute('data-filter');\n                        actions.sort    = button.getAttribute('data-sort');\n\n                        break;\n                    case 'toggle':\n                        actions.filter  = button.getAttribute('data-toggle');\n\n                        break;\n                }\n\n                actions = self.callFilters('actionsUpdateLive', actions, arguments);\n\n                self.parseStatusChange(button, command, actions, toggleArray);\n            }\n\n            self.callActions('afterUpdateLive', arguments);\n        },\n\n        /**\n         * @param   {HTMLElement}             button\n         * @param   {mixitup.CommandMultimix} command\n         * @param   {mixitup.CommandMultimix} actions\n         * @param   {Array<string>}           toggleArray\n         * @return  {void}\n         */\n\n        parseStatusChange: function(button, command, actions, toggleArray) {\n            var self    = this,\n                alias   = '',\n                toggle  = '',\n                i       = -1;\n\n            self.callActions('beforeParseStatusChange', arguments);\n\n            switch (self.type) {\n                case 'filter':\n                    if (command.filter === actions.filter) {\n                        self.renderStatus(button, 'active');\n                    } else {\n                        self.renderStatus(button, 'inactive');\n                    }\n\n                    break;\n                case 'multimix':\n                    if (command.sort === actions.sort && command.filter === actions.filter) {\n                        self.renderStatus(button, 'active');\n                    } else {\n                        self.renderStatus(button, 'inactive');\n                    }\n\n                    break;\n                case 'sort':\n                    if (command.sort.match(/:asc/g)) {\n                        alias = command.sort.replace(/:asc/g, '');\n                    }\n\n                    if (command.sort === actions.sort || alias === actions.sort) {\n                        self.renderStatus(button, 'active');\n                    } else {\n                        self.renderStatus(button, 'inactive');\n                    }\n\n                    break;\n                case 'toggle':\n                    if (toggleArray.length < 1) self.renderStatus(button, 'inactive');\n\n                    if (command.filter === actions.filter) {\n                        self.renderStatus(button, 'active');\n                    }\n\n                    for (i = 0; i < toggleArray.length; i++) {\n                        toggle = toggleArray[i];\n\n                        if (toggle === actions.filter) {\n                            // Button matches one active toggle\n\n                            self.renderStatus(button, 'active');\n\n                            break;\n                        }\n\n                        self.renderStatus(button, 'inactive');\n                    }\n\n                    break;\n            }\n\n            self.callActions('afterParseStatusChange', arguments);\n        },\n\n        /**\n         * @param   {HTMLElement}   button\n         * @param   {string}        status\n         * @return  {void}\n         */\n\n        renderStatus: function(button, status) {\n            var self = this;\n\n            self.callActions('beforeRenderStatus', arguments);\n\n            switch (status) {\n                case 'active':\n                    h.addClass(button, self.classNames.active);\n                    h.removeClass(button, self.classNames.disabled);\n\n                    if (self.canDisable) self.el.disabled = false;\n\n                    break;\n                case 'inactive':\n                    h.removeClass(button, self.classNames.active);\n                    h.removeClass(button, self.classNames.disabled);\n\n                    if (self.canDisable) self.el.disabled = false;\n\n                    break;\n                case 'disabled':\n                    if (self.canDisable) self.el.disabled = true;\n\n                    h.addClass(button, self.classNames.disabled);\n                    h.removeClass(button, self.classNames.active);\n\n                    break;\n            }\n\n            if (self.status !== 'live') {\n                // Update the control's status propery if not live\n\n                self.status = status;\n            }\n\n            self.callActions('afterRenderStatus', arguments);\n        }\n    });\n\n    mixitup.controls = [];\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.StyleData = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.x              = 0;\n        this.y              = 0;\n        this.top            = 0;\n        this.right          = 0;\n        this.bottom         = 0;\n        this.left           = 0;\n        this.width          = 0;\n        this.height         = 0;\n        this.marginRight    = 0;\n        this.marginBottom   = 0;\n        this.opacity        = 0;\n        this.scale          = new mixitup.TransformData();\n        this.translateX     = new mixitup.TransformData();\n        this.translateY     = new mixitup.TransformData();\n        this.translateZ     = new mixitup.TransformData();\n        this.rotateX        = new mixitup.TransformData();\n        this.rotateY        = new mixitup.TransformData();\n        this.rotateZ        = new mixitup.TransformData();\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.StyleData);\n\n    mixitup.StyleData.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.StyleData.prototype.constructor = mixitup.StyleData;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.TransformData = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.value  = 0;\n        this.unit   = '';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.TransformData);\n\n    mixitup.TransformData.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.TransformData.prototype.constructor = mixitup.TransformData;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.TransformDefaults = function() {\n        mixitup.StyleData.apply(this);\n\n        this.callActions('beforeConstruct');\n\n        this.scale.value        = 0.01;\n        this.scale.unit         = '';\n\n        this.translateX.value   = 20;\n        this.translateX.unit    = 'px';\n\n        this.translateY.value   = 20;\n        this.translateY.unit    = 'px';\n\n        this.translateZ.value   = 20;\n        this.translateZ.unit    = 'px';\n\n        this.rotateX.value      = 90;\n        this.rotateX.unit       = 'deg';\n\n        this.rotateY.value      = 90;\n        this.rotateY.unit       = 'deg';\n\n        this.rotateX.value      = 90;\n        this.rotateX.unit       = 'deg';\n\n        this.rotateZ.value      = 180;\n        this.rotateZ.unit       = 'deg';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.TransformDefaults);\n\n    mixitup.TransformDefaults.prototype = Object.create(mixitup.StyleData.prototype);\n\n    mixitup.TransformDefaults.prototype.constructor = mixitup.TransformDefaults;\n\n    /**\n     * @private\n     * @static\n     * @since   3.0.0\n     * @type    {mixitup.TransformDefaults}\n     */\n\n    mixitup.transformDefaults = new mixitup.TransformDefaults();\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.EventDetail = function() {\n        this.state          = null;\n        this.futureState    = null;\n        this.instance       = null;\n        this.originalEvent  = null;\n    };\n\n    /**\n     * The `mixitup.Events` class contains all custom events dispatched by MixItUp at various\n     * points within the lifecycle of a mixer operation.\n     *\n     * Each event is analogous to the callback function of the same name defined in\n     * the `callbacks` configuration object, and is triggered immediately before it.\n     *\n     * Events are always triggered from the container element on which MixItUp is instantiated\n     * upon.\n     *\n     * As with any event, registered event handlers receive the event object as a parameter\n     * which includes a `detail` property containting references to the current `state`,\n     * the `mixer` instance, and other event-specific properties described below.\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.Events = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * A custom event triggered immediately after any MixItUp operation is requested\n         * and before animations have begun.\n         *\n         * The `mixStart` event also exposes a `futureState` property via the\n         * `event.detail` object, which represents the final state of the mixer once\n         * the requested operation has completed.\n         *\n         * @name        mixStart\n         * @memberof    mixitup.Events\n         * @static\n         * @type        {CustomEvent}\n         */\n\n        this.mixStart = null;\n\n        /**\n         * A custom event triggered when a MixItUp operation is requested while another\n         * operation is in progress, and the animation queue is full, or queueing\n         * is disabled.\n         *\n         * @name        mixBusy\n         * @memberof    mixitup.Events\n         * @static\n         * @type        {CustomEvent}\n         */\n\n        this.mixBusy = null;\n\n        /**\n         * A custom event triggered after any MixItUp operation has completed, and the\n         * state has been updated.\n         *\n         * @name        mixEnd\n         * @memberof    mixitup.Events\n         * @static\n         * @type        {CustomEvent}\n         */\n\n        this.mixEnd = null;\n\n        /**\n         * A custom event triggered whenever a filter operation \"fails\", i.e. no targets\n         * could be found matching the requested filter.\n         *\n         * @name        mixFail\n         * @memberof    mixitup.Events\n         * @static\n         * @type        {CustomEvent}\n         */\n\n        this.mixFail = null;\n\n        /**\n         * A custom event triggered whenever a MixItUp control is clicked, and before its\n         * respective operation is requested.\n         *\n         * This event also exposes an `originalEvent` property via the `event.detail`\n         * object, which holds a reference to the original click event.\n         *\n         * @name        mixClick\n         * @memberof    mixitup.Events\n         * @static\n         * @type        {CustomEvent}\n         */\n\n        this.mixClick = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Events);\n\n    mixitup.Events.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.Events.prototype.constructor = mixitup.Events;\n\n    /**\n     * @private\n     * @param   {string}      eventType\n     * @param   {Element}     el\n     * @param   {object}      detail\n     * @param   {Document}    [doc]\n     */\n\n    mixitup.Events.prototype.fire = function(eventType, el, detail, doc) {\n        var self        = this,\n            event       = null,\n            eventDetail = new mixitup.EventDetail();\n\n        self.callActions('beforeFire', arguments);\n\n        if (typeof self[eventType] === 'undefined') {\n            throw new Error('Event type \"' + eventType + '\" not found.');\n        }\n\n        eventDetail.state = new mixitup.State();\n\n        h.extend(eventDetail.state, detail.state);\n\n        if (detail.futureState) {\n            eventDetail.futureState = new mixitup.State();\n\n            h.extend(eventDetail.futureState, detail.futureState);\n        }\n\n        eventDetail.instance = detail.instance;\n\n        if (detail.originalEvent) {\n            eventDetail.originalEvent = detail.originalEvent;\n        }\n\n        event = h.getCustomEvent(eventType, eventDetail, doc);\n\n        self.callFilters('eventFire', event, arguments);\n\n        el.dispatchEvent(event);\n    };\n\n    // Asign a singleton instance to `mixitup.events`:\n\n    mixitup.events = new mixitup.Events();\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.QueueItem = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.args           = [];\n        this.instruction    = null;\n        this.triggerElement = null;\n        this.deferred       = null;\n        this.isToggling     = false;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.QueueItem);\n\n    mixitup.QueueItem.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.QueueItem.prototype.constructor = mixitup.QueueItem;\n\n    /**\n     * The `mixitup.Mixer` class is used to hold discreet, user-configured\n     * instances of MixItUp on a provided container element.\n     *\n     * Mixer instances are returned whenever the `mixitup()` factory function is called,\n     * which expose a range of methods enabling API-based filtering, sorting,\n     * insertion, removal and more.\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.Mixer = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.config            = new mixitup.Config();\n\n        this.id                = '';\n\n        this.isBusy            = false;\n        this.isToggling        = false;\n        this.incPadding        = true;\n\n        this.controls          = [];\n        this.targets           = [];\n        this.origOrder         = [];\n        this.cache             = {};\n\n        this.toggleArray       = [];\n\n        this.targetsMoved      = 0;\n        this.targetsImmovable  = 0;\n        this.targetsBound      = 0;\n        this.targetsDone       = 0;\n\n        this.staggerDuration   = 0;\n        this.effectsIn         = null;\n        this.effectsOut        = null;\n        this.transformIn       = [];\n        this.transformOut      = [];\n        this.queue             = [];\n\n        this.state             = null;\n        this.lastOperation     = null;\n        this.lastClicked       = null;\n        this.userCallback      = null;\n        this.userDeferred      = null;\n\n        this.dom               = new mixitup.MixerDom();\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Mixer);\n\n    mixitup.Mixer.prototype = Object.create(mixitup.Base.prototype);\n\n    h.extend(mixitup.Mixer.prototype,\n    /** @lends mixitup.Mixer */\n    {\n        constructor: mixitup.Mixer,\n\n        /**\n         * @private\n         * @instance\n         * @since 3.0.0\n         * @param {HTMLElement} container\n         * @param {HTMLElement} document\n         * @param {string}      id\n         * @param {object}      [config]\n         */\n\n        attach: function(container, document, id, config) {\n            var self    = this,\n                target  = null,\n                i       = -1;\n\n            self.callActions('beforeAttach', arguments);\n\n            self.id = id;\n\n            if (config) {\n                h.extend(self.config, config, true, true);\n            }\n\n            self.sanitizeConfig();\n\n            self.cacheDom(container, document);\n\n            if (self.config.layout.containerClassName) {\n                h.addClass(self.dom.container, self.config.layout.containerClassName);\n            }\n\n            if (!mixitup.features.has.transitions) {\n                self.config.animation.enable = false;\n            }\n\n            if (typeof window.console === 'undefined') {\n                self.config.debug.showWarnings = false;\n            }\n\n            if (self.config.data.uidKey) {\n                // If the dataset API is in use, force disable controls\n\n                self.config.controls.enable = false;\n            }\n\n            self.indexTargets();\n\n            self.state = self.getInitialState();\n\n            for (i = 0; target = self.lastOperation.toHide[i]; i++) {\n                target.hide();\n            }\n\n            if (self.config.controls.enable) {\n                self.initControls();\n\n                self.buildToggleArray(null, self.state);\n\n                self.updateControls({\n                    filter: self.state.activeFilter,\n                    sort: self.state.activeSort\n                });\n            }\n\n            self.parseEffects();\n\n            self.callActions('afterAttach', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since 3.0.0\n         * @return {void}\n         */\n\n        sanitizeConfig: function() {\n            var self = this;\n\n            self.callActions('beforeSanitizeConfig', arguments);\n\n            // Sanitize enum/string config options\n\n            self.config.controls.scope          = self.config.controls.scope.toLowerCase().trim();\n            self.config.controls.toggleLogic    = self.config.controls.toggleLogic.toLowerCase().trim();\n            self.config.controls.toggleDefault  = self.config.controls.toggleDefault.toLowerCase().trim();\n\n            self.config.animation.effects       = self.config.animation.effects.trim();\n\n            self.callActions('afterSanitizeConfig', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {mixitup.State}\n         */\n\n        getInitialState: function() {\n            var self        = this,\n                state       = new mixitup.State(),\n                operation   = new mixitup.Operation();\n\n            self.callActions('beforeGetInitialState', arguments);\n\n            // Map initial values into a mock state object in order to construct an operation\n\n            state.activeContainerClassName = self.config.layout.containerClassName;\n\n            if (self.config.load.dataset) {\n                // Dataset API\n\n                if (!self.config.data.uidKey || typeof self.config.data.uidKey !== 'string') {\n                    throw new TypeError(mixitup.messages.errorConfigDataUidKeyNotSet());\n                }\n\n                operation.startDataset = operation.newDataset = state.activeDataset = self.config.load.dataset.slice();\n                operation.startContainerClassName = operation.newContainerClassName = state.activeContainerClassName;\n                operation.show = self.targets.slice();\n\n                state = self.callFilters('stateGetInitialState', state, arguments);\n            } else {\n                // DOM API\n\n                state.activeFilter              = self.parseFilterArgs([self.config.load.filter]).command;\n                state.activeSort                = self.parseSortArgs([self.config.load.sort]).command;\n                state.totalTargets              = self.targets.length;\n\n                state = self.callFilters('stateGetInitialState', state, arguments);\n\n                if (\n                    state.activeSort.collection || state.activeSort.attribute ||\n                    state.activeSort.order === 'random' || state.activeSort.order === 'desc'\n                ) {\n                    // Sorting on load\n\n                    operation.newSort = state.activeSort;\n\n                    self.sortOperation(operation);\n\n                    self.printSort(false, operation);\n\n                    self.targets = operation.newOrder;\n                } else {\n                    operation.startOrder = operation.newOrder = self.targets;\n                }\n\n                operation.startFilter               = operation.newFilter               = state.activeFilter;\n                operation.startSort                 = operation.newSort                 = state.activeSort;\n                operation.startContainerClassName   = operation.newContainerClassName   = state.activeContainerClassName;\n\n                if (operation.newFilter.selector === 'all') {\n                    operation.newFilter.selector = self.config.selectors.target;\n                } else if (operation.newFilter.selector === 'none') {\n                    operation.newFilter.selector = '';\n                }\n            }\n\n            operation = self.callFilters('operationGetInitialState', operation, [state]);\n\n            self.lastOperation = operation;\n\n            if (operation.newFilter) {\n                self.filterOperation(operation);\n            }\n\n            state = self.buildState(operation);\n\n            return state;\n        },\n\n        /**\n         * Caches references of DOM elements neccessary for the mixer's functionality.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {HTMLElement}       el\n         * @param   {HTMLHtmlElement}   document\n         * @return  {void}\n         */\n\n        cacheDom: function(el, document) {\n            var self    = this;\n\n            self.callActions('beforeCacheDom', arguments);\n\n            self.dom.document  = document;\n            self.dom.body      = self.dom.document.querySelector('body');\n            self.dom.container = el;\n            self.dom.parent    = el;\n\n            self.callActions('afterCacheDom', arguments);\n        },\n\n        /**\n         * Indexes all child elements of the mixer matching the `selectors.target`\n         * selector, instantiating a mixitup.Target for each one.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {void}\n         */\n\n        indexTargets: function() {\n            var self            = this,\n                target          = null,\n                el              = null,\n                dataset         = null,\n                i               = -1;\n\n            self.callActions('beforeIndexTargets', arguments);\n\n            self.dom.targets = self.config.layout.allowNestedTargets ?\n                self.dom.container.querySelectorAll(self.config.selectors.target) :\n                h.children(self.dom.container, self.config.selectors.target, self.dom.document);\n\n            self.dom.targets = h.arrayFromList(self.dom.targets);\n\n            self.targets = [];\n\n            if ((dataset = self.config.load.dataset) && dataset.length !== self.dom.targets.length) {\n                throw new Error(mixitup.messages.errorDatasetPrerenderedMismatch());\n            }\n\n            if (self.dom.targets.length) {\n                for (i = 0; el = self.dom.targets[i]; i++) {\n                    target = new mixitup.Target();\n\n                    target.init(el, self, dataset ? dataset[i] : void(0));\n\n                    target.isInDom = true;\n\n                    self.targets.push(target);\n                }\n\n                self.dom.parent = self.dom.targets[0].parentElement === self.dom.container ?\n                    self.dom.container :\n                    self.dom.targets[0].parentElement;\n            }\n\n            self.origOrder = self.targets;\n\n            self.callActions('afterIndexTargets', arguments);\n        },\n\n        initControls: function() {\n            var self                = this,\n                definition          = '',\n                controlElements     = null,\n                el                  = null,\n                parent              = null,\n                delagators          = null,\n                control             = null,\n                i                   = -1,\n                j                   = -1;\n\n            self.callActions('beforeInitControls', arguments);\n\n            switch (self.config.controls.scope) {\n                case 'local':\n                    parent = self.dom.container;\n\n                    break;\n                case 'global':\n                    parent = self.dom.document;\n\n                    break;\n                default:\n                    throw new Error(mixitup.messages.errorConfigInvalidControlsScope());\n            }\n\n            for (i = 0; definition = mixitup.controlDefinitions[i]; i++) {\n                if (self.config.controls.live || definition.live) {\n                    if (definition.parent) {\n                        delagators = self.dom[definition.parent];\n\n                        if (!delagators || delagators.length < 0) continue;\n\n                        if (typeof delagators.length !== 'number') {\n                            delagators = [delagators];\n                        }\n                    } else {\n                        delagators = [parent];\n                    }\n\n                    for (j = 0; (el = delagators[j]); j++) {\n                        control = self.getControl(el,  definition.type, definition.selector);\n\n                        self.controls.push(control);\n                    }\n                } else {\n                    controlElements = parent.querySelectorAll(self.config.selectors.control + definition.selector);\n\n                    for (j = 0; (el = controlElements[j]); j++) {\n                        control = self.getControl(el, definition.type, '');\n\n                        if (!control) continue;\n\n                        self.controls.push(control);\n                    }\n                }\n            }\n\n            self.callActions('afterInitControls', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {HTMLElement} el\n         * @param   {string}      type\n         * @param   {string}      selector\n         * @return  {mixitup.Control|null}\n         */\n\n        getControl: function(el, type, selector) {\n            var self    = this,\n                control = null,\n                i       = -1;\n\n            self.callActions('beforeGetControl', arguments);\n\n            if (!selector) {\n                // Static controls only\n\n                for (i = 0; control = mixitup.controls[i]; i++) {\n                    if (control.el === el && control.isBound(self)) {\n                        // Control already bound to this mixer (as another type).\n\n                        // NB: This prevents duplicate controls from being registered where a selector\n                        // might collide, eg: \"[data-filter]\" and \"[data-filter][data-sort]\"\n\n                        return self.callFilters('controlGetControl', null, arguments);\n                    } else if (control.el === el && control.type === type && control.selector === selector) {\n                        // Another mixer is already using this control, add this mixer as a binding\n\n                        control.addBinding(self);\n\n                        return self.callFilters('controlGetControl', control, arguments);\n                    }\n                }\n            }\n\n            // Create new control\n\n            control = new mixitup.Control();\n\n            control.init(el, type, selector);\n\n            control.classNames.base     = h.getClassname(self.config.classNames, type);\n            control.classNames.active   = h.getClassname(self.config.classNames, type, self.config.classNames.modifierActive);\n            control.classNames.disabled = h.getClassname(self.config.classNames, type, self.config.classNames.modifierDisabled);\n\n            // Add a reference to this mixer as a binding\n\n            control.addBinding(self);\n\n            return self.callFilters('controlGetControl', control, arguments);\n        },\n\n        /**\n         * Creates a compound selector by joining the `toggleArray` value as per the\n         * defined toggle logic.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {string}\n         */\n\n        getToggleSelector: function() {\n            var self            = this,\n                delineator      = self.config.controls.toggleLogic === 'or' ? ', ' : '',\n                toggleSelector  = '';\n\n            self.callActions('beforeGetToggleSelector', arguments);\n\n            self.toggleArray = h.clean(self.toggleArray);\n\n            toggleSelector = self.toggleArray.join(delineator);\n\n            if (toggleSelector === '') {\n                toggleSelector = self.config.controls.toggleDefault;\n            }\n\n            return self.callFilters('selectorGetToggleSelector', toggleSelector, arguments);\n        },\n\n        /**\n         * Breaks compound selector strings in an array of discreet selectors,\n         * as per the active `controls.toggleLogic` configuration option. Accepts\n         * either a dynamic command object, or a state object.\n         *\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {object}        [command]\n         * @param   {mixitup.State} [state]\n         * @return  {void}\n         */\n\n        buildToggleArray: function(command, state) {\n            var self                    = this,\n                activeFilterSelector    = '';\n\n            self.callActions('beforeBuildToggleArray', arguments);\n\n            if (command && command.filter) {\n                activeFilterSelector = command.filter.selector.replace(/\\s/g, '');\n            } else if (state) {\n                activeFilterSelector = state.activeFilter.selector.replace(/\\s/g, '');\n            } else {\n                return;\n            }\n\n            if (activeFilterSelector === self.config.selectors.target || activeFilterSelector === 'all') {\n                activeFilterSelector = '';\n            }\n\n            if (self.config.controls.toggleLogic === 'or') {\n                self.toggleArray = activeFilterSelector.split(',');\n            } else {\n                self.toggleArray = self.splitCompoundSelector(activeFilterSelector);\n            }\n\n            self.toggleArray = h.clean(self.toggleArray);\n\n            self.callActions('afterBuildToggleArray', arguments);\n        },\n\n        /**\n         * Takes a compound selector (e.g. `.cat-1.cat-2`, `[data-cat=\"1\"][data-cat=\"2\"]`)\n         * and breaks into its individual selectors.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {string} compoundSelector\n         * @return  {string[]}\n         */\n\n        splitCompoundSelector: function(compoundSelector) {\n            // Break at a `.` or `[`, capturing the delineator\n\n            var partials    = compoundSelector.split(/([\\.\\[])/g),\n                toggleArray = [],\n                selector    = '',\n                i           = -1;\n\n            if (partials[0] === '') {\n                partials.shift();\n            }\n\n            for (i = 0; i < partials.length; i++) {\n                if (i % 2 === 0) {\n                    selector = '';\n                }\n\n                selector += partials[i];\n\n                if (i % 2 !== 0) {\n                    toggleArray.push(selector);\n                }\n            }\n\n            return toggleArray;\n        },\n\n        /**\n         * Updates controls to their active/inactive state based on the command or\n         * current state of the mixer.\n         *\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {object} command\n         * @return  {void}\n         */\n\n        updateControls: function(command) {\n            var self    = this,\n                control = null,\n                output  = new mixitup.CommandMultimix(),\n                i       = -1;\n\n            self.callActions('beforeUpdateControls', arguments);\n\n            // Sanitise to defaults\n\n            if (command.filter) {\n                output.filter = command.filter.selector;\n            } else {\n                output.filter = self.state.activeFilter.selector;\n            }\n\n            if (command.sort) {\n                output.sort = self.buildSortString(command.sort);\n            } else {\n                output.sort = self.buildSortString(self.state.activeSort);\n            }\n\n            if (output.filter === self.config.selectors.target) {\n                output.filter = 'all';\n            }\n\n            if (output.filter === '') {\n                output.filter = 'none';\n            }\n\n            h.freeze(output);\n\n            for (i = 0; control = self.controls[i]; i++) {\n                control.update(output, self.toggleArray);\n            }\n\n            self.callActions('afterUpdateControls', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {mixitup.CommandSort}   command\n         * @return  {string}\n         */\n\n        buildSortString: function(command) {\n            var self    = this;\n            var output  = '';\n\n            output += command.sortString;\n\n            if (command.next) {\n                output += ' ' + self.buildSortString(command.next);\n            }\n\n            return output;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {object}        command\n         * @param   {Operation}     operation\n         * @return  {Promise.<mixitup.State>}\n         */\n\n        insertTargets: function(command, operation) {\n            var self            = this,\n                nextSibling     = null,\n                insertionIndex  = -1,\n                frag            = null,\n                target          = null,\n                el              = null,\n                i               = -1;\n\n            self.callActions('beforeInsertTargets', arguments);\n\n            if (typeof command.index === 'undefined') command.index = 0;\n\n            nextSibling = self.getNextSibling(command.index, command.sibling, command.position);\n            frag        = self.dom.document.createDocumentFragment();\n\n            if (nextSibling) {\n                insertionIndex = h.index(nextSibling, self.config.selectors.target);\n            } else {\n                insertionIndex = self.targets.length;\n            }\n\n            if (command.collection) {\n                for (i = 0; el = command.collection[i]; i++) {\n                    if (self.dom.targets.indexOf(el) > -1) {\n                        throw new Error(mixitup.messages.errorInsertPreexistingElement());\n                    }\n\n                    // Ensure elements are hidden when they are added to the DOM, so they can\n                    // be animated in gracefully\n\n                    el.style.display = 'none';\n\n                    frag.appendChild(el);\n                    frag.appendChild(self.dom.document.createTextNode(' '));\n\n                    if (!h.isElement(el, self.dom.document) || !el.matches(self.config.selectors.target)) continue;\n\n                    target = new mixitup.Target();\n\n                    target.init(el, self);\n\n                    target.isInDom = true;\n\n                    self.targets.splice(insertionIndex, 0, target);\n\n                    insertionIndex++;\n                }\n\n                self.dom.parent.insertBefore(frag, nextSibling);\n            }\n\n            // Since targets have been added, the original order must be updated\n\n            operation.startOrder = self.origOrder = self.targets;\n\n            self.callActions('afterInsertTargets', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Number}      [index]\n         * @param   {Element}     [sibling]\n         * @param   {string}      [position]\n         * @return  {Element}\n         */\n\n        getNextSibling: function(index, sibling, position) {\n            var self    = this,\n                element = null;\n\n            index = Math.max(index, 0);\n\n            if (sibling && position === 'before') {\n                // Explicit sibling\n\n                element = sibling;\n            } else if (sibling && position === 'after') {\n                // Explicit sibling\n\n                element = sibling.nextElementSibling || null;\n            } else if (self.targets.length > 0 && typeof index !== 'undefined') {\n                // Index and targets exist\n\n                element = (index < self.targets.length || !self.targets.length) ?\n                    self.targets[index].dom.el :\n                    self.targets[self.targets.length - 1].dom.el.nextElementSibling;\n            } else if (self.targets.length === 0 && self.dom.parent.children.length > 0) {\n                // No targets but other siblings\n\n                if (self.config.layout.siblingAfter) {\n                    element = self.config.layout.siblingAfter;\n                } else if (self.config.layout.siblingBefore) {\n                    element = self.config.layout.siblingBefore.nextElementSibling;\n                } else {\n                    self.dom.parent.children[0];\n                }\n            } else {\n                element === null;\n            }\n\n            return self.callFilters('elementGetNextSibling', element, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        filterOperation: function(operation) {\n            var self        = this,\n                testResult  = false,\n                index       = -1,\n                action      = '',\n                target      = null,\n                i           = -1;\n\n            self.callActions('beforeFilterOperation', arguments);\n\n            action = operation.newFilter.action;\n\n            for (i = 0; target = operation.newOrder[i]; i++) {\n                if (operation.newFilter.collection) {\n                    // show via collection\n\n                    testResult = operation.newFilter.collection.indexOf(target.dom.el) > -1;\n                } else {\n                    // show via selector\n\n                    if (operation.newFilter.selector === '') {\n                        testResult = false;\n                    } else {\n                        testResult = target.dom.el.matches(operation.newFilter.selector);\n                    }\n                }\n\n                self.evaluateHideShow(testResult, target, action, operation);\n            }\n\n            if (operation.toRemove.length) {\n                for (i = 0; target = operation.show[i]; i++) {\n                    if (operation.toRemove.indexOf(target) > -1) {\n                        // If any shown targets should be removed, move them into the toHide array\n\n                        operation.show.splice(i, 1);\n\n                        if ((index = operation.toShow.indexOf(target)) > -1) {\n                            operation.toShow.splice(index, 1);\n                        }\n\n                        operation.toHide.push(target);\n                        operation.hide.push(target);\n\n                        i--;\n                    }\n                }\n            }\n\n            operation.matching = operation.show.slice();\n\n            if (operation.show.length === 0 && operation.newFilter.selector !== '' && self.targets.length !== 0) {\n                operation.hasFailed = true;\n            }\n\n            self.callActions('afterFilterOperation', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {boolean}   testResult\n         * @param   {Element}   target\n         * @param   {string}    action\n         * @param   {Operation} operation\n         * @return  {void}\n         */\n\n        evaluateHideShow: function(testResult, target, action, operation) {\n            var self = this,\n                filteredTestResult = false,\n                args = Array.prototype.slice.call(arguments, 1);\n\n            filteredTestResult = self.callFilters('testResultEvaluateHideShow', testResult, args);\n\n            self.callActions('beforeEvaluateHideShow', arguments);\n\n            if (\n                filteredTestResult === true && action === 'show' ||\n                filteredTestResult === false && action === 'hide'\n            ) {\n                operation.show.push(target);\n\n                !target.isShown && operation.toShow.push(target);\n            } else {\n                operation.hide.push(target);\n\n                target.isShown && operation.toHide.push(target);\n            }\n\n            self.callActions('afterEvaluateHideShow', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        sortOperation: function(operation) {\n            var self     = this,\n                newOrder = [],\n                target   = null,\n                el       = null,\n                i        = -1;\n\n            self.callActions('beforeSortOperation', arguments);\n\n            operation.startOrder = self.targets;\n\n            if (operation.newSort.collection) {\n                // Sort by collection\n\n                newOrder = [];\n\n                for (i = 0; (el = operation.newSort.collection[i]); i++) {\n                    if (self.dom.targets.indexOf(el) < 0) {\n                        throw new Error(mixitup.messages.errorSortNonExistentElement());\n                    }\n\n                    target = new mixitup.Target();\n\n                    target.init(el, self);\n\n                    target.isInDom = true;\n\n                    newOrder.push(target);\n                }\n\n                operation.newOrder = newOrder;\n            } else if (operation.newSort.order === 'random') {\n                // Sort random\n\n                operation.newOrder = h.arrayShuffle(operation.startOrder);\n            } else if (operation.newSort.attribute === '') {\n                // Sort by default\n\n                operation.newOrder = self.origOrder.slice();\n\n                if (operation.newSort.order === 'desc') {\n                    operation.newOrder.reverse();\n                }\n            } else {\n                // Sort by attribute\n\n                operation.newOrder = operation.startOrder.slice();\n\n                operation.newOrder.sort(function(a, b) {\n                    return self.compare(a, b, operation.newSort);\n                });\n            }\n\n            if (h.isEqualArray(operation.newOrder, operation.startOrder)) {\n                operation.willSort = false;\n            }\n\n            self.callActions('afterSortOperation', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {mixitup.Target}        a\n         * @param   {mixitup.Target}        b\n         * @param   {mixitup.CommandSort}   command\n         * @return  {Number}\n         */\n\n        compare: function(a, b, command) {\n            var self        = this,\n                order       = command.order,\n                attrA       = self.getAttributeValue(a, command.attribute),\n                attrB       = self.getAttributeValue(b, command.attribute);\n\n            if (isNaN(attrA * 1) || isNaN(attrB * 1)) {\n                attrA = attrA.toLowerCase();\n                attrB = attrB.toLowerCase();\n            } else {\n                attrA = attrA * 1;\n                attrB = attrB * 1;\n            }\n\n            if (attrA < attrB) {\n                return order === 'asc' ? -1 : 1;\n            }\n\n            if (attrA > attrB) {\n                return order === 'asc' ? 1 : -1;\n            }\n\n            if (attrA === attrB && command.next) {\n                return self.compare(a, b, command.next);\n            }\n\n            return 0;\n        },\n\n        /**\n         * Reads the values of any data attributes present the provided target element\n         * which match the current sort command.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {mixitup.Target}    target\n         * @param   {string}            [attribute]\n         * @return  {(String|Number)}\n         */\n\n        getAttributeValue: function(target, attribute) {\n            var self    = this,\n                value   = '';\n\n            value = target.dom.el.getAttribute('data-' + attribute);\n\n            if (value === null) {\n                if (self.config.debug.showWarnings) {\n                    // Encourage users to assign values to all targets to avoid erroneous sorting\n                    // when types are mixed\n\n                    console.warn(mixitup.messages.warningInconsistentSortingAttributes({\n                        attribute: 'data-' + attribute\n                    }));\n                }\n            }\n\n            // If an attribute is not present, return 0 as a safety value\n\n            return self.callFilters('valueGetAttributeValue', value || 0, arguments);\n        },\n\n        /**\n         * Inserts elements into the DOM in the appropriate\n         * order using a document fragment for minimal\n         * DOM thrashing\n         *\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {boolean}   isResetting\n         * @param   {Operation} operation\n         * @return  {void}\n         */\n\n        printSort: function(isResetting, operation) {\n            var self        = this,\n                startOrder  = isResetting ? operation.newOrder : operation.startOrder,\n                newOrder    = isResetting ? operation.startOrder : operation.newOrder,\n                nextSibling = startOrder.length ? startOrder[startOrder.length - 1].dom.el.nextElementSibling : null,\n                frag        = window.document.createDocumentFragment(),\n                whitespace  = null,\n                target      = null,\n                el          = null,\n                i           = -1;\n\n            self.callActions('beforePrintSort', arguments);\n\n            // Empty the container\n\n            for (i = 0; target = startOrder[i]; i++) {\n                el = target.dom.el;\n\n                if (el.style.position === 'absolute') continue;\n\n                h.removeWhitespace(el.previousSibling);\n\n                el.parentElement.removeChild(el);\n            }\n\n            whitespace = nextSibling ? nextSibling.previousSibling : self.dom.parent.lastChild;\n\n            if (whitespace && whitespace.nodeName === '#text') {\n                h.removeWhitespace(whitespace);\n            }\n\n            for (i = 0; target = newOrder[i]; i++) {\n                // Add targets into a document fragment\n\n                el = target.dom.el;\n\n                if (h.isElement(frag.lastChild)) {\n                    frag.appendChild(window.document.createTextNode(' '));\n                }\n\n                frag.appendChild(el);\n            }\n\n            // Insert the document fragment into the container\n            // before any other non-target elements\n\n            if (self.dom.parent.firstChild && self.dom.parent.firstChild !== nextSibling) {\n                frag.insertBefore(window.document.createTextNode(' '), frag.childNodes[0]);\n            }\n\n            if (nextSibling) {\n                frag.appendChild(window.document.createTextNode(' '));\n\n                self.dom.parent.insertBefore(frag, nextSibling);\n            } else {\n                self.dom.parent.appendChild(frag);\n            }\n\n            self.callActions('afterPrintSort', arguments);\n        },\n\n        /**\n         * Parses user-defined sort strings (i.e. `default:asc`) into sort commands objects.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {string}                sortString\n         * @param   {mixitup.CommandSort}   command\n         * @return  {mixitup.CommandSort}\n         */\n\n        parseSortString: function(sortString, command) {\n            var self        = this,\n                rules       = sortString.split(' '),\n                current     = command,\n                rule        = [],\n                i           = -1;\n\n            // command.sortString = sortString;\n\n            for (i = 0; i < rules.length; i++) {\n                rule = rules[i].split(':');\n\n                current.sortString  = rules[i];\n                current.attribute   = h.dashCase(rule[0]);\n                current.order       = rule[1] || 'asc';\n\n                switch (current.attribute) {\n                    case 'default':\n                        // treat \"default\" as sorting by no attribute\n\n                        current.attribute = '';\n\n                        break;\n                    case 'random':\n                        // treat \"random\" as an order not an attribute\n\n                        current.attribute   = '';\n                        current.order       = 'random';\n\n                        break;\n                }\n\n                if (!current.attribute || current.order === 'random') break;\n\n                if (i < rules.length - 1) {\n                    // Embed reference to the next command\n\n                    current.next = new mixitup.CommandSort();\n\n                    h.freeze(current);\n\n                    current = current.next;\n                }\n            }\n\n            return self.callFilters('commandsParseSort', command, arguments);\n        },\n\n        /**\n         * Parses all effects out of the user-defined `animation.effects` string into\n         * their respective properties and units.\n         *\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @return  {void}\n         */\n\n        parseEffects: function() {\n            var self            = this,\n                transformName   = '',\n                effectsIn       = self.config.animation.effectsIn || self.config.animation.effects,\n                effectsOut      = self.config.animation.effectsOut || self.config.animation.effects;\n\n            self.callActions('beforeParseEffects', arguments);\n\n            self.effectsIn      = new mixitup.StyleData();\n            self.effectsOut     = new mixitup.StyleData();\n            self.transformIn    = [];\n            self.transformOut   = [];\n\n            self.effectsIn.opacity = self.effectsOut.opacity = 1;\n\n            self.parseEffect('fade', effectsIn, self.effectsIn, self.transformIn);\n            self.parseEffect('fade', effectsOut, self.effectsOut, self.transformOut, true);\n\n            for (transformName in mixitup.transformDefaults) {\n                if (!(mixitup.transformDefaults[transformName] instanceof mixitup.TransformData)) {\n                    continue;\n                }\n\n                self.parseEffect(transformName, effectsIn, self.effectsIn, self.transformIn);\n                self.parseEffect(transformName, effectsOut, self.effectsOut, self.transformOut, true);\n            }\n\n            self.parseEffect('stagger', effectsIn, self.effectsIn, self.transformIn);\n            self.parseEffect('stagger', effectsOut, self.effectsOut, self.transformOut, true);\n\n            self.callActions('afterParseEffects', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {string}    effectName\n         * @param   {string}    effectString\n         * @param   {StyleData} effects\n         * @param   {String[]}  transform\n         * @param   {boolean}   [isOut]\n         */\n\n        parseEffect: function(effectName, effectString, effects, transform, isOut) {\n            var self        = this,\n                re          = /\\(([^)]+)\\)/,\n                propIndex   = -1,\n                str         = '',\n                match       = [],\n                val         = '',\n                units       = ['%', 'px', 'em', 'rem', 'vh', 'vw', 'deg'],\n                unit        = '',\n                i           = -1;\n\n            self.callActions('beforeParseEffect', arguments);\n\n            if (typeof effectString !== 'string') {\n                throw new TypeError(mixitup.messages.errorConfigInvalidAnimationEffects());\n            }\n\n            if (effectString.indexOf(effectName) < 0) {\n                // The effect is not present in the effects string\n\n                if (effectName === 'stagger') {\n                    // Reset stagger to 0\n\n                    self.staggerDuration = 0;\n                }\n\n                return;\n            }\n\n            // The effect is present\n\n            propIndex = effectString.indexOf(effectName + '(');\n\n            if (propIndex > -1) {\n                // The effect has a user defined value in parentheses\n\n                // Extract from the first parenthesis to the end of string\n\n                str = effectString.substring(propIndex);\n\n                // Match any number of characters between \"(\" and \")\"\n\n                match = re.exec(str);\n\n                val = match[1];\n            }\n\n            switch (effectName) {\n                case 'fade':\n                    effects.opacity = val ? parseFloat(val) : 0;\n\n                    break;\n                case 'stagger':\n                    self.staggerDuration = val ? parseFloat(val) : 100;\n\n                    // TODO: Currently stagger must be applied globally, but\n                    // if seperate values are specified for in/out, this should\n                    // be respected\n\n                    break;\n                default:\n                    // All other effects are transforms following the same structure\n\n                    if (isOut && self.config.animation.reverseOut && effectName !== 'scale') {\n                        effects[effectName].value =\n                            (val ? parseFloat(val) : mixitup.transformDefaults[effectName].value) * -1;\n                    } else {\n                        effects[effectName].value =\n                            (val ? parseFloat(val) : mixitup.transformDefaults[effectName].value);\n                    }\n\n                    if (val) {\n                        for (i = 0; unit = units[i]; i++) {\n                            if (val.indexOf(unit) > -1) {\n                                effects[effectName].unit = unit;\n\n                                break;\n                            }\n                        }\n                    } else {\n                        effects[effectName].unit = mixitup.transformDefaults[effectName].unit;\n                    }\n\n                    transform.push(\n                        effectName +\n                        '(' +\n                        effects[effectName].value +\n                        effects[effectName].unit +\n                        ')'\n                    );\n            }\n\n            self.callActions('afterParseEffect', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {State}\n         */\n\n        buildState: function(operation) {\n            var self        = this,\n                state       = new mixitup.State(),\n                target      = null,\n                i           = -1;\n\n            self.callActions('beforeBuildState', arguments);\n\n            // Map target elements into state arrays.\n            // the real target objects should never be exposed\n\n            for (i = 0; target = self.targets[i]; i++) {\n                if (!operation.toRemove.length || operation.toRemove.indexOf(target) < 0) {\n                    state.targets.push(target.dom.el);\n                }\n            }\n\n            for (i = 0; target = operation.matching[i]; i++) {\n                state.matching.push(target.dom.el);\n            }\n\n            for (i = 0; target = operation.show[i]; i++) {\n                state.show.push(target.dom.el);\n            }\n\n            for (i = 0; target = operation.hide[i]; i++) {\n                if (!operation.toRemove.length || operation.toRemove.indexOf(target) < 0) {\n                    state.hide.push(target.dom.el);\n                }\n            }\n\n            state.id                        = self.id;\n            state.container                 = self.dom.container;\n            state.activeFilter              = operation.newFilter;\n            state.activeSort                = operation.newSort;\n            state.activeDataset             = operation.newDataset;\n            state.activeContainerClassName  = operation.newContainerClassName;\n            state.hasFailed                 = operation.hasFailed;\n            state.totalTargets              = self.targets.length;\n            state.totalShow                 = operation.show.length;\n            state.totalHide                 = operation.hide.length;\n            state.totalMatching             = operation.matching.length;\n            state.triggerElement            = operation.triggerElement;\n\n            return self.callFilters('stateBuildState', state, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {boolean}   shouldAnimate\n         * @param   {Operation} operation\n         * @return  {void}\n         */\n\n        goMix: function(shouldAnimate, operation) {\n            var self        = this,\n                deferred    = null;\n\n            self.callActions('beforeGoMix', arguments);\n\n            // If the animation duration is set to 0ms,\n            // or no effects specified,\n            // or the container is hidden\n            // then abort animation\n\n            if (\n                !self.config.animation.duration || !self.config.animation.effects || !h.isVisible(self.dom.container)\n            ) {\n                shouldAnimate = false;\n            }\n\n            if (\n                !operation.toShow.length &&\n                !operation.toHide.length &&\n                !operation.willSort &&\n                !operation.willChangeLayout\n            ) {\n                // If nothing to show or hide, and not sorting or\n                // changing layout\n\n                shouldAnimate = false;\n            }\n\n            if (\n                !operation.startState.show.length &&\n                !operation.show.length\n            ) {\n                // If nothing currently shown, nothing to show\n\n                shouldAnimate = false;\n            }\n\n            mixitup.events.fire('mixStart', self.dom.container, {\n                state: operation.startState,\n                futureState: operation.newState,\n                instance: self\n            }, self.dom.document);\n\n            if (typeof self.config.callbacks.onMixStart === 'function') {\n                self.config.callbacks.onMixStart.call(\n                    self.dom.container,\n                    operation.startState,\n                    operation.newState,\n                    self\n                );\n            }\n\n            h.removeClass(self.dom.container, h.getClassname(self.config.classNames, 'container', self.config.classNames.modifierFailed));\n\n            if (!self.userDeferred) {\n                // Queue empty, no pending operations\n\n                deferred = self.userDeferred = h.defer(mixitup.libraries);\n            } else {\n                // Use existing deferred\n\n                deferred = self.userDeferred;\n            }\n\n            self.isBusy = true;\n\n            if (!shouldAnimate || !mixitup.features.has.transitions) {\n                // Abort\n\n                if (self.config.debug.fauxAsync) {\n                    setTimeout(function() {\n                        self.cleanUp(operation);\n                    }, self.config.animation.duration);\n                } else {\n                    self.cleanUp(operation);\n                }\n\n                return self.callFilters('promiseGoMix', deferred.promise, arguments);\n            }\n\n            // If we should animate and the platform supports transitions, go for it\n\n            if (window.pageYOffset !== operation.docState.scrollTop) {\n                window.scrollTo(operation.docState.scrollLeft, operation.docState.scrollTop);\n            }\n\n            if (self.config.animation.applyPerspective) {\n                self.dom.parent.style[mixitup.features.perspectiveProp] =\n                    self.config.animation.perspectiveDistance;\n\n                self.dom.parent.style[mixitup.features.perspectiveOriginProp] =\n                    self.config.animation.perspectiveOrigin;\n            }\n\n            if (\n                self.config.animation.animateResizeContainer &&\n                operation.startHeight !== operation.newHeight &&\n                operation.viewportDeltaY !== operation.startHeight - operation.newHeight\n            ) {\n                self.dom.parent.style.height = operation.startHeight + 'px';\n            }\n\n            if (\n                self.config.animation.animateResizeContainer &&\n                operation.startWidth !== operation.newWidth &&\n                operation.viewportDeltaX !== operation.startWidth - operation.newWidth\n            ) {\n                self.dom.parent.style.width = operation.startWidth + 'px';\n            }\n\n            if (operation.startHeight === operation.newHeight) {\n                self.dom.parent.style.height = operation.startHeight + 'px';\n            }\n\n            if (operation.startWidth === operation.newWidth) {\n                self.dom.parent.style.width = operation.startWidth + 'px';\n            }\n\n            if (operation.startHeight === operation.newHeight && operation.startWidth === operation.newWidth) {\n                self.dom.parent.style.overflow = 'hidden';\n            }\n\n            requestAnimationFrame(function() {\n                self.moveTargets(operation);\n            });\n\n            return self.callFilters('promiseGoMix', deferred.promise, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        getStartMixData: function(operation) {\n            var self        = this,\n                parentStyle = window.getComputedStyle(self.dom.parent),\n                parentRect  = self.dom.parent.getBoundingClientRect(),\n                target      = null,\n                data        = {},\n                i           = -1,\n                boxSizing   = parentStyle[mixitup.features.boxSizingProp];\n\n            self.incPadding = (boxSizing === 'border-box');\n\n            self.callActions('beforeGetStartMixData', arguments);\n\n            for (i = 0; target = operation.show[i]; i++) {\n                data = target.getPosData();\n\n                operation.showPosData[i] = {\n                    startPosData: data\n                };\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                data = target.getPosData();\n\n                operation.toHidePosData[i] = {\n                    startPosData: data\n                };\n            }\n\n            operation.startX = parentRect.left;\n            operation.startY = parentRect.top;\n\n            operation.startHeight = self.incPadding ?\n                parentRect.height :\n                parentRect.height -\n                    parseFloat(parentStyle.paddingTop) -\n                    parseFloat(parentStyle.paddingBottom) -\n                    parseFloat(parentStyle.borderTop) -\n                    parseFloat(parentStyle.borderBottom);\n\n            operation.startWidth = self.incPadding ?\n                parentRect.width :\n                parentRect.width -\n                    parseFloat(parentStyle.paddingLeft) -\n                    parseFloat(parentStyle.paddingRight) -\n                    parseFloat(parentStyle.borderLeft) -\n                    parseFloat(parentStyle.borderRight);\n\n            self.callActions('afterGetStartMixData', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        setInter: function(operation) {\n            var self    = this,\n                target  = null,\n                i       = -1;\n\n            self.callActions('beforeSetInter', arguments);\n\n            // Prevent scrollbar flicker on non-inertial scroll platforms by clamping height/width\n\n            if (self.config.animation.clampHeight) {\n                self.dom.parent.style.height    = operation.startHeight + 'px';\n                self.dom.parent.style.overflow  = 'hidden';\n            }\n\n            if (self.config.animation.clampWidth) {\n                self.dom.parent.style.width     = operation.startWidth + 'px';\n                self.dom.parent.style.overflow  = 'hidden';\n            }\n\n            for (i = 0; target = operation.toShow[i]; i++) {\n                target.show();\n            }\n\n            if (operation.willChangeLayout) {\n                h.removeClass(self.dom.container, operation.startContainerClassName);\n                h.addClass(self.dom.container, operation.newContainerClassName);\n            }\n\n            self.callActions('afterSetInter', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        getInterMixData: function(operation) {\n            var self    = this,\n                target  = null,\n                i       = -1;\n\n            self.callActions('beforeGetInterMixData', arguments);\n\n            for (i = 0; target = operation.show[i]; i++) {\n                operation.showPosData[i].interPosData = target.getPosData();\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                operation.toHidePosData[i].interPosData = target.getPosData();\n            }\n\n            self.callActions('afterGetInterMixData', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        setFinal: function(operation) {\n            var self    = this,\n                target  = null,\n                i       = -1;\n\n            self.callActions('beforeSetFinal', arguments);\n\n            operation.willSort && self.printSort(false, operation);\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                target.hide();\n            }\n\n            self.callActions('afterSetFinal', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        getFinalMixData: function(operation) {\n            var self        = this,\n                parentStyle = null,\n                parentRect  = null,\n                target      = null,\n                i           = -1;\n\n            self.callActions('beforeGetFinalMixData', arguments);\n\n            for (i = 0; target = operation.show[i]; i++) {\n                operation.showPosData[i].finalPosData = target.getPosData();\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                operation.toHidePosData[i].finalPosData = target.getPosData();\n            }\n\n            // Remove clamping\n\n            if (self.config.animation.clampHeight || self.config.animation.clampWidth) {\n                self.dom.parent.style.height    =\n                self.dom.parent.style.width     =\n                self.dom.parent.style.overflow  = '';\n            }\n\n            if (!self.incPadding) {\n                parentStyle = window.getComputedStyle(self.dom.parent);\n            }\n\n            parentRect  = self.dom.parent.getBoundingClientRect();\n\n            operation.newX = parentRect.left;\n            operation.newY = parentRect.top;\n\n            operation.newHeight = self.incPadding ?\n                parentRect.height :\n                parentRect.height -\n                    parseFloat(parentStyle.paddingTop) -\n                    parseFloat(parentStyle.paddingBottom) -\n                    parseFloat(parentStyle.borderTop) -\n                    parseFloat(parentStyle.borderBottom);\n\n            operation.newWidth = self.incPadding ?\n                parentRect.width :\n                parentRect.width -\n                    parseFloat(parentStyle.paddingLeft) -\n                    parseFloat(parentStyle.paddingRight) -\n                    parseFloat(parentStyle.borderLeft) -\n                    parseFloat(parentStyle.borderRight);\n\n            operation.viewportDeltaX = operation.docState.viewportWidth - this.dom.document.documentElement.clientWidth;\n            operation.viewportDeltaY = operation.docState.viewportHeight - this.dom.document.documentElement.clientHeight;\n\n            if (operation.willSort) {\n                self.printSort(true, operation);\n            }\n\n            for (i = 0; target = operation.toShow[i]; i++) {\n                target.hide();\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                target.show();\n            }\n\n            if (operation.willChangeLayout) {\n                h.removeClass(self.dom.container, operation.newContainerClassName);\n                h.addClass(self.dom.container, self.config.layout.containerClassName);\n            }\n\n            self.callActions('afterGetFinalMixData', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since    3.0.0\n         * @param    {Operation}     operation\n         */\n\n        getTweenData: function(operation) {\n            var self            = this,\n                target          = null,\n                posData         = null,\n                effectNames     = Object.getOwnPropertyNames(self.effectsIn),\n                effectName      = '',\n                effect          = null,\n                widthChange     = -1,\n                heightChange    = -1,\n                i               = -1,\n                j               = -1;\n\n            self.callActions('beforeGetTweenData', arguments);\n\n            for (i = 0; target = operation.show[i]; i++) {\n                posData             = operation.showPosData[i];\n                posData.posIn       = new mixitup.StyleData();\n                posData.posOut      = new mixitup.StyleData();\n                posData.tweenData   = new mixitup.StyleData();\n\n                // Process x and y\n\n                if (target.isShown) {\n                    posData.posIn.x = posData.startPosData.x - posData.interPosData.x;\n                    posData.posIn.y = posData.startPosData.y - posData.interPosData.y;\n                } else {\n                    posData.posIn.x = posData.posIn.y = 0;\n                }\n\n                posData.posOut.x = posData.finalPosData.x - posData.interPosData.x;\n                posData.posOut.y = posData.finalPosData.y - posData.interPosData.y;\n\n                // Process opacity\n\n                posData.posIn.opacity       = target.isShown ? 1 : self.effectsIn.opacity;\n                posData.posOut.opacity      = 1;\n                posData.tweenData.opacity   = posData.posOut.opacity - posData.posIn.opacity;\n\n                // Adjust x and y if not nudging\n\n                if (!target.isShown && !self.config.animation.nudge) {\n                    posData.posIn.x = posData.posOut.x;\n                    posData.posIn.y = posData.posOut.y;\n                }\n\n                posData.tweenData.x = posData.posOut.x - posData.posIn.x;\n                posData.tweenData.y = posData.posOut.y - posData.posIn.y;\n\n                // Process width, height, and margins\n\n                if (self.config.animation.animateResizeTargets) {\n                    posData.posIn.width     = posData.startPosData.width;\n                    posData.posIn.height    = posData.startPosData.height;\n\n                    // \"||\" Prevents width/height change from including 0 width/height if hiding or showing\n\n                    widthChange = (posData.startPosData.width || posData.finalPosData.width) - posData.interPosData.width;\n\n                    posData.posIn.marginRight = posData.startPosData.marginRight - widthChange;\n\n                    heightChange = (posData.startPosData.height || posData.finalPosData.height) - posData.interPosData.height;\n\n                    posData.posIn.marginBottom = posData.startPosData.marginBottom - heightChange;\n\n                    posData.posOut.width    = posData.finalPosData.width;\n                    posData.posOut.height   = posData.finalPosData.height;\n\n                    widthChange = (posData.finalPosData.width || posData.startPosData.width) - posData.interPosData.width;\n\n                    posData.posOut.marginRight = posData.finalPosData.marginRight - widthChange;\n\n                    heightChange = (posData.finalPosData.height || posData.startPosData.height) - posData.interPosData.height;\n\n                    posData.posOut.marginBottom = posData.finalPosData.marginBottom - heightChange;\n\n                    posData.tweenData.width         = posData.posOut.width - posData.posIn.width;\n                    posData.tweenData.height        = posData.posOut.height - posData.posIn.height;\n                    posData.tweenData.marginRight   = posData.posOut.marginRight - posData.posIn.marginRight;\n                    posData.tweenData.marginBottom  = posData.posOut.marginBottom - posData.posIn.marginBottom;\n                }\n\n                // Process transforms\n\n                for (j = 0; effectName = effectNames[j]; j++) {\n                    effect = self.effectsIn[effectName];\n\n                    if (!(effect instanceof mixitup.TransformData) || !effect.value) continue;\n\n                    posData.posIn[effectName].value     = effect.value;\n                    posData.posOut[effectName].value    = 0;\n\n                    posData.tweenData[effectName].value =\n                        posData.posOut[effectName].value - posData.posIn[effectName].value;\n\n                    posData.posIn[effectName].unit =\n                        posData.posOut[effectName].unit =\n                        posData.tweenData[effectName].unit =\n                        effect.unit;\n                }\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                posData             = operation.toHidePosData[i];\n                posData.posIn       = new mixitup.StyleData();\n                posData.posOut      = new mixitup.StyleData();\n                posData.tweenData   = new mixitup.StyleData();\n\n                // Process x and y\n\n                posData.posIn.x     = target.isShown ? posData.startPosData.x - posData.interPosData.x : 0;\n                posData.posIn.y     = target.isShown ? posData.startPosData.y - posData.interPosData.y : 0;\n                posData.posOut.x    = self.config.animation.nudge ? 0 : posData.posIn.x;\n                posData.posOut.y    = self.config.animation.nudge ? 0 : posData.posIn.y;\n                posData.tweenData.x = posData.posOut.x - posData.posIn.x;\n                posData.tweenData.y = posData.posOut.y - posData.posIn.y;\n\n                // Process width, height, and margins\n\n                if (self.config.animation.animateResizeTargets) {\n                    posData.posIn.width         = posData.startPosData.width;\n                    posData.posIn.height        = posData.startPosData.height;\n\n                    widthChange = posData.startPosData.width - posData.interPosData.width;\n\n                    posData.posIn.marginRight = posData.startPosData.marginRight - widthChange;\n\n                    heightChange = posData.startPosData.height - posData.interPosData.height;\n\n                    posData.posIn.marginBottom = posData.startPosData.marginBottom - heightChange;\n                }\n\n                // Process opacity\n\n                posData.posIn.opacity       = 1;\n                posData.posOut.opacity      = self.effectsOut.opacity;\n                posData.tweenData.opacity   = posData.posOut.opacity - posData.posIn.opacity;\n\n                // Process transforms\n\n                for (j = 0; effectName = effectNames[j]; j++) {\n                    effect = self.effectsOut[effectName];\n\n                    if (!(effect instanceof mixitup.TransformData) || !effect.value) continue;\n\n                    posData.posIn[effectName].value     = 0;\n                    posData.posOut[effectName].value    = effect.value;\n\n                    posData.tweenData[effectName].value =\n                        posData.posOut[effectName].value - posData.posIn[effectName].value;\n\n                    posData.posIn[effectName].unit =\n                        posData.posOut[effectName].unit =\n                        posData.tweenData[effectName].unit =\n                        effect.unit;\n                }\n            }\n\n            self.callActions('afterGetTweenData', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        moveTargets: function(operation) {\n            var self            = this,\n                target          = null,\n                moveData        = null,\n                posData         = null,\n                statusChange    = '',\n                willTransition  = false,\n                staggerIndex    = -1,\n                i               = -1,\n                checkProgress   = self.checkProgress.bind(self);\n\n            self.callActions('beforeMoveTargets', arguments);\n\n            // TODO: this is an extra loop in addition to the calcs\n            // done in getOperation, could some of this be done there?\n\n            for (i = 0; target = operation.show[i]; i++) {\n                moveData    = new mixitup.IMoveData();\n                posData     = operation.showPosData[i];\n\n                statusChange = target.isShown ? 'none' : 'show';\n\n                willTransition = self.willTransition(\n                    statusChange,\n                    operation.hasEffect,\n                    posData.posIn,\n                    posData.posOut\n                );\n\n                if (willTransition) {\n                    // Prevent non-transitioning targets from incrementing the staggerIndex\n\n                    staggerIndex++;\n                }\n\n                target.show();\n\n                moveData.posIn          = posData.posIn;\n                moveData.posOut         = posData.posOut;\n                moveData.statusChange   = statusChange;\n                moveData.staggerIndex   = staggerIndex;\n                moveData.operation      = operation;\n                moveData.callback       = willTransition ? checkProgress : null;\n\n                target.move(moveData);\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                posData  = operation.toHidePosData[i];\n                moveData = new mixitup.IMoveData();\n\n                statusChange = 'hide';\n\n                willTransition = self.willTransition(statusChange, posData.posIn, posData.posOut);\n\n                moveData.posIn          = posData.posIn;\n                moveData.posOut         = posData.posOut;\n                moveData.statusChange   = statusChange;\n                moveData.staggerIndex   = i;\n                moveData.operation      = operation;\n                moveData.callback       = willTransition ? checkProgress : null;\n\n                target.move(moveData);\n            }\n\n            if (self.config.animation.animateResizeContainer) {\n                self.dom.parent.style[mixitup.features.transitionProp] =\n                    'height ' + self.config.animation.duration + 'ms ease, ' +\n                    'width ' + self.config.animation.duration + 'ms ease ';\n\n                requestAnimationFrame(function() {\n                    if (\n                        operation.startHeight !== operation.newHeight &&\n                        operation.viewportDeltaY !== operation.startHeight - operation.newHeight\n                    ) {\n                        self.dom.parent.style.height = operation.newHeight + 'px';\n                    }\n\n                    if (\n                        operation.startWidth !== operation.newWidth &&\n                        operation.viewportDeltaX !== operation.startWidth - operation.newWidth\n                    ) {\n                        self.dom.parent.style.width = operation.newWidth + 'px';\n                    }\n                });\n            }\n\n            if (operation.willChangeLayout) {\n                h.removeClass(self.dom.container, self.config.layout.ContainerClassName);\n                h.addClass(self.dom.container, operation.newContainerClassName);\n            }\n\n            self.callActions('afterMoveTargets', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @return  {boolean}\n         */\n\n        hasEffect: function() {\n            var self        = this,\n                EFFECTABLES = [\n                    'scale',\n                    'translateX', 'translateY', 'translateZ',\n                    'rotateX', 'rotateY', 'rotateZ'\n                ],\n                effectName  = '',\n                effect      = null,\n                result      = false,\n                value       = -1,\n                i           = -1;\n\n            if (self.effectsIn.opacity !== 1) {\n                return self.callFilters('resultHasEffect', true, arguments);\n            }\n\n            for (i = 0; effectName = EFFECTABLES[i]; i++) {\n                effect  = self.effectsIn[effectName];\n                value   = (typeof effect && effect.value !== 'undefined') ?\n                    effect.value : effect;\n\n                if (value !== 0) {\n                    result = true;\n\n                    break;\n                }\n            }\n\n            return self.callFilters('resultHasEffect', result, arguments);\n        },\n\n        /**\n         * Determines if a target element will transition in\n         * some fasion and therefore requires binding of\n         * transitionEnd\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {string}        statusChange\n         * @param   {boolean}       hasEffect\n         * @param   {StyleData}     posIn\n         * @param   {StyleData}     posOut\n         * @return  {boolean}\n         */\n\n        willTransition: function(statusChange, hasEffect, posIn, posOut) {\n            var self    = this,\n                result  = false;\n\n            if (!h.isVisible(self.dom.container)) {\n                // If the container is not visible, the transitionEnd\n                // event will not occur and MixItUp will hang\n\n                result = false;\n            } else if (\n                (statusChange !== 'none' && hasEffect) ||\n                posIn.x !== posOut.x ||\n                posIn.y !== posOut.y\n            ) {\n                // If opacity and/or translate will change\n\n                result = true;\n            } else if (self.config.animation.animateResizeTargets) {\n                // Check if width, height or margins will change\n\n                result = (\n                    posIn.width !== posOut.width ||\n                    posIn.height !== posOut.height ||\n                    posIn.marginRight !== posOut.marginRight ||\n                    posIn.marginTop !== posOut.marginTop\n                );\n            } else {\n                result = false;\n            }\n\n            return self.callFilters('resultWillTransition', result, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        checkProgress: function(operation) {\n            var self = this;\n\n            self.targetsDone++;\n\n            if (self.targetsBound === self.targetsDone) {\n                self.cleanUp(operation);\n            }\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Operation}     operation\n         * @return  {void}\n         */\n\n        cleanUp: function(operation) {\n            var self                = this,\n                target              = null,\n                whitespaceBefore    = null,\n                whitespaceAfter     = null,\n                nextInQueue         = null,\n                i                   = -1;\n\n            self.callActions('beforeCleanUp', arguments);\n\n            self.targetsMoved          =\n                self.targetsImmovable  =\n                self.targetsBound      =\n                self.targetsDone       = 0;\n\n            for (i = 0; target = operation.show[i]; i++) {\n                target.cleanUp();\n\n                target.show();\n            }\n\n            for (i = 0; target = operation.toHide[i]; i++) {\n                target.cleanUp();\n\n                target.hide();\n            }\n\n            if (operation.willSort) {\n                self.printSort(false, operation);\n            }\n\n            // Remove any styles applied to the parent container\n\n            self.dom.parent.style[mixitup.features.transitionProp]             =\n                self.dom.parent.style.height                                   =\n                self.dom.parent.style.width                                    =\n                self.dom.parent.style.overflow                                 =\n                self.dom.parent.style[mixitup.features.perspectiveProp]        =\n                self.dom.parent.style[mixitup.features.perspectiveOriginProp]  = '';\n\n            if (operation.willChangeLayout) {\n                h.removeClass(self.dom.container, operation.startContainerClassName);\n                h.addClass(self.dom.container, operation.newContainerClassName);\n            }\n\n            if (operation.toRemove.length) {\n                for (i = 0; target = self.targets[i]; i++) {\n                    if (operation.toRemove.indexOf(target) > -1) {\n                        if (\n                            (whitespaceBefore = target.dom.el.previousSibling) && whitespaceBefore.nodeName === '#text' &&\n                            (whitespaceAfter = target.dom.el.nextSibling) && whitespaceAfter.nodeName === '#text'\n                        ) {\n                            h.removeWhitespace(whitespaceBefore);\n                        }\n\n                        if (!operation.willSort) {\n                            // NB: Sorting will remove targets as a bi-product of `printSort()`\n\n                            self.dom.parent.removeChild(target.dom.el);\n                        }\n\n                        self.targets.splice(i, 1);\n\n                        target.isInDom = false;\n\n                        i--;\n                    }\n                }\n\n                // Since targets have been removed, the original order must be updated\n\n                self.origOrder = self.targets;\n            }\n\n            if (operation.willSort) {\n                self.targets = operation.newOrder;\n            }\n\n            self.state = operation.newState;\n            self.lastOperation = operation;\n\n            self.dom.targets = self.state.targets;\n\n            // mixEnd\n\n            mixitup.events.fire('mixEnd', self.dom.container, {\n                state: self.state,\n                instance: self\n            }, self.dom.document);\n\n            if (typeof self.config.callbacks.onMixEnd === 'function') {\n                self.config.callbacks.onMixEnd.call(self.dom.container, self.state, self);\n            }\n\n            if (operation.hasFailed) {\n                // mixFail\n\n                mixitup.events.fire('mixFail', self.dom.container, {\n                    state: self.state,\n                    instance: self\n                }, self.dom.document);\n\n                if (typeof self.config.callbacks.onMixFail === 'function') {\n                    self.config.callbacks.onMixFail.call(self.dom.container, self.state, self);\n                }\n\n                h.addClass(self.dom.container, h.getClassname(self.config.classNames, 'container', self.config.classNames.modifierFailed));\n            }\n\n            // User-defined callback function\n\n            if (typeof self.userCallback === 'function') {\n                self.userCallback.call(self.dom.container, self.state, self);\n            }\n\n            if (typeof self.userDeferred.resolve === 'function') {\n                self.userDeferred.resolve(self.state);\n            }\n\n            self.userCallback  = null;\n            self.userDeferred  = null;\n            self.lastClicked   = null;\n            self.isToggling    = false;\n            self.isBusy        = false;\n\n            if (self.queue.length) {\n                self.callActions('beforeReadQueueCleanUp', arguments);\n\n                nextInQueue = self.queue.shift();\n\n                // Update non-public API properties stored in queue\n\n                self.userDeferred  = nextInQueue.deferred;\n                self.isToggling    = nextInQueue.isToggling;\n                self.lastClicked   = nextInQueue.triggerElement;\n\n                if (nextInQueue.instruction.command instanceof mixitup.CommandMultimix) {\n                    self.multimix.apply(self, nextInQueue.args);\n                } else {\n                    self.dataset.apply(self, nextInQueue.args);\n                }\n            }\n\n            self.callActions('afterCleanUp', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Array<*>}  args\n         * @return  {mixitup.UserInstruction}\n         */\n\n        parseMultimixArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                arg         = null,\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandMultimix();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (arg === null) continue;\n\n                if (typeof arg === 'object') {\n                    h.extend(instruction.command, arg);\n                } else if (typeof arg === 'boolean') {\n                    instruction.animate = arg;\n                } else if (typeof arg === 'function') {\n                    instruction.callback = arg;\n                }\n            }\n\n            // Coerce arbitrary command arguments into typed command objects\n\n            if (instruction.command.insert && !(instruction.command.insert instanceof mixitup.CommandInsert)) {\n                instruction.command.insert = self.parseInsertArgs([instruction.command.insert]).command;\n            }\n\n            if (instruction.command.remove && !(instruction.command.remove instanceof mixitup.CommandRemove)) {\n                instruction.command.remove = self.parseRemoveArgs([instruction.command.remove]).command;\n            }\n\n            if (instruction.command.filter && !(instruction.command.filter instanceof mixitup.CommandFilter)) {\n                instruction.command.filter = self.parseFilterArgs([instruction.command.filter]).command;\n            }\n\n            if (instruction.command.sort && !(instruction.command.sort instanceof mixitup.CommandSort)) {\n                instruction.command.sort = self.parseSortArgs([instruction.command.sort]).command;\n            }\n\n            if (instruction.command.changeLayout && !(instruction.command.changeLayout instanceof mixitup.CommandChangeLayout)) {\n                instruction.command.changeLayout = self.parseChangeLayoutArgs([instruction.command.changeLayout]).command;\n            }\n\n            instruction = self.callFilters('instructionParseMultimixArgs', instruction, arguments);\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Array<*>}  args\n         * @return  {mixitup.UserInstruction}\n         */\n\n        parseFilterArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                arg         = null,\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandFilter();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (typeof arg === 'string') {\n                    // Selector\n\n                    instruction.command.selector = arg;\n                } else if (arg === null) {\n                    instruction.command.collection = [];\n                } else if (typeof arg === 'object' && h.isElement(arg, self.dom.document)) {\n                    // Single element\n\n                    instruction.command.collection = [arg];\n                } else if (typeof arg === 'object' && typeof arg.length !== 'undefined') {\n                    // Multiple elements in array, NodeList or jQuery collection\n\n                    instruction.command.collection = h.arrayFromList(arg);\n                } else if (typeof arg === 'object') {\n                    // Filter command\n\n                    h.extend(instruction.command, arg);\n                } else if (typeof arg === 'boolean') {\n                    instruction.animate = arg;\n                } else if (typeof arg === 'function') {\n                    instruction.callback = arg;\n                }\n            }\n\n            if (instruction.command.selector && instruction.command.collection) {\n                throw new Error(mixitup.messages.errorFilterInvalidArguments());\n            }\n\n            instruction = self.callFilters('instructionParseFilterArgs', instruction, arguments);\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        parseSortArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                arg         = null,\n                sortString  = '',\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandSort();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (arg === null) continue;\n\n                switch (typeof arg) {\n                    case 'string':\n                        // Sort string\n\n                        sortString = arg;\n\n                        break;\n                    case 'object':\n                        // Array of element references\n\n                        if (arg.length) {\n                            instruction.command.collection = h.arrayFromList(arg);\n                        }\n\n                        break;\n                    case 'boolean':\n                        instruction.animate = arg;\n\n                        break;\n                    case 'function':\n                        instruction.callback = arg;\n\n                        break;\n                }\n            }\n\n            if (sortString) {\n                instruction.command = self.parseSortString(sortString, instruction.command);\n            }\n\n            instruction = self.callFilters('instructionParseSortArgs', instruction, arguments);\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {Array<*>}  args\n         * @return  {mixitup.UserInstruction}\n         */\n\n        parseInsertArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                arg         = null,\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandInsert();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (arg === null) continue;\n\n                if (typeof arg === 'number') {\n                    // Insert index\n\n                    instruction.command.index = arg;\n                } else if (typeof arg === 'string' && ['before', 'after'].indexOf(arg) > -1) {\n                    // 'before'/'after'\n\n                    instruction.command.position = arg;\n                } else if (typeof arg === 'string') {\n                    // Markup\n\n                    instruction.command.collection =\n                        h.arrayFromList(h.createElement(arg).childNodes);\n                } else if (typeof arg === 'object' && h.isElement(arg, self.dom.document)) {\n                    // Single element\n\n                    !instruction.command.collection.length ?\n                        (instruction.command.collection = [arg]) :\n                        (instruction.command.sibling = arg);\n                } else if (typeof arg === 'object' && arg.length) {\n                    // Multiple elements in array or jQuery collection\n\n                    !instruction.command.collection.length ?\n                        (instruction.command.collection = arg) :\n                        instruction.command.sibling = arg[0];\n                } else if (typeof arg === 'object' && arg.childNodes && arg.childNodes.length) {\n                    // Document fragment\n\n                    !instruction.command.collection.length ?\n                        instruction.command.collection = h.arrayFromList(arg.childNodes) :\n                        instruction.command.sibling = arg.childNodes[0];\n                } else if (typeof arg === 'object') {\n                    // Insert command\n\n                    h.extend(instruction.command, arg);\n                } else if (typeof arg === 'boolean') {\n                    instruction.animate = arg;\n                } else if (typeof arg === 'function') {\n                    instruction.callback = arg;\n                }\n            }\n\n            if (instruction.command.index && instruction.command.sibling) {\n                throw new Error(mixitup.messages.errorInsertInvalidArguments());\n            }\n\n            if (!instruction.command.collection.length && self.config.debug.showWarnings) {\n                console.warn(mixitup.messages.warningInsertNoElements());\n            }\n\n            instruction = self.callFilters('instructionParseInsertArgs', instruction, arguments);\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Array<*>}  args\n         * @return  {mixitup.UserInstruction}\n         */\n\n        parseRemoveArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                target      = null,\n                arg         = null,\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandRemove();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (arg === null) continue;\n\n                switch (typeof arg) {\n                    case 'number':\n                        if (self.targets[arg]) {\n                            instruction.command.targets[0] = self.targets[arg];\n                        }\n\n                        break;\n                    case 'string':\n                        instruction.command.collection = h.arrayFromList(self.dom.parent.querySelectorAll(arg));\n\n                        break;\n                    case 'object':\n                        if (arg && arg.length) {\n                            instruction.command.collection = arg;\n                        } else if (h.isElement(arg, self.dom.document)) {\n                            instruction.command.collection = [arg];\n                        } else {\n                            // Remove command\n\n                            h.extend(instruction.command, arg);\n                        }\n\n                        break;\n                    case 'boolean':\n                        instruction.animate = arg;\n\n                        break;\n                    case 'function':\n                        instruction.callback = arg;\n\n                        break;\n                }\n            }\n\n            if (instruction.command.collection.length) {\n                for (i = 0; target = self.targets[i]; i++) {\n                    if (instruction.command.collection.indexOf(target.dom.el) > -1) {\n                        instruction.command.targets.push(target);\n                    }\n                }\n            }\n\n            if (!instruction.command.targets.length && self.config.debug.showWarnings) {\n                console.warn(mixitup.messages.warningRemoveNoElements());\n            }\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Array<*>}  args\n         * @return  {mixitup.UserInstruction}\n         */\n\n        parseDatasetArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                arg         = null,\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandDataset();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (arg === null) continue;\n\n                switch (typeof arg) {\n                    case 'object':\n                        if (Array.isArray(arg) || typeof arg.length === 'number') {\n                            instruction.command.dataset = arg;\n                        } else {\n                            // Change layout command\n\n                            h.extend(instruction.command, arg);\n                        }\n\n                        break;\n                    case 'boolean':\n                        instruction.animate = arg;\n\n                        break;\n                    case 'function':\n                        instruction.callback = arg;\n\n                        break;\n                }\n            }\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Array<*>}  args\n         * @return  {mixitup.UserInstruction}\n         */\n\n        parseChangeLayoutArgs: function(args) {\n            var self        = this,\n                instruction = new mixitup.UserInstruction(),\n                arg         = null,\n                i           = -1;\n\n            instruction.animate = self.config.animation.enable;\n            instruction.command = new mixitup.CommandChangeLayout();\n\n            for (i = 0; i < args.length; i++) {\n                arg = args[i];\n\n                if (arg === null) continue;\n\n                switch (typeof arg) {\n                    case 'string':\n                        instruction.command.containerClassName = arg;\n\n                        break;\n                    case 'object':\n                        // Change layout command\n\n                        h.extend(instruction.command, arg);\n\n                        break;\n                    case 'boolean':\n                        instruction.animate = arg;\n\n                        break;\n                    case 'function':\n                        instruction.callback = arg;\n\n                        break;\n                }\n            }\n\n            h.freeze(instruction);\n\n            return instruction;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since       3.0.0\n         * @param       {mixitup.QueueItem}         queueItem\n         * @return      {Promise.<mixitup.State>}\n         */\n\n        queueMix: function(queueItem) {\n            var self            = this,\n                deferred        = null,\n                toggleSelector  = '';\n\n            self.callActions('beforeQueueMix', arguments);\n\n            deferred = h.defer(mixitup.libraries);\n\n            if (self.config.animation.queue && self.queue.length < self.config.animation.queueLimit) {\n                queueItem.deferred = deferred;\n\n                self.queue.push(queueItem);\n\n                // Keep controls in sync with user interactions. Mixer will catch up as it drains the queue.\n\n                if (self.config.controls.enable) {\n                    if (self.isToggling) {\n                        self.buildToggleArray(queueItem.instruction.command);\n\n                        toggleSelector = self.getToggleSelector();\n\n                        self.updateControls({\n                            filter: {\n                                selector: toggleSelector\n                            }\n                        });\n                    } else {\n                        self.updateControls(queueItem.instruction.command);\n                    }\n                }\n            } else {\n                if (self.config.debug.showWarnings) {\n                    console.warn(mixitup.messages.warningMultimixInstanceQueueFull());\n                }\n\n                deferred.resolve(self.state);\n\n                mixitup.events.fire('mixBusy', self.dom.container, {\n                    state: self.state,\n                    instance: self\n                }, self.dom.document);\n\n                if (typeof self.config.callbacks.onMixBusy === 'function') {\n                    self.config.callbacks.onMixBusy.call(self.dom.container, self.state, self);\n                }\n            }\n\n            return self.callFilters('promiseQueueMix', deferred.promise, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Array.<object>}    newDataset\n         * @return  {Operation}\n         */\n\n        getDataOperation: function(newDataset) {\n            var self                = this,\n                operation           = new mixitup.Operation(),\n                startDataset        = [];\n\n            operation = self.callFilters('operationUnmappedGetDataOperation', operation, arguments);\n\n            if (self.dom.targets.length && !(startDataset = (self.state.activeDataset || [])).length) {\n                throw new Error(mixitup.messages.errorDatasetNotSet());\n            }\n\n            operation.id            = h.randomHex();\n            operation.startState    = self.state;\n            operation.startDataset  = startDataset;\n            operation.newDataset    = newDataset.slice();\n\n            self.diffDatasets(operation);\n\n            operation.startOrder = self.targets;\n            operation.newOrder = operation.show;\n\n            if (self.config.animation.enable) {\n                self.getStartMixData(operation);\n                self.setInter(operation);\n\n                operation.docState = h.getDocumentState(self.dom.document);\n\n                self.getInterMixData(operation);\n                self.setFinal(operation);\n                self.getFinalMixData(operation);\n\n                self.parseEffects();\n\n                operation.hasEffect = self.hasEffect();\n\n                self.getTweenData(operation);\n            }\n\n            self.targets = operation.show.slice();\n\n            operation.newState = self.buildState(operation);\n\n            // NB: Targets to be removed must be included in `self.targets` for removal during clean up,\n            // but are added after state is built so that state is accurate\n\n            Array.prototype.push.apply(self.targets, operation.toRemove);\n\n            operation = self.callFilters('operationMappedGetDataOperation', operation, arguments);\n\n            return operation;\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {mixitup.Operation} operation\n         * @return  {void}\n         */\n\n        diffDatasets: function(operation) {\n            var self                = this,\n                persistantStartIds  = [],\n                persistantNewIds    = [],\n                insertedTargets     = [],\n                data                = null,\n                target              = null,\n                el                  = null,\n                frag                = null,\n                nextEl              = null,\n                uids                = {},\n                id                  = '',\n                i                   = -1;\n\n            self.callActions('beforeDiffDatasets', arguments);\n\n            for (i = 0; data = operation.newDataset[i]; i++) {\n                if (typeof (id = data[self.config.data.uidKey]) === 'undefined' || id.toString().length < 1) {\n                    throw new TypeError(mixitup.messages.errorDatasetInvalidUidKey({\n                        uidKey: self.config.data.uidKey\n                    }));\n                }\n\n                if (!uids[id]) {\n                    uids[id] = true;\n                } else {\n                    throw new Error(mixitup.messages.errorDatasetDuplicateUid({\n                        uid: id\n                    }));\n                }\n\n                if ((target = self.cache[id]) instanceof mixitup.Target) {\n                    // Already in cache\n\n                    if (self.config.data.dirtyCheck && !h.deepEquals(data, target.data)) {\n                        // change detected\n\n                        el = target.render(data);\n\n                        target.data = data;\n\n                        if (el !== target.dom.el) {\n                            // Update target element reference\n\n                            if (target.isInDom) {\n                                target.unbindEvents();\n\n                                self.dom.parent.replaceChild(el, target.dom.el);\n                            }\n\n                            if (!target.isShown) {\n                                el.style.display = 'none';\n                            }\n\n                            target.dom.el = el;\n\n                            if (target.isInDom) {\n                                target.bindEvents();\n                            }\n                        }\n                    }\n\n                    el = target.dom.el;\n                } else {\n                    // New target\n\n                    target = new mixitup.Target();\n\n                    target.init(null, self, data);\n\n                    target.hide();\n                }\n\n                if (!target.isInDom) {\n                    // Adding to DOM\n\n                    if (!frag) {\n                        // Open frag\n\n                        frag = self.dom.document.createDocumentFragment();\n                    }\n\n                    if (frag.lastElementChild) {\n                        frag.appendChild(self.dom.document.createTextNode(' '));\n                    }\n\n                    frag.appendChild(target.dom.el);\n\n                    target.isInDom = true;\n\n                    target.unbindEvents();\n                    target.bindEvents();\n                    target.hide();\n\n                    operation.toShow.push(target);\n\n                    insertedTargets.push(target);\n                } else {\n                    // Already in DOM\n\n                    nextEl = target.dom.el.nextElementSibling;\n\n                    persistantNewIds.push(id);\n\n                    if (frag) {\n                        // Close and insert previously opened frag\n\n                        if (frag.lastElementChild) {\n                            frag.appendChild(self.dom.document.createTextNode(' '));\n                        }\n\n                        self.insertDatasetFrag(frag, target.dom.el, insertedTargets);\n\n                        frag = null;\n                    }\n                }\n\n                operation.show.push(target);\n            }\n\n            if (frag) {\n                // Unclosed frag remaining\n\n                nextEl = nextEl || self.config.layout.siblingAfter;\n\n                if (nextEl) {\n                    frag.appendChild(self.dom.document.createTextNode(' '));\n                }\n\n                self.insertDatasetFrag(frag, nextEl, insertedTargets);\n            }\n\n            for (i = 0; data = operation.startDataset[i]; i++) {\n                id = data[self.config.data.uidKey];\n\n                target = self.cache[id];\n\n                if (operation.show.indexOf(target) < 0) {\n                    // Previously shown but now absent\n\n                    operation.hide.push(target);\n                    operation.toHide.push(target);\n                    operation.toRemove.push(target);\n                } else {\n                    persistantStartIds.push(id);\n                }\n            }\n\n            if (!h.isEqualArray(persistantStartIds, persistantNewIds)) {\n                operation.willSort = true;\n            }\n\n            self.callActions('afterDiffDatasets', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.1.5\n         * @param   {DocumentFragment}          frag\n         * @param   {(HTMLElement|null)}        nextEl\n         * @param   {Array.<mixitup.Target>}    targets\n         * @return  {void}\n         */\n\n        insertDatasetFrag: function(frag, nextEl, targets) {\n            var self = this;\n            var insertAt = nextEl ? h.arrayFromList(self.dom.parent.children).indexOf(nextEl) : self.targets.length;\n\n            self.dom.parent.insertBefore(frag, nextEl);\n\n            while (targets.length) {\n                self.targets.splice(insertAt, 0, targets.shift());\n\n                insertAt++;\n            }\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {mixitup.CommandSort} sortCommandA\n         * @param   {mixitup.CommandSort} sortCommandB\n         * @return  {boolean}\n         */\n\n        willSort: function(sortCommandA, sortCommandB) {\n            var self    = this,\n                result  = false;\n\n            if (\n                self.config.behavior.liveSort ||\n                sortCommandA.order       === 'random' ||\n                sortCommandA.attribute   !== sortCommandB.attribute ||\n                sortCommandA.order       !== sortCommandB.order ||\n                sortCommandA.collection  !== sortCommandB.collection ||\n                (sortCommandA.next === null && sortCommandB.next) ||\n                (sortCommandA.next && sortCommandB.next === null)\n            ) {\n                result = true;\n            } else if (sortCommandA.next && sortCommandB.next) {\n                result = self.willSort(sortCommandA.next, sortCommandB.next);\n            } else {\n                result = false;\n            }\n\n            return self.callFilters('resultWillSort', result, arguments);\n        },\n\n        /**\n         * A shorthand method for `.filter('all')`. Shows all targets in the container.\n         *\n         * @example\n         *\n         * .show()\n         *\n         * @example <caption>Example: Showing all targets</caption>\n         *\n         * mixer.show()\n         *     .then(function(state) {\n         *         console.log(state.totalShow === state.totalTargets); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @return      {Promise.<mixitup.State>}\n         */\n\n        show: function() {\n            var self = this;\n\n            return self.filter('all');\n        },\n\n        /**\n         * A shorthand method for `.filter('none')`. Hides all targets in the container.\n         *\n         * @example\n         *\n         * .hide()\n         *\n         * @example <caption>Example: Hiding all targets</caption>\n         *\n         * mixer.hide()\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 0); // true\n         *         console.log(state.totalHide === state.totalTargets); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @return      {Promise.<mixitup.State>}\n         */\n\n        hide: function() {\n            var self = this;\n\n            return self.filter('none');\n        },\n\n        /**\n         * Returns a boolean indicating whether or not a MixItUp operation is\n         * currently in progress.\n         *\n         * @example\n         *\n         * .isMixing()\n         *\n         * @example <caption>Example: Checking the status of a mixer</caption>\n         *\n         * mixer.sort('random', function() {\n         *     console.log(mixer.isMixing()) // false\n         * });\n         *\n         * console.log(mixer.isMixing()) // true\n         *\n         * @public\n         * @instance\n         * @since   2.0.0\n         * @return  {boolean}\n         */\n\n        isMixing: function() {\n            var self = this;\n\n            return self.isBusy;\n        },\n\n        /**\n         * Filters all targets in the container by a provided selector string, or the values `'all'`\n         * or `'none'`. Only targets matching the selector will be shown.\n         *\n         * @example\n         *\n         * .filter(selector [, animate] [, callback])\n         *\n         * @example <caption>Example 1: Filtering targets by a class selector</caption>\n         *\n         * mixer.filter('.category-a')\n         *     .then(function(state) {\n         *         console.log(state.totalShow === containerEl.querySelectorAll('.category-a').length); // true\n         *     });\n         *\n         * @example <caption>Example 2: Filtering targets by an attribute selector</caption>\n         *\n         * mixer.filter('[data-category~=\"a\"]')\n         *     .then(function(state) {\n         *         console.log(state.totalShow === containerEl.querySelectorAll('[data-category~=\"a\"]').length); // true\n         *     });\n         *\n         * @example <caption>Example 3: Filtering targets by a compound selector</caption>\n         *\n         * // Show only those targets with the classes 'category-a' AND 'category-b'\n         *\n         * mixer.filter('.category-a.category-c')\n         *     .then(function(state) {\n         *         console.log(state.totalShow === containerEl.querySelectorAll('.category-a.category-c').length); // true\n         *     });\n         *\n         * @example <caption>Example 4: Filtering via an element collection</caption>\n         *\n         * var collection = Array.from(container.querySelectorAll('.mix'));\n         *\n         * console.log(collection.length); // 34\n         *\n         * // Filter the collection manually using Array.prototype.filter\n         *\n         * var filtered = collection.filter(function(target) {\n         *    return parseInt(target.getAttribute('data-price')) > 10;\n         * });\n         *\n         * console.log(filtered.length); // 22\n         *\n         * // Pass the filtered collection to MixItUp\n         *\n         * mixer.filter(filtered)\n         *    .then(function(state) {\n         *        console.log(state.activeFilter.collection.length === 22); // true\n         *    });\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @param       {(string|HTMLElement|Array.<HTMLElement>)} selector\n         *      Any valid CSS selector (i.e. `'.category-a'`), or the values `'all'` or `'none'`. The filter method also accepts a reference to single target element or a collection of target elements to show.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        filter: function() {\n            var self        = this,\n                instruction = self.parseFilterArgs(arguments);\n\n            return self.multimix({\n                filter: instruction.command\n            }, instruction.animate, instruction.callback);\n        },\n\n        /**\n         * Adds an additional selector to the currently active filter selector, concatenating\n         * as per the logic defined in `controls.toggleLogic`.\n         *\n         * @example\n         *\n         * .toggleOn(selector [, animate] [, callback])\n         *\n         * @example <caption>Example: Toggling on a filter selector</caption>\n         *\n         * console.log(mixer.getState().activeFilter.selector); // '.category-a'\n         *\n         * mixer.toggleOn('.category-b')\n         *     .then(function(state) {\n         *         console.log(state.activeFilter.selector); // '.category-a, .category-b'\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {string}    selector\n         *      Any valid CSS selector (i.e. `'.category-a'`)\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        toggleOn: function() {\n            var self            = this,\n                instruction     = self.parseFilterArgs(arguments),\n                selector        = instruction.command.selector,\n                toggleSelector  = '';\n\n            self.isToggling = true;\n\n            if (self.toggleArray.indexOf(selector) < 0) {\n                self.toggleArray.push(selector);\n            }\n\n            toggleSelector = self.getToggleSelector();\n\n            return self.multimix({\n                filter: toggleSelector\n            }, instruction.animate, instruction.callback);\n        },\n\n        /**\n         * Removes a selector from the active filter selector.\n         *\n         * @example\n         *\n         * .toggleOff(selector [, animate] [, callback])\n         *\n         * @example <caption>Example: Toggling off a filter selector</caption>\n         *\n         * console.log(mixer.getState().activeFilter.selector); // '.category-a, .category-b'\n         *\n         * mixer.toggleOff('.category-b')\n         *     .then(function(state) {\n         *         console.log(state.activeFilter.selector); // '.category-a'\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {string}    selector\n         *      Any valid CSS selector (i.e. `'.category-a'`)\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        toggleOff: function() {\n            var self            = this,\n                instruction     = self.parseFilterArgs(arguments),\n                selector        = instruction.command.selector,\n                selectorIndex   = self.toggleArray.indexOf(selector),\n                toggleSelector  = '';\n\n            self.isToggling = true;\n\n            if (selectorIndex > -1) {\n                self.toggleArray.splice(selectorIndex, 1);\n            }\n\n            toggleSelector = self.getToggleSelector();\n\n            return self.multimix({\n                filter: toggleSelector\n            }, instruction.animate, instruction.callback);\n        },\n\n        /**\n         * Sorts all targets in the container according to a provided sort string.\n         *\n         * @example\n         *\n         * .sort(sortString [, animate] [, callback])\n         *\n         * @example <caption>Example 1: Sorting by the default DOM order</caption>\n         *\n         * // Reverse the default order of the targets\n         *\n         * mixer.sort('default:desc')\n         *     .then(function(state) {\n         *         console.log(state.activeSort.attribute === 'default'); // true\n         *         console.log(state.activeSort.order === 'desc'); // true\n         *     });\n         *\n         * @example <caption>Example 2: Sorting by a custom data-attribute</caption>\n         *\n         * // Sort the targets by the value of a `data-published-date` attribute\n         *\n         * mixer.sort('published-date:asc')\n         *     .then(function(state) {\n         *         console.log(state.activeSort.attribute === 'published-date'); // true\n         *         console.log(state.activeSort.order === 'asc'); // true\n         *     });\n         *\n         * @example <caption>Example 3: Sorting by multiple attributes</caption>\n         *\n         * // Sort the targets by the value of a `data-published-date` attribute, then by `data-title`\n         *\n         * mixer.sort('published-date:desc data-title:asc')\n         *     .then(function(state) {\n         *         console.log(state.activeSort.attribute === 'published-date'); // true\n         *         console.log(state.activeSort.order === 'desc'); // true\n         *\n         *         console.log(state.activeSort.next.attribute === 'title'); // true\n         *         console.log(state.activeSort.next.order === 'asc'); // true\n         *     });\n         *\n         * @example <caption>Example 4: Sorting by random</caption>\n         *\n         * mixer.sort('random')\n         *     .then(function(state) {\n         *         console.log(state.activeSort.order === 'random') // true\n         *     });\n         *\n         * @example <caption>Example 5: Sorting via an element collection</caption>\n         *\n         * var collection = Array.from(container.querySelectorAll('.mix'));\n         *\n         * // Swap the position of two elements in the collection:\n         *\n         * var temp = collection[1];\n         *\n         * collection[1] = collection[0];\n         * collection[0] = temp;\n         *\n         * // Pass the sorted collection to MixItUp\n         *\n         * mixer.sort(collection)\n         *     .then(function(state) {\n         *         console.log(state.targets[0] === collection[0]); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @param       {(string|Array.<HTMLElement>)}    sortString\n         *      A valid sort string (e.g. `'default'`, `'published-date:asc'`, or `'random'`). The sort method also accepts an array of all target elements in a user-defined order.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        sort: function() {\n            var self        = this,\n                instruction = self.parseSortArgs(arguments);\n\n            return self.multimix({\n                sort: instruction.command\n            }, instruction.animate, instruction.callback);\n        },\n\n        /**\n         * Changes the layout of the container by adding, removing or updating a\n         * layout-specific class name. If `animation.animateResizetargets` is\n         * enabled, MixItUp will attempt to gracefully animate the width, height,\n         * and position of targets between layout states.\n         *\n         * @example\n         *\n         * .changeLayout(containerClassName [, animate] [, callback])\n         *\n         * @example <caption>Example 1: Adding a new class name to the container</caption>\n         *\n         * mixer.changeLayout('container-list')\n         *      .then(function(state) {\n         *          console.log(state.activeContainerClass === 'container-list'); // true\n         *      });\n         *\n         * @example <caption>Example 2: Removing a previously added class name from the container</caption>\n         *\n         * mixer.changeLayout('')\n         *      .then(function(state) {\n         *          console.log(state.activeContainerClass === ''); // true\n         *      });\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @param       {string}    containerClassName\n         *      A layout-specific class name to add to the container.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        changeLayout: function() {\n            var self        = this,\n                instruction = self.parseChangeLayoutArgs(arguments);\n\n            return self.multimix({\n                changeLayout: instruction.command\n            }, instruction.animate, instruction.callback);\n        },\n\n        /**\n         * Updates the contents and order of the container to reflect the provided dataset,\n         * if the dataset API is in use.\n         *\n         * The dataset API is designed for use in API-driven JavaScript applications, and\n         * can be used instead of DOM-based methods such as `.filter()`, `.sort()`,\n         * `.insert()`, etc. When used, insertion, removal, sorting and pagination can be\n         * achieved purely via changes to your data model, without the uglyness of having\n         * to interact with or query the DOM directly.\n         *\n         * @example\n         *\n         * .dataset(dataset [, animate] [, callback])\n         *\n         * @example <caption>Example 1: Rendering a dataset</caption>\n         *\n         * var myDataset = [\n         *     {id: 1, ...},\n         *     {id: 2, ...},\n         *     {id: 3, ...}\n         * ];\n         *\n         * mixer.dataset(myDataset)\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 3); // true\n         *     });\n         *\n         * @example <caption>Example 2: Sorting a dataset</caption>\n         *\n         * // Create a new dataset in reverse order\n         *\n         * var newDataset = myDataset.slice().reverse();\n         *\n         * mixer.dataset(newDataset)\n         *     .then(function(state) {\n         *         console.log(state.activeDataset[0] === myDataset[2]); // true\n         *     });\n         *\n         * @example <caption>Example 3: Removing an item from the dataset</caption>\n         *\n         * console.log(myDataset.length); // 3\n         *\n         * // Create a new dataset with the last item removed.\n         *\n         * var newDataset = myDataset.slice().pop();\n         *\n         * mixer.dataset(newDataset)\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 2); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {Array.<object>}    dataset\n         *      An array of objects, each one representing the underlying data model of a target to be rendered.\n         * @param       {boolean}           [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}          [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        dataset: function() {\n            var self        = this,\n                instruction = self.parseDatasetArgs(arguments),\n                operation   = null,\n                queueItem   = null,\n                animate     = false;\n\n            self.callActions('beforeDataset', arguments);\n\n            if (!self.isBusy) {\n                if (instruction.callback) self.userCallback = instruction.callback;\n\n                animate = (instruction.animate ^ self.config.animation.enable) ? instruction.animate : self.config.animation.enable;\n\n                operation = self.getDataOperation(instruction.command.dataset);\n\n                return self.goMix(animate, operation);\n            } else {\n                queueItem = new mixitup.QueueItem();\n\n                queueItem.args          = arguments;\n                queueItem.instruction   = instruction;\n\n                return self.queueMix(queueItem);\n            }\n        },\n\n        /**\n         * Performs simultaneous `filter`, `sort`, `insert`, `remove` and `changeLayout`\n         * operations as requested.\n         *\n         * @example\n         *\n         * .multimix(multimixCommand [, animate] [, callback])\n         *\n         * @example <caption>Example 1: Performing simultaneous filtering and sorting</caption>\n         *\n         * mixer.multimix({\n         *     filter: '.category-b',\n         *     sort: 'published-date:desc'\n         * })\n         *     .then(function(state) {\n         *         console.log(state.activeFilter.selector === '.category-b'); // true\n         *         console.log(state.activeSort.attribute === 'published-date'); // true\n         *     });\n         *\n         * @example <caption>Example 2: Performing simultaneous sorting, insertion, and removal</caption>\n         *\n         * console.log(mixer.getState().totalShow); // 6\n         *\n         * // NB: When inserting via `multimix()`, an object should be provided as the value\n         * // for the `insert` portion of the command, allowing for a collection of elements\n         * // and an insertion index to be specified.\n         *\n         * mixer.multimix({\n         *     sort: 'published-date:desc', // Sort the container, including any new elements\n         *     insert: {\n         *         collection: [newElementReferenceA, newElementReferenceB], // Add 2 new elements at index 5\n         *         index: 5\n         *     },\n         *     remove: existingElementReference // Remove 1 existing element\n         * })\n         *     .then(function(state) {\n         *         console.log(state.activeSort.attribute === 'published-date'); // true\n         *         console.log(state.totalShow === 7); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @param       {object}    multimixCommand\n         *      An object containing one or more things to do\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        multimix: function() {\n            var self        = this,\n                operation   = null,\n                animate     = false,\n                queueItem   = null,\n                instruction = self.parseMultimixArgs(arguments);\n\n            self.callActions('beforeMultimix', arguments);\n\n            if (!self.isBusy) {\n                operation = self.getOperation(instruction.command);\n\n                if (self.config.controls.enable) {\n                    // Update controls for API calls\n\n                    if (instruction.command.filter && !self.isToggling) {\n                        // As we are not toggling, reset the toggle array\n                        // so new filter overrides existing toggles\n\n                        self.toggleArray.length = 0;\n                        self.buildToggleArray(operation.command);\n                    }\n\n                    if (self.queue.length < 1) {\n                        self.updateControls(operation.command);\n                    }\n                }\n\n                if (instruction.callback) self.userCallback = instruction.callback;\n\n                // Always allow the instruction to override the instance setting\n\n                animate = (instruction.animate ^ self.config.animation.enable) ?\n                    instruction.animate :\n                    self.config.animation.enable;\n\n                self.callFilters('operationMultimix', operation, arguments);\n\n                return self.goMix(animate, operation);\n            } else {\n                queueItem = new mixitup.QueueItem();\n\n                queueItem.args           = arguments;\n                queueItem.instruction    = instruction;\n                queueItem.triggerElement = self.lastClicked;\n                queueItem.isToggling     = self.isToggling;\n\n                return self.queueMix(queueItem);\n            }\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {object}            multimixCommand\n         * @param   {boolean}           [isPreFetch]\n         *      An optional boolean indicating that the operation is being pre-fetched for execution at a later time.\n         * @return  {Operation|null}\n         */\n\n        getOperation: function(multimixCommand) {\n            var self                = this,\n                sortCommand         = multimixCommand.sort,\n                filterCommand       = multimixCommand.filter,\n                changeLayoutCommand = multimixCommand.changeLayout,\n                removeCommand       = multimixCommand.remove,\n                insertCommand       = multimixCommand.insert,\n                operation           = new mixitup.Operation();\n\n            operation = self.callFilters('operationUnmappedGetOperation', operation, arguments);\n\n            operation.id                = h.randomHex();\n            operation.command           = multimixCommand;\n            operation.startState        = self.state;\n            operation.triggerElement    = self.lastClicked;\n\n            if (self.isBusy) {\n                if (self.config.debug.showWarnings) {\n                    console.warn(mixitup.messages.warningGetOperationInstanceBusy());\n                }\n\n                return null;\n            }\n\n            if (insertCommand) {\n                self.insertTargets(insertCommand, operation);\n            }\n\n            if (removeCommand) {\n                operation.toRemove = removeCommand.targets;\n            }\n\n            operation.startSort = operation.newSort = operation.startState.activeSort;\n            operation.startOrder = operation.newOrder = self.targets;\n\n            if (sortCommand) {\n                operation.startSort = operation.startState.activeSort;\n                operation.newSort   = sortCommand;\n\n                operation.willSort = self.willSort(sortCommand, operation.startState.activeSort);\n\n                if (operation.willSort) {\n                    self.sortOperation(operation);\n                }\n            }\n\n            operation.startFilter = operation.startState.activeFilter;\n\n            if (filterCommand) {\n                operation.newFilter = filterCommand;\n            } else {\n                operation.newFilter = h.extend(new mixitup.CommandFilter(), operation.startFilter);\n            }\n\n            if (operation.newFilter.selector === 'all') {\n                operation.newFilter.selector = self.config.selectors.target;\n            } else if (operation.newFilter.selector === 'none') {\n                operation.newFilter.selector = '';\n            }\n\n            self.filterOperation(operation);\n\n            operation.startContainerClassName = operation.startState.activeContainerClassName;\n\n            if (changeLayoutCommand) {\n                operation.newContainerClassName = changeLayoutCommand.containerClassName;\n\n                if (operation.newContainerClassName !== operation.startContainerClassName) {\n                    operation.willChangeLayout = true;\n                }\n            } else {\n                operation.newContainerClassName = operation.startContainerClassName;\n            }\n\n            if (self.config.animation.enable) {\n                // Populate the operation's position data\n\n                self.getStartMixData(operation);\n                self.setInter(operation);\n\n                operation.docState = h.getDocumentState(self.dom.document);\n\n                self.getInterMixData(operation);\n                self.setFinal(operation);\n                self.getFinalMixData(operation);\n\n                self.parseEffects();\n\n                operation.hasEffect = self.hasEffect();\n\n                self.getTweenData(operation);\n            }\n\n            if (operation.willSort) {\n                self.targets = operation.newOrder;\n            }\n\n            operation.newState = self.buildState(operation);\n\n            return self.callFilters('operationMappedGetOperation', operation, arguments);\n        },\n\n        /**\n         * Renders a previously created operation at a specific point in its path, as\n         * determined by a multiplier between 0 and 1.\n         *\n         * @example\n         * .tween(operation, multiplier)\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {mixitup.Operation}     operation\n         *      An operation object created via the `getOperation` method\n         *\n         * @param   {Float}                 multiplier\n         *      Any number between 0 and 1 representing the percentage complete of the operation\n         * @return  {void}\n         */\n\n        tween: function(operation, multiplier) {\n            var target          = null,\n                posData         = null,\n                toHideIndex     = -1,\n                i               = -1;\n\n            multiplier = Math.min(multiplier, 1);\n            multiplier = Math.max(multiplier, 0);\n\n            for (i = 0; target = operation.show[i]; i++) {\n                posData = operation.showPosData[i];\n\n                target.applyTween(posData, multiplier);\n            }\n\n            for (i = 0; target = operation.hide[i]; i++) {\n                if (target.isShown) {\n                    target.hide();\n                }\n\n                if ((toHideIndex = operation.toHide.indexOf(target)) > -1) {\n                    posData = operation.toHidePosData[toHideIndex];\n\n                    if (!target.isShown) {\n                        target.show();\n                    }\n\n                    target.applyTween(posData, multiplier);\n                }\n            }\n        },\n\n        /**\n         * Inserts one or more new target elements into the container at a specified\n         * index.\n         *\n         * To be indexed as targets, new elements must match the `selectors.target`\n         * selector (`'.mix'` by default).\n         *\n         * @example\n         *\n         * .insert(newElements [, index] [, animate], [, callback])\n         *\n         * @example <caption>Example 1: Inserting a single element via reference</caption>\n         *\n         * console.log(mixer.getState().totalShow); // 0\n         *\n         * // Create a new element\n         *\n         * var newElement = document.createElement('div');\n         * newElement.classList.add('mix');\n         *\n         * mixer.insert(newElement)\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 1); // true\n         *     });\n         *\n         * @example <caption>Example 2: Inserting a single element via HTML string</caption>\n         *\n         * console.log(mixer.getState().totalShow); // 1\n         *\n         * // Create a new element via reference\n         *\n         * var newElementHtml = '&lt;div class=\"mix\"&gt;&lt;/div&gt;';\n         *\n         * // Create and insert the new element at index 1\n         *\n         * mixer.insert(newElementHtml, 1)\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 2); // true\n         *         console.log(state.show[1].outerHTML === newElementHtml); // true\n         *     });\n         *\n         * @example <caption>Example 3: Inserting multiple elements via reference</caption>\n         *\n         * console.log(mixer.getState().totalShow); // 2\n         *\n         * // Create an array of new elements to insert.\n         *\n         * var newElement1 = document.createElement('div');\n         * var newElement2 = document.createElement('div');\n         *\n         * newElement1.classList.add('mix');\n         * newElement2.classList.add('mix');\n         *\n         * var newElementsCollection = [newElement1, newElement2];\n         *\n         * // Insert the new elements starting at index 1\n         *\n         * mixer.insert(newElementsCollection, 1)\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 4); // true\n         *         console.log(state.show[1] === newElement1); // true\n         *         console.log(state.show[2] === newElement2); // true\n         *     });\n         *\n         * @example <caption>Example 4: Inserting a jQuery collection object containing one or more elements</caption>\n         *\n         * console.log(mixer.getState().totalShow); // 4\n         *\n         * var $newElement = $('&lt;div class=\"mix\"&gt;&lt;/div&gt;');\n         *\n         * // Insert the new elements starting at index 3\n         *\n         * mixer.insert($newElement, 3)\n         *     .then(function(state) {\n         *         console.log(state.totalShow === 5); // true\n         *         console.log(state.show[3] === $newElement[0]); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @param       {(HTMLElement|Array.<HTMLElement>|string)}    newElements\n         *      A reference to a single element to insert, an array-like collection of elements, or an HTML string representing a single element.\n         * @param       {number}    index=0\n         *      The index at which to insert the new element(s). `0` by default.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        insert: function() {\n            var self = this,\n                args = self.parseInsertArgs(arguments);\n\n            return self.multimix({\n                insert: args.command\n            }, args.animate, args.callback);\n        },\n\n        /**\n         * Inserts one or more new elements before a provided reference element.\n         *\n         * @example\n         *\n         * .insertBefore(newElements, referenceElement [, animate] [, callback])\n         *\n         * @example <caption>Example: Inserting a new element before a reference element</caption>\n         *\n         * // An existing reference element is chosen at index 2\n         *\n         * var referenceElement = mixer.getState().show[2];\n         *\n         * // Create a new element\n         *\n         * var newElement = document.createElement('div');\n         * newElement.classList.add('mix');\n         *\n         * mixer.insertBefore(newElement, referenceElement)\n         *     .then(function(state) {\n         *         // The new element is inserted into the container at index 2, before the reference element\n         *\n         *         console.log(state.show[2] === newElement); // true\n         *\n         *         // The reference element is now at index 3\n         *\n         *         console.log(state.show[3] === referenceElement); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {(HTMLElement|Array.<HTMLElement>|string)}    newElements\n         *      A reference to a single element to insert, an array-like collection of elements, or an HTML string representing a single element.\n         * @param       {HTMLElement}    referenceElement\n         *      A reference to an existing element in the container to insert new elements before.\n         *@param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        insertBefore: function() {\n            var self = this,\n                args = self.parseInsertArgs(arguments);\n\n            return self.insert(args.command.collection, 'before', args.command.sibling, args.animate, args.callback);\n        },\n\n        /**\n         * Inserts one or more new elements after a provided reference element.\n         *\n         * @example\n         *\n         * .insertAfter(newElements, referenceElement [, animate] [, callback])\n         *\n         * @example <caption>Example: Inserting a new element after a reference element</caption>\n         *\n         * // An existing reference element is chosen at index 2\n         *\n         * var referenceElement = mixer.getState().show[2];\n         *\n         * // Create a new element\n         *\n         * var newElement = document.createElement('div');\n         * newElement.classList.add('mix');\n         *\n         * mixer.insertAfter(newElement, referenceElement)\n         *     .then(function(state) {\n         *         // The new element is inserted into the container at index 3, after the reference element\n         *\n         *         console.log(state.show[3] === newElement); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {(HTMLElement|Array.<HTMLElement>|string)}    newElements\n         *      A reference to a single element to insert, an array-like collection of elements, or an HTML string representing a single element.\n         * @param       {HTMLElement}    referenceElement\n         *      A reference to an existing element in the container to insert new elements after.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        insertAfter: function() {\n            var self = this,\n                args = self.parseInsertArgs(arguments);\n\n            return self.insert(args.command.collection, 'after', args.command.sibling, args.animate, args.callback);\n        },\n\n        /**\n         * Inserts one or more new elements into the container before all existing targets.\n         *\n         * @example\n         *\n         * .prepend(newElements [,animate] [,callback])\n         *\n         * @example <caption>Example: Prepending a new element</caption>\n         *\n         * // Create a new element\n         *\n         * var newElement = document.createElement('div');\n         * newElement.classList.add('mix');\n         *\n         * // Insert the element into the container\n         *\n         * mixer.prepend(newElement)\n         *     .then(function(state) {\n         *         console.log(state.show[0] === newElement); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {(HTMLElement|Array.<HTMLElement>|string)}    newElements\n         *      A reference to a single element to insert, an array-like collection of elements, or an HTML string representing a single element.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        prepend: function() {\n            var self = this,\n                args = self.parseInsertArgs(arguments);\n\n            return self.insert(0, args.command.collection, args.animate, args.callback);\n        },\n\n        /**\n         * Inserts one or more new elements into the container after all existing targets.\n         *\n         * @example\n         *\n         * .append(newElements [,animate] [,callback])\n         *\n         * @example <caption>Example: Appending a new element</caption>\n         *\n         * // Create a new element\n         *\n         * var newElement = document.createElement('div');\n         * newElement.classList.add('mix');\n         *\n         * // Insert the element into the container\n         *\n         * mixer.append(newElement)\n         *     .then(function(state) {\n         *         console.log(state.show[state.show.length - 1] === newElement); // true\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {(HTMLElement|Array.<HTMLElement>|string)}    newElements\n         *      A reference to a single element to insert, an array-like collection of elements, or an HTML string representing a single element.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        append: function() {\n            var self = this,\n                args = self.parseInsertArgs(arguments);\n\n            return self.insert(self.state.totalTargets, args.command.collection, args.animate, args.callback);\n        },\n\n        /**\n         * Removes one or more existing target elements from the container.\n         *\n         * @example\n         *\n         * .remove(elements [, animate] [, callback])\n         *\n         * @example <caption>Example 1: Removing an element by reference</caption>\n         *\n         * var elementToRemove = containerEl.firstElementChild;\n         *\n         * mixer.remove(elementToRemove)\n         *      .then(function(state) {\n         *          console.log(state.targets.indexOf(elementToRemove) === -1); // true\n         *      });\n         *\n         * @example <caption>Example 2: Removing a collection of elements by reference</caption>\n         *\n         * var elementsToRemove = containerEl.querySelectorAll('.category-a');\n         *\n         * console.log(elementsToRemove.length) // 3\n         *\n         * mixer.remove(elementsToRemove)\n         *      .then(function() {\n         *          console.log(containerEl.querySelectorAll('.category-a').length); // 0\n         *      });\n         *\n         * @example <caption>Example 3: Removing one or more elements by selector</caption>\n         *\n         * mixer.remove('.category-a')\n         *      .then(function() {\n         *          console.log(containerEl.querySelectorAll('.category-a').length); // 0\n         *      });\n         *\n         * @example <caption>Example 4: Removing an element by index</caption>\n         *\n         * console.log(mixer.getState.totalShow); // 4\n         *\n         * // Remove the element at index 3\n         *\n         * mixer.remove(3)\n         *      .then(function(state) {\n         *          console.log(state.totalShow); // 3\n         *          console.log(state.show[3]); // undefined\n         *      });\n         *\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {(HTMLElement|Array.<HTMLElement>|string|number)}    elements\n         *      A reference to a single element to remove, an array-like collection of elements, a selector string, or the index of an element to remove.\n         * @param       {boolean}   [animate=true]\n         *      An optional boolean dictating whether the operation should animate, or occur syncronously with no animation. `true` by default.\n         * @param       {function}  [callback=null]\n         *      An optional callback function to be invoked after the operation has completed.\n         * @return      {Promise.<mixitup.State>}\n         *      A promise resolving with the current state object.\n         */\n\n        remove: function() {\n            var self = this,\n                args = self.parseRemoveArgs(arguments);\n\n            return self.multimix({\n                remove: args.command\n            }, args.animate, args.callback);\n        },\n\n        /**\n         * Retrieves the the value of any property or sub-object within the current\n         * mixitup configuration, or the whole configuration object.\n         *\n         * @example\n         *\n         * .getConfig([stringKey])\n         *\n         * @example <caption>Example 1: retrieve the entire configuration object</caption>\n         *\n         * var config = mixer.getConfig(); // Config { ... }\n         *\n         * @example <caption>Example 2: retrieve a named sub-object of configuration object</caption>\n         *\n         * var animation = mixer.getConfig('animation'); // ConfigAnimation { ... }\n         *\n         * @example <caption>Example 3: retrieve a value of configuration object via a dot-notation string key</caption>\n         *\n         * var effects = mixer.getConfig('animation.effects'); // 'fade scale'\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @param       {string}    [stringKey]    A \"dot-notation\" string key\n         * @return      {*}\n         */\n\n        getConfig: function(stringKey) {\n            var self    = this,\n                value   = null;\n\n            if (!stringKey) {\n                value = self.config;\n            } else {\n                value = h.getProperty(self.config, stringKey);\n            }\n\n            return self.callFilters('valueGetConfig', value, arguments);\n        },\n\n        /**\n         * Updates the configuration of the mixer, after it has been instantiated.\n         *\n         * See the Configuration Object documentation for a full list of avilable\n         * configuration options.\n         *\n         * @example\n         *\n         * .configure(config)\n         *\n         * @example <caption>Example 1: Updating animation options</caption>\n         *\n         * mixer.configure({\n         *     animation: {\n         *         effects: 'fade translateX(-100%)',\n         *         duration: 300\n         *     }\n         * });\n         *\n         * @example <caption>Example 2: Removing a callback after it has been set</caption>\n         *\n         * var mixer;\n         *\n         * function handleMixEndOnce() {\n         *     // Do something ..\n         *\n         *     // Then nullify the callback\n         *\n         *     mixer.configure({\n         *         callbacks: {\n         *             onMixEnd: null\n         *         }\n         *     });\n         * };\n         *\n         * // Instantiate a mixer with a callback defined\n         *\n         * mixer = mixitup(containerEl, {\n         *     callbacks: {\n         *         onMixEnd: handleMixEndOnce\n         *     }\n         * });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {object}    config\n         *      An object containing one of more configuration options.\n         * @return      {void}\n         */\n\n        configure: function(config) {\n            var self = this;\n\n            self.callActions('beforeConfigure', arguments);\n\n            h.extend(self.config, config, true, true);\n\n            self.callActions('afterConfigure', arguments);\n        },\n\n        /**\n         * Returns an object containing information about the current state of the\n         * mixer. See the State Object documentation for more information.\n         *\n         * NB: State objects are immutable and should therefore be regenerated\n         * after any operation.\n         *\n         * @example\n         *\n         * .getState();\n         *\n         * @example <caption>Example: Retrieving a state object</caption>\n         *\n         * var state = mixer.getState();\n         *\n         * console.log(state.totalShow + 'targets are currently shown');\n         *\n         * @public\n         * @instance\n         * @since       2.0.0\n         * @return      {mixitup.State} An object reflecting the current state of the mixer.\n         */\n\n        getState: function() {\n            var self    = this,\n                state   = null;\n\n            state = new mixitup.State();\n\n            h.extend(state, self.state);\n\n            h.freeze(state);\n\n            return self.callFilters('stateGetState', state, arguments);\n        },\n\n        /**\n         * Forces the re-indexing all targets within the container.\n         *\n         * This should only be used if some other piece of code in your application\n         * has manipulated the contents of your container, which should be avoided.\n         *\n         * If you need to add or remove target elements from the container, use\n         * the built-in `.insert()` or `.remove()` methods, and MixItUp will keep\n         * itself up to date.\n         *\n         * @example\n         *\n         * .forceRefresh()\n         *\n         * @example <caption>Example: Force refreshing the mixer after external DOM manipulation</caption>\n         *\n         * console.log(mixer.getState().totalShow); // 3\n         *\n         * // An element is removed from the container via some external DOM manipulation code:\n         *\n         * containerEl.removeChild(containerEl.firstElementChild);\n         *\n         * // The mixer does not know that the number of targets has changed:\n         *\n         * console.log(mixer.getState().totalShow); // 3\n         *\n         * mixer.forceRefresh();\n         *\n         * // After forceRefresh, the mixer is in sync again:\n         *\n         * console.log(mixer.getState().totalShow); // 2\n         *\n         * @public\n         * @instance\n         * @since 2.1.2\n         * @return {void}\n         */\n\n        forceRefresh: function() {\n            var self = this;\n\n            self.indexTargets();\n        },\n\n        /**\n         * Forces the re-rendering of all targets when using the Dataset API.\n         *\n         * By default, targets are only re-rendered when `data.dirtyCheck` is\n         * enabled, and an item's data has changed when `dataset()` is called.\n         *\n         * The `forceRender()` method allows for the re-rendering of all targets\n         * in response to some arbitrary event, such as the changing of the target\n         * render function.\n         *\n         * Targets are rendered against their existing data.\n         *\n         * @example\n         *\n         * .forceRender()\n         *\n         * @example <caption>Example: Force render targets after changing the target render function</caption>\n         *\n         * console.log(container.innerHTML); // ... &lt;span class=\"mix\"&gt;Foo&lt;/span&gt; ...\n         *\n         * mixer.configure({\n         *     render: {\n         *         target: (item) => `&lt;a href=\"/${item.slug}/\" class=\"mix\"&gt;${item.title}&lt;/a&gt;`\n         *     }\n         * });\n         *\n         * mixer.forceRender();\n         *\n         * console.log(container.innerHTML); // ... &lt;a href=\"/foo/\" class=\"mix\"&gt;Foo&lt;/a&gt; ...\n         *\n         * @public\n         * @instance\n         * @since 3.2.1\n         * @return {void}\n         */\n\n        forceRender: function() {\n            var self    = this,\n                target  = null,\n                el      = null,\n                id      = '';\n\n            for (id in self.cache) {\n                target = self.cache[id];\n\n                el = target.render(target.data);\n\n                if (el !== target.dom.el) {\n                    // Update target element reference\n\n                    if (target.isInDom) {\n                        target.unbindEvents();\n\n                        self.dom.parent.replaceChild(el, target.dom.el);\n                    }\n\n                    if (!target.isShown) {\n                        el.style.display = 'none';\n                    }\n\n                    target.dom.el = el;\n\n                    if (target.isInDom) {\n                        target.bindEvents();\n                    }\n                }\n            }\n\n            self.state = self.buildState(self.lastOperation);\n        },\n\n        /**\n         * Removes mixitup functionality from the container, unbinds all control\n         * event handlers, and deletes the mixer instance from MixItUp's internal\n         * cache.\n         *\n         * This should be performed whenever a mixer's container is removed from\n         * the DOM, such as during a page change in a single page application,\n         * or React's `componentWillUnmount()`.\n         *\n         * @example\n         *\n         * .destroy([cleanUp])\n         *\n         * @example <caption>Example: Destroying the mixer before removing its container element</caption>\n         *\n         * mixer.destroy();\n         *\n         * containerEl.parentElement.removeChild(containerEl);\n         *\n         * @public\n         * @instance\n         * @since   2.0.0\n         * @param   {boolean}   [cleanUp=false]\n         *     An optional boolean dictating whether or not to clean up any inline `display: none;` styling applied to hidden targets.\n         * @return  {void}\n         */\n\n        destroy: function(cleanUp) {\n            var self    = this,\n                control = null,\n                target  = null,\n                i       = 0;\n\n            self.callActions('beforeDestroy', arguments);\n\n            for (i = 0; control = self.controls[i]; i++) {\n                control.removeBinding(self);\n            }\n\n            for (i = 0; target = self.targets[i]; i++) {\n                if (cleanUp) {\n                    target.show();\n                }\n\n                target.unbindEvents();\n            }\n\n            if (self.dom.container.id.match(/^MixItUp/)) {\n                self.dom.container.removeAttribute('id');\n            }\n\n            delete mixitup.instances[self.id];\n\n            self.callActions('afterDestroy', arguments);\n        }\n    });\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.IMoveData = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.posIn          = null;\n        this.posOut         = null;\n        this.operation      = null;\n        this.callback       = null;\n        this.statusChange   = '';\n        this.duration       = -1;\n        this.staggerIndex   = -1;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.IMoveData);\n\n    mixitup.IMoveData.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.IMoveData.prototype.constructor = mixitup.IMoveData;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.TargetDom = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.el = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.TargetDom);\n\n    mixitup.TargetDom.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.TargetDom.prototype.constructor = mixitup.TargetDom;\n\n    /**\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Target = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.id         = '';\n        this.sortString = '';\n        this.mixer      = null;\n        this.callback   = null;\n        this.isShown    = false;\n        this.isBound    = false;\n        this.isExcluded = false;\n        this.isInDom    = false;\n        this.handler    = null;\n        this.operation  = null;\n        this.data       = null;\n        this.dom        = new mixitup.TargetDom();\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Target);\n\n    mixitup.Target.prototype = Object.create(mixitup.Base.prototype);\n\n    h.extend(mixitup.Target.prototype, {\n        constructor: mixitup.Target,\n\n        /**\n         * Initialises a newly instantiated Target.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {(Element|null)}    el\n         * @param   {object}            mixer\n         * @param   {object}            [data]\n         * @return  {void}\n         */\n\n        init: function(el, mixer, data) {\n            var self = this,\n                id   = '';\n\n            self.callActions('beforeInit', arguments);\n\n            self.mixer = mixer;\n\n            if (!el) {\n                // If no element is provided, render it\n\n                el = self.render(data);\n            }\n\n            self.cacheDom(el);\n\n            self.bindEvents();\n\n            if (self.dom.el.style.display !== 'none') {\n                self.isShown = true;\n            }\n\n            if (data && mixer.config.data.uidKey) {\n                if (typeof (id = data[mixer.config.data.uidKey]) === 'undefined' || id.toString().length < 1) {\n                    throw new TypeError(mixitup.messages.errorDatasetInvalidUidKey({\n                        uidKey: mixer.config.data.uidKey\n                    }));\n                }\n\n                self.id     = id;\n                self.data   = data;\n\n                mixer.cache[id] = self;\n            }\n\n            self.callActions('afterInit', arguments);\n        },\n\n        /**\n         * Renders the target element using a user-defined renderer function.\n         *\n         * @private\n         * @instance\n         * @since   3.1.4\n         * @param   {object} data\n         * @return  {void}\n         */\n\n        render: function(data) {\n            var self    = this,\n                render  = null,\n                el      = null,\n                temp    = null,\n                output  = '';\n\n            self.callActions('beforeRender', arguments);\n\n            render = self.callFilters('renderRender', self.mixer.config.render.target, arguments);\n\n            if (typeof render !== 'function') {\n                throw new TypeError(mixitup.messages.errorDatasetRendererNotSet());\n            }\n\n            output = render(data);\n\n            if (output && typeof output === 'object' && h.isElement(output)) {\n                el = output;\n            } else if (typeof output === 'string') {\n                temp = document.createElement('div');\n                temp.innerHTML = output;\n\n                el = temp.firstElementChild;\n            }\n\n            return self.callFilters('elRender', el, arguments);\n        },\n\n        /**\n         * Caches references of DOM elements neccessary for the target's functionality.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Element} el\n         * @return  {void}\n         */\n\n        cacheDom: function(el) {\n            var self = this;\n\n            self.callActions('beforeCacheDom', arguments);\n\n            self.dom.el = el;\n\n            self.callActions('afterCacheDom', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {string}    attributeName\n         * @return  {void}\n         */\n\n        getSortString: function(attributeName) {\n            var self    = this,\n                value   = self.dom.el.getAttribute('data-' + attributeName) || '';\n\n            self.callActions('beforeGetSortString', arguments);\n\n            value = isNaN(value * 1) ?\n                value.toLowerCase() :\n                value * 1;\n\n            self.sortString = value;\n\n            self.callActions('afterGetSortString', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {void}\n         */\n\n        show: function() {\n            var self = this;\n\n            self.callActions('beforeShow', arguments);\n\n            if (!self.isShown) {\n                self.dom.el.style.display = '';\n\n                self.isShown = true;\n            }\n\n            self.callActions('afterShow', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {void}\n         */\n\n        hide: function() {\n            var self = this;\n\n            self.callActions('beforeHide', arguments);\n\n            if (self.isShown) {\n                self.dom.el.style.display = 'none';\n\n                self.isShown = false;\n            }\n\n            self.callActions('afterHide', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {mixitup.IMoveData} moveData\n         * @return  {void}\n         */\n\n        move: function(moveData) {\n            var self = this;\n\n            self.callActions('beforeMove', arguments);\n\n            if (!self.isExcluded) {\n                self.mixer.targetsMoved++;\n            }\n\n            self.applyStylesIn(moveData);\n\n            requestAnimationFrame(function() {\n                self.applyStylesOut(moveData);\n            });\n\n            self.callActions('afterMove', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {object}    posData\n         * @param   {number}    multiplier\n         * @return  {void}\n         */\n\n        applyTween: function(posData, multiplier) {\n            var self                    = this,\n                propertyName            = '',\n                tweenData               = null,\n                posIn                   = posData.posIn,\n                currentTransformValues  = [],\n                currentValues           = new mixitup.StyleData(),\n                i                       = -1;\n\n            self.callActions('beforeApplyTween', arguments);\n\n            currentValues.x     = posIn.x;\n            currentValues.y     = posIn.y;\n\n            if (multiplier === 0) {\n                self.hide();\n            } else if (!self.isShown) {\n                self.show();\n            }\n\n            for (i = 0; propertyName = mixitup.features.TWEENABLE[i]; i++) {\n                tweenData = posData.tweenData[propertyName];\n\n                if (propertyName === 'x') {\n                    if (!tweenData) continue;\n\n                    currentValues.x = posIn.x + (tweenData * multiplier);\n                } else if (propertyName === 'y') {\n                    if (!tweenData) continue;\n\n                    currentValues.y = posIn.y + (tweenData * multiplier);\n                } else if (tweenData instanceof mixitup.TransformData) {\n                    if (!tweenData.value) continue;\n\n                    currentValues[propertyName].value =\n                        posIn[propertyName].value + (tweenData.value * multiplier);\n\n                    currentValues[propertyName].unit  = tweenData.unit;\n\n                    currentTransformValues.push(\n                        propertyName + '(' + currentValues[propertyName].value + tweenData.unit + ')'\n                    );\n                } else {\n                    if (!tweenData) continue;\n\n                    currentValues[propertyName] = posIn[propertyName] + (tweenData * multiplier);\n\n                    self.dom.el.style[propertyName] = currentValues[propertyName];\n                }\n            }\n\n            if (currentValues.x || currentValues.y) {\n                currentTransformValues.unshift('translate(' + currentValues.x + 'px, ' + currentValues.y + 'px)');\n            }\n\n            if (currentTransformValues.length) {\n                self.dom.el.style[mixitup.features.transformProp] = currentTransformValues.join(' ');\n            }\n\n            self.callActions('afterApplyTween', arguments);\n        },\n\n        /**\n         * Applies the initial styling to a target element before any transition\n         * is applied.\n         *\n         * @private\n         * @instance\n         * @param   {mixitup.IMoveData} moveData\n         * @return  {void}\n         */\n\n        applyStylesIn: function(moveData) {\n            var self            = this,\n                posIn           = moveData.posIn,\n                isFading        = self.mixer.effectsIn.opacity !== 1,\n                transformValues = [];\n\n            self.callActions('beforeApplyStylesIn', arguments);\n\n            transformValues.push('translate(' + posIn.x + 'px, ' + posIn.y + 'px)');\n\n            if (self.mixer.config.animation.animateResizeTargets) {\n                if (moveData.statusChange !== 'show') {\n                    // Don't apply posIn width or height or showing, as will be 0\n\n                    self.dom.el.style.width  = posIn.width + 'px';\n                    self.dom.el.style.height = posIn.height + 'px';\n                }\n\n                self.dom.el.style.marginRight  = posIn.marginRight + 'px';\n                self.dom.el.style.marginBottom = posIn.marginBottom + 'px';\n            }\n\n            isFading && (self.dom.el.style.opacity = posIn.opacity);\n\n            if (moveData.statusChange === 'show') {\n                transformValues = transformValues.concat(self.mixer.transformIn);\n            }\n\n            self.dom.el.style[mixitup.features.transformProp] = transformValues.join(' ');\n\n            self.callActions('afterApplyStylesIn', arguments);\n        },\n\n        /**\n         * Applies a transition followed by the final styles for the element to\n         * transition towards.\n         *\n         * @private\n         * @instance\n         * @param   {mixitup.IMoveData} moveData\n         * @return  {void}\n         */\n\n        applyStylesOut: function(moveData) {\n            var self            = this,\n                transitionRules = [],\n                transformValues = [],\n                isResizing      = self.mixer.config.animation.animateResizeTargets,\n                isFading        = typeof self.mixer.effectsIn.opacity !== 'undefined';\n\n            self.callActions('beforeApplyStylesOut', arguments);\n\n            // Build the transition rules\n\n            transitionRules.push(self.writeTransitionRule(\n                mixitup.features.transformRule,\n                moveData.staggerIndex\n            ));\n\n            if (moveData.statusChange !== 'none') {\n                transitionRules.push(self.writeTransitionRule(\n                    'opacity',\n                    moveData.staggerIndex,\n                    moveData.duration\n                ));\n            }\n\n            if (isResizing) {\n                transitionRules.push(self.writeTransitionRule(\n                    'width',\n                    moveData.staggerIndex,\n                    moveData.duration\n                ));\n\n                transitionRules.push(self.writeTransitionRule(\n                    'height',\n                    moveData.staggerIndex,\n                    moveData.duration\n                ));\n\n                transitionRules.push(self.writeTransitionRule(\n                    'margin',\n                    moveData.staggerIndex,\n                    moveData.duration\n                ));\n            }\n\n            // If no callback was provided, the element will\n            // not transition in any way so tag it as \"immovable\"\n\n            if (!moveData.callback) {\n                self.mixer.targetsImmovable++;\n\n                if (self.mixer.targetsMoved === self.mixer.targetsImmovable) {\n                    // If the total targets moved is equal to the\n                    // number of immovable targets, the operation\n                    // should be considered finished\n\n                    self.mixer.cleanUp(moveData.operation);\n                }\n\n                return;\n            }\n\n            // If the target will transition in some fasion,\n            // assign a callback function\n\n            self.operation = moveData.operation;\n            self.callback = moveData.callback;\n\n            // As long as the target is not excluded, increment\n            // the total number of targets bound\n\n            !self.isExcluded && self.mixer.targetsBound++;\n\n            // Tag the target as bound to differentiate from transitionEnd\n            // events that may come from stylesheet driven effects\n\n            self.isBound = true;\n\n            // Apply the transition\n\n            self.applyTransition(transitionRules);\n\n            // Apply width, height and margin negation\n\n            if (isResizing && moveData.posOut.width > 0 && moveData.posOut.height > 0) {\n                self.dom.el.style.width        = moveData.posOut.width + 'px';\n                self.dom.el.style.height       = moveData.posOut.height + 'px';\n                self.dom.el.style.marginRight  = moveData.posOut.marginRight + 'px';\n                self.dom.el.style.marginBottom = moveData.posOut.marginBottom + 'px';\n            }\n\n            if (!self.mixer.config.animation.nudge && moveData.statusChange === 'hide') {\n                // If we're not nudging, the translation should be\n                // applied before any other transforms to prevent\n                // lateral movement\n\n                transformValues.push('translate(' + moveData.posOut.x + 'px, ' + moveData.posOut.y + 'px)');\n            }\n\n            // Apply fade\n\n            switch (moveData.statusChange) {\n                case 'hide':\n                    isFading && (self.dom.el.style.opacity = self.mixer.effectsOut.opacity);\n\n                    transformValues = transformValues.concat(self.mixer.transformOut);\n\n                    break;\n                case 'show':\n                    isFading && (self.dom.el.style.opacity = 1);\n            }\n\n            if (\n                self.mixer.config.animation.nudge ||\n                (!self.mixer.config.animation.nudge && moveData.statusChange !== 'hide')\n            ) {\n                // Opposite of above - apply translate after\n                // other transform\n\n                transformValues.push('translate(' + moveData.posOut.x + 'px, ' + moveData.posOut.y + 'px)');\n            }\n\n            // Apply transforms\n\n            self.dom.el.style[mixitup.features.transformProp] = transformValues.join(' ');\n\n            self.callActions('afterApplyStylesOut', arguments);\n        },\n\n        /**\n         * Combines the name of a CSS property with the appropriate duration and delay\n         * values to created a valid transition rule.\n         *\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {string}    property\n         * @param   {number}    staggerIndex\n         * @param   {number}    duration\n         * @return  {string}\n         */\n\n        writeTransitionRule: function(property, staggerIndex, duration) {\n            var self  = this,\n                delay = self.getDelay(staggerIndex),\n                rule  = '';\n\n            rule = property + ' ' +\n                (duration > 0 ? duration : self.mixer.config.animation.duration) + 'ms ' +\n                delay + 'ms ' +\n                (property === 'opacity' ? 'linear' : self.mixer.config.animation.easing);\n\n            return self.callFilters('ruleWriteTransitionRule', rule, arguments);\n        },\n\n        /**\n         * Calculates the transition delay for each target element based on its index, if\n         * staggering is applied. If defined, A custom `animation.staggerSeqeuence`\n         * function can be used to manipulate the order of indices to produce custom\n         * stagger effects (e.g. for use in a grid with irregular row lengths).\n         *\n         * @private\n         * @instance\n         * @since   2.0.0\n         * @param   {number}    index\n         * @return  {number}\n         */\n\n        getDelay: function(index) {\n            var self    = this,\n                delay   = -1;\n\n            if (typeof self.mixer.config.animation.staggerSequence === 'function') {\n                index = self.mixer.config.animation.staggerSequence.call(self, index, self.state);\n            }\n\n            delay = !!self.mixer.staggerDuration ? index * self.mixer.staggerDuration : 0;\n\n            return self.callFilters('delayGetDelay', delay, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {string[]}  rules\n         * @return  {void}\n         */\n\n        applyTransition: function(rules) {\n            var self                = this,\n                transitionString    = rules.join(', ');\n\n            self.callActions('beforeApplyTransition', arguments);\n\n            self.dom.el.style[mixitup.features.transitionProp] = transitionString;\n\n            self.callActions('afterApplyTransition', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Event} e\n         * @return  {void}\n         */\n\n        handleTransitionEnd: function(e) {\n            var self        = this,\n                propName    = e.propertyName,\n                canResize   = self.mixer.config.animation.animateResizeTargets;\n\n            self.callActions('beforeHandleTransitionEnd', arguments);\n\n            if (\n                self.isBound &&\n                e.target.matches(self.mixer.config.selectors.target) &&\n                (\n                    propName.indexOf('transform') > -1 ||\n                    propName.indexOf('opacity') > -1 ||\n                    canResize && propName.indexOf('height') > -1 ||\n                    canResize && propName.indexOf('width') > -1 ||\n                    canResize && propName.indexOf('margin') > -1\n                )\n            ) {\n                self.callback.call(self, self.operation);\n\n                self.isBound = false;\n                self.callback = null;\n                self.operation = null;\n            }\n\n            self.callActions('afterHandleTransitionEnd', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {Event}     e\n         * @return  {void}\n         */\n\n        eventBus: function(e) {\n            var self = this;\n\n            self.callActions('beforeEventBus', arguments);\n\n            switch (e.type) {\n                case 'webkitTransitionEnd':\n                case 'transitionend':\n                    self.handleTransitionEnd(e);\n            }\n\n            self.callActions('afterEventBus', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {void}\n         */\n\n        unbindEvents: function() {\n            var self = this;\n\n            self.callActions('beforeUnbindEvents', arguments);\n\n            h.off(self.dom.el, 'webkitTransitionEnd', self.handler);\n            h.off(self.dom.el, 'transitionend', self.handler);\n\n            self.callActions('afterUnbindEvents', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @return  {void}\n         */\n\n        bindEvents: function() {\n            var self                = this,\n                transitionEndEvent  = '';\n\n            self.callActions('beforeBindEvents', arguments);\n\n            transitionEndEvent = mixitup.features.transitionPrefix === 'webkit' ? 'webkitTransitionEnd' : 'transitionend';\n\n            self.handler = function(e) {\n                return self.eventBus(e);\n            };\n\n            h.on(self.dom.el, transitionEndEvent, self.handler);\n\n            self.callActions('afterBindEvents', arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since   3.0.0\n         * @param   {boolean}   [getBox]\n         * @return  {PosData}\n         */\n\n        getPosData: function(getBox) {\n            var self    = this,\n                styles  = {},\n                rect    = null,\n                posData = new mixitup.StyleData();\n\n            self.callActions('beforeGetPosData', arguments);\n\n            posData.x = self.dom.el.offsetLeft;\n            posData.y = self.dom.el.offsetTop;\n\n            if (self.mixer.config.animation.animateResizeTargets || getBox) {\n                rect = self.dom.el.getBoundingClientRect();\n\n                posData.top     = rect.top;\n                posData.right   = rect.right;\n                posData.bottom  = rect.bottom;\n                posData.left    = rect.left;\n\n                posData.width  = rect.width;\n                posData.height = rect.height;\n            }\n\n            if (self.mixer.config.animation.animateResizeTargets) {\n                styles = window.getComputedStyle(self.dom.el);\n\n                posData.marginBottom = parseFloat(styles.marginBottom);\n                posData.marginRight  = parseFloat(styles.marginRight);\n            }\n\n            return self.callFilters('posDataGetPosData', posData, arguments);\n        },\n\n        /**\n         * @private\n         * @instance\n         * @since       3.0.0\n         * @return      {void}\n         */\n\n        cleanUp: function() {\n            var self = this;\n\n            self.callActions('beforeCleanUp', arguments);\n\n            self.dom.el.style[mixitup.features.transformProp]  = '';\n            self.dom.el.style[mixitup.features.transitionProp] = '';\n            self.dom.el.style.opacity                          = '';\n\n            if (self.mixer.config.animation.animateResizeTargets) {\n                self.dom.el.style.width        = '';\n                self.dom.el.style.height       = '';\n                self.dom.el.style.marginRight  = '';\n                self.dom.el.style.marginBottom = '';\n            }\n\n            self.callActions('afterCleanUp', arguments);\n        }\n    });\n\n    /**\n     * A jQuery-collection-like wrapper around one or more `mixitup.Mixer` instances\n     * allowing simultaneous control of said instances similar to the MixItUp 2 API.\n     *\n     * @example\n     * new mixitup.Collection(instances)\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     * @param       {mixitup.Mixer[]}   instances\n     */\n\n    mixitup.Collection = function(instances) {\n        var instance    = null,\n            i           = -1;\n\n        this.callActions('beforeConstruct');\n\n        for (i = 0; instance = instances[i]; i++) {\n            this[i] = instance;\n        }\n\n        this.length = instances.length;\n\n        this.callActions('afterConstruct');\n\n        h.freeze(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Collection);\n\n    mixitup.Collection.prototype = Object.create(mixitup.Base.prototype);\n\n    h.extend(mixitup.Collection.prototype,\n    /** @lends mixitup.Collection */\n    {\n        constructor: mixitup.Collection,\n\n        /**\n         * Calls a method on all instances in the collection by passing the method\n         * name as a string followed by any applicable parameters to be curried into\n         * to the method.\n         *\n         * @example\n         * .mixitup(methodName[,arg1][,arg2..]);\n         *\n         * @example\n         * var collection = new Collection([mixer1, mixer2]);\n         *\n         * return collection.mixitup('filter', '.category-a')\n         *     .then(function(states) {\n         *         state.forEach(function(state) {\n         *             console.log(state.activeFilter.selector); // .category-a\n         *         });\n         *     });\n         *\n         * @public\n         * @instance\n         * @since       3.0.0\n         * @param       {string}  methodName\n         * @return      {Promise<Array<mixitup.State>>}\n         */\n\n        mixitup: function(methodName) {\n            var self        = this,\n                instance    = null,\n                args        = Array.prototype.slice.call(arguments),\n                tasks       = [],\n                i           = -1;\n\n            this.callActions('beforeMixitup');\n\n            args.shift();\n\n            for (i = 0; instance = self[i]; i++) {\n                tasks.push(instance[methodName].apply(instance, args));\n            }\n\n            return self.callFilters('promiseMixitup', h.all(tasks, mixitup.libraries), arguments);\n        }\n    });\n\n    /**\n     * `mixitup.Operation` objects contain all data neccessary to describe the full\n     * lifecycle of any MixItUp operation. They can be used to compute and store an\n     * operation for use at a later time (e.g. programmatic tweening).\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Operation = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.id                      = '';\n\n        this.args                    = [];\n        this.command                 = null;\n        this.showPosData             = [];\n        this.toHidePosData           = [];\n\n        this.startState              = null;\n        this.newState                = null;\n        this.docState                = null;\n\n        this.willSort                = false;\n        this.willChangeLayout        = false;\n        this.hasEffect               = false;\n        this.hasFailed               = false;\n\n        this.triggerElement          = null;\n\n        this.show                    = [];\n        this.hide                    = [];\n        this.matching                = [];\n        this.toShow                  = [];\n        this.toHide                  = [];\n        this.toMove                  = [];\n        this.toRemove                = [];\n        this.startOrder              = [];\n        this.newOrder                = [];\n        this.startSort               = null;\n        this.newSort                 = null;\n        this.startFilter             = null;\n        this.newFilter               = null;\n        this.startDataset            = null;\n        this.newDataset              = null;\n        this.viewportDeltaX          = 0;\n        this.viewportDeltaY          = 0;\n        this.startX                  = 0;\n        this.startY                  = 0;\n        this.startHeight             = 0;\n        this.startWidth              = 0;\n        this.newX                    = 0;\n        this.newY                    = 0;\n        this.newHeight               = 0;\n        this.newWidth                = 0;\n        this.startContainerClassName = '';\n        this.startDisplay            = '';\n        this.newContainerClassName   = '';\n        this.newDisplay              = '';\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Operation);\n\n    mixitup.Operation.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.Operation.prototype.constructor = mixitup.Operation;\n\n    /**\n     * `mixitup.State` objects expose various pieces of data detailing the state of\n     * a MixItUp instance. They are provided at the start and end of any operation via\n     * callbacks and events, with the most recent state stored between operations\n     * for retrieval at any time via the API.\n     *\n     * @constructor\n     * @namespace\n     * @memberof    mixitup\n     * @public\n     * @since       3.0.0\n     */\n\n    mixitup.State = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /**\n         * The ID of the mixer instance.\n         *\n         * @name        id\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {string}\n         * @default     ''\n         */\n\n        this.id = '';\n\n        /**\n         * The currently active filter command as set by a control click or API call.\n         *\n         * @name        activeFilter\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {mixitup.CommandFilter}\n         * @default     null\n         */\n\n        this.activeFilter = null;\n\n        /**\n         * The currently active sort command as set by a control click or API call.\n         *\n         * @name        activeSort\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {mixitup.CommandSort}\n         * @default     null\n         */\n\n        this.activeSort = null;\n\n        /**\n         * The current layout-specific container class name, if applied.\n         *\n         * @name        activeContainerClassName\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {string}\n         * @default     ''\n         */\n\n        this.activeContainerClassName = '';\n\n        /**\n         * A reference to the container element that the mixer is instantiated on.\n         *\n         * @name        container\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Element}\n         * @default     null\n         */\n\n        this.container = null;\n\n        /**\n         * An array of all target elements indexed by the mixer.\n         *\n         * @name        targets\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Array.<Element>}\n         * @default     []\n         */\n\n        this.targets = [];\n\n        /**\n         * An array of all target elements not matching the current filter.\n         *\n         * @name        hide\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Array.<Element>}\n         * @default     []\n         */\n\n        this.hide = [];\n\n        /**\n         * An array of all target elements matching the current filter and any additional\n         * limits applied such as pagination.\n         *\n         * @name        show\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Array.<Element>}\n         * @default     []\n         */\n\n        this.show = [];\n\n        /**\n         * An array of all target elements matching the current filter irrespective of\n         * any additional limits applied such as pagination.\n         *\n         * @name        matching\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Array.<Element>}\n         * @default     []\n         */\n\n        this.matching = [];\n\n        /**\n         * An integer representing the total number of target elements indexed by the\n         * mixer. Equivalent to `state.targets.length`.\n         *\n         * @name        totalTargets\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {number}\n         * @default     -1\n         */\n\n        this.totalTargets = -1;\n\n        /**\n         * An integer representing the total number of target elements matching the\n         * current filter and any additional limits applied such as pagination.\n         * Equivalent to `state.show.length`.\n         *\n         * @name        totalShow\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {number}\n         * @default     -1\n         */\n\n        this.totalShow = -1;\n\n        /**\n         * An integer representing the total number of target elements not matching\n         * the current filter. Equivalent to `state.hide.length`.\n         *\n         * @name        totalHide\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {number}\n         * @default     -1\n         */\n\n        this.totalHide = -1;\n\n        /**\n         * An integer representing the total number of target elements matching the\n         * current filter irrespective of any other limits applied such as pagination.\n         * Equivalent to `state.matching.length`.\n         *\n         * @name        totalMatching\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {number}\n         * @default     -1\n         */\n\n        this.totalMatching = -1;\n\n        /**\n         * A boolean indicating whether the last operation \"failed\", i.e. no targets\n         * could be found matching the filter.\n         *\n         * @name        hasFailed\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {boolean}\n         * @default     false\n         */\n\n        this.hasFailed = false;\n\n        /**\n         * The DOM element that was clicked if the last operation was triggered by the\n         * clicking of a control and not an API call.\n         *\n         * @name        triggerElement\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Element|null}\n         * @default     null\n         */\n\n        this.triggerElement = null;\n\n        /**\n         * The currently active dataset underlying the rendered targets, if the\n         * dataset API is in use.\n         *\n         * @name        activeDataset\n         * @memberof    mixitup.State\n         * @instance\n         * @type        {Array.<object>}\n         * @default     null\n         */\n\n        this.activeDataset = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.State);\n\n    mixitup.State.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.State.prototype.constructor = mixitup.State;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.UserInstruction = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        this.command    = {};\n        this.animate    = false;\n        this.callback   = null;\n\n        this.callActions('afterConstruct');\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.UserInstruction);\n\n    mixitup.UserInstruction.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.UserInstruction.prototype.constructor = mixitup.UserInstruction;\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     */\n\n    mixitup.Messages = function() {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct');\n\n        /* Errors\n        ----------------------------------------------------------------------------- */\n\n        this.ERROR_FACTORY_INVALID_CONTAINER =\n            '[MixItUp] An invalid selector or element reference was passed to the mixitup factory function';\n\n        this.ERROR_FACTORY_CONTAINER_NOT_FOUND =\n            '[MixItUp] The provided selector yielded no container element';\n\n        this.ERROR_CONFIG_INVALID_ANIMATION_EFFECTS =\n            '[MixItUp] Invalid value for `animation.effects`';\n\n        this.ERROR_CONFIG_INVALID_CONTROLS_SCOPE =\n            '[MixItUp] Invalid value for `controls.scope`';\n\n        this.ERROR_CONFIG_INVALID_PROPERTY =\n            '[MixitUp] Invalid configuration object property \"${erroneous}\"${suggestion}';\n\n        this.ERROR_CONFIG_INVALID_PROPERTY_SUGGESTION =\n            '. Did you mean \"${probableMatch}\"?';\n\n        this.ERROR_CONFIG_DATA_UID_KEY_NOT_SET =\n            '[MixItUp] To use the dataset API, a UID key must be specified using `data.uidKey`';\n\n        this.ERROR_DATASET_INVALID_UID_KEY =\n            '[MixItUp] The specified UID key \"${uidKey}\" is not present on one or more dataset items';\n\n        this.ERROR_DATASET_DUPLICATE_UID =\n            '[MixItUp] The UID \"${uid}\" was found on two or more dataset items. UIDs must be unique.';\n\n        this.ERROR_INSERT_INVALID_ARGUMENTS =\n            '[MixItUp] Please provider either an index or a sibling and position to insert, not both';\n\n        this.ERROR_INSERT_PREEXISTING_ELEMENT =\n            '[MixItUp] An element to be inserted already exists in the container';\n\n        this.ERROR_FILTER_INVALID_ARGUMENTS =\n            '[MixItUp] Please provide either a selector or collection `.filter()`, not both';\n\n        this.ERROR_DATASET_NOT_SET =\n            '[MixItUp] To use the dataset API with pre-rendered targets, a starting dataset must be set using `load.dataset`';\n\n        this.ERROR_DATASET_PRERENDERED_MISMATCH =\n            '[MixItUp] `load.dataset` does not match pre-rendered targets';\n\n        this.ERROR_DATASET_RENDERER_NOT_SET =\n            '[MixItUp] To insert an element via the dataset API, a target renderer function must be provided to `render.target`';\n\n        this.ERROR_SORT_NON_EXISTENT_ELEMENT =\n            '[MixItUp] An element to be sorted does not already exist in the container';\n\n        /* Warnings\n        ----------------------------------------------------------------------------- */\n\n        this.WARNING_FACTORY_PREEXISTING_INSTANCE =\n            '[MixItUp] WARNING: This element already has an active MixItUp instance. The provided configuration object will be ignored.' +\n            ' If you wish to perform additional methods on this instance, please create a reference.';\n\n        this.WARNING_INSERT_NO_ELEMENTS =\n            '[MixItUp] WARNING: No valid elements were passed to `.insert()`';\n\n        this.WARNING_REMOVE_NO_ELEMENTS =\n            '[MixItUp] WARNING: No valid elements were passed to `.remove()`';\n\n        this.WARNING_MULTIMIX_INSTANCE_QUEUE_FULL =\n            '[MixItUp] WARNING: An operation was requested but the MixItUp instance was busy. The operation was rejected because the ' +\n            'queue is full or queuing is disabled.';\n\n        this.WARNING_GET_OPERATION_INSTANCE_BUSY =\n            '[MixItUp] WARNING: Operations can be be created while the MixItUp instance is busy.';\n\n        this.WARNING_NO_PROMISE_IMPLEMENTATION =\n            '[MixItUp] WARNING: No Promise implementations could be found. If you wish to use promises with MixItUp please install' +\n            ' an ES6 Promise polyfill.';\n\n        this.WARNING_INCONSISTENT_SORTING_ATTRIBUTES =\n            '[MixItUp] WARNING: The requested sorting data attribute \"${attribute}\" was not present on one or more target elements' +\n            ' which may product unexpected sort output';\n\n        this.callActions('afterConstruct');\n\n        this.compileTemplates();\n\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Messages);\n\n    mixitup.Messages.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.Messages.prototype.constructor = mixitup.Messages;\n\n    /**\n     * @return {void}\n     */\n\n    mixitup.Messages.prototype.compileTemplates = function() {\n        var errorKey        = '';\n        var errorMessage    = '';\n\n        for (errorKey in this) {\n            if (typeof (errorMessage = this[errorKey]) !== 'string') continue;\n\n            this[h.camelCase(errorKey)] = h.template(errorMessage);\n        }\n    };\n\n    mixitup.messages = new mixitup.Messages();\n\n    /**\n     * @constructor\n     * @memberof    mixitup\n     * @private\n     * @since       3.0.0\n     * @param       {mixitup.Mixer} mixer\n     */\n\n    mixitup.Facade = function Mixer(mixer) {\n        mixitup.Base.call(this);\n\n        this.callActions('beforeConstruct', arguments);\n\n        this.configure          = mixer.configure.bind(mixer);\n        this.show               = mixer.show.bind(mixer);\n        this.hide               = mixer.hide.bind(mixer);\n        this.filter             = mixer.filter.bind(mixer);\n        this.toggleOn           = mixer.toggleOn.bind(mixer);\n        this.toggleOff          = mixer.toggleOff.bind(mixer);\n        this.sort               = mixer.sort.bind(mixer);\n        this.changeLayout       = mixer.changeLayout.bind(mixer);\n        this.multimix           = mixer.multimix.bind(mixer);\n        this.dataset            = mixer.dataset.bind(mixer);\n        this.tween              = mixer.tween.bind(mixer);\n        this.insert             = mixer.insert.bind(mixer);\n        this.insertBefore       = mixer.insertBefore.bind(mixer);\n        this.insertAfter        = mixer.insertAfter.bind(mixer);\n        this.prepend            = mixer.prepend.bind(mixer);\n        this.append             = mixer.append.bind(mixer);\n        this.remove             = mixer.remove.bind(mixer);\n        this.destroy            = mixer.destroy.bind(mixer);\n        this.forceRefresh       = mixer.forceRefresh.bind(mixer);\n        this.forceRender        = mixer.forceRender.bind(mixer);\n        this.isMixing           = mixer.isMixing.bind(mixer);\n        this.getOperation       = mixer.getOperation.bind(mixer);\n        this.getConfig          = mixer.getConfig.bind(mixer);\n        this.getState           = mixer.getState.bind(mixer);\n\n        this.callActions('afterConstruct', arguments);\n\n        h.freeze(this);\n        h.seal(this);\n    };\n\n    mixitup.BaseStatic.call(mixitup.Facade);\n\n    mixitup.Facade.prototype = Object.create(mixitup.Base.prototype);\n\n    mixitup.Facade.prototype.constructor = mixitup.Facade;\n\n    if (typeof exports === 'object' && typeof module === 'object') {\n        module.exports = mixitup;\n    } else if (typeof define === 'function' && define.amd) {\n        define(function() {\n            return mixitup;\n        });\n    } else if (typeof window.mixitup === 'undefined' || typeof window.mixitup !== 'function') {\n        window.mixitup = mixitup;\n    }\n    mixitup.BaseStatic.call(mixitup.constructor);\n\n    mixitup.NAME = 'mixitup';\n    mixitup.CORE_VERSION = '3.3.1';\n})(window);","/**!\n * MixItUp MultiFilter v3.3.6\n * A UI-builder for powerful multidimensional filtering\n * Build 293e0dda-087e-4a76-aadf-e3e8b311b81f\n *\n * Requires mixitup.js >= v^3.1.2\n *\n * @copyright Copyright 2014-2020 KunkaLabs Limited.\n * @author    KunkaLabs Limited.\n * @link      https://www.kunkalabs.com/mixitup-multifilter/\n *\n * @license   Commercial use requires a commercial license.\n *            https://www.kunkalabs.com/mixitup-multifilter/licenses/\n *\n *            Non-commercial use permitted under same terms as  license.\n *            http://creativecommons.org/licenses/by-nc/3.0/\n */\n!function(u){\"use strict\";var e=function(u){var t,i=u.h;if(t=[[\"A\",/[\\u0041\\u24B6\\uFF21\\u00C0\\u00C1\\u00C2\\u1EA6\\u1EA4\\u1EAA\\u1EA8\\u00C3\\u0100\\u0102\\u1EB0\\u1EAE\\u1EB4\\u1EB2\\u0226\\u01E0\\u00C4\\u01DE\\u1EA2\\u00C5\\u01FA\\u01CD\\u0200\\u0202\\u1EA0\\u1EAC\\u1EB6\\u1E00\\u0104\\u023A\\u2C6F]/g],[\"AA\",/[\\uA732]/g],[\"AE\",/[\\u00C6\\u01FC\\u01E2]/g],[\"AO\",/[\\uA734]/g],[\"AU\",/[\\uA736]/g],[\"AV\",/[\\uA738\\uA73A]/g],[\"AY\",/[\\uA73C]/g],[\"B\",/[\\u0042\\u24B7\\uFF22\\u1E02\\u1E04\\u1E06\\u0243\\u0182\\u0181]/g],[\"C\",/[\\u0043\\u24B8\\uFF23\\u0106\\u0108\\u010A\\u010C\\u00C7\\u1E08\\u0187\\u023B\\uA73E]/g],[\"D\",/[\\u0044\\u24B9\\uFF24\\u1E0A\\u010E\\u1E0C\\u1E10\\u1E12\\u1E0E\\u0110\\u018B\\u018A\\u0189\\uA779]/g],[\"DZ\",/[\\u01F1\\u01C4]/g],[\"Dz\",/[\\u01F2\\u01C5]/g],[\"E\",/[\\u0045\\u24BA\\uFF25\\u00C8\\u00C9\\u00CA\\u1EC0\\u1EBE\\u1EC4\\u1EC2\\u1EBC\\u0112\\u1E14\\u1E16\\u0114\\u0116\\u00CB\\u1EBA\\u011A\\u0204\\u0206\\u1EB8\\u1EC6\\u0228\\u1E1C\\u0118\\u1E18\\u1E1A\\u0190\\u018E]/g],[\"F\",/[\\u0046\\u24BB\\uFF26\\u1E1E\\u0191\\uA77B]/g],[\"G\",/[\\u0047\\u24BC\\uFF27\\u01F4\\u011C\\u1E20\\u011E\\u0120\\u01E6\\u0122\\u01E4\\u0193\\uA7A0\\uA77D\\uA77E]/g],[\"H\",/[\\u0048\\u24BD\\uFF28\\u0124\\u1E22\\u1E26\\u021E\\u1E24\\u1E28\\u1E2A\\u0126\\u2C67\\u2C75\\uA78D]/g],[\"I\",/[\\u0049\\u24BE\\uFF29\\u00CC\\u00CD\\u00CE\\u0128\\u012A\\u012C\\u0130\\u00CF\\u1E2E\\u1EC8\\u01CF\\u0208\\u020A\\u1ECA\\u012E\\u1E2C\\u0197]/g],[\"J\",/[\\u004A\\u24BF\\uFF2A\\u0134\\u0248]/g],[\"K\",/[\\u004B\\u24C0\\uFF2B\\u1E30\\u01E8\\u1E32\\u0136\\u1E34\\u0198\\u2C69\\uA740\\uA742\\uA744\\uA7A2]/g],[\"L\",/[\\u004C\\u24C1\\uFF2C\\u013F\\u0139\\u013D\\u1E36\\u1E38\\u013B\\u1E3C\\u1E3A\\u0141\\u023D\\u2C62\\u2C60\\uA748\\uA746\\uA780]/g],[\"LJ\",/[\\u01C7]/g],[\"Lj\",/[\\u01C8]/g],[\"M\",/[\\u004D\\u24C2\\uFF2D\\u1E3E\\u1E40\\u1E42\\u2C6E\\u019C]/g],[\"N\",/[\\u004E\\u24C3\\uFF2E\\u01F8\\u0143\\u00D1\\u1E44\\u0147\\u1E46\\u0145\\u1E4A\\u1E48\\u0220\\u019D\\uA790\\uA7A4]/g],[\"NJ\",/[\\u01CA]/g],[\"Nj\",/[\\u01CB]/g],[\"O\",/[\\u004F\\u24C4\\uFF2F\\u00D2\\u00D3\\u00D4\\u1ED2\\u1ED0\\u1ED6\\u1ED4\\u00D5\\u1E4C\\u022C\\u1E4E\\u014C\\u1E50\\u1E52\\u014E\\u022E\\u0230\\u00D6\\u022A\\u1ECE\\u0150\\u01D1\\u020C\\u020E\\u01A0\\u1EDC\\u1EDA\\u1EE0\\u1EDE\\u1EE2\\u1ECC\\u1ED8\\u01EA\\u01EC\\u00D8\\u01FE\\u0186\\u019F\\uA74A\\uA74C]/g],[\"OI\",/[\\u01A2]/g],[\"OO\",/[\\uA74E]/g],[\"OU\",/[\\u0222]/g],[\"P\",/[\\u0050\\u24C5\\uFF30\\u1E54\\u1E56\\u01A4\\u2C63\\uA750\\uA752\\uA754]/g],[\"Q\",/[\\u0051\\u24C6\\uFF31\\uA756\\uA758\\u024A]/g],[\"R\",/[\\u0052\\u24C7\\uFF32\\u0154\\u1E58\\u0158\\u0210\\u0212\\u1E5A\\u1E5C\\u0156\\u1E5E\\u024C\\u2C64\\uA75A\\uA7A6\\uA782]/g],[\"S\",/[\\u0053\\u24C8\\uFF33\\u1E9E\\u015A\\u1E64\\u015C\\u1E60\\u0160\\u1E66\\u1E62\\u1E68\\u0218\\u015E\\u2C7E\\uA7A8\\uA784]/g],[\"T\",/[\\u0054\\u24C9\\uFF34\\u1E6A\\u0164\\u1E6C\\u021A\\u0162\\u1E70\\u1E6E\\u0166\\u01AC\\u01AE\\u023E\\uA786]/g],[\"TZ\",/[\\uA728]/g],[\"U\",/[\\u0055\\u24CA\\uFF35\\u00D9\\u00DA\\u00DB\\u0168\\u1E78\\u016A\\u1E7A\\u016C\\u00DC\\u01DB\\u01D7\\u01D5\\u01D9\\u1EE6\\u016E\\u0170\\u01D3\\u0214\\u0216\\u01AF\\u1EEA\\u1EE8\\u1EEE\\u1EEC\\u1EF0\\u1EE4\\u1E72\\u0172\\u1E76\\u1E74\\u0244]/g],[\"V\",/[\\u0056\\u24CB\\uFF36\\u1E7C\\u1E7E\\u01B2\\uA75E\\u0245]/g],[\"VY\",/[\\uA760]/g],[\"W\",/[\\u0057\\u24CC\\uFF37\\u1E80\\u1E82\\u0174\\u1E86\\u1E84\\u1E88\\u2C72]/g],[\"X\",/[\\u0058\\u24CD\\uFF38\\u1E8A\\u1E8C]/g],[\"Y\",/[\\u0059\\u24CE\\uFF39\\u1EF2\\u00DD\\u0176\\u1EF8\\u0232\\u1E8E\\u0178\\u1EF6\\u1EF4\\u01B3\\u024E\\u1EFE]/g],[\"Z\",/[\\u005A\\u24CF\\uFF3A\\u0179\\u1E90\\u017B\\u017D\\u1E92\\u1E94\\u01B5\\u0224\\u2C7F\\u2C6B\\uA762]/g],[\"a\",/[\\u0061\\u24D0\\uFF41\\u1E9A\\u00E0\\u00E1\\u00E2\\u1EA7\\u1EA5\\u1EAB\\u1EA9\\u00E3\\u0101\\u0103\\u1EB1\\u1EAF\\u1EB5\\u1EB3\\u0227\\u01E1\\u00E4\\u01DF\\u1EA3\\u00E5\\u01FB\\u01CE\\u0201\\u0203\\u1EA1\\u1EAD\\u1EB7\\u1E01\\u0105\\u2C65\\u0250]/g],[\"aa\",/[\\uA733]/g],[\"ae\",/[\\u00E6\\u01FD\\u01E3]/g],[\"ao\",/[\\uA735]/g],[\"au\",/[\\uA737]/g],[\"av\",/[\\uA739\\uA73B]/g],[\"ay\",/[\\uA73D]/g],[\"b\",/[\\u0062\\u24D1\\uFF42\\u1E03\\u1E05\\u1E07\\u0180\\u0183\\u0253]/g],[\"c\",/[\\u0063\\u24D2\\uFF43\\u0107\\u0109\\u010B\\u010D\\u00E7\\u1E09\\u0188\\u023C\\uA73F\\u2184]/g],[\"d\",/[\\u0064\\u24D3\\uFF44\\u1E0B\\u010F\\u1E0D\\u1E11\\u1E13\\u1E0F\\u0111\\u018C\\u0256\\u0257\\uA77A]/g],[\"dz\",/[\\u01F3\\u01C6]/g],[\"e\",/[\\u0065\\u24D4\\uFF45\\u00E8\\u00E9\\u00EA\\u1EC1\\u1EBF\\u1EC5\\u1EC3\\u1EBD\\u0113\\u1E15\\u1E17\\u0115\\u0117\\u00EB\\u1EBB\\u011B\\u0205\\u0207\\u1EB9\\u1EC7\\u0229\\u1E1D\\u0119\\u1E19\\u1E1B\\u0247\\u025B\\u01DD]/g],[\"f\",/[\\u0066\\u24D5\\uFF46\\u1E1F\\u0192\\uA77C]/g],[\"g\",/[\\u0067\\u24D6\\uFF47\\u01F5\\u011D\\u1E21\\u011F\\u0121\\u01E7\\u0123\\u01E5\\u0260\\uA7A1\\u1D79\\uA77F]/g],[\"h\",/[\\u0068\\u24D7\\uFF48\\u0125\\u1E23\\u1E27\\u021F\\u1E25\\u1E29\\u1E2B\\u1E96\\u0127\\u2C68\\u2C76\\u0265]/g],[\"hv\",/[\\u0195]/g],[\"i\",/[\\u0069\\u24D8\\uFF49\\u00EC\\u00ED\\u00EE\\u0129\\u012B\\u012D\\u00EF\\u1E2F\\u1EC9\\u01D0\\u0209\\u020B\\u1ECB\\u012F\\u1E2D\\u0268\\u0131]/g],[\"j\",/[\\u006A\\u24D9\\uFF4A\\u0135\\u01F0\\u0249]/g],[\"k\",/[\\u006B\\u24DA\\uFF4B\\u1E31\\u01E9\\u1E33\\u0137\\u1E35\\u0199\\u2C6A\\uA741\\uA743\\uA745\\uA7A3]/g],[\"l\",/[\\u006C\\u24DB\\uFF4C\\u0140\\u013A\\u013E\\u1E37\\u1E39\\u013C\\u1E3D\\u1E3B\\u017F\\u0142\\u019A\\u026B\\u2C61\\uA749\\uA781\\uA747]/g],[\"lj\",/[\\u01C9]/g],[\"m\",/[\\u006D\\u24DC\\uFF4D\\u1E3F\\u1E41\\u1E43\\u0271\\u026F]/g],[\"n\",/[\\u006E\\u24DD\\uFF4E\\u01F9\\u0144\\u00F1\\u1E45\\u0148\\u1E47\\u0146\\u1E4B\\u1E49\\u019E\\u0272\\u0149\\uA791\\uA7A5]/g],[\"nj\",/[\\u01CC]/g],[\"o\",/[\\u006F\\u24DE\\uFF4F\\u00F2\\u00F3\\u00F4\\u1ED3\\u1ED1\\u1ED7\\u1ED5\\u00F5\\u1E4D\\u022D\\u1E4F\\u014D\\u1E51\\u1E53\\u014F\\u022F\\u0231\\u00F6\\u022B\\u1ECF\\u0151\\u01D2\\u020D\\u020F\\u01A1\\u1EDD\\u1EDB\\u1EE1\\u1EDF\\u1EE3\\u1ECD\\u1ED9\\u01EB\\u01ED\\u00F8\\u01FF\\u0254\\uA74B\\uA74D\\u0275]/g],[\"oi\",/[\\u01A3]/g],[\"ou\",/[\\u0223]/g],[\"oo\",/[\\uA74F]/g],[\"p\",/[\\u0070\\u24DF\\uFF50\\u1E55\\u1E57\\u01A5\\u1D7D\\uA751\\uA753\\uA755]/g],[\"q\",/[\\u0071\\u24E0\\uFF51\\u024B\\uA757\\uA759]/g],[\"r\",/[\\u0072\\u24E1\\uFF52\\u0155\\u1E59\\u0159\\u0211\\u0213\\u1E5B\\u1E5D\\u0157\\u1E5F\\u024D\\u027D\\uA75B\\uA7A7\\uA783]/g],[\"s\",/[\\u0073\\u24E2\\uFF53\\u00DF\\u015B\\u1E65\\u015D\\u1E61\\u0161\\u1E67\\u1E63\\u1E69\\u0219\\u015F\\u023F\\uA7A9\\uA785\\u1E9B]/g],[\"t\",/[\\u0074\\u24E3\\uFF54\\u1E6B\\u1E97\\u0165\\u1E6D\\u021B\\u0163\\u1E71\\u1E6F\\u0167\\u01AD\\u0288\\u2C66\\uA787]/g],[\"tz\",/[\\uA729]/g],[\"u\",/[\\u0075\\u24E4\\uFF55\\u00F9\\u00FA\\u00FB\\u0169\\u1E79\\u016B\\u1E7B\\u016D\\u00FC\\u01DC\\u01D8\\u01D6\\u01DA\\u1EE7\\u016F\\u0171\\u01D4\\u0215\\u0217\\u01B0\\u1EEB\\u1EE9\\u1EEF\\u1EED\\u1EF1\\u1EE5\\u1E73\\u0173\\u1E77\\u1E75\\u0289]/g],[\"v\",/[\\u0076\\u24E5\\uFF56\\u1E7D\\u1E7F\\u028B\\uA75F\\u028C]/g],[\"vy\",/[\\uA761]/g],[\"w\",/[\\u0077\\u24E6\\uFF57\\u1E81\\u1E83\\u0175\\u1E87\\u1E85\\u1E98\\u1E89\\u2C73]/g],[\"x\",/[\\u0078\\u24E7\\uFF58\\u1E8B\\u1E8D]/g],[\"y\",/[\\u0079\\u24E8\\uFF59\\u1EF3\\u00FD\\u0177\\u1EF9\\u0233\\u1E8F\\u00FF\\u1EF7\\u1E99\\u1EF5\\u01B4\\u024F\\u1EFF]/g],[\"z\",/[\\u007A\\u24E9\\uFF5A\\u017A\\u1E91\\u017C\\u017E\\u1E93\\u1E95\\u01B6\\u0225\\u0240\\u2C6C\\uA763]/g]],!u.CORE_VERSION||!i.compareVersions(e.REQUIRE_CORE_VERSION,u.CORE_VERSION))throw new Error(\"[MixItUp Multifilter] MixItUp Multifilter v\"+e.EXTENSION_VERSION+\" requires at least MixItUp v\"+e.REQUIRE_CORE_VERSION);u.ConfigCallbacks.registerAction(\"afterConstruct\",\"multifilter\",function(){this.onParseFilterGroups=null}),u.ConfigMultifilter=function(){this.enable=!1,this.logicWithinGroup=\"or\",this.logicBetweenGroups=\"and\",this.minSearchLength=3,this.parseOn=\"change\",this.keyupThrottleDuration=350,i.seal(this)},u.Config.registerAction(\"beforeConstruct\",\"multifilter\",function(){this.multifilter=new u.ConfigMultifilter}),u.MultifilterFormEventTracker=function(){this.form=null,this.totalBound=0,this.totalHandled=0,i.seal(this)},u.FilterGroupDom=function(){this.el=null,this.form=null,i.seal(this)},u.FilterGroup=function(){this.name=\"\",this.dom=new u.FilterGroupDom,this.activeSelectors=[],this.activeFilters=[],this.activeToggles=[],this.handler=null,this.mixer=null,this.logic=\"or\",this.parseOn=\"change\",this.keyupTimeout=-1,i.seal(this)},i.extend(u.FilterGroup.prototype,{init:function(u,e){var t=this,i=u.getAttribute(\"data-logic\");t.dom.el=u,this.name=t.dom.el.getAttribute(\"data-filter-group\")||\"\",t.cacheDom(),t.dom.form&&t.enableButtons(),t.mixer=e,(i&&\"and\"===i.toLowerCase()||\"and\"===e.config.multifilter.logicWithinGroup)&&(t.logic=\"and\"),t.bindEvents()},cacheDom:function(){var u=this;u.dom.form=i.closestParent(u.dom.el,\"form\",!0)},enableButtons:function(){var u=this,e=u.dom.form.querySelectorAll('button[type=\"submit\"]:disabled'),t=null,i=-1;for(i=0;t=e[i];i++)t.disabled&&(t.disabled=!1)},bindEvents:function(){var u=this;u.handler=function(e){switch(e.type){case\"reset\":case\"submit\":u.handleFormEvent(e);break;default:u[\"handle\"+i.pascalCase(e.type)](e)}},i.on(u.dom.el,\"click\",u.handler),i.on(u.dom.el,\"change\",u.handler),i.on(u.dom.el,\"keyup\",u.handler),u.dom.form&&(i.on(u.dom.form,\"reset\",u.handler),i.on(u.dom.form,\"submit\",u.handler))},unbindEvents:function(){var u=this;i.off(u.dom.el,\"click\",u.handler),i.off(u.dom.el,\"change\",u.handler),i.off(u.dom.el,\"keyup\",u.handler),u.dom.form&&(i.off(u.dom.form,\"reset\",u.handler),i.off(u.dom.form,\"submit\",u.handler)),u.handler=null},handleClick:function(u){var e=this,t=e.mixer,r=null,l=i.closestParent(u.target,\"[data-filter], [data-toggle]\",!0),o=\"\",n=-1,E=\"\";l&&((o=e.mixer.config.selectors.control)&&!l.matches(o)||(u.stopPropagation(),t.lastClicked||(t.lastClicked=l),\"function\"==typeof t.config.callbacks.onMixClick&&(r=t.config.callbacks.onMixClick.call(t.lastClicked,t.state,u,e),r===!1)||(l.matches(\"[data-filter]\")?(E=l.getAttribute(\"data-filter\"),e.activeToggles=[],e.activeSelectors=e.activeFilters=[E]):l.matches(\"[data-toggle]\")&&(E=l.getAttribute(\"data-toggle\"),e.activeFilters=[],(n=e.activeToggles.indexOf(E))>-1?e.activeToggles.splice(n,1):e.activeToggles.push(E),\"and\"===e.logic?e.activeSelectors=[e.activeToggles]:e.activeSelectors=e.activeToggles),e.updateControls(),\"change\"===e.mixer.config.multifilter.parseOn&&e.mixer.parseFilterGroups())))},handleChange:function(u){var e=this,t=u.target;switch(u.stopPropagation(),t.type){case\"text\":case\"search\":case\"email\":case\"select-one\":case\"radio\":e.getSingleValue(t);break;case\"checkbox\":case\"select-multiple\":e.getMultipleValues(t)}\"change\"===e.mixer.config.multifilter.parseOn&&e.mixer.parseFilterGroups()},handleKeyup:function(u){var e=this,t=u.target;if(!([\"text\",\"search\",\"email\"].indexOf(t.type)<0)){if(\"change\"!==e.mixer.config.multifilter.parseOn)return void e.mixer.getSingleValue(t);clearTimeout(e.keyupTimeout),e.keyupTimeout=setTimeout(function(){e.getSingleValue(t),e.mixer.parseFilterGroups()},e.mixer.config.multifilter.keyupThrottleDuration)}},handleFormEvent:function(e){var t=this,i=null,r=null,l=-1;if(\"submit\"===e.type&&e.preventDefault(),\"reset\"===e.type&&(t.activeFilters=t.activeToggles=t.activeSelectors=[],t.updateControls()),t.mixer.multifilterFormEventTracker)i=t.mixer.multifilterFormEventTracker;else for(i=t.mixer.multifilterFormEventTracker=new u.MultifilterFormEventTracker,i.form=e.target,l=0;r=t.mixer.filterGroups[l];l++)r.dom.form===e.target&&i.totalBound++;e.target===i.form&&(i.totalHandled++,i.totalHandled===i.totalBound&&(t.mixer.multifilterFormEventTracker=null,\"submit\"!==e.type&&\"change\"!==t.mixer.config.multifilter.parseOn||t.mixer.parseFilterGroups()))},getSingleValue:function(u){var e=this,i=null,r=\"\",l=\"\",o=\"\",n=-1;if(u.type.match(/text|search|email/g)){if(r=u.getAttribute(\"data-search-attribute\"),!r)throw new Error(\"[MixItUp MultiFilter] A valid `data-search-attribute` must be present on text inputs\");if(u.value.length<e.mixer.config.multifilter.minSearchLength)return void(e.activeSelectors=e.activeFilters=e.activeToggles=[\"\"]);for(o=u.value.toLowerCase().trim(),n=0;i=t[n];n++)o=o.replace(i[1],i[0]);o=o.replace(/\\W+/g,\" \"),l=\"[\"+r+'*=\"'+o+'\"]'}else l=u.value;\"string\"==typeof u.value&&(e.activeSelectors=e.activeToggles=e.activeFilters=l?[l]:[])},getMultipleValues:function(u){var e=this,t=[],i=\"\",r=null,l=null,o=-1;switch(u.type){case\"checkbox\":i='input[type=\"checkbox\"]';break;case\"select-multiple\":i=\"option\"}for(l=e.dom.el.querySelectorAll(i),o=0;r=l[o];o++)(r.checked||r.selected)&&r.value&&t.push(r.value);e.activeFilters=[],e.activeToggles=t,\"and\"===e.logic?e.activeSelectors=[t]:e.activeSelectors=t},updateControls:function(u){var e=this,t=null,i=\"\",r=\"\",l=\"\",o=-1;for(i=e.mixer.config.selectors.control.trim(),r=[\"[data-filter]\"+i,\"[data-toggle]\"+i].join(\", \"),u=u||e.dom.el.querySelectorAll(r),o=0;t=u[o];o++)l=Boolean(t.getAttribute(\"data-toggle\"))?\"toggle\":\"filter\",e.updateControl(t,l)},updateControl:function(u,e){var t=this,r=u.getAttribute(\"data-\"+e),l=t.activeToggles.concat(t.activeFilters),o=\"\";o=i.getClassname(t.mixer.config.classNames,e,t.mixer.config.classNames.modifierActive),l.indexOf(r)>-1?i.addClass(u,o):i.removeClass(u,o)},updateUi:function(){var u=this,e=u.dom.el.querySelectorAll(\"[data-filter], [data-toggle]\"),t=u.dom.el.querySelectorAll('input[type=\"radio\"], input[type=\"checkbox\"], option'),i=u.activeToggles.concat(u.activeFilters),r=!1,l=null,o=-1;for(e.length&&u.updateControls(e,!0),o=0;l=t[o];o++)switch(r=i.indexOf(l.value)>-1,l.tagName.toLowerCase()){case\"option\":l.selected=r;break;case\"input\":l.checked=r}}}),u.MixerDom.registerAction(\"afterConstruct\",\"multifilter\",function(){this.filterGroups=[]}),u.Mixer.registerAction(\"afterConstruct\",\"multifilter\",function(){this.filterGroups=[],this.filterGroupsHash={},this.multifilterFormEventTracker=null}),u.Mixer.registerAction(\"afterCacheDom\",\"multifilter\",function(){var e=this,t=null;if(e.config.multifilter.enable){switch(e.config.controls.scope){case\"local\":t=e.dom.container;break;case\"global\":t=e.dom.document;break;default:throw new Error(u.messages.ERROR_CONFIG_INVALID_CONTROLS_SCOPE)}e.dom.filterGroups=t.querySelectorAll(\"[data-filter-group]\")}}),u.Mixer.registerAction(\"beforeInitControls\",\"multifilter\",function(){var u=this;u.config.multifilter.enable&&(u.config.controls.live=!0)}),u.Mixer.registerAction(\"afterSanitizeConfig\",\"multifilter\",function(){var u=this;u.config.multifilter.logicBetweenGroups=u.config.multifilter.logicBetweenGroups.toLowerCase().trim(),u.config.multifilter.logicWithinGroup=u.config.multifilter.logicWithinGroup.toLowerCase().trim()}),u.Mixer.registerAction(\"afterAttach\",\"multifilter\",function(){var u=this;u.dom.filterGroups.length&&u.indexFilterGroups()}),u.Mixer.registerAction(\"afterUpdateControls\",\"multifilter\",function(){var u=this,e=null,t=-1;for(t=0;e=u.filterGroups[t];t++)e.updateControls()}),u.Mixer.registerAction(\"beforeDestroy\",\"multifilter\",function(){var u=this,e=null,t=-1;for(t=0;e=u.filterGroups[t];t++)e.unbindEvents()}),u.Mixer.extend({indexFilterGroups:function(){var e=this,t=null,i=null,r=-1;for(r=0;i=e.dom.filterGroups[r];r++)if(t=new u.FilterGroup,t.init(i,e),e.filterGroups.push(t),t.name){if(\"undefined\"!=typeof e.filterGroupsHash[t.name])throw new Error('[MixItUp MultiFilter] A filter group with name \"'+t.name+'\" already exists');e.filterGroupsHash[t.name]=t}},parseParseFilterGroupsArgs:function(e){var t=this,r=new u.UserInstruction,l=null,o=-1;for(r.animate=t.config.animation.enable,r.command=new u.CommandFilter,o=0;o<e.length;o++)l=e[o],\"boolean\"==typeof l?r.animate=l:\"function\"==typeof l&&(r.callback=l);return i.freeze(r),r},getFilterGroupPaths:function(){var u=this,e=null,t=null,r=null,l=[],o=[],n=[],E=-1;for(E=0;E<u.filterGroups.length;E++)(r=u.filterGroups[E].activeSelectors).length&&(l.push(r),n.push(0));return e=function(){var u=null,e=[],t=-1;for(t=0;t<l.length;t++)u=l[t][n[t]],Array.isArray(u)&&(u=u.join(\"\")),e.push(u);e=i.clean(e),o.push(e)},t=function(u){u=u||0;for(var i=l[u];n[u]<i.length;)u<l.length-1?t(u+1):e(),n[u]++;n[u]=0},l.length?(t(),o):\"\"},buildSelectorFromPaths:function(u){var e=this,t=null,i=[],r=\"\",l=\"\",o=-1;if(!u.length)return\"\";if(\"or\"===e.config.multifilter.logicBetweenGroups&&(l=\", \"),u.length>1){for(o=0;o<u.length;o++)t=u[o],r=t.join(l),i.indexOf(r)<0&&i.push(r);return i.join(\", \")}return u[0].join(l)},parseFilterGroups:function(){var u=this,e=u.parseFilterArgs(arguments),t=u.getFilterGroupPaths(),i=u.buildSelectorFromPaths(t),r=null,l={};return\"\"===i&&(i=u.config.controls.toggleDefault),e.command.selector=i,l.filter=e.command,\"function\"==typeof(r=u.config.callbacks.onParseFilterGroups)&&(l=r(l)),u.multimix(l,e.animate,e.callback)},setFilterGroupSelectors:function(u,e){var t=this,i=null;if(e=Array.isArray(e)?e:[e],\"undefined\"==typeof(i=t.filterGroupsHash[u]))throw new Error('[MixItUp MultiFilter] No filter group could be found with the name \"'+u+'\"');i.activeToggles=e.slice(),\"and\"===i.logic?i.activeSelectors=[i.activeToggles]:i.activeSelectors=i.activeToggles,i.updateUi(i.activeToggles)},getFilterGroupSelectors:function(u){var e=this,t=null;if(\"undefined\"==typeof(t=e.filterGroupsHash[u]))throw new Error('[MixItUp MultiFilter] No filter group could be found with the name \"'+u+'\"');return t.activeSelectors.slice()}}),u.Facade.registerAction(\"afterConstruct\",\"multifilter\",function(u){this.parseFilterGroups=u.parseFilterGroups.bind(u),this.setFilterGroupSelectors=u.setFilterGroupSelectors.bind(u),this.getFilterGroupSelectors=u.getFilterGroupSelectors.bind(u)})};if(e.TYPE=\"mixitup-extension\",e.NAME=\"mixitup-multifilter\",e.EXTENSION_VERSION=\"3.3.6\",e.REQUIRE_CORE_VERSION=\"^3.1.2\",\"object\"==typeof exports&&\"object\"==typeof module)module.exports=e;else if(\"function\"==typeof define&&define.amd)define(function(){return e});else{if(!u.mixitup||\"function\"!=typeof u.mixitup)throw new Error(\"[MixItUp MultiFilter] MixItUp core not found\");e(u.mixitup)}}(window);","module.exports = {\n\tproxyUrl: 'class-vrnew.test',\n\tport: 3000,\n};\n\n","new Swiper('.image-slider__swiper', {\n    loop: true,\n    slidesPerView: 1,\n    spaceBetween: 40,\n    navigation: {\n        nextEl: '.image-slider__next',\n        prevEl: '.image-slider__prev' +\n            '',\n    },\n    breakpoints: {\n        // when window width is <= 999px\n        1000: {\n            slidesPerView: 2,\n        }\n    }\n});","function tabs() {\n    let btn = document.getElementsByClassName('three-tabs__btn');\n    let content = document.getElementsByClassName('three-tabs__content');\n\n    if ( typeof(btn[0]) != 'undefined' && btn[0] != null && typeof(content[0]) != 'undefined' && content[0] != null) {\n        content[0].classList.add('three-tabs__content--active');\n        btn[0].classList.add('three-tabs__btn--active');\n\n        for ( let i = 0; i < btn.length; i++ ) {\n            btn[i].addEventListener( 'click', function(event) {\n                let activeTab = event.currentTarget.dataset.tab;\n                let activeContent = document.getElementsByClassName( 'three-tabs__content--active' );\n                let activeBtn = document.getElementsByClassName( 'three-tabs__btn--active' );\n\n                if( activeContent.length ) {\n                    activeContent[0].classList.remove('three-tabs__content--active');\n                    activeBtn[0].classList.remove('three-tabs__btn--active');\n                }\n\n                for ( let o = 0; o < content.length; o++ ) {\n                    if( activeTab === content[o].dataset.tab ) {\n                        content[o].classList.add('three-tabs__content--active');\n                        btn[o].classList.add('three-tabs__btn--active');\n                    }\n                }\n            });\n        }\n    }\n}\n\ntabs();","let navigation = document.getElementsByClassName('navigation');\nlet navigationHeight = navigation[0].offsetHeight;\nlet navigationOffset = navigation[0].offsetTop;\n\n$(window).scroll(function(){\n    let navigationFixed = document.getElementsByClassName('navigation__fixed');\n    let header = document.getElementsByClassName('header');\n\n    if ($(window).scrollTop() >= navigationOffset) {\n        for (let i = 0; i < navigation.length; i++) {\n            navigation[i].style.height = navigationHeight + 'px';\n            navigation[i].classList.add('navigation--active');\n        }\n    }\n\n    if ($(window).scrollTop() < navigationOffset) {\n        for (let x = 0; x < navigation.length; x++) {\n            navigation[x].style.height = 'auto';\n            navigation[x].classList.remove('navigation--active');\n        }\n    }\n});\n\n\n// Function to disable menu-item which has childrens\ndocument.addEventListener('DOMContentLoaded', () => {\n\n\tconst mediaQuery = window.matchMedia('(min-width: 1299px)')\n\n\t// Clickhandler which disabled function of a href\n\tconst clickHandler = (event) => {\n\t\tevent.preventDefault();\n\t}\n\n\t// Target all menu-items which have a sub-menu child\n\tconst navItemsWithSubmenu = document.querySelectorAll('.menu-item-has-children');\n\t\n\t// Looping trough all said menu-items\n\tfor (let i = 0; i < navItemsWithSubmenu.length; i++) {\n\n\t\t// Define current item\n\t\tlet navItemWithSubmenu = navItemsWithSubmenu[i];\n\n\t\t// Get height of current item\n\t\tconst navItemWithSubmenuHeight = navItemWithSubmenu.offsetHeight;\n\t\t\n\t\t// Get current item link\n\t\tconst navItemSubmenuLink = navItemWithSubmenu.querySelector('a');\n\n\t\t// Add the clickHandler\n\t\tnavItemSubmenuLink.addEventListener('click', clickHandler, false);\n\n\t\t// Get current item submenu\n\t\tconst navItemSubmenu = navItemWithSubmenu.querySelector('ul');\n\n\t\tif(mediaQuery.matches) {\n\t\t\t// Set margin top on submenu\n\t\t\tnavItemSubmenu.style.marginTop = `${navItemWithSubmenuHeight - 5}` + \"px\";\n\t\t}\n\t}\n});\n","let sectionField = $('.product-list__materials');\nlet enterField = $('.product-list__materials .product-table .product-table__row-item');\nlet body = $('body');\n\nif ( typeof(sectionField[0]) != 'undefined' && sectionField[0] != null && window.innerWidth > 768 ) {\n\n    body[0].classList.add('material-hover-active');\n\n    /*\n    set all variables\n    */\n    let mouseFollow = $('.product-list__materials .mouse-hover');\n    let mouseHoverSrc = $('.product-list__materials .mouse-hover__image img');\n\n    document.body.addEventListener('mousemove', function(e) {\n\n        mouseFollow[0].style.left = ( e.clientX + 24 ) + \"px\";\n        mouseFollow[0].style.top = ( e.clientY + window.pageYOffset ) + \"px\";\n\n    });\n\n    for (let x = 0; x < enterField.length; x++) {\n        enterField[x].addEventListener('mouseenter', function() {\n            let imageSrc = this.querySelector('.product-table__product').getAttribute('data-image-src');\n            mouseHoverSrc.attr('src', imageSrc);\n            mouseFollow[0].classList.add('mouse-hover__active');\n        });\n\n        enterField[x].addEventListener('mouseleave', function() {\n            mouseFollow[0].classList.remove('mouse-hover__active');\n        });\n    }\n\n}","if (document.documentMode || /Edge/.test(navigator.userAgent)) {\n    jQuery('.object-fit img').each(function(){\n        var t = jQuery(this),\n            s = 'url(' + t.attr('src') + ')',\n            p = t.parent(),\n            d = jQuery('<div class=\"ie-image\"></div>');\n        p.append(d);\n\t\tvar bgSize = 'cover';\n\t\tif (p.hasClass('object-fit--contain')) {\n\t\t\tbgSize = 'contain';\n\t\t}\n        d.css({\n            'position'       \t\t: 'absolute',\n            'top'       \t\t\t: '0',\n            'left'       \t\t\t: '0',\n            'height'                : '100%',\n            'width'                 : '100%',\n            'background-size'       : bgSize,\n            'background-repeat'     : 'no-repeat',\n            'background-position'   : '50% 20%',\n            'background-image'      : s,\n        });\n\n        t.hide();\n    });\n}\n","import mixitup from 'mixitup';\nimport mixitupMultifilter from '../../js/important/mixitup-multifilter.min';\n\nlet containerEl = document.querySelector(\"#mixitup_container\");\n\nif ( typeof(containerEl) != 'undefined' && containerEl != null ) {\n\n    mixitup.use(mixitupMultifilter);\n\n    let filterSelectZero = document.querySelector('select#FilterSelect_0');\n    let filterSelectOne = document.querySelector('select#FilterSelect_1');\n\n    let courseFilter = mixitup(containerEl, {\n        animation: {\n            enable: false\n        },\n        multifilter: {\n            enable: true\n        }\n    });\n\n    filterSelectZero.addEventListener('change', function() {\n        courseFilter.filter(this.value);\n    });\n\n    filterSelectOne.addEventListener('change', function() {\n        courseFilter.filter(this.value);\n    });\n\n}\n","// This is the bottle neck for the application all sass and js files will be loaded through this file.\n// config file is for webpack.\nimport config from '@/config';\nimport '../scss/main.scss';\n\n// Load JS files from the components directory\nimport './components/swiper-sliders';\nimport './components/tabs';\nimport './components/fixed-navigation';\nimport './components/table-hover';\nimport './components/mixitup';\n\nimport './important/object-fit.js';\n\n// import './important/lazyload.js';\n// import './optional/swiper.js';\n\n\ndocument.addEventListener('DOMContentLoaded', function () {\n    function mobileMenu() {\n        const toggle = document.querySelectorAll( '.mobile-toggle' );\n        const nav = document.querySelector( '.menu' );\n        const body = document.querySelector( 'body' );\n\n        toggle[0].addEventListener( 'click', function()  {\n            nav.classList.toggle( 'menu--active' );\n            body.classList.toggle( 'menu--active' );\n        });\n    }\n\n    mobileMenu();\n\n\n    function YtOverlay() {\n        const overlay = document.querySelectorAll( '.img-overlay' );\n\n        for ( let i = 0; i < overlay.length; i++ ) {\n            overlay[i].addEventListener( 'click', function() {\n               this.classList.toggle( 'img-overlay--hidden' );\n\n               const iframe = document.getElementsByTagName( \"iframe\" )[i];\n               iframe.src += \"?autoplay=1\";\n            });\n        }\n    }\n\n    YtOverlay();\n});\n"],"sourceRoot":""}