{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/bootstrap/js/dist/dom/data.js","webpack:///./node_modules/bootstrap/js/dist/dom/selector-engine.js","webpack:///./node_modules/bootstrap/js/dist/base-component.js","webpack:///./node_modules/vue-loader/lib/runtime/componentNormalizer.js","webpack:///./node_modules/bootstrap/js/dist/dom/manipulator.js","webpack:///./node_modules/vue/dist/vue.esm.js","webpack:///(webpack)/buildin/global.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/bootstrap/js/dist/collapse.js","webpack:///./node_modules/timers-browserify/main.js","webpack:///./node_modules/setimmediate/setImmediate.js","webpack:///./app/javascript/components/home/_faq.vue?3f6d","webpack:///./app/javascript/components/home/_faq.vue?6097","webpack:///./app/javascript/components/home/_faq.vue","webpack:///./app/javascript/components/home/_faq.vue?ce11","webpack:///./app/javascript/packs/home/faq.js","webpack:///./node_modules/bootstrap/js/dist/dom/event-handler.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","elementMap","Map","element","instance","has","set","instanceMap","size","console","error","Array","from","keys","delete","factory","isElement","obj","jquery","nodeType","isVisible","getClientRects","length","getComputedStyle","getPropertyValue","isDisabled","Node","ELEMENT_NODE","classList","contains","disabled","hasAttribute","getAttribute","NODE_TEXT","find","selector","document","documentElement","concat","Element","querySelectorAll","findOne","querySelector","children","filter","child","matches","parents","ancestor","parentNode","push","previous","previousElementSibling","next","nextElementSibling","focusables","map","join","this","el","Data","EventHandler","_interopDefaultLegacy","e","Data__default","EventHandler__default","MILLISECONDS_MULTIPLIER","TRANSITION_END","getTransitionDurationFromElement","transitionDuration","transitionDelay","window","floatTransitionDuration","Number","parseFloat","floatTransitionDelay","split","triggerTransitionEnd","dispatchEvent","Event","getElement","execute","callback","executeAfterTransition","transitionElement","waitForTransition","durationPadding","emulatedDuration","called","handler","target","removeEventListener","addEventListener","setTimeout","VERSION","BaseComponent","_element","constructor","DATA_KEY","remove","off","EVENT_KEY","getOwnPropertyNames","forEach","propertyName","isAnimated","config","getInstance","Error","NAME","normalizeComponent","scriptExports","render","staticRenderFns","functionalTemplate","injectStyles","scopeId","moduleIdentifier","shadowMode","hook","options","_compiled","functional","_scopeId","context","$vnode","ssrContext","parent","__VUE_SSR_CONTEXT__","_registeredComponents","add","_ssrRegister","$root","$options","shadowRoot","_injectStyles","originalRender","h","existing","beforeCreate","normalizeData","val","toString","normalizeDataKey","replace","chr","toLowerCase","setAttribute","removeAttribute","attributes","dataset","startsWith","pureKey","charAt","slice","getDataAttribute","rect","getBoundingClientRect","top","pageYOffset","left","pageXOffset","position","offsetTop","offsetLeft","emptyObject","freeze","isUndef","v","undefined","isDef","isTrue","isPrimitive","isObject","_toString","isPlainObject","isRegExp","isValidArrayIndex","String","Math","floor","isFinite","isPromise","then","catch","isArray","JSON","stringify","toNumber","isNaN","makeMap","str","expectsLowerCase","list","isBuiltInTag","isReservedAttribute","arr","item","index","indexOf","splice","hasOwn","cached","fn","cache","camelizeRE","camelize","_","toUpperCase","capitalize","hyphenateRE","hyphenate","Function","ctx","boundFn","a","arguments","apply","_length","toArray","start","ret","extend","to","_from","toObject","res","noop","b","no","identity","looseEqual","isObjectA","isObjectB","isArrayA","isArrayB","every","Date","getTime","keysA","keysB","looseIndexOf","once","SSR_ATTR","ASSET_TYPES","LIFECYCLE_HOOKS","optionMergeStrategies","silent","productionTip","devtools","performance","errorHandler","warnHandler","ignoredElements","keyCodes","isReservedTag","isReservedAttr","isUnknownElement","getTagNamespace","parsePlatformTagName","mustUseProp","async","_lifecycleHooks","unicodeRegExp","isReserved","charCodeAt","def","writable","configurable","bailRE","RegExp","_isServer","hasProto","inBrowser","inWeex","WXEnvironment","platform","weexPlatform","UA","navigator","userAgent","isIE","test","isIE9","isEdge","isIOS","isFF","match","nativeWatch","watch","supportsPassive","opts","isServerRendering","global","env","VUE_ENV","__VUE_DEVTOOLS_GLOBAL_HOOK__","isNative","Ctor","_Set","hasSymbol","Reflect","ownKeys","Set","clear","warn","uid","Dep","id","subs","addSub","sub","removeSub","depend","addDep","notify","update","targetStack","pushTarget","popTarget","pop","VNode","tag","data","text","elm","componentOptions","asyncFactory","fnContext","fnOptions","fnScopeId","componentInstance","raw","isStatic","isRootInsert","isComment","isCloned","isOnce","asyncMeta","isAsyncPlaceholder","prototypeAccessors","defineProperties","createEmptyVNode","node","createTextVNode","cloneVNode","vnode","cloned","arrayProto","arrayMethods","method","original","args","len","inserted","result","ob","__ob__","observeArray","dep","arrayKeys","shouldObserve","toggleObserving","Observer","vmCount","src","__proto__","protoAugment","copyAugment","walk","observe","asRootData","isExtensible","_isVue","defineReactive$$1","customSetter","shallow","getOwnPropertyDescriptor","setter","childOb","dependArray","newVal","max","del","items","strats","mergeData","toVal","fromVal","mergeDataOrFn","parentVal","childVal","vm","instanceData","defaultData","mergeHook","hooks","dedupeHooks","mergeAssets","type","key$1","props","methods","inject","computed","provide","defaultStrat","mergeOptions","normalizeProps","normalized","normalizeInject","dirs","directives","def$$1","normalizeDirectives","_base","extends","mixins","mergeField","strat","resolveAsset","warnMissing","assets","camelizedId","PascalCaseId","validateProp","propOptions","propsData","prop","absent","booleanIndex","getTypeIndex","Boolean","stringIndex","default","_props","getType","getPropDefaultValue","prevShouldObserve","isSameType","expectedTypes","handleError","err","info","cur","$parent","errorCaptured","globalHandleError","invokeWithErrorHandling","_handled","logError","timerFunc","isUsingMicroTask","callbacks","pending","flushCallbacks","copies","Promise","resolve","MutationObserver","setImmediate","counter","observer","textNode","createTextNode","characterData","nextTick","cb","_resolve","seenObjects","traverse","_traverse","seen","isA","isFrozen","depId","normalizeEvent","passive","once$$1","capture","createFnInvoker","fns","invoker","arguments$1","updateListeners","on","oldOn","remove$$1","createOnceHandler","old","event","params","mergeVNodeHook","hookKey","oldHook","wrappedHook","merged","checkProp","hash","altKey","preserve","normalizeChildren","normalizeArrayChildren","isTextNode","nestedIndex","lastIndex","last","shift","_isVList","resolveInject","provideKey","source","_provided","provideDefault","resolveSlots","slots","attrs","slot","name$1","isWhitespace","normalizeScopedSlots","normalSlots","prevSlots","hasNormalSlots","isStable","$stable","$key","_normalized","$hasNormal","normalizeScopedSlot","key$2","proxyNormalSlot","proxy","renderList","iterator","done","renderSlot","fallback","bindObject","nodes","scopedSlotFn","$scopedSlots","$slots","$createElement","resolveFilter","isKeyNotMatch","expect","actual","checkKeyCodes","eventKeyCode","builtInKeyCode","eventKeyName","builtInKeyName","mappedKeyCode","bindObjectProps","asProp","isSync","loop","domProps","camelizedKey","hyphenatedKey","$event","renderStatic","isInFor","_staticTrees","tree","markStatic","_renderProxy","markOnce","markStaticNode","bindObjectListeners","ours","resolveScopedSlots","hasDynamicKeys","contentHashKey","bindDynamicKeys","baseObj","values","prependModifier","symbol","installRenderHelpers","_o","_n","_s","_l","_t","_q","_i","_m","_f","_k","_b","_v","_e","_u","_g","_d","_p","FunctionalRenderContext","contextVm","this$1","_original","isCompiled","needNormalization","listeners","injections","scopedSlots","_c","createElement","cloneAndMarkFunctionalResult","renderContext","clone","mergeProps","componentVNodeHooks","init","hydrating","_isDestroyed","keepAlive","mountedNode","prepatch","_isComponent","_parentVnode","inlineTemplate","createComponentInstanceForVnode","activeInstance","$mount","oldVnode","parentVnode","renderChildren","newScopedSlots","oldScopedSlots","hasDynamicScopedSlot","needsForceUpdate","_renderChildren","_vnode","$attrs","$listeners","propKeys","_propKeys","oldListeners","_parentListeners","updateComponentListeners","$forceUpdate","updateChildComponent","insert","_isMounted","callHook","_inactive","activatedChildren","activateChildComponent","destroy","deactivateChildComponent","$destroy","hooksToMerge","createComponent","baseCtor","cid","errorComp","resolved","owner","currentRenderingInstance","owners","loading","loadingComp","sync","timerLoading","timerTimeout","$on","forceRender","renderCompleted","clearTimeout","ensureCtor","reject","reason","component","delay","timeout","resolveAsyncComponent","createAsyncPlaceholder","resolveConstructorOptions","model","transformModel","extractPropsFromVNodeData","vnodes","createFunctionalComponent","nativeOn","abstract","toMerge","_merged","mergeHook$1","installComponentHooks","f1","f2","normalizationType","alwaysNormalize","is","simpleNormalizeChildren","pre","applyNS","style","class","registerDeepBindings","_createElement","force","comp","base","getFirstComponentChild","remove$1","$off","_target","onceHandler","setActiveInstance","prevActiveInstance","isInInactiveTree","direct","_directInactive","$children","handlers","j","_hasHookEvent","$emit","queue","waiting","flushing","currentFlushTimestamp","getNow","now","createEvent","timeStamp","flushSchedulerQueue","watcher","sort","before","run","activatedQueue","updatedQueue","callActivatedHooks","_watcher","callUpdatedHooks","emit","uid$2","Watcher","expOrFn","isRenderWatcher","_watchers","deep","user","lazy","active","dirty","deps","newDeps","depIds","newDepIds","expression","path","segments","parsePath","cleanupDeps","tmp","queueWatcher","oldValue","evaluate","teardown","_isBeingDestroyed","sharedPropertyDefinition","sourceKey","initState","propsOptions","initProps","initMethods","_data","getData","initData","watchers","_computedWatchers","isSSR","userDef","computedWatcherOptions","defineComputed","initComputed","createWatcher","initWatch","shouldCache","createComputedGetter","createGetterInvoker","$watch","uid$3","super","superOptions","modifiedOptions","modified","latest","sealed","sealedOptions","resolveModifiedOptions","extendOptions","components","Vue","_init","initExtend","Super","SuperId","cachedCtors","_Ctor","Sub","Comp","initProps$1","initComputed$1","mixin","use","getComponentName","pattern","pruneCache","keepAliveInstance","cachedNode","pruneCacheEntry","current","cached$$1","_uid","vnodeComponentOptions","_componentTag","initInternalComponent","_self","$refs","initLifecycle","_events","initEvents","parentData","initRender","initInjections","initProvide","initMixin","dataDef","propsDef","$set","$delete","immediate","stateMixin","hookRE","$once","i$1","cbs","eventsMixin","_update","prevEl","$el","prevVnode","restoreActiveInstance","__patch__","__vue__","lifecycleMixin","$nextTick","_render","ref","renderMixin","patternTypes","builtInComponents","KeepAlive","include","exclude","created","destroyed","mounted","parseInt","configDef","util","defineReactive","observable","plugin","installedPlugins","_installedPlugins","unshift","install","initUse","initMixin$1","definition","initAssetRegisters","initGlobalAPI","version","acceptValue","attr","isEnumeratedAttr","isValidContentEditableValue","isBooleanAttr","xlinkNS","isXlink","getXlinkProp","isFalsyAttrValue","genClassForVnode","childNode","mergeClassData","staticClass","dynamicClass","stringifyClass","renderClass","stringified","stringifyArray","stringifyObject","namespaceMap","svg","math","isHTMLTag","isSVG","unknownElementCache","isTextInputType","query","selected","nodeOps","tagName","multiple","createElementNS","namespace","createComment","insertBefore","newNode","referenceNode","removeChild","appendChild","nextSibling","setTextContent","textContent","setStyleScope","registerRef","isRemoval","refs","refInFor","emptyNode","sameVnode","typeA","typeB","sameInputType","createKeyToOldIdx","beginIdx","endIdx","updateDirectives","oldDir","dir","isCreate","isDestroy","oldDirs","normalizeDirectives$1","newDirs","dirsWithInsert","dirsWithPostpatch","oldArg","arg","callHook$1","componentUpdated","callInsert","emptyModifiers","modifiers","getRawDirName","rawName","baseModules","updateAttrs","inheritAttrs","oldAttrs","setAttr","removeAttributeNS","baseSetAttr","convertEnumeratedValue","setAttributeNS","__ieph","blocker","stopImmediatePropagation","updateClass","oldData","cls","transitionClass","_transitionClasses","_prevClass","index$1","expressionPos","expressionEndPos","klass","validDivisionCharRE","parseFilters","exp","prev","filters","inSingle","inDouble","inTemplateString","inRegex","curly","square","paren","lastFilterIndex","trim","pushFilter","wrapFilter","baseWarn","msg","range","pluckModuleFunction","addProp","dynamic","rangeSetItem","plain","addAttr","dynamicAttrs","addRawAttr","attrsMap","attrsList","addDirective","isDynamicArg","prependModifierMarker","addHandler","important","events","right","middle","native","nativeEvents","newHandler","getBindingAttr","getStatic","dynamicValue","getAndRemoveAttr","staticValue","removeFromMap","getAndRemoveAttrByRegex","end","genComponentModel","number","baseValueExpression","valueExpression","assignment","genAssignmentCode","lastIndexOf","eof","isStringStart","parseString","parseBracket","parseModel","inBracket","stringQuote","target$1","RANGE_TOKEN","createOnceHandler$1","remove$2","useMicrotaskFix","add$1","attachedTimestamp","_wrapper","currentTarget","ownerDocument","updateDOMListeners","change","normalizeEvents","svgContainer","updateDOMProps","oldProps","childNodes","_value","strCur","shouldUpdateValue","innerHTML","firstChild","checkVal","composing","notInFocus","activeElement","isNotInFocusAndDirty","_vModifiers","isDirtyWithModifiers","parseStyleText","cssText","propertyDelimiter","normalizeStyleData","normalizeStyleBinding","staticStyle","bindingStyle","emptyStyle","cssVarRE","importantRE","setProp","setProperty","normalizedName","normalize","vendorNames","capName","updateStyle","oldStaticStyle","oldStyleBinding","normalizedStyle","oldStyle","newStyle","checkChild","styleData","getStyle","whitespaceRE","addClass","removeClass","tar","resolveTransition","css","autoCssTransition","enterClass","enterToClass","enterActiveClass","leaveClass","leaveToClass","leaveActiveClass","hasTransition","TRANSITION","ANIMATION","transitionProp","transitionEndEvent","animationProp","animationEndEvent","ontransitionend","onwebkittransitionend","onanimationend","onwebkitanimationend","raf","requestAnimationFrame","nextFrame","addTransitionClass","transitionClasses","removeTransitionClass","whenTransitionEnds","expectedType","getTransitionInfo","propCount","ended","onEnd","transformRE","styles","transitionDelays","transitionDurations","transitionTimeout","getTimeout","animationDelays","animationDurations","animationTimeout","hasTransform","delays","durations","toMs","enter","toggleDisplay","_leaveCb","cancelled","transition","_enterCb","appearClass","appearToClass","appearActiveClass","beforeEnter","afterEnter","enterCancelled","beforeAppear","appear","afterAppear","appearCancelled","duration","transitionNode","isAppear","startClass","activeClass","toClass","beforeEnterHook","enterHook","afterEnterHook","enterCancelledHook","explicitEnterDuration","expectsCSS","userWantsControl","getHookArgumentsLength","show","pendingNode","_pending","isValidDuration","leave","rm","beforeLeave","afterLeave","leaveCancelled","delayLeave","explicitLeaveDuration","performLeave","invokerFns","_enter","patch","backend","removeNode","createElm","insertedVnodeQueue","parentElm","refElm","nested","ownerArray","isReactivated","initComponent","innerNode","activate","reactivateComponent","setScope","createChildren","invokeCreateHooks","pendingInsert","isPatchable","ref$$1","addVnodes","startIdx","invokeDestroyHook","removeVnodes","ch","removeAndInvokeRemoveHook","childElm","createRmCb","findIdxInOld","oldCh","patchVnode","removeOnly","hydrate","newCh","oldKeyToIdx","idxInOld","vnodeToMove","oldStartIdx","newStartIdx","oldEndIdx","oldStartVnode","oldEndVnode","newEndIdx","newStartVnode","newEndVnode","canMove","updateChildren","postpatch","invokeInsertHook","initial","isRenderedModule","inVPre","hasChildNodes","childrenMatch","fullInvoke","isInitialPatch","isRealElement","oldElm","patchable","i$2","createPatchFunction","vmodel","trigger","directive","binding","_vOptions","setSelected","getValue","onCompositionStart","onCompositionEnd","prevOptions","curOptions","some","hasNoMatchingOption","actuallySetSelected","isMultiple","option","selectedIndex","initEvent","locateNode","platformDirectives","transition$$1","originalDisplay","__vOriginalDisplay","display","unbind","transitionProps","getRealChild","compOptions","extractTransitionData","placeholder","rawChild","isNotTextNode","isVShowDirective","Transition","hasParentTransition","_leaving","oldRawChild","oldChild","isSameChild","delayedLeave","moveClass","callPendingCbs","_moveCb","recordPosition","newPos","applyTranslation","oldPos","pos","dx","dy","moved","transform","WebkitTransform","platformComponents","TransitionGroup","beforeMount","kept","prevChildren","rawChildren","transitionData","removed","c$1","updated","hasMove","_reflow","body","offsetHeight","_hasMove","cloneNode","HTMLUnknownElement","HTMLElement","updateComponent","mountComponent","defaultTagRE","regexEscapeRE","buildRegex","delimiters","open","close","klass$1","staticKeys","transformNode","classBinding","genData","decoder","style$1","styleBinding","he","html","isUnaryTag","canBeLeftOpenTag","isNonPhrasingTag","attribute","dynamicArgAttribute","ncname","qnameCapture","startTagOpen","startTagClose","endTag","doctype","comment","conditionalComment","isPlainTextElement","reCache","decodingMap","encodedAttr","encodedAttrWithNewLines","isIgnoreNewlineTag","shouldIgnoreFirstNewline","decodeAttr","shouldDecodeNewlines","re","warn$2","transforms","preTransforms","postTransforms","platformIsPreTag","platformMustUseProp","platformGetTagNamespace","onRE","dirRE","forAliasRE","forIteratorRE","stripParensRE","dynamicArgRE","argRE","bindRE","modifierRE","slotRE","lineBreakRE","whitespaceRE$1","decodeHTMLCached","emptySlotScopeToken","createASTElement","makeAttrsMap","rawAttrsMap","parse","template","isPreTag","root","currentParent","stack","preserveWhitespace","whitespaceOption","whitespace","inPre","closeElement","trimEndingWhitespace","processed","processElement","if","elseif","else","addIfCondition","block","forbidden","findPrevElement","slotScope","slotTarget","lastNode","lastTag","expectHTML","isUnaryTag$$1","canBeLeftOpenTag$$1","endTagLength","stackedTag","reStackedTag","rest$1","all","chars","parseEndTag","textEnd","commentEnd","shouldKeepComment","substring","advance","conditionalEnd","doctypeMatch","endTagMatch","curIndex","startTagMatch","parseStartTag","handleStartTag","rest","unarySlash","unary","shouldDecodeNewlinesForHref","lowerCasedTag","lowerCasedTagName","parseHTML","comments","outputSourceRange","start$1","ieNSBug","ieNSPrefix","guardIESVGBug","processPre","processRawAttrs","processFor","processIf","processOnce","end$1","tagRE","tokenValue","tokens","rawTokens","exec","parseText","processKey","for","checkInFor","processRef","slotTargetDynamic","getRawBindingAttr","slotBinding","getSlotName","slotBinding$1","ref$1","dynamic$1","slotContainer","processSlotContent","slotName","processComponent","syncGen","isDynamic","hasBindings","parseModifiers","camel","argMatch","processAttrs","inMatch","alias","iteratorMatch","iterator1","iterator2","parseFor","condition","ifConditions","cloneASTElement","modules$1","preTransformNode","typeBinding","ifCondition","ifConditionExtra","hasElse","elseIfCondition","branch0","branch1","branch2","isStaticKey","isPlatformReservedTag","baseOptions","_warn","code","genSelect","valueBinding","trueValueBinding","falseValueBinding","genCheckboxModel","genRadioModel","needCompositionGuard","genDefaultModel","reduce","genStaticKeys","genStaticKeysCached","optimize","markStatic$1","markStaticRoots","static","isDirectChildOfTemplateFor","l$1","staticInFor","staticRoot","fnExpRE","fnInvokeRE","simplePathRE","esc","tab","space","up","down","keyNames","genGuard","modifierCode","stop","prevent","self","ctrl","alt","meta","genHandlers","prefix","staticHandlers","dynamicHandlers","handlerCode","genHandler","isMethodPath","isFunctionExpression","isFunctionInvocation","genModifierCode","keyModifier","genFilterCode","genKeyFilter","keyVal","keyCode","keyName","baseDirectives","wrapListeners","wrapData","cloak","CodegenState","dataGenFns","maybeComponent","onceId","generate","ast","state","genElement","staticProcessed","genStatic","onceProcessed","genOnce","forProcessed","genFor","ifProcessed","genIf","genChildren","genProps","bind$$1","genSlot","componentName","genData$2","genComponent","originalPreState","altGen","altEmpty","genIfConditions","conditions","genTernaryExp","altHelper","needRuntime","hasRuntime","gen","genDirectives","containsSlotChild","needsKey","generatedSlots","genScopedSlot","inlineRenderFns","genInlineTemplate","isLegacySyntax","reverseProxy","checkSkip","altGenElement","altGenNode","el$1","normalizationType$1","needsNormalization","getNormalizationType","genNode","genComment","transformSpecialNewlines","genText","staticProps","dynamicProps","createFunction","errors","createCompileToFunctionFn","compile","compiled","fnGenErrors","baseCompile","div","finalOptions","tips","tip","compileToFunctions","getShouldDecode","href","idToTemplate","mount","outerHTML","container","getOuterHTML","g","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","marker","runClearTimeout","Item","array","title","browser","argv","versions","addListener","removeListener","removeAllListeners","prependListener","prependOnceListener","cwd","chdir","umask","Manipulator","SelectorEngine","Manipulator__default","SelectorEngine__default","BaseComponent__default","toType","getSelector","hrefAttr","includes","getSelectorFromElement","getElementFromSelector","typeCheckConfig","configTypes","valueType","TypeError","reflow","getjQuery","jQuery","DOMContentLoadedCallbacks","onDOMContentLoaded","readyState","defineJQueryPlugin","$","JQUERY_NO_CONFLICT","jQueryInterface","Constructor","noConflict","Default","toggle","DefaultType","EVENT_SHOW","EVENT_SHOWN","EVENT_HIDE","EVENT_HIDDEN","EVENT_CLICK_DATA_API","CLASS_NAME_SHOW","CLASS_NAME_COLLAPSE","CLASS_NAME_COLLAPSING","CLASS_NAME_COLLAPSED","CLASS_NAME_HORIZONTAL","WIDTH","HEIGHT","SELECTOR_ACTIVES","SELECTOR_DATA_TOGGLE","Collapse","_isTransitioning","_config","_getConfig","_triggerArray","toggleList","elem","filterElement","foundElem","_selector","_initializeChildren","_addAriaAndCollapsedClass","_isShown","hide","activesData","actives","tempActiveData","defaultPrevented","elemActive","getOrCreateInstance","dimension","_getDimension","complete","scrollSize","_queueCallback","triggerArrayLength","getDataAttributes","triggerArray","isOpen","each","delegateTarget","preventDefault","Timeout","clearFn","_id","_clearFn","scope","setInterval","clearInterval","unref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","_onTimeout","clearImmediate","registerImmediate","channel","messagePrefix","onGlobalMessage","nextHandle","tasksByHandle","currentlyRunningATask","doc","attachTo","getPrototypeOf","handle","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","canUsePostMessage","MessageChannel","port1","port2","script","onreadystatechange","random","attachEvent","task","_0x455e","_0x4c7a81","_0x4d7cd3","_0x5e5a47","_0x450ab8","_0xed2ec7","_0x4d0d9c","_0xa3e43e","_0x728b","_0x157495","_0x35970d","_0x2b7cf6","_0x4269d0","_0x108df1","_0x315a1f","_0x2a2f6a","_0x43068f","_0x3f04","_0x55aadd","_0x20e6db","_0x5bcc41","_0x284c3d","_0x3f9b3f","_0x244eaf","_0x1d78b7","_0xc70f14","_0x2eede5","_0x3d473f","_0x5339f5","_0x1bc04d","_0x27b885","_0x476ba7","_0x6e0bd3","_0x584d38","_0x1ebb1b","_0x4cd32f","_0x37bdc2","_0xfdaa3c","_0x66d45e","_0x5b4ef8","_0x3b7ce0","_0x37b7aa","_0x985ea9","_0x22c834","_0x51c687","_0x5e11aa","_0x44f811","_0x2dc27d","_0x23d4f1","_0x4680a1","_0x150ee8","_0x14a30a","_0x2864","_0xd64782","_0x525f75","_0x267a47","_0x50306d","_0x5e4cbb","_0x3d9376","_0xce68d9","_0x2b3f57","_0x507de4","_0x1426ad","_0x216f91","_0x3302a5","_0x264634","_0x387167","_0x458493","_0xc005c7","_0x5824ba","_0x288c96","_0x36a472","_0xf3e805","_0x32638c","_0x5cd5c3","_0x863d9c","_0x1e6232","_0x18f70f","_0x4a3819","_0x1cdbb5","_0x46e054","_0x587795","_0x4c4fb5","_0x24e908","_0x468cfc","_0x37e6d1","_0x57266a","_0x1a04b8","_0x1d63d7","_0x53cecc","_0x28c32b","_0x49b5fb","_0x956145","_0x4a64b8","_0x3f27ed","_0x5c0baa","_0x577c8f","_0x4b08b4","_0x1c60d1","_0xd9eb47","_0xe7b3f8","_0x489f19","_0x3be1c4","_0x1c9fd3","_0x6c5da","I18n","_0x13e8","_0x4e45","_0x2862d2","_0x5567b2","_0x20e34f","_0x17044d","_0x4f912e","_0x35b5cf","_0x32ba78","_0x40ca1f","_0x40440d","_0x4918b7","_0x54e0e1","_0x53e002","_0x39b0d6","_0x1e2786","_0x50c74c","_0x2b9ad4","_0x169c2f","_0x3a967a","_0xefac1","_0x1b4607","_0x165c17","_0x278d5c","_0xd3c80b","_0x567763","_0x1e7f31","_0x5d0344","_0x1fa230","_0x55697a","_0x4d45ff","_0x3ea3a0","_0x30f7ca","_0x1b4d1c","_0x6eb32b","_0x480999","_0x18ac49","_vm","_h","_0xd23b","_0x3c7bb6","_0x4809af","_0x2e1294","_0x1209c1","_0x134447","_0x2b96","_0x7bff68","_0xc35c5b","_0x21fdb1","_0x406334","_0x455e53","_0x433123","_0x353e1a","_0x5a31fd","_0x5e863e","_0x2e8a1c","_0x5d4dd7","_0x3820c3","_0x4ec46f","_0x324552","_0x57b550","_0x4d80de","_0x256efa","_0x314c3a","_0x47a784","_0x5b1a52","_0x2b4c39","_0x1cb637","_0x3e72c6","_0x3f65fb","_0x579984","_0x347cda","_0x29a967","_0x45c0ba","_0x35f207","_0x45e0c1","_0xd26c19","_0x480682","_0xb5fb27","_0x1d7033","_0x3fe227","_0x2c62f4","_0xa3a180","_0x469808","_0x343fad","_0x341d01","_0x110363","_0x570f2c","_0x47941d","_0x201e4f","_0x2d6678","_0x28b653","_0x7a512b","_0x30c327","_0x18559e","_0x52820d","_0x4739fb","_0x59cf41","_0x5124b8","_0xf4f081","_0x474c98","_0x450093","_0x403c7d","_0x2f11ad","_0x299487","_0x3ebd25","namespaceRegex","stripNameRegex","stripUidRegex","eventRegistry","uidEvent","customEvents","mouseenter","mouseleave","customEventsRegex","getUidEvent","getEvent","bootstrapHandler","oneOff","bootstrapDelegationHandler","domElements","findHandler","delegationSelector","uidEventList","originalHandler","normalizeParams","originalTypeEvent","delegationFn","delegation","typeEvent","getTypeEvent","wrapFn","relatedTarget","previousFn","removeHandler","removeNamespacedHandlers","storeElementEvent","handlerKey","inNamespace","isNamespace","elementEvent","keyHandlers","jQueryEvent","bubbles","nativeDispatch","evt","isPropagationStopped","isImmediatePropagationStopped","isDefaultPrevented","CustomEvent","cancelable"],"mappings":";aACE,IAAIA,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUC,QAGnC,IAAIC,EAASJ,EAAiBE,GAAY,CACzCG,EAAGH,EACHI,GAAG,EACHH,QAAS,IAUV,OANAI,EAAQL,GAAUM,KAAKJ,EAAOD,QAASC,EAAQA,EAAOD,QAASF,GAG/DG,EAAOE,GAAI,EAGJF,EAAOD,QAKfF,EAAoBQ,EAAIF,EAGxBN,EAAoBS,EAAIV,EAGxBC,EAAoBU,EAAI,SAASR,EAASS,EAAMC,GAC3CZ,EAAoBa,EAAEX,EAASS,IAClCG,OAAOC,eAAeb,EAASS,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEZ,EAAoBkB,EAAI,SAAShB,GACX,qBAAXiB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAeb,EAASiB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAeb,EAAS,aAAc,CAAEmB,OAAO,KAQvDrB,EAAoBsB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQrB,EAAoBqB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,kBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFA1B,EAAoBkB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOrB,EAAoBU,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRzB,EAAoB6B,EAAI,SAAS1B,GAChC,IAAIS,EAAST,GAAUA,EAAOqB,WAC7B,WAAwB,OAAOrB,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAH,EAAoBU,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRZ,EAAoBa,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG/B,EAAoBkC,EAAI,UAIjBlC,EAAoBA,EAAoBmC,EAAI,K,sBC5EYhC,EAAOD,QAGhE,WAAe,aAcrB,MAAMkC,EAAa,IAAIC,IA0CvB,MAzCW,CACT,IAAIC,EAASX,EAAKY,GACXH,EAAWI,IAAIF,IAClBF,EAAWK,IAAIH,EAAS,IAAID,KAG9B,MAAMK,EAAcN,EAAWnB,IAAIqB,GAG9BI,EAAYF,IAAIb,IAA6B,IAArBe,EAAYC,KAMzCD,EAAYD,IAAId,EAAKY,GAJnBK,QAAQC,MAAM,+EAA+EC,MAAMC,KAAKL,EAAYM,QAAQ,QAOhI/B,IAAG,CAACqB,EAASX,IACPS,EAAWI,IAAIF,IACVF,EAAWnB,IAAIqB,GAASrB,IAAIU,IAG9B,KAGT,OAAOW,EAASX,GACd,IAAKS,EAAWI,IAAIF,GAClB,OAGF,MAAMI,EAAcN,EAAWnB,IAAIqB,GACnCI,EAAYO,OAAOtB,GAEM,IAArBe,EAAYC,MACdP,EAAWa,OAAOX,KArDwDY,I,oBCAjB/C,EAAOD,QAGhE,WAAe,aASrB,MAAMiD,EAAYC,MACXA,GAAsB,kBAARA,KAIO,qBAAfA,EAAIC,SACbD,EAAMA,EAAI,IAGmB,qBAAjBA,EAAIE,UAGdC,EAAYjB,MACXa,EAAUb,IAAgD,IAApCA,EAAQkB,iBAAiBC,SAIgB,YAA7DC,iBAAiBpB,GAASqB,iBAAiB,cAG9CC,EAAatB,IACZA,GAAWA,EAAQgB,WAAaO,KAAKC,gBAItCxB,EAAQyB,UAAUC,SAAS,cAIC,qBAArB1B,EAAQ2B,SACV3B,EAAQ2B,SAGV3B,EAAQ4B,aAAa,aAAoD,UAArC5B,EAAQ6B,aAAa,aAS5DC,EAAY,EAgElB,MA/DuB,CACrBC,KAAI,CAACC,EAAUhC,EAAUiC,SAASC,kBACzB,GAAGC,UAAUC,QAAQ1C,UAAU2C,iBAAiBpE,KAAK+B,EAASgC,IAGvEM,QAAO,CAACN,EAAUhC,EAAUiC,SAASC,kBAC5BE,QAAQ1C,UAAU6C,cAActE,KAAK+B,EAASgC,GAGvDQ,SAAQ,CAACxC,EAASgC,IACT,GAAGG,UAAUnC,EAAQwC,UAAUC,QAAOC,GAASA,EAAMC,QAAQX,KAGtE,QAAQhC,EAASgC,GACf,MAAMY,EAAU,GAChB,IAAIC,EAAW7C,EAAQ8C,WAEvB,KAAOD,GAAYA,EAAS7B,WAAaO,KAAKC,cAAgBqB,EAAS7B,WAAac,GAC9Ee,EAASF,QAAQX,IACnBY,EAAQG,KAAKF,GAGfA,EAAWA,EAASC,WAGtB,OAAOF,GAGT,KAAK5C,EAASgC,GACZ,IAAIgB,EAAWhD,EAAQiD,uBAEvB,KAAOD,GAAU,CACf,GAAIA,EAASL,QAAQX,GACnB,MAAO,CAACgB,GAGVA,EAAWA,EAASC,uBAGtB,MAAO,IAGT,KAAKjD,EAASgC,GACZ,IAAIkB,EAAOlD,EAAQmD,mBAEnB,KAAOD,GAAM,CACX,GAAIA,EAAKP,QAAQX,GACf,MAAO,CAACkB,GAGVA,EAAOA,EAAKC,mBAGd,MAAO,IAGT,kBAAkBnD,GAChB,MAAMoD,EAAa,CAAC,IAAK,SAAU,QAAS,WAAY,SAAU,UAAW,aAAc,4BAA4BC,KAAIrB,GAAY,GAAGA,2BAAiCsB,KAAK,MAChL,OAAOC,KAAKxB,KAAKqB,EAAYpD,GAASyC,QAAOe,IAAOlC,EAAWkC,IAAOvC,EAAUuC,OAjHJ5C,I,oBCAjB/C,EAAOD,QAGhE,SAAW6F,EAAMC,GAAgB,aAEvC,SAASC,EAAuBC,GAAK,OAAOA,GAAkB,kBAANA,GAAkB,YAAaA,EAAIA,EAAI,CAAE,QAAWA,GAE5G,IAAIC,EAA6BF,EAAsBF,GACnDK,EAAqCH,EAAsBD,GAQ/D,MAAMK,EAA0B,IAC1BC,EAAiB,gBAEjBC,EAAmCjE,IACvC,IAAKA,EACH,OAAO,EAIT,IAAI,mBACFkE,EAAkB,gBAClBC,GACEC,OAAOhD,iBAAiBpB,GAC5B,MAAMqE,EAA0BC,OAAOC,WAAWL,GAC5CM,EAAuBF,OAAOC,WAAWJ,GAE/C,OAAKE,GAA4BG,GAKjCN,EAAqBA,EAAmBO,MAAM,KAAK,GACnDN,EAAkBA,EAAgBM,MAAM,KAAK,IACrCH,OAAOC,WAAWL,GAAsBI,OAAOC,WAAWJ,IAAoBJ,GAN7E,GASLW,EAAuB1E,IAC3BA,EAAQ2E,cAAc,IAAIC,MAAMZ,KAG5BnD,EAAYC,MACXA,GAAsB,kBAARA,KAIO,qBAAfA,EAAIC,SACbD,EAAMA,EAAI,IAGmB,qBAAjBA,EAAIE,UAGd6D,EAAa/D,GACbD,EAAUC,GAELA,EAAIC,OAASD,EAAI,GAAKA,EAGZ,kBAARA,GAAoBA,EAAIK,OAAS,EACnCc,SAASM,cAAczB,GAGzB,KAGHgE,EAAUC,IACU,oBAAbA,GACTA,KAIEC,EAAyB,CAACD,EAAUE,EAAmBC,GAAoB,KAC/E,IAAKA,EAEH,YADAJ,EAAQC,GAIV,MAAMI,EAAkB,EAClBC,EAAmBnB,EAAiCgB,GAAqBE,EAC/E,IAAIE,GAAS,EAEb,MAAMC,EAAU,EACdC,aAEIA,IAAWN,IAIfI,GAAS,EACTJ,EAAkBO,oBAAoBxB,EAAgBsB,GACtDR,EAAQC,KAGVE,EAAkBQ,iBAAiBzB,EAAgBsB,GACnDI,YAAW,KACJL,GACHX,EAAqBO,KAEtBG,IAeCO,EAAU,QAEhB,MAAMC,EACJ,YAAY5F,IACVA,EAAU6E,EAAW7E,MAMrBuD,KAAKsC,SAAW7F,EAChB6D,EAAuB,QAAE1D,IAAIoD,KAAKsC,SAAUtC,KAAKuC,YAAYC,SAAUxC,OAGzE,UACEM,EAAuB,QAAEmC,OAAOzC,KAAKsC,SAAUtC,KAAKuC,YAAYC,UAChEjC,EAA+B,QAAEmC,IAAI1C,KAAKsC,SAAUtC,KAAKuC,YAAYI,WACrE1H,OAAO2H,oBAAoB5C,MAAM6C,SAAQC,IACvC9C,KAAK8C,GAAgB,QAIzB,eAAetB,EAAU/E,EAASsG,GAAa,GAC7CtB,EAAuBD,EAAU/E,EAASsG,GAK5C,mBAAmBtG,GACjB,OAAO6D,EAAuB,QAAElF,IAAIkG,EAAW7E,GAAUuD,KAAKwC,UAGhE,2BAA2B/F,EAASuG,EAAS,IAC3C,OAAOhD,KAAKiD,YAAYxG,IAAY,IAAIuD,KAAKvD,EAA2B,kBAAXuG,EAAsBA,EAAS,MAG9F,qBACE,OAAOZ,EAGT,kBACE,MAAM,IAAIc,MAAM,uEAGlB,sBACE,MAAO,MAAMlD,KAAKmD,OAGpB,uBACE,MAAO,IAAInD,KAAKwC,YAKpB,OAAOH,EA7KyEhF,CAAQ,EAAQ,KAAkB,EAAQ,M,gCCA7G,SAAS+F,EACtBC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,GAGA,IAqBIC,EArBAC,EAAmC,oBAAlBT,EACjBA,EAAcS,QACdT,EAsDJ,GAnDIC,IACFQ,EAAQR,OAASA,EACjBQ,EAAQP,gBAAkBA,EAC1BO,EAAQC,WAAY,GAIlBP,IACFM,EAAQE,YAAa,GAInBN,IACFI,EAAQG,SAAW,UAAYP,GAI7BC,GACFE,EAAO,SAAUK,IAEfA,EACEA,GACClE,KAAKmE,QAAUnE,KAAKmE,OAAOC,YAC3BpE,KAAKqE,QAAUrE,KAAKqE,OAAOF,QAAUnE,KAAKqE,OAAOF,OAAOC,aAEZ,qBAAxBE,sBACrBJ,EAAUI,qBAGRb,GACFA,EAAa/I,KAAKsF,KAAMkE,GAGtBA,GAAWA,EAAQK,uBACrBL,EAAQK,sBAAsBC,IAAIb,IAKtCG,EAAQW,aAAeZ,GACdJ,IACTI,EAAOD,EACH,WACAH,EAAa/I,KACXsF,MACC8D,EAAQE,WAAahE,KAAKqE,OAASrE,MAAM0E,MAAMC,SAASC,aAG3DnB,GAGFI,EACF,GAAIC,EAAQE,WAAY,CAGtBF,EAAQe,cAAgBhB,EAExB,IAAIiB,EAAiBhB,EAAQR,OAC7BQ,EAAQR,OAAS,SAAmCyB,EAAGb,GAErD,OADAL,EAAKnJ,KAAKwJ,GACHY,EAAeC,EAAGb,QAEtB,CAEL,IAAIc,EAAWlB,EAAQmB,aACvBnB,EAAQmB,aAAeD,EACnB,GAAGpG,OAAOoG,EAAUnB,GACpB,CAACA,GAIT,MAAO,CACLxJ,QAASgJ,EACTS,QAASA,GA/Fb,mC,oBCMiExJ,EAAOD,QAGhE,WAAe,aAQrB,SAAS6K,EAAcC,GACrB,MAAY,SAARA,GAIQ,UAARA,IAIAA,IAAQpE,OAAOoE,GAAKC,WACfrE,OAAOoE,GAGJ,KAARA,GAAsB,SAARA,EACT,KAGFA,GAGT,SAASE,EAAiBvJ,GACxB,OAAOA,EAAIwJ,QAAQ,UAAUC,GAAO,IAAIA,EAAIC,kBA+C9C,MA5CoB,CAClB,iBAAiB/I,EAASX,EAAKN,GAC7BiB,EAAQgJ,aAAa,WAAWJ,EAAiBvJ,KAAQN,IAG3D,oBAAoBiB,EAASX,GAC3BW,EAAQiJ,gBAAgB,WAAWL,EAAiBvJ,OAGtD,kBAAkBW,GAChB,IAAKA,EACH,MAAO,GAGT,MAAMkJ,EAAa,GAMnB,OALA1K,OAAOkC,KAAKV,EAAQmJ,SAAS1G,QAAOpD,GAAOA,EAAI+J,WAAW,QAAOhD,SAAQ/G,IACvE,IAAIgK,EAAUhK,EAAIwJ,QAAQ,MAAO,IACjCQ,EAAUA,EAAQC,OAAO,GAAGP,cAAgBM,EAAQE,MAAM,EAAGF,EAAQlI,QACrE+H,EAAWG,GAAWZ,EAAczI,EAAQmJ,QAAQ9J,OAE/C6J,GAGTM,iBAAgB,CAACxJ,EAASX,IACjBoJ,EAAczI,EAAQ6B,aAAa,WAAW+G,EAAiBvJ,OAGxE,OAAOW,GACL,MAAMyJ,EAAOzJ,EAAQ0J,wBACrB,MAAO,CACLC,IAAKF,EAAKE,IAAMvF,OAAOwF,YACvBC,KAAMJ,EAAKI,KAAOzF,OAAO0F,cAI7BC,SAAS/J,IACA,CACL2J,IAAK3J,EAAQgK,UACbH,KAAM7J,EAAQiK,cAzE4DrJ,I,gCCNlF,qBAOA,IAAIsJ,EAAc1L,OAAO2L,OAAO,IAIhC,SAASC,EAASC,GAChB,YAAaC,IAAND,GAAyB,OAANA,EAG5B,SAASE,EAAOF,GACd,YAAaC,IAAND,GAAyB,OAANA,EAG5B,SAASG,EAAQH,GACf,OAAa,IAANA,EAUT,SAASI,EAAa1L,GACpB,MACmB,kBAAVA,GACU,kBAAVA,GAEU,kBAAVA,GACU,mBAAVA,EASX,SAAS2L,EAAU5J,GACjB,OAAe,OAARA,GAA+B,kBAARA,EAMhC,IAAI6J,EAAYnM,OAAOkB,UAAUiJ,SAUjC,SAASiC,EAAe9J,GACtB,MAA+B,oBAAxB6J,EAAU1M,KAAK6C,GAGxB,SAAS+J,EAAUR,GACjB,MAA6B,oBAAtBM,EAAU1M,KAAKoM,GAMxB,SAASS,EAAmBpC,GAC1B,IAAInJ,EAAIgF,WAAWwG,OAAOrC,IAC1B,OAAOnJ,GAAK,GAAKyL,KAAKC,MAAM1L,KAAOA,GAAK2L,SAASxC,GAGnD,SAASyC,EAAWzC,GAClB,OACE6B,EAAM7B,IACc,oBAAbA,EAAI0C,MACU,oBAAd1C,EAAI2C,MAOf,SAAS1C,EAAUD,GACjB,OAAc,MAAPA,EACH,GACAlI,MAAM8K,QAAQ5C,IAASkC,EAAclC,IAAQA,EAAIC,WAAagC,EAC5DY,KAAKC,UAAU9C,EAAK,KAAM,GAC1BqC,OAAOrC,GAOf,SAAS+C,EAAU/C,GACjB,IAAInJ,EAAIgF,WAAWmE,GACnB,OAAOgD,MAAMnM,GAAKmJ,EAAMnJ,EAO1B,SAASoM,EACPC,EACAC,GAIA,IAFA,IAAIxI,EAAM7E,OAAOY,OAAO,MACpB0M,EAAOF,EAAInH,MAAM,KACZ3G,EAAI,EAAGA,EAAIgO,EAAK3K,OAAQrD,IAC/BuF,EAAIyI,EAAKhO,KAAM,EAEjB,OAAO+N,EACH,SAAUnD,GAAO,OAAOrF,EAAIqF,EAAIK,gBAChC,SAAUL,GAAO,OAAOrF,EAAIqF,IAMlC,IAAIqD,EAAeJ,EAAQ,kBAAkB,GAKzCK,EAAsBL,EAAQ,8BAKlC,SAAS3F,EAAQiG,EAAKC,GACpB,GAAID,EAAI9K,OAAQ,CACd,IAAIgL,EAAQF,EAAIG,QAAQF,GACxB,GAAIC,GAAS,EACX,OAAOF,EAAII,OAAOF,EAAO,IAQ/B,IAAIxM,EAAiBnB,OAAOkB,UAAUC,eACtC,SAAS2M,EAAQxL,EAAKzB,GACpB,OAAOM,EAAe1B,KAAK6C,EAAKzB,GAMlC,SAASkN,EAAQC,GACf,IAAIC,EAAQjO,OAAOY,OAAO,MAC1B,OAAO,SAAoBwM,GAEzB,OADUa,EAAMb,KACDa,EAAMb,GAAOY,EAAGZ,KAOnC,IAAIc,EAAa,SACbC,EAAWJ,GAAO,SAAUX,GAC9B,OAAOA,EAAI/C,QAAQ6D,GAAY,SAAUE,EAAGzO,GAAK,OAAOA,EAAIA,EAAE0O,cAAgB,SAM5EC,EAAaP,GAAO,SAAUX,GAChC,OAAOA,EAAItC,OAAO,GAAGuD,cAAgBjB,EAAIrC,MAAM,MAM7CwD,EAAc,aACdC,EAAYT,GAAO,SAAUX,GAC/B,OAAOA,EAAI/C,QAAQkE,EAAa,OAAOhE,iBA8BzC,IAAIzJ,EAAO2N,SAASvN,UAAUJ,KAJ9B,SAAqBkN,EAAIU,GACvB,OAAOV,EAAGlN,KAAK4N,IAfjB,SAAuBV,EAAIU,GACzB,SAASC,EAASC,GAChB,IAAIrP,EAAIsP,UAAUlM,OAClB,OAAOpD,EACHA,EAAI,EACFyO,EAAGc,MAAMJ,EAAKG,WACdb,EAAGvO,KAAKiP,EAAKE,GACfZ,EAAGvO,KAAKiP,GAId,OADAC,EAAQI,QAAUf,EAAGrL,OACdgM,GAcT,SAASK,EAAS1B,EAAM2B,GACtBA,EAAQA,GAAS,EAGjB,IAFA,IAAI3P,EAAIgO,EAAK3K,OAASsM,EAClBC,EAAM,IAAIlN,MAAM1C,GACbA,KACL4P,EAAI5P,GAAKgO,EAAKhO,EAAI2P,GAEpB,OAAOC,EAMT,SAASC,EAAQC,EAAIC,GACnB,IAAK,IAAIxO,KAAOwO,EACdD,EAAGvO,GAAOwO,EAAMxO,GAElB,OAAOuO,EAMT,SAASE,EAAU7B,GAEjB,IADA,IAAI8B,EAAM,GACDjQ,EAAI,EAAGA,EAAImO,EAAI9K,OAAQrD,IAC1BmO,EAAInO,IACN6P,EAAOI,EAAK9B,EAAInO,IAGpB,OAAOiQ,EAUT,SAASC,EAAMZ,EAAGa,EAAG9P,IAKrB,IAAI+P,EAAK,SAAUd,EAAGa,EAAG9P,GAAK,OAAO,GAOjCgQ,EAAW,SAAUvB,GAAK,OAAOA,GAerC,SAASwB,EAAYhB,EAAGa,GACtB,GAAIb,IAAMa,EAAK,OAAO,EACtB,IAAII,EAAY3D,EAAS0C,GACrBkB,EAAY5D,EAASuD,GACzB,IAAII,IAAaC,EAwBV,OAAKD,IAAcC,GACjBvD,OAAOqC,KAAOrC,OAAOkD,GAxB5B,IACE,IAAIM,EAAW/N,MAAM8K,QAAQ8B,GACzBoB,EAAWhO,MAAM8K,QAAQ2C,GAC7B,GAAIM,GAAYC,EACd,OAAOpB,EAAEjM,SAAW8M,EAAE9M,QAAUiM,EAAEqB,OAAM,SAAU7K,EAAG9F,GACnD,OAAOsQ,EAAWxK,EAAGqK,EAAEnQ,OAEpB,GAAIsP,aAAasB,MAAQT,aAAaS,KAC3C,OAAOtB,EAAEuB,YAAcV,EAAEU,UACpB,GAAKJ,GAAaC,EAQvB,OAAO,EAPP,IAAII,EAAQpQ,OAAOkC,KAAK0M,GACpByB,EAAQrQ,OAAOkC,KAAKuN,GACxB,OAAOW,EAAMzN,SAAW0N,EAAM1N,QAAUyN,EAAMH,OAAM,SAAUpP,GAC5D,OAAO+O,EAAWhB,EAAE/N,GAAM4O,EAAE5O,OAMhC,MAAOuE,GAEP,OAAO,GAcb,SAASkL,EAAc7C,EAAKvD,GAC1B,IAAK,IAAI5K,EAAI,EAAGA,EAAImO,EAAI9K,OAAQrD,IAC9B,GAAIsQ,EAAWnC,EAAInO,GAAI4K,GAAQ,OAAO5K,EAExC,OAAQ,EAMV,SAASiR,EAAMvC,GACb,IAAInH,GAAS,EACb,OAAO,WACAA,IACHA,GAAS,EACTmH,EAAGc,MAAM/J,KAAM8J,aAKrB,IAAI2B,EAAW,uBAEXC,EAAc,CAChB,YACA,YACA,UAGEC,EAAkB,CACpB,eACA,UACA,cACA,UACA,eACA,UACA,gBACA,YACA,YACA,cACA,gBACA,kBAOE3I,EAAS,CAKX4I,sBAAuB3Q,OAAOY,OAAO,MAKrCgQ,QAAQ,EAKRC,eAAe,EAKfC,UAAU,EAKVC,aAAa,EAKbC,aAAc,KAKdC,YAAa,KAKbC,gBAAiB,GAMjBC,SAAUnR,OAAOY,OAAO,MAMxBwQ,cAAe1B,EAMf2B,eAAgB3B,EAMhB4B,iBAAkB5B,EAKlB6B,gBAAiB/B,EAKjBgC,qBAAsB7B,EAMtB8B,YAAa/B,EAMbgC,OAAO,EAKPC,gBAAiBjB,GAUfkB,EAAgB,8JAKpB,SAASC,EAAYzE,GACnB,IAAIzN,GAAKyN,EAAM,IAAI0E,WAAW,GAC9B,OAAa,KAANnS,GAAoB,KAANA,EAMvB,SAASoS,EAAKzP,EAAKzB,EAAKqJ,EAAKhK,GAC3BF,OAAOC,eAAeqC,EAAKzB,EAAK,CAC9BN,MAAO2J,EACPhK,aAAcA,EACd8R,UAAU,EACVC,cAAc,IAOlB,IAAIC,EAAS,IAAIC,OAAQ,KAAQP,EAAoB,OAAI,WAkBzD,IAmCIQ,EAnCAC,EAAW,aAAe,GAG1BC,EAA8B,qBAAX1M,OACnB2M,EAAkC,qBAAlBC,iBAAmCA,cAAcC,SACjEC,EAAeH,GAAUC,cAAcC,SAASlI,cAChDoI,EAAKL,GAAa1M,OAAOgN,UAAUC,UAAUtI,cAC7CuI,EAAOH,GAAM,eAAeI,KAAKJ,GACjCK,EAAQL,GAAMA,EAAG/E,QAAQ,YAAc,EACvCqF,GAASN,GAAMA,EAAG/E,QAAQ,SAAW,EAErCsF,IADaP,GAAMA,EAAG/E,QAAQ,WACrB+E,GAAM,uBAAuBI,KAAKJ,IAA0B,QAAjBD,GAGpDS,IAFWR,GAAM,cAAcI,KAAKJ,GACtBA,GAAM,YAAYI,KAAKJ,GAC9BA,GAAMA,EAAGS,MAAM,mBAGtBC,GAAc,GAAKC,MAEnBC,IAAkB,EACtB,GAAIjB,EACF,IACE,IAAIkB,GAAO,GACXxT,OAAOC,eAAeuT,GAAM,UAAW,CACrCrT,IAAK,WAEHoT,IAAkB,KAGtB3N,OAAOqB,iBAAiB,eAAgB,KAAMuM,IAC9C,MAAOpO,KAMX,IAAIqO,GAAoB,WAWtB,YAVkB3H,IAAdsG,IAOAA,GALGE,IAAcC,GAA4B,qBAAXmB,IAGtBA,EAAgB,SAAuC,WAAlCA,EAAgB,QAAEC,IAAIC,UAKpDxB,GAILtB,GAAWwB,GAAa1M,OAAOiO,6BAGnC,SAASC,GAAUC,GACjB,MAAuB,oBAATA,GAAuB,cAAchB,KAAKgB,EAAK5J,YAG/D,IAII6J,GAJAC,GACgB,qBAAX5T,QAA0ByT,GAASzT,SACvB,qBAAZ6T,SAA2BJ,GAASI,QAAQC,SAMnDH,GAFiB,qBAARI,KAAuBN,GAASM,KAElCA,IAGc,WACnB,SAASA,IACPrP,KAAKpD,IAAM3B,OAAOY,OAAO,MAY3B,OAVAwT,EAAIlT,UAAUQ,IAAM,SAAcb,GAChC,OAAyB,IAAlBkE,KAAKpD,IAAId,IAElBuT,EAAIlT,UAAUqI,IAAM,SAAc1I,GAChCkE,KAAKpD,IAAId,IAAO,GAElBuT,EAAIlT,UAAUmT,MAAQ,WACpBtP,KAAKpD,IAAM3B,OAAOY,OAAO,OAGpBwT,EAdW,GAoBtB,IAAIE,GAAO9E,EA8FP+E,GAAM,EAMNC,GAAM,WACRzP,KAAK0P,GAAKF,KACVxP,KAAK2P,KAAO,IAGdF,GAAItT,UAAUyT,OAAS,SAAiBC,GACtC7P,KAAK2P,KAAKnQ,KAAKqQ,IAGjBJ,GAAItT,UAAU2T,UAAY,SAAoBD,GAC5CpN,EAAOzC,KAAK2P,KAAME,IAGpBJ,GAAItT,UAAU4T,OAAS,WACjBN,GAAIzN,QACNyN,GAAIzN,OAAOgO,OAAOhQ,OAItByP,GAAItT,UAAU8T,OAAS,WAErB,IAAIN,EAAO3P,KAAK2P,KAAK3J,QAOrB,IAAK,IAAIzL,EAAI,EAAGC,EAAImV,EAAK/R,OAAQrD,EAAIC,EAAGD,IACtCoV,EAAKpV,GAAG2V,UAOZT,GAAIzN,OAAS,KACb,IAAImO,GAAc,GAElB,SAASC,GAAYpO,GACnBmO,GAAY3Q,KAAKwC,GACjByN,GAAIzN,OAASA,EAGf,SAASqO,KACPF,GAAYG,MACZb,GAAIzN,OAASmO,GAAYA,GAAYvS,OAAS,GAKhD,IAAI2S,GAAQ,SACVC,EACAC,EACAxR,EACAyR,EACAC,EACAzM,EACA0M,EACAC,GAEA7Q,KAAKwQ,IAAMA,EACXxQ,KAAKyQ,KAAOA,EACZzQ,KAAKf,SAAWA,EAChBe,KAAK0Q,KAAOA,EACZ1Q,KAAK2Q,IAAMA,EACX3Q,KAAKpE,QAAKmL,EACV/G,KAAKkE,QAAUA,EACflE,KAAK8Q,eAAY/J,EACjB/G,KAAK+Q,eAAYhK,EACjB/G,KAAKgR,eAAYjK,EACjB/G,KAAKlE,IAAM2U,GAAQA,EAAK3U,IACxBkE,KAAK4Q,iBAAmBA,EACxB5Q,KAAKiR,uBAAoBlK,EACzB/G,KAAKqE,YAAS0C,EACd/G,KAAKkR,KAAM,EACXlR,KAAKmR,UAAW,EAChBnR,KAAKoR,cAAe,EACpBpR,KAAKqR,WAAY,EACjBrR,KAAKsR,UAAW,EAChBtR,KAAKuR,QAAS,EACdvR,KAAK6Q,aAAeA,EACpB7Q,KAAKwR,eAAYzK,EACjB/G,KAAKyR,oBAAqB,GAGxBC,GAAqB,CAAEvS,MAAO,CAAE+N,cAAc,IAIlDwE,GAAmBvS,MAAM/D,IAAM,WAC7B,OAAO4E,KAAKiR,mBAGdhW,OAAO0W,iBAAkBpB,GAAMpU,UAAWuV,IAE1C,IAAIE,GAAmB,SAAUlB,QACjB,IAATA,IAAkBA,EAAO,IAE9B,IAAImB,EAAO,IAAItB,GAGf,OAFAsB,EAAKnB,KAAOA,EACZmB,EAAKR,WAAY,EACVQ,GAGT,SAASC,GAAiB3M,GACxB,OAAO,IAAIoL,QAAMxJ,OAAWA,OAAWA,EAAWS,OAAOrC,IAO3D,SAAS4M,GAAYC,GACnB,IAAIC,EAAS,IAAI1B,GACfyB,EAAMxB,IACNwB,EAAMvB,KAINuB,EAAM/S,UAAY+S,EAAM/S,SAAS+G,QACjCgM,EAAMtB,KACNsB,EAAMrB,IACNqB,EAAM9N,QACN8N,EAAMpB,iBACNoB,EAAMnB,cAWR,OATAoB,EAAOrW,GAAKoW,EAAMpW,GAClBqW,EAAOd,SAAWa,EAAMb,SACxBc,EAAOnW,IAAMkW,EAAMlW,IACnBmW,EAAOZ,UAAYW,EAAMX,UACzBY,EAAOnB,UAAYkB,EAAMlB,UACzBmB,EAAOlB,UAAYiB,EAAMjB,UACzBkB,EAAOjB,UAAYgB,EAAMhB,UACzBiB,EAAOT,UAAYQ,EAAMR,UACzBS,EAAOX,UAAW,EACXW,EAQT,IAAIC,GAAajV,MAAMd,UACnBgW,GAAelX,OAAOY,OAAOqW,IAEZ,CACnB,OACA,MACA,QACA,UACA,SACA,OACA,WAMarP,SAAQ,SAAUuP,GAE/B,IAAIC,EAAWH,GAAWE,GAC1BpF,EAAImF,GAAcC,GAAQ,WAExB,IADA,IAAIE,EAAO,GAAIC,EAAMzI,UAAUlM,OACvB2U,KAAQD,EAAMC,GAAQzI,UAAWyI,GAEzC,IAEIC,EAFAC,EAASJ,EAAStI,MAAM/J,KAAMsS,GAC9BI,EAAK1S,KAAK2S,OAEd,OAAQP,GACN,IAAK,OACL,IAAK,UACHI,EAAWF,EACX,MACF,IAAK,SACHE,EAAWF,EAAKtM,MAAM,GAM1B,OAHIwM,GAAYE,EAAGE,aAAaJ,GAEhCE,EAAGG,IAAI5C,SACAwC,QAMX,IAAIK,GAAY7X,OAAO2H,oBAAoBuP,IAMvCY,IAAgB,EAEpB,SAASC,GAAiBxX,GACxBuX,GAAgBvX,EASlB,IAAIyX,GAAW,SAAmBzX,GAChCwE,KAAKxE,MAAQA,EACbwE,KAAK6S,IAAM,IAAIpD,GACfzP,KAAKkT,QAAU,EACflG,EAAIxR,EAAO,SAAUwE,MACjB/C,MAAM8K,QAAQvM,IACZ8R,EAsCR,SAAuBtL,EAAQmR,GAE7BnR,EAAOoR,UAAYD,EAvCfE,CAAa7X,EAAO2W,IAgD1B,SAAsBnQ,EAAQmR,EAAKhW,GACjC,IAAK,IAAI5C,EAAI,EAAGC,EAAI2C,EAAKS,OAAQrD,EAAIC,EAAGD,IAAK,CAC3C,IAAIuB,EAAMqB,EAAK5C,GACfyS,EAAIhL,EAAQlG,EAAKqX,EAAIrX,KAjDnBwX,CAAY9X,EAAO2W,GAAcW,IAEnC9S,KAAK4S,aAAapX,IAElBwE,KAAKuT,KAAK/X,IAsDd,SAASgY,GAAShY,EAAOiY,GAIvB,IAAIf,EAHJ,GAAKvL,EAAS3L,MAAUA,aAAiB+U,IAkBzC,OAdIxH,EAAOvN,EAAO,WAAaA,EAAMmX,kBAAkBM,GACrDP,EAAKlX,EAAMmX,OAEXI,KACCrE,OACAzR,MAAM8K,QAAQvM,IAAU6L,EAAc7L,KACvCP,OAAOyY,aAAalY,KACnBA,EAAMmY,SAEPjB,EAAK,IAAIO,GAASzX,IAEhBiY,GAAcf,GAChBA,EAAGQ,UAEER,EAMT,SAASkB,GACPrW,EACAzB,EACAqJ,EACA0O,EACAC,GAEA,IAAIjB,EAAM,IAAIpD,GAEVvT,EAAWjB,OAAO8Y,yBAAyBxW,EAAKzB,GACpD,IAAII,IAAsC,IAA1BA,EAASgR,aAAzB,CAKA,IAAInS,EAASmB,GAAYA,EAASd,IAC9B4Y,EAAS9X,GAAYA,EAASU,IAC5B7B,IAAUiZ,GAAgC,IAArBlK,UAAUlM,SACnCuH,EAAM5H,EAAIzB,IAGZ,IAAImY,GAAWH,GAAWN,GAAQrO,GAClClK,OAAOC,eAAeqC,EAAKzB,EAAK,CAC9BX,YAAY,EACZ+R,cAAc,EACd9R,IAAK,WACH,IAAII,EAAQT,EAASA,EAAOL,KAAK6C,GAAO4H,EAUxC,OATIsK,GAAIzN,SACN6Q,EAAI9C,SACAkE,IACFA,EAAQpB,IAAI9C,SACR9S,MAAM8K,QAAQvM,IAChB0Y,GAAY1Y,KAIXA,GAEToB,IAAK,SAAyBuX,GAC5B,IAAI3Y,EAAQT,EAASA,EAAOL,KAAK6C,GAAO4H,EAEpCgP,IAAW3Y,GAAU2Y,IAAWA,GAAU3Y,IAAUA,GAQpDT,IAAWiZ,IACXA,EACFA,EAAOtZ,KAAK6C,EAAK4W,GAEjBhP,EAAMgP,EAERF,GAAWH,GAAWN,GAAQW,GAC9BtB,EAAI5C,cAUV,SAASrT,GAAKoF,EAAQlG,EAAKqJ,GAMzB,GAAIlI,MAAM8K,QAAQ/F,IAAWuF,EAAkBzL,GAG7C,OAFAkG,EAAOpE,OAAS6J,KAAK2M,IAAIpS,EAAOpE,OAAQ9B,GACxCkG,EAAO8G,OAAOhN,EAAK,EAAGqJ,GACfA,EAET,GAAIrJ,KAAOkG,KAAYlG,KAAOb,OAAOkB,WAEnC,OADA6F,EAAOlG,GAAOqJ,EACPA,EAET,IAAIuN,EAAK,EAASC,OAClB,OAAI3Q,EAAO2R,QAAWjB,GAAMA,EAAGQ,QAKtB/N,EAEJuN,GAILkB,GAAkBlB,EAAGlX,MAAOM,EAAKqJ,GACjCuN,EAAGG,IAAI5C,SACA9K,IALLnD,EAAOlG,GAAOqJ,EACPA,GAUX,SAASkP,GAAKrS,EAAQlG,GAMpB,GAAImB,MAAM8K,QAAQ/F,IAAWuF,EAAkBzL,GAC7CkG,EAAO8G,OAAOhN,EAAK,OADrB,CAIA,IAAI4W,EAAK,EAASC,OACd3Q,EAAO2R,QAAWjB,GAAMA,EAAGQ,SAO1BnK,EAAO/G,EAAQlG,YAGbkG,EAAOlG,GACT4W,GAGLA,EAAGG,IAAI5C,WAOT,SAASiE,GAAa1Y,GACpB,IAAK,IAAI6E,OAAI,EAAU9F,EAAI,EAAGC,EAAIgB,EAAMoC,OAAQrD,EAAIC,EAAGD,KACrD8F,EAAI7E,EAAMjB,KACL8F,EAAEsS,QAAUtS,EAAEsS,OAAOE,IAAI9C,SAC1B9S,MAAM8K,QAAQ1H,IAChB6T,GAAY7T,GAhNlB4S,GAAS9W,UAAUoX,KAAO,SAAehW,GAEvC,IADA,IAAIJ,EAAOlC,OAAOkC,KAAKI,GACdhD,EAAI,EAAGA,EAAI4C,EAAKS,OAAQrD,IAC/BqZ,GAAkBrW,EAAKJ,EAAK5C,KAOhC0Y,GAAS9W,UAAUyW,aAAe,SAAuB0B,GACvD,IAAK,IAAI/Z,EAAI,EAAGC,EAAI8Z,EAAM1W,OAAQrD,EAAIC,EAAGD,IACvCiZ,GAAQc,EAAM/Z,KAgNlB,IAAIga,GAASvR,EAAO4I,sBAoBpB,SAAS4I,GAAWnK,EAAInN,GACtB,IAAKA,EAAQ,OAAOmN,EAOpB,IANA,IAAIvO,EAAK2Y,EAAOC,EAEZvX,EAAO+R,GACPC,QAAQC,QAAQlS,GAChBjC,OAAOkC,KAAKD,GAEP3C,EAAI,EAAGA,EAAI4C,EAAKS,OAAQrD,IAGnB,YAFZuB,EAAMqB,EAAK5C,MAGXka,EAAQpK,EAAGvO,GACX4Y,EAAUxX,EAAKpB,GACViN,EAAOsB,EAAIvO,GAGd2Y,IAAUC,GACVrN,EAAcoN,IACdpN,EAAcqN,IAEdF,GAAUC,EAAOC,GANjB9X,GAAIyN,EAAIvO,EAAK4Y,IASjB,OAAOrK,EAMT,SAASsK,GACPC,EACAC,EACAC,GAEA,OAAKA,EAoBI,WAEL,IAAIC,EAAmC,oBAAbF,EACtBA,EAASna,KAAKoa,EAAIA,GAClBD,EACAG,EAAmC,oBAAdJ,EACrBA,EAAUla,KAAKoa,EAAIA,GACnBF,EACJ,OAAIG,EACKP,GAAUO,EAAcC,GAExBA,GA7BNH,EAGAD,EAQE,WACL,OAAOJ,GACe,oBAAbK,EAA0BA,EAASna,KAAKsF,KAAMA,MAAQ6U,EACxC,oBAAdD,EAA2BA,EAAUla,KAAKsF,KAAMA,MAAQ4U,IAV1DC,EAHAD,EA2Db,SAASK,GACPL,EACAC,GAEA,IAAIrK,EAAMqK,EACND,EACEA,EAAUhW,OAAOiW,GACjB5X,MAAM8K,QAAQ8M,GACZA,EACA,CAACA,GACLD,EACJ,OAAOpK,EAKT,SAAsB0K,GAEpB,IADA,IAAI1K,EAAM,GACDjQ,EAAI,EAAGA,EAAI2a,EAAMtX,OAAQrD,KACD,IAA3BiQ,EAAI3B,QAAQqM,EAAM3a,KACpBiQ,EAAIhL,KAAK0V,EAAM3a,IAGnB,OAAOiQ,EAXH2K,CAAY3K,GACZA,EAwBN,SAAS4K,GACPR,EACAC,EACAC,EACAhZ,GAEA,IAAI0O,EAAMvP,OAAOY,OAAO+Y,GAAa,MACrC,OAAIC,EAEKzK,EAAOI,EAAKqK,GAEZrK,EAzEX+J,GAAO9D,KAAO,SACZmE,EACAC,EACAC,GAEA,OAAKA,EAcEH,GAAcC,EAAWC,EAAUC,GAbpCD,GAAgC,oBAAbA,EAQdD,EAEFD,GAAcC,EAAWC,IAmCpClJ,EAAgB9I,SAAQ,SAAUgB,GAChC0Q,GAAO1Q,GAAQoR,MAyBjBvJ,EAAY7I,SAAQ,SAAUwS,GAC5Bd,GAAOc,EAAO,KAAOD,MASvBb,GAAOhG,MAAQ,SACbqG,EACAC,EACAC,EACAhZ,GAMA,GAHI8Y,IAActG,KAAesG,OAAY7N,GACzC8N,IAAavG,KAAeuG,OAAW9N,IAEtC8N,EAAY,OAAO5Z,OAAOY,OAAO+Y,GAAa,MAInD,IAAKA,EAAa,OAAOC,EACzB,IAAI1K,EAAM,GAEV,IAAK,IAAImL,KADTlL,EAAOD,EAAKyK,GACMC,EAAU,CAC1B,IAAIxQ,EAAS8F,EAAImL,GACbnW,EAAQ0V,EAASS,GACjBjR,IAAWpH,MAAM8K,QAAQ1D,KAC3BA,EAAS,CAACA,IAEZ8F,EAAImL,GAASjR,EACTA,EAAOzF,OAAOO,GACdlC,MAAM8K,QAAQ5I,GAASA,EAAQ,CAACA,GAEtC,OAAOgL,GAMToK,GAAOgB,MACPhB,GAAOiB,QACPjB,GAAOkB,OACPlB,GAAOmB,SAAW,SAChBd,EACAC,EACAC,EACAhZ,GAKA,IAAK8Y,EAAa,OAAOC,EACzB,IAAI1K,EAAMlP,OAAOY,OAAO,MAGxB,OAFAuO,EAAOD,EAAKyK,GACRC,GAAYzK,EAAOD,EAAK0K,GACrB1K,GAEToK,GAAOoB,QAAUhB,GAKjB,IAAIiB,GAAe,SAAUhB,EAAWC,GACtC,YAAoB9N,IAAb8N,EACHD,EACAC,GAyHN,SAASgB,GACPxR,EACAlF,EACA2V,GAkBA,GAZqB,oBAAV3V,IACTA,EAAQA,EAAM2E,SApGlB,SAAyBA,EAASgR,GAChC,IAAIS,EAAQzR,EAAQyR,MACpB,GAAKA,EAAL,CACA,IACIhb,EAAG4K,EADHqF,EAAM,GAEV,GAAIvN,MAAM8K,QAAQwN,GAEhB,IADAhb,EAAIgb,EAAM3X,OACHrD,KAEc,kBADnB4K,EAAMoQ,EAAMhb,MAGViQ,EADOpB,EAASjE,IACJ,CAAEkQ,KAAM,YAKnB,GAAIhO,EAAckO,GACvB,IAAK,IAAIzZ,KAAOyZ,EACdpQ,EAAMoQ,EAAMzZ,GAEZ0O,EADOpB,EAAStN,IACJuL,EAAclC,GACtBA,EACA,CAAEkQ,KAAMlQ,GAShBrB,EAAQyR,MAAQ/K,GAwEhBsL,CAAe3W,GAlEjB,SAA0B2E,EAASgR,GACjC,IAAIW,EAAS3R,EAAQ2R,OACrB,GAAKA,EAAL,CACA,IAAIM,EAAajS,EAAQ2R,OAAS,GAClC,GAAIxY,MAAM8K,QAAQ0N,GAChB,IAAK,IAAIlb,EAAI,EAAGA,EAAIkb,EAAO7X,OAAQrD,IACjCwb,EAAWN,EAAOlb,IAAM,CAAE2C,KAAMuY,EAAOlb,SAEpC,GAAI8M,EAAcoO,GACvB,IAAK,IAAI3Z,KAAO2Z,EAAQ,CACtB,IAAItQ,EAAMsQ,EAAO3Z,GACjBia,EAAWja,GAAOuL,EAAclC,GAC5BiF,EAAO,CAAElN,KAAMpB,GAAOqJ,GACtB,CAAEjI,KAAMiI,KAsDhB6Q,CAAgB7W,GAxClB,SAA8B2E,GAC5B,IAAImS,EAAOnS,EAAQoS,WACnB,GAAID,EACF,IAAK,IAAIna,KAAOma,EAAM,CACpB,IAAIE,EAASF,EAAKna,GACI,oBAAXqa,IACTF,EAAKna,GAAO,CAAEC,KAAMoa,EAAQjG,OAAQiG,KAmC1CC,CAAoBjX,IAMfA,EAAMkX,QACLlX,EAAMmX,UACRjS,EAASwR,GAAaxR,EAAQlF,EAAMmX,QAASxB,IAE3C3V,EAAMoX,QACR,IAAK,IAAIhc,EAAI,EAAGC,EAAI2E,EAAMoX,OAAO3Y,OAAQrD,EAAIC,EAAGD,IAC9C8J,EAASwR,GAAaxR,EAAQlF,EAAMoX,OAAOhc,GAAIua,GAKrD,IACIhZ,EADAgI,EAAU,GAEd,IAAKhI,KAAOuI,EACVmS,EAAW1a,GAEb,IAAKA,KAAOqD,EACL4J,EAAO1E,EAAQvI,IAClB0a,EAAW1a,GAGf,SAAS0a,EAAY1a,GACnB,IAAI2a,EAAQlC,GAAOzY,IAAQ8Z,GAC3B9R,EAAQhI,GAAO2a,EAAMpS,EAAOvI,GAAMqD,EAAMrD,GAAMgZ,EAAIhZ,GAEpD,OAAOgI,EAQT,SAAS4S,GACP5S,EACAuR,EACA3F,EACAiH,GAGA,GAAkB,kBAAPjH,EAAX,CAGA,IAAIkH,EAAS9S,EAAQuR,GAErB,GAAItM,EAAO6N,EAAQlH,GAAO,OAAOkH,EAAOlH,GACxC,IAAImH,EAAczN,EAASsG,GAC3B,GAAI3G,EAAO6N,EAAQC,GAAgB,OAAOD,EAAOC,GACjD,IAAIC,EAAevN,EAAWsN,GAC9B,OAAI9N,EAAO6N,EAAQE,GAAwBF,EAAOE,GAExCF,EAAOlH,IAAOkH,EAAOC,IAAgBD,EAAOE,IAcxD,SAASC,GACPjb,EACAkb,EACAC,EACAnC,GAEA,IAAIoC,EAAOF,EAAYlb,GACnBqb,GAAUpO,EAAOkO,EAAWnb,GAC5BN,EAAQyb,EAAUnb,GAElBsb,EAAeC,GAAaC,QAASJ,EAAK7B,MAC9C,GAAI+B,GAAgB,EAClB,GAAID,IAAWpO,EAAOmO,EAAM,WAC1B1b,GAAQ,OACH,GAAc,KAAVA,GAAgBA,IAAUiO,EAAU3N,GAAM,CAGnD,IAAIyb,EAAcF,GAAa7P,OAAQ0P,EAAK7B,OACxCkC,EAAc,GAAKH,EAAeG,KACpC/b,GAAQ,GAKd,QAAcuL,IAAVvL,EAAqB,CACvBA,EAqBJ,SAA8BsZ,EAAIoC,EAAMpb,GAEtC,IAAKiN,EAAOmO,EAAM,WAChB,OAEF,IAAIlK,EAAMkK,EAAKM,QAEX,EAUJ,GAAI1C,GAAMA,EAAGnQ,SAASsS,gBACWlQ,IAA/B+N,EAAGnQ,SAASsS,UAAUnb,SACHiL,IAAnB+N,EAAG2C,OAAO3b,GAEV,OAAOgZ,EAAG2C,OAAO3b,GAInB,MAAsB,oBAARkR,GAA6C,aAAvB0K,GAAQR,EAAK7B,MAC7CrI,EAAItS,KAAKoa,GACT9H,EAhDM2K,CAAoB7C,EAAIoC,EAAMpb,GAGtC,IAAI8b,EAAoB7E,GACxBC,IAAgB,GAChBQ,GAAQhY,GACRwX,GAAgB4E,GASlB,OAAOpc,EAsHT,SAASkc,GAASzO,GAChB,IAAIoF,EAAQpF,GAAMA,EAAG7D,WAAWiJ,MAAM,sBACtC,OAAOA,EAAQA,EAAM,GAAK,GAG5B,SAASwJ,GAAYhO,EAAGa,GACtB,OAAOgN,GAAQ7N,KAAO6N,GAAQhN,GAGhC,SAAS2M,GAAchC,EAAMyC,GAC3B,IAAK7a,MAAM8K,QAAQ+P,GACjB,OAAOD,GAAWC,EAAezC,GAAQ,GAAK,EAEhD,IAAK,IAAI9a,EAAI,EAAGgY,EAAMuF,EAAcla,OAAQrD,EAAIgY,EAAKhY,IACnD,GAAIsd,GAAWC,EAAcvd,GAAI8a,GAC/B,OAAO9a,EAGX,OAAQ,EAgDV,SAASwd,GAAaC,EAAKlD,EAAImD,GAG7B7H,KACA,IACE,GAAI0E,EAEF,IADA,IAAIoD,EAAMpD,EACFoD,EAAMA,EAAIC,SAAU,CAC1B,IAAIjD,EAAQgD,EAAIvT,SAASyT,cACzB,GAAIlD,EACF,IAAK,IAAI3a,EAAI,EAAGA,EAAI2a,EAAMtX,OAAQrD,IAChC,IAEE,IADoD,IAAtC2a,EAAM3a,GAAGG,KAAKwd,EAAKF,EAAKlD,EAAImD,GAC3B,OACf,MAAO5X,IACPgY,GAAkBhY,GAAG6X,EAAK,uBAMpCG,GAAkBL,EAAKlD,EAAImD,GAC3B,QACA5H,MAIJ,SAASiI,GACPvW,EACAmC,EACAoO,EACAwC,EACAmD,GAEA,IAAIzN,EACJ,KACEA,EAAM8H,EAAOvQ,EAAQgI,MAAM7F,EAASoO,GAAQvQ,EAAQrH,KAAKwJ,MAC7CsG,EAAImJ,QAAU/L,EAAU4C,KAASA,EAAI+N,WAC/C/N,EAAI1C,OAAM,SAAUzH,GAAK,OAAO0X,GAAY1X,EAAGyU,EAAImD,EAAO,uBAG1DzN,EAAI+N,UAAW,GAEjB,MAAOlY,IACP0X,GAAY1X,GAAGyU,EAAImD,GAErB,OAAOzN,EAGT,SAAS6N,GAAmBL,EAAKlD,EAAImD,GACnC,GAAIjV,EAAOiJ,aACT,IACE,OAAOjJ,EAAOiJ,aAAavR,KAAK,KAAMsd,EAAKlD,EAAImD,GAC/C,MAAO5X,IAGHA,KAAM2X,GACRQ,GAASnY,GAAG,KAAM,uBAIxBmY,GAASR,EAAKlD,EAAImD,GAGpB,SAASO,GAAUR,EAAKlD,EAAImD,GAK1B,IAAK1K,IAAaC,GAA8B,qBAAZzQ,QAGlC,MAAMib,EAFNjb,QAAQC,MAAMgb,GAQlB,IAyBIS,GAzBAC,IAAmB,EAEnBC,GAAY,GACZC,IAAU,EAEd,SAASC,KACPD,IAAU,EACV,IAAIE,EAASH,GAAU3S,MAAM,GAC7B2S,GAAU/a,OAAS,EACnB,IAAK,IAAIrD,EAAI,EAAGA,EAAIue,EAAOlb,OAAQrD,IACjCue,EAAOve,KAwBX,GAAuB,qBAAZwe,SAA2BhK,GAASgK,SAAU,CACvD,IAAI1c,GAAI0c,QAAQC,UAChBP,GAAY,WACVpc,GAAEwL,KAAKgR,IAMH1K,IAAShM,WAAWsI,IAE1BiO,IAAmB,OACd,GAAK3K,GAAoC,qBAArBkL,mBACzBlK,GAASkK,mBAEuB,yCAAhCA,iBAAiB7T,WAoBjBqT,GAJiC,qBAAjBS,GAAgCnK,GAASmK,GAI7C,WACVA,EAAaL,KAIH,WACV1W,WAAW0W,GAAgB,QAzB5B,CAID,IAAIM,GAAU,EACVC,GAAW,IAAIH,iBAAiBJ,IAChCQ,GAAW3a,SAAS4a,eAAe9R,OAAO2R,KAC9CC,GAAS5F,QAAQ6F,GAAU,CACzBE,eAAe,IAEjBd,GAAY,WACVU,IAAWA,GAAU,GAAK,EAC1BE,GAAS5I,KAAOjJ,OAAO2R,KAEzBT,IAAmB,EAerB,SAASc,GAAUC,EAAI9P,GACrB,IAAI+P,EAiBJ,GAhBAf,GAAUnZ,MAAK,WACb,GAAIia,EACF,IACEA,EAAG/e,KAAKiP,GACR,MAAOtJ,IACP0X,GAAY1X,GAAGsJ,EAAK,iBAEb+P,GACTA,EAAS/P,MAGRiP,KACHA,IAAU,EACVH,OAGGgB,GAAyB,qBAAZV,QAChB,OAAO,IAAIA,SAAQ,SAAUC,GAC3BU,EAAWV,KAwHjB,IAAIW,GAAc,IAAI1K,GAOtB,SAAS2K,GAAUzU,GACjB0U,GAAU1U,EAAKwU,IACfA,GAAYrK,QAGd,SAASuK,GAAW1U,EAAK2U,GACvB,IAAIvf,EAAG4C,EACH4c,EAAM9c,MAAM8K,QAAQ5C,GACxB,MAAM4U,IAAQ5S,EAAShC,IAASlK,OAAO+e,SAAS7U,IAAQA,aAAeoL,IAAvE,CAGA,GAAIpL,EAAIwN,OAAQ,CACd,IAAIsH,EAAQ9U,EAAIwN,OAAOE,IAAInD,GAC3B,GAAIoK,EAAKnd,IAAIsd,GACX,OAEFH,EAAKtV,IAAIyV,GAEX,GAAIF,EAEF,IADAxf,EAAI4K,EAAIvH,OACDrD,KAAOsf,GAAU1U,EAAI5K,GAAIuf,QAIhC,IADAvf,GADA4C,EAAOlC,OAAOkC,KAAKgI,IACVvH,OACFrD,KAAOsf,GAAU1U,EAAIhI,EAAK5C,IAAKuf,IAM1C,IAAII,GAAiBlR,GAAO,SAAUlO,GACpC,IAAIqf,EAA6B,MAAnBrf,EAAKiL,OAAO,GAEtBqU,EAA6B,OADjCtf,EAAOqf,EAAUrf,EAAKkL,MAAM,GAAKlL,GACdiL,OAAO,GAEtBsU,EAA6B,OADjCvf,EAAOsf,EAAUtf,EAAKkL,MAAM,GAAKlL,GACdiL,OAAO,GAE1B,MAAO,CACLjL,KAFFA,EAAOuf,EAAUvf,EAAKkL,MAAM,GAAKlL,EAG/B0Q,KAAM4O,EACNC,QAASA,EACTF,QAASA,MAIb,SAASG,GAAiBC,EAAKzF,GAC7B,SAAS0F,IACP,IAAIC,EAAc3Q,UAEdyQ,EAAMC,EAAQD,IAClB,IAAItd,MAAM8K,QAAQwS,GAOhB,OAAOjC,GAAwBiC,EAAK,KAAMzQ,UAAWgL,EAAI,gBALzD,IADA,IAAI7C,EAASsI,EAAIvU,QACRzL,EAAI,EAAGA,EAAI0X,EAAOrU,OAAQrD,IACjC+d,GAAwBrG,EAAO1X,GAAI,KAAMkgB,EAAa3F,EAAI,gBAQhE,OADA0F,EAAQD,IAAMA,EACPC,EAGT,SAASE,GACPC,EACAC,EACApW,EACAqW,EACAC,EACAhG,GAEA,IAAIha,EAAcod,EAAK6C,EAAKC,EAC5B,IAAKlgB,KAAQ6f,EACFzC,EAAMyC,EAAG7f,GAClBigB,EAAMH,EAAM9f,GACZkgB,EAAQd,GAAepf,GACnB+L,EAAQqR,KAKDrR,EAAQkU,IACblU,EAAQqR,EAAIqC,OACdrC,EAAMyC,EAAG7f,GAAQwf,GAAgBpC,EAAKpD,IAEpC7N,EAAO+T,EAAMxP,QACf0M,EAAMyC,EAAG7f,GAAQggB,EAAkBE,EAAMlgB,KAAMod,EAAK8C,EAAMX,UAE5D7V,EAAIwW,EAAMlgB,KAAMod,EAAK8C,EAAMX,QAASW,EAAMb,QAASa,EAAMC,SAChD/C,IAAQ6C,IACjBA,EAAIR,IAAMrC,EACVyC,EAAG7f,GAAQigB,IAGf,IAAKjgB,KAAQ8f,EACP/T,EAAQ8T,EAAG7f,KAEb+f,GADAG,EAAQd,GAAepf,IACPA,KAAM8f,EAAM9f,GAAOkgB,EAAMX,SAO/C,SAASa,GAAgBlO,EAAKmO,EAAStX,GAIrC,IAAI2W,EAHAxN,aAAeuD,KACjBvD,EAAMA,EAAIyD,KAAK5M,OAASmJ,EAAIyD,KAAK5M,KAAO,KAG1C,IAAIuX,EAAUpO,EAAImO,GAElB,SAASE,IACPxX,EAAKkG,MAAM/J,KAAM8J,WAGjBrH,EAAO+X,EAAQD,IAAKc,GAGlBxU,EAAQuU,GAEVZ,EAAUF,GAAgB,CAACe,IAGvBrU,EAAMoU,EAAQb,MAAQtT,EAAOmU,EAAQE,SAEvCd,EAAUY,GACFb,IAAI/a,KAAK6b,GAGjBb,EAAUF,GAAgB,CAACc,EAASC,IAIxCb,EAAQc,QAAS,EACjBtO,EAAImO,GAAWX,EA8CjB,SAASe,GACP/Q,EACAgR,EACA1f,EACA2f,EACAC,GAEA,GAAI1U,EAAMwU,GAAO,CACf,GAAIzS,EAAOyS,EAAM1f,GAKf,OAJA0O,EAAI1O,GAAO0f,EAAK1f,GACX4f,UACIF,EAAK1f,IAEP,EACF,GAAIiN,EAAOyS,EAAMC,GAKtB,OAJAjR,EAAI1O,GAAO0f,EAAKC,GACXC,UACIF,EAAKC,IAEP,EAGX,OAAO,EA8BT,SAASE,GAAmB1c,GAC1B,OAAOiI,EAAYjI,GACf,CAAC6S,GAAgB7S,IACjBhC,MAAM8K,QAAQ9I,GACZ2c,GAAuB3c,QACvB8H,EAGR,SAAS8U,GAAYhK,GACnB,OAAO7K,EAAM6K,IAAS7K,EAAM6K,EAAKnB,QA5yEpB,IA4yEqCmB,EAAKR,UAGzD,SAASuK,GAAwB3c,EAAU6c,GACzC,IACIvhB,EAAGK,EAAGmhB,EAAWC,EADjBxR,EAAM,GAEV,IAAKjQ,EAAI,EAAGA,EAAI0E,EAASrB,OAAQrD,IAE3BsM,EADJjM,EAAIqE,EAAS1E,KACkB,mBAANK,IAEzBohB,EAAOxR,EADPuR,EAAYvR,EAAI5M,OAAS,GAGrBX,MAAM8K,QAAQnN,GACZA,EAAEgD,OAAS,IAGTie,IAFJjhB,EAAIghB,GAAuBhhB,GAAKkhB,GAAe,IAAM,IAAMvhB,IAE1C,KAAOshB,GAAWG,KACjCxR,EAAIuR,GAAajK,GAAgBkK,EAAKtL,KAAQ9V,EAAE,GAAI8V,MACpD9V,EAAEqhB,SAEJzR,EAAIhL,KAAKuK,MAAMS,EAAK5P,IAEbsM,EAAYtM,GACjBihB,GAAWG,GAIbxR,EAAIuR,GAAajK,GAAgBkK,EAAKtL,KAAO9V,GAC9B,KAANA,GAET4P,EAAIhL,KAAKsS,GAAgBlX,IAGvBihB,GAAWjhB,IAAMihB,GAAWG,GAE9BxR,EAAIuR,GAAajK,GAAgBkK,EAAKtL,KAAO9V,EAAE8V,OAG3CzJ,EAAOhI,EAASid,WAClBlV,EAAMpM,EAAE4V,MACR3J,EAAQjM,EAAEkB,MACVkL,EAAM8U,KACNlhB,EAAEkB,IAAM,UAAYggB,EAAc,IAAMvhB,EAAI,MAE9CiQ,EAAIhL,KAAK5E,KAIf,OAAO4P,EAqCT,SAAS2R,GAAe1G,EAAQX,GAC9B,GAAIW,EAAQ,CAOV,IALA,IAAIhD,EAASxX,OAAOY,OAAO,MACvBsB,EAAO+R,GACPC,QAAQC,QAAQqG,GAChBxa,OAAOkC,KAAKsY,GAEPlb,EAAI,EAAGA,EAAI4C,EAAKS,OAAQrD,IAAK,CACpC,IAAIuB,EAAMqB,EAAK5C,GAEf,GAAY,WAARuB,EAAJ,CAGA,IAFA,IAAIsgB,EAAa3G,EAAO3Z,GAAKoB,KACzBmf,EAASvH,EACNuH,GAAQ,CACb,GAAIA,EAAOC,WAAavT,EAAOsT,EAAOC,UAAWF,GAAa,CAC5D3J,EAAO3W,GAAOugB,EAAOC,UAAUF,GAC/B,MAEFC,EAASA,EAAOlE,QAElB,IAAKkE,EACH,GAAI,YAAa5G,EAAO3Z,GAAM,CAC5B,IAAIygB,EAAiB9G,EAAO3Z,GAAK0b,QACjC/E,EAAO3W,GAAiC,oBAAnBygB,EACjBA,EAAe7hB,KAAKoa,GACpByH,OACK,GAKf,OAAO9J,GAWX,SAAS+J,GACPvd,EACAiF,GAEA,IAAKjF,IAAaA,EAASrB,OACzB,MAAO,GAGT,IADA,IAAI6e,EAAQ,GACHliB,EAAI,EAAGC,EAAIyE,EAASrB,OAAQrD,EAAIC,EAAGD,IAAK,CAC/C,IAAI4E,EAAQF,EAAS1E,GACjBkW,EAAOtR,EAAMsR,KAOjB,GALIA,GAAQA,EAAKiM,OAASjM,EAAKiM,MAAMC,aAC5BlM,EAAKiM,MAAMC,KAIfxd,EAAM+E,UAAYA,GAAW/E,EAAM2R,YAAc5M,IACpDuM,GAAqB,MAAbA,EAAKkM,MAUZF,EAAMjF,UAAYiF,EAAMjF,QAAU,KAAKhY,KAAKL,OAT7C,CACA,IAAIrE,EAAO2V,EAAKkM,KACZA,EAAQF,EAAM3hB,KAAU2hB,EAAM3hB,GAAQ,IACxB,aAAdqE,EAAMqR,IACRmM,EAAKnd,KAAKuK,MAAM4S,EAAMxd,EAAMF,UAAY,IAExC0d,EAAKnd,KAAKL,IAOhB,IAAK,IAAIyd,KAAUH,EACbA,EAAMG,GAAQ1R,MAAM2R,YACfJ,EAAMG,GAGjB,OAAOH,EAGT,SAASI,GAAchL,GACrB,OAAQA,EAAKR,YAAcQ,EAAKhB,cAA+B,MAAdgB,EAAKnB,KAKxD,SAASoM,GACPL,EACAM,EACAC,GAEA,IAAIxS,EACAyS,EAAiBhiB,OAAOkC,KAAK4f,GAAanf,OAAS,EACnDsf,EAAWT,IAAUA,EAAMU,SAAWF,EACtCnhB,EAAM2gB,GAASA,EAAMW,KACzB,GAAKX,EAEE,IAAIA,EAAMY,YAEf,OAAOZ,EAAMY,YACR,GACLH,GACAF,GACAA,IAAcrW,GACd7K,IAAQkhB,EAAUI,OACjBH,IACAD,EAAUM,WAIX,OAAON,EAGP,IAAK,IAAI1H,KADT9K,EAAM,GACYiS,EACZA,EAAMnH,IAAuB,MAAbA,EAAM,KACxB9K,EAAI8K,GAASiI,GAAoBR,EAAazH,EAAOmH,EAAMnH,UAnB/D9K,EAAM,GAwBR,IAAK,IAAIgT,KAAST,EACVS,KAAShT,IACbA,EAAIgT,GAASC,GAAgBV,EAAaS,IAW9C,OANIf,GAASxhB,OAAOyY,aAAa+I,KAC/B,EAAQY,YAAc7S,GAExBwC,EAAIxC,EAAK,UAAW0S,GACpBlQ,EAAIxC,EAAK,OAAQ1O,GACjBkR,EAAIxC,EAAK,aAAcyS,GAChBzS,EAGT,SAAS+S,GAAoBR,EAAajhB,EAAKmN,GAC7C,IAAI8M,EAAa,WACf,IAAIvL,EAAMV,UAAUlM,OAASqL,EAAGc,MAAM,KAAMD,WAAab,EAAG,IAI5D,OAHAuB,EAAMA,GAAsB,kBAARA,IAAqBvN,MAAM8K,QAAQyC,GACnD,CAACA,GACDmR,GAAkBnR,MAEL,IAAfA,EAAI5M,QACY,IAAf4M,EAAI5M,QAAgB4M,EAAI,GAAG6G,gBAC1BtK,EACAyD,GAYN,OAPIvB,EAAGyU,OACLziB,OAAOC,eAAe6hB,EAAajhB,EAAK,CACtCV,IAAK2a,EACL5a,YAAY,EACZ+R,cAAc,IAGX6I,EAGT,SAAS0H,GAAgBhB,EAAO3gB,GAC9B,OAAO,WAAc,OAAO2gB,EAAM3gB,IAQpC,SAAS6hB,GACPxY,EACA7B,GAEA,IAAI6G,EAAK5P,EAAGC,EAAG2C,EAAMrB,EACrB,GAAImB,MAAM8K,QAAQ5C,IAAuB,kBAARA,EAE/B,IADAgF,EAAM,IAAIlN,MAAMkI,EAAIvH,QACfrD,EAAI,EAAGC,EAAI2K,EAAIvH,OAAQrD,EAAIC,EAAGD,IACjC4P,EAAI5P,GAAK+I,EAAO6B,EAAI5K,GAAIA,QAErB,GAAmB,kBAAR4K,EAEhB,IADAgF,EAAM,IAAIlN,MAAMkI,GACX5K,EAAI,EAAGA,EAAI4K,EAAK5K,IACnB4P,EAAI5P,GAAK+I,EAAO/I,EAAI,EAAGA,QAEpB,GAAI4M,EAAShC,GAClB,GAAI+J,IAAa/J,EAAI7J,OAAOsiB,UAAW,CACrCzT,EAAM,GAGN,IAFA,IAAIyT,EAAWzY,EAAI7J,OAAOsiB,YACtBnL,EAASmL,EAASje,QACd8S,EAAOoL,MACb1T,EAAI3K,KAAK8D,EAAOmP,EAAOjX,MAAO2O,EAAIvM,SAClC6U,EAASmL,EAASje,YAKpB,IAFAxC,EAAOlC,OAAOkC,KAAKgI,GACnBgF,EAAM,IAAIlN,MAAME,EAAKS,QAChBrD,EAAI,EAAGC,EAAI2C,EAAKS,OAAQrD,EAAIC,EAAGD,IAClCuB,EAAMqB,EAAK5C,GACX4P,EAAI5P,GAAK+I,EAAO6B,EAAIrJ,GAAMA,EAAKvB,GAQrC,OAJKyM,EAAMmD,KACTA,EAAM,IAER,EAAM+R,UAAW,EACV/R,EAQT,SAAS2T,GACPhjB,EACAijB,EACAxI,EACAyI,GAEA,IACIC,EADAC,EAAele,KAAKme,aAAarjB,GAEjCojB,GACF3I,EAAQA,GAAS,GACbyI,IAOFzI,EAAQnL,EAAOA,EAAO,GAAI4T,GAAazI,IAEzC0I,EAAQC,EAAa3I,IAAUwI,GAE/BE,EAAQje,KAAKoe,OAAOtjB,IAASijB,EAG/B,IAAI/b,EAASuT,GAASA,EAAMoH,KAC5B,OAAI3a,EACKhC,KAAKqe,eAAe,WAAY,CAAE1B,KAAM3a,GAAUic,GAElDA,EASX,SAASK,GAAe5O,GACtB,OAAOgH,GAAa1W,KAAK2E,SAAU,UAAW+K,IAAa9E,EAK7D,SAAS2T,GAAeC,EAAQC,GAC9B,OAAIxhB,MAAM8K,QAAQyW,IACmB,IAA5BA,EAAO3V,QAAQ4V,GAEfD,IAAWC,EAStB,SAASC,GACPC,EACA7iB,EACA8iB,EACAC,EACAC,GAEA,IAAIC,EAAgB/b,EAAOoJ,SAAStQ,IAAQ8iB,EAC5C,OAAIE,GAAkBD,IAAiB7b,EAAOoJ,SAAStQ,GAC9CyiB,GAAcO,EAAgBD,GAC5BE,EACFR,GAAcQ,EAAeJ,GAC3BE,EACFpV,EAAUoV,KAAkB/iB,OAD9B,EAUT,SAASkjB,GACPvO,EACAD,EACAhV,EACAyjB,EACAC,GAEA,GAAI1jB,EACF,GAAK2L,EAAS3L,GAKP,CAIL,IAAIggB,EAHAve,MAAM8K,QAAQvM,KAChBA,EAAQ+O,EAAS/O,IAGnB,IAAI2jB,EAAO,SAAWrjB,GACpB,GACU,UAARA,GACQ,UAARA,GACA2M,EAAoB3M,GAEpB0f,EAAO/K,MACF,CACL,IAAI4E,EAAO5E,EAAKiM,OAASjM,EAAKiM,MAAMrH,KACpCmG,EAAOyD,GAAUjc,EAAO0J,YAAY8D,EAAK6E,EAAMvZ,GAC3C2U,EAAK2O,WAAa3O,EAAK2O,SAAW,IAClC3O,EAAKiM,QAAUjM,EAAKiM,MAAQ,IAElC,IAAI2C,EAAejW,EAAStN,GACxBwjB,EAAgB7V,EAAU3N,GACxBujB,KAAgB7D,GAAW8D,KAAiB9D,IAChDA,EAAK1f,GAAON,EAAMM,GAEdojB,KACOzO,EAAKkK,KAAOlK,EAAKkK,GAAK,KAC3B,UAAY7e,GAAQ,SAAUyjB,GAChC/jB,EAAMM,GAAOyjB,MAMrB,IAAK,IAAIzjB,KAAON,EAAO2jB,EAAMrjB,QAGjC,OAAO2U,EAQT,SAAS+O,GACP5W,EACA6W,GAEA,IAAIzW,EAAShJ,KAAK0f,eAAiB1f,KAAK0f,aAAe,IACnDC,EAAO3W,EAAOJ,GAGlB,OAAI+W,IAASF,GASbG,GALAD,EAAO3W,EAAOJ,GAAS5I,KAAK2E,SAASpB,gBAAgBqF,GAAOlO,KAC1DsF,KAAK6f,aACL,KACA7f,MAEgB,aAAe4I,GAAQ,GARhC+W,EAgBX,SAASG,GACPH,EACA/W,EACA9M,GAGA,OADA8jB,GAAWD,EAAO,WAAa/W,GAAS9M,EAAO,IAAMA,EAAO,KAAM,GAC3D6jB,EAGT,SAASC,GACPD,EACA7jB,EACAyV,GAEA,GAAItU,MAAM8K,QAAQ4X,GAChB,IAAK,IAAIplB,EAAI,EAAGA,EAAIolB,EAAK/hB,OAAQrD,IAC3BolB,EAAKplB,IAAyB,kBAAZolB,EAAKplB,IACzBwlB,GAAeJ,EAAKplB,GAAKuB,EAAM,IAAMvB,EAAIgX,QAI7CwO,GAAeJ,EAAM7jB,EAAKyV,GAI9B,SAASwO,GAAgBlO,EAAM/V,EAAKyV,GAClCM,EAAKV,UAAW,EAChBU,EAAK/V,IAAMA,EACX+V,EAAKN,OAASA,EAKhB,SAASyO,GAAqBvP,EAAMjV,GAClC,GAAIA,EACF,GAAK6L,EAAc7L,GAKZ,CACL,IAAImf,EAAKlK,EAAKkK,GAAKlK,EAAKkK,GAAKvQ,EAAO,GAAIqG,EAAKkK,IAAM,GACnD,IAAK,IAAI7e,KAAON,EAAO,CACrB,IAAIwJ,EAAW2V,EAAG7e,GACdmkB,EAAOzkB,EAAMM,GACjB6e,EAAG7e,GAAOkJ,EAAW,GAAGpG,OAAOoG,EAAUib,GAAQA,QAIvD,OAAOxP,EAKT,SAASyP,GACP3F,EACA/P,EAEA2V,EACAC,GAEA5V,EAAMA,GAAO,CAAE2S,SAAUgD,GACzB,IAAK,IAAI5lB,EAAI,EAAGA,EAAIggB,EAAI3c,OAAQrD,IAAK,CACnC,IAAIoiB,EAAOpC,EAAIhgB,GACX0C,MAAM8K,QAAQ4U,GAChBuD,GAAmBvD,EAAMnS,EAAK2V,GACrBxD,IAELA,EAAKe,QACPf,EAAK1T,GAAGyU,OAAQ,GAElBlT,EAAImS,EAAK7gB,KAAO6gB,EAAK1T,IAMzB,OAHImX,IACF,EAAMhD,KAAOgD,GAER5V,EAKT,SAAS6V,GAAiBC,EAASC,GACjC,IAAK,IAAIhmB,EAAI,EAAGA,EAAIgmB,EAAO3iB,OAAQrD,GAAK,EAAG,CACzC,IAAIuB,EAAMykB,EAAOhmB,GACE,kBAARuB,GAAoBA,IAC7BwkB,EAAQC,EAAOhmB,IAAMgmB,EAAOhmB,EAAI,IASpC,OAAO+lB,EAMT,SAASE,GAAiBhlB,EAAOilB,GAC/B,MAAwB,kBAAVjlB,EAAqBilB,EAASjlB,EAAQA,EAKtD,SAASklB,GAAsB1e,GAC7BA,EAAO2e,GAAKb,GACZ9d,EAAO4e,GAAK1Y,EACZlG,EAAO6e,GAAKzb,EACZpD,EAAO8e,GAAKnD,GACZ3b,EAAO+e,GAAKjD,GACZ9b,EAAOgf,GAAKnW,EACZ7I,EAAOif,GAAK1V,EACZvJ,EAAOkf,GAAK1B,GACZxd,EAAOmf,GAAK7C,GACZtc,EAAOof,GAAK1C,GACZ1c,EAAOqf,GAAKrC,GACZhd,EAAOsf,GAAKxP,GACZ9P,EAAOuf,GAAK3P,GACZ5P,EAAOwf,GAAKtB,GACZle,EAAOyf,GAAKzB,GACZhe,EAAO0f,GAAKrB,GACZre,EAAO2f,GAAKnB,GAKd,SAASoB,GACPnR,EACA8E,EACAtW,EACAoF,EACA2K,GAEA,IAKI6S,EALAC,EAAS9hB,KAET8D,EAAUkL,EAAKlL,QAIfiF,EAAO1E,EAAQ,SACjBwd,EAAY5mB,OAAOY,OAAOwI,IAEhB0d,UAAY1d,GAKtBwd,EAAYxd,EAEZA,EAASA,EAAO0d,WAElB,IAAIC,EAAa/a,EAAOnD,EAAQC,WAC5Bke,GAAqBD,EAEzBhiB,KAAKyQ,KAAOA,EACZzQ,KAAKuV,MAAQA,EACbvV,KAAKf,SAAWA,EAChBe,KAAKqE,OAASA,EACdrE,KAAKkiB,UAAYzR,EAAKkK,IAAMhU,EAC5B3G,KAAKmiB,WAAahG,GAAcrY,EAAQ2R,OAAQpR,GAChDrE,KAAKyc,MAAQ,WAOX,OANKqF,EAAO1D,QACVtB,GACErM,EAAK2R,YACLN,EAAO1D,OAAS5B,GAAavd,EAAUoF,IAGpCyd,EAAO1D,QAGhBnjB,OAAOC,eAAe8E,KAAM,cAAe,CACzC7E,YAAY,EACZC,IAAK,WACH,OAAO0hB,GAAqBrM,EAAK2R,YAAapiB,KAAKyc,YAKnDuF,IAEFhiB,KAAK2E,SAAWb,EAEhB9D,KAAKoe,OAASpe,KAAKyc,QACnBzc,KAAKme,aAAerB,GAAqBrM,EAAK2R,YAAapiB,KAAKoe,SAG9Dta,EAAQG,SACVjE,KAAKqiB,GAAK,SAAUxY,EAAGa,EAAG9P,EAAGC,GAC3B,IAAImX,EAAQsQ,GAAcT,EAAWhY,EAAGa,EAAG9P,EAAGC,EAAGonB,GAKjD,OAJIjQ,IAAU/U,MAAM8K,QAAQiK,KAC1BA,EAAMhB,UAAYlN,EAAQG,SAC1B+N,EAAMlB,UAAYzM,GAEb2N,GAGThS,KAAKqiB,GAAK,SAAUxY,EAAGa,EAAG9P,EAAGC,GAAK,OAAOynB,GAAcT,EAAWhY,EAAGa,EAAG9P,EAAGC,EAAGonB,IA+ClF,SAASM,GAA8BvQ,EAAOvB,EAAMoR,EAAW/d,EAAS0e,GAItE,IAAIC,EAAQ1Q,GAAWC,GASvB,OARAyQ,EAAM3R,UAAY+Q,EAClBY,EAAM1R,UAAYjN,EAId2M,EAAKkM,QACN8F,EAAMhS,OAASgS,EAAMhS,KAAO,KAAKkM,KAAOlM,EAAKkM,MAEzC8F,EAGT,SAASC,GAAYrY,EAAInN,GACvB,IAAK,IAAIpB,KAAOoB,EACdmN,EAAGjB,EAAStN,IAAQoB,EAAKpB,GA7D7B4kB,GAAqBkB,GAAwBzlB,WA0E7C,IAAIwmB,GAAsB,CACxBC,KAAM,SAAe5Q,EAAO6Q,GAC1B,GACE7Q,EAAMf,oBACLe,EAAMf,kBAAkB6R,cACzB9Q,EAAMvB,KAAKsS,UACX,CAEA,IAAIC,EAAchR,EAClB2Q,GAAoBM,SAASD,EAAaA,OACrC,EACOhR,EAAMf,kBA0JxB,SACEe,EACA3N,GAEA,IAAIP,EAAU,CACZof,cAAc,EACdC,aAAcnR,EACd3N,OAAQA,GAGN+e,EAAiBpR,EAAMvB,KAAK2S,eAC5Bpc,EAAMoc,KACRtf,EAAQR,OAAS8f,EAAe9f,OAChCQ,EAAQP,gBAAkB6f,EAAe7f,iBAE3C,OAAO,IAAIyO,EAAMpB,iBAAiB5B,KAAKlL,GAzKGuf,CACpCrR,EACAsR,KAEIC,OAAOV,EAAY7Q,EAAMrB,SAAM5J,EAAW8b,KAIpDI,SAAU,SAAmBO,EAAUxR,GACrC,IAAIlO,EAAUkO,EAAMpB,kBAw8BxB,SACEkE,EACAmC,EACAiL,EACAuB,EACAC,GAEI,EAUJ,IAAIC,EAAiBF,EAAYhT,KAAK2R,YAClCwB,EAAiB9O,EAAGqJ,aACpB0F,KACDF,IAAmBA,EAAexG,SAClCyG,IAAmBjd,IAAgBid,EAAezG,SAClDwG,GAAkB7O,EAAGqJ,aAAaf,OAASuG,EAAevG,MAMzD0G,KACFJ,GACA5O,EAAGnQ,SAASof,iBACZF,GAGF/O,EAAGnQ,SAASwe,aAAeM,EAC3B3O,EAAG3Q,OAASsf,EAER3O,EAAGkP,SACLlP,EAAGkP,OAAO3f,OAASof,GAWrB,GATA3O,EAAGnQ,SAASof,gBAAkBL,EAK9B5O,EAAGmP,OAASR,EAAYhT,KAAKiM,OAAS/V,EACtCmO,EAAGoP,WAAahC,GAAavb,EAGzBsQ,GAAanC,EAAGnQ,SAAS4Q,MAAO,CAClCvC,IAAgB,GAGhB,IAFA,IAAIuC,EAAQT,EAAG2C,OACX0M,EAAWrP,EAAGnQ,SAASyf,WAAa,GAC/B7pB,EAAI,EAAGA,EAAI4pB,EAASvmB,OAAQrD,IAAK,CACxC,IAAIuB,EAAMqoB,EAAS5pB,GACfyc,EAAclC,EAAGnQ,SAAS4Q,MAC9BA,EAAMzZ,GAAOib,GAAajb,EAAKkb,EAAaC,EAAWnC,GAEzD9B,IAAgB,GAEhB8B,EAAGnQ,SAASsS,UAAYA,EAI1BiL,EAAYA,GAAavb,EACzB,IAAI0d,EAAevP,EAAGnQ,SAAS2f,iBAC/BxP,EAAGnQ,SAAS2f,iBAAmBpC,EAC/BqC,GAAyBzP,EAAIoN,EAAWmC,GAGpCP,IACFhP,EAAGsJ,OAAS5B,GAAakH,EAAgBD,EAAYvf,SACrD4Q,EAAG0P,gBAGD,EAjhCFC,CADYzS,EAAMf,kBAAoBuS,EAASvS,kBAG7CnN,EAAQmT,UACRnT,EAAQoe,UACRlQ,EACAlO,EAAQ7E,WAIZylB,OAAQ,SAAiB1S,GACvB,IAysC8B8C,EAzsC1B5Q,EAAU8N,EAAM9N,QAChB+M,EAAoBe,EAAMf,kBACzBA,EAAkB0T,aACrB1T,EAAkB0T,YAAa,EAC/BC,GAAS3T,EAAmB,YAE1Be,EAAMvB,KAAKsS,YACT7e,EAAQygB,aAksCgB7P,EA5rCF7D,GA+rC3B4T,WAAY,EACfC,GAAkBtlB,KAAKsV,IA9rCjBiQ,GAAuB9T,GAAmB,KAKhD+T,QAAS,SAAkBhT,GACzB,IAAIf,EAAoBe,EAAMf,kBACzBA,EAAkB6R,eAChB9Q,EAAMvB,KAAKsS,UAGdkC,GAAyBhU,GAAmB,GAF5CA,EAAkBiU,cAQtBC,GAAelqB,OAAOkC,KAAKwlB,IAE/B,SAASyC,GACPpW,EACAyB,EACAvM,EACAjF,EACAuR,GAEA,IAAI3J,EAAQmI,GAAZ,CAIA,IAAIqW,EAAWnhB,EAAQS,SAAS0R,MAShC,GANIlP,EAAS6H,KACXA,EAAOqW,EAASjb,OAAO4E,IAKL,oBAATA,EAAX,CAQA,IAAI6B,EACJ,GAAIhK,EAAQmI,EAAKsW,WAGFve,KADbiI,EA+ZJ,SACE3R,EACAgoB,GAEA,GAAIpe,EAAO5J,EAAQL,QAAUgK,EAAM3J,EAAQkoB,WACzC,OAAOloB,EAAQkoB,UAGjB,GAAIve,EAAM3J,EAAQmoB,UAChB,OAAOnoB,EAAQmoB,SAGjB,IAAIC,EAAQC,GACRD,GAASze,EAAM3J,EAAQsoB,UAA8C,IAAnCtoB,EAAQsoB,OAAO9c,QAAQ4c,IAE3DpoB,EAAQsoB,OAAOnmB,KAAKimB,GAGtB,GAAIxe,EAAO5J,EAAQuoB,UAAY5e,EAAM3J,EAAQwoB,aAC3C,OAAOxoB,EAAQwoB,YAGjB,GAAIJ,IAAUze,EAAM3J,EAAQsoB,QAAS,CACnC,IAAIA,EAAStoB,EAAQsoB,OAAS,CAACF,GAC3BK,GAAO,EACPC,EAAe,KACfC,EAAe,KAElB,EAAQC,IAAI,kBAAkB,WAAc,OAAOxjB,EAAOkjB,EAAQF,MAEnE,IAAIS,EAAc,SAAUC,GAC1B,IAAK,IAAI5rB,EAAI,EAAGC,EAAImrB,EAAO/nB,OAAQrD,EAAIC,EAAGD,IACvCorB,EAAOprB,GAAIiqB,eAGV2B,IACFR,EAAO/nB,OAAS,EACK,OAAjBmoB,IACFK,aAAaL,GACbA,EAAe,MAEI,OAAjBC,IACFI,aAAaJ,GACbA,EAAe,QAKjBhN,EAAUxN,GAAK,SAAUhB,GAE3BnN,EAAQmoB,SAAWa,GAAW7b,EAAK6a,GAG9BS,EAGHH,EAAO/nB,OAAS,EAFhBsoB,GAAY,MAMZI,EAAS9a,GAAK,SAAU+a,GAKtBvf,EAAM3J,EAAQkoB,aAChBloB,EAAQL,OAAQ,EAChBkpB,GAAY,OAIZ1b,EAAMnN,EAAQ2b,EAASsN,GA+C3B,OA7CInf,EAASqD,KACP5C,EAAU4C,GAER3D,EAAQxJ,EAAQmoB,WAClBhb,EAAI3C,KAAKmR,EAASsN,GAEX1e,EAAU4C,EAAIgc,aACvBhc,EAAIgc,UAAU3e,KAAKmR,EAASsN,GAExBtf,EAAMwD,EAAIxN,SACZK,EAAQkoB,UAAYc,GAAW7b,EAAIxN,MAAOqoB,IAGxCre,EAAMwD,EAAIob,WACZvoB,EAAQwoB,YAAcQ,GAAW7b,EAAIob,QAASP,GAC5B,IAAd7a,EAAIic,MACNppB,EAAQuoB,SAAU,EAElBG,EAAe5jB,YAAW,WACxB4jB,EAAe,KACXlf,EAAQxJ,EAAQmoB,WAAa3e,EAAQxJ,EAAQL,SAC/CK,EAAQuoB,SAAU,EAClBM,GAAY,MAEb1b,EAAIic,OAAS,MAIhBzf,EAAMwD,EAAIkc,WACZV,EAAe7jB,YAAW,WACxB6jB,EAAe,KACXnf,EAAQxJ,EAAQmoB,WAClBc,EAGM,QAGP9b,EAAIkc,YAKbZ,GAAO,EAEAzoB,EAAQuoB,QACXvoB,EAAQwoB,YACRxoB,EAAQmoB,UAvhBLmB,CADP9V,EAAe7B,EAC4BqW,IAKzC,OA6YN,SACEhoB,EACAoT,EACAvM,EACAjF,EACAuR,GAEA,IAAIqB,EAAOD,KAGX,OAFAC,EAAKhB,aAAexT,EACpBwU,EAAKL,UAAY,CAAEf,KAAMA,EAAMvM,QAASA,EAASjF,SAAUA,EAAUuR,IAAKA,GACnEqB,EAvZI+U,CACL/V,EACAJ,EACAvM,EACAjF,EACAuR,GAKNC,EAAOA,GAAQ,GAIfoW,GAA0B7X,GAGtBhI,EAAMyJ,EAAKqW,QAwFjB,SAAyBhjB,EAAS2M,GAChC,IAAIyG,EAAQpT,EAAQgjB,OAAShjB,EAAQgjB,MAAM5P,MAAS,QAChD8D,EAASlX,EAAQgjB,OAAShjB,EAAQgjB,MAAM9L,OAAU,SACpDvK,EAAKiM,QAAUjM,EAAKiM,MAAQ,KAAKxF,GAAQzG,EAAKqW,MAAMtrB,MACtD,IAAImf,EAAKlK,EAAKkK,KAAOlK,EAAKkK,GAAK,IAC3B3V,EAAW2V,EAAGK,GACdxZ,EAAWiP,EAAKqW,MAAMtlB,SACtBwF,EAAMhC,IAEN/H,MAAM8K,QAAQ/C,IACsB,IAAhCA,EAAS6D,QAAQrH,GACjBwD,IAAaxD,KAEjBmZ,EAAGK,GAAS,CAACxZ,GAAU5C,OAAOoG,IAGhC2V,EAAGK,GAASxZ,EAvGZulB,CAAe/X,EAAKlL,QAAS2M,GAI/B,IAAIwG,EAr8BN,SACExG,EACAzB,EACAwB,GAKA,IAAIwG,EAAchI,EAAKlL,QAAQyR,MAC/B,IAAI1O,EAAQmQ,GAAZ,CAGA,IAAIxM,EAAM,GACNkS,EAAQjM,EAAKiM,MACbnH,EAAQ9E,EAAK8E,MACjB,GAAIvO,EAAM0V,IAAU1V,EAAMuO,GACxB,IAAK,IAAIzZ,KAAOkb,EAAa,CAC3B,IAAIyE,EAAShS,EAAU3N,GAiBvByf,GAAU/Q,EAAK+K,EAAOzZ,EAAK2f,GAAQ,IACnCF,GAAU/Q,EAAKkS,EAAO5gB,EAAK2f,GAAQ,GAGvC,OAAOjR,GA+5BSwc,CAA0BvW,EAAMzB,GAGhD,GAAI/H,EAAO+H,EAAKlL,QAAQE,YACtB,OAxMJ,SACEgL,EACAiI,EACAxG,EACAoR,EACA5iB,GAEA,IAAI6E,EAAUkL,EAAKlL,QACfyR,EAAQ,GACRyB,EAAclT,EAAQyR,MAC1B,GAAIvO,EAAMgQ,GACR,IAAK,IAAIlb,KAAOkb,EACdzB,EAAMzZ,GAAOib,GAAajb,EAAKkb,EAAaC,GAAatQ,QAGvDK,EAAMyJ,EAAKiM,QAAUgG,GAAWnN,EAAO9E,EAAKiM,OAC5C1V,EAAMyJ,EAAK8E,QAAUmN,GAAWnN,EAAO9E,EAAK8E,OAGlD,IAAIiN,EAAgB,IAAIZ,GACtBnR,EACA8E,EACAtW,EACA4iB,EACA7S,GAGEgD,EAAQlO,EAAQR,OAAO5I,KAAK,KAAM8nB,EAAcH,GAAIG,GAExD,GAAIxQ,aAAiBzB,GACnB,OAAOgS,GAA6BvQ,EAAOvB,EAAM+R,EAAcne,OAAQP,GAClE,GAAI7G,MAAM8K,QAAQiK,GAAQ,CAG/B,IAFA,IAAIiV,EAAStL,GAAkB3J,IAAU,GACrCxH,EAAM,IAAIvN,MAAMgqB,EAAOrpB,QAClBrD,EAAI,EAAGA,EAAI0sB,EAAOrpB,OAAQrD,IACjCiQ,EAAIjQ,GAAKgoB,GAA6B0E,EAAO1sB,GAAIkW,EAAM+R,EAAcne,OAAQP,GAE/E,OAAO0G,GAmKA0c,CAA0BlY,EAAMiI,EAAWxG,EAAMvM,EAASjF,GAKnE,IAAIijB,EAAYzR,EAAKkK,GAKrB,GAFAlK,EAAKkK,GAAKlK,EAAK0W,SAEXlgB,EAAO+H,EAAKlL,QAAQsjB,UAAW,CAKjC,IAAIzK,EAAOlM,EAAKkM,KAChBlM,EAAO,GACHkM,IACFlM,EAAKkM,KAAOA,IAqClB,SAAgClM,GAE9B,IADA,IAAIyE,EAAQzE,EAAK5M,OAAS4M,EAAK5M,KAAO,IAC7BtJ,EAAI,EAAGA,EAAI4qB,GAAavnB,OAAQrD,IAAK,CAC5C,IAAIuB,EAAMqpB,GAAa5qB,GACnByK,EAAWkQ,EAAMpZ,GACjBurB,EAAU1E,GAAoB7mB,GAC9BkJ,IAAaqiB,GAAariB,GAAYA,EAASsiB,UACjDpS,EAAMpZ,GAAOkJ,EAAWuiB,GAAYF,EAASriB,GAAYqiB,IAvC7DG,CAAsB/W,GAGtB,IAAI3V,EAAOkU,EAAKlL,QAAQhJ,MAAQ0V,EAQhC,OAPY,IAAID,GACb,iBAAoBvB,EAAQ,KAAKlU,EAAQ,IAAMA,EAAQ,IACxD2V,OAAM1J,OAAWA,OAAWA,EAAW7C,EACvC,CAAE8K,KAAMA,EAAMiI,UAAWA,EAAWiL,UAAWA,EAAW1R,IAAKA,EAAKvR,SAAUA,GAC9E4R,KAoCJ,SAAS0W,GAAaE,EAAIC,GACxB,IAAIpM,EAAS,SAAUzR,EAAGa,GAExB+c,EAAG5d,EAAGa,GACNgd,EAAG7d,EAAGa,IAGR,OADA4Q,EAAOgM,SAAU,EACVhM,EAgCT,SAASgH,GACPpe,EACAsM,EACAC,EACAxR,EACA0oB,EACAC,GAUA,OARI3qB,MAAM8K,QAAQ0I,IAASvJ,EAAYuJ,MACrCkX,EAAoB1oB,EACpBA,EAAWwR,EACXA,OAAO1J,GAELE,EAAO2gB,KACTD,EAlBmB,GAuBvB,SACEzjB,EACAsM,EACAC,EACAxR,EACA0oB,GAEA,GAAI3gB,EAAMyJ,IAASzJ,EAAM,EAAO2L,QAM9B,OAAOf,KAGL5K,EAAMyJ,IAASzJ,EAAMyJ,EAAKoX,MAC5BrX,EAAMC,EAAKoX,IAEb,IAAKrX,EAEH,OAAOoB,KAGL,EAYA3U,MAAM8K,QAAQ9I,IACO,oBAAhBA,EAAS,MAEhBwR,EAAOA,GAAQ,IACV2R,YAAc,CAAE5K,QAASvY,EAAS,IACvCA,EAASrB,OAAS,GAhEC,IAkEjB+pB,EACF1oB,EAAW0c,GAAkB1c,GApEV,IAqEV0oB,IACT1oB,EApiCJ,SAAkCA,GAChC,IAAK,IAAI1E,EAAI,EAAGA,EAAI0E,EAASrB,OAAQrD,IACnC,GAAI0C,MAAM8K,QAAQ9I,EAAS1E,IACzB,OAAO0C,MAAMd,UAAUyC,OAAOmL,MAAM,GAAI9K,GAG5C,OAAOA,EA8hCM6oB,CAAwB7oB,IAErC,IAAI+S,EAAOpW,EACX,GAAmB,kBAAR4U,EAAkB,CAC3B,IAAIxB,EACJpT,EAAMsI,EAAQC,QAAUD,EAAQC,OAAOvI,IAAOoH,EAAOwJ,gBAAgBgE,GASnEwB,EAREhP,EAAOqJ,cAAcmE,GAQf,IAAID,GACVvN,EAAOyJ,qBAAqB+D,GAAMC,EAAMxR,OACxC8H,OAAWA,EAAW7C,GAEbuM,GAASA,EAAKsX,MAAQ/gB,EAAMgI,EAAO0H,GAAaxS,EAAQS,SAAU,aAAc6L,IAOnF,IAAID,GACVC,EAAKC,EAAMxR,OACX8H,OAAWA,EAAW7C,GAPhBkhB,GAAgBpW,EAAMyB,EAAMvM,EAASjF,EAAUuR,QAYzDwB,EAAQoT,GAAgB5U,EAAKC,EAAMvM,EAASjF,GAE9C,OAAIhC,MAAM8K,QAAQiK,GACTA,EACEhL,EAAMgL,IACXhL,EAAMpL,IAAOosB,GAAQhW,EAAOpW,GAC5BoL,EAAMyJ,IA4Bd,SAA+BA,GACzBtJ,EAASsJ,EAAKwX,QAChBrO,GAASnJ,EAAKwX,OAEZ9gB,EAASsJ,EAAKyX,QAChBtO,GAASnJ,EAAKyX,OAjCKC,CAAqB1X,GACjCuB,GAEAJ,KA1FFwW,CAAelkB,EAASsM,EAAKC,EAAMxR,EAAU0oB,GA8FtD,SAASK,GAAShW,EAAOpW,EAAIysB,GAO3B,GANArW,EAAMpW,GAAKA,EACO,kBAAdoW,EAAMxB,MAER5U,OAAKmL,EACLshB,GAAQ,GAENrhB,EAAMgL,EAAM/S,UACd,IAAK,IAAI1E,EAAI,EAAGC,EAAIwX,EAAM/S,SAASrB,OAAQrD,EAAIC,EAAGD,IAAK,CACrD,IAAI4E,EAAQ6S,EAAM/S,SAAS1E,GACvByM,EAAM7H,EAAMqR,OACd3J,EAAQ1H,EAAMvD,KAAQqL,EAAOohB,IAAwB,QAAdlpB,EAAMqR,MAC7CwX,GAAQ7oB,EAAOvD,EAAIysB,IAuD3B,IAkQIrmB,GAlQA0jB,GAA2B,KA4E/B,SAASW,GAAYiC,EAAMC,GAOzB,OALED,EAAK3sB,YACJuT,IAA0C,WAA7BoZ,EAAKhtB,OAAOC,gBAE1B+sB,EAAOA,EAAK9Q,SAEPrQ,EAASmhB,GACZC,EAAKne,OAAOke,GACZA,EA8IN,SAAS7W,GAAoBI,GAC3B,OAAOA,EAAKR,WAAaQ,EAAKhB,aAKhC,SAAS2X,GAAwBvpB,GAC/B,GAAIhC,MAAM8K,QAAQ9I,GAChB,IAAK,IAAI1E,EAAI,EAAGA,EAAI0E,EAASrB,OAAQrD,IAAK,CACxC,IAAIK,EAAIqE,EAAS1E,GACjB,GAAIyM,EAAMpM,KAAOoM,EAAMpM,EAAEgW,mBAAqBa,GAAmB7W,IAC/D,OAAOA,GAsBf,SAAS4J,GAAKwW,EAAO/R,GACnBjH,GAAOikB,IAAIjL,EAAO/R,GAGpB,SAASwf,GAAUzN,EAAO/R,GACxBjH,GAAO0mB,KAAK1N,EAAO/R,GAGrB,SAAS6R,GAAmBE,EAAO/R,GACjC,IAAI0f,EAAU3mB,GACd,OAAO,SAAS4mB,IACd,IAAIpe,EAAMvB,EAAGc,MAAM,KAAMD,WACb,OAARU,GACFme,EAAQD,KAAK1N,EAAO4N,IAK1B,SAASrE,GACPzP,EACAoN,EACAmC,GAEAriB,GAAS8S,EACT4F,GAAgBwH,EAAWmC,GAAgB,GAAI7f,GAAKikB,GAAU3N,GAAmBhG,GACjF9S,QAAS+E,EAkGX,IAAIuc,GAAiB,KAGrB,SAASuF,GAAkB/T,GACzB,IAAIgU,EAAqBxF,GAEzB,OADAA,GAAiBxO,EACV,WACLwO,GAAiBwF,GA2QrB,SAASC,GAAkBjU,GACzB,KAAOA,IAAOA,EAAKA,EAAGqD,UACpB,GAAIrD,EAAG+P,UAAa,OAAO,EAE7B,OAAO,EAGT,SAASE,GAAwBjQ,EAAIkU,GACnC,GAAIA,GAEF,GADAlU,EAAGmU,iBAAkB,EACjBF,GAAiBjU,GACnB,YAEG,GAAIA,EAAGmU,gBACZ,OAEF,GAAInU,EAAG+P,WAA8B,OAAjB/P,EAAG+P,UAAoB,CACzC/P,EAAG+P,WAAY,EACf,IAAK,IAAItqB,EAAI,EAAGA,EAAIua,EAAGoU,UAAUtrB,OAAQrD,IACvCwqB,GAAuBjQ,EAAGoU,UAAU3uB,IAEtCqqB,GAAS9P,EAAI,cAIjB,SAASmQ,GAA0BnQ,EAAIkU,GACrC,KAAIA,IACFlU,EAAGmU,iBAAkB,GACjBF,GAAiBjU,OAIlBA,EAAG+P,UAAW,CACjB/P,EAAG+P,WAAY,EACf,IAAK,IAAItqB,EAAI,EAAGA,EAAIua,EAAGoU,UAAUtrB,OAAQrD,IACvC0qB,GAAyBnQ,EAAGoU,UAAU3uB,IAExCqqB,GAAS9P,EAAI,gBAIjB,SAAS8P,GAAU9P,EAAIjR,GAErBuM,KACA,IAAI+Y,EAAWrU,EAAGnQ,SAASd,GACvBoU,EAAOpU,EAAO,QAClB,GAAIslB,EACF,IAAK,IAAI5uB,EAAI,EAAG6uB,EAAID,EAASvrB,OAAQrD,EAAI6uB,EAAG7uB,IAC1C+d,GAAwB6Q,EAAS5uB,GAAIua,EAAI,KAAMA,EAAImD,GAGnDnD,EAAGuU,eACLvU,EAAGwU,MAAM,QAAUzlB,GAErBwM,KAKF,IAEIkZ,GAAQ,GACRzE,GAAoB,GACpBnoB,GAAM,GAEN6sB,IAAU,EACVC,IAAW,EACX7gB,GAAQ,EAmBZ,IAAI8gB,GAAwB,EAGxBC,GAASxe,KAAKye,IAQlB,GAAIrc,IAAcQ,EAAM,CACtB,IAAI/B,GAAcnL,OAAOmL,YAEvBA,IAC2B,oBAApBA,GAAY4d,KACnBD,KAAWjrB,SAASmrB,YAAY,SAASC,YAMzCH,GAAS,WAAc,OAAO3d,GAAY4d,QAO9C,SAASG,KAGP,IAAIC,EAASta,EAcb,IAhBAga,GAAwBC,KACxBF,IAAW,EAWXF,GAAMU,MAAK,SAAUpgB,EAAGa,GAAK,OAAOb,EAAE6F,GAAKhF,EAAEgF,MAIxC9G,GAAQ,EAAGA,GAAQ2gB,GAAM3rB,OAAQgL,MACpCohB,EAAUT,GAAM3gB,KACJshB,QACVF,EAAQE,SAEVxa,EAAKsa,EAAQta,GACb/S,GAAI+S,GAAM,KACVsa,EAAQG,MAmBV,IAAIC,EAAiBtF,GAAkB9e,QACnCqkB,EAAed,GAAMvjB,QAtFzB4C,GAAQ2gB,GAAM3rB,OAASknB,GAAkBlnB,OAAS,EAClDjB,GAAM,GAIN6sB,GAAUC,IAAW,EAsHvB,SAA6BF,GAC3B,IAAK,IAAIhvB,EAAI,EAAGA,EAAIgvB,EAAM3rB,OAAQrD,IAChCgvB,EAAMhvB,GAAGsqB,WAAY,EACrBE,GAAuBwE,EAAMhvB,IAAI,GAnCnC+vB,CAAmBF,GAUrB,SAA2Bb,GACzB,IAAIhvB,EAAIgvB,EAAM3rB,OACd,KAAOrD,KAAK,CACV,IAAIyvB,EAAUT,EAAMhvB,GAChBua,EAAKkV,EAAQlV,GACbA,EAAGyV,WAAaP,GAAWlV,EAAG6P,aAAe7P,EAAGgO,cAClD8B,GAAS9P,EAAI,YAfjB0V,CAAiBH,GAIbte,IAAY/I,EAAO+I,UACrBA,GAAS0e,KAAK,SAsElB,IAAIC,GAAQ,EAORC,GAAU,SACZ7V,EACA8V,EACAnR,EACA3V,EACA+mB,GAEA7qB,KAAK8U,GAAKA,EACN+V,IACF/V,EAAGyV,SAAWvqB,MAEhB8U,EAAGgW,UAAUtrB,KAAKQ,MAEd8D,GACF9D,KAAK+qB,OAASjnB,EAAQinB,KACtB/qB,KAAKgrB,OAASlnB,EAAQknB,KACtBhrB,KAAKirB,OAASnnB,EAAQmnB,KACtBjrB,KAAK8lB,OAAShiB,EAAQgiB,KACtB9lB,KAAKkqB,OAASpmB,EAAQomB,QAEtBlqB,KAAK+qB,KAAO/qB,KAAKgrB,KAAOhrB,KAAKirB,KAAOjrB,KAAK8lB,MAAO,EAElD9lB,KAAKyZ,GAAKA,EACVzZ,KAAK0P,KAAOgb,GACZ1qB,KAAKkrB,QAAS,EACdlrB,KAAKmrB,MAAQnrB,KAAKirB,KAClBjrB,KAAKorB,KAAO,GACZprB,KAAKqrB,QAAU,GACfrrB,KAAKsrB,OAAS,IAAIrc,GAClBjP,KAAKurB,UAAY,IAAItc,GACrBjP,KAAKwrB,WAED,GAEmB,oBAAZZ,EACT5qB,KAAKjF,OAAS6vB,GAEd5qB,KAAKjF,OAx3HT,SAAoB0wB,GAClB,IAAIte,EAAOa,KAAKyd,GAAhB,CAGA,IAAIC,EAAWD,EAAKvqB,MAAM,KAC1B,OAAO,SAAU3D,GACf,IAAK,IAAIhD,EAAI,EAAGA,EAAImxB,EAAS9tB,OAAQrD,IAAK,CACxC,IAAKgD,EAAO,OACZA,EAAMA,EAAImuB,EAASnxB,IAErB,OAAOgD,IA82HOouB,CAAUf,GACnB5qB,KAAKjF,SACRiF,KAAKjF,OAAS0P,IASlBzK,KAAKxE,MAAQwE,KAAKirB,UACdlkB,EACA/G,KAAK5E,OAMXuvB,GAAQxuB,UAAUf,IAAM,WAEtB,IAAII,EADJ4U,GAAWpQ,MAEX,IAAI8U,EAAK9U,KAAK8U,GACd,IACEtZ,EAAQwE,KAAKjF,OAAOL,KAAKoa,EAAIA,GAC7B,MAAOzU,IACP,IAAIL,KAAKgrB,KAGP,MAAM3qB,GAFN0X,GAAY1X,GAAGyU,EAAK,uBAA2B9U,KAAe,WAAI,KAIpE,QAGIA,KAAK+qB,MACPnR,GAASpe,GAEX6U,KACArQ,KAAK4rB,cAEP,OAAOpwB,GAMTmvB,GAAQxuB,UAAU6T,OAAS,SAAiB6C,GAC1C,IAAInD,EAAKmD,EAAInD,GACR1P,KAAKurB,UAAU5uB,IAAI+S,KACtB1P,KAAKurB,UAAU/mB,IAAIkL,GACnB1P,KAAKqrB,QAAQ7rB,KAAKqT,GACb7S,KAAKsrB,OAAO3uB,IAAI+S,IACnBmD,EAAIjD,OAAO5P,QAQjB2qB,GAAQxuB,UAAUyvB,YAAc,WAE9B,IADA,IAAIrxB,EAAIyF,KAAKorB,KAAKxtB,OACXrD,KAAK,CACV,IAAIsY,EAAM7S,KAAKorB,KAAK7wB,GACfyF,KAAKurB,UAAU5uB,IAAIkW,EAAInD,KAC1BmD,EAAI/C,UAAU9P,MAGlB,IAAI6rB,EAAM7rB,KAAKsrB,OACftrB,KAAKsrB,OAAStrB,KAAKurB,UACnBvrB,KAAKurB,UAAYM,EACjB7rB,KAAKurB,UAAUjc,QACfuc,EAAM7rB,KAAKorB,KACXprB,KAAKorB,KAAOprB,KAAKqrB,QACjBrrB,KAAKqrB,QAAUQ,EACf7rB,KAAKqrB,QAAQztB,OAAS,GAOxB+sB,GAAQxuB,UAAU+T,OAAS,WAErBlQ,KAAKirB,KACPjrB,KAAKmrB,OAAQ,EACJnrB,KAAK8lB,KACd9lB,KAAKmqB,MAnKT,SAAuBH,GACrB,IAAIta,EAAKsa,EAAQta,GACjB,GAAe,MAAX/S,GAAI+S,GAAa,CAEnB,GADA/S,GAAI+S,IAAM,EACL+Z,GAEE,CAIL,IADA,IAAIlvB,EAAIgvB,GAAM3rB,OAAS,EAChBrD,EAAIqO,IAAS2gB,GAAMhvB,GAAGmV,GAAKsa,EAAQta,IACxCnV,IAEFgvB,GAAMzgB,OAAOvO,EAAI,EAAG,EAAGyvB,QARvBT,GAAM/pB,KAAKwqB,GAWRR,KACHA,IAAU,EAMVhQ,GAASuQ,MA8IX+B,CAAa9rB,OAQjB2qB,GAAQxuB,UAAUguB,IAAM,WACtB,GAAInqB,KAAKkrB,OAAQ,CACf,IAAI1vB,EAAQwE,KAAK5E,MACjB,GACEI,IAAUwE,KAAKxE,OAIf2L,EAAS3L,IACTwE,KAAK+qB,KACL,CAEA,IAAIgB,EAAW/rB,KAAKxE,MAEpB,GADAwE,KAAKxE,MAAQA,EACTwE,KAAKgrB,KACP,IACEhrB,KAAKyZ,GAAG/e,KAAKsF,KAAK8U,GAAItZ,EAAOuwB,GAC7B,MAAO1rB,IACP0X,GAAY1X,GAAGL,KAAK8U,GAAK,yBAA6B9U,KAAe,WAAI,UAG3EA,KAAKyZ,GAAG/e,KAAKsF,KAAK8U,GAAItZ,EAAOuwB,MAUrCpB,GAAQxuB,UAAU6vB,SAAW,WAC3BhsB,KAAKxE,MAAQwE,KAAK5E,MAClB4E,KAAKmrB,OAAQ,GAMfR,GAAQxuB,UAAU4T,OAAS,WAEzB,IADA,IAAIxV,EAAIyF,KAAKorB,KAAKxtB,OACXrD,KACLyF,KAAKorB,KAAK7wB,GAAGwV,UAOjB4a,GAAQxuB,UAAU8vB,SAAW,WAC3B,GAAIjsB,KAAKkrB,OAAQ,CAIVlrB,KAAK8U,GAAGoX,mBACXzpB,EAAOzC,KAAK8U,GAAGgW,UAAW9qB,MAG5B,IADA,IAAIzF,EAAIyF,KAAKorB,KAAKxtB,OACXrD,KACLyF,KAAKorB,KAAK7wB,GAAGuV,UAAU9P,MAEzBA,KAAKkrB,QAAS,IAMlB,IAAIiB,GAA2B,CAC7BhxB,YAAY,EACZ+R,cAAc,EACd9R,IAAKqP,EACL7N,IAAK6N,GAGP,SAASiT,GAAO1b,EAAQoqB,EAAWtwB,GACjCqwB,GAAyB/wB,IAAM,WAC7B,OAAO4E,KAAKosB,GAAWtwB,IAEzBqwB,GAAyBvvB,IAAM,SAAsBuI,GACnDnF,KAAKosB,GAAWtwB,GAAOqJ,GAEzBlK,OAAOC,eAAe8G,EAAQlG,EAAKqwB,IAGrC,SAASE,GAAWvX,GAClBA,EAAGgW,UAAY,GACf,IAAIrc,EAAOqG,EAAGnQ,SACV8J,EAAK8G,OAaX,SAAoBT,EAAIwX,GACtB,IAAIrV,EAAYnC,EAAGnQ,SAASsS,WAAa,GACrC1B,EAAQT,EAAG2C,OAAS,GAGpBta,EAAO2X,EAAGnQ,SAASyf,UAAY,GACrBtP,EAAGqD,SAGfnF,IAAgB,GAElB,IAAImM,EAAO,SAAWrjB,GACpBqB,EAAKqC,KAAK1D,GACV,IAAIN,EAAQub,GAAajb,EAAKwwB,EAAcrV,EAAWnC,GAuBrDlB,GAAkB2B,EAAOzZ,EAAKN,GAK1BM,KAAOgZ,GACX4I,GAAM5I,EAAI,SAAUhZ,IAIxB,IAAK,IAAIA,KAAOwwB,EAAcnN,EAAMrjB,GACpCkX,IAAgB,GA5DEuZ,CAAUzX,EAAIrG,EAAK8G,OACjC9G,EAAK+G,SAoNX,SAAsBV,EAAIU,GACZV,EAAGnQ,SAAS4Q,MACxB,IAAK,IAAIzZ,KAAO0Z,EAsBdV,EAAGhZ,GAA+B,oBAAjB0Z,EAAQ1Z,GAAsB2O,EAAO1O,EAAKyZ,EAAQ1Z,GAAMgZ,GA5OvD0X,CAAY1X,EAAIrG,EAAK+G,SACrC/G,EAAKgC,KA6DX,SAAmBqE,GACjB,IAAIrE,EAAOqE,EAAGnQ,SAAS8L,KAIlBpJ,EAHLoJ,EAAOqE,EAAG2X,MAAwB,oBAAThc,EAwC3B,SAAkBA,EAAMqE,GAEtB1E,KACA,IACE,OAAOK,EAAK/V,KAAKoa,EAAIA,GACrB,MAAOzU,IAEP,OADA0X,GAAY1X,GAAGyU,EAAI,UACZ,GACP,QACAzE,MAhDEqc,CAAQjc,EAAMqE,GACdrE,GAAQ,MAEVA,EAAO,IAQT,IAAItT,EAAOlC,OAAOkC,KAAKsT,GACnB8E,EAAQT,EAAGnQ,SAAS4Q,MAEpBhb,GADUua,EAAGnQ,SAAS6Q,QAClBrY,EAAKS,QACb,KAAOrD,KAAK,CACV,IAAIuB,EAAMqB,EAAK5C,GACX,EAQAgb,GAASxM,EAAOwM,EAAOzZ,IAMfgR,EAAWhR,IACrB4hB,GAAM5I,EAAI,QAAShZ,GAIvB0X,GAAQ/C,GAAM,GAnGZkc,CAAS7X,GAETtB,GAAQsB,EAAG2X,MAAQ,IAAI,GAErBhe,EAAKiH,UAiHX,SAAuBZ,EAAIY,GAEzB,IAAIkX,EAAW9X,EAAG+X,kBAAoB5xB,OAAOY,OAAO,MAEhDixB,EAAQpe,KAEZ,IAAK,IAAI5S,KAAO4Z,EAAU,CACxB,IAAIqX,EAAUrX,EAAS5Z,GACnBf,EAA4B,oBAAZgyB,EAAyBA,EAAUA,EAAQ3xB,IAC3D,EAOC0xB,IAEHF,EAAS9wB,GAAO,IAAI6uB,GAClB7V,EACA/Z,GAAU0P,EACVA,EACAuiB,KAOElxB,KAAOgZ,GACXmY,GAAenY,EAAIhZ,EAAKixB,IA/IPG,CAAapY,EAAIrG,EAAKiH,UACvCjH,EAAKF,OAASE,EAAKF,QAAUD,IAyOnC,SAAoBwG,EAAIvG,GACtB,IAAK,IAAIzS,KAAOyS,EAAO,CACrB,IAAIxM,EAAUwM,EAAMzS,GACpB,GAAImB,MAAM8K,QAAQhG,GAChB,IAAK,IAAIxH,EAAI,EAAGA,EAAIwH,EAAQnE,OAAQrD,IAClC4yB,GAAcrY,EAAIhZ,EAAKiG,EAAQxH,SAGjC4yB,GAAcrY,EAAIhZ,EAAKiG,IAhPzBqrB,CAAUtY,EAAIrG,EAAKF,OA6GvB,IAAIye,GAAyB,CAAE/B,MAAM,GA2CrC,SAASgC,GACPjrB,EACAlG,EACAixB,GAEA,IAAIM,GAAe3e,KACI,oBAAZqe,GACTZ,GAAyB/wB,IAAMiyB,EAC3BC,GAAqBxxB,GACrByxB,GAAoBR,GACxBZ,GAAyBvvB,IAAM6N,IAE/B0hB,GAAyB/wB,IAAM2xB,EAAQ3xB,IACnCiyB,IAAiC,IAAlBN,EAAQ7jB,MACrBokB,GAAqBxxB,GACrByxB,GAAoBR,EAAQ3xB,KAC9BqP,EACJ0hB,GAAyBvvB,IAAMmwB,EAAQnwB,KAAO6N,GAWhDxP,OAAOC,eAAe8G,EAAQlG,EAAKqwB,IAGrC,SAASmB,GAAsBxxB,GAC7B,OAAO,WACL,IAAIkuB,EAAUhqB,KAAK6sB,mBAAqB7sB,KAAK6sB,kBAAkB/wB,GAC/D,GAAIkuB,EAOF,OANIA,EAAQmB,OACVnB,EAAQgC,WAENvc,GAAIzN,QACNgoB,EAAQja,SAEHia,EAAQxuB,OAKrB,SAAS+xB,GAAoBtkB,GAC3B,OAAO,WACL,OAAOA,EAAGvO,KAAKsF,KAAMA,OA6CzB,SAASmtB,GACPrY,EACA8V,EACA7oB,EACA+B,GASA,OAPIuD,EAActF,KAChB+B,EAAU/B,EACVA,EAAUA,EAAQA,SAEG,kBAAZA,IACTA,EAAU+S,EAAG/S,IAER+S,EAAG0Y,OAAO5C,EAAS7oB,EAAS+B,GAwDrC,IAAI2pB,GAAQ,EAgFZ,SAAS5G,GAA2B7X,GAClC,IAAIlL,EAAUkL,EAAKlL,QACnB,GAAIkL,EAAK0e,MAAO,CACd,IAAIC,EAAe9G,GAA0B7X,EAAK0e,OAElD,GAAIC,IADqB3e,EAAK2e,aACW,CAGvC3e,EAAK2e,aAAeA,EAEpB,IAAIC,EAcV,SAAiC5e,GAC/B,IAAI6e,EACAC,EAAS9e,EAAKlL,QACdiqB,EAAS/e,EAAKgf,cAClB,IAAK,IAAIlyB,KAAOgyB,EACVA,EAAOhyB,KAASiyB,EAAOjyB,KACpB+xB,IAAYA,EAAW,IAC5BA,EAAS/xB,GAAOgyB,EAAOhyB,IAG3B,OAAO+xB,EAxBmBI,CAAuBjf,GAEzC4e,GACFxjB,EAAO4E,EAAKkf,cAAeN,IAE7B9pB,EAAUkL,EAAKlL,QAAU+R,GAAa8X,EAAc3e,EAAKkf,gBAC7CpzB,OACVgJ,EAAQqqB,WAAWrqB,EAAQhJ,MAAQkU,IAIzC,OAAOlL,EAgBT,SAASsqB,GAAKtqB,GAMZ9D,KAAKquB,MAAMvqB,GA0Cb,SAASwqB,GAAYF,GAMnBA,EAAI9I,IAAM,EACV,IAAIA,EAAM,EAKV8I,EAAIhkB,OAAS,SAAU8jB,GACrBA,EAAgBA,GAAiB,GACjC,IAAIK,EAAQvuB,KACRwuB,EAAUD,EAAMjJ,IAChBmJ,EAAcP,EAAcQ,QAAUR,EAAcQ,MAAQ,IAChE,GAAID,EAAYD,GACd,OAAOC,EAAYD,GAGrB,IAAI1zB,EAAOozB,EAAcpzB,MAAQyzB,EAAMzqB,QAAQhJ,KAK/C,IAAI6zB,EAAM,SAAuB7qB,GAC/B9D,KAAKquB,MAAMvqB,IA6Cb,OA3CA6qB,EAAIxyB,UAAYlB,OAAOY,OAAO0yB,EAAMpyB,YACtBoG,YAAcosB,EAC5BA,EAAIrJ,IAAMA,IACVqJ,EAAI7qB,QAAU+R,GACZ0Y,EAAMzqB,QACNoqB,GAEFS,EAAW,MAAIJ,EAKXI,EAAI7qB,QAAQyR,OAmCpB,SAAsBqZ,GACpB,IAAIrZ,EAAQqZ,EAAK9qB,QAAQyR,MACzB,IAAK,IAAIzZ,KAAOyZ,EACdmI,GAAMkR,EAAKzyB,UAAW,SAAUL,GArC9B+yB,CAAYF,GAEVA,EAAI7qB,QAAQ4R,UAuCpB,SAAyBkZ,GACvB,IAAIlZ,EAAWkZ,EAAK9qB,QAAQ4R,SAC5B,IAAK,IAAI5Z,KAAO4Z,EACduX,GAAe2B,EAAKzyB,UAAWL,EAAK4Z,EAAS5Z,IAzC3CgzB,CAAeH,GAIjBA,EAAIvkB,OAASmkB,EAAMnkB,OACnBukB,EAAII,MAAQR,EAAMQ,MAClBJ,EAAIK,IAAMT,EAAMS,IAIhBtjB,EAAY7I,SAAQ,SAAUwS,GAC5BsZ,EAAItZ,GAAQkZ,EAAMlZ,MAGhBva,IACF6zB,EAAI7qB,QAAQqqB,WAAWrzB,GAAQ6zB,GAMjCA,EAAIhB,aAAeY,EAAMzqB,QACzB6qB,EAAIT,cAAgBA,EACpBS,EAAIX,cAAgB5jB,EAAO,GAAIukB,EAAI7qB,SAGnC2qB,EAAYD,GAAWG,EAChBA,GAsDX,SAASM,GAAkBxgB,GACzB,OAAOA,IAASA,EAAKO,KAAKlL,QAAQhJ,MAAQ2T,EAAK+B,KAGjD,SAASpR,GAAS8vB,EAASp0B,GACzB,OAAImC,MAAM8K,QAAQmnB,GACTA,EAAQrmB,QAAQ/N,IAAS,EACJ,kBAAZo0B,EACTA,EAAQhuB,MAAM,KAAK2H,QAAQ/N,IAAS,IAClCwM,EAAS4nB,IACXA,EAAQlhB,KAAKlT,GAMxB,SAASq0B,GAAYC,EAAmBlwB,GACtC,IAAIgK,EAAQkmB,EAAkBlmB,MAC1B/L,EAAOiyB,EAAkBjyB,KACzB6mB,EAASoL,EAAkBpL,OAC/B,IAAK,IAAIloB,KAAOoN,EAAO,CACrB,IAAImmB,EAAanmB,EAAMpN,GACvB,GAAIuzB,EAAY,CACd,IAAIv0B,EAAOm0B,GAAiBI,EAAWze,kBACnC9V,IAASoE,EAAOpE,IAClBw0B,GAAgBpmB,EAAOpN,EAAKqB,EAAM6mB,KAM1C,SAASsL,GACPpmB,EACApN,EACAqB,EACAoyB,GAEA,IAAIC,EAAYtmB,EAAMpN,IAClB0zB,GAAeD,GAAWC,EAAUhf,MAAQ+e,EAAQ/e,KACtDgf,EAAUve,kBAAkBiU,WAE9Bhc,EAAMpN,GAAO,KACb2G,EAAOtF,EAAMrB,IA3Uf,SAAoBsyB,GAClBA,EAAIjyB,UAAUkyB,MAAQ,SAAUvqB,GAC9B,IAAIgR,EAAK9U,KAET8U,EAAG2a,KAAOhC,KAWV3Y,EAAGnB,QAAS,EAER7P,GAAWA,EAAQof,aA0C3B,SAAgCpO,EAAIhR,GAClC,IAAI2K,EAAOqG,EAAGnQ,SAAW1J,OAAOY,OAAOiZ,EAAGvS,YAAYuB,SAElD2f,EAAc3f,EAAQqf,aAC1B1U,EAAKpK,OAASP,EAAQO,OACtBoK,EAAK0U,aAAeM,EAEpB,IAAIiM,EAAwBjM,EAAY7S,iBACxCnC,EAAKwI,UAAYyY,EAAsBzY,UACvCxI,EAAK6V,iBAAmBoL,EAAsBxN,UAC9CzT,EAAKsV,gBAAkB2L,EAAsBzwB,SAC7CwP,EAAKkhB,cAAgBD,EAAsBlf,IAEvC1M,EAAQR,SACVmL,EAAKnL,OAASQ,EAAQR,OACtBmL,EAAKlL,gBAAkBO,EAAQP,iBArD7BqsB,CAAsB9a,EAAIhR,GAE1BgR,EAAGnQ,SAAWkR,GACZgR,GAA0B/R,EAAGvS,aAC7BuB,GAAW,GACXgR,GAOFA,EAAG+K,aAAe/K,EAGpBA,EAAG+a,MAAQ/a,EApkCf,SAAwBA,GACtB,IAAIhR,EAAUgR,EAAGnQ,SAGbN,EAASP,EAAQO,OACrB,GAAIA,IAAWP,EAAQsjB,SAAU,CAC/B,KAAO/iB,EAAOM,SAASyiB,UAAY/iB,EAAO8T,SACxC9T,EAASA,EAAO8T,QAElB9T,EAAO6kB,UAAU1pB,KAAKsV,GAGxBA,EAAGqD,QAAU9T,EACbyQ,EAAGpQ,MAAQL,EAASA,EAAOK,MAAQoQ,EAEnCA,EAAGoU,UAAY,GACfpU,EAAGgb,MAAQ,GAEXhb,EAAGyV,SAAW,KACdzV,EAAG+P,UAAY,KACf/P,EAAGmU,iBAAkB,EACrBnU,EAAG6P,YAAa,EAChB7P,EAAGgO,cAAe,EAClBhO,EAAGoX,mBAAoB,EA8iCrB6D,CAAcjb,GAvtClB,SAAqBA,GACnBA,EAAGkb,QAAU/0B,OAAOY,OAAO,MAC3BiZ,EAAGuU,eAAgB,EAEnB,IAAInH,EAAYpN,EAAGnQ,SAAS2f,iBACxBpC,GACFqC,GAAyBzP,EAAIoN,GAktC7B+N,CAAWnb,GAn/Cf,SAAqBA,GACnBA,EAAGkP,OAAS,KACZlP,EAAG4K,aAAe,KAClB,IAAI5b,EAAUgR,EAAGnQ,SACb8e,EAAc3O,EAAG3Q,OAASL,EAAQqf,aAClCX,EAAgBiB,GAAeA,EAAYvf,QAC/C4Q,EAAGsJ,OAAS5B,GAAa1Y,EAAQigB,gBAAiBvB,GAClD1N,EAAGqJ,aAAexX,EAKlBmO,EAAGuN,GAAK,SAAUxY,EAAGa,EAAG9P,EAAGC,GAAK,OAAOynB,GAAcxN,EAAIjL,EAAGa,EAAG9P,EAAGC,GAAG,IAGrEia,EAAGuJ,eAAiB,SAAUxU,EAAGa,EAAG9P,EAAGC,GAAK,OAAOynB,GAAcxN,EAAIjL,EAAGa,EAAG9P,EAAGC,GAAG,IAIjF,IAAIq1B,EAAazM,GAAeA,EAAYhT,KAW1CmD,GAAkBkB,EAAI,SAAUob,GAAcA,EAAWxT,OAAS/V,EAAa,MAAM,GACrFiN,GAAkBkB,EAAI,aAAchR,EAAQwgB,kBAAoB3d,EAAa,MAAM,GAq9CnFwpB,CAAWrb,GACX8P,GAAS9P,EAAI,gBAlhFjB,SAAyBA,GACvB,IAAIrC,EAAS0J,GAAcrH,EAAGnQ,SAAS8Q,OAAQX,GAC3CrC,IACFO,IAAgB,GAChB/X,OAAOkC,KAAKsV,GAAQ5P,SAAQ,SAAU/G,GAYlC8X,GAAkBkB,EAAIhZ,EAAK2W,EAAO3W,OAGtCkX,IAAgB,IAggFhBod,CAAetb,GACfuX,GAAUvX,GA7hFd,SAAsBA,GACpB,IAAIa,EAAUb,EAAGnQ,SAASgR,QACtBA,IACFb,EAAGwH,UAA+B,oBAAZ3G,EAClBA,EAAQjb,KAAKoa,GACba,GAyhFJ0a,CAAYvb,GACZ8P,GAAS9P,EAAI,WASTA,EAAGnQ,SAAS1E,IACd6U,EAAGyO,OAAOzO,EAAGnQ,SAAS1E,KAsE5BqwB,CAAUlC,IAnLV,SAAqBA,GAInB,IAAImC,EAAU,CACd,IAAc,WAAc,OAAOvwB,KAAKysB,QACpC+D,EAAW,CACf,IAAe,WAAc,OAAOxwB,KAAKyX,SAazCxc,OAAOC,eAAekzB,EAAIjyB,UAAW,QAASo0B,GAC9Ct1B,OAAOC,eAAekzB,EAAIjyB,UAAW,SAAUq0B,GAE/CpC,EAAIjyB,UAAUs0B,KAAO7zB,GACrBwxB,EAAIjyB,UAAUu0B,QAAUrc,GAExB+Z,EAAIjyB,UAAUqxB,OAAS,SACrB5C,EACAnR,EACA3V,GAEA,IAAIgR,EAAK9U,KACT,GAAIqH,EAAcoS,GAChB,OAAO0T,GAAcrY,EAAI8V,EAASnR,EAAI3V,IAExCA,EAAUA,GAAW,IACbknB,MAAO,EACf,IAAIhB,EAAU,IAAIW,GAAQ7V,EAAI8V,EAASnR,EAAI3V,GAC3C,GAAIA,EAAQ6sB,UACV,IACElX,EAAG/e,KAAKoa,EAAIkV,EAAQxuB,OACpB,MAAOwB,GACP+a,GAAY/a,EAAO8X,EAAK,mCAAuCkV,EAAkB,WAAI,KAGzF,OAAO,WACLA,EAAQiC,aAsId2E,CAAWxC,IAvwCX,SAAsBA,GACpB,IAAIyC,EAAS,SACbzC,EAAIjyB,UAAU8pB,IAAM,SAAUjL,EAAO/R,GACnC,IAAI6L,EAAK9U,KACT,GAAI/C,MAAM8K,QAAQiT,GAChB,IAAK,IAAIzgB,EAAI,EAAGC,EAAIwgB,EAAMpd,OAAQrD,EAAIC,EAAGD,IACvCua,EAAGmR,IAAIjL,EAAMzgB,GAAI0O,QAGlB6L,EAAGkb,QAAQhV,KAAWlG,EAAGkb,QAAQhV,GAAS,KAAKxb,KAAKyJ,GAGjD4nB,EAAO7iB,KAAKgN,KACdlG,EAAGuU,eAAgB,GAGvB,OAAOvU,GAGTsZ,EAAIjyB,UAAU20B,MAAQ,SAAU9V,EAAO/R,GACrC,IAAI6L,EAAK9U,KACT,SAAS2a,IACP7F,EAAG4T,KAAK1N,EAAOL,GACf1R,EAAGc,MAAM+K,EAAIhL,WAIf,OAFA6Q,EAAG1R,GAAKA,EACR6L,EAAGmR,IAAIjL,EAAOL,GACP7F,GAGTsZ,EAAIjyB,UAAUusB,KAAO,SAAU1N,EAAO/R,GACpC,IAAI6L,EAAK9U,KAET,IAAK8J,UAAUlM,OAEb,OADAkX,EAAGkb,QAAU/0B,OAAOY,OAAO,MACpBiZ,EAGT,GAAI7X,MAAM8K,QAAQiT,GAAQ,CACxB,IAAK,IAAI+V,EAAM,EAAGv2B,EAAIwgB,EAAMpd,OAAQmzB,EAAMv2B,EAAGu2B,IAC3Cjc,EAAG4T,KAAK1N,EAAM+V,GAAM9nB,GAEtB,OAAO6L,EAGT,IASI2E,EATAuX,EAAMlc,EAAGkb,QAAQhV,GACrB,IAAKgW,EACH,OAAOlc,EAET,IAAK7L,EAEH,OADA6L,EAAGkb,QAAQhV,GAAS,KACblG,EAKT,IADA,IAAIva,EAAIy2B,EAAIpzB,OACLrD,KAEL,IADAkf,EAAKuX,EAAIz2B,MACE0O,GAAMwQ,EAAGxQ,KAAOA,EAAI,CAC7B+nB,EAAIloB,OAAOvO,EAAG,GACd,MAGJ,OAAOua,GAGTsZ,EAAIjyB,UAAUmtB,MAAQ,SAAUtO,GAC9B,IAAIlG,EAAK9U,KAaLgxB,EAAMlc,EAAGkb,QAAQhV,GACrB,GAAIgW,EAAK,CACPA,EAAMA,EAAIpzB,OAAS,EAAIqM,EAAQ+mB,GAAOA,EAGtC,IAFA,IAAI1e,EAAOrI,EAAQH,UAAW,GAC1BmO,EAAO,sBAAyB+C,EAAQ,IACnCzgB,EAAI,EAAGC,EAAIw2B,EAAIpzB,OAAQrD,EAAIC,EAAGD,IACrC+d,GAAwB0Y,EAAIz2B,GAAIua,EAAIxC,EAAMwC,EAAImD,GAGlD,OAAOnD,GA+qCXmc,CAAY7C,IApoCZ,SAAyBA,GACvBA,EAAIjyB,UAAU+0B,QAAU,SAAUlf,EAAO6Q,GACvC,IAAI/N,EAAK9U,KACLmxB,EAASrc,EAAGsc,IACZC,EAAYvc,EAAGkP,OACfsN,EAAwBzI,GAAkB/T,GAC9CA,EAAGkP,OAAShS,EAQV8C,EAAGsc,IALAC,EAKMvc,EAAGyc,UAAUF,EAAWrf,GAHxB8C,EAAGyc,UAAUzc,EAAGsc,IAAKpf,EAAO6Q,GAAW,GAKlDyO,IAEIH,IACFA,EAAOK,QAAU,MAEf1c,EAAGsc,MACLtc,EAAGsc,IAAII,QAAU1c,GAGfA,EAAG3Q,QAAU2Q,EAAGqD,SAAWrD,EAAG3Q,SAAW2Q,EAAGqD,QAAQ6L,SACtDlP,EAAGqD,QAAQiZ,IAAMtc,EAAGsc,MAMxBhD,EAAIjyB,UAAUqoB,aAAe,WAClBxkB,KACFuqB,UADEvqB,KAEJuqB,SAASra,UAIhBke,EAAIjyB,UAAU+oB,SAAW,WACvB,IAAIpQ,EAAK9U,KACT,IAAI8U,EAAGoX,kBAAP,CAGAtH,GAAS9P,EAAI,iBACbA,EAAGoX,mBAAoB,EAEvB,IAAI7nB,EAASyQ,EAAGqD,SACZ9T,GAAWA,EAAO6nB,mBAAsBpX,EAAGnQ,SAASyiB,UACtD3kB,EAAO4B,EAAO6kB,UAAWpU,GAGvBA,EAAGyV,UACLzV,EAAGyV,SAAS0B,WAGd,IADA,IAAI1xB,EAAIua,EAAGgW,UAAUltB,OACdrD,KACLua,EAAGgW,UAAUvwB,GAAG0xB,WAIdnX,EAAG2X,MAAM9Z,QACXmC,EAAG2X,MAAM9Z,OAAOO,UAGlB4B,EAAGgO,cAAe,EAElBhO,EAAGyc,UAAUzc,EAAGkP,OAAQ,MAExBY,GAAS9P,EAAI,aAEbA,EAAG4T,OAEC5T,EAAGsc,MACLtc,EAAGsc,IAAII,QAAU,MAGf1c,EAAG3Q,SACL2Q,EAAG3Q,OAAOE,OAAS,QAujCzBotB,CAAerD,IAviDf,SAAsBA,GAEpB1N,GAAqB0N,EAAIjyB,WAEzBiyB,EAAIjyB,UAAUu1B,UAAY,SAAUzoB,GAClC,OAAOuQ,GAASvQ,EAAIjJ,OAGtBouB,EAAIjyB,UAAUw1B,QAAU,WACtB,IAiBI3f,EAjBA8C,EAAK9U,KACL4xB,EAAM9c,EAAGnQ,SACTrB,EAASsuB,EAAItuB,OACb6f,EAAeyO,EAAIzO,aAEnBA,IACFrO,EAAGqJ,aAAerB,GAChBqG,EAAa1S,KAAK2R,YAClBtN,EAAGsJ,OACHtJ,EAAGqJ,eAMPrJ,EAAG3Q,OAASgf,EAGZ,IAIEuC,GAA2B5Q,EAC3B9C,EAAQ1O,EAAO5I,KAAKoa,EAAG+K,aAAc/K,EAAGuJ,gBACxC,MAAOhe,IACP0X,GAAY1X,GAAGyU,EAAI,UAYjB9C,EAAQ8C,EAAGkP,OAEb,QACA0B,GAA2B,KAmB7B,OAhBIzoB,MAAM8K,QAAQiK,IAA2B,IAAjBA,EAAMpU,SAChCoU,EAAQA,EAAM,IAGVA,aAAiBzB,KAQrByB,EAAQJ,MAGVI,EAAM3N,OAAS8e,EACRnR,GAo+CX6f,CAAYzD,IA8MZ,IAAI0D,GAAe,CAACtqB,OAAQ4F,OAAQnQ,OAiFhC80B,GAAoB,CACtBC,UAhFc,CACdl3B,KAAM,aACNssB,UAAU,EAEV7R,MAAO,CACL0c,QAASH,GACTI,QAASJ,GACT1d,IAAK,CAAC5M,OAAQzG,SAGhBoxB,QAAS,WACPnyB,KAAKkJ,MAAQjO,OAAOY,OAAO,MAC3BmE,KAAK7C,KAAO,IAGdi1B,UAAW,WACT,IAAK,IAAIt2B,KAAOkE,KAAKkJ,MACnBomB,GAAgBtvB,KAAKkJ,MAAOpN,EAAKkE,KAAK7C,OAI1Ck1B,QAAS,WACP,IAAIvQ,EAAS9hB,KAEbA,KAAKwtB,OAAO,WAAW,SAAUroB,GAC/BgqB,GAAWrN,GAAQ,SAAUhnB,GAAQ,OAAOsE,GAAQ+F,EAAKrK,SAE3DkF,KAAKwtB,OAAO,WAAW,SAAUroB,GAC/BgqB,GAAWrN,GAAQ,SAAUhnB,GAAQ,OAAQsE,GAAQ+F,EAAKrK,UAI9DwI,OAAQ,WACN,IAAIqZ,EAAO3c,KAAKoe,OAAO5G,QACnBxF,EAAQwW,GAAuB7L,GAC/B/L,EAAmBoB,GAASA,EAAMpB,iBACtC,GAAIA,EAAkB,CAEpB,IAAI9V,EAAOm0B,GAAiBre,GAExBqhB,EADMjyB,KACQiyB,QACdC,EAFMlyB,KAEQkyB,QAClB,GAEGD,KAAan3B,IAASsE,GAAQ6yB,EAASn3B,KAEvCo3B,GAAWp3B,GAAQsE,GAAQ8yB,EAASp3B,GAErC,OAAOkX,EAGT,IACI9I,EADQlJ,KACMkJ,MACd/L,EAFQ6C,KAEK7C,KACbrB,EAAmB,MAAbkW,EAAMlW,IAGZ8U,EAAiB5B,KAAKsW,KAAO1U,EAAiBJ,IAAO,KAAQI,EAAoB,IAAK,IACtFoB,EAAMlW,IACNoN,EAAMpN,IACRkW,EAAMf,kBAAoB/H,EAAMpN,GAAKmV,kBAErCxO,EAAOtF,EAAMrB,GACbqB,EAAKqC,KAAK1D,KAEVoN,EAAMpN,GAAOkW,EACb7U,EAAKqC,KAAK1D,GAENkE,KAAKoU,KAAOjX,EAAKS,OAAS00B,SAAStyB,KAAKoU,MAC1Ckb,GAAgBpmB,EAAO/L,EAAK,GAAIA,EAAM6C,KAAKgkB,SAI/ChS,EAAMvB,KAAKsS,WAAY,EAEzB,OAAO/Q,GAAU2K,GAAQA,EAAK,OAUlC,SAAwByR,GAEtB,IAAImE,EAAY,CAChB,IAAgB,WAAc,OAAOvvB,IAQrC/H,OAAOC,eAAekzB,EAAK,SAAUmE,GAKrCnE,EAAIoE,KAAO,CACTjjB,KAAMA,GACNnF,OAAQA,EACRyL,aAAcA,GACd4c,eAAgB7e,IAGlBwa,EAAIxxB,IAAMA,GACVwxB,EAAIhxB,OAASiX,GACb+Z,EAAI5U,SAAWA,GAGf4U,EAAIsE,WAAa,SAAUn1B,GAEzB,OADAiW,GAAQjW,GACDA,GAGT6wB,EAAItqB,QAAU7I,OAAOY,OAAO,MAC5B6P,EAAY7I,SAAQ,SAAUwS,GAC5B+Y,EAAItqB,QAAQuR,EAAO,KAAOpa,OAAOY,OAAO,SAK1CuyB,EAAItqB,QAAQuS,MAAQ+X,EAEpBhkB,EAAOgkB,EAAItqB,QAAQqqB,WAAY4D,IA3UjC,SAAkB3D,GAChBA,EAAIY,IAAM,SAAU2D,GAClB,IAAIC,EAAoB5yB,KAAK6yB,oBAAsB7yB,KAAK6yB,kBAAoB,IAC5E,GAAID,EAAiB/pB,QAAQ8pB,IAAW,EACtC,OAAO3yB,KAIT,IAAIsS,EAAOrI,EAAQH,UAAW,GAQ9B,OAPAwI,EAAKwgB,QAAQ9yB,MACiB,oBAAnB2yB,EAAOI,QAChBJ,EAAOI,QAAQhpB,MAAM4oB,EAAQrgB,GACF,oBAAXqgB,GAChBA,EAAO5oB,MAAM,KAAMuI,GAErBsgB,EAAiBpzB,KAAKmzB,GACf3yB,MA6TTgzB,CAAQ5E,GAvTV,SAAsBA,GACpBA,EAAIW,MAAQ,SAAUA,GAEpB,OADA/uB,KAAK8D,QAAU+R,GAAa7V,KAAK8D,QAASirB,GACnC/uB,MAqTTizB,CAAY7E,GACZE,GAAWF,GApNb,SAA6BA,GAI3B1iB,EAAY7I,SAAQ,SAAUwS,GAC5B+Y,EAAI/Y,GAAQ,SACV3F,EACAwjB,GAEA,OAAKA,GAOU,cAAT7d,GAAwBhO,EAAc6rB,KACxCA,EAAWp4B,KAAOo4B,EAAWp4B,MAAQ4U,EACrCwjB,EAAalzB,KAAK8D,QAAQuS,MAAMjM,OAAO8oB,IAE5B,cAAT7d,GAA8C,oBAAf6d,IACjCA,EAAa,CAAEn3B,KAAMm3B,EAAYhjB,OAAQgjB,IAE3ClzB,KAAK8D,QAAQuR,EAAO,KAAK3F,GAAMwjB,EACxBA,GAdAlzB,KAAK8D,QAAQuR,EAAO,KAAK3F,OA2MtCyjB,CAAmB/E,GAGrBgF,CAAchF,IAEdnzB,OAAOC,eAAekzB,GAAIjyB,UAAW,YAAa,CAChDf,IAAKsT,KAGPzT,OAAOC,eAAekzB,GAAIjyB,UAAW,cAAe,CAClDf,IAAK,WAEH,OAAO4E,KAAKmE,QAAUnE,KAAKmE,OAAOC,cAKtCnJ,OAAOC,eAAekzB,GAAK,0BAA2B,CACpD5yB,MAAOomB,KAGTwM,GAAIiF,QAAU,SAMd,IAAI/mB,GAAiBlE,EAAQ,eAGzBkrB,GAAclrB,EAAQ,yCACtBsE,GAAc,SAAU8D,EAAK6E,EAAMke,GACrC,MACY,UAATA,GAAoBD,GAAY9iB,IAAkB,WAAT6E,GAChC,aAATke,GAA+B,WAAR/iB,GACd,YAAT+iB,GAA8B,UAAR/iB,GACb,UAAT+iB,GAA4B,UAAR/iB,GAIrBgjB,GAAmBprB,EAAQ,wCAE3BqrB,GAA8BrrB,EAAQ,sCAWtCsrB,GAAgBtrB,EAClB,wYAQEurB,GAAU,+BAEVC,GAAU,SAAU94B,GACtB,MAA0B,MAAnBA,EAAKiL,OAAO,IAAmC,UAArBjL,EAAKkL,MAAM,EAAG,IAG7C6tB,GAAe,SAAU/4B,GAC3B,OAAO84B,GAAQ94B,GAAQA,EAAKkL,MAAM,EAAGlL,EAAK8C,QAAU,IAGlDk2B,GAAmB,SAAU3uB,GAC/B,OAAc,MAAPA,IAAuB,IAARA,GAKxB,SAAS4uB,GAAkB/hB,GAIzB,IAHA,IAAIvB,EAAOuB,EAAMvB,KACblR,EAAayS,EACbgiB,EAAYhiB,EACThL,EAAMgtB,EAAU/iB,qBACrB+iB,EAAYA,EAAU/iB,kBAAkB+S,SACvBgQ,EAAUvjB,OACzBA,EAAOwjB,GAAeD,EAAUvjB,KAAMA,IAG1C,KAAOzJ,EAAMzH,EAAaA,EAAW8E,SAC/B9E,GAAcA,EAAWkR,OAC3BA,EAAOwjB,GAAexjB,EAAMlR,EAAWkR,OAG3C,OAYF,SACEyjB,EACAC,GAEA,GAAIntB,EAAMktB,IAAgBltB,EAAMmtB,GAC9B,OAAOv1B,GAAOs1B,EAAaE,GAAeD,IAG5C,MAAO,GApBAE,CAAY5jB,EAAKyjB,YAAazjB,EAAKyX,OAG5C,SAAS+L,GAAgB90B,EAAOkF,GAC9B,MAAO,CACL6vB,YAAat1B,GAAOO,EAAM+0B,YAAa7vB,EAAO6vB,aAC9ChM,MAAOlhB,EAAM7H,EAAM+oB,OACf,CAAC/oB,EAAM+oB,MAAO7jB,EAAO6jB,OACrB7jB,EAAO6jB,OAef,SAAStpB,GAAQiL,EAAGa,GAClB,OAAOb,EAAIa,EAAKb,EAAI,IAAMa,EAAKb,EAAKa,GAAK,GAG3C,SAAS0pB,GAAgB54B,GACvB,OAAIyB,MAAM8K,QAAQvM,GAapB,SAAyBA,GAGvB,IAFA,IACI84B,EADA9pB,EAAM,GAEDjQ,EAAI,EAAGC,EAAIgB,EAAMoC,OAAQrD,EAAIC,EAAGD,IACnCyM,EAAMstB,EAAcF,GAAe54B,EAAMjB,MAAwB,KAAhB+5B,IAC/C9pB,IAAOA,GAAO,KAClBA,GAAO8pB,GAGX,OAAO9pB,EArBE+pB,CAAe/4B,GAEpB2L,EAAS3L,GAsBf,SAA0BA,GACxB,IAAIgP,EAAM,GACV,IAAK,IAAI1O,KAAON,EACVA,EAAMM,KACJ0O,IAAOA,GAAO,KAClBA,GAAO1O,GAGX,OAAO0O,EA7BEgqB,CAAgBh5B,GAEJ,kBAAVA,EACFA,EAGF,GA4BT,IAAIi5B,GAAe,CACjBC,IAAK,6BACLC,KAAM,sCAGJC,GAAYxsB,EACd,snBAeEysB,GAAQzsB,EACV,kNAGA,GAKEiE,GAAgB,SAAUmE,GAC5B,OAAOokB,GAAUpkB,IAAQqkB,GAAMrkB,IAGjC,SAAShE,GAAiBgE,GACxB,OAAIqkB,GAAMrkB,GACD,MAIG,SAARA,EACK,YADT,EAKF,IAAIskB,GAAsB75B,OAAOY,OAAO,MA0BxC,IAAIk5B,GAAkB3sB,EAAQ,6CAO9B,SAAS4sB,GAAO/0B,GACd,GAAkB,kBAAPA,EAAiB,CAC1B,IAAIg1B,EAAWv2B,SAASM,cAAciB,GACtC,OAAKg1B,GAIIv2B,SAAS4jB,cAAc,OAIhC,OAAOriB,EA8DX,IAAIi1B,GAAuBj6B,OAAO2L,OAAO,CACvC0b,cAzDF,SAA0B6S,EAASnjB,GACjC,IAAIrB,EAAMjS,SAAS4jB,cAAc6S,GACjC,MAAgB,WAAZA,GAIAnjB,EAAMvB,MAAQuB,EAAMvB,KAAKiM,YAAuC3V,IAA9BiL,EAAMvB,KAAKiM,MAAM0Y,UACrDzkB,EAAIlL,aAAa,WAAY,YAJtBkL,GAuDT0kB,gBA9CF,SAA0BC,EAAWH,GACnC,OAAOz2B,SAAS22B,gBAAgBZ,GAAaa,GAAYH,IA8CzD7b,eA3CF,SAAyB5I,GACvB,OAAOhS,SAAS4a,eAAe5I,IA2C/B6kB,cAxCF,SAAwB7kB,GACtB,OAAOhS,SAAS62B,cAAc7kB,IAwC9B8kB,aArCF,SAAuBj2B,EAAYk2B,EAASC,GAC1Cn2B,EAAWi2B,aAAaC,EAASC,IAqCjCC,YAlCF,SAAsB9jB,EAAM1S,GAC1B0S,EAAK8jB,YAAYx2B,IAkCjBy2B,YA/BF,SAAsB/jB,EAAM1S,GAC1B0S,EAAK+jB,YAAYz2B,IA+BjBI,WA5BF,SAAqBsS,GACnB,OAAOA,EAAKtS,YA4BZs2B,YAzBF,SAAsBhkB,GACpB,OAAOA,EAAKgkB,aAyBZV,QAtBF,SAAkBtjB,GAChB,OAAOA,EAAKsjB,SAsBZW,eAnBF,SAAyBjkB,EAAMnB,GAC7BmB,EAAKkkB,YAAcrlB,GAmBnBslB,cAhBF,SAAwBnkB,EAAMnO,GAC5BmO,EAAKpM,aAAa/B,EAAS,OAoBzBkuB,GAAM,CACR/1B,OAAQ,SAAiBwN,EAAG2I,GAC1BikB,GAAYjkB,IAEd9B,OAAQ,SAAiBsT,EAAUxR,GAC7BwR,EAAS/S,KAAKmhB,MAAQ5f,EAAMvB,KAAKmhB,MACnCqE,GAAYzS,GAAU,GACtByS,GAAYjkB,KAGhBgT,QAAS,SAAkBhT,GACzBikB,GAAYjkB,GAAO,KAIvB,SAASikB,GAAajkB,EAAOkkB,GAC3B,IAAIp6B,EAAMkW,EAAMvB,KAAKmhB,IACrB,GAAK5qB,EAAMlL,GAAX,CAEA,IAAIgZ,EAAK9C,EAAM9N,QACX0tB,EAAM5f,EAAMf,mBAAqBe,EAAMrB,IACvCwlB,EAAOrhB,EAAGgb,MACVoG,EACEj5B,MAAM8K,QAAQouB,EAAKr6B,IACrB2G,EAAO0zB,EAAKr6B,GAAM81B,GACTuE,EAAKr6B,KAAS81B,IACvBuE,EAAKr6B,QAAOiL,GAGViL,EAAMvB,KAAK2lB,SACRn5B,MAAM8K,QAAQouB,EAAKr6B,IAEbq6B,EAAKr6B,GAAK+M,QAAQ+oB,GAAO,GAElCuE,EAAKr6B,GAAK0D,KAAKoyB,GAHfuE,EAAKr6B,GAAO,CAAC81B,GAMfuE,EAAKr6B,GAAO81B,GAiBlB,IAAIyE,GAAY,IAAI9lB,GAAM,GAAI,GAAI,IAE9B2E,GAAQ,CAAC,SAAU,WAAY,SAAU,SAAU,WAEvD,SAASohB,GAAWzsB,EAAGa,GACrB,OACEb,EAAE/N,MAAQ4O,EAAE5O,MAER+N,EAAE2G,MAAQ9F,EAAE8F,KACZ3G,EAAEwH,YAAc3G,EAAE2G,WAClBrK,EAAM6C,EAAE4G,QAAUzJ,EAAM0D,EAAE+F,OAWlC,SAAwB5G,EAAGa,GACzB,GAAc,UAAVb,EAAE2G,IAAmB,OAAO,EAChC,IAAIjW,EACAg8B,EAAQvvB,EAAMzM,EAAIsP,EAAE4G,OAASzJ,EAAMzM,EAAIA,EAAEmiB,QAAUniB,EAAE8a,KACrDmhB,EAAQxvB,EAAMzM,EAAImQ,EAAE+F,OAASzJ,EAAMzM,EAAIA,EAAEmiB,QAAUniB,EAAE8a,KACzD,OAAOkhB,IAAUC,GAASzB,GAAgBwB,IAAUxB,GAAgByB,GAf9DC,CAAc5sB,EAAGa,IAEjBzD,EAAO4C,EAAE4H,qBACT5H,EAAEgH,eAAiBnG,EAAEmG,cACrBhK,EAAQ6D,EAAEmG,aAAa7T,QAc/B,SAAS05B,GAAmBz3B,EAAU03B,EAAUC,GAC9C,IAAIr8B,EAAGuB,EACHgE,EAAM,GACV,IAAKvF,EAAIo8B,EAAUp8B,GAAKq8B,IAAUr8B,EAE5ByM,EADJlL,EAAMmD,EAAS1E,GAAGuB,OACAgE,EAAIhE,GAAOvB,GAE/B,OAAOuF,EAqtBT,IAAIoW,GAAa,CACfra,OAAQg7B,GACR3mB,OAAQ2mB,GACR7R,QAAS,SAA2BhT,GAClC6kB,GAAiB7kB,EAAOqkB,MAI5B,SAASQ,GAAkBrT,EAAUxR,IAC/BwR,EAAS/S,KAAKyF,YAAclE,EAAMvB,KAAKyF,aAK7C,SAAkBsN,EAAUxR,GAC1B,IAQIlW,EAAKg7B,EAAQC,EARbC,EAAWxT,IAAa6S,GACxBY,EAAYjlB,IAAUqkB,GACtBa,EAAUC,GAAsB3T,EAAS/S,KAAKyF,WAAYsN,EAAStf,SACnEkzB,EAAUD,GAAsBnlB,EAAMvB,KAAKyF,WAAYlE,EAAM9N,SAE7DmzB,EAAiB,GACjBC,EAAoB,GAGxB,IAAKx7B,KAAOs7B,EACVN,EAASI,EAAQp7B,GACjBi7B,EAAMK,EAAQt7B,GACTg7B,GAQHC,EAAIhL,SAAW+K,EAAOt7B,MACtBu7B,EAAIQ,OAAST,EAAOU,IACpBC,GAAWV,EAAK,SAAU/kB,EAAOwR,GAC7BuT,EAAI/pB,KAAO+pB,EAAI/pB,IAAI0qB,kBACrBJ,EAAkB93B,KAAKu3B,KAVzBU,GAAWV,EAAK,OAAQ/kB,EAAOwR,GAC3BuT,EAAI/pB,KAAO+pB,EAAI/pB,IAAIwF,UACrB6kB,EAAe73B,KAAKu3B,IAa1B,GAAIM,EAAez5B,OAAQ,CACzB,IAAI+5B,EAAa,WACf,IAAK,IAAIp9B,EAAI,EAAGA,EAAI88B,EAAez5B,OAAQrD,IACzCk9B,GAAWJ,EAAe98B,GAAI,WAAYyX,EAAOwR,IAGjDwT,EACF9b,GAAelJ,EAAO,SAAU2lB,GAEhCA,IAIAL,EAAkB15B,QACpBsd,GAAelJ,EAAO,aAAa,WACjC,IAAK,IAAIzX,EAAI,EAAGA,EAAI+8B,EAAkB15B,OAAQrD,IAC5Ck9B,GAAWH,EAAkB/8B,GAAI,mBAAoByX,EAAOwR,MAKlE,IAAKwT,EACH,IAAKl7B,KAAOo7B,EACLE,EAAQt7B,IAEX27B,GAAWP,EAAQp7B,GAAM,SAAU0nB,EAAUA,EAAUyT,GA3D3D/F,CAAQ1N,EAAUxR,GAiEtB,IAAI4lB,GAAiB38B,OAAOY,OAAO,MAEnC,SAASs7B,GACPlhB,EACAnB,GAEA,IAKIva,EAAGw8B,EALHvsB,EAAMvP,OAAOY,OAAO,MACxB,IAAKoa,EAEH,OAAOzL,EAGT,IAAKjQ,EAAI,EAAGA,EAAI0b,EAAKrY,OAAQrD,KAC3Bw8B,EAAM9gB,EAAK1b,IACFs9B,YAEPd,EAAIc,UAAYD,IAElBptB,EAAIstB,GAAcf,IAAQA,EAC1BA,EAAI/pB,IAAM0J,GAAa5B,EAAGnQ,SAAU,aAAcoyB,EAAIj8B,MAGxD,OAAO0P,EAGT,SAASstB,GAAef,GACtB,OAAOA,EAAIgB,SAAahB,EAAQ,KAAI,IAAO97B,OAAOkC,KAAK45B,EAAIc,WAAa,IAAI93B,KAAK,KAGnF,SAAS03B,GAAYV,EAAKlzB,EAAMmO,EAAOwR,EAAUyT,GAC/C,IAAIhuB,EAAK8tB,EAAI/pB,KAAO+pB,EAAI/pB,IAAInJ,GAC5B,GAAIoF,EACF,IACEA,EAAG+I,EAAMrB,IAAKomB,EAAK/kB,EAAOwR,EAAUyT,GACpC,MAAO52B,IACP0X,GAAY1X,GAAG2R,EAAM9N,QAAU,aAAgB6yB,EAAQ,KAAI,IAAMlzB,EAAO,UAK9E,IAAIm0B,GAAc,CAChBpG,GACA1b,IAKF,SAAS+hB,GAAazU,EAAUxR,GAC9B,IAAIvD,EAAOuD,EAAMpB,iBACjB,KAAI5J,EAAMyH,KAA4C,IAAnCA,EAAKO,KAAKlL,QAAQo0B,iBAGjCrxB,EAAQ2c,EAAS/S,KAAKiM,SAAU7V,EAAQmL,EAAMvB,KAAKiM,QAAvD,CAGA,IAAI5gB,EAAKoc,EACLvH,EAAMqB,EAAMrB,IACZwnB,EAAW3U,EAAS/S,KAAKiM,OAAS,GAClCA,EAAQ1K,EAAMvB,KAAKiM,OAAS,GAMhC,IAAK5gB,KAJDkL,EAAM0V,EAAM/J,UACd+J,EAAQ1K,EAAMvB,KAAKiM,MAAQtS,EAAO,GAAIsS,IAG5BA,EACVxE,EAAMwE,EAAM5gB,GACNq8B,EAASr8B,KACHoc,GACVkgB,GAAQznB,EAAK7U,EAAKoc,GAStB,IAAKpc,KAHAiS,GAAQG,KAAWwO,EAAMlhB,QAAU28B,EAAS38B,OAC/C48B,GAAQznB,EAAK,QAAS+L,EAAMlhB,OAElB28B,EACNtxB,EAAQ6V,EAAM5gB,MACZ83B,GAAQ93B,GACV6U,EAAI0nB,kBAAkB1E,GAASE,GAAa/3B,IAClC03B,GAAiB13B,IAC3B6U,EAAIjL,gBAAgB5J,KAM5B,SAASs8B,GAASn4B,EAAInE,EAAKN,GACrByE,EAAGk1B,QAAQtsB,QAAQ,MAAQ,EAC7ByvB,GAAYr4B,EAAInE,EAAKN,GACZk4B,GAAc53B,GAGnBg4B,GAAiBt4B,GACnByE,EAAGyF,gBAAgB5J,IAInBN,EAAgB,oBAARM,GAA4C,UAAfmE,EAAGk1B,QACpC,OACAr5B,EACJmE,EAAGwF,aAAa3J,EAAKN,IAEdg4B,GAAiB13B,GAC1BmE,EAAGwF,aAAa3J,EA9vCS,SAAUA,EAAKN,GAC1C,OAAOs4B,GAAiBt4B,IAAoB,UAAVA,EAC9B,QAEQ,oBAARM,GAA6B23B,GAA4Bj4B,GACvDA,EACA,OAwvCiB+8B,CAAuBz8B,EAAKN,IACxCo4B,GAAQ93B,GACbg4B,GAAiBt4B,GACnByE,EAAGo4B,kBAAkB1E,GAASE,GAAa/3B,IAE3CmE,EAAGu4B,eAAe7E,GAAS73B,EAAKN,GAGlC88B,GAAYr4B,EAAInE,EAAKN,GAIzB,SAAS88B,GAAar4B,EAAInE,EAAKN,GAC7B,GAAIs4B,GAAiBt4B,GACnByE,EAAGyF,gBAAgB5J,OACd,CAKL,GACEiS,IAASE,GACM,aAAfhO,EAAGk1B,SACK,gBAARr5B,GAAmC,KAAVN,IAAiByE,EAAGw4B,OAC7C,CACA,IAAIC,EAAU,SAAUr4B,GACtBA,EAAEs4B,2BACF14B,EAAGgC,oBAAoB,QAASy2B,IAElCz4B,EAAGiC,iBAAiB,QAASw2B,GAE7Bz4B,EAAGw4B,QAAS,EAEdx4B,EAAGwF,aAAa3J,EAAKN,IAIzB,IAAIkhB,GAAQ,CACV7gB,OAAQo8B,GACR/nB,OAAQ+nB,IAKV,SAASW,GAAapV,EAAUxR,GAC9B,IAAI/R,EAAK+R,EAAMrB,IACXF,EAAOuB,EAAMvB,KACbooB,EAAUrV,EAAS/S,KACvB,KACE5J,EAAQ4J,EAAKyjB,cACbrtB,EAAQ4J,EAAKyX,SACXrhB,EAAQgyB,IACNhyB,EAAQgyB,EAAQ3E,cAChBrtB,EAAQgyB,EAAQ3Q,SALtB,CAYA,IAAI4Q,EAAM/E,GAAiB/hB,GAGvB+mB,EAAkB94B,EAAG+4B,mBACrBhyB,EAAM+xB,KACRD,EAAMl6B,GAAOk6B,EAAK1E,GAAe2E,KAI/BD,IAAQ74B,EAAGg5B,aACbh5B,EAAGwF,aAAa,QAASqzB,GACzB74B,EAAGg5B,WAAaH,IAIpB,IA4YIvmB,GAAKlK,GAAK9C,GAAK2zB,GAASC,GAAeC,GA5YvCC,GAAQ,CACVx9B,OAAQ+8B,GACR1oB,OAAQ0oB,IAKNU,GAAsB,gBAE1B,SAASC,GAAcC,GACrB,IAQI5+B,EAAG6+B,EAAMl/B,EAAGixB,EAAYkO,EARxBC,GAAW,EACXC,GAAW,EACXC,GAAmB,EACnBC,GAAU,EACVC,EAAQ,EACRC,EAAS,EACTC,EAAQ,EACRC,EAAkB,EAGtB,IAAK3/B,EAAI,EAAGA,EAAIi/B,EAAI57B,OAAQrD,IAG1B,GAFAk/B,EAAO7+B,EACPA,EAAI4+B,EAAIzsB,WAAWxS,GACfo/B,EACQ,KAAN/+B,GAAuB,KAAT6+B,IAAiBE,GAAW,QACzC,GAAIC,EACC,KAANh/B,GAAuB,KAAT6+B,IAAiBG,GAAW,QACzC,GAAIC,EACC,KAANj/B,GAAuB,KAAT6+B,IAAiBI,GAAmB,QACjD,GAAIC,EACC,KAANl/B,GAAuB,KAAT6+B,IAAiBK,GAAU,QACxC,GACC,MAANl/B,GAC0B,MAA1B4+B,EAAIzsB,WAAWxS,EAAI,IACO,MAA1Bi/B,EAAIzsB,WAAWxS,EAAI,IAClBw/B,GAAUC,GAAWC,EASjB,CACL,OAAQr/B,GACN,KAAK,GAAMg/B,GAAW,EAAM,MAC5B,KAAK,GAAMD,GAAW,EAAM,MAC5B,KAAK,GAAME,GAAmB,EAAM,MACpC,KAAK,GAAMI,IAAS,MACpB,KAAK,GAAMA,IAAS,MACpB,KAAK,GAAMD,IAAU,MACrB,KAAK,GAAMA,IAAU,MACrB,KAAK,IAAMD,IAAS,MACpB,KAAK,IAAMA,IAEb,GAAU,KAANn/B,EAAY,CAId,IAHA,IAAIwuB,EAAI7uB,EAAI,EACR8B,OAAI,EAED+sB,GAAK,GAEA,OADV/sB,EAAIm9B,EAAIzzB,OAAOqjB,IADFA,KAIV/sB,GAAMi9B,GAAoBtrB,KAAK3R,KAClCy9B,GAAU,cA5BK/yB,IAAfykB,GAEF0O,EAAkB3/B,EAAI,EACtBixB,EAAagO,EAAIxzB,MAAM,EAAGzL,GAAG4/B,QAE7BC,IAmCN,SAASA,KACNV,IAAYA,EAAU,KAAKl6B,KAAKg6B,EAAIxzB,MAAMk0B,EAAiB3/B,GAAG4/B,QAC/DD,EAAkB3/B,EAAI,EAGxB,QAXmBwM,IAAfykB,EACFA,EAAagO,EAAIxzB,MAAM,EAAGzL,GAAG4/B,OACA,IAApBD,GACTE,IAQEV,EACF,IAAKn/B,EAAI,EAAGA,EAAIm/B,EAAQ97B,OAAQrD,IAC9BixB,EAAa6O,GAAW7O,EAAYkO,EAAQn/B,IAIhD,OAAOixB,EAGT,SAAS6O,GAAYb,EAAKt6B,GACxB,IAAI3E,EAAI2E,EAAO2J,QAAQ,KACvB,GAAItO,EAAI,EAEN,MAAQ,OAAU2E,EAAS,MAASs6B,EAAM,IAE1C,IAAI1+B,EAAOoE,EAAO8G,MAAM,EAAGzL,GACvB+X,EAAOpT,EAAO8G,MAAMzL,EAAI,GAC5B,MAAQ,OAAUO,EAAO,MAAS0+B,GAAgB,MAATlnB,EAAe,IAAMA,EAAOA,GASzE,SAASgoB,GAAUC,EAAKC,GACtBz9B,QAAQC,MAAO,mBAAqBu9B,GAItC,SAASE,GACPhgC,EACAqB,GAEA,OAAOrB,EACHA,EAAQqF,KAAI,SAAUnF,GAAK,OAAOA,EAAEmB,MAASoD,QAAO,SAAUmK,GAAK,OAAOA,KAC1E,GAGN,SAASqxB,GAASz6B,EAAInF,EAAMU,EAAOg/B,EAAOG,IACvC16B,EAAGsV,QAAUtV,EAAGsV,MAAQ,KAAK/V,KAAKo7B,GAAa,CAAE9/B,KAAMA,EAAMU,MAAOA,EAAOm/B,QAASA,GAAWH,IAChGv6B,EAAG46B,OAAQ,EAGb,SAASC,GAAS76B,EAAInF,EAAMU,EAAOg/B,EAAOG,IAC5BA,EACP16B,EAAG86B,eAAiB96B,EAAG86B,aAAe,IACtC96B,EAAGyc,QAAUzc,EAAGyc,MAAQ,KACvBld,KAAKo7B,GAAa,CAAE9/B,KAAMA,EAAMU,MAAOA,EAAOm/B,QAASA,GAAWH,IACxEv6B,EAAG46B,OAAQ,EAIb,SAASG,GAAY/6B,EAAInF,EAAMU,EAAOg/B,GACpCv6B,EAAGg7B,SAASngC,GAAQU,EACpByE,EAAGi7B,UAAU17B,KAAKo7B,GAAa,CAAE9/B,KAAMA,EAAMU,MAAOA,GAASg/B,IAG/D,SAASW,GACPl7B,EACAnF,EACAi9B,EACAv8B,EACAg8B,EACA4D,EACAvD,EACA2C,IAECv6B,EAAGiW,aAAejW,EAAGiW,WAAa,KAAK1W,KAAKo7B,GAAa,CACxD9/B,KAAMA,EACNi9B,QAASA,EACTv8B,MAAOA,EACPg8B,IAAKA,EACL4D,aAAcA,EACdvD,UAAWA,GACV2C,IACHv6B,EAAG46B,OAAQ,EAGb,SAASQ,GAAuB5a,EAAQ3lB,EAAM6/B,GAC5C,OAAOA,EACF,MAAQ7/B,EAAO,KAAQ2lB,EAAS,KACjCA,EAAS3lB,EAGf,SAASwgC,GACPr7B,EACAnF,EACAU,EACAq8B,EACA0D,EACAhsB,EACAirB,EACAG,GAiDA,IAAIa,GA/CJ3D,EAAYA,GAAalxB,GAiBX80B,MACRd,EACF7/B,EAAO,IAAMA,EAAO,8BAAgCA,EAAO,IACzC,UAATA,IACTA,EAAO,qBACA+8B,EAAU4D,OAEV5D,EAAU6D,SACff,EACF7/B,EAAO,IAAMA,EAAO,0BAA4BA,EAAO,IACrC,UAATA,IACTA,EAAO,YAKP+8B,EAAUxd,iBACLwd,EAAUxd,QACjBvf,EAAOugC,GAAsB,IAAKvgC,EAAM6/B,IAEtC9C,EAAUrsB,cACLqsB,EAAUrsB,KACjB1Q,EAAOugC,GAAsB,IAAKvgC,EAAM6/B,IAGtC9C,EAAU1d,iBACL0d,EAAU1d,QACjBrf,EAAOugC,GAAsB,IAAKvgC,EAAM6/B,IAItC9C,EAAU8D,eACL9D,EAAU8D,OACjBH,EAASv7B,EAAG27B,eAAiB37B,EAAG27B,aAAe,KAE/CJ,EAASv7B,EAAGu7B,SAAWv7B,EAAGu7B,OAAS,IAGrC,IAAIK,EAAajB,GAAa,CAAEp/B,MAAOA,EAAM2+B,OAAQQ,QAASA,GAAWH,GACrE3C,IAAclxB,IAChBk1B,EAAWhE,UAAYA,GAGzB,IAAI1O,EAAWqS,EAAO1gC,GAElBmC,MAAM8K,QAAQohB,GAChBoS,EAAYpS,EAAS2J,QAAQ+I,GAAc1S,EAAS3pB,KAAKq8B,GAEzDL,EAAO1gC,GADEquB,EACMoS,EAAY,CAACM,EAAY1S,GAAY,CAACA,EAAU0S,GAEhDA,EAGjB57B,EAAG46B,OAAQ,EAYb,SAASiB,GACP77B,EACAnF,EACAihC,GAEA,IAAIC,EACFC,GAAiBh8B,EAAI,IAAMnF,IAC3BmhC,GAAiBh8B,EAAI,UAAYnF,GACnC,GAAoB,MAAhBkhC,EACF,OAAOzC,GAAayC,GACf,IAAkB,IAAdD,EAAqB,CAC9B,IAAIG,EAAcD,GAAiBh8B,EAAInF,GACvC,GAAmB,MAAfohC,EACF,OAAOl0B,KAAKC,UAAUi0B,IAS5B,SAASD,GACPh8B,EACAnF,EACAqhC,GAEA,IAAIh3B,EACJ,GAAiC,OAA5BA,EAAMlF,EAAGg7B,SAASngC,IAErB,IADA,IAAIyN,EAAOtI,EAAGi7B,UACL3gC,EAAI,EAAGC,EAAI+N,EAAK3K,OAAQrD,EAAIC,EAAGD,IACtC,GAAIgO,EAAKhO,GAAGO,OAASA,EAAM,CACzByN,EAAKO,OAAOvO,EAAG,GACf,MAON,OAHI4hC,UACKl8B,EAAGg7B,SAASngC,GAEdqK,EAGT,SAASi3B,GACPn8B,EACAnF,GAGA,IADA,IAAIyN,EAAOtI,EAAGi7B,UACL3gC,EAAI,EAAGC,EAAI+N,EAAK3K,OAAQrD,EAAIC,EAAGD,IAAK,CAC3C,IAAIg5B,EAAOhrB,EAAKhO,GAChB,GAAIO,EAAKkT,KAAKulB,EAAKz4B,MAEjB,OADAyN,EAAKO,OAAOvO,EAAG,GACRg5B,GAKb,SAASqH,GACPjyB,EACA6xB,GAUA,OARIA,IACiB,MAAfA,EAAMtwB,QACRvB,EAAKuB,MAAQswB,EAAMtwB,OAEJ,MAAbswB,EAAM6B,MACR1zB,EAAK0zB,IAAM7B,EAAM6B,MAGd1zB,EAQT,SAAS2zB,GACPr8B,EACAzE,EACAq8B,GAEA,IAAIjG,EAAMiG,GAAa,GACnB0E,EAAS3K,EAAI2K,OAGbC,EAAsB,MACtBC,EAAkBD,EAHX5K,EAAIuI,OAKbsC,EACE,8CAIAF,IACFE,EAAkB,MAAQA,EAAkB,KAE9C,IAAIC,EAAaC,GAAkBnhC,EAAOihC,GAE1Cx8B,EAAG6mB,MAAQ,CACTtrB,MAAQ,IAAMA,EAAQ,IACtBgwB,WAAYxjB,KAAKC,UAAUzM,GAC3BgG,SAAW,mBAA6Ck7B,EAAa,KAOzE,SAASC,GACPnhC,EACAkhC,GAEA,IAAIlyB,EA2BN,SAAqBrF,GAMnB,GAHAA,EAAMA,EAAIg1B,OACV5nB,GAAMpN,EAAIvH,OAENuH,EAAI0D,QAAQ,KAAO,GAAK1D,EAAIy3B,YAAY,KAAOrqB,GAAM,EAEvD,OADA2mB,GAAU/zB,EAAIy3B,YAAY,OACX,EACN,CACLpD,IAAKr0B,EAAIa,MAAM,EAAGkzB,IAClBp9B,IAAK,IAAMqJ,EAAIa,MAAMkzB,GAAU,GAAK,KAG/B,CACLM,IAAKr0B,EACLrJ,IAAK,MAKXuM,GAAMlD,EACN+zB,GAAUC,GAAgBC,GAAmB,EAE7C,MAAQyD,MAGFC,GAFJv3B,GAAM5F,MAGJo9B,GAAYx3B,IACK,KAARA,IACTy3B,GAAaz3B,IAIjB,MAAO,CACLi0B,IAAKr0B,EAAIa,MAAM,EAAGmzB,IAClBr9B,IAAKqJ,EAAIa,MAAMmzB,GAAgB,EAAGC,KA/D1B6D,CAAWzhC,GACrB,OAAgB,OAAZgP,EAAI1O,IACEN,EAAQ,IAAMkhC,EAEd,QAAWlyB,EAAO,IAAI,KAAQA,EAAO,IAAI,KAAOkyB,EAAa,IA+DzE,SAAS/8B,KACP,OAAO0I,GAAI0E,aAAamsB,IAG1B,SAAS2D,KACP,OAAO3D,IAAW3mB,GAGpB,SAASuqB,GAAev3B,GACtB,OAAe,KAARA,GAAwB,KAARA,EAGzB,SAASy3B,GAAcz3B,GACrB,IAAI23B,EAAY,EAEhB,IADA/D,GAAgBD,IACR2D,MAEN,GAAIC,GADJv3B,EAAM5F,MAEJo9B,GAAYx3B,QAKd,GAFY,KAARA,GAAgB23B,IACR,KAAR33B,GAAgB23B,IACF,IAAdA,EAAiB,CACnB9D,GAAmBF,GACnB,OAKN,SAAS6D,GAAax3B,GAEpB,IADA,IAAI43B,EAAc53B,GACVs3B,OACNt3B,EAAM5F,QACMw9B,KAYhB,IAgMIC,GAhMAC,GAAc,MAkMlB,SAASC,GAAqBtiB,EAAOjZ,EAASsY,GAC5C,IAAIsO,EAAUyU,GACd,OAAO,SAASxU,IACd,IAAIpe,EAAMzI,EAAQgI,MAAM,KAAMD,WAClB,OAARU,GACF+yB,GAASviB,EAAO4N,EAAavO,EAASsO,IAQ5C,IAAI6U,GAAkB9kB,MAAsBtK,IAAQrN,OAAOqN,GAAK,KAAO,IAEvE,SAASqvB,GACP3iC,EACAiH,EACAsY,EACAF,GAQA,GAAIqjB,GAAiB,CACnB,IAAIE,EAAoBhU,GACpBrX,EAAWtQ,EACfA,EAAUsQ,EAASsrB,SAAW,SAAUt9B,GACtC,GAIEA,EAAE2B,SAAW3B,EAAEu9B,eAEfv9B,EAAEypB,WAAa4T,GAIfr9B,EAAEypB,WAAa,GAIfzpB,EAAE2B,OAAO67B,gBAAkBn/B,SAE3B,OAAO2T,EAAStI,MAAM/J,KAAM8J,YAIlCszB,GAASl7B,iBACPpH,EACAiH,EACAyM,GACI,CAAE6L,QAASA,EAASF,QAASA,GAC7BE,GAIR,SAASkjB,GACPziC,EACAiH,EACAsY,EACAsO,IAECA,GAAWyU,IAAUn7B,oBACpBnH,EACAiH,EAAQ47B,UAAY57B,EACpBsY,GAIJ,SAASyjB,GAAoBta,EAAUxR,GACrC,IAAInL,EAAQ2c,EAAS/S,KAAKkK,MAAO9T,EAAQmL,EAAMvB,KAAKkK,IAApD,CAGA,IAAIA,EAAK3I,EAAMvB,KAAKkK,IAAM,GACtBC,EAAQ4I,EAAS/S,KAAKkK,IAAM,GAChCyiB,GAAWprB,EAAMrB,IAlGnB,SAA0BgK,GAExB,GAAI3T,EAAM2T,EAAc,KAAI,CAE1B,IAAIK,EAAQjN,EAAO,SAAW,QAC9B4M,EAAGK,GAAS,GAAGpc,OAAO+b,EAAc,IAAGA,EAAGK,IAAU,WAC7CL,EAAc,IAKnB3T,EAAM2T,EAAuB,OAC/BA,EAAGojB,OAAS,GAAGn/B,OAAO+b,EAAuB,IAAGA,EAAGojB,QAAU,WACtDpjB,EAAuB,KAsFhCqjB,CAAgBrjB,GAChBD,GAAgBC,EAAIC,EAAO6iB,GAAOF,GAAUD,GAAqBtrB,EAAM9N,SACvEk5B,QAAWr2B,GAGb,IAOIk3B,GAPAzC,GAAS,CACX3/B,OAAQiiC,GACR5tB,OAAQ4tB,IAOV,SAASI,GAAgB1a,EAAUxR,GACjC,IAAInL,EAAQ2c,EAAS/S,KAAK2O,YAAavY,EAAQmL,EAAMvB,KAAK2O,UAA1D,CAGA,IAAItjB,EAAKoc,EACLvH,EAAMqB,EAAMrB,IACZwtB,EAAW3a,EAAS/S,KAAK2O,UAAY,GACrC7J,EAAQvD,EAAMvB,KAAK2O,UAAY,GAMnC,IAAKtjB,KAJDkL,EAAMuO,EAAM5C,UACd4C,EAAQvD,EAAMvB,KAAK2O,SAAWhV,EAAO,GAAImL,IAG/B4oB,EACJriC,KAAOyZ,IACX5E,EAAI7U,GAAO,IAIf,IAAKA,KAAOyZ,EAAO,CAKjB,GAJA2C,EAAM3C,EAAMzZ,GAIA,gBAARA,GAAiC,cAARA,EAAqB,CAEhD,GADIkW,EAAM/S,WAAY+S,EAAM/S,SAASrB,OAAS,GAC1Csa,IAAQimB,EAASriC,GAAQ,SAGC,IAA1B6U,EAAIytB,WAAWxgC,QACjB+S,EAAIglB,YAAYhlB,EAAIytB,WAAW,IAInC,GAAY,UAARtiC,GAAmC,aAAhB6U,EAAIwkB,QAAwB,CAGjDxkB,EAAI0tB,OAASnmB,EAEb,IAAIomB,EAASz3B,EAAQqR,GAAO,GAAK1Q,OAAO0Q,GACpCqmB,GAAkB5tB,EAAK2tB,KACzB3tB,EAAInV,MAAQ8iC,QAET,GAAY,cAARxiC,GAAuB+4B,GAAMlkB,EAAIwkB,UAAYtuB,EAAQ8J,EAAI6tB,WAAY,EAE9EP,GAAeA,IAAgBv/B,SAAS4jB,cAAc,QACzCkc,UAAY,QAAUtmB,EAAM,SAEzC,IADA,IAAIwc,EAAMuJ,GAAaQ,WAChB9tB,EAAI8tB,YACT9tB,EAAIglB,YAAYhlB,EAAI8tB,YAEtB,KAAO/J,EAAI+J,YACT9tB,EAAIilB,YAAYlB,EAAI+J,iBAEjB,GAKLvmB,IAAQimB,EAASriC,GAIjB,IACE6U,EAAI7U,GAAOoc,EACX,MAAO7X,QAQf,SAASk+B,GAAmB5tB,EAAK+tB,GAC/B,OAAS/tB,EAAIguB,YACK,WAAhBhuB,EAAIwkB,SAMR,SAA+BxkB,EAAK+tB,GAGlC,IAAIE,GAAa,EAGjB,IAAMA,EAAalgC,SAASmgC,gBAAkBluB,EAAO,MAAOtQ,KAC5D,OAAOu+B,GAAcjuB,EAAInV,QAAUkjC,EAZjCI,CAAqBnuB,EAAK+tB,IAe9B,SAA+B/tB,EAAKwD,GAClC,IAAI3Y,EAAQmV,EAAInV,MACZq8B,EAAYlnB,EAAIouB,YACpB,GAAI/3B,EAAM6wB,GAAY,CACpB,GAAIA,EAAU0E,OACZ,OAAOr0B,EAAS1M,KAAW0M,EAASiM,GAEtC,GAAI0jB,EAAUsC,KACZ,OAAO3+B,EAAM2+B,SAAWhmB,EAAOgmB,OAGnC,OAAO3+B,IAAU2Y,EAzBf6qB,CAAqBruB,EAAK+tB,IA4B9B,IAAItf,GAAW,CACbvjB,OAAQqiC,GACRhuB,OAAQguB,IAKNe,GAAiBj2B,GAAO,SAAUk2B,GACpC,IAAI10B,EAAM,GAEN20B,EAAoB,QAOxB,OANAD,EAAQh+B,MAFY,iBAES2B,SAAQ,SAAU8F,GAC7C,GAAIA,EAAM,CACR,IAAIkjB,EAAMljB,EAAKzH,MAAMi+B,GACrBtT,EAAIjuB,OAAS,IAAM4M,EAAIqhB,EAAI,GAAGsO,QAAUtO,EAAI,GAAGsO,YAG5C3vB,KAIT,SAAS40B,GAAoB3uB,GAC3B,IAAIwX,EAAQoX,GAAsB5uB,EAAKwX,OAGvC,OAAOxX,EAAK6uB,YACRl1B,EAAOqG,EAAK6uB,YAAarX,GACzBA,EAIN,SAASoX,GAAuBE,GAC9B,OAAItiC,MAAM8K,QAAQw3B,GACTh1B,EAASg1B,GAEU,kBAAjBA,EACFN,GAAeM,GAEjBA,EAuCT,IAyBIC,GAzBAC,GAAW,MACXC,GAAc,iBACdC,GAAU,SAAU1/B,EAAInF,EAAMqK,GAEhC,GAAIs6B,GAASzxB,KAAKlT,GAChBmF,EAAGgoB,MAAM2X,YAAY9kC,EAAMqK,QACtB,GAAIu6B,GAAY1xB,KAAK7I,GAC1BlF,EAAGgoB,MAAM2X,YAAYn2B,EAAU3O,GAAOqK,EAAIG,QAAQo6B,GAAa,IAAK,iBAC/D,CACL,IAAIG,EAAiBC,GAAUhlC,GAC/B,GAAImC,MAAM8K,QAAQ5C,GAIhB,IAAK,IAAI5K,EAAI,EAAGgY,EAAMpN,EAAIvH,OAAQrD,EAAIgY,EAAKhY,IACzC0F,EAAGgoB,MAAM4X,GAAkB16B,EAAI5K,QAGjC0F,EAAGgoB,MAAM4X,GAAkB16B,IAK7B46B,GAAc,CAAC,SAAU,MAAO,MAGhCD,GAAY92B,GAAO,SAAUkO,GAG/B,GAFAsoB,GAAaA,IAAc9gC,SAAS4jB,cAAc,OAAO2F,MAE5C,YADb/Q,EAAO9N,EAAS8N,KACUA,KAAQsoB,GAChC,OAAOtoB,EAGT,IADA,IAAI8oB,EAAU9oB,EAAKnR,OAAO,GAAGuD,cAAgB4N,EAAKlR,MAAM,GAC/CzL,EAAI,EAAGA,EAAIwlC,GAAYniC,OAAQrD,IAAK,CAC3C,IAAIO,EAAOilC,GAAYxlC,GAAKylC,EAC5B,GAAIllC,KAAQ0kC,GACV,OAAO1kC,MAKb,SAASmlC,GAAazc,EAAUxR,GAC9B,IAAIvB,EAAOuB,EAAMvB,KACbooB,EAAUrV,EAAS/S,KAEvB,KAAI5J,EAAQ4J,EAAK6uB,cAAgBz4B,EAAQ4J,EAAKwX,QAC5CphB,EAAQgyB,EAAQyG,cAAgBz4B,EAAQgyB,EAAQ5Q,QADlD,CAMA,IAAI/P,EAAKpd,EACLmF,EAAK+R,EAAMrB,IACXuvB,EAAiBrH,EAAQyG,YACzBa,EAAkBtH,EAAQuH,iBAAmBvH,EAAQ5Q,OAAS,GAG9DoY,EAAWH,GAAkBC,EAE7BlY,EAAQoX,GAAsBrtB,EAAMvB,KAAKwX,QAAU,GAKvDjW,EAAMvB,KAAK2vB,gBAAkBp5B,EAAMihB,EAAMtV,QACrCvI,EAAO,GAAI6d,GACXA,EAEJ,IAAIqY,EApGN,SAAmBtuB,EAAOuuB,GACxB,IACIC,EADAh2B,EAAM,GAGV,GAAI+1B,EAEF,IADA,IAAIvM,EAAYhiB,EACTgiB,EAAU/iB,oBACf+iB,EAAYA,EAAU/iB,kBAAkB+S,SAEzBgQ,EAAUvjB,OACtB+vB,EAAYpB,GAAmBpL,EAAUvjB,QAE1CrG,EAAOI,EAAKg2B,IAKbA,EAAYpB,GAAmBptB,EAAMvB,QACxCrG,EAAOI,EAAKg2B,GAId,IADA,IAAIjhC,EAAayS,EACTzS,EAAaA,EAAW8E,QAC1B9E,EAAWkR,OAAS+vB,EAAYpB,GAAmB7/B,EAAWkR,QAChErG,EAAOI,EAAKg2B,GAGhB,OAAOh2B,EAyEQi2B,CAASzuB,GAAO,GAE/B,IAAKlX,KAAQulC,EACPx5B,EAAQy5B,EAASxlC,KACnB6kC,GAAQ1/B,EAAInF,EAAM,IAGtB,IAAKA,KAAQwlC,GACXpoB,EAAMooB,EAASxlC,MACHulC,EAASvlC,IAEnB6kC,GAAQ1/B,EAAInF,EAAa,MAAPod,EAAc,GAAKA,IAK3C,IAAI+P,GAAQ,CACVpsB,OAAQokC,GACR/vB,OAAQ+vB,IAKNS,GAAe,MAMnB,SAASC,GAAU1gC,EAAI64B,GAErB,GAAKA,IAASA,EAAMA,EAAIqB,QAKxB,GAAIl6B,EAAG/B,UACD46B,EAAIjwB,QAAQ,MAAQ,EACtBiwB,EAAI53B,MAAMw/B,IAAc79B,SAAQ,SAAUjI,GAAK,OAAOqF,EAAG/B,UAAUsG,IAAI5J,MAEvEqF,EAAG/B,UAAUsG,IAAIs0B,OAEd,CACL,IAAI5gB,EAAM,KAAOjY,EAAG3B,aAAa,UAAY,IAAM,IAC/C4Z,EAAIrP,QAAQ,IAAMiwB,EAAM,KAAO,GACjC74B,EAAGwF,aAAa,SAAUyS,EAAM4gB,GAAKqB,SAS3C,SAASyG,GAAa3gC,EAAI64B,GAExB,GAAKA,IAASA,EAAMA,EAAIqB,QAKxB,GAAIl6B,EAAG/B,UACD46B,EAAIjwB,QAAQ,MAAQ,EACtBiwB,EAAI53B,MAAMw/B,IAAc79B,SAAQ,SAAUjI,GAAK,OAAOqF,EAAG/B,UAAUuE,OAAO7H,MAE1EqF,EAAG/B,UAAUuE,OAAOq2B,GAEjB74B,EAAG/B,UAAUN,QAChBqC,EAAGyF,gBAAgB,aAEhB,CAGL,IAFA,IAAIwS,EAAM,KAAOjY,EAAG3B,aAAa,UAAY,IAAM,IAC/CuiC,EAAM,IAAM/H,EAAM,IACf5gB,EAAIrP,QAAQg4B,IAAQ,GACzB3oB,EAAMA,EAAI5S,QAAQu7B,EAAK,MAEzB3oB,EAAMA,EAAIiiB,QAERl6B,EAAGwF,aAAa,QAASyS,GAEzBjY,EAAGyF,gBAAgB,UAOzB,SAASo7B,GAAmB3qB,GAC1B,GAAKA,EAAL,CAIA,GAAsB,kBAAXA,EAAqB,CAC9B,IAAI3L,EAAM,GAKV,OAJmB,IAAf2L,EAAO4qB,KACT32B,EAAOI,EAAKw2B,GAAkB7qB,EAAOrb,MAAQ,MAE/CsP,EAAOI,EAAK2L,GACL3L,EACF,MAAsB,kBAAX2L,EACT6qB,GAAkB7qB,QADpB,GAKT,IAAI6qB,GAAoBh4B,GAAO,SAAUlO,GACvC,MAAO,CACLmmC,WAAanmC,EAAO,SACpBomC,aAAepmC,EAAO,YACtBqmC,iBAAmBrmC,EAAO,gBAC1BsmC,WAAatmC,EAAO,SACpBumC,aAAevmC,EAAO,YACtBwmC,iBAAmBxmC,EAAO,oBAI1BymC,GAAgBh0B,IAAcU,EAC9BuzB,GAAa,aACbC,GAAY,YAGZC,GAAiB,aACjBC,GAAqB,gBACrBC,GAAgB,YAChBC,GAAoB,eACpBN,UAE6Bx6B,IAA3BlG,OAAOihC,sBACwB/6B,IAAjClG,OAAOkhC,wBAEPL,GAAiB,mBACjBC,GAAqB,4BAEO56B,IAA1BlG,OAAOmhC,qBACuBj7B,IAAhClG,OAAOohC,uBAEPL,GAAgB,kBAChBC,GAAoB,uBAKxB,IAAIK,GAAM30B,EACN1M,OAAOshC,sBACLthC,OAAOshC,sBAAsBpmC,KAAK8E,QAClCsB,WACyB,SAAU8G,GAAM,OAAOA,KAEtD,SAASm5B,GAAWn5B,GAClBi5B,IAAI,WACFA,GAAIj5B,MAIR,SAASo5B,GAAoBpiC,EAAI64B,GAC/B,IAAIwJ,EAAoBriC,EAAG+4B,qBAAuB/4B,EAAG+4B,mBAAqB,IACtEsJ,EAAkBz5B,QAAQiwB,GAAO,IACnCwJ,EAAkB9iC,KAAKs5B,GACvB6H,GAAS1gC,EAAI64B,IAIjB,SAASyJ,GAAuBtiC,EAAI64B,GAC9B74B,EAAG+4B,oBACLv2B,EAAOxC,EAAG+4B,mBAAoBF,GAEhC8H,GAAY3gC,EAAI64B,GAGlB,SAAS0J,GACPviC,EACAwiC,EACAhpB,GAEA,IAAImY,EAAM8Q,GAAkBziC,EAAIwiC,GAC5BptB,EAAOuc,EAAIvc,KACXqR,EAAUkL,EAAIlL,QACdic,EAAY/Q,EAAI+Q,UACpB,IAAKttB,EAAQ,OAAOoE,IACpB,IAAIuB,EAAQ3F,IAASmsB,GAAaG,GAAqBE,GACnDe,EAAQ,EACRvG,EAAM,WACRp8B,EAAGgC,oBAAoB+Y,EAAO6nB,GAC9BppB,KAEEopB,EAAQ,SAAUxiC,GAChBA,EAAE2B,SAAW/B,KACT2iC,GAASD,GACbtG,KAINl6B,YAAW,WACLygC,EAAQD,GACVtG,MAED3V,EAAU,GACbzmB,EAAGiC,iBAAiB8Y,EAAO6nB,GAG7B,IAAIC,GAAc,yBAElB,SAASJ,GAAmBziC,EAAIwiC,GAC9B,IASIptB,EATA0tB,EAASliC,OAAOhD,iBAAiBoC,GAEjC+iC,GAAoBD,EAAOrB,GAAiB,UAAY,IAAIxgC,MAAM,MAClE+hC,GAAuBF,EAAOrB,GAAiB,aAAe,IAAIxgC,MAAM,MACxEgiC,EAAoBC,GAAWH,EAAkBC,GACjDG,GAAmBL,EAAOnB,GAAgB,UAAY,IAAI1gC,MAAM,MAChEmiC,GAAsBN,EAAOnB,GAAgB,aAAe,IAAI1gC,MAAM,MACtEoiC,EAAmBH,GAAWC,EAAiBC,GAG/C3c,EAAU,EACVic,EAAY,EA8BhB,OA5BIF,IAAiBjB,GACf0B,EAAoB,IACtB7tB,EAAOmsB,GACP9a,EAAUwc,EACVP,EAAYM,EAAoBrlC,QAEzB6kC,IAAiBhB,GACtB6B,EAAmB,IACrBjuB,EAAOosB,GACP/a,EAAU4c,EACVX,EAAYU,EAAmBzlC,QASjC+kC,GALAttB,GADAqR,EAAUjf,KAAK2M,IAAI8uB,EAAmBI,IACrB,EACbJ,EAAoBI,EAClB9B,GACAC,GACF,MAEApsB,IAASmsB,GACPyB,EAAoBrlC,OACpBylC,EAAmBzlC,OACrB,EAKC,CACLyX,KAAMA,EACNqR,QAASA,EACTic,UAAWA,EACXY,aANAluB,IAASmsB,IACTsB,GAAY90B,KAAK+0B,EAAOrB,GAAiB,cAS7C,SAASyB,GAAYK,EAAQC,GAE3B,KAAOD,EAAO5lC,OAAS6lC,EAAU7lC,QAC/B4lC,EAASA,EAAO5kC,OAAO4kC,GAGzB,OAAO/7B,KAAK2M,IAAIrK,MAAM,KAAM05B,EAAU3jC,KAAI,SAAUjF,EAAGN,GACrD,OAAOmpC,GAAK7oC,GAAK6oC,GAAKF,EAAOjpC,QAQjC,SAASmpC,GAAMpnC,GACb,OAAkD,IAA3CyE,OAAOzE,EAAE0J,MAAM,GAAI,GAAGV,QAAQ,IAAK,MAK5C,SAASq+B,GAAO3xB,EAAO4xB,GACrB,IAAI3jC,EAAK+R,EAAMrB,IAGX3J,EAAM/G,EAAG4jC,YACX5jC,EAAG4jC,SAASC,WAAY,EACxB7jC,EAAG4jC,YAGL,IAAIpzB,EAAOqwB,GAAkB9uB,EAAMvB,KAAKszB,YACxC,IAAIl9B,EAAQ4J,KAKRzJ,EAAM/G,EAAG+jC,WAA6B,IAAhB/jC,EAAGxC,SAA7B,CA4BA,IAxBA,IAAIsjC,EAAMtwB,EAAKswB,IACX1rB,EAAO5E,EAAK4E,KACZ4rB,EAAaxwB,EAAKwwB,WAClBC,EAAezwB,EAAKywB,aACpBC,EAAmB1wB,EAAK0wB,iBACxB8C,EAAcxzB,EAAKwzB,YACnBC,EAAgBzzB,EAAKyzB,cACrBC,EAAoB1zB,EAAK0zB,kBACzBC,EAAc3zB,EAAK2zB,YACnBT,EAAQlzB,EAAKkzB,MACbU,EAAa5zB,EAAK4zB,WAClBC,EAAiB7zB,EAAK6zB,eACtBC,EAAe9zB,EAAK8zB,aACpBC,EAAS/zB,EAAK+zB,OACdC,EAAch0B,EAAKg0B,YACnBC,EAAkBj0B,EAAKi0B,gBACvBC,EAAWl0B,EAAKk0B,SAMhBzgC,EAAUof,GACVshB,EAAiBthB,GAAenf,OAC7BygC,GAAkBA,EAAevgC,QACtCH,EAAU0gC,EAAe1gC,QACzB0gC,EAAiBA,EAAevgC,OAGlC,IAAIwgC,GAAY3gC,EAAQygB,aAAe3S,EAAMZ,aAE7C,IAAIyzB,GAAaL,GAAqB,KAAXA,EAA3B,CAIA,IAAIM,EAAaD,GAAYZ,EACzBA,EACAhD,EACA8D,EAAcF,GAAYV,EAC1BA,EACAhD,EACA6D,EAAUH,GAAYX,EACtBA,EACAhD,EAEA+D,EAAkBJ,GACjBN,GACDH,EACAc,EAAYL,GACO,oBAAXL,EAAwBA,EAChCb,EACAwB,EAAiBN,GAChBJ,GACDJ,EACAe,EAAqBP,GACpBH,GACDJ,EAEAe,EAAwBn9B,EAC1Bf,EAASw9B,GACLA,EAAShB,MACTgB,GAGF,EAIJ,IAAIW,GAAqB,IAARvE,IAAkB9yB,EAC/Bs3B,EAAmBC,GAAuBN,GAE1CzrB,EAAKxZ,EAAG+jC,SAAWx4B,GAAK,WACtB85B,IACF/C,GAAsBtiC,EAAI+kC,GAC1BzC,GAAsBtiC,EAAI8kC,IAExBtrB,EAAGqqB,WACDwB,GACF/C,GAAsBtiC,EAAI6kC,GAE5BM,GAAsBA,EAAmBnlC,IAEzCklC,GAAkBA,EAAellC,GAEnCA,EAAG+jC,SAAW,QAGXhyB,EAAMvB,KAAKg1B,MAEdvqB,GAAelJ,EAAO,UAAU,WAC9B,IAAI3N,EAASpE,EAAGV,WACZmmC,EAAcrhC,GAAUA,EAAOshC,UAAYthC,EAAOshC,SAAS3zB,EAAMlW,KACjE4pC,GACFA,EAAYl1B,MAAQwB,EAAMxB,KAC1Bk1B,EAAY/0B,IAAIkzB,UAEhB6B,EAAY/0B,IAAIkzB,WAElBqB,GAAaA,EAAUjlC,EAAIwZ,MAK/BwrB,GAAmBA,EAAgBhlC,GAC/BqlC,IACFjD,GAAmBpiC,EAAI6kC,GACvBzC,GAAmBpiC,EAAI8kC,GACvB3C,IAAU,WACRG,GAAsBtiC,EAAI6kC,GACrBrrB,EAAGqqB,YACNzB,GAAmBpiC,EAAI+kC,GAClBO,IACCK,GAAgBP,GAClBljC,WAAWsX,EAAI4rB,GAEf7C,GAAmBviC,EAAIoV,EAAMoE,SAOnCzH,EAAMvB,KAAKg1B,OACb7B,GAAiBA,IACjBsB,GAAaA,EAAUjlC,EAAIwZ,IAGxB6rB,GAAeC,GAClB9rB,MAIJ,SAASosB,GAAO7zB,EAAO8zB,GACrB,IAAI7lC,EAAK+R,EAAMrB,IAGX3J,EAAM/G,EAAG+jC,YACX/jC,EAAG+jC,SAASF,WAAY,EACxB7jC,EAAG+jC,YAGL,IAAIvzB,EAAOqwB,GAAkB9uB,EAAMvB,KAAKszB,YACxC,GAAIl9B,EAAQ4J,IAAyB,IAAhBxQ,EAAGxC,SACtB,OAAOqoC,IAIT,IAAI9+B,EAAM/G,EAAG4jC,UAAb,CAIA,IAAI9C,EAAMtwB,EAAKswB,IACX1rB,EAAO5E,EAAK4E,KACZ+rB,EAAa3wB,EAAK2wB,WAClBC,EAAe5wB,EAAK4wB,aACpBC,EAAmB7wB,EAAK6wB,iBACxByE,EAAct1B,EAAKs1B,YACnBF,EAAQp1B,EAAKo1B,MACbG,EAAav1B,EAAKu1B,WAClBC,EAAiBx1B,EAAKw1B,eACtBC,EAAaz1B,EAAKy1B,WAClBvB,EAAWl0B,EAAKk0B,SAEhBW,GAAqB,IAARvE,IAAkB9yB,EAC/Bs3B,EAAmBC,GAAuBK,GAE1CM,EAAwBj+B,EAC1Bf,EAASw9B,GACLA,EAASkB,MACTlB,GAGF,EAIJ,IAAIlrB,EAAKxZ,EAAG4jC,SAAWr4B,GAAK,WACtBvL,EAAGV,YAAcU,EAAGV,WAAWomC,WACjC1lC,EAAGV,WAAWomC,SAAS3zB,EAAMlW,KAAO,MAElCwpC,IACF/C,GAAsBtiC,EAAIohC,GAC1BkB,GAAsBtiC,EAAIqhC,IAExB7nB,EAAGqqB,WACDwB,GACF/C,GAAsBtiC,EAAImhC,GAE5B6E,GAAkBA,EAAehmC,KAEjC6lC,IACAE,GAAcA,EAAW/lC,IAE3BA,EAAG4jC,SAAW,QAGZqC,EACFA,EAAWE,GAEXA,IAGF,SAASA,IAEH3sB,EAAGqqB,aAIF9xB,EAAMvB,KAAKg1B,MAAQxlC,EAAGV,cACxBU,EAAGV,WAAWomC,WAAa1lC,EAAGV,WAAWomC,SAAW,KAAM3zB,EAAS,KAAKA,GAE3E+zB,GAAeA,EAAY9lC,GACvBqlC,IACFjD,GAAmBpiC,EAAImhC,GACvBiB,GAAmBpiC,EAAIqhC,GACvBc,IAAU,WACRG,GAAsBtiC,EAAImhC,GACrB3nB,EAAGqqB,YACNzB,GAAmBpiC,EAAIohC,GAClBkE,IACCK,GAAgBO,GAClBhkC,WAAWsX,EAAI0sB,GAEf3D,GAAmBviC,EAAIoV,EAAMoE,SAMvCosB,GAASA,EAAM5lC,EAAIwZ,GACd6rB,GAAeC,GAClB9rB,MAsBN,SAASmsB,GAAiBzgC,GACxB,MAAsB,kBAARA,IAAqBgD,MAAMhD,GAS3C,SAASqgC,GAAwBv8B,GAC/B,GAAIpC,EAAQoC,GACV,OAAO,EAET,IAAIo9B,EAAap9B,EAAGsR,IACpB,OAAIvT,EAAMq/B,GAEDb,GACLvoC,MAAM8K,QAAQs+B,GACVA,EAAW,GACXA,IAGEp9B,EAAGe,SAAWf,EAAGrL,QAAU,EAIvC,SAAS0oC,GAAQj9B,EAAG2I,IACM,IAApBA,EAAMvB,KAAKg1B,MACb9B,GAAM3xB,GAIV,IA4BIu0B,GA9iFJ,SAA8BC,GAC5B,IAAIjsC,EAAG6uB,EACH4H,EAAM,GAENv2B,EAAU+rC,EAAQ/rC,QAClBy6B,EAAUsR,EAAQtR,QAEtB,IAAK36B,EAAI,EAAGA,EAAI2a,GAAMtX,SAAUrD,EAE9B,IADAy2B,EAAI9b,GAAM3a,IAAM,GACX6uB,EAAI,EAAGA,EAAI3uB,EAAQmD,SAAUwrB,EAC5BpiB,EAAMvM,EAAQ2uB,GAAGlU,GAAM3a,MACzBy2B,EAAI9b,GAAM3a,IAAIiF,KAAK/E,EAAQ2uB,GAAGlU,GAAM3a,KAmB1C,SAASksC,EAAYxmC,GACnB,IAAIoE,EAAS6wB,EAAQ31B,WAAWU,GAE5B+G,EAAM3C,IACR6wB,EAAQS,YAAYtxB,EAAQpE,GAsBhC,SAASymC,EACP10B,EACA20B,EACAC,EACAC,EACAC,EACAC,EACAn+B,GAYA,GAVI5B,EAAMgL,EAAMrB,MAAQ3J,EAAM+/B,KAM5B/0B,EAAQ+0B,EAAWn+B,GAASmJ,GAAWC,IAGzCA,EAAMZ,cAAgB01B,GAiDxB,SAA0B90B,EAAO20B,EAAoBC,EAAWC,GAC9D,IAAItsC,EAAIyX,EAAMvB,KACd,GAAIzJ,EAAMzM,GAAI,CACZ,IAAIysC,EAAgBhgC,EAAMgL,EAAMf,oBAAsB1W,EAAEwoB,UAQxD,GAPI/b,EAAMzM,EAAIA,EAAEsJ,OAASmD,EAAMzM,EAAIA,EAAEqoB,OACnCroB,EAAEyX,GAAO,GAMPhL,EAAMgL,EAAMf,mBAMd,OALAg2B,EAAcj1B,EAAO20B,GACrBjiB,EAAOkiB,EAAW50B,EAAMrB,IAAKk2B,GACzB5/B,EAAO+/B,IA0BjB,SAA8Bh1B,EAAO20B,EAAoBC,EAAWC,GAClE,IAAItsC,EAKA2sC,EAAYl1B,EAChB,KAAOk1B,EAAUj2B,mBAEf,GAAIjK,EAAMzM,GADV2sC,EAAYA,EAAUj2B,kBAAkB+S,QAChBvT,OAASzJ,EAAMzM,EAAIA,EAAEwpC,YAAa,CACxD,IAAKxpC,EAAI,EAAGA,EAAIy2B,EAAImW,SAASvpC,SAAUrD,EACrCy2B,EAAImW,SAAS5sC,GAAG87B,GAAW6Q,GAE7BP,EAAmBnnC,KAAK0nC,GACxB,MAKJxiB,EAAOkiB,EAAW50B,EAAMrB,IAAKk2B,GA5CvBO,CAAoBp1B,EAAO20B,EAAoBC,EAAWC,IAErD,GAjEPzhB,CAAgBpT,EAAO20B,EAAoBC,EAAWC,GAA1D,CAIA,IAAIp2B,EAAOuB,EAAMvB,KACbxR,EAAW+S,EAAM/S,SACjBuR,EAAMwB,EAAMxB,IACZxJ,EAAMwJ,IAeRwB,EAAMrB,IAAMqB,EAAMpW,GACds5B,EAAQG,gBAAgBrjB,EAAMpW,GAAI4U,GAClC0kB,EAAQ5S,cAAc9R,EAAKwB,GAC/Bq1B,EAASr1B,GAIPs1B,EAAet1B,EAAO/S,EAAU0nC,GAC5B3/B,EAAMyJ,IACR82B,EAAkBv1B,EAAO20B,GAE3BjiB,EAAOkiB,EAAW50B,EAAMrB,IAAKk2B,IAMtB5/B,EAAO+K,EAAMX,YACtBW,EAAMrB,IAAMukB,EAAQK,cAAcvjB,EAAMtB,MACxCgU,EAAOkiB,EAAW50B,EAAMrB,IAAKk2B,KAE7B70B,EAAMrB,IAAMukB,EAAQ5b,eAAetH,EAAMtB,MACzCgU,EAAOkiB,EAAW50B,EAAMrB,IAAKk2B,KA0BjC,SAASI,EAAej1B,EAAO20B,GACzB3/B,EAAMgL,EAAMvB,KAAK+2B,iBACnBb,EAAmBnnC,KAAKuK,MAAM48B,EAAoB30B,EAAMvB,KAAK+2B,eAC7Dx1B,EAAMvB,KAAK+2B,cAAgB,MAE7Bx1B,EAAMrB,IAAMqB,EAAMf,kBAAkBmgB,IAChCqW,EAAYz1B,IACdu1B,EAAkBv1B,EAAO20B,GACzBU,EAASr1B,KAITikB,GAAYjkB,GAEZ20B,EAAmBnnC,KAAKwS,IA0B5B,SAAS0S,EAAQrgB,EAAQsM,EAAK+2B,GACxB1gC,EAAM3C,KACJ2C,EAAM0gC,GACJxS,EAAQ31B,WAAWmoC,KAAYrjC,GACjC6wB,EAAQM,aAAanxB,EAAQsM,EAAK+2B,GAGpCxS,EAAQU,YAAYvxB,EAAQsM,IAKlC,SAAS22B,EAAgBt1B,EAAO/S,EAAU0nC,GACxC,GAAI1pC,MAAM8K,QAAQ9I,GAAW,CACvB,EAGJ,IAAK,IAAI1E,EAAI,EAAGA,EAAI0E,EAASrB,SAAUrD,EACrCmsC,EAAUznC,EAAS1E,GAAIosC,EAAoB30B,EAAMrB,IAAK,MAAM,EAAM1R,EAAU1E,QAErE2M,EAAY8K,EAAMtB,OAC3BwkB,EAAQU,YAAY5jB,EAAMrB,IAAKukB,EAAQ5b,eAAe9R,OAAOwK,EAAMtB,QAIvE,SAAS+2B,EAAaz1B,GACpB,KAAOA,EAAMf,mBACXe,EAAQA,EAAMf,kBAAkB+S,OAElC,OAAOhd,EAAMgL,EAAMxB,KAGrB,SAAS+2B,EAAmBv1B,EAAO20B,GACjC,IAAK,IAAI5V,EAAM,EAAGA,EAAMC,EAAIn1B,OAAO+B,SAAUmzB,EAC3CC,EAAIn1B,OAAOk1B,GAAKsF,GAAWrkB,GAGzBhL,EADJzM,EAAIyX,EAAMvB,KAAK5M,QAETmD,EAAMzM,EAAEsB,SAAWtB,EAAEsB,OAAOw6B,GAAWrkB,GACvChL,EAAMzM,EAAEmqB,SAAWiiB,EAAmBnnC,KAAKwS,IAOnD,SAASq1B,EAAUr1B,GACjB,IAAIzX,EACJ,GAAIyM,EAAMzM,EAAIyX,EAAMhB,WAClBkkB,EAAQc,cAAchkB,EAAMrB,IAAKpW,QAGjC,IADA,IAAI+E,EAAW0S,EACR1S,GACD0H,EAAMzM,EAAI+E,EAAS4E,UAAY8C,EAAMzM,EAAIA,EAAEoK,SAASV,WACtDixB,EAAQc,cAAchkB,EAAMrB,IAAKpW,GAEnC+E,EAAWA,EAAS+E,OAIpB2C,EAAMzM,EAAI+oB,KACZ/oB,IAAMyX,EAAM9N,SACZ3J,IAAMyX,EAAMlB,WACZ9J,EAAMzM,EAAIA,EAAEoK,SAASV,WAErBixB,EAAQc,cAAchkB,EAAMrB,IAAKpW,GAIrC,SAASotC,EAAWf,EAAWC,EAAQ5f,EAAQ2gB,EAAUhR,EAAQ+P,GAC/D,KAAOiB,GAAYhR,IAAUgR,EAC3BlB,EAAUzf,EAAO2gB,GAAWjB,EAAoBC,EAAWC,GAAQ,EAAO5f,EAAQ2gB,GAItF,SAASC,EAAmB71B,GAC1B,IAAIzX,EAAG6uB,EACH3Y,EAAOuB,EAAMvB,KACjB,GAAIzJ,EAAMyJ,GAER,IADIzJ,EAAMzM,EAAIkW,EAAK5M,OAASmD,EAAMzM,EAAIA,EAAEyqB,UAAYzqB,EAAEyX,GACjDzX,EAAI,EAAGA,EAAIy2B,EAAIhM,QAAQpnB,SAAUrD,EAAKy2B,EAAIhM,QAAQzqB,GAAGyX,GAE5D,GAAIhL,EAAMzM,EAAIyX,EAAM/S,UAClB,IAAKmqB,EAAI,EAAGA,EAAIpX,EAAM/S,SAASrB,SAAUwrB,EACvCye,EAAkB71B,EAAM/S,SAASmqB,IAKvC,SAAS0e,EAAc7gB,EAAQ2gB,EAAUhR,GACvC,KAAOgR,GAAYhR,IAAUgR,EAAU,CACrC,IAAIG,EAAK9gB,EAAO2gB,GACZ5gC,EAAM+gC,KACJ/gC,EAAM+gC,EAAGv3B,MACXw3B,EAA0BD,GAC1BF,EAAkBE,IAElBtB,EAAWsB,EAAGp3B,OAMtB,SAASq3B,EAA2Bh2B,EAAO8zB,GACzC,GAAI9+B,EAAM8+B,IAAO9+B,EAAMgL,EAAMvB,MAAO,CAClC,IAAIlW,EACA2nB,EAAY8O,EAAIvuB,OAAO7E,OAAS,EAapC,IAZIoJ,EAAM8+B,GAGRA,EAAG5jB,WAAaA,EAGhB4jB,EAtRN,SAAqBmC,EAAU/lB,GAC7B,SAASrH,IACuB,MAAxBA,EAAUqH,WACdukB,EAAWwB,GAIf,OADAptB,EAAUqH,UAAYA,EACfrH,EA+QEqtB,CAAWl2B,EAAMrB,IAAKuR,GAGzBlb,EAAMzM,EAAIyX,EAAMf,oBAAsBjK,EAAMzM,EAAIA,EAAEypB,SAAWhd,EAAMzM,EAAEkW,OACvEu3B,EAA0BztC,EAAGurC,GAE1BvrC,EAAI,EAAGA,EAAIy2B,EAAIvuB,OAAO7E,SAAUrD,EACnCy2B,EAAIvuB,OAAOlI,GAAGyX,EAAO8zB,GAEnB9+B,EAAMzM,EAAIyX,EAAMvB,KAAK5M,OAASmD,EAAMzM,EAAIA,EAAEkI,QAC5ClI,EAAEyX,EAAO8zB,GAETA,SAGFW,EAAWz0B,EAAMrB,KA8FrB,SAASw3B,EAAct2B,EAAMu2B,EAAOl+B,EAAOmyB,GACzC,IAAK,IAAI9hC,EAAI2P,EAAO3P,EAAI8hC,EAAK9hC,IAAK,CAChC,IAAIK,EAAIwtC,EAAM7tC,GACd,GAAIyM,EAAMpM,IAAM07B,GAAUzkB,EAAMjX,GAAM,OAAOL,GAIjD,SAAS8tC,EACP7kB,EACAxR,EACA20B,EACAI,EACAn+B,EACA0/B,GAEA,GAAI9kB,IAAaxR,EAAjB,CAIIhL,EAAMgL,EAAMrB,MAAQ3J,EAAM+/B,KAE5B/0B,EAAQ+0B,EAAWn+B,GAASmJ,GAAWC,IAGzC,IAAIrB,EAAMqB,EAAMrB,IAAM6S,EAAS7S,IAE/B,GAAI1J,EAAOuc,EAAS/R,oBACdzK,EAAMgL,EAAMnB,aAAa2U,UAC3B+iB,EAAQ/kB,EAAS7S,IAAKqB,EAAO20B,GAE7B30B,EAAMP,oBAAqB,OAS/B,GAAIxK,EAAO+K,EAAMb,WACflK,EAAOuc,EAASrS,WAChBa,EAAMlW,MAAQ0nB,EAAS1nB,MACtBmL,EAAO+K,EAAMV,WAAarK,EAAO+K,EAAMT,SAExCS,EAAMf,kBAAoBuS,EAASvS,sBALrC,CASA,IAAI1W,EACAkW,EAAOuB,EAAMvB,KACbzJ,EAAMyJ,IAASzJ,EAAMzM,EAAIkW,EAAK5M,OAASmD,EAAMzM,EAAIA,EAAE0oB,WACrD1oB,EAAEipB,EAAUxR,GAGd,IAAIo2B,EAAQ5kB,EAASvkB,SACjB8oC,EAAK/1B,EAAM/S,SACf,GAAI+H,EAAMyJ,IAASg3B,EAAYz1B,GAAQ,CACrC,IAAKzX,EAAI,EAAGA,EAAIy2B,EAAI9gB,OAAOtS,SAAUrD,EAAKy2B,EAAI9gB,OAAO3V,GAAGipB,EAAUxR,GAC9DhL,EAAMzM,EAAIkW,EAAK5M,OAASmD,EAAMzM,EAAIA,EAAE2V,SAAW3V,EAAEipB,EAAUxR,GAE7DnL,EAAQmL,EAAMtB,MACZ1J,EAAMohC,IAAUphC,EAAM+gC,GACpBK,IAAUL,GAxJpB,SAAyBnB,EAAWwB,EAAOI,EAAO7B,EAAoB2B,GACpE,IAQIG,EAAaC,EAAUC,EARvBC,EAAc,EACdC,EAAc,EACdC,EAAYV,EAAMxqC,OAAS,EAC3BmrC,EAAgBX,EAAM,GACtBY,EAAcZ,EAAMU,GACpBG,EAAYT,EAAM5qC,OAAS,EAC3BsrC,EAAgBV,EAAM,GACtBW,EAAcX,EAAMS,GAMpBG,GAAWd,EAMf,KAAOM,GAAeE,GAAaD,GAAeI,GAC5CpiC,EAAQkiC,GACVA,EAAgBX,IAAQQ,GACf/hC,EAAQmiC,GACjBA,EAAcZ,IAAQU,GACbxS,GAAUyS,EAAeG,IAClCb,EAAWU,EAAeG,EAAevC,EAAoB6B,EAAOK,GACpEE,EAAgBX,IAAQQ,GACxBM,EAAgBV,IAAQK,IACfvS,GAAU0S,EAAaG,IAChCd,EAAWW,EAAaG,EAAaxC,EAAoB6B,EAAOS,GAChED,EAAcZ,IAAQU,GACtBK,EAAcX,IAAQS,IACb3S,GAAUyS,EAAeI,IAClCd,EAAWU,EAAeI,EAAaxC,EAAoB6B,EAAOS,GAClEG,GAAWlU,EAAQM,aAAaoR,EAAWmC,EAAcp4B,IAAKukB,EAAQW,YAAYmT,EAAYr4B,MAC9Fo4B,EAAgBX,IAAQQ,GACxBO,EAAcX,IAAQS,IACb3S,GAAU0S,EAAaE,IAChCb,EAAWW,EAAaE,EAAevC,EAAoB6B,EAAOK,GAClEO,GAAWlU,EAAQM,aAAaoR,EAAWoC,EAAYr4B,IAAKo4B,EAAcp4B,KAC1Eq4B,EAAcZ,IAAQU,GACtBI,EAAgBV,IAAQK,KAEpBhiC,EAAQ4hC,KAAgBA,EAAc/R,GAAkB0R,EAAOQ,EAAaE,IAI5EjiC,EAHJ6hC,EAAW1hC,EAAMkiC,EAAcptC,KAC3B2sC,EAAYS,EAAcptC,KAC1BqsC,EAAae,EAAed,EAAOQ,EAAaE,IAElDpC,EAAUwC,EAAevC,EAAoBC,EAAWmC,EAAcp4B,KAAK,EAAO63B,EAAOK,GAGrFvS,GADJqS,EAAcP,EAAMM,GACOQ,IACzBb,EAAWM,EAAaO,EAAevC,EAAoB6B,EAAOK,GAClET,EAAMM,QAAY3hC,EAClBqiC,GAAWlU,EAAQM,aAAaoR,EAAW+B,EAAYh4B,IAAKo4B,EAAcp4B,MAG1E+1B,EAAUwC,EAAevC,EAAoBC,EAAWmC,EAAcp4B,KAAK,EAAO63B,EAAOK,GAG7FK,EAAgBV,IAAQK,IAGxBD,EAAcE,EAEhBnB,EAAUf,EADD//B,EAAQ2hC,EAAMS,EAAY,IAAM,KAAOT,EAAMS,EAAY,GAAGt4B,IACxC63B,EAAOK,EAAaI,EAAWtC,GACnDkC,EAAcI,GACvBnB,EAAaM,EAAOQ,EAAaE,GAoFXO,CAAe14B,EAAKy3B,EAAOL,EAAIpB,EAAoB2B,GAC9DthC,EAAM+gC,IAIX/gC,EAAMwc,EAAS9S,OAASwkB,EAAQY,eAAenlB,EAAK,IACxDg3B,EAAUh3B,EAAK,KAAMo3B,EAAI,EAAGA,EAAGnqC,OAAS,EAAG+oC,IAClC3/B,EAAMohC,GACfN,EAAaM,EAAO,EAAGA,EAAMxqC,OAAS,GAC7BoJ,EAAMwc,EAAS9S,OACxBwkB,EAAQY,eAAenlB,EAAK,IAErB6S,EAAS9S,OAASsB,EAAMtB,MACjCwkB,EAAQY,eAAenlB,EAAKqB,EAAMtB,MAEhC1J,EAAMyJ,IACJzJ,EAAMzM,EAAIkW,EAAK5M,OAASmD,EAAMzM,EAAIA,EAAE+uC,YAAc/uC,EAAEipB,EAAUxR,KAItE,SAASu3B,EAAkBv3B,EAAOuX,EAAOigB,GAGvC,GAAIviC,EAAOuiC,IAAYxiC,EAAMgL,EAAM3N,QACjC2N,EAAM3N,OAAOoM,KAAK+2B,cAAgBje,OAElC,IAAK,IAAIhvB,EAAI,EAAGA,EAAIgvB,EAAM3rB,SAAUrD,EAClCgvB,EAAMhvB,GAAGkW,KAAK5M,KAAK6gB,OAAO6E,EAAMhvB,IAKtC,IAKIkvC,EAAmBrhC,EAAQ,2CAG/B,SAASmgC,EAAS53B,EAAKqB,EAAO20B,EAAoB+C,GAChD,IAAInvC,EACAiW,EAAMwB,EAAMxB,IACZC,EAAOuB,EAAMvB,KACbxR,EAAW+S,EAAM/S,SAIrB,GAHAyqC,EAASA,GAAWj5B,GAAQA,EAAKsX,IACjC/V,EAAMrB,IAAMA,EAER1J,EAAO+K,EAAMX,YAAcrK,EAAMgL,EAAMnB,cAEzC,OADAmB,EAAMP,oBAAqB,GACpB,EAQT,GAAIzK,EAAMyJ,KACJzJ,EAAMzM,EAAIkW,EAAK5M,OAASmD,EAAMzM,EAAIA,EAAEqoB,OAASroB,EAAEyX,GAAO,GACtDhL,EAAMzM,EAAIyX,EAAMf,oBAGlB,OADAg2B,EAAcj1B,EAAO20B,IACd,EAGX,GAAI3/B,EAAMwJ,GAAM,CACd,GAAIxJ,EAAM/H,GAER,GAAK0R,EAAIg5B,gBAIP,GAAI3iC,EAAMzM,EAAIkW,IAASzJ,EAAMzM,EAAIA,EAAE6kB,WAAapY,EAAMzM,EAAIA,EAAEikC,YAC1D,GAAIjkC,IAAMoW,EAAI6tB,UAWZ,OAAO,MAEJ,CAIL,IAFA,IAAIoL,GAAgB,EAChB5V,EAAYrjB,EAAI8tB,WACX1N,EAAM,EAAGA,EAAM9xB,EAASrB,OAAQmzB,IAAO,CAC9C,IAAKiD,IAAcuU,EAAQvU,EAAW/0B,EAAS8xB,GAAM4V,EAAoB+C,GAAS,CAChFE,GAAgB,EAChB,MAEF5V,EAAYA,EAAU6B,YAIxB,IAAK+T,GAAiB5V,EAUpB,OAAO,OAxCXsT,EAAet1B,EAAO/S,EAAU0nC,GA6CpC,GAAI3/B,EAAMyJ,GAAO,CACf,IAAIo5B,GAAa,EACjB,IAAK,IAAI/tC,KAAO2U,EACd,IAAKg5B,EAAiB3tC,GAAM,CAC1B+tC,GAAa,EACbtC,EAAkBv1B,EAAO20B,GACzB,OAGCkD,GAAcp5B,EAAY,OAE7BmJ,GAASnJ,EAAY,aAGhBE,EAAIF,OAASuB,EAAMtB,OAC5BC,EAAIF,KAAOuB,EAAMtB,MAEnB,OAAO,EAcT,OAAO,SAAgB8S,EAAUxR,EAAO6Q,EAAWylB,GACjD,IAAIzhC,EAAQmL,GAAZ,CAKA,IA7lBoBrB,EA6lBhBm5B,GAAiB,EACjBnD,EAAqB,GAEzB,GAAI9/B,EAAQ2c,GAEVsmB,GAAiB,EACjBpD,EAAU10B,EAAO20B,OACZ,CACL,IAAIoD,EAAgB/iC,EAAMwc,EAAS/lB,UACnC,IAAKssC,GAAiBzT,GAAU9S,EAAUxR,GAExCq2B,EAAW7kB,EAAUxR,EAAO20B,EAAoB,KAAM,KAAM2B,OACvD,CACL,GAAIyB,EAAe,CAQjB,GAJ0B,IAAtBvmB,EAAS/lB,UAAkB+lB,EAASnlB,aAAaoN,KACnD+X,EAAS9d,gBAAgB+F,GACzBoX,GAAY,GAEV5b,EAAO4b,IACL0lB,EAAQ/kB,EAAUxR,EAAO20B,GAE3B,OADA4C,EAAiBv3B,EAAO20B,GAAoB,GACrCnjB,EArnBG7S,EAkoBS6S,EAAvBA,EAjoBC,IAAIjT,GAAM2kB,EAAQC,QAAQxkB,GAAKnL,cAAe,GAAI,QAAIuB,EAAW4J,GAqoBpE,IAAIq5B,EAASxmB,EAAS7S,IAClBi2B,EAAY1R,EAAQ31B,WAAWyqC,GAcnC,GAXAtD,EACE10B,EACA20B,EAIAqD,EAAOnG,SAAW,KAAO+C,EACzB1R,EAAQW,YAAYmU,IAIlBhjC,EAAMgL,EAAM3N,QAGd,IAFA,IAAI/E,EAAW0S,EAAM3N,OACjB4lC,EAAYxC,EAAYz1B,GACrB1S,GAAU,CACf,IAAK,IAAI/E,EAAI,EAAGA,EAAIy2B,EAAIhM,QAAQpnB,SAAUrD,EACxCy2B,EAAIhM,QAAQzqB,GAAG+E,GAGjB,GADAA,EAASqR,IAAMqB,EAAMrB,IACjBs5B,EAAW,CACb,IAAK,IAAIlZ,EAAM,EAAGA,EAAMC,EAAIn1B,OAAO+B,SAAUmzB,EAC3CC,EAAIn1B,OAAOk1B,GAAKsF,GAAW/2B,GAK7B,IAAIolB,EAASplB,EAASmR,KAAK5M,KAAK6gB,OAChC,GAAIA,EAAOpJ,OAET,IAAK,IAAI4uB,EAAM,EAAGA,EAAMxlB,EAAOnK,IAAI3c,OAAQssC,IACzCxlB,EAAOnK,IAAI2vB,UAIfjU,GAAY32B,GAEdA,EAAWA,EAAS+E,OAKpB2C,EAAM4/B,GACRkB,EAAa,CAACtkB,GAAW,EAAG,GACnBxc,EAAMwc,EAAShT,MACxBq3B,EAAkBrkB,IAMxB,OADA+lB,EAAiBv3B,EAAO20B,EAAoBmD,GACrC93B,EAAMrB,IAnGP3J,EAAMwc,IAAaqkB,EAAkBrkB,IAq8DnC2mB,CAAoB,CAAEjV,QAASA,GAASz6B,QAf9B,CACpBiiB,GACA2c,GACAmC,GACApc,GACA6I,GAlBe1a,EAAY,CAC3B1R,OAAQyqC,GACRa,SAAUb,GACV7jC,OAAQ,SAAoBuP,EAAO8zB,IAET,IAApB9zB,EAAMvB,KAAKg1B,KACbI,GAAM7zB,EAAO8zB,GAEbA,MAGF,IAe0BlnC,OAAOo5B,MAUjC/pB,GAEFvP,SAASwD,iBAAiB,mBAAmB,WAC3C,IAAIjC,EAAKvB,SAASmgC,cACd5+B,GAAMA,EAAGmqC,QACXC,GAAQpqC,EAAI,YAKlB,IAAIqqC,GAAY,CACd93B,SAAU,SAAmBvS,EAAIsqC,EAASv4B,EAAOwR,GAC7B,WAAdxR,EAAMxB,KAEJgT,EAAS7S,MAAQ6S,EAAS7S,IAAI65B,UAChCtvB,GAAelJ,EAAO,aAAa,WACjCs4B,GAAU5S,iBAAiBz3B,EAAIsqC,EAASv4B,MAG1Cy4B,GAAYxqC,EAAIsqC,EAASv4B,EAAM9N,SAEjCjE,EAAGuqC,UAAY,GAAG1qC,IAAIpF,KAAKuF,EAAG6D,QAAS4mC,MAChB,aAAd14B,EAAMxB,KAAsBukB,GAAgB90B,EAAGoV,SACxDpV,EAAG8+B,YAAcwL,EAAQ1S,UACpB0S,EAAQ1S,UAAU5M,OACrBhrB,EAAGiC,iBAAiB,mBAAoByoC,IACxC1qC,EAAGiC,iBAAiB,iBAAkB0oC,IAKtC3qC,EAAGiC,iBAAiB,SAAU0oC,IAE1B38B,IACFhO,EAAGmqC,QAAS,MAMpB1S,iBAAkB,SAA2Bz3B,EAAIsqC,EAASv4B,GACxD,GAAkB,WAAdA,EAAMxB,IAAkB,CAC1Bi6B,GAAYxqC,EAAIsqC,EAASv4B,EAAM9N,SAK/B,IAAI2mC,EAAc5qC,EAAGuqC,UACjBM,EAAa7qC,EAAGuqC,UAAY,GAAG1qC,IAAIpF,KAAKuF,EAAG6D,QAAS4mC,IACxD,GAAII,EAAWC,MAAK,SAAU/vC,EAAGT,GAAK,OAAQsQ,EAAW7P,EAAG6vC,EAAYtwC,QAGtD0F,EAAGm1B,SACfmV,EAAQ/uC,MAAMuvC,MAAK,SAAUjkC,GAAK,OAAOkkC,GAAoBlkC,EAAGgkC,MAChEP,EAAQ/uC,QAAU+uC,EAAQxe,UAAYif,GAAoBT,EAAQ/uC,MAAOsvC,KAE3ET,GAAQpqC,EAAI,aAOtB,SAASwqC,GAAaxqC,EAAIsqC,EAASz1B,GACjCm2B,GAAoBhrC,EAAIsqC,EAASz1B,IAE7B/G,GAAQG,KACV/L,YAAW,WACT8oC,GAAoBhrC,EAAIsqC,EAASz1B,KAChC,GAIP,SAASm2B,GAAqBhrC,EAAIsqC,EAASz1B,GACzC,IAAItZ,EAAQ+uC,EAAQ/uC,MAChB0vC,EAAajrC,EAAGm1B,SACpB,IAAI8V,GAAejuC,MAAM8K,QAAQvM,GAAjC,CASA,IADA,IAAIy5B,EAAUkW,EACL5wC,EAAI,EAAGC,EAAIyF,EAAG6D,QAAQlG,OAAQrD,EAAIC,EAAGD,IAE5C,GADA4wC,EAASlrC,EAAG6D,QAAQvJ,GAChB2wC,EACFjW,EAAW1pB,EAAa/P,EAAOkvC,GAASS,KAAY,EAChDA,EAAOlW,WAAaA,IACtBkW,EAAOlW,SAAWA,QAGpB,GAAIpqB,EAAW6/B,GAASS,GAAS3vC,GAI/B,YAHIyE,EAAGmrC,gBAAkB7wC,IACvB0F,EAAGmrC,cAAgB7wC,IAMtB2wC,IACHjrC,EAAGmrC,eAAiB,IAIxB,SAASJ,GAAqBxvC,EAAOsI,GACnC,OAAOA,EAAQoH,OAAM,SAAUlQ,GAAK,OAAQ6P,EAAW7P,EAAGQ,MAG5D,SAASkvC,GAAUS,GACjB,MAAO,WAAYA,EACfA,EAAO9M,OACP8M,EAAO3vC,MAGb,SAASmvC,GAAoBtqC,GAC3BA,EAAE2B,OAAO28B,WAAY,EAGvB,SAASiM,GAAkBvqC,GAEpBA,EAAE2B,OAAO28B,YACdt+B,EAAE2B,OAAO28B,WAAY,EACrB0L,GAAQhqC,EAAE2B,OAAQ,UAGpB,SAASqoC,GAASpqC,EAAIoV,GACpB,IAAIhV,EAAI3B,SAASmrB,YAAY,cAC7BxpB,EAAEgrC,UAAUh2B,GAAM,GAAM,GACxBpV,EAAGmB,cAAcf,GAMnB,SAASirC,GAAYt5B,GACnB,OAAOA,EAAMf,mBAAuBe,EAAMvB,MAASuB,EAAMvB,KAAKszB,WAE1D/xB,EADAs5B,GAAWt5B,EAAMf,kBAAkB+S,QAIzC,IAuDIunB,GAAqB,CACvBzkB,MAAOwjB,GACP7E,KAzDS,CACT1pC,KAAM,SAAekE,EAAI2xB,EAAK5f,GAC5B,IAAIxW,EAAQo2B,EAAIp2B,MAGZgwC,GADJx5B,EAAQs5B,GAAWt5B,IACOvB,MAAQuB,EAAMvB,KAAKszB,WACzC0H,EAAkBxrC,EAAGyrC,mBACF,SAArBzrC,EAAGgoB,MAAM0jB,QAAqB,GAAK1rC,EAAGgoB,MAAM0jB,QAC1CnwC,GAASgwC,GACXx5B,EAAMvB,KAAKg1B,MAAO,EAClB9B,GAAM3xB,GAAO,WACX/R,EAAGgoB,MAAM0jB,QAAUF,MAGrBxrC,EAAGgoB,MAAM0jB,QAAUnwC,EAAQiwC,EAAkB,QAIjDv7B,OAAQ,SAAiBjQ,EAAI2xB,EAAK5f,GAChC,IAAIxW,EAAQo2B,EAAIp2B,OAIXA,KAHUo2B,EAAI7F,YAInB/Z,EAAQs5B,GAAWt5B,IACOvB,MAAQuB,EAAMvB,KAAKszB,YAE3C/xB,EAAMvB,KAAKg1B,MAAO,EACdjqC,EACFmoC,GAAM3xB,GAAO,WACX/R,EAAGgoB,MAAM0jB,QAAU1rC,EAAGyrC,sBAGxB7F,GAAM7zB,GAAO,WACX/R,EAAGgoB,MAAM0jB,QAAU,WAIvB1rC,EAAGgoB,MAAM0jB,QAAUnwC,EAAQyE,EAAGyrC,mBAAqB,SAIvDE,OAAQ,SACN3rC,EACAsqC,EACAv4B,EACAwR,EACAyT,GAEKA,IACHh3B,EAAGgoB,MAAM0jB,QAAU1rC,EAAGyrC,uBAYxBG,GAAkB,CACpB/wC,KAAM0M,OACNg9B,OAAQltB,QACRypB,IAAKzpB,QACL5b,KAAM8L,OACN6N,KAAM7N,OACNy5B,WAAYz5B,OACZ45B,WAAY55B,OACZ05B,aAAc15B,OACd65B,aAAc75B,OACd25B,iBAAkB35B,OAClB85B,iBAAkB95B,OAClBy8B,YAAaz8B,OACb28B,kBAAmB38B,OACnB08B,cAAe18B,OACfm9B,SAAU,CAAC5jC,OAAQyG,OAAQvM,SAK7B,SAAS6wC,GAAc95B,GACrB,IAAI+5B,EAAc/5B,GAASA,EAAMpB,iBACjC,OAAIm7B,GAAeA,EAAY/8B,KAAKlL,QAAQsjB,SACnC0kB,GAAatjB,GAAuBujB,EAAY9sC,WAEhD+S,EAIX,SAASg6B,GAAuB1jB,GAC9B,IAAI7X,EAAO,GACP3M,EAAUwkB,EAAK3jB,SAEnB,IAAK,IAAI7I,KAAOgI,EAAQmT,UACtBxG,EAAK3U,GAAOwsB,EAAKxsB,GAInB,IAAIomB,EAAYpe,EAAQwgB,iBACxB,IAAK,IAAIhP,KAAS4M,EAChBzR,EAAKrH,EAASkM,IAAU4M,EAAU5M,GAEpC,OAAO7E,EAGT,SAASw7B,GAAalnC,EAAGmnC,GACvB,GAAI,iBAAiBl+B,KAAKk+B,EAAS17B,KACjC,OAAOzL,EAAE,aAAc,CACrBwQ,MAAO22B,EAASt7B,iBAAiBqG,YAiBvC,IAAIk1B,GAAgB,SAAUvxC,GAAK,OAAOA,EAAE4V,KAAOiB,GAAmB7W,IAElEwxC,GAAmB,SAAUvxC,GAAK,MAAkB,SAAXA,EAAEC,MAE3CuxC,GAAa,CACfvxC,KAAM,aACNya,MAAOs2B,GACPzkB,UAAU,EAEV9jB,OAAQ,SAAiByB,GACvB,IAAI+c,EAAS9hB,KAETf,EAAWe,KAAKoe,OAAO5G,QAC3B,GAAKvY,IAKLA,EAAWA,EAASC,OAAOitC,KAEbvuC,OAAd,CAKI,EAQJ,IAAIlC,EAAOsE,KAAKtE,KAGZ,EASJ,IAAIwwC,EAAWjtC,EAAS,GAIxB,GA7DJ,SAA8B+S,GAC5B,KAAQA,EAAQA,EAAM3N,QACpB,GAAI2N,EAAMvB,KAAKszB,WACb,OAAO,EA0DLuI,CAAoBtsC,KAAKmE,QAC3B,OAAO+nC,EAKT,IAAI/sC,EAAQ2sC,GAAaI,GAEzB,IAAK/sC,EACH,OAAO+sC,EAGT,GAAIlsC,KAAKusC,SACP,OAAON,GAAYlnC,EAAGmnC,GAMxB,IAAIx8B,EAAK,gBAAmB1P,KAAS,KAAI,IACzCb,EAAMrD,IAAmB,MAAbqD,EAAMrD,IACdqD,EAAMkS,UACJ3B,EAAK,UACLA,EAAKvQ,EAAMqR,IACbtJ,EAAY/H,EAAMrD,KACmB,IAAlC0L,OAAOrI,EAAMrD,KAAK+M,QAAQ6G,GAAYvQ,EAAMrD,IAAM4T,EAAKvQ,EAAMrD,IAC9DqD,EAAMrD,IAEZ,IAAI2U,GAAQtR,EAAMsR,OAAStR,EAAMsR,KAAO,KAAKszB,WAAaiI,GAAsBhsC,MAC5EwsC,EAAcxsC,KAAKgkB,OACnByoB,EAAWX,GAAaU,GAQ5B,GAJIrtC,EAAMsR,KAAKyF,YAAc/W,EAAMsR,KAAKyF,WAAW60B,KAAKqB,MACtDjtC,EAAMsR,KAAKg1B,MAAO,GAIlBgH,GACAA,EAASh8B,OA7Ff,SAAsBtR,EAAOstC,GAC3B,OAAOA,EAAS3wC,MAAQqD,EAAMrD,KAAO2wC,EAASj8B,MAAQrR,EAAMqR,IA6FvDk8B,CAAYvtC,EAAOstC,KACnBh7B,GAAmBg7B,MAElBA,EAASx7B,oBAAqBw7B,EAASx7B,kBAAkB+S,OAAO3S,WAClE,CAGA,IAAIwnB,EAAU4T,EAASh8B,KAAKszB,WAAa35B,EAAO,GAAIqG,GAEpD,GAAa,WAAT/U,EAOF,OALAsE,KAAKusC,UAAW,EAChBrxB,GAAe2d,EAAS,cAAc,WACpC/W,EAAOyqB,UAAW,EAClBzqB,EAAO0C,kBAEFynB,GAAYlnC,EAAGmnC,GACjB,GAAa,WAATxwC,EAAmB,CAC5B,GAAI+V,GAAmBtS,GACrB,OAAOqtC,EAET,IAAIG,EACAvG,EAAe,WAAcuG,KACjCzxB,GAAezK,EAAM,aAAc21B,GACnClrB,GAAezK,EAAM,iBAAkB21B,GACvClrB,GAAe2d,EAAS,cAAc,SAAUgN,GAAS8G,EAAe9G,MAI5E,OAAOqG,KAMP32B,GAAQnL,EAAO,CACjBoG,IAAKhJ,OACLolC,UAAWplC,QACVqkC,IAwIH,SAASgB,GAAgBjyC,GAEnBA,EAAE+V,IAAIm8B,SACRlyC,EAAE+V,IAAIm8B,UAGJlyC,EAAE+V,IAAIqzB,UACRppC,EAAE+V,IAAIqzB,WAIV,SAAS+I,GAAgBnyC,GACvBA,EAAE6V,KAAKu8B,OAASpyC,EAAE+V,IAAIxK,wBAGxB,SAAS8mC,GAAkBryC,GACzB,IAAIsyC,EAAStyC,EAAE6V,KAAK08B,IAChBH,EAASpyC,EAAE6V,KAAKu8B,OAChBI,EAAKF,EAAO5mC,KAAO0mC,EAAO1mC,KAC1B+mC,EAAKH,EAAO9mC,IAAM4mC,EAAO5mC,IAC7B,GAAIgnC,GAAMC,EAAI,CACZzyC,EAAE6V,KAAK68B,OAAQ,EACf,IAAIhxC,EAAI1B,EAAE+V,IAAIsX,MACd3rB,EAAEixC,UAAYjxC,EAAEkxC,gBAAkB,aAAeJ,EAAK,MAAQC,EAAK,MACnE/wC,EAAEqE,mBAAqB,aA9JpB4U,GAAM7Z,KAkKb,IAAI+xC,GAAqB,CACvBpB,WAAYA,GACZqB,gBAlKoB,CACpBn4B,MAAOA,GAEPo4B,YAAa,WACX,IAAI7rB,EAAS9hB,KAETkQ,EAASlQ,KAAKkxB,QAClBlxB,KAAKkxB,QAAU,SAAUlf,EAAO6Q,GAC9B,IAAIyO,EAAwBzI,GAAkB/G,GAE9CA,EAAOyP,UACLzP,EAAOkC,OACPlC,EAAO8rB,MACP,GACA,GAEF9rB,EAAOkC,OAASlC,EAAO8rB,KACvBtc,IACAphB,EAAOxV,KAAKonB,EAAQ9P,EAAO6Q,KAI/Bvf,OAAQ,SAAiByB,GAQvB,IAPA,IAAIyL,EAAMxQ,KAAKwQ,KAAOxQ,KAAKmE,OAAOsM,KAAKD,KAAO,OAC1C1Q,EAAM7E,OAAOY,OAAO,MACpBgyC,EAAe7tC,KAAK6tC,aAAe7tC,KAAKf,SACxC6uC,EAAc9tC,KAAKoe,OAAO5G,SAAW,GACrCvY,EAAWe,KAAKf,SAAW,GAC3B8uC,EAAiB/B,GAAsBhsC,MAElCzF,EAAI,EAAGA,EAAIuzC,EAAYlwC,OAAQrD,IAAK,CAC3C,IAAIK,EAAIkzC,EAAYvzC,GACpB,GAAIK,EAAE4V,IACJ,GAAa,MAAT5V,EAAEkB,KAAoD,IAArC0L,OAAO5M,EAAEkB,KAAK+M,QAAQ,WACzC5J,EAASO,KAAK5E,GACdkF,EAAIlF,EAAEkB,KAAOlB,GACXA,EAAE6V,OAAS7V,EAAE6V,KAAO,KAAKszB,WAAagK,QAS9C,GAAIF,EAAc,CAGhB,IAFA,IAAID,EAAO,GACPI,EAAU,GACLjd,EAAM,EAAGA,EAAM8c,EAAajwC,OAAQmzB,IAAO,CAClD,IAAIkd,EAAMJ,EAAa9c,GACvBkd,EAAIx9B,KAAKszB,WAAagK,EACtBE,EAAIx9B,KAAK08B,IAAMc,EAAIt9B,IAAIxK,wBACnBrG,EAAImuC,EAAInyC,KACV8xC,EAAKpuC,KAAKyuC,GAEVD,EAAQxuC,KAAKyuC,GAGjBjuC,KAAK4tC,KAAO7oC,EAAEyL,EAAK,KAAMo9B,GACzB5tC,KAAKguC,QAAUA,EAGjB,OAAOjpC,EAAEyL,EAAK,KAAMvR,IAGtBivC,QAAS,WACP,IAAIjvC,EAAWe,KAAK6tC,aAChBjB,EAAY5sC,KAAK4sC,YAAe5sC,KAAKlF,MAAQ,KAAO,QACnDmE,EAASrB,QAAWoC,KAAKmuC,QAAQlvC,EAAS,GAAG0R,IAAKi8B,KAMvD3tC,EAAS4D,QAAQgqC,IACjB5tC,EAAS4D,QAAQkqC,IACjB9tC,EAAS4D,QAAQoqC,IAKjBjtC,KAAKouC,QAAU1vC,SAAS2vC,KAAKC,aAE7BrvC,EAAS4D,SAAQ,SAAUjI,GACzB,GAAIA,EAAE6V,KAAK68B,MAAO,CAChB,IAAIrtC,EAAKrF,EAAE+V,IACPrU,EAAI2D,EAAGgoB,MACXoa,GAAmBpiC,EAAI2sC,GACvBtwC,EAAEixC,UAAYjxC,EAAEkxC,gBAAkBlxC,EAAEqE,mBAAqB,GACzDV,EAAGiC,iBAAiBy/B,GAAoB1hC,EAAG6sC,QAAU,SAASrzB,EAAIpZ,GAC5DA,GAAKA,EAAE2B,SAAW/B,GAGjBI,IAAK,aAAa2N,KAAK3N,EAAEyC,gBAC5B7C,EAAGgC,oBAAoB0/B,GAAoBloB,GAC3CxZ,EAAG6sC,QAAU,KACbvK,GAAsBtiC,EAAI2sC,YAOpCp3B,QAAS,CACP24B,QAAS,SAAkBluC,EAAI2sC,GAE7B,IAAKrL,GACH,OAAO,EAGT,GAAIvhC,KAAKuuC,SACP,OAAOvuC,KAAKuuC,SAOd,IAAI9rB,EAAQxiB,EAAGuuC,YACXvuC,EAAG+4B,oBACL/4B,EAAG+4B,mBAAmBn2B,SAAQ,SAAUi2B,GAAO8H,GAAYne,EAAOqW,MAEpE6H,GAASle,EAAOmqB,GAChBnqB,EAAMwF,MAAM0jB,QAAU,OACtB3rC,KAAKoxB,IAAIwE,YAAYnT,GACrB,IAAIxK,EAAOyqB,GAAkBjgB,GAE7B,OADAziB,KAAKoxB,IAAIuE,YAAYlT,GACbziB,KAAKuuC,SAAWt2B,EAAKsrB,iBAyCnCnV,GAAIprB,OAAO0J,YAAcA,GACzB0hB,GAAIprB,OAAOqJ,cAAgBA,GAC3B+hB,GAAIprB,OAAOsJ,eAAiBA,GAC5B8hB,GAAIprB,OAAOwJ,gBAAkBA,GAC7B4hB,GAAIprB,OAAOuJ,iBA10GX,SAA2BiE,GAEzB,IAAKjD,EACH,OAAO,EAET,GAAIlB,GAAcmE,GAChB,OAAO,EAIT,GAFAA,EAAMA,EAAIhL,cAEsB,MAA5BsvB,GAAoBtkB,GACtB,OAAOskB,GAAoBtkB,GAE7B,IAAIvQ,EAAKvB,SAAS4jB,cAAc9R,GAChC,OAAIA,EAAI3H,QAAQ,MAAQ,EAEdisB,GAAoBtkB,GAC1BvQ,EAAGsC,cAAgB1B,OAAO4tC,oBAC1BxuC,EAAGsC,cAAgB1B,OAAO6tC,YAGpB5Z,GAAoBtkB,GAAO,qBAAqBxC,KAAK/N,EAAGmF,aAwzGpEgF,EAAOgkB,GAAItqB,QAAQoS,WAAYq1B,IAC/BnhC,EAAOgkB,GAAItqB,QAAQqqB,WAAYsf,IAG/Brf,GAAIjyB,UAAUo1B,UAAYhkB,EAAYg5B,GAAQ97B,EAG9C2jB,GAAIjyB,UAAUonB,OAAS,SACrBtjB,EACA4iB,GAGA,OA76JF,SACE/N,EACA7U,EACA4iB,GAyBA,IAAI8rB,EA2CJ,OAlEA75B,EAAGsc,IAAMnxB,EACJ6U,EAAGnQ,SAASrB,SACfwR,EAAGnQ,SAASrB,OAASsO,IAmBvBgT,GAAS9P,EAAI,eAsBX65B,EAAkB,WAChB75B,EAAGoc,QAAQpc,EAAG6c,UAAW9O,IAO7B,IAAI8H,GAAQ7V,EAAI65B,EAAiBlkC,EAAM,CACrCyf,OAAQ,WACFpV,EAAG6P,aAAe7P,EAAGgO,cACvB8B,GAAS9P,EAAI,mBAGhB,GACH+N,GAAY,EAIK,MAAb/N,EAAG3Q,SACL2Q,EAAG6P,YAAa,EAChBC,GAAS9P,EAAI,YAERA,EAs2JA85B,CAAe5uC,KADtBC,EAAKA,GAAMsN,EAAYynB,GAAM/0B,QAAM8G,EACH8b,IAK9BtV,GACFpL,YAAW,WACLa,EAAO+I,UACLA,IACFA,GAAS0e,KAAK,OAAQ2D,MAsBzB,GAKL,IAAIygB,GAAe,2BACfC,GAAgB,yBAEhBC,GAAa/lC,GAAO,SAAUgmC,GAChC,IAAIC,EAAOD,EAAW,GAAG1pC,QAAQwpC,GAAe,QAC5CI,EAAQF,EAAW,GAAG1pC,QAAQwpC,GAAe,QACjD,OAAO,IAAI1hC,OAAO6hC,EAAO,gBAAkBC,EAAO,QA6EpD,IAAIC,GAAU,CACZC,WAAY,CAAC,eACbC,cArCF,SAAwBpvC,EAAI6D,GACfA,EAAQyL,KAAnB,IACI2kB,EAAc+H,GAAiBh8B,EAAI,SAanCi0B,IACFj0B,EAAGi0B,YAAclsB,KAAKC,UAAUisB,IAElC,IAAIob,EAAexT,GAAe77B,EAAI,SAAS,GAC3CqvC,IACFrvC,EAAGqvC,aAAeA,IAkBpBC,QAdF,SAAkBtvC,GAChB,IAAIwQ,EAAO,GAOX,OANIxQ,EAAGi0B,cACLzjB,GAAQ,eAAkBxQ,EAAc,YAAI,KAE1CA,EAAGqvC,eACL7+B,GAAQ,SAAYxQ,EAAe,aAAI,KAElCwQ,IAgDT,IAQI++B,GARAC,GAAU,CACZL,WAAY,CAAC,eACbC,cAvCF,SAA0BpvC,EAAI6D,GACjBA,EAAQyL,KAAnB,IACI+vB,EAAcrD,GAAiBh8B,EAAI,SACnCq/B,IAcFr/B,EAAGq/B,YAAct3B,KAAKC,UAAUg3B,GAAeK,KAGjD,IAAIoQ,EAAe5T,GAAe77B,EAAI,SAAS,GAC3CyvC,IACFzvC,EAAGyvC,aAAeA,IAkBpBH,QAdF,SAAoBtvC,GAClB,IAAIwQ,EAAO,GAOX,OANIxQ,EAAGq/B,cACL7uB,GAAQ,eAAkBxQ,EAAc,YAAI,KAE1CA,EAAGyvC,eACLj/B,GAAQ,UAAaxQ,EAAe,aAAI,MAEnCwQ,IAaLk/B,GACM,SAAiBC,GAGvB,OAFAJ,GAAUA,IAAW9wC,SAAS4jB,cAAc,QACpCkc,UAAYoR,EACbJ,GAAQzZ,aAMf8Z,GAAaznC,EACf,6FAME0nC,GAAmB1nC,EACrB,2DAKE2nC,GAAmB3nC,EACrB,mSAYE4nC,GAAY,4EACZC,GAAsB,wGACtBC,GAAS,6BAAgCrjC,EAAoB,OAAI,KACjEsjC,GAAe,OAASD,GAAS,QAAUA,GAAS,IACpDE,GAAe,IAAIhjC,OAAQ,KAAO+iC,IAClCE,GAAgB,aAChBC,GAAS,IAAIljC,OAAQ,QAAU+iC,GAAe,UAC9CI,GAAU,qBAEVC,GAAU,SACVC,GAAqB,QAGrBC,GAAqBtoC,EAAQ,yBAAyB,GACtDuoC,GAAU,GAEVC,GAAc,CAChB,OAAQ,IACR,OAAQ,IACR,SAAU,IACV,QAAS,IACT,QAAS,KACT,OAAQ,KACR,QAAS,KAEPC,GAAc,4BACdC,GAA0B,mCAG1BC,GAAqB3oC,EAAQ,gBAAgB,GAC7C4oC,GAA2B,SAAUxgC,EAAKo/B,GAAQ,OAAOp/B,GAAOugC,GAAmBvgC,IAAoB,OAAZo/B,EAAK,IAEpG,SAASqB,GAAYz1C,EAAO01C,GAC1B,IAAIC,EAAKD,EAAuBJ,GAA0BD,GAC1D,OAAOr1C,EAAM8J,QAAQ6rC,GAAI,SAAU9iC,GAAS,OAAOuiC,GAAYviC,MAmQjE,IAuBI+iC,GACApC,GACAqC,GACAC,GACAC,GACAC,GACAC,GACAC,GA9BAC,GAAO,YACPC,GAAQ,eACRC,GAAa,qCACbC,GAAgB,iCAChBC,GAAgB,WAChBC,GAAe,WAEfC,GAAQ,SACRC,GAAS,kBACTC,GAAa,wBAEbC,GAAS,kBAETC,GAAc,SACdC,GAAiB,OAIjBC,GAAmBvpC,EAAO2mC,IAE1B6C,GAAsB,UAa1B,SAASC,GACPjiC,EACAkM,EACArY,GAEA,MAAO,CACLgR,KAAM,EACN7E,IAAKA,EACL0qB,UAAWxe,EACXue,SAAUyX,GAAah2B,GACvBi2B,YAAa,GACbtuC,OAAQA,EACRpF,SAAU,IAOd,SAAS2zC,GACPC,EACA/uC,GAEAstC,GAASttC,EAAQyL,MAAQ+qB,GAEzBkX,GAAmB1tC,EAAQgvC,UAAYnoC,EACvC8mC,GAAsB3tC,EAAQ4I,aAAe/B,EAC7C+mC,GAA0B5tC,EAAQ0I,iBAAmB7B,EACrD,IAAI0B,EAAgBvI,EAAQuI,eAAiB1B,GAC5B,SAAU1K,GAAM,QAASA,EAAGumB,YAAcna,EAAcpM,EAAGuQ,OAE5E6gC,GAAa5W,GAAoB32B,EAAQrJ,QAAS,iBAClD62C,GAAgB7W,GAAoB32B,EAAQrJ,QAAS,oBACrD82C,GAAiB9W,GAAoB32B,EAAQrJ,QAAS,qBAEtDu0C,GAAalrC,EAAQkrC,WAErB,IAGI+D,EACAC,EAJAC,EAAQ,GACRC,GAAoD,IAA/BpvC,EAAQovC,mBAC7BC,EAAmBrvC,EAAQsvC,WAG3B1J,GAAS,EACT2J,GAAQ,EAUZ,SAASC,EAAc72C,GAyBrB,GAxBA82C,EAAqB92C,GAChBitC,GAAWjtC,EAAQ+2C,YACtB/2C,EAAUg3C,GAAeh3C,EAASqH,IAG/BmvC,EAAMr1C,QAAUnB,IAAYs2C,GAE3BA,EAAKW,KAAOj3C,EAAQk3C,QAAUl3C,EAAQm3C,OAIxCC,GAAed,EAAM,CACnBvZ,IAAK/8B,EAAQk3C,OACbG,MAAOr3C,IAWTu2C,IAAkBv2C,EAAQs3C,UAC5B,GAAIt3C,EAAQk3C,QAAUl3C,EAAQm3C,KAqZN3zC,EApZFxD,GAqZtBg9B,EAeN,SAA0Bx6B,GAExB,IADA,IAAI1E,EAAI0E,EAASrB,OACVrD,KAAK,CACV,GAAyB,IAArB0E,EAAS1E,GAAG8a,KACd,OAAOpW,EAAS1E,GAShB0E,EAASqR,OA5BF0jC,CArZwBhB,EAqZD/zC,YACtBw6B,EAAKia,IACfG,GAAepa,EAAM,CACnBD,IAAKv5B,EAAG0zC,OACRG,MAAO7zC,QAxZA,CACL,GAAIxD,EAAQw3C,UAAW,CAIrB,IAAIn5C,EAAO2B,EAAQy3C,YAAc,aAC/BlB,EAAc5wB,cAAgB4wB,EAAc5wB,YAAc,KAAKtnB,GAAQ2B,EAE3Eu2C,EAAc/zC,SAASO,KAAK/C,GAC5BA,EAAQ4H,OAAS2uC,EA0YzB,IAA8B/yC,EACxBw5B,EArYFh9B,EAAQwC,SAAWxC,EAAQwC,SAASC,QAAO,SAAUtE,GAAK,OAAQ,EAAIq5C,aAEtEV,EAAqB92C,GAGjBA,EAAQsrB,MACV2hB,GAAS,GAEP8H,GAAiB/0C,EAAQ+T,OAC3B6iC,GAAQ,GAGV,IAAK,IAAI94C,EAAI,EAAGA,EAAIg3C,GAAe3zC,OAAQrD,IACzCg3C,GAAeh3C,GAAGkC,EAASqH,GAI/B,SAASyvC,EAAsBtzC,GAE7B,IAAKozC,EAEH,IADA,IAAIc,GAEDA,EAAWl0C,EAAGhB,SAASgB,EAAGhB,SAASrB,OAAS,KAC3B,IAAlBu2C,EAAS9+B,MACS,MAAlB8+B,EAASzjC,MAETzQ,EAAGhB,SAASqR,MAyNlB,OApnBF,SAAoBs/B,EAAM9rC,GAOxB,IANA,IAKIkY,EAAMo4B,EALNnB,EAAQ,GACRoB,EAAavwC,EAAQuwC,WACrBC,EAAgBxwC,EAAQ+rC,YAAcllC,EACtC4pC,EAAsBzwC,EAAQgsC,kBAAoBnlC,EAClD/B,EAAQ,EAELgnC,GAAM,CAGX,GAFA5zB,EAAO4zB,EAEFwE,GAAY1D,GAAmB0D,GAkF7B,CACL,IAAII,EAAe,EACfC,EAAaL,EAAQ5uC,cACrBkvC,EAAe/D,GAAQ8D,KAAgB9D,GAAQ8D,GAAc,IAAIrnC,OAAO,kBAAoBqnC,EAAa,UAAW,MACpHE,EAAS/E,EAAKtqC,QAAQovC,GAAc,SAAUE,EAAKlkC,EAAM4/B,GAa3D,OAZAkE,EAAelE,EAAO1yC,OACjB8yC,GAAmB+D,IAA8B,aAAfA,IACrC/jC,EAAOA,EACJpL,QAAQ,sBAAuB,MAC/BA,QAAQ,4BAA6B,OAEtC0rC,GAAyByD,EAAY/jC,KACvCA,EAAOA,EAAK1K,MAAM,IAEhBlC,EAAQ+wC,OACV/wC,EAAQ+wC,MAAMnkC,GAET,MAET9H,GAASgnC,EAAKhyC,OAAS+2C,EAAO/2C,OAC9BgyC,EAAO+E,EACPG,EAAYL,EAAY7rC,EAAQ4rC,EAAc5rC,OAvGF,CAC5C,IAAImsC,EAAUnF,EAAK/mC,QAAQ,KAC3B,GAAgB,IAAZksC,EAAe,CAEjB,GAAIvE,GAAQxiC,KAAK4hC,GAAO,CACtB,IAAIoF,EAAapF,EAAK/mC,QAAQ,UAE9B,GAAImsC,GAAc,EAAG,CACflxC,EAAQmxC,mBACVnxC,EAAQ0sC,QAAQZ,EAAKsF,UAAU,EAAGF,GAAapsC,EAAOA,EAAQosC,EAAa,GAE7EG,EAAQH,EAAa,GACrB,UAKJ,GAAIvE,GAAmBziC,KAAK4hC,GAAO,CACjC,IAAIwF,EAAiBxF,EAAK/mC,QAAQ,MAElC,GAAIusC,GAAkB,EAAG,CACvBD,EAAQC,EAAiB,GACzB,UAKJ,IAAIC,EAAezF,EAAKvhC,MAAMkiC,IAC9B,GAAI8E,EAAc,CAChBF,EAAQE,EAAa,GAAGz3C,QACxB,SAIF,IAAI03C,EAAc1F,EAAKvhC,MAAMiiC,IAC7B,GAAIgF,EAAa,CACf,IAAIC,EAAW3sC,EACfusC,EAAQG,EAAY,GAAG13C,QACvBk3C,EAAYQ,EAAY,GAAIC,EAAU3sC,GACtC,SAIF,IAAI4sC,EAAgBC,IACpB,GAAID,EAAe,CACjBE,EAAeF,GACXxE,GAAyBwE,EAAcrgB,QAASya,IAClDuF,EAAQ,GAEV,UAIJ,IAAIzkC,OAAO,EAAUilC,OAAO,EAAUh2C,OAAO,EAC7C,GAAIo1C,GAAW,EAAG,CAEhB,IADAY,EAAO/F,EAAK5pC,MAAM+uC,IAEfzE,GAAOtiC,KAAK2nC,KACZvF,GAAapiC,KAAK2nC,KAClBnF,GAAQxiC,KAAK2nC,KACblF,GAAmBziC,KAAK2nC,OAGzBh2C,EAAOg2C,EAAK9sC,QAAQ,IAAK,IACd,IACXksC,GAAWp1C,EACXg2C,EAAO/F,EAAK5pC,MAAM+uC,GAEpBrkC,EAAOk/B,EAAKsF,UAAU,EAAGH,GAGvBA,EAAU,IACZrkC,EAAOk/B,GAGLl/B,GACFykC,EAAQzkC,EAAK9S,QAGXkG,EAAQ+wC,OAASnkC,GACnB5M,EAAQ+wC,MAAMnkC,EAAM9H,EAAQ8H,EAAK9S,OAAQgL,GA0B7C,GAAIgnC,IAAS5zB,EAAM,CACjBlY,EAAQ+wC,OAAS/wC,EAAQ+wC,MAAMjF,GAI/B,OAOJ,SAASuF,EAASn5C,GAChB4M,GAAS5M,EACT4zC,EAAOA,EAAKsF,UAAUl5C,GAGxB,SAASy5C,IACP,IAAIvrC,EAAQ0lC,EAAKvhC,MAAM+hC,IACvB,GAAIlmC,EAAO,CACT,IAMImyB,EAAK9I,EANLllB,EAAQ,CACV8mB,QAASjrB,EAAM,GACfwS,MAAO,GACPxS,MAAOtB,GAIT,IAFAusC,EAAQjrC,EAAM,GAAGtM,UAERy+B,EAAMuT,EAAKvhC,MAAMgiC,OAAoB9c,EAAOqc,EAAKvhC,MAAM4hC,KAAwBL,EAAKvhC,MAAM2hC,MACjGzc,EAAKrpB,MAAQtB,EACbusC,EAAQ5hB,EAAK,GAAG31B,QAChB21B,EAAK8I,IAAMzzB,EACXyF,EAAMqO,MAAMld,KAAK+zB,GAEnB,GAAI8I,EAIF,OAHAhuB,EAAMunC,WAAavZ,EAAI,GACvB8Y,EAAQ9Y,EAAI,GAAGz+B,QACfyQ,EAAMguB,IAAMzzB,EACLyF,GAKb,SAASqnC,EAAgBrnC,GACvB,IAAI8mB,EAAU9mB,EAAM8mB,QAChBygB,EAAavnC,EAAMunC,WAEnBvB,IACc,MAAZD,GAAmBrE,GAAiB5a,IACtC2f,EAAYV,GAEVG,EAAoBpf,IAAYif,IAAYjf,GAC9C2f,EAAY3f,IAQhB,IAJA,IAAI0gB,EAAQvB,EAAcnf,MAAcygB,EAEpCp7C,EAAI6T,EAAMqO,MAAM9e,OAChB8e,EAAQ,IAAIzf,MAAMzC,GACbD,EAAI,EAAGA,EAAIC,EAAGD,IAAK,CAC1B,IAAI+X,EAAOjE,EAAMqO,MAAMniB,GACnBiB,EAAQ8W,EAAK,IAAMA,EAAK,IAAMA,EAAK,IAAM,GACzC4+B,EAAmC,MAAZ/b,GAA+B,SAAZ7iB,EAAK,GAC/CxO,EAAQgyC,4BACRhyC,EAAQotC,qBACZx0B,EAAMniB,GAAK,CACTO,KAAMwX,EAAK,GACX9W,MAAOy1C,GAAWz1C,EAAO01C,IAQxB2E,IACH5C,EAAMzzC,KAAK,CAAEgR,IAAK2kB,EAAS4gB,cAAe5gB,EAAQ3vB,cAAekX,MAAOA,EAAOxS,MAAOmE,EAAMnE,MAAOmyB,IAAKhuB,EAAMguB,MAC9G+X,EAAUjf,GAGRrxB,EAAQoG,OACVpG,EAAQoG,MAAMirB,EAASzY,EAAOm5B,EAAOxnC,EAAMnE,MAAOmE,EAAMguB,KAI5D,SAASyY,EAAa3f,EAASjrB,EAAOmyB,GACpC,IAAI8Q,EAAK6I,EAKT,GAJa,MAAT9rC,IAAiBA,EAAQtB,GAClB,MAAPyzB,IAAeA,EAAMzzB,GAGrBusB,EAEF,IADA6gB,EAAoB7gB,EAAQ3vB,cACvB2nC,EAAM8F,EAAMr1C,OAAS,EAAGuvC,GAAO,GAC9B8F,EAAM9F,GAAK4I,gBAAkBC,EADI7I,UAOvCA,EAAM,EAGR,GAAIA,GAAO,EAAG,CAEZ,IAAK,IAAI5yC,EAAI04C,EAAMr1C,OAAS,EAAGrD,GAAK4yC,EAAK5yC,IAUnCuJ,EAAQu4B,KACVv4B,EAAQu4B,IAAI4W,EAAM14C,GAAGiW,IAAKtG,EAAOmyB,GAKrC4W,EAAMr1C,OAASuvC,EACfiH,EAAUjH,GAAO8F,EAAM9F,EAAM,GAAG38B,QACD,OAAtBwlC,EACLlyC,EAAQoG,OACVpG,EAAQoG,MAAMirB,EAAS,IAAI,EAAMjrB,EAAOmyB,GAEX,MAAtB2Z,IACLlyC,EAAQoG,OACVpG,EAAQoG,MAAMirB,EAAS,IAAI,EAAOjrB,EAAOmyB,GAEvCv4B,EAAQu4B,KACVv4B,EAAQu4B,IAAIlH,EAASjrB,EAAOmyB,IA1HlCyY,IAmTAmB,CAAUpD,EAAU,CAClBtjC,KAAM6hC,GACNiD,WAAYvwC,EAAQuwC,WACpBxE,WAAY/rC,EAAQ+rC,WACpBC,iBAAkBhsC,EAAQgsC,iBAC1BoB,qBAAsBptC,EAAQotC,qBAC9B4E,4BAA6BhyC,EAAQgyC,4BACrCb,kBAAmBnxC,EAAQoyC,SAC3BC,kBAAmBryC,EAAQqyC,kBAC3BjsC,MAAO,SAAgBsG,EAAKkM,EAAOm5B,EAAOO,EAAS/Z,GAGjD,IAAIzgC,EAAMo3C,GAAiBA,EAAcp3C,IAAO81C,GAAwBlhC,GAIpEzC,GAAe,QAAPnS,IACV8gB,EAmtBR,SAAwBA,GAEtB,IADA,IAAIlS,EAAM,GACDjQ,EAAI,EAAGA,EAAImiB,EAAM9e,OAAQrD,IAAK,CACrC,IAAIg5B,EAAO7W,EAAMniB,GACZ87C,GAAQroC,KAAKulB,EAAKz4B,QACrBy4B,EAAKz4B,KAAOy4B,EAAKz4B,KAAKwK,QAAQgxC,GAAY,IAC1C9rC,EAAIhL,KAAK+zB,IAGb,OAAO/oB,EA5tBO+rC,CAAc75B,IAGxB,IAksBmBzc,EAlsBfxD,EAAUg2C,GAAiBjiC,EAAKkM,EAAOs2B,GACvCp3C,IACFa,EAAQb,GAAKA,GAksBN,WAFUqE,EAtqBAxD,GAwqBlB+T,MACS,WAAXvQ,EAAGuQ,KACDvQ,EAAGg7B,SAAS5lB,MACQ,oBAArBpV,EAAGg7B,SAAS5lB,OA3qBoB3G,OAC9BjS,EAAQs3C,WAAY,GAUtB,IAAK,IAAIx5C,EAAI,EAAGA,EAAI+2C,GAAc1zC,OAAQrD,IACxCkC,EAAU60C,GAAc/2C,GAAGkC,EAASqH,IAAYrH,EAG7CitC,KAuIX,SAAqBzpC,GACkB,MAAjCg8B,GAAiBh8B,EAAI,WACvBA,EAAG8nB,KAAM,GAxILyuB,CAAW/5C,GACPA,EAAQsrB,MACV2hB,GAAS,IAGT8H,GAAiB/0C,EAAQ+T,OAC3B6iC,GAAQ,GAEN3J,EAoIV,SAA0BzpC,GACxB,IAAIsI,EAAOtI,EAAGi7B,UACV3oB,EAAMhK,EAAK3K,OACf,GAAI2U,EAEF,IADA,IAAImK,EAAQzc,EAAGyc,MAAQ,IAAIzf,MAAMsV,GACxBhY,EAAI,EAAGA,EAAIgY,EAAKhY,IACvBmiB,EAAMniB,GAAK,CACTO,KAAMyN,EAAKhO,GAAGO,KACdU,MAAOwM,KAAKC,UAAUM,EAAKhO,GAAGiB,QAEX,MAAjB+M,EAAKhO,GAAG2P,QACVwS,EAAMniB,GAAG2P,MAAQ3B,EAAKhO,GAAG2P,MACzBwS,EAAMniB,GAAG8hC,IAAM9zB,EAAKhO,GAAG8hC,UAGjBp8B,EAAG8nB,MAEb9nB,EAAG46B,OAAQ,GApJP4b,CAAgBh6C,GACNA,EAAQ+2C,YAElBkD,GAAWj6C,GAqPnB,SAAoBwD,GAClB,IAAIu5B,EAAMyC,GAAiBh8B,EAAI,QAC/B,GAAIu5B,EACFv5B,EAAGyzC,GAAKla,EACRqa,GAAe5zC,EAAI,CACjBu5B,IAAKA,EACLsa,MAAO7zC,QAEJ,CACiC,MAAlCg8B,GAAiBh8B,EAAI,YACvBA,EAAG2zC,MAAO,GAEZ,IAAID,EAAS1X,GAAiBh8B,EAAI,aAC9B0zC,IACF1zC,EAAG0zC,OAASA,IAlQVgD,CAAUl6C,GAgTlB,SAAsBwD,GAEL,MADDg8B,GAAiBh8B,EAAI,YAEjCA,EAAGuL,MAAO,GAlTNorC,CAAYn6C,IAGTs2C,IACHA,EAAOt2C,GAMJo5C,EAIHvC,EAAa72C,IAHbu2C,EAAgBv2C,EAChBw2C,EAAMzzC,KAAK/C,KAMf4/B,IAAK,SAAc7rB,EAAKtG,EAAO2sC,GAC7B,IAAIp6C,EAAUw2C,EAAMA,EAAMr1C,OAAS,GAEnCq1C,EAAMr1C,QAAU,EAChBo1C,EAAgBC,EAAMA,EAAMr1C,OAAS,GAIrC01C,EAAa72C,IAGfo4C,MAAO,SAAgBnkC,EAAMxG,EAAOmyB,GAClC,GAAK2W,KAkBDjlC,GACoB,aAAtBilC,EAAcxiC,KACdwiC,EAAc/X,SAASgR,cAAgBv7B,GAFzC,CAMA,IA8kBczQ,EAxjBRuK,EACArL,EAvBFF,EAAW+zC,EAAc/zC,SAiB7B,GAfEyR,EADE2iC,GAAS3iC,EAAKypB,OA8kBJ,YADAl6B,EA5kBK+yC,GA6kBbxiC,KAA+B,UAAXvQ,EAAGuQ,IA7kBOE,EAAO6hC,GAAiB7hC,GAChDzR,EAASrB,OAGVu1C,EACgB,aAArBA,GAGKd,GAAYrkC,KAAK0C,GAAQ,GAEzB,IAGFwiC,EAAqB,IAAM,GAV3B,GAaFG,GAA8B,aAArBF,IAEZziC,EAAOA,EAAKpL,QAAQgtC,GAAgB,OAIjC5I,GAAmB,MAATh5B,IAAiBlG,EArxBxC,SACEkG,EACAs+B,GAEA,IAAI8H,EAAQ9H,EAAaD,GAAWC,GAAcH,GAClD,GAAKiI,EAAM9oC,KAAK0C,GAAhB,CAOA,IAJA,IAGIrC,EAAOzF,EAAOmuC,EAHdC,EAAS,GACTC,EAAY,GACZl7B,EAAY+6B,EAAM/6B,UAAY,EAE1B1N,EAAQyoC,EAAMI,KAAKxmC,IAAQ,EACjC9H,EAAQyF,EAAMzF,OAEFmT,IACVk7B,EAAUz3C,KAAKu3C,EAAarmC,EAAK1K,MAAM+V,EAAWnT,IAClDouC,EAAOx3C,KAAKwI,KAAKC,UAAU8uC,KAG7B,IAAIvd,EAAMD,GAAalrB,EAAM,GAAG8rB,QAChC6c,EAAOx3C,KAAM,MAAQg6B,EAAM,KAC3Byd,EAAUz3C,KAAK,CAAE,WAAYg6B,IAC7Bzd,EAAYnT,EAAQyF,EAAM,GAAGzQ,OAM/B,OAJIme,EAAYrL,EAAK9S,SACnBq5C,EAAUz3C,KAAKu3C,EAAarmC,EAAK1K,MAAM+V,IACvCi7B,EAAOx3C,KAAKwI,KAAKC,UAAU8uC,KAEtB,CACLvrB,WAAYwrB,EAAOj3C,KAAK,KACxBi3C,OAAQC,IAsvBkCE,CAAUzmC,EAAMs+B,KACpD7vC,EAAQ,CACNkW,KAAM,EACNmW,WAAYhhB,EAAIghB,WAChBwrB,OAAQxsC,EAAIwsC,OACZtmC,KAAMA,GAEU,MAATA,GAAiBzR,EAASrB,QAAiD,MAAvCqB,EAASA,EAASrB,OAAS,GAAG8S,OAC3EvR,EAAQ,CACNkW,KAAM,EACN3E,KAAMA,IAGNvR,GAKFF,EAASO,KAAKL,KAIpBqxC,QAAS,SAAkB9/B,EAAMxG,EAAOmyB,GAGtC,GAAI2W,EAAe,CACjB,IAAI7zC,EAAQ,CACVkW,KAAM,EACN3E,KAAMA,EACNW,WAAW,GAET,EAIJ2hC,EAAc/zC,SAASO,KAAKL,OAI3B4zC,EA8BT,SAASU,GACPh3C,EACAqH,GA8SF,IAA4B7D,GAvR5B,SAAqBA,GACnB,IAAIu5B,EAAMsC,GAAe77B,EAAI,OAC7B,GAAIu5B,EAAK,CAqBPv5B,EAAGnE,IAAM09B,GA5CX4d,CAAW36C,GAIXA,EAAQo+B,OACLp+B,EAAQX,MACRW,EAAQ2lB,cACR3lB,EAAQy+B,UAAUt9B,OAyCvB,SAAqBqC,GACnB,IAAI2xB,EAAMkK,GAAe77B,EAAI,OACzB2xB,IACF3xB,EAAG2xB,IAAMA,EACT3xB,EAAGm2B,SAsZP,SAAqBn2B,GACnB,IAAIoE,EAASpE,EACb,KAAOoE,GAAQ,CACb,QAAmB0C,IAAf1C,EAAOgzC,IACT,OAAO,EAEThzC,EAASA,EAAOA,OAElB,OAAO,EA9ZSizC,CAAWr3C,IA1C3Bs3C,CAAW96C,GAuJb,SAA6BwD,GAC3B,IAAIg0C,EACW,aAAXh0C,EAAGuQ,KACLyjC,EAAYhY,GAAiBh8B,EAAI,SAYjCA,EAAGg0C,UAAYA,GAAahY,GAAiBh8B,EAAI,gBACvCg0C,EAAYhY,GAAiBh8B,EAAI,iBAW3CA,EAAGg0C,UAAYA,GAIjB,IAAIC,EAAapY,GAAe77B,EAAI,QAChCi0C,IACFj0C,EAAGi0C,WAA4B,OAAfA,EAAsB,YAAcA,EACpDj0C,EAAGu3C,qBAAuBv3C,EAAGg7B,SAAS,WAAYh7B,EAAGg7B,SAAS,gBAG/C,aAAXh7B,EAAGuQ,KAAuBvQ,EAAGg0C,WAC/BnZ,GAAQ76B,EAAI,OAAQi0C,EA1gG1B,SACEj0C,EACAnF,GAEA,OAAOmF,EAAG0yC,YAAY,IAAM73C,IAC1BmF,EAAG0yC,YAAY,UAAY73C,IAC3BmF,EAAG0yC,YAAY73C,GAogGmB28C,CAAkBx3C,EAAI,UAMxD,GAAe,aAAXA,EAAGuQ,IAAoB,CAEzB,IAAIknC,EAActb,GAAwBn8B,EAAImyC,IAC9C,GAAIsF,EAAa,CACX,EAeJ,IAAI9lB,EAAM+lB,GAAYD,GAClB58C,EAAO82B,EAAI92B,KACX6/B,EAAU/I,EAAI+I,QAClB16B,EAAGi0C,WAAap5C,EAChBmF,EAAGu3C,kBAAoB7c,EACvB16B,EAAGg0C,UAAYyD,EAAYl8C,OAASg3C,QAEjC,CAEL,IAAIoF,EAAgBxb,GAAwBn8B,EAAImyC,IAChD,GAAIwF,EAAe,CACb,EAsBJ,IAAIn7B,EAAQxc,EAAGmiB,cAAgBniB,EAAGmiB,YAAc,IAC5Cy1B,EAAQF,GAAYC,GACpBh7B,EAASi7B,EAAM/8C,KACfg9C,EAAYD,EAAMld,QAClBod,EAAgBt7B,EAAMG,GAAU61B,GAAiB,WAAY,GAAIxyC,GACrE83C,EAAc7D,WAAat3B,EAC3Bm7B,EAAcP,kBAAoBM,EAClCC,EAAc94C,SAAWgB,EAAGhB,SAASC,QAAO,SAAUtE,GACpD,IAAKA,EAAEq5C,UAEL,OADAr5C,EAAEyJ,OAAS0zC,GACJ,KAGXA,EAAc9D,UAAY2D,EAAcp8C,OAASg3C,GAEjDvyC,EAAGhB,SAAW,GAEdgB,EAAG46B,OAAQ,IAvQjBmd,CAAmBv7C,GAkSJ,UADWwD,EAhSRxD,GAiSX+T,MACLvQ,EAAGg4C,SAAWnc,GAAe77B,EAAI,SAYrC,SAA2BA,GACzB,IAAIsqC,GACCA,EAAUzO,GAAe77B,EAAI,SAChCA,EAAGumB,UAAY+jB,GAE8B,MAA3CtO,GAAiBh8B,EAAI,qBACvBA,EAAGmjB,gBAAiB,GAnTtB80B,CAAiBz7C,GACjB,IAAK,IAAIlC,EAAI,EAAGA,EAAI82C,GAAWzzC,OAAQrD,IACrCkC,EAAU40C,GAAW92C,GAAGkC,EAASqH,IAAYrH,EAG/C,OAkTF,SAAuBwD,GACrB,IACI1F,EAAGC,EAAGM,EAAMi9B,EAASv8B,EAAOq8B,EAAWsgB,EAASC,EADhD7vC,EAAOtI,EAAGi7B,UAEd,IAAK3gC,EAAI,EAAGC,EAAI+N,EAAK3K,OAAQrD,EAAIC,EAAGD,IAAK,CAGvC,GAFAO,EAAOi9B,EAAUxvB,EAAKhO,GAAGO,KACzBU,EAAQ+M,EAAKhO,GAAGiB,MACZo2C,GAAM5jC,KAAKlT,GASb,GAPAmF,EAAGo4C,aAAc,GAEjBxgB,EAAYygB,GAAex9C,EAAKwK,QAAQssC,GAAO,QAG7C92C,EAAOA,EAAKwK,QAAQ6sC,GAAY,KAE9BD,GAAOlkC,KAAKlT,GACdA,EAAOA,EAAKwK,QAAQ4sC,GAAQ,IAC5B12C,EAAQ+9B,GAAa/9B,IACrB48C,EAAYpG,GAAahkC,KAAKlT,MAE5BA,EAAOA,EAAKkL,MAAM,GAAI,IAUpB6xB,IACEA,EAAU3gB,OAASkhC,GAER,eADbt9C,EAAOsO,EAAStO,MACYA,EAAO,aAEjC+8B,EAAU0gB,QAAUH,IACtBt9C,EAAOsO,EAAStO,IAEd+8B,EAAU/R,OACZqyB,EAAUxb,GAAkBnhC,EAAO,UAC9B48C,EAuBH9c,GACEr7B,EACC,cAAkBnF,EAAO,IAC1Bq9C,EACA,MACA,EACA/G,EACA7oC,EAAKhO,IACL,IA9BF+gC,GACEr7B,EACC,UAAamJ,EAAStO,GACvBq9C,EACA,MACA,EACA/G,EACA7oC,EAAKhO,IAEHkP,EAAU3O,KAAUsO,EAAStO,IAC/BwgC,GACEr7B,EACC,UAAawJ,EAAU3O,GACxBq9C,EACA,MACA,EACA/G,EACA7oC,EAAKhO,OAkBVs9B,GAAaA,EAAU3gB,OACzBjX,EAAGumB,WAAairB,GAAoBxxC,EAAGuQ,IAAKvQ,EAAGg7B,SAAS5lB,KAAMva,GAE/D4/B,GAAQz6B,EAAInF,EAAMU,EAAO+M,EAAKhO,GAAI69C,GAElCtd,GAAQ76B,EAAInF,EAAMU,EAAO+M,EAAKhO,GAAI69C,QAE/B,GAAIzG,GAAK3jC,KAAKlT,GACnBA,EAAOA,EAAKwK,QAAQqsC,GAAM,KAC1ByG,EAAYpG,GAAahkC,KAAKlT,MAE5BA,EAAOA,EAAKkL,MAAM,GAAI,IAExBs1B,GAAWr7B,EAAInF,EAAMU,EAAOq8B,GAAW,EAAOuZ,EAAQ7oC,EAAKhO,GAAI69C,OAC1D,CAGL,IAAII,GAFJ19C,EAAOA,EAAKwK,QAAQssC,GAAO,KAEPvjC,MAAM4jC,IACtBza,EAAMghB,GAAYA,EAAS,GAC/BJ,GAAY,EACR5gB,IACF18B,EAAOA,EAAKkL,MAAM,IAAKwxB,EAAI55B,OAAS,IAChCo0C,GAAahkC,KAAKwpB,KACpBA,EAAMA,EAAIxxB,MAAM,GAAI,GACpBoyC,GAAY,IAGhBjd,GAAal7B,EAAInF,EAAMi9B,EAASv8B,EAAOg8B,EAAK4gB,EAAWvgB,EAAWtvB,EAAKhO,SAmBzEugC,GAAQ76B,EAAInF,EAAMkN,KAAKC,UAAUzM,GAAQ+M,EAAKhO,KAGzC0F,EAAGumB,WACK,UAAT1rB,GACA22C,GAAoBxxC,EAAGuQ,IAAKvQ,EAAGg7B,SAAS5lB,KAAMva,IAChD4/B,GAAQz6B,EAAInF,EAAM,OAAQyN,EAAKhO,KAnbrCk+C,CAAah8C,GACNA,EAsCT,SAASi6C,GAAYz2C,GACnB,IAAIu5B,EACJ,GAAKA,EAAMyC,GAAiBh8B,EAAI,SAAW,CACzC,IAAIuK,EAcR,SAAmBgvB,GACjB,IAAIkf,EAAUlf,EAAInrB,MAAMwjC,IACxB,IAAK6G,EAAW,OAChB,IAAIluC,EAAM,GACVA,EAAI6sC,IAAMqB,EAAQ,GAAGve,OACrB,IAAIwe,EAAQD,EAAQ,GAAGve,OAAO70B,QAAQysC,GAAe,IACjD6G,EAAgBD,EAAMtqC,MAAMyjC,IAC5B8G,GACFpuC,EAAImuC,MAAQA,EAAMrzC,QAAQwsC,GAAe,IAAI3X,OAC7C3vB,EAAIquC,UAAYD,EAAc,GAAGze,OAC7Bye,EAAc,KAChBpuC,EAAIsuC,UAAYF,EAAc,GAAGze,SAGnC3vB,EAAImuC,MAAQA,EAEd,OAAOnuC,EA9BKuuC,CAASvf,GACfhvB,GACFJ,EAAOnK,EAAIuK,IAoFjB,SAASqpC,GAAgB5zC,EAAI+4C,GACtB/4C,EAAGg5C,eACNh5C,EAAGg5C,aAAe,IAEpBh5C,EAAGg5C,aAAaz5C,KAAKw5C,GAmIvB,SAASrB,GAAapN,GACpB,IAAIzvC,EAAOyvC,EAAQzvC,KAAKwK,QAAQ8sC,GAAQ,IAWxC,OAVKt3C,GACqB,MAApByvC,EAAQzvC,KAAK,KACfA,EAAO,WAQJk3C,GAAahkC,KAAKlT,GAErB,CAAEA,KAAMA,EAAKkL,MAAM,GAAI,GAAI20B,SAAS,GAEpC,CAAE7/B,KAAO,IAAOA,EAAO,IAAO6/B,SAAS,GA6K7C,SAAS2d,GAAgBx9C,GACvB,IAAIuT,EAAQvT,EAAKuT,MAAM8jC,IACvB,GAAI9jC,EAAO,CACT,IAAIlE,EAAM,GAEV,OADAkE,EAAMxL,SAAQ,SAAUlI,GAAKwP,EAAIxP,EAAEqL,MAAM,KAAM,KACxCmE,GAIX,SAASuoC,GAAch2B,GAErB,IADA,IAAI5c,EAAM,GACDvF,EAAI,EAAGC,EAAIkiB,EAAM9e,OAAQrD,EAAIC,EAAGD,IAOvCuF,EAAI4c,EAAMniB,GAAGO,MAAQ4hB,EAAMniB,GAAGiB,MAEhC,OAAOsE,EAkBT,IAAIu2C,GAAU,eACVC,GAAa,UAgGjB,SAAS4C,GAAiBj5C,GACxB,OAAOwyC,GAAiBxyC,EAAGuQ,IAAKvQ,EAAGi7B,UAAUl1B,QAAS/F,EAAGoE,QAG3D,IAII80C,GAAY,CACdhK,GACAM,GANY,CACZ2J,iBAnEF,SAA2Bn5C,EAAI6D,GAC7B,GAAe,UAAX7D,EAAGuQ,IAAiB,CACtB,IAKI6oC,EALAv5C,EAAMG,EAAGg7B,SACb,IAAKn7B,EAAI,WACP,OAWF,IAPIA,EAAI,UAAYA,EAAI,kBACtBu5C,EAAcvd,GAAe77B,EAAI,SAE9BH,EAAIuV,MAASgkC,IAAev5C,EAAI,YACnCu5C,EAAc,IAAOv5C,EAAI,UAAa,UAGpCu5C,EAAa,CACf,IAAIC,EAAcrd,GAAiBh8B,EAAI,QAAQ,GAC3Cs5C,EAAmBD,EAAe,MAAQA,EAAc,IAAO,GAC/DE,EAAkD,MAAxCvd,GAAiBh8B,EAAI,UAAU,GACzCw5C,EAAkBxd,GAAiBh8B,EAAI,aAAa,GAEpDy5C,EAAUR,GAAgBj5C,GAE9By2C,GAAWgD,GACX1e,GAAW0e,EAAS,OAAQ,YAC5BjG,GAAeiG,EAAS51C,GACxB41C,EAAQlG,WAAY,EACpBkG,EAAQhG,GAAK,IAAM2F,EAAc,iBAAmBE,EACpD1F,GAAe6F,EAAS,CACtBlgB,IAAKkgB,EAAQhG,GACbI,MAAO4F,IAGT,IAAIC,EAAUT,GAAgBj5C,GAC9Bg8B,GAAiB0d,EAAS,SAAS,GACnC3e,GAAW2e,EAAS,OAAQ,SAC5BlG,GAAekG,EAAS71C,GACxB+vC,GAAe6F,EAAS,CACtBlgB,IAAK,IAAM6f,EAAc,cAAgBE,EACzCzF,MAAO6F,IAGT,IAAIC,EAAUV,GAAgBj5C,GAe9B,OAdAg8B,GAAiB2d,EAAS,SAAS,GACnC5e,GAAW4e,EAAS,QAASP,GAC7B5F,GAAemG,EAAS91C,GACxB+vC,GAAe6F,EAAS,CACtBlgB,IAAK8f,EACLxF,MAAO8F,IAGLJ,EACFE,EAAQ9F,MAAO,EACN6F,IACTC,EAAQ/F,OAAS8F,GAGZC,OAmCb,IAuBIG,GACAC,GAhBAC,GAAc,CAChB1F,YAAY,EACZ55C,QAAS0+C,GACTjjC,WAXiB,CACjB4Q,MAhtGF,SACE7mB,EACA82B,EACAijB,GAESA,EACT,IAAIx+C,EAAQu7B,EAAIv7B,MACZq8B,EAAYd,EAAIc,UAChBrnB,EAAMvQ,EAAGuQ,IACT6E,EAAOpV,EAAGg7B,SAAS5lB,KAcvB,GAAIpV,EAAGumB,UAGL,OAFA8V,GAAkBr8B,EAAIzE,EAAOq8B,IAEtB,EACF,GAAY,WAARrnB,GAqEb,SACEvQ,EACAzE,EACAq8B,GAEA,IAOIoiB,EAAO,8KAPEpiB,GAAaA,EAAU0E,OAIZ,UAAY,OAGzB,MACX0d,EAAOA,EAAO,IAAOtd,GAAkBnhC,EAFtB,6DAGjB8/B,GAAWr7B,EAAI,SAAUg6C,EAAM,MAAM,GAlFnCC,CAAUj6C,EAAIzE,EAAOq8B,QAChB,GAAY,UAARrnB,GAA4B,aAAT6E,GAwBhC,SACEpV,EACAzE,EACAq8B,GAEA,IAAI0E,EAAS1E,GAAaA,EAAU0E,OAChC4d,EAAere,GAAe77B,EAAI,UAAY,OAC9Cm6C,EAAmBte,GAAe77B,EAAI,eAAiB,OACvDo6C,EAAoBve,GAAe77B,EAAI,gBAAkB,QAC7Dy6B,GAAQz6B,EAAI,UACV,iBAAmBzE,EAAnB,QACSA,EAAQ,IAAM2+C,EAAe,QACf,SAArBC,EACK,KAAO5+C,EAAQ,IACf,OAASA,EAAQ,IAAM4+C,EAAmB,MAGnD9e,GAAWr7B,EAAI,SACb,WAAazE,EAAb,yCAE2B4+C,EAAmB,MAAQC,EAFtD,qCAIgB9d,EAAS,MAAQ4d,EAAe,IAAMA,GAJtD,6CAMiCxd,GAAkBnhC,EAAO,qBAN1D,mBAOsBmhC,GAAkBnhC,EAAO,6CAP/C,WAQYmhC,GAAkBnhC,EAAO,OAAU,IAC/C,MAAM,GAlDN8+C,CAAiBr6C,EAAIzE,EAAOq8B,QACvB,GAAY,UAARrnB,GAA4B,UAAT6E,GAqDhC,SACEpV,EACAzE,EACAq8B,GAEA,IAAI0E,EAAS1E,GAAaA,EAAU0E,OAChC4d,EAAere,GAAe77B,EAAI,UAAY,OAElDy6B,GAAQz6B,EAAI,UAAY,MAAQzE,EAAQ,KADxC2+C,EAAe5d,EAAU,MAAQ4d,EAAe,IAAOA,GACM,KAC7D7e,GAAWr7B,EAAI,SAAU08B,GAAkBnhC,EAAO2+C,GAAe,MAAM,GA7DrEI,CAAct6C,EAAIzE,EAAOq8B,QACpB,GAAY,UAARrnB,GAA2B,aAARA,GAgFhC,SACEvQ,EACAzE,EACAq8B,GAEA,IAAIxiB,EAAOpV,EAAGg7B,SAAS5lB,KAInB,EAaJ,IAAIuc,EAAMiG,GAAa,GACnB5M,EAAO2G,EAAI3G,KACXsR,EAAS3K,EAAI2K,OACbpC,EAAOvI,EAAIuI,KACXqgB,GAAwBvvB,GAAiB,UAAT5V,EAChC2F,EAAQiQ,EACR,SACS,UAAT5V,EACEgoB,GACA,QAEFZ,EAAkB,sBAClBtC,IACFsC,EAAkB,8BAEhBF,IACFE,EAAkB,MAAQA,EAAkB,KAG9C,IAAIwd,EAAOtd,GAAkBnhC,EAAOihC,GAChC+d,IACFP,EAAO,qCAAuCA,GAGhDvf,GAAQz6B,EAAI,QAAU,IAAMzE,EAAQ,KACpC8/B,GAAWr7B,EAAI+a,EAAOi/B,EAAM,MAAM,IAC9B9f,GAAQoC,IACVjB,GAAWr7B,EAAI,OAAQ,kBAhIvBw6C,CAAgBx6C,EAAIzE,EAAOq8B,OACtB,KAAK70B,EAAOqJ,cAAcmE,GAG/B,OAFA8rB,GAAkBr8B,EAAIzE,EAAOq8B,IAEtB,EAYT,OAAO,GA+pGPnnB,KAhBF,SAAezQ,EAAI82B,GACbA,EAAIv7B,OACNk/B,GAAQz6B,EAAI,cAAgB,MAAS82B,EAAS,MAAI,IAAMA,IAe1D6Y,KATF,SAAe3vC,EAAI82B,GACbA,EAAIv7B,OACNk/B,GAAQz6B,EAAI,YAAc,MAAS82B,EAAS,MAAI,IAAMA,KAgBxD+b,SA93Ja,SAAUtiC,GAAO,MAAe,QAARA,GA+3JrCq/B,WAAYA,GACZnjC,YAAaA,GACbojC,iBAAkBA,GAClBzjC,cAAeA,GACfG,gBAAiBA,GACjB4iC,WAxmUF,SAAwB30C,GACtB,OAAOA,EAAQigD,QAAO,SAAUv9C,EAAMxC,GACpC,OAAOwC,EAAKyB,OAAOjE,EAAEy0C,YAAc,MAClC,IAAIrvC,KAAK,KAqmUA46C,CAAcxB,KAQxByB,GAAsB5xC,GAuB1B,SAA0B7L,GACxB,OAAOiL,EACL,iFACCjL,EAAO,IAAMA,EAAO,QAbzB,SAAS09C,GAAU9H,EAAMjvC,GAClBivC,IACL8G,GAAce,GAAoB92C,EAAQsrC,YAAc,IACxD0K,GAAwBh2C,EAAQuI,eAAiB1B,EAEjDmwC,GAAa/H,GAEbgI,GAAgBhI,GAAM,IAUxB,SAAS+H,GAAcjpC,GAErB,GADAA,EAAKmpC,OA6DP,SAAmBnpC,GACjB,GAAkB,IAAdA,EAAKwD,KACP,OAAO,EAET,GAAkB,IAAdxD,EAAKwD,KACP,OAAO,EAET,SAAUxD,EAAKkW,MACZlW,EAAKwmC,aACLxmC,EAAK6hC,IAAO7hC,EAAKwlC,KACjB7uC,EAAaqJ,EAAKrB,OACnBspC,GAAsBjoC,EAAKrB,MAM/B,SAAqCqB,GACnC,KAAOA,EAAKxN,QAAQ,CAElB,GAAiB,cADjBwN,EAAOA,EAAKxN,QACHmM,IACP,OAAO,EAET,GAAIqB,EAAKwlC,IACP,OAAO,EAGX,OAAO,EAfJ4D,CAA2BppC,KAC5B5W,OAAOkC,KAAK0U,GAAM3G,MAAM2uC,MA1EZ1oC,CAASU,GACL,IAAdA,EAAKwD,KAAY,CAInB,IACGykC,GAAsBjoC,EAAKrB,MACf,SAAbqB,EAAKrB,KAC+B,MAApCqB,EAAKopB,SAAS,mBAEd,OAEF,IAAK,IAAI1gC,EAAI,EAAGC,EAAIqX,EAAK5S,SAASrB,OAAQrD,EAAIC,EAAGD,IAAK,CACpD,IAAI4E,EAAQ0S,EAAK5S,SAAS1E,GAC1BugD,GAAa37C,GACRA,EAAM67C,SACTnpC,EAAKmpC,QAAS,GAGlB,GAAInpC,EAAKonC,aACP,IAAK,IAAIloB,EAAM,EAAGmqB,EAAMrpC,EAAKonC,aAAar7C,OAAQmzB,EAAMmqB,EAAKnqB,IAAO,CAClE,IAAI+iB,EAAQjiC,EAAKonC,aAAaloB,GAAK+iB,MACnCgH,GAAahH,GACRA,EAAMkH,SACTnpC,EAAKmpC,QAAS,KAOxB,SAASD,GAAiBlpC,EAAM4N,GAC9B,GAAkB,IAAd5N,EAAKwD,KAAY,CAOnB,IANIxD,EAAKmpC,QAAUnpC,EAAKrG,QACtBqG,EAAKspC,YAAc17B,GAKjB5N,EAAKmpC,QAAUnpC,EAAK5S,SAASrB,SACN,IAAzBiU,EAAK5S,SAASrB,QACY,IAA1BiU,EAAK5S,SAAS,GAAGoW,MAGjB,YADAxD,EAAKupC,YAAa,GAKpB,GAFEvpC,EAAKupC,YAAa,EAEhBvpC,EAAK5S,SACP,IAAK,IAAI1E,EAAI,EAAGC,EAAIqX,EAAK5S,SAASrB,OAAQrD,EAAIC,EAAGD,IAC/CwgD,GAAgBlpC,EAAK5S,SAAS1E,GAAIklB,KAAa5N,EAAKwlC,KAGxD,GAAIxlC,EAAKonC,aACP,IAAK,IAAIloB,EAAM,EAAGmqB,EAAMrpC,EAAKonC,aAAar7C,OAAQmzB,EAAMmqB,EAAKnqB,IAC3DgqB,GAAgBlpC,EAAKonC,aAAaloB,GAAK+iB,MAAOr0B,IAsCtD,IAAI47B,GAAU,0DACVC,GAAa,gBACbC,GAAe,+FAGfnvC,GAAW,CACbovC,IAAK,GACLC,IAAK,EACL9X,MAAO,GACP+X,MAAO,GACPC,GAAI,GACJr1C,KAAM,GACNm1B,MAAO,GACPmgB,KAAM,GACN,OAAU,CAAC,EAAG,KAIZC,GAAW,CAEbL,IAAK,CAAC,MAAO,UACbC,IAAK,MACL9X,MAAO,QAEP+X,MAAO,CAAC,IAAK,YAEbC,GAAI,CAAC,KAAM,WACXr1C,KAAM,CAAC,OAAQ,aACfm1B,MAAO,CAAC,QAAS,cACjBmgB,KAAM,CAAC,OAAQ,aAEf,OAAU,CAAC,YAAa,SAAU,QAMhCE,GAAW,SAAU9C,GAAa,MAAQ,MAAQA,EAAY,iBAE9D+C,GAAe,CACjBC,KAAM,4BACNC,QAAS,2BACTC,KAAMJ,GAAS,0CACfK,KAAML,GAAS,mBACf7/B,MAAO6/B,GAAS,oBAChBM,IAAKN,GAAS,kBACdO,KAAMP,GAAS,mBACfx1C,KAAMw1C,GAAS,6CACfpgB,OAAQogB,GAAS,6CACjBrgB,MAAOqgB,GAAS,8CAGlB,SAASQ,GACP9gB,EACAzsB,GAEA,IAAIwtC,EAASxtC,EAAW,YAAc,MAClCytC,EAAiB,GACjBC,EAAkB,GACtB,IAAK,IAAI3hD,KAAQ0gC,EAAQ,CACvB,IAAIkhB,EAAcC,GAAWnhB,EAAO1gC,IAChC0gC,EAAO1gC,IAAS0gC,EAAO1gC,GAAM6/B,QAC/B8hB,GAAmB3hD,EAAO,IAAM4hD,EAAc,IAE9CF,GAAkB,IAAO1hD,EAAO,KAAQ4hD,EAAc,IAI1D,OADAF,EAAiB,IAAOA,EAAex2C,MAAM,GAAI,GAAM,IACnDy2C,EACKF,EAAS,MAAQC,EAAiB,KAAQC,EAAgBz2C,MAAM,GAAI,GAAM,KAE1Eu2C,EAASC,EAIpB,SAASG,GAAY56C,GACnB,IAAKA,EACH,MAAO,eAGT,GAAI9E,MAAM8K,QAAQhG,GAChB,MAAQ,IAAOA,EAAQjC,KAAI,SAAUiC,GAAW,OAAO46C,GAAW56C,MAAahC,KAAK,KAAQ,IAG9F,IAAI68C,EAAerB,GAAavtC,KAAKjM,EAAQvG,OACzCqhD,EAAuBxB,GAAQrtC,KAAKjM,EAAQvG,OAC5CshD,EAAuBvB,GAAavtC,KAAKjM,EAAQvG,MAAM8J,QAAQg2C,GAAY,KAE/E,GAAKv5C,EAAQ81B,UAKN,CACL,IAAIoiB,EAAO,GACP8C,EAAkB,GAClB5/C,EAAO,GACX,IAAK,IAAIrB,KAAOiG,EAAQ81B,UACtB,GAAIkkB,GAAajgD,GACfihD,GAAmBhB,GAAajgD,GAE5BsQ,GAAStQ,IACXqB,EAAKqC,KAAK1D,QAEP,GAAY,UAARA,EAAiB,CAC1B,IAAI+7B,EAAa91B,EAAiB,UAClCg7C,GAAmBjB,GACjB,CAAC,OAAQ,QAAS,MAAO,QACtB58C,QAAO,SAAU89C,GAAe,OAAQnlB,EAAUmlB,MAClDl9C,KAAI,SAAUk9C,GAAe,MAAQ,UAAYA,EAAc,SAC/Dj9C,KAAK,YAGV5C,EAAKqC,KAAK1D,GAiBd,OAdIqB,EAAKS,SACPq8C,GAiBN,SAAuB98C,GACrB,MAIE,mCACCA,EAAK2C,IAAIm9C,IAAel9C,KAAK,MAAS,gBAvB7Bm9C,CAAa//C,IAGnB4/C,IACF9C,GAAQ8C,GASF,oBAAsB9C,GAPZ2C,EACb,UAAa76C,EAAa,MAAI,WAC/B86C,EACG,WAAc96C,EAAa,MAAI,YAChC+6C,EACG,UAAa/6C,EAAa,MAC3BA,EAAQvG,OACmC,IAzCnD,OAAIohD,GAAgBC,EACX96C,EAAQvG,MAET,qBAAuBshD,EAAwB,UAAa/6C,EAAa,MAAKA,EAAQvG,OAAS,IAoD3G,SAASyhD,GAAenhD,GACtB,IAAIqhD,EAAS7qB,SAASx2B,EAAK,IAC3B,GAAIqhD,EACF,MAAQ,oBAAsBA,EAEhC,IAAIC,EAAUhxC,GAAStQ,GACnBuhD,EAAUxB,GAAS//C,GACvB,MACE,qBACCkM,KAAKC,UAAUnM,GAAQ,IACvBkM,KAAKC,UAAUm1C,GAFhB,eAIMp1C,KAAKC,UAAUo1C,GACrB,IAuBJ,IAAIC,GAAiB,CACnB3iC,GAlBF,SAAa1a,EAAI82B,GAIf92B,EAAGs9C,cAAgB,SAAUtD,GAAQ,MAAQ,MAAQA,EAAO,IAAOljB,EAAS,MAAI,MAehFh7B,KAVF,SAAiBkE,EAAI82B,GACnB92B,EAAGu9C,SAAW,SAAUvD,GACtB,MAAQ,MAAQA,EAAO,KAAQh6C,EAAM,IAAI,KAAQ82B,EAAS,MAAI,KAAOA,EAAIc,WAAad,EAAIc,UAAU3gB,KAAO,OAAS,UAAY6f,EAAIc,WAAad,EAAIc,UAAU/R,KAAO,QAAU,IAAM,MASxL23B,MAAOhzC,GASLizC,GAAe,SAAuB55C,GACxC9D,KAAK8D,QAAUA,EACf9D,KAAKuP,KAAOzL,EAAQyL,MAAQ+qB,GAC5Bt6B,KAAKqxC,WAAa5W,GAAoB32B,EAAQrJ,QAAS,iBACvDuF,KAAK29C,WAAaljB,GAAoB32B,EAAQrJ,QAAS,WACvDuF,KAAKkW,WAAa9L,EAAOA,EAAO,GAAIkzC,IAAiBx5C,EAAQoS,YAC7D,IAAI7J,EAAgBvI,EAAQuI,eAAiB1B,EAC7C3K,KAAK49C,eAAiB,SAAU39C,GAAM,QAASA,EAAGumB,YAAcna,EAAcpM,EAAGuQ,MACjFxQ,KAAK69C,OAAS,EACd79C,KAAKuD,gBAAkB,GACvBvD,KAAK+nB,KAAM,GAKb,SAAS+1B,GACPC,EACAj6C,GAEA,IAAIk6C,EAAQ,IAAIN,GAAa55C,GAE7B,MAAO,CACLR,OAAS,sBAFAy6C,EAAME,GAAWF,EAAKC,GAAS,aAED,IACvCz6C,gBAAiBy6C,EAAMz6C,iBAI3B,SAAS06C,GAAYh+C,EAAI+9C,GAKvB,GAJI/9C,EAAGoE,SACLpE,EAAG8nB,IAAM9nB,EAAG8nB,KAAO9nB,EAAGoE,OAAO0jB,KAG3B9nB,EAAGm7C,aAAen7C,EAAGi+C,gBACvB,OAAOC,GAAUl+C,EAAI+9C,GAChB,GAAI/9C,EAAGuL,OAASvL,EAAGm+C,cACxB,OAAOC,GAAQp+C,EAAI+9C,GACd,GAAI/9C,EAAGo3C,MAAQp3C,EAAGq+C,aACvB,OAAOC,GAAOt+C,EAAI+9C,GACb,GAAI/9C,EAAGyzC,KAAOzzC,EAAGu+C,YACtB,OAAOC,GAAMx+C,EAAI+9C,GACZ,GAAe,aAAX/9C,EAAGuQ,KAAuBvQ,EAAGi0C,YAAe8J,EAAMj2B,IAEtD,IAAe,SAAX9nB,EAAGuQ,IACZ,OAubJ,SAAkBvQ,EAAI+9C,GACpB,IAAI/F,EAAWh4C,EAAGg4C,UAAY,YAC1Bh5C,EAAWy/C,GAAYz+C,EAAI+9C,GAC3BxzC,EAAM,MAAQytC,GAAYh5C,EAAY,IAAMA,EAAY,IACxDyd,EAAQzc,EAAGyc,OAASzc,EAAG86B,aACvB4jB,IAAU1+C,EAAGyc,OAAS,IAAI9d,OAAOqB,EAAG86B,cAAgB,IAAIj7B,KAAI,SAAUyzB,GAAQ,MAAO,CAEnFz4B,KAAMsO,EAASmqB,EAAKz4B,MACpBU,MAAO+3B,EAAK/3B,MACZm/B,QAASpH,EAAKoH,aAEhB,KACAikB,EAAU3+C,EAAGg7B,SAAS,WACrBve,IAASkiC,GAAa3/C,IACzBuL,GAAO,SAELkS,IACFlS,GAAO,IAAMkS,GAEXkiC,IACFp0C,IAAQkS,EAAQ,GAAK,SAAW,IAAMkiC,GAExC,OAAOp0C,EAAM,IA7cJq0C,CAAQ5+C,EAAI+9C,GAGnB,IAAI/D,EACJ,GAAIh6C,EAAGumB,UACLyzB,EA4cN,SACE6E,EACA7+C,EACA+9C,GAEA,IAAI/+C,EAAWgB,EAAGmjB,eAAiB,KAAOs7B,GAAYz+C,EAAI+9C,GAAO,GACjE,MAAQ,MAAQc,EAAgB,IAAOC,GAAU9+C,EAAI+9C,IAAW/+C,EAAY,IAAMA,EAAY,IAAM,IAldzF+/C,CAAa/+C,EAAGumB,UAAWvmB,EAAI+9C,OACjC,CACL,IAAIvtC,IACCxQ,EAAG46B,OAAU56B,EAAG8nB,KAAOi2B,EAAMJ,eAAe39C,MAC/CwQ,EAAOsuC,GAAU9+C,EAAI+9C,IAGvB,IAAI/+C,EAAWgB,EAAGmjB,eAAiB,KAAOs7B,GAAYz+C,EAAI+9C,GAAO,GACjE/D,EAAO,OAAUh6C,EAAM,IAAI,KAAOwQ,EAAQ,IAAMA,EAAQ,KAAOxR,EAAY,IAAMA,EAAY,IAAM,IAGrG,IAAK,IAAI1E,EAAI,EAAGA,EAAIyjD,EAAM3M,WAAWzzC,OAAQrD,IAC3C0/C,EAAO+D,EAAM3M,WAAW92C,GAAG0F,EAAIg6C,GAEjC,OAAOA,EArBP,OAAOyE,GAAYz+C,EAAI+9C,IAAU,SA0BrC,SAASG,GAAWl+C,EAAI+9C,GACtB/9C,EAAGi+C,iBAAkB,EAIrB,IAAIe,EAAmBjB,EAAMj2B,IAM7B,OALI9nB,EAAG8nB,MACLi2B,EAAMj2B,IAAM9nB,EAAG8nB,KAEjBi2B,EAAMz6C,gBAAgB/D,KAAM,qBAAwBy+C,GAAWh+C,EAAI+9C,GAAU,KAC7EA,EAAMj2B,IAAMk3B,EACJ,OAASjB,EAAMz6C,gBAAgB3F,OAAS,IAAMqC,EAAGk7C,YAAc,QAAU,IAAM,IAIzF,SAASkD,GAASp+C,EAAI+9C,GAEpB,GADA/9C,EAAGm+C,eAAgB,EACfn+C,EAAGyzC,KAAOzzC,EAAGu+C,YACf,OAAOC,GAAMx+C,EAAI+9C,GACZ,GAAI/9C,EAAGk7C,YAAa,CAGzB,IAFA,IAAIr/C,EAAM,GACNuI,EAASpE,EAAGoE,OACTA,GAAQ,CACb,GAAIA,EAAOgzC,IAAK,CACdv7C,EAAMuI,EAAOvI,IACb,MAEFuI,EAASA,EAAOA,OAElB,OAAKvI,EAOG,MAASmiD,GAAWh+C,EAAI+9C,GAAU,IAAOA,EAAMH,SAAY,IAAM/hD,EAAM,IAFtEmiD,GAAWh+C,EAAI+9C,GAIxB,OAAOG,GAAUl+C,EAAI+9C,GAIzB,SAASS,GACPx+C,EACA+9C,EACAkB,EACAC,GAGA,OADAl/C,EAAGu+C,aAAc,EACVY,GAAgBn/C,EAAGg5C,aAAajzC,QAASg4C,EAAOkB,EAAQC,GAGjE,SAASC,GACPC,EACArB,EACAkB,EACAC,GAEA,IAAKE,EAAWzhD,OACd,OAAOuhD,GAAY,OAGrB,IAAInG,EAAYqG,EAAWpjC,QAC3B,OAAI+8B,EAAUxf,IACJ,IAAOwf,EAAa,IAAI,KAAQsG,EAActG,EAAUlF,OAAU,IAAOsL,GAAgBC,EAAYrB,EAAOkB,EAAQC,GAEpH,GAAMG,EAActG,EAAUlF,OAIxC,SAASwL,EAAer/C,GACtB,OAAOi/C,EACHA,EAAOj/C,EAAI+9C,GACX/9C,EAAGuL,KACD6yC,GAAQp+C,EAAI+9C,GACZC,GAAWh+C,EAAI+9C,IAIzB,SAASO,GACPt+C,EACA+9C,EACAkB,EACAK,GAEA,IAAI/lB,EAAMv5B,EAAGo3C,IACTsB,EAAQ14C,EAAG04C,MACXE,EAAY54C,EAAG44C,UAAa,IAAO54C,EAAY,UAAK,GACpD64C,EAAY74C,EAAG64C,UAAa,IAAO74C,EAAY,UAAK,GAkBxD,OADAA,EAAGq+C,cAAe,GACViB,GAAa,MAAQ,KAAO/lB,EAA7B,cACSmf,EAAQE,EAAYC,EAD7B,aAEWoG,GAAUjB,IAAYh+C,EAAI+9C,GAC1C,KAGJ,SAASe,GAAW9+C,EAAI+9C,GACtB,IAAIvtC,EAAO,IAIPwF,EA+EN,SAAwBhW,EAAI+9C,GAC1B,IAAI/nC,EAAOhW,EAAGiW,WACd,IAAKD,EAAQ,OACb,IAEI1b,EAAGC,EAAGu8B,EAAKyoB,EAFXh1C,EAAM,eACNi1C,GAAa,EAEjB,IAAKllD,EAAI,EAAGC,EAAIyb,EAAKrY,OAAQrD,EAAIC,EAAGD,IAAK,CACvCw8B,EAAM9gB,EAAK1b,GACXilD,GAAc,EACd,IAAIE,EAAM1B,EAAM9nC,WAAW6gB,EAAIj8B,MAC3B4kD,IAGFF,IAAgBE,EAAIz/C,EAAI82B,EAAKinB,EAAMzuC,OAEjCiwC,IACFC,GAAa,EACbj1C,GAAO,UAAcusB,EAAQ,KAAI,cAAmBA,EAAW,QAAI,KAAQA,EAAIv7B,MAAS,WAAcu7B,EAAS,MAAI,gBAAmB/uB,KAAKC,UAAU8uB,EAAIv7B,OAAW,KAAOu7B,EAAIS,IAAO,SAAWT,EAAIqE,aAAerE,EAAIS,IAAO,IAAQT,EAAO,IAAI,KAAU,KAAOA,EAAIc,UAAa,cAAiB7vB,KAAKC,UAAU8uB,EAAIc,WAAe,IAAM,MAGjV,GAAI4nB,EACF,OAAOj1C,EAAIxE,MAAM,GAAI,GAAK,IApGjB25C,CAAc1/C,EAAI+9C,GACzB/nC,IAAQxF,GAAQwF,EAAO,KAGvBhW,EAAGnE,MACL2U,GAAQ,OAAUxQ,EAAM,IAAI,KAG1BA,EAAG2xB,MACLnhB,GAAQ,OAAUxQ,EAAM,IAAI,KAE1BA,EAAGm2B,WACL3lB,GAAQ,kBAGNxQ,EAAG8nB,MACLtX,GAAQ,aAGNxQ,EAAGumB,YACL/V,GAAQ,QAAYxQ,EAAM,IAAI,MAGhC,IAAK,IAAI1F,EAAI,EAAGA,EAAIyjD,EAAML,WAAW//C,OAAQrD,IAC3CkW,GAAQutC,EAAML,WAAWpjD,GAAG0F,GA+B9B,GA5BIA,EAAGyc,QACLjM,GAAQ,SAAYkuC,GAAS1+C,EAAGyc,OAAU,KAGxCzc,EAAGsV,QACL9E,GAAQ,YAAekuC,GAAS1+C,EAAGsV,OAAU,KAG3CtV,EAAGu7B,SACL/qB,GAAS6rC,GAAYr8C,EAAGu7B,QAAQ,GAAU,KAExCv7B,EAAG27B,eACLnrB,GAAS6rC,GAAYr8C,EAAG27B,cAAc,GAAS,KAI7C37B,EAAGi0C,aAAej0C,EAAGg0C,YACvBxjC,GAAQ,QAAWxQ,EAAa,WAAI,KAGlCA,EAAGmiB,cACL3R,GAwEJ,SACExQ,EACAwc,EACAuhC,GAMA,IAAIl6B,EAAmB7jB,EAAGo3C,KAAOp8C,OAAOkC,KAAKsf,GAAOsuB,MAAK,SAAUjvC,GACjE,IAAI6gB,EAAOF,EAAM3gB,GACjB,OACE6gB,EAAK66B,mBACL76B,EAAK+2B,IACL/2B,EAAK06B,KACLuI,GAAkBjjC,MAQlBkjC,IAAa5/C,EAAGyzC,GAOpB,IAAK5vB,EAEH,IADA,IAAIzf,EAASpE,EAAGoE,OACTA,GAAQ,CACb,GACGA,EAAO4vC,WAAa5vC,EAAO4vC,YAAczB,IAC1CnuC,EAAOgzC,IACP,CACAvzB,GAAmB,EACnB,MAEEzf,EAAOqvC,KACTmM,GAAW,GAEbx7C,EAASA,EAAOA,OAIpB,IAAIy7C,EAAiB7kD,OAAOkC,KAAKsf,GAC9B3c,KAAI,SAAUhE,GAAO,OAAOikD,GAActjC,EAAM3gB,GAAMkiD,MACtDj+C,KAAK,KAER,MAAQ,mBAAqB+/C,EAAiB,KAAOh8B,EAAmB,aAAe,MAAQA,GAAoB+7B,EAAY,eAGjI,SAAcx3C,GACZ,IAAImT,EAAO,KACPjhB,EAAI8N,EAAIzK,OACZ,KAAMrD,GACJihB,EAAe,GAAPA,EAAanT,EAAI0E,aAAaxS,GAExC,OAAOihB,IAAS,EATgI,CAAMskC,GAAoB,IAAM,IA3HtK,CAAgB7/C,EAAIA,EAAGmiB,YAAa47B,GAAU,KAGpD/9C,EAAG6mB,QACLrW,GAAQ,gBAAmBxQ,EAAG6mB,MAAW,MAAI,aAAgB7mB,EAAG6mB,MAAc,SAAI,eAAkB7mB,EAAG6mB,MAAgB,WAAI,MAGzH7mB,EAAGmjB,eAAgB,CACrB,IAAIA,EAgDR,SAA4BnjB,EAAI+9C,GAC9B,IAAID,EAAM99C,EAAGhB,SAAS,GAClB,EAQJ,GAAI8+C,GAAoB,IAAbA,EAAI1oC,KAAY,CACzB,IAAI2qC,EAAkBlC,GAASC,EAAKC,EAAMl6C,SAC1C,MAAQ,qCAAwCk8C,EAAsB,OAAI,sBAAyBA,EAAgBz8C,gBAAgBzD,KAAI,SAAUm6C,GAAQ,MAAQ,cAAgBA,EAAO,OAASl6C,KAAK,KAAQ,MA5DzLkgD,CAAkBhgD,EAAI+9C,GACvC56B,IACF3S,GAAQ2S,EAAiB,KAkB7B,OAfA3S,EAAOA,EAAKnL,QAAQ,KAAM,IAAM,IAI5BrF,EAAG86B,eACLtqB,EAAO,MAAQA,EAAO,KAASxQ,EAAM,IAAI,KAAS0+C,GAAS1+C,EAAG86B,cAAiB,KAG7E96B,EAAGu9C,WACL/sC,EAAOxQ,EAAGu9C,SAAS/sC,IAGjBxQ,EAAGs9C,gBACL9sC,EAAOxQ,EAAGs9C,cAAc9sC,IAEnBA,EA2GT,SAASmvC,GAAmB3/C,GAC1B,OAAgB,IAAZA,EAAGoV,OACU,SAAXpV,EAAGuQ,KAGAvQ,EAAGhB,SAAS8rC,KAAK6U,KAK5B,SAASG,GACP9/C,EACA+9C,GAEA,IAAIkC,EAAiBjgD,EAAGg7B,SAAS,cACjC,GAAIh7B,EAAGyzC,KAAOzzC,EAAGu+C,cAAgB0B,EAC/B,OAAOzB,GAAMx+C,EAAI+9C,EAAO+B,GAAe,QAEzC,GAAI9/C,EAAGo3C,MAAQp3C,EAAGq+C,aAChB,OAAOC,GAAOt+C,EAAI+9C,EAAO+B,IAE3B,IAAI9L,EAAYh0C,EAAGg0C,YAAczB,GAC7B,GACAhrC,OAAOvH,EAAGg0C,WACVhrC,EAAK,YAAcgrC,EAAd,aACiB,aAAXh0C,EAAGuQ,IACZvQ,EAAGyzC,IAAMwM,EACN,IAAOjgD,EAAK,GAAI,MAAQy+C,GAAYz+C,EAAI+9C,IAAU,aAAe,aAClEU,GAAYz+C,EAAI+9C,IAAU,YAC5BC,GAAWh+C,EAAI+9C,IAAU,IAE3BmC,EAAelM,EAAY,GAAK,cACpC,MAAQ,SAAWh0C,EAAGi0C,YAAc,aAAiB,OAASjrC,EAAKk3C,EAAe,IAGpF,SAASzB,GACPz+C,EACA+9C,EACAoC,EACAC,EACAC,GAEA,IAAIrhD,EAAWgB,EAAGhB,SAClB,GAAIA,EAASrB,OAAQ,CACnB,IAAI2iD,EAAOthD,EAAS,GAEpB,GAAwB,IAApBA,EAASrB,QACX2iD,EAAKlJ,KACQ,aAAbkJ,EAAK/vC,KACQ,SAAb+vC,EAAK/vC,IACL,CACA,IAAImX,EAAoBy4B,EACpBpC,EAAMJ,eAAe2C,GAAQ,KAAO,KACpC,GACJ,MAAQ,IAAOF,GAAiBpC,IAAYsC,EAAMvC,GAAUr2B,EAE9D,IAAI64B,EAAsBJ,EAY9B,SACEnhD,EACA2+C,GAGA,IADA,IAAIpzC,EAAM,EACDjQ,EAAI,EAAGA,EAAI0E,EAASrB,OAAQrD,IAAK,CACxC,IAAI0F,EAAKhB,EAAS1E,GAClB,GAAgB,IAAZ0F,EAAGoV,KAAP,CAGA,GAAIorC,GAAmBxgD,IAClBA,EAAGg5C,cAAgBh5C,EAAGg5C,aAAalO,MAAK,SAAUnwC,GAAK,OAAO6lD,GAAmB7lD,EAAEk5C,UAAa,CACnGtpC,EAAM,EACN,OAEEozC,EAAe39C,IACdA,EAAGg5C,cAAgBh5C,EAAGg5C,aAAalO,MAAK,SAAUnwC,GAAK,OAAOgjD,EAAehjD,EAAEk5C,aAClFtpC,EAAM,IAGV,OAAOA,EA/BDk2C,CAAqBzhD,EAAU++C,EAAMJ,gBACrC,EACA8B,EAAMY,GAAcK,GACxB,MAAQ,IAAO1hD,EAASa,KAAI,SAAUlF,GAAK,OAAO8kD,EAAI9kD,EAAGojD,MAAWj+C,KAAK,KAAQ,KAAOygD,EAAuB,IAAMA,EAAuB,KA+BhJ,SAASC,GAAoBxgD,GAC3B,YAAkB8G,IAAX9G,EAAGo3C,KAAgC,aAAXp3C,EAAGuQ,KAAiC,SAAXvQ,EAAGuQ,IAG7D,SAASmwC,GAAS9uC,EAAMmsC,GACtB,OAAkB,IAAdnsC,EAAKwD,KACA4oC,GAAWpsC,EAAMmsC,GACD,IAAdnsC,EAAKwD,MAAcxD,EAAKR,UAarC,SAAqBm/B,GACnB,MAAQ,MAASxoC,KAAKC,UAAUuoC,EAAQ9/B,MAAS,IAbxCkwC,CAAW/uC,GAMtB,SAAkBnB,GAChB,MAAQ,OAAuB,IAAdA,EAAK2E,KAClB3E,EAAK8a,WACLq1B,GAAyB74C,KAAKC,UAAUyI,EAAKA,QAAU,IAPlDowC,CAAQjvC,GAiDnB,SAAS8sC,GAAUppC,GAGjB,IAFA,IAAIwrC,EAAc,GACdC,EAAe,GACVzmD,EAAI,EAAGA,EAAIgb,EAAM3X,OAAQrD,IAAK,CACrC,IAAI2c,EAAO3B,EAAMhb,GACbiB,EAAQqlD,GAAyB3pC,EAAK1b,OACtC0b,EAAKyjB,QACPqmB,GAAiB9pC,EAAS,KAAI,IAAM1b,EAAQ,IAE5CulD,GAAe,IAAQ7pC,EAAS,KAAI,KAAQ1b,EAAQ,IAIxD,OADAulD,EAAc,IAAOA,EAAY/6C,MAAM,GAAI,GAAM,IAC7Cg7C,EACM,MAAQD,EAAc,KAAQC,EAAah7C,MAAM,GAAI,GAAM,KAE5D+6C,EAKX,SAASF,GAA0BnwC,GACjC,OAAOA,EACJpL,QAAQ,UAAW,WACnBA,QAAQ,UAAW,WASE,IAAI8H,OAAO,MAAQ,iMAI3ClM,MAAM,KAAKnB,KAAK,WAAa,OAGR,IAAIqN,OAAO,MAAQ,qBAExClM,MAAM,KAAKnB,KAAK,yBAA2B,qBA0K7C,SAASkhD,GAAgBhH,EAAMiH,GAC7B,IACE,OAAO,IAAIx3C,SAASuwC,GACpB,MAAOjiC,GAEP,OADAkpC,EAAO1hD,KAAK,CAAEwY,IAAKA,EAAKiiC,KAAMA,IACvBxvC,GAIX,SAAS02C,GAA2BC,GAClC,IAAIl4C,EAAQjO,OAAOY,OAAO,MAE1B,OAAO,SACLg3C,EACA/uC,EACAgR,IAEAhR,EAAUsG,EAAO,GAAItG,IACCyL,YACfzL,EAAQyL,KAqBf,IAAIzT,EAAMgI,EAAQkrC,WACdxnC,OAAO1D,EAAQkrC,YAAc6D,EAC7BA,EACJ,GAAI3pC,EAAMpN,GACR,OAAOoN,EAAMpN,GAIf,IAAIulD,EAAWD,EAAQvO,EAAU/uC,GA+BjC,IAAI0G,EAAM,GACN82C,EAAc,GAyBlB,OAxBA92C,EAAIlH,OAAS29C,GAAeI,EAAS/9C,OAAQg+C,GAC7C92C,EAAIjH,gBAAkB89C,EAAS99C,gBAAgBzD,KAAI,SAAUm6C,GAC3D,OAAOgH,GAAehH,EAAMqH,MAsBtBp4C,EAAMpN,GAAO0O,GAiFzB,IA3EgC+2C,GAoG5BC,GAPA3J,IA7F4B0J,GA2EW,SACzC1O,EACA/uC,GAEA,IAAIi6C,EAAMnL,GAAMC,EAAS1Y,OAAQr2B,IACR,IAArBA,EAAQ+2C,UACVA,GAASkD,EAAKj6C,GAEhB,IAAIm2C,EAAO6D,GAASC,EAAKj6C,GACzB,MAAO,CACLi6C,IAAKA,EACLz6C,OAAQ22C,EAAK32C,OACbC,gBAAiB02C,EAAK12C,kBAtFjB,SAAyBw2C,GAC9B,SAASqH,EACPvO,EACA/uC,GAEA,IAAI29C,EAAexmD,OAAOY,OAAOk+C,GAC7BmH,EAAS,GACTQ,EAAO,GAMX,GAAI59C,EA+BF,IAAK,IAAIhI,KAZLgI,EAAQrJ,UACVgnD,EAAahnD,SACVs/C,EAAYt/C,SAAW,IAAImE,OAAOkF,EAAQrJ,UAG3CqJ,EAAQoS,aACVurC,EAAavrC,WAAa9L,EACxBnP,OAAOY,OAAOk+C,EAAY7jC,YAAc,MACxCpS,EAAQoS,aAIIpS,EACF,YAARhI,GAA6B,eAARA,IACvB2lD,EAAa3lD,GAAOgI,EAAQhI,IAKlC2lD,EAAalyC,KA1CF,SAAUgrB,EAAKC,EAAOmnB,IAC9BA,EAAMD,EAAOR,GAAQ1hD,KAAK+6B,IA2C7B,IAAI8mB,EAAWE,GAAY1O,EAAS1Y,OAAQsnB,GAM5C,OAFAJ,EAASH,OAASA,EAClBG,EAASK,KAAOA,EACTL,EAGT,MAAO,CACLD,QAASA,EACTQ,mBAAoBT,GAA0BC,MA4BzBrH,IAEvB6H,IADU/J,GAAMuJ,QACKvJ,GAAM+J,oBAM/B,SAASC,GAAiBC,GAGxB,OAFAN,GAAMA,IAAO9iD,SAAS4jB,cAAc,QAChCkc,UAAYsjB,EAAO,iBAAqB,gBACrCN,GAAIhjB,UAAU31B,QAAQ,SAAW,EAI1C,IAAIqoC,KAAuB3jC,GAAYs0C,IAAgB,GAEnD/L,KAA8BvoC,GAAYs0C,IAAgB,GAI1DE,GAAe/4C,GAAO,SAAU0G,GAClC,IAAIzP,EAAK+0B,GAAMtlB,GACf,OAAOzP,GAAMA,EAAGu+B,aAGdwjB,GAAQ5zB,GAAIjyB,UAAUonB,OAC1B6K,GAAIjyB,UAAUonB,OAAS,SACrBtjB,EACA4iB,GAKA,IAHA5iB,EAAKA,GAAM+0B,GAAM/0B,MAGNvB,SAAS2vC,MAAQpuC,IAAOvB,SAASC,gBAI1C,OAAOqB,KAGT,IAAI8D,EAAU9D,KAAK2E,SAEnB,IAAKb,EAAQR,OAAQ,CACnB,IAAIuvC,EAAW/uC,EAAQ+uC,SACvB,GAAIA,EACF,GAAwB,kBAAbA,EACkB,MAAvBA,EAAS9sC,OAAO,KAClB8sC,EAAWkP,GAAalP,QASrB,KAAIA,EAASp1C,SAMlB,OAAOuC,KALP6yC,EAAWA,EAASrU,eAObv+B,IACT4yC,EAkCN,SAAuB5yC,GACrB,GAAIA,EAAGgiD,UACL,OAAOhiD,EAAGgiD,UAEV,IAAIC,EAAYxjD,SAAS4jB,cAAc,OAEvC,OADA4/B,EAAUtsB,YAAY31B,EAAGuuC,WAAU,IAC5B0T,EAAU1jB,UAxCJ2jB,CAAaliD,IAE1B,GAAI4yC,EAAU,CAER,EAIJ,IAAIjhB,EAAMgwB,GAAmB/O,EAAU,CACrCsD,mBAAmB,EACnBjF,qBAAsBA,GACtB4E,4BAA6BA,GAC7B9G,WAAYlrC,EAAQkrC,WACpBkH,SAAUpyC,EAAQoyC,UACjBl2C,MACCsD,EAASsuB,EAAItuB,OACbC,EAAkBquB,EAAIruB,gBAC1BO,EAAQR,OAASA,EACjBQ,EAAQP,gBAAkBA,GAS9B,OAAOy+C,GAAMtnD,KAAKsF,KAAMC,EAAI4iB,IAiB9BuL,GAAIgzB,QAAUQ,GAEC,c,sDCxtXf,IAAIQ,EAGJA,EAAI,WACH,OAAOpiD,KADJ,GAIJ,IAECoiD,EAAIA,GAAK,IAAI14C,SAAS,cAAb,GACR,MAAOrJ,GAEc,kBAAXQ,SAAqBuhD,EAAIvhD,QAOrCvG,EAAOD,QAAU+nD,G,iBClBjB,IAOIC,EACAC,EARAC,EAAUjoD,EAAOD,QAAU,GAU/B,SAASmoD,IACL,MAAM,IAAIt/C,MAAM,mCAEpB,SAASu/C,IACL,MAAM,IAAIv/C,MAAM,qCAsBpB,SAASw/C,EAAWC,GAChB,GAAIN,IAAqBlgD,WAErB,OAAOA,WAAWwgD,EAAK,GAG3B,IAAKN,IAAqBG,IAAqBH,IAAqBlgD,WAEhE,OADAkgD,EAAmBlgD,WACZA,WAAWwgD,EAAK,GAE3B,IAEI,OAAON,EAAiBM,EAAK,GAC/B,MAAMtiD,GACJ,IAEI,OAAOgiD,EAAiB3nD,KAAK,KAAMioD,EAAK,GAC1C,MAAMtiD,GAEJ,OAAOgiD,EAAiB3nD,KAAKsF,KAAM2iD,EAAK,MAvCnD,WACG,IAEQN,EADsB,oBAAflgD,WACYA,WAEAqgD,EAEzB,MAAOniD,GACLgiD,EAAmBG,EAEvB,IAEQF,EADwB,oBAAjBl8B,aACcA,aAEAq8B,EAE3B,MAAOpiD,GACLiiD,EAAqBG,GAjB7B,GAwEA,IAEIG,EAFAr5B,EAAQ,GACRs5B,GAAW,EAEXC,GAAc,EAElB,SAASC,IACAF,GAAaD,IAGlBC,GAAW,EACPD,EAAahlD,OACb2rB,EAAQq5B,EAAahkD,OAAO2qB,GAE5Bu5B,GAAc,EAEdv5B,EAAM3rB,QACNolD,KAIR,SAASA,IACL,IAAIH,EAAJ,CAGA,IAAIn8B,EAAUg8B,EAAWK,GACzBF,GAAW,EAGX,IADA,IAAItwC,EAAMgX,EAAM3rB,OACV2U,GAAK,CAGP,IAFAqwC,EAAer5B,EACfA,EAAQ,KACCu5B,EAAavwC,GACdqwC,GACAA,EAAaE,GAAY34B,MAGjC24B,GAAc,EACdvwC,EAAMgX,EAAM3rB,OAEhBglD,EAAe,KACfC,GAAW,EAnEf,SAAyBI,GACrB,GAAIX,IAAuBl8B,aAEvB,OAAOA,aAAa68B,GAGxB,IAAKX,IAAuBG,IAAwBH,IAAuBl8B,aAEvE,OADAk8B,EAAqBl8B,aACdA,aAAa68B,GAExB,IAEWX,EAAmBW,GAC5B,MAAO5iD,GACL,IAEI,OAAOiiD,EAAmB5nD,KAAK,KAAMuoD,GACvC,MAAO5iD,GAGL,OAAOiiD,EAAmB5nD,KAAKsF,KAAMijD,KAgD7CC,CAAgBx8B,IAiBpB,SAASy8B,EAAKR,EAAKS,GACfpjD,KAAK2iD,IAAMA,EACX3iD,KAAKojD,MAAQA,EAYjB,SAAS34C,KA5BT83C,EAAQ/oC,SAAW,SAAUmpC,GACzB,IAAIrwC,EAAO,IAAIrV,MAAM6M,UAAUlM,OAAS,GACxC,GAAIkM,UAAUlM,OAAS,EACnB,IAAK,IAAIrD,EAAI,EAAGA,EAAIuP,UAAUlM,OAAQrD,IAClC+X,EAAK/X,EAAI,GAAKuP,UAAUvP,GAGhCgvB,EAAM/pB,KAAK,IAAI2jD,EAAKR,EAAKrwC,IACJ,IAAjBiX,EAAM3rB,QAAiBilD,GACvBH,EAAWM,IASnBG,EAAKhnD,UAAUguB,IAAM,WACjBnqB,KAAK2iD,IAAI54C,MAAM,KAAM/J,KAAKojD,QAE9Bb,EAAQc,MAAQ,UAChBd,EAAQe,SAAU,EAClBf,EAAQ3zC,IAAM,GACd2zC,EAAQgB,KAAO,GACfhB,EAAQlvB,QAAU,GAClBkvB,EAAQiB,SAAW,GAInBjB,EAAQ5nC,GAAKlQ,EACb83C,EAAQkB,YAAch5C,EACtB83C,EAAQ/2C,KAAOf,EACf83C,EAAQ7/C,IAAM+H,EACd83C,EAAQmB,eAAiBj5C,EACzB83C,EAAQoB,mBAAqBl5C,EAC7B83C,EAAQ93B,KAAOhgB,EACf83C,EAAQqB,gBAAkBn5C,EAC1B83C,EAAQsB,oBAAsBp5C,EAE9B83C,EAAQrgC,UAAY,SAAUpnB,GAAQ,MAAO,IAE7CynD,EAAQhY,QAAU,SAAUzvC,GACxB,MAAM,IAAIoI,MAAM,qCAGpBq/C,EAAQuB,IAAM,WAAc,MAAO,KACnCvB,EAAQwB,MAAQ,SAAUhtB,GACtB,MAAM,IAAI7zB,MAAM,mCAEpBq/C,EAAQyB,MAAQ,WAAa,OAAO,I,oBCjL6B1pD,EAAOD,QAGhE,SAAW6F,EAAMC,EAAc8jD,EAAaC,EAAgB7hD,GAAiB,aAEnF,SAASjC,EAAuBC,GAAK,OAAOA,GAAkB,kBAANA,GAAkB,YAAaA,EAAIA,EAAI,CAAE,QAAWA,GAE5G,IAAIC,EAA6BF,EAAsBF,GACnDK,EAAqCH,EAAsBD,GAC3DgkD,EAAoC/jD,EAAsB6jD,GAC1DG,EAAuChkD,EAAsB8jD,GAC7DG,EAAsCjkD,EAAsBiC,GAShE,MAAMiiD,EAAS/mD,GACD,OAARA,QAAwBwJ,IAARxJ,EACX,GAAGA,IAGL,GAAG6H,SAAS1K,KAAK6C,GAAK8Q,MAAM,eAAe,GAAG7I,cAGjD++C,EAAc9nD,IAClB,IAAIgC,EAAWhC,EAAQ6B,aAAa,kBAEpC,IAAKG,GAAyB,MAAbA,EAAkB,CACjC,IAAI+lD,EAAW/nD,EAAQ6B,aAAa,QAKpC,IAAKkmD,IAAaA,EAASC,SAAS,OAASD,EAAS3+C,WAAW,KAC/D,OAAO,KAIL2+C,EAASC,SAAS,OAASD,EAAS3+C,WAAW,OACjD2+C,EAAW,IAAIA,EAAStjD,MAAM,KAAK,MAGrCzC,EAAW+lD,GAAyB,MAAbA,EAAmBA,EAASrqB,OAAS,KAG9D,OAAO17B,GAGHimD,EAAyBjoD,IAC7B,MAAMgC,EAAW8lD,EAAY9nD,GAE7B,OAAIgC,GACKC,SAASM,cAAcP,GAAYA,EAGrC,MAGHkmD,EAAyBloD,IAC7B,MAAMgC,EAAW8lD,EAAY9nD,GAC7B,OAAOgC,EAAWC,SAASM,cAAcP,GAAY,MAGjDnB,EAAYC,MACXA,GAAsB,kBAARA,KAIO,qBAAfA,EAAIC,SACbD,EAAMA,EAAI,IAGmB,qBAAjBA,EAAIE,UAGd6D,EAAa/D,GACbD,EAAUC,GAELA,EAAIC,OAASD,EAAI,GAAKA,EAGZ,kBAARA,GAAoBA,EAAIK,OAAS,EACnCc,SAASM,cAAczB,GAGzB,KAGHqnD,EAAkB,CAAC9F,EAAe97C,EAAQ6hD,KAC9C5pD,OAAOkC,KAAK0nD,GAAahiD,SAAQ3G,IAC/B,MAAM4b,EAAgB+sC,EAAY3oD,GAC5BV,EAAQwH,EAAO9G,GACf4oD,EAAYtpD,GAAS8B,EAAU9B,GAAS,UAAY8oD,EAAO9oD,GAEjE,IAAK,IAAI4R,OAAO0K,GAAe9J,KAAK82C,GAClC,MAAM,IAAIC,UAAU,GAAGjG,EAAcx1C,0BAA0BpN,qBAA4B4oD,yBAAiChtC,WAc5HktC,EAASvoD,IAEbA,EAAQ6xC,cAGJ2W,EAAY,KAChB,MAAM,OACJC,GACErkD,OAEJ,OAAIqkD,IAAWxmD,SAAS2vC,KAAKhwC,aAAa,qBACjC6mD,EAGF,MAGHC,EAA4B,GAE5BC,EAAqB5jD,IACG,YAAxB9C,SAAS2mD,YAENF,EAA0BvnD,QAC7Bc,SAASwD,iBAAiB,oBAAoB,KAC5CijD,EAA0BtiD,SAAQrB,GAAYA,SAIlD2jD,EAA0B3lD,KAAKgC,IAE/BA,KAIE8jD,EAAqB3yB,IACzByyB,GAAmB,KACjB,MAAMG,EAAIN,IAGV,GAAIM,EAAG,CACL,MAAMzqD,EAAO63B,EAAOxvB,KACdqiD,EAAqBD,EAAEt8C,GAAGnO,GAChCyqD,EAAEt8C,GAAGnO,GAAQ63B,EAAO8yB,gBACpBF,EAAEt8C,GAAGnO,GAAM4qD,YAAc/yB,EAEzB4yB,EAAEt8C,GAAGnO,GAAM6qD,WAAa,KACtBJ,EAAEt8C,GAAGnO,GAAQ0qD,EACN7yB,EAAO8yB,sBAkBhBtiD,EAAO,WACPX,EAAW,cACXG,EAAY,IAAIH,IAEhBojD,EAAU,CACdC,QAAQ,EACRxhD,OAAQ,MAEJyhD,EAAc,CAClBD,OAAQ,UACRxhD,OAAQ,kBAEJ0hD,EAAa,OAAOpjD,IACpBqjD,EAAc,QAAQrjD,IACtBsjD,EAAa,OAAOtjD,IACpBujD,EAAe,SAASvjD,IACxBwjD,EAAuB,QAAQxjD,aAC/ByjD,EAAkB,OAClBC,EAAsB,WACtBC,EAAwB,aACxBC,EAAuB,YACvBC,EAAwB,sBACxBC,EAAQ,QACRC,EAAS,SACTC,EAAmB,uCACnBC,EAAuB,8BAO7B,MAAMC,UAAiBxC,EAAgC,QACrD,YAAY5nD,EAASuG,GACnB0qB,MAAMjxB,GACNuD,KAAK8mD,kBAAmB,EACxB9mD,KAAK+mD,QAAU/mD,KAAKgnD,WAAWhkD,GAC/BhD,KAAKinD,cAAgB,GACrB,MAAMC,EAAa9C,EAAiC,QAAE5lD,KAAKooD,GAE3D,IAAK,IAAIrsD,EAAI,EAAGgY,EAAM20C,EAAWtpD,OAAQrD,EAAIgY,EAAKhY,IAAK,CACrD,MAAM4sD,EAAOD,EAAW3sD,GAClBkE,EAAWimD,EAAuByC,GAClCC,EAAgBhD,EAAiC,QAAE5lD,KAAKC,GAAUS,QAAOmoD,GAAaA,IAAcrnD,KAAKsC,WAE9F,OAAb7D,GAAqB2oD,EAAcxpD,SACrCoC,KAAKsnD,UAAY7oD,EAEjBuB,KAAKinD,cAAcznD,KAAK2nD,IAI5BnnD,KAAKunD,sBAEAvnD,KAAK+mD,QAAQ1iD,QAChBrE,KAAKwnD,0BAA0BxnD,KAAKinD,cAAejnD,KAAKynD,YAGtDznD,KAAK+mD,QAAQlB,QACf7lD,KAAK6lD,SAKT,qBACE,OAAOD,EAGT,kBACE,OAAOziD,EAIT,SACMnD,KAAKynD,WACPznD,KAAK0nD,OAEL1nD,KAAKylC,OAIT,OACE,GAAIzlC,KAAK8mD,kBAAoB9mD,KAAKynD,WAChC,OAGF,IACIE,EADAC,EAAU,GAGd,GAAI5nD,KAAK+mD,QAAQ1iD,OAAQ,CACvB,MAAMpF,EAAWmlD,EAAiC,QAAE5lD,KAAK,IAAI6nD,MAAwBA,IAAuBrmD,KAAK+mD,QAAQ1iD,QACzHujD,EAAUxD,EAAiC,QAAE5lD,KAAKmoD,EAAkB3mD,KAAK+mD,QAAQ1iD,QAAQnF,QAAOioD,IAASloD,EAASwlD,SAAS0C,KAG7H,MAAMjF,EAAYkC,EAAiC,QAAErlD,QAAQiB,KAAKsnD,WAElE,GAAIM,EAAQhqD,OAAQ,CAClB,MAAMiqD,EAAiBD,EAAQppD,MAAK2oD,GAAQjF,IAAciF,IAG1D,GAFAQ,EAAcE,EAAiBhB,EAAS5jD,YAAY4kD,GAAkB,KAElEF,GAAeA,EAAYb,iBAC7B,OAMJ,GAFmBvmD,EAA+B,QAAE8pC,QAAQrqC,KAAKsC,SAAUyjD,GAE5D+B,iBACb,OAGFF,EAAQ/kD,SAAQklD,IACV7F,IAAc6F,GAChBlB,EAASmB,oBAAoBD,EAAY,CACvClC,QAAQ,IACP6B,OAGAC,GACHrnD,EAAuB,QAAE1D,IAAImrD,EAAYvlD,EAAU,SAIvD,MAAMylD,EAAYjoD,KAAKkoD,gBAEvBloD,KAAKsC,SAASpE,UAAUuE,OAAO4jD,GAE/BrmD,KAAKsC,SAASpE,UAAUsG,IAAI8hD,GAE5BtmD,KAAKsC,SAAS2lB,MAAMggC,GAAa,EAEjCjoD,KAAKwnD,0BAA0BxnD,KAAKinD,eAAe,GAEnDjnD,KAAK8mD,kBAAmB,EAExB,MAAMqB,EAAW,KACfnoD,KAAK8mD,kBAAmB,EAExB9mD,KAAKsC,SAASpE,UAAUuE,OAAO6jD,GAE/BtmD,KAAKsC,SAASpE,UAAUsG,IAAI6hD,EAAqBD,GAEjDpmD,KAAKsC,SAAS2lB,MAAMggC,GAAa,GACjC1nD,EAA+B,QAAE8pC,QAAQrqC,KAAKsC,SAAU0jD,IAIpDoC,EAAa,SADUH,EAAU,GAAG3+C,cAAgB2+C,EAAUjiD,MAAM,KAG1EhG,KAAKqoD,eAAeF,EAAUnoD,KAAKsC,UAAU,GAE7CtC,KAAKsC,SAAS2lB,MAAMggC,GAAa,GAAGjoD,KAAKsC,SAAS8lD,OAGpD,OACE,GAAIpoD,KAAK8mD,mBAAqB9mD,KAAKynD,WACjC,OAKF,GAFmBlnD,EAA+B,QAAE8pC,QAAQrqC,KAAKsC,SAAU2jD,GAE5D6B,iBACb,OAGF,MAAMG,EAAYjoD,KAAKkoD,gBAEvBloD,KAAKsC,SAAS2lB,MAAMggC,GAAa,GAAGjoD,KAAKsC,SAAS6D,wBAAwB8hD,OAC1EjD,EAAOhlD,KAAKsC,UAEZtC,KAAKsC,SAASpE,UAAUsG,IAAI8hD,GAE5BtmD,KAAKsC,SAASpE,UAAUuE,OAAO4jD,EAAqBD,GAEpD,MAAMkC,EAAqBtoD,KAAKinD,cAAcrpD,OAE9C,IAAK,IAAIrD,EAAI,EAAGA,EAAI+tD,EAAoB/tD,IAAK,CAC3C,MAAM8vC,EAAUrqC,KAAKinD,cAAc1sD,GAC7B4sD,EAAOxC,EAAuBta,GAEhC8c,IAASnnD,KAAKynD,SAASN,IACzBnnD,KAAKwnD,0BAA0B,CAACnd,IAAU,GAI9CrqC,KAAK8mD,kBAAmB,EAExB,MAAMqB,EAAW,KACfnoD,KAAK8mD,kBAAmB,EAExB9mD,KAAKsC,SAASpE,UAAUuE,OAAO6jD,GAE/BtmD,KAAKsC,SAASpE,UAAUsG,IAAI6hD,GAE5B9lD,EAA+B,QAAE8pC,QAAQrqC,KAAKsC,SAAU4jD,IAG1DlmD,KAAKsC,SAAS2lB,MAAMggC,GAAa,GAEjCjoD,KAAKqoD,eAAeF,EAAUnoD,KAAKsC,UAAU,GAG/C,SAAS7F,EAAUuD,KAAKsC,UACtB,OAAO7F,EAAQyB,UAAUC,SAASioD,GAIpC,WAAWpjD,GAST,OARAA,EAAS,IAAK4iD,KACTzB,EAA8B,QAAEoE,kBAAkBvoD,KAAKsC,aACvDU,IAEE6iD,OAASvuC,QAAQtU,EAAO6iD,QAE/B7iD,EAAOqB,OAAS/C,EAAW0B,EAAOqB,QAClCugD,EAAgBzhD,EAAMH,EAAQ8iD,GACvB9iD,EAGT,gBACE,OAAOhD,KAAKsC,SAASpE,UAAUC,SAASqoD,GAAyBC,EAAQC,EAG3E,sBACE,IAAK1mD,KAAK+mD,QAAQ1iD,OAChB,OAGF,MAAMpF,EAAWmlD,EAAiC,QAAE5lD,KAAK,IAAI6nD,MAAwBA,IAAuBrmD,KAAK+mD,QAAQ1iD,QACzH+/C,EAAiC,QAAE5lD,KAAKooD,EAAsB5mD,KAAK+mD,QAAQ1iD,QAAQnF,QAAOioD,IAASloD,EAASwlD,SAAS0C,KAAOtkD,SAAQpG,IAClI,MAAMw4B,EAAW0vB,EAAuBloD,GAEpCw4B,GACFj1B,KAAKwnD,0BAA0B,CAAC/qD,GAAUuD,KAAKynD,SAASxyB,OAK9D,0BAA0BuzB,EAAcC,GACjCD,EAAa5qD,QAIlB4qD,EAAa3lD,SAAQskD,IACfsB,EACFtB,EAAKjpD,UAAUuE,OAAO8jD,GAEtBY,EAAKjpD,UAAUsG,IAAI+hD,GAGrBY,EAAK1hD,aAAa,gBAAiBgjD,MAKvC,uBAAuBzlD,GACrB,OAAOhD,KAAK0oD,MAAK,WACf,MAAM3B,EAAU,GAEM,kBAAX/jD,GAAuB,YAAYgL,KAAKhL,KACjD+jD,EAAQlB,QAAS,GAGnB,MAAMp1C,EAAOo2C,EAASmB,oBAAoBhoD,KAAM+mD,GAEhD,GAAsB,kBAAX/jD,EAAqB,CAC9B,GAA4B,qBAAjByN,EAAKzN,GACd,MAAM,IAAI+hD,UAAU,oBAAoB/hD,MAG1CyN,EAAKzN,UAoCb,OAvBAzC,EAA+B,QAAEoa,GAAGjc,SAAUynD,EAAsBS,GAAsB,SAAU5rC,IAErE,MAAzBA,EAAMhZ,OAAOmzB,SAAmBna,EAAM2tC,gBAAmD,MAAjC3tC,EAAM2tC,eAAexzB,UAC/Ena,EAAM4tC,iBAGR,MAAMnqD,EAAWimD,EAAuB1kD,MACfokD,EAAiC,QAAE5lD,KAAKC,GAChDoE,SAAQpG,IACvBoqD,EAASmB,oBAAoBvrD,EAAS,CACpCopD,QAAQ,IACPA,eAUPP,EAAmBuB,GAEZA,EApeyExpD,CAAQ,EAAQ,KAAkB,EAAQ,IAA2B,EAAQ,KAAyB,EAAQ,KAA6B,EAAQ,O,oBCNrO,6CAC6B,qBAAT6+C,MAAwBA,MAChCr7C,OACRkJ,EAAQL,SAASvN,UAAU4N,MAiB/B,SAAS8+C,EAAQn5C,EAAIo5C,GACnB9oD,KAAK+oD,IAAMr5C,EACX1P,KAAKgpD,SAAWF,EAflBzuD,EAAQ8H,WAAa,WACnB,OAAO,IAAI0mD,EAAQ9+C,EAAMrP,KAAKyH,WAAY8mD,EAAOn/C,WAAYsc,eAE/D/rB,EAAQ6uD,YAAc,WACpB,OAAO,IAAIL,EAAQ9+C,EAAMrP,KAAKwuD,YAAaD,EAAOn/C,WAAYq/C,gBAEhE9uD,EAAQ+rB,aACR/rB,EAAQ8uD,cAAgB,SAASziC,GAC3BA,GACFA,EAAQwoB,SAQZ2Z,EAAQ1sD,UAAUitD,MAAQP,EAAQ1sD,UAAUy1B,IAAM,aAClDi3B,EAAQ1sD,UAAU+yC,MAAQ,WACxBlvC,KAAKgpD,SAAStuD,KAAKuuD,EAAOjpD,KAAK+oD,MAIjC1uD,EAAQgvD,OAAS,SAAS1gD,EAAM2gD,GAC9BljC,aAAazd,EAAK4gD,gBAClB5gD,EAAK6gD,aAAeF,GAGtBjvD,EAAQovD,SAAW,SAAS9gD,GAC1Byd,aAAazd,EAAK4gD,gBAClB5gD,EAAK6gD,cAAgB,GAGvBnvD,EAAQqvD,aAAervD,EAAQ6wB,OAAS,SAASviB,GAC/Cyd,aAAazd,EAAK4gD,gBAElB,IAAID,EAAQ3gD,EAAK6gD,aACbF,GAAS,IACX3gD,EAAK4gD,eAAiBpnD,YAAW,WAC3BwG,EAAKghD,YACPhhD,EAAKghD,eACNL,KAKP,EAAQ,IAIRjvD,EAAQ6e,aAAgC,qBAATgjC,MAAwBA,KAAKhjC,cAClB,qBAAXvK,GAA0BA,EAAOuK,cACxClZ,MAAQA,KAAKkZ,aACrC7e,EAAQuvD,eAAkC,qBAAT1N,MAAwBA,KAAK0N,gBAClB,qBAAXj7C,GAA0BA,EAAOi7C,gBACxC5pD,MAAQA,KAAK4pD,iB,sCC9DvC,6BACI,aAEA,IAAIj7C,EAAOuK,aAAX,CAIA,IAII2wC,EA6HIja,EAZAka,EArBAC,EACAC,EAjGJC,EAAa,EACbC,EAAgB,GAChBC,GAAwB,EACxBC,EAAMz7C,EAAOjQ,SAoJb2rD,EAAWpvD,OAAOqvD,gBAAkBrvD,OAAOqvD,eAAe37C,GAC9D07C,EAAWA,GAAYA,EAASloD,WAAakoD,EAAW17C,EAGf,qBAArC,GAAGvJ,SAAS1K,KAAKiU,EAAO4zC,SApFxBsH,EAAoB,SAASU,GACzBhI,EAAQ/oC,UAAS,WAAcgxC,EAAaD,QAIpD,WAGI,GAAI57C,EAAO87C,cAAgB97C,EAAO+7C,cAAe,CAC7C,IAAIC,GAA4B,EAC5BC,EAAej8C,EAAOk8C,UAM1B,OALAl8C,EAAOk8C,UAAY,WACfF,GAA4B,GAEhCh8C,EAAO87C,YAAY,GAAI,KACvB97C,EAAOk8C,UAAYD,EACZD,GAwEJG,GAIAn8C,EAAOo8C,iBA9CVjB,EAAU,IAAIiB,gBACVC,MAAMH,UAAY,SAAS7vC,GAE/BwvC,EADaxvC,EAAMvK,OAIvBo5C,EAAoB,SAASU,GACzBT,EAAQmB,MAAMR,YAAYF,KA2CvBH,GAAO,uBAAwBA,EAAI9nC,cAAc,WAtCpDstB,EAAOwa,EAAIzrD,gBACfkrD,EAAoB,SAASU,GAGzB,IAAIW,EAASd,EAAI9nC,cAAc,UAC/B4oC,EAAOC,mBAAqB,WACxBX,EAAaD,GACbW,EAAOC,mBAAqB,KAC5Bvb,EAAKja,YAAYu1B,GACjBA,EAAS,MAEbtb,EAAKha,YAAYs1B,KAKrBrB,EAAoB,SAASU,GACzBpoD,WAAWqoD,EAAc,EAAGD,KAlD5BR,EAAgB,gBAAkBtiD,KAAK2jD,SAAW,IAClDpB,EAAkB,SAAShvC,GACvBA,EAAMqB,SAAW1N,GACK,kBAAfqM,EAAMvK,MACyB,IAAtCuK,EAAMvK,KAAK5H,QAAQkhD,IACnBS,GAAcxvC,EAAMvK,KAAKzK,MAAM+jD,EAAcnsD,UAIjD+Q,EAAOzM,iBACPyM,EAAOzM,iBAAiB,UAAW8nD,GAAiB,GAEpDr7C,EAAO08C,YAAY,YAAarB,GAGpCH,EAAoB,SAASU,GACzB57C,EAAO87C,YAAYV,EAAgBQ,EAAQ,OAgEnDF,EAASnxC,aA1KT,SAAsB1X,GAEI,oBAAbA,IACTA,EAAW,IAAIkI,SAAS,GAAKlI,IAI/B,IADA,IAAI8Q,EAAO,IAAIrV,MAAM6M,UAAUlM,OAAS,GAC/BrD,EAAI,EAAGA,EAAI+X,EAAK1U,OAAQrD,IAC7B+X,EAAK/X,GAAKuP,UAAUvP,EAAI,GAG5B,IAAI+wD,EAAO,CAAE9pD,SAAUA,EAAU8Q,KAAMA,GAGvC,OAFA43C,EAAcD,GAAcqB,EAC5BzB,EAAkBI,GACXA,KA6JTI,EAAST,eAAiBA,EA1J1B,SAASA,EAAeW,UACbL,EAAcK,GAyBzB,SAASC,EAAaD,GAGlB,GAAIJ,EAGAhoD,WAAWqoD,EAAc,EAAGD,OACzB,CACH,IAAIe,EAAOpB,EAAcK,GACzB,GAAIe,EAAM,CACNnB,GAAwB,EACxB,KAjCZ,SAAamB,GACT,IAAI9pD,EAAW8pD,EAAK9pD,SAChB8Q,EAAOg5C,EAAKh5C,KAChB,OAAQA,EAAK1U,QACb,KAAK,EACD4D,IACA,MACJ,KAAK,EACDA,EAAS8Q,EAAK,IACd,MACJ,KAAK,EACD9Q,EAAS8Q,EAAK,GAAIA,EAAK,IACvB,MACJ,KAAK,EACD9Q,EAAS8Q,EAAK,GAAIA,EAAK,GAAIA,EAAK,IAChC,MACJ,QACI9Q,EAASuI,WAnDrB,EAmDsCuI,IAiBlB6X,CAAImhC,GACN,QACE1B,EAAeW,GACfJ,GAAwB,MAvE5C,CAyLkB,qBAATjO,KAAyC,qBAAXvtC,EAAyB3O,KAAO2O,EAASutC,Q,4ECzL5EqP,G,OAAQ,CAAC,eAAe,UAAU,eAAe,wBAA6C,cAAc,gBAAgB,cAAc,WAAW,UAAU,eAAe,UAAU,OAAO,eAAe,UAAU,QAAQ,OAAO,OAAO,aAAa,aAAa,WAAW,WAAW,QAAQ,iBAAsH,SAASC,EAAUC,GAA2N,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOC,EAAQH,IAAY,IAAME,GAAY,SAASE,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOL,EAAQK,EAAU,IAAMF,GAAqH,OAAY,IAAwlB,GAAiJ,UAAvtB55B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,MAAQp5B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,MAASp5B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,OAASp5B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,OAASp5B,UAA3tB+5B,EAA8uB,IAApuBC,EAA0uB,IAApsBP,EAAQO,EAAU,IAAMD,KAAgsB/5B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,OAASp5B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,MAAQp5B,SAASo5B,EAAU,GAAQ,IAAM,GAAQ,OAASp5B,SAAS05B,EAAU,EAAM,IAAM,EAAM,OAAS15B,SAAS05B,EAAU,EAAM,IAAM,EAAM,MAAQ15B,SAAxiBy5B,GAA0kB,MAAtjB,KAA6jB,MAAQz5B,SAAl5By5B,GAA66B,MAAz5B,KAAg6B,MAAuC,MAAWP,EAAgB,KAAEA,EAAiB,SAAM,MAAMe,GAAWf,EAAgB,KAAEA,EAAiB,SAAtoC,IAApFa,EAAUC,EAA5D,CAAqxCf,GAAkB,IAAIiB,EAAQ,CAACC,EAAU,IAAM,IAAM,IAAM,KAAO,YAAYA,EAAU,IAAM,IAAM,IAAM,KAAOC,GAAW,KAAM,KAAM,KAAM,KAAMA,GAAW,KAAM,KAAM,KAAM,KAAMA,GAAW,KAAM,KAAM,KAAM,KAAMA,GAAW,KAAM,KAAM,KAAM,KAAM,OAAO,cAAc,aAAa,eAAe,gBAAgB,iBAA+N,SAASC,EAAUC,GAAqJ,IAA6BC,EAAzBC,GAAyBD,GAAU,EAAY,SAASE,EAAUC,GAAW,IAAIC,EAAUJ,EAAU,WAAW,SAASK,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOvB,EAAQqB,EAAU,IAAME,GAAY,GAAGN,EAAU,CAAC,IAAIO,EAAUP,EAAUE,EAAU,EAAM,IAAM,EAAM,MAAQH,EAAUjjD,WAAW,OAAOkjD,EAAU,KAAKO,IAAa,aAAa,OAAOV,GAAU,EAAII,IAAgB,SAASO,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAxpB7B,EAAmtB6B,IAAY,KAA7sB,IAAuqBH,GAA+P,SAASI,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,IAAIC,EAAUpB,EAAU9sD,MAAK,WAAW,IAAImuD,EAAU,WAAW,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOzC,EAAQsC,EAAU,IAAME,GAA8N,IAAtFE,EAAUC,EAAqO,OAA3IP,EAAUC,EAAU,IAAM,EAAM,MAAcA,EAAU,IAAM,EAAM,KAApED,GAAiG,YAAE,6BAAvMM,GAA2Q,IAAjQC,GAAuQ,IAAjO3C,EAAQ2C,IAAY,IAAMD,KAA0NP,IAAa,OAAOC,OAAe,OAAOD,IAAYS,EAAQX,EAAU,IAAKD,GAAY,SAASa,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOL,EAAQG,IAAY,IAAMC,GAAY,SAASE,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOV,EAAQS,IAAY,GAAKD,GAAqJ,OAAY,IAA0b,GAAgP,SAAxpB78B,SAASu7B,EAAU,EAAM,IAAM,OAAev7B,SAAS28B,EAAU,EAAK,IAAK,MAAY38B,SAAS28B,EAAU,EAAM,IAAK,MAAY38B,SAAp2Cq8B,GAAk4C,IAA92C,KAAo2C,IAAqBr8B,SAAS28B,EAAU,EAAM,IAAK,OAAc38B,SAASs8B,EAAU,EAAI,GAAK,MAAat8B,SAASu7B,EAAU,EAAM,IAAM,MAAcv7B,SAASs8B,EAAU,EAAK,GAAK,MAAWt8B,SAASu7B,EAAU,EAAM,IAAM,OAAev7B,SAASs8B,EAAU,EAAI,GAAI,KAAoC,MAAWjC,EAAgB,KAAEA,EAAUa,GAAW,IAAM,EAAO,GAAQ,SAAY,MAAM8B,GAAW3C,EAAUa,GAAW,IAAM,EAAO,GAAQ,MAAQb,EAAUa,GAAW,IAAM,EAAO,GAAQ,UAA1mF,CAAynFhB,GAAkB,IAA6B+C,EAAkXC,GAAlXD,GAAU,EAAY,SAASE,EAAUC,GAAW,IAAIC,EAAUJ,EAAU,WAAW,SAASK,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOjE,EAAQ+D,EAAU,IAAMC,GAAY,GAAGL,EAAU,CAAC,IAAIO,EAAUP,EAAUE,EAAU,EAAM,KAAM,OAAcH,EAAU3lD,WAAW,OAAO4lD,EAAU,KAAKO,IAAa,aAAa,OAAOV,GAAU,EAAII,SAAoC,GAAK,WAAW,IAAIO,EAAU,WAAoH,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAO5B,EAAQ2B,EAAU,IAAMD,GAAmH,IAA1RG,EAAoBC,EAA8Z,OAA1IP,EAAUC,EAAU,EAAM,KAAM,QAAxUK,GAAuW,GAAnVC,GAA8V,GAA5U1E,EAAQ0E,IAAY,IAAMD,IAAwON,GAAgG,YAAE,4BAAyDC,EAAU,EAAM,KAAM,OAAcX,IAAa,OAAOU,OAA2B,SAASvB,EAAQ+B,EAAUC,GAAW,OAAOhC,EAAQ,SAASiC,EAAUC,GAAsE,OAAnBrE,EAAxCoE,GAAoB,OAAkEF,EAAUC,GAA+C,SAASlE,EAAUqE,EAAUC,EAAUC,EAAUC,GAAW,OAAOlF,EAAQiF,EAAU,IAAMC,GAAY,SAASvE,EAAUwE,EAAUC,EAAUC,EAAUC,GAAW,OAAOtF,EAAQoF,IAAY,IAAMC,GAAlb5B,IAAqiB,IAA1E8B,EAAoBC,EAA0DC,EAAU,GAAG,SAASzF,EAAQ0F,EAAUC,GAAW,OAAO3F,EAAQ,SAAS4F,EAAUC,GAAqE,OAAnBrG,EAAvCoG,GAAoB,OAAiEF,EAAUC,GAAYF,GAAzRF,EAAmT,IAA/RC,EAA2S,IAAzR5C,EAAQ4C,EAAU,IAAMD,KAAyQ,WAAyJ,IAA5GO,EAAUC,EAAsGC,EAAS,GAAG,OAAOA,GAAnIF,EAA4J,IAAlJC,EAAwJ,IAA1vJ/F,EAAkqJ+F,EAAU,MAAxpJ,EAAooJD,KAAgHG,KAAKD,GAA0B,QCAx2NE,EAAQ,CAAC,eAAe,gBAAgB,wBAA6C,gBAAgB,eAAe,cAAc,eAAe,2BAAuC,QAAQ,gBAAgB,gBAA+jC,SAASC,EAAQC,EAAUC,GAAW,OAAOF,EAAQ,SAASG,EAAUC,GAAsE,OAAnBL,EAAxCI,GAAoB,OAAkEF,EAAUC,IAAjuC,SAASG,EAAUC,GAAkH,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOX,EAAQU,IAAY,IAAMC,GAAY,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOhB,EAAQgB,IAAY,IAAMH,GAA4N,OAAY,IAAgW,GAAiJ,UAA9dzgC,SAASmgC,EAAU,EAAO,GAAQ,KAAO,MAASngC,SAASwgC,GAAW,IAAM,EAAO,GAAQ,MAAQxgC,SAA/Q4/B,EAAkS,MAA9Q,IAAwR,MAAY5/B,SAASmgC,EAAU,EAAO,GAAQ,KAAO,OAASngC,UAAlT6gC,EAAqU,IAA3TC,EAAiU,IAA3RlB,EAAQkB,IAAY,IAAKD,KAAsR7gC,SAASmgC,EAAU,EAAO,GAAQ,KAAO,MAAQngC,SAASwgC,GAAW,IAAM,EAAO,GAAQ,MAAiC,MAAWP,EAAgB,KAAEA,EAAiB,SAAM,MAAMc,GAAUd,EAAgB,KAAEA,EAAiB,SAAplB,IAAmBY,EAAUC,EAA7d,CAA6hCnB,GAAiN,IAA6BqB,EAA+WhB,GAA/WgB,GAAU,EAAY,SAASC,EAAUC,GAAW,IAAIC,EAAUH,EAAU,WAAW,SAASI,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAO5B,EAAQyB,IAAY,IAAKC,GAAY,GAAGJ,EAAU,CAAC,IAAIO,EAAUP,EAAUE,EAAU,IAAK,MAAiBH,EAAUzpD,WAAW,OAAO0pD,EAAU,KAAKO,IAAa,aAAa,OAAOT,GAAU,EAAIG,SAAoC,GAAK,WAAW,IAAIO,EAAU,WAAkH,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOnC,EAAQmC,EAAU,IAAMF,GAAoY,OAAnQH,EAAUC,EAAU,EAAM,KAAM,EAAM,OAAQA,EAAU,EAAM,KAAM,EAAM,MAA1ED,GAAoFC,EAAU,EAAM,KAAM,EAAM,OAAhX/B,EAAwY,KAAtX,IAA4X,OAA4I,KAAEI,IAAa,OAAO0B,OAAe1B,IAA2S,Q,QCkBzzF,EAXC,YACd,GCRW,WAAa,IAAIgC,EAAIt0D,KAASu0D,EAAGD,EAAIj2C,eAAmBgE,EAAGiyC,EAAIzkC,MAAMxN,IAAIkyC,EAAG,OAAOlyC,EAAG,MAAM,CAACA,EAAG,MAAM,CAAC6R,YAAY,gBAAgB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,sEAAsE,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,0CAA0C,CAAC7R,EAAG,KAAK,CAACiyC,EAAIhzC,GAAGgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,uBAAuB64D,EAAIhzC,GAAG,KAAKe,EAAG,IAAI,CAACiyC,EAAIhzC,GAAGgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,4BAA4B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,kDAAkD,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,sBAAsB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,iBAAiB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,gBAAgB,CAAC7R,EAAG,KAAK,CAACiyC,EAAIhzC,GAAGgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,8BAA8B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,yCAAyCxX,MAAM,CAAC,GAAK,uBAAuB,CAAC2F,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,mBAAmBxX,MAAM,CAAC,GAAK,qBAAqB,CAAC2F,EAAG,IAAI,CAAC6R,YAAY,mBAAmBxX,MAAM,CAAC,KAAO,SAAS,iBAAiB,WAAW,iBAAiB,oBAAoB,gBAAgB,OAAO,gBAAgB,qBAAqB,CAAC43C,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,0BAA0B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,mCAAmCxX,MAAM,CAAC,GAAK,mBAAmB,kBAAkB,mBAAmB,iBAAiB,wBAAwB,CAAC2F,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAACogC,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,4BAA4B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,mBAAmBxX,MAAM,CAAC,GAAK,qBAAqB,CAAC2F,EAAG,IAAI,CAAC6R,YAAY,6BAA6BxX,MAAM,CAAC,KAAO,SAAS,iBAAiB,WAAW,iBAAiB,oBAAoB,gBAAgB,QAAQ,gBAAgB,qBAAqB,CAAC43C,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,0BAA0B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,8BAA8BxX,MAAM,CAAC,GAAK,mBAAmB,kBAAkB,mBAAmB,iBAAiB,wBAAwB,CAAC2F,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAACogC,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,wBAAwB4mB,EAAG,MAAMiyC,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,6BAA6B,wBAAwB4mB,EAAG,IAAI,CAAC3F,MAAM,CAAC,KAAO43C,EAAItC,KAAKv2D,EAAE,iCAAiC,OAAS,WAAW,CAAC64D,EAAIhzC,GAAGgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,0BAA0B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,mBAAmBxX,MAAM,CAAC,GAAK,uBAAuB,CAAC2F,EAAG,IAAI,CAAC6R,YAAY,6BAA6BxX,MAAM,CAAC,KAAO,SAAS,iBAAiB,WAAW,iBAAiB,oBAAoB,gBAAgB,QAAQ,gBAAgB,qBAAqB,CAAC43C,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,0BAA0B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,8BAA8BxX,MAAM,CAAC,GAAK,mBAAmB,kBAAkB,qBAAqB,iBAAiB,wBAAwB,CAAC2F,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAACogC,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,4BAA4B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,mBAAmBxX,MAAM,CAAC,GAAK,sBAAsB,CAAC2F,EAAG,IAAI,CAAC6R,YAAY,6BAA6BxX,MAAM,CAAC,KAAO,SAAS,iBAAiB,WAAW,iBAAiB,oBAAoB,gBAAgB,QAAQ,gBAAgB,qBAAqB,CAAC43C,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,0BAA0B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,8BAA8BxX,MAAM,CAAC,GAAK,mBAAmB,kBAAkB,oBAAoB,iBAAiB,wBAAwB,CAAC2F,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAACogC,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,4BAA4B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAAC7R,EAAG,MAAM,CAAC6R,YAAY,mBAAmBxX,MAAM,CAAC,GAAK,sBAAsB,CAAC2F,EAAG,IAAI,CAAC6R,YAAY,6BAA6BxX,MAAM,CAAC,KAAO,SAAS,iBAAiB,WAAW,iBAAiB,oBAAoB,gBAAgB,QAAQ,gBAAgB,qBAAqB,CAAC43C,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,0BAA0B64D,EAAIhzC,GAAG,KAAKe,EAAG,MAAM,CAAC6R,YAAY,8BAA8BxX,MAAM,CAAC,GAAK,mBAAmB,kBAAkB,oBAAoB,iBAAiB,wBAAwB,CAAC2F,EAAG,MAAM,CAAC6R,YAAY,kBAAkB,CAACogC,EAAIhzC,GAAG,uBAAuBgzC,EAAIzzC,GAAGyzC,EAAItC,KAAKv2D,EAAE,wBAAwB,0CAC7lJ,IDUpB,EACA,KACA,KACA,M,QEdE+4D,EAAQ,CAAC,mBAAmB,eAAe,YAAY,eAAe,UAAU,UAAU,aAAa,mBAAmB,cAAc,cAAc,aAAa,2BAAuC,eAAe,wBAA6C,UAAU,YAAY,cAAc,UAAU,UAAU,eAAe,UAAU,QAAQ,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOC,EAAQH,IAAY,IAAKE,GAAozC,SAASC,EAAQC,EAAUC,GAAW,OAAOF,EAAQ,SAASG,EAAUC,GAAqE,OAAnBV,EAAvCS,GAAoB,OAAiEF,EAAUC,IAAz9C,SAASG,EAAUC,GAAW,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOX,EAAQW,EAAU,IAAMD,GAAY,SAASE,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOhB,EAAQa,IAAY,GAAKG,GAAqH,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOrB,EAAQoB,EAAU,IAAKF,GAAY,SAASI,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAO1B,EAAQyB,EAAU,IAAMF,GAAY,OAAY,IAA4lB,GAAkJ,SAA5tB/jC,SAAS+iC,EAAU,EAAM,EAAM,IAAM,MAAQ/iC,SAASyjC,EAAU,IAAM,EAAM,MAAczjC,SAASyjC,EAAU,IAAM,EAAM,MAAczjC,SAAS8jC,EAAU,IAAM,EAAM,OAAe9jC,SAAS+iC,EAAU,EAAM,EAAM,IAAM,MAAQ/iC,SAASojC,EAAU,IAAK,EAAK,EAAK,MAAOpjC,SAAS8jC,EAAU,IAAM,EAAM,MAAc9jC,SAAS+iC,EAAU,EAAM,EAAM,IAAM,MAAS/iC,SAASyjC,EAAU,IAAM,EAAM,OAAezjC,UAA3sBmkC,GAAsuB,IAAltBC,GAAguB,IAA9sB5B,EAAQ2B,IAAY,IAAMC,MAA6rBpkC,SAASyjC,EAAU,IAAM,EAAM,OAAezjC,SAAS+iC,EAAU,EAAM,EAAM,IAAM,MAAQ/iC,SAASojC,EAAU,IAAK,EAAK,EAAK,MAAgC,MAAWP,EAAgB,KAAEA,EAAiB,SAAM,MAAMwB,GAAWxB,EAAgB,KAAEA,EAAiB,SAA/hC,IAA6BsB,EAAoBC,EAA/R,CAAsxClC,GAAgN,IAA6BoC,EAAgP1B,GAAhP0B,GAAU,EAAY,SAASC,EAAUC,GAAW,IAAIC,EAAUH,EAAU,WAAW,GAAGE,EAAU,CAAC,IAAIE,EAAUF,EAAiB,MAAED,EAAU/sD,WAAW,OAAOgtD,EAAU,KAAKE,IAAa,aAAa,OAAOJ,GAAU,EAAIG,SAAoC,GAAK,WAAW,IAAIE,EAAU,WAAmU,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOxC,EAAQwC,EAAU,IAAMH,GAAqH,IAAlEI,EAAUC,EAAhUC,EAAUC,EAAvIC,EAAUC,EAAypB,OAAhKX,GAAtYQ,EAAsa,IAA5ZC,EAAka,IAAhZ5C,EAAQ4C,EAAU,IAAMD,MAAkQF,GAAuJ,IAA7IC,GAAoJ,IAAlI1C,EAAQyC,IAAY,IAAMC,IAA0BP,GAAwFC,EAAU,IAAM,EAAM,EAAM,MAAQA,EAAU,IAAM,EAAM,EAAM,OAA3pBS,GAA+rB,IAArrBC,GAA4rB,IAAtpB9C,EAAQ8C,IAAY,IAAMD,KAAkpBzC,IAAa,OAAO+B,OAAsD,SAASY,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOnD,EAAQgD,EAAU,IAAME,GAAlI9C,IAA+Lx2D,SAAS+1D,EAAU,EAAK,IAAK,EAAK,MAAOA,EAAU,EAAK,IAAK,EAAK,MAAM,WAAkJ,IAAIyD,EAAU,GAAG,SAASC,EAAUC,EAAUC,EAAUC,EAAUC,GAAW,OAAOV,EAAUO,EAAU,IAAMC,EAAeE,GAAsKL,EAAUC,EAAU,KAAM,EAAM,EAAM,OAAQ,EAAU,IAArcK,EAAUC,EAA+bC,EAAU,GAAG,OAAOA,EAAc,GAAEP,EAAU,KAAM,EAAM,EAAM,MAAOO,GAAhhBF,EAA0iB,KAAhiBC,EAAsiB,KAA1gBZ,EAAUY,EAAU,IAAMD,EAAeA,KAA+eN,EAAU,IAAI,UAAUQ,O,mBCMj1Hp+D,EAAOD,QAGhE,WAAe,aASrB,MAAM4qD,EAAY,KAChB,MAAM,OACJC,GACErkD,OAEJ,OAAIqkD,IAAWxmD,SAAS2vC,KAAKhwC,aAAa,qBACjC6mD,EAGF,MAeHyT,EAAiB,qBACjBC,EAAiB,OACjBC,EAAgB,SAChBC,EAAgB,GAEtB,IAAIC,EAAW,EACf,MAAMC,EAAe,CACnBC,WAAY,YACZC,WAAY,YAERC,EAAoB,4BACpBv9B,EAAe,IAAIvsB,IAAI,CAAC,QAAS,WAAY,UAAW,YAAa,cAAe,aAAc,iBAAkB,YAAa,WAAY,YAAa,cAAe,YAAa,UAAW,WAAY,QAAS,oBAAqB,aAAc,YAAa,WAAY,cAAe,cAAe,cAAe,YAAa,eAAgB,gBAAiB,eAAgB,gBAAiB,aAAc,QAAS,OAAQ,SAAU,QAAS,SAAU,SAAU,UAAW,WAAY,OAAQ,SAAU,eAAgB,SAAU,OAAQ,mBAAoB,mBAAoB,QAAS,QAAS,WAO/lB,SAAS+pD,EAAY38D,EAAS+S,GAC5B,OAAOA,GAAO,GAAGA,MAAQupD,OAAgBt8D,EAAQs8D,UAAYA,IAG/D,SAASM,EAAS58D,GAChB,MAAM+S,EAAM4pD,EAAY38D,GAGxB,OAFAA,EAAQs8D,SAAWvpD,EACnBspD,EAActpD,GAAOspD,EAActpD,IAAQ,GACpCspD,EAActpD,GAGvB,SAAS8pD,EAAiB78D,EAASwM,GACjC,OAAO,SAASlH,EAAQiZ,GAOtB,OANAA,EAAM2tC,eAAiBlsD,EAEnBsF,EAAQw3D,QACVp5D,EAAauC,IAAIjG,EAASue,EAAM3F,KAAMpM,GAGjCA,EAAGc,MAAMtN,EAAS,CAACue,KAI9B,SAASw+C,EAA2B/8D,EAASgC,EAAUwK,GACrD,OAAO,SAASlH,EAAQiZ,GACtB,MAAMy+C,EAAch9D,EAAQqC,iBAAiBL,GAE7C,IAAK,IAAI,OACPuD,GACEgZ,EAAOhZ,GAAUA,IAAWhC,KAAMgC,EAASA,EAAOzC,WACpD,IAAK,IAAIhF,EAAIk/D,EAAY77D,OAAQrD,KAC/B,GAAIk/D,EAAYl/D,KAAOyH,EAOrB,OANAgZ,EAAM2tC,eAAiB3mD,EAEnBD,EAAQw3D,QACVp5D,EAAauC,IAAIjG,EAASue,EAAM3F,KAAM5W,EAAUwK,GAG3CA,EAAGc,MAAM/H,EAAQ,CAACgZ,IAM/B,OAAO,MAIX,SAAS0+C,EAAYl+B,EAAQz5B,EAAS43D,EAAqB,MACzD,MAAMC,EAAe3+D,OAAOkC,KAAKq+B,GAEjC,IAAK,IAAIjhC,EAAI,EAAGgY,EAAMqnD,EAAah8D,OAAQrD,EAAIgY,EAAKhY,IAAK,CACvD,MAAMygB,EAAQwgB,EAAOo+B,EAAar/D,IAElC,GAAIygB,EAAM6+C,kBAAoB93D,GAAWiZ,EAAM2+C,qBAAuBA,EACpE,OAAO3+C,EAIX,OAAO,KAGT,SAAS8+C,EAAgBC,EAAmBh4D,EAASi4D,GACnD,MAAMC,EAAgC,kBAAZl4D,EACpB83D,EAAkBI,EAAaD,EAAej4D,EACpD,IAAIm4D,EAAYC,EAAaJ,GAO7B,OANiBn+B,EAAaj/B,IAAIu9D,KAGhCA,EAAYH,GAGP,CAACE,EAAYJ,EAAiBK,GAGvC,SAAS5+B,EAAW7+B,EAASs9D,EAAmBh4D,EAASi4D,EAAcT,GACrE,GAAiC,kBAAtBQ,IAAmCt9D,EAC5C,OAUF,GAPKsF,IACHA,EAAUi4D,EACVA,EAAe,MAKbb,EAAkBnrD,KAAK+rD,GAAoB,CAC7C,MAAMK,EAASnxD,GACN,SAAU+R,GACf,IAAKA,EAAMq/C,eAAiBr/C,EAAMq/C,gBAAkBr/C,EAAM2tC,iBAAmB3tC,EAAM2tC,eAAexqD,SAAS6c,EAAMq/C,eAC/G,OAAOpxD,EAAGvO,KAAKsF,KAAMgb,IAKvBg/C,EACFA,EAAeI,EAAOJ,GAEtBj4D,EAAUq4D,EAAOr4D,GAIrB,MAAOk4D,EAAYJ,EAAiBK,GAAaJ,EAAgBC,EAAmBh4D,EAASi4D,GACvFx+B,EAAS69B,EAAS58D,GAClB0sB,EAAWqS,EAAO0+B,KAAe1+B,EAAO0+B,GAAa,IACrDI,EAAaZ,EAAYvwC,EAAU0wC,EAAiBI,EAAal4D,EAAU,MAEjF,GAAIu4D,EAEF,YADAA,EAAWf,OAASe,EAAWf,QAAUA,GAI3C,MAAM/pD,EAAM4pD,EAAYS,EAAiBE,EAAkBz0D,QAAQqzD,EAAgB,KAC7E1vD,EAAKgxD,EAAaT,EAA2B/8D,EAASsF,EAASi4D,GAAgBV,EAAiB78D,EAASsF,GAC/GkH,EAAG0wD,mBAAqBM,EAAal4D,EAAU,KAC/CkH,EAAG4wD,gBAAkBA,EACrB5wD,EAAGswD,OAASA,EACZtwD,EAAG8vD,SAAWvpD,EACd2Z,EAAS3Z,GAAOvG,EAChBxM,EAAQyF,iBAAiBg4D,EAAWjxD,EAAIgxD,GAG1C,SAASM,EAAc99D,EAAS++B,EAAQ0+B,EAAWn4D,EAAS43D,GAC1D,MAAM1wD,EAAKywD,EAAYl+B,EAAO0+B,GAAYn4D,EAAS43D,GAE9C1wD,IAILxM,EAAQwF,oBAAoBi4D,EAAWjxD,EAAIqO,QAAQqiD,WAC5Cn+B,EAAO0+B,GAAWjxD,EAAG8vD,WAG9B,SAASyB,EAAyB/9D,EAAS++B,EAAQ0+B,EAAW5kC,GAC5D,MAAMmlC,EAAoBj/B,EAAO0+B,IAAc,GAC/Cj/D,OAAOkC,KAAKs9D,GAAmB53D,SAAQ63D,IACrC,GAAIA,EAAWjW,SAASnvB,GAAY,CAClC,MAAMta,EAAQy/C,EAAkBC,GAChCH,EAAc99D,EAAS++B,EAAQ0+B,EAAWl/C,EAAM6+C,gBAAiB7+C,EAAM2+C,wBAK7E,SAASQ,EAAan/C,GAGpB,OADAA,EAAQA,EAAM1V,QAAQszD,EAAgB,IAC/BI,EAAah+C,IAAUA,EAGhC,MAAM7a,EAAe,CACnB,GAAG1D,EAASue,EAAOjZ,EAASi4D,GAC1B1+B,EAAW7+B,EAASue,EAAOjZ,EAASi4D,GAAc,IAGpD,IAAIv9D,EAASue,EAAOjZ,EAASi4D,GAC3B1+B,EAAW7+B,EAASue,EAAOjZ,EAASi4D,GAAc,IAGpD,IAAIv9D,EAASs9D,EAAmBh4D,EAASi4D,GACvC,GAAiC,kBAAtBD,IAAmCt9D,EAC5C,OAGF,MAAOw9D,EAAYJ,EAAiBK,GAAaJ,EAAgBC,EAAmBh4D,EAASi4D,GACvFW,EAAcT,IAAcH,EAC5Bv+B,EAAS69B,EAAS58D,GAClBm+D,EAAcb,EAAkBl0D,WAAW,KAEjD,GAA+B,qBAApBg0D,EAAiC,CAE1C,IAAKr+B,IAAWA,EAAO0+B,GACrB,OAIF,YADAK,EAAc99D,EAAS++B,EAAQ0+B,EAAWL,EAAiBI,EAAal4D,EAAU,MAIhF64D,GACF3/D,OAAOkC,KAAKq+B,GAAQ34B,SAAQg4D,IAC1BL,EAAyB/9D,EAAS++B,EAAQq/B,EAAcd,EAAkB/zD,MAAM,OAIpF,MAAMy0D,EAAoBj/B,EAAO0+B,IAAc,GAC/Cj/D,OAAOkC,KAAKs9D,GAAmB53D,SAAQi4D,IACrC,MAAMJ,EAAaI,EAAYx1D,QAAQuzD,EAAe,IAEtD,IAAK8B,GAAeZ,EAAkBtV,SAASiW,GAAa,CAC1D,MAAM1/C,EAAQy/C,EAAkBK,GAChCP,EAAc99D,EAAS++B,EAAQ0+B,EAAWl/C,EAAM6+C,gBAAiB7+C,EAAM2+C,yBAK7E,QAAQl9D,EAASue,EAAO1I,GACtB,GAAqB,kBAAV0I,IAAuBve,EAChC,OAAO,KAGT,MAAM8oD,EAAIN,IACJiV,EAAYC,EAAan/C,GACzB2/C,EAAc3/C,IAAUk/C,EACxBnrD,EAAW6sB,EAAaj/B,IAAIu9D,GAClC,IAAIa,EACAC,GAAU,EACVC,GAAiB,EACjBnT,GAAmB,EACnBoT,EAAM,KA4CV,OA1CIP,GAAepV,IACjBwV,EAAcxV,EAAElkD,MAAM2Z,EAAO1I,GAC7BizC,EAAE9oD,GAAS4tC,QAAQ0wB,GACnBC,GAAWD,EAAYI,uBACvBF,GAAkBF,EAAYK,gCAC9BtT,EAAmBiT,EAAYM,sBAG7BtsD,GACFmsD,EAAMx8D,SAASmrB,YAAY,cAC3BqxC,EAAI7vB,UAAU6uB,EAAWc,GAAS,IAElCE,EAAM,IAAII,YAAYtgD,EAAO,CAC3BggD,UACAO,YAAY,IAKI,qBAATjpD,GACTrX,OAAOkC,KAAKmV,GAAMzP,SAAQ/G,IACxBb,OAAOC,eAAeggE,EAAKp/D,EAAK,CAC9BV,IAAG,IACMkX,EAAKxW,QAOhBgsD,GACFoT,EAAItS,iBAGFqS,GACFx+D,EAAQ2E,cAAc85D,GAGpBA,EAAIpT,kBAA2C,qBAAhBiT,GACjCA,EAAYnS,iBAGPsS,IAKX,OAAO/6D,EAxTyE9C","file":"js/home/faq-ccb64ffa1ef2005ca3ae.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 728);\n","/*!\n  * Bootstrap data.js v5.1.1 (https://getbootstrap.com/)\n  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n  */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Data = factory());\n}(this, (function () { 'use strict';\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): dom/data.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n\n  /**\n   * ------------------------------------------------------------------------\n   * Constants\n   * ------------------------------------------------------------------------\n   */\n  const elementMap = new Map();\n  var data = {\n    set(element, key, instance) {\n      if (!elementMap.has(element)) {\n        elementMap.set(element, new Map());\n      }\n\n      const instanceMap = elementMap.get(element); // make it clear we only want one instance per element\n      // can be removed later when multiple key/instances are fine to be used\n\n      if (!instanceMap.has(key) && instanceMap.size !== 0) {\n        // eslint-disable-next-line no-console\n        console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);\n        return;\n      }\n\n      instanceMap.set(key, instance);\n    },\n\n    get(element, key) {\n      if (elementMap.has(element)) {\n        return elementMap.get(element).get(key) || null;\n      }\n\n      return null;\n    },\n\n    remove(element, key) {\n      if (!elementMap.has(element)) {\n        return;\n      }\n\n      const instanceMap = elementMap.get(element);\n      instanceMap.delete(key); // free up element references if there are no instances left for an element\n\n      if (instanceMap.size === 0) {\n        elementMap.delete(element);\n      }\n    }\n\n  };\n\n  return data;\n\n})));\n//# sourceMappingURL=data.js.map\n","/*!\n  * Bootstrap selector-engine.js v5.1.1 (https://getbootstrap.com/)\n  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n  */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.SelectorEngine = factory());\n}(this, (function () { 'use strict';\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): util/index.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n\n  const isElement = obj => {\n    if (!obj || typeof obj !== 'object') {\n      return false;\n    }\n\n    if (typeof obj.jquery !== 'undefined') {\n      obj = obj[0];\n    }\n\n    return typeof obj.nodeType !== 'undefined';\n  };\n\n  const isVisible = element => {\n    if (!isElement(element) || element.getClientRects().length === 0) {\n      return false;\n    }\n\n    return getComputedStyle(element).getPropertyValue('visibility') === 'visible';\n  };\n\n  const isDisabled = element => {\n    if (!element || element.nodeType !== Node.ELEMENT_NODE) {\n      return true;\n    }\n\n    if (element.classList.contains('disabled')) {\n      return true;\n    }\n\n    if (typeof element.disabled !== 'undefined') {\n      return element.disabled;\n    }\n\n    return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';\n  };\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): dom/selector-engine.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n  const NODE_TEXT = 3;\n  const SelectorEngine = {\n    find(selector, element = document.documentElement) {\n      return [].concat(...Element.prototype.querySelectorAll.call(element, selector));\n    },\n\n    findOne(selector, element = document.documentElement) {\n      return Element.prototype.querySelector.call(element, selector);\n    },\n\n    children(element, selector) {\n      return [].concat(...element.children).filter(child => child.matches(selector));\n    },\n\n    parents(element, selector) {\n      const parents = [];\n      let ancestor = element.parentNode;\n\n      while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {\n        if (ancestor.matches(selector)) {\n          parents.push(ancestor);\n        }\n\n        ancestor = ancestor.parentNode;\n      }\n\n      return parents;\n    },\n\n    prev(element, selector) {\n      let previous = element.previousElementSibling;\n\n      while (previous) {\n        if (previous.matches(selector)) {\n          return [previous];\n        }\n\n        previous = previous.previousElementSibling;\n      }\n\n      return [];\n    },\n\n    next(element, selector) {\n      let next = element.nextElementSibling;\n\n      while (next) {\n        if (next.matches(selector)) {\n          return [next];\n        }\n\n        next = next.nextElementSibling;\n      }\n\n      return [];\n    },\n\n    focusableChildren(element) {\n      const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable=\"true\"]'].map(selector => `${selector}:not([tabindex^=\"-\"])`).join(', ');\n      return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));\n    }\n\n  };\n\n  return SelectorEngine;\n\n})));\n//# sourceMappingURL=selector-engine.js.map\n","/*!\n  * Bootstrap base-component.js v5.1.1 (https://getbootstrap.com/)\n  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n  */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('./dom/data.js'), require('./dom/event-handler.js')) :\n  typeof define === 'function' && define.amd ? define(['./dom/data', './dom/event-handler'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Base = factory(global.Data, global.EventHandler));\n}(this, (function (Data, EventHandler) { 'use strict';\n\n  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n  var Data__default = /*#__PURE__*/_interopDefaultLegacy(Data);\n  var EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler);\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): util/index.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n  const MILLISECONDS_MULTIPLIER = 1000;\n  const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)\n\n  const getTransitionDurationFromElement = element => {\n    if (!element) {\n      return 0;\n    } // Get transition-duration of the element\n\n\n    let {\n      transitionDuration,\n      transitionDelay\n    } = window.getComputedStyle(element);\n    const floatTransitionDuration = Number.parseFloat(transitionDuration);\n    const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found\n\n    if (!floatTransitionDuration && !floatTransitionDelay) {\n      return 0;\n    } // If multiple durations are defined, take the first\n\n\n    transitionDuration = transitionDuration.split(',')[0];\n    transitionDelay = transitionDelay.split(',')[0];\n    return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;\n  };\n\n  const triggerTransitionEnd = element => {\n    element.dispatchEvent(new Event(TRANSITION_END));\n  };\n\n  const isElement = obj => {\n    if (!obj || typeof obj !== 'object') {\n      return false;\n    }\n\n    if (typeof obj.jquery !== 'undefined') {\n      obj = obj[0];\n    }\n\n    return typeof obj.nodeType !== 'undefined';\n  };\n\n  const getElement = obj => {\n    if (isElement(obj)) {\n      // it's a jQuery object or a node element\n      return obj.jquery ? obj[0] : obj;\n    }\n\n    if (typeof obj === 'string' && obj.length > 0) {\n      return document.querySelector(obj);\n    }\n\n    return null;\n  };\n\n  const execute = callback => {\n    if (typeof callback === 'function') {\n      callback();\n    }\n  };\n\n  const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {\n    if (!waitForTransition) {\n      execute(callback);\n      return;\n    }\n\n    const durationPadding = 5;\n    const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;\n    let called = false;\n\n    const handler = ({\n      target\n    }) => {\n      if (target !== transitionElement) {\n        return;\n      }\n\n      called = true;\n      transitionElement.removeEventListener(TRANSITION_END, handler);\n      execute(callback);\n    };\n\n    transitionElement.addEventListener(TRANSITION_END, handler);\n    setTimeout(() => {\n      if (!called) {\n        triggerTransitionEnd(transitionElement);\n      }\n    }, emulatedDuration);\n  };\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): base-component.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n  /**\n   * ------------------------------------------------------------------------\n   * Constants\n   * ------------------------------------------------------------------------\n   */\n\n  const VERSION = '5.1.1';\n\n  class BaseComponent {\n    constructor(element) {\n      element = getElement(element);\n\n      if (!element) {\n        return;\n      }\n\n      this._element = element;\n      Data__default['default'].set(this._element, this.constructor.DATA_KEY, this);\n    }\n\n    dispose() {\n      Data__default['default'].remove(this._element, this.constructor.DATA_KEY);\n      EventHandler__default['default'].off(this._element, this.constructor.EVENT_KEY);\n      Object.getOwnPropertyNames(this).forEach(propertyName => {\n        this[propertyName] = null;\n      });\n    }\n\n    _queueCallback(callback, element, isAnimated = true) {\n      executeAfterTransition(callback, element, isAnimated);\n    }\n    /** Static */\n\n\n    static getInstance(element) {\n      return Data__default['default'].get(getElement(element), this.DATA_KEY);\n    }\n\n    static getOrCreateInstance(element, config = {}) {\n      return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);\n    }\n\n    static get VERSION() {\n      return VERSION;\n    }\n\n    static get NAME() {\n      throw new Error('You have to implement the static method \"NAME\", for each component!');\n    }\n\n    static get DATA_KEY() {\n      return `bs.${this.NAME}`;\n    }\n\n    static get EVENT_KEY() {\n      return `.${this.DATA_KEY}`;\n    }\n\n  }\n\n  return BaseComponent;\n\n})));\n//# sourceMappingURL=base-component.js.map\n","/* globals __VUE_SSR_CONTEXT__ */\n\n// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).\n// This module is a runtime utility for cleaner component module output and will\n// be included in the final webpack user bundle.\n\nexport default function normalizeComponent (\n  scriptExports,\n  render,\n  staticRenderFns,\n  functionalTemplate,\n  injectStyles,\n  scopeId,\n  moduleIdentifier, /* server only */\n  shadowMode /* vue-cli only */\n) {\n  // Vue.extend constructor export interop\n  var options = typeof scriptExports === 'function'\n    ? scriptExports.options\n    : scriptExports\n\n  // render functions\n  if (render) {\n    options.render = render\n    options.staticRenderFns = staticRenderFns\n    options._compiled = true\n  }\n\n  // functional template\n  if (functionalTemplate) {\n    options.functional = true\n  }\n\n  // scopedId\n  if (scopeId) {\n    options._scopeId = 'data-v-' + scopeId\n  }\n\n  var hook\n  if (moduleIdentifier) { // server build\n    hook = function (context) {\n      // 2.3 injection\n      context =\n        context || // cached call\n        (this.$vnode && this.$vnode.ssrContext) || // stateful\n        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional\n      // 2.2 with runInNewContext: true\n      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {\n        context = __VUE_SSR_CONTEXT__\n      }\n      // inject component styles\n      if (injectStyles) {\n        injectStyles.call(this, context)\n      }\n      // register component module identifier for async chunk inferrence\n      if (context && context._registeredComponents) {\n        context._registeredComponents.add(moduleIdentifier)\n      }\n    }\n    // used by ssr in case component is cached and beforeCreate\n    // never gets called\n    options._ssrRegister = hook\n  } else if (injectStyles) {\n    hook = shadowMode\n      ? function () {\n        injectStyles.call(\n          this,\n          (options.functional ? this.parent : this).$root.$options.shadowRoot\n        )\n      }\n      : injectStyles\n  }\n\n  if (hook) {\n    if (options.functional) {\n      // for template-only hot-reload because in that case the render fn doesn't\n      // go through the normalizer\n      options._injectStyles = hook\n      // register for functional component in vue file\n      var originalRender = options.render\n      options.render = function renderWithStyleInjection (h, context) {\n        hook.call(context)\n        return originalRender(h, context)\n      }\n    } else {\n      // inject component registration as beforeCreate hook\n      var existing = options.beforeCreate\n      options.beforeCreate = existing\n        ? [].concat(existing, hook)\n        : [hook]\n    }\n  }\n\n  return {\n    exports: scriptExports,\n    options: options\n  }\n}\n","/*!\n  * Bootstrap manipulator.js v5.1.1 (https://getbootstrap.com/)\n  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n  */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Manipulator = factory());\n}(this, (function () { 'use strict';\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): dom/manipulator.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n  function normalizeData(val) {\n    if (val === 'true') {\n      return true;\n    }\n\n    if (val === 'false') {\n      return false;\n    }\n\n    if (val === Number(val).toString()) {\n      return Number(val);\n    }\n\n    if (val === '' || val === 'null') {\n      return null;\n    }\n\n    return val;\n  }\n\n  function normalizeDataKey(key) {\n    return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);\n  }\n\n  const Manipulator = {\n    setDataAttribute(element, key, value) {\n      element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);\n    },\n\n    removeDataAttribute(element, key) {\n      element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);\n    },\n\n    getDataAttributes(element) {\n      if (!element) {\n        return {};\n      }\n\n      const attributes = {};\n      Object.keys(element.dataset).filter(key => key.startsWith('bs')).forEach(key => {\n        let pureKey = key.replace(/^bs/, '');\n        pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);\n        attributes[pureKey] = normalizeData(element.dataset[key]);\n      });\n      return attributes;\n    },\n\n    getDataAttribute(element, key) {\n      return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));\n    },\n\n    offset(element) {\n      const rect = element.getBoundingClientRect();\n      return {\n        top: rect.top + window.pageYOffset,\n        left: rect.left + window.pageXOffset\n      };\n    },\n\n    position(element) {\n      return {\n        top: element.offsetTop,\n        left: element.offsetLeft\n      };\n    }\n\n  };\n\n  return Manipulator;\n\n})));\n//# sourceMappingURL=manipulator.js.map\n","/*!\n * Vue.js v2.6.12\n * (c) 2014-2020 Evan You\n * Released under the MIT License.\n */\n/*  */\n\nvar emptyObject = Object.freeze({});\n\n// These helpers produce better VM code in JS engines due to their\n// explicitness and function inlining.\nfunction isUndef (v) {\n  return v === undefined || v === null\n}\n\nfunction isDef (v) {\n  return v !== undefined && v !== null\n}\n\nfunction isTrue (v) {\n  return v === true\n}\n\nfunction isFalse (v) {\n  return v === false\n}\n\n/**\n * Check if value is primitive.\n */\nfunction isPrimitive (value) {\n  return (\n    typeof value === 'string' ||\n    typeof value === 'number' ||\n    // $flow-disable-line\n    typeof value === 'symbol' ||\n    typeof value === 'boolean'\n  )\n}\n\n/**\n * Quick object check - this is primarily used to tell\n * Objects from primitive values when we know the value\n * is a JSON-compliant type.\n */\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\n/**\n * Get the raw type string of a value, e.g., [object Object].\n */\nvar _toString = Object.prototype.toString;\n\nfunction toRawType (value) {\n  return _toString.call(value).slice(8, -1)\n}\n\n/**\n * Strict object type check. Only returns true\n * for plain JavaScript objects.\n */\nfunction isPlainObject (obj) {\n  return _toString.call(obj) === '[object Object]'\n}\n\nfunction isRegExp (v) {\n  return _toString.call(v) === '[object RegExp]'\n}\n\n/**\n * Check if val is a valid array index.\n */\nfunction isValidArrayIndex (val) {\n  var n = parseFloat(String(val));\n  return n >= 0 && Math.floor(n) === n && isFinite(val)\n}\n\nfunction isPromise (val) {\n  return (\n    isDef(val) &&\n    typeof val.then === 'function' &&\n    typeof val.catch === 'function'\n  )\n}\n\n/**\n * Convert a value to a string that is actually rendered.\n */\nfunction toString (val) {\n  return val == null\n    ? ''\n    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)\n      ? JSON.stringify(val, null, 2)\n      : String(val)\n}\n\n/**\n * Convert an input value to a number for persistence.\n * If the conversion fails, return original string.\n */\nfunction toNumber (val) {\n  var n = parseFloat(val);\n  return isNaN(n) ? val : n\n}\n\n/**\n * Make a map and return a function for checking if a key\n * is in that map.\n */\nfunction makeMap (\n  str,\n  expectsLowerCase\n) {\n  var map = Object.create(null);\n  var list = str.split(',');\n  for (var i = 0; i < list.length; i++) {\n    map[list[i]] = true;\n  }\n  return expectsLowerCase\n    ? function (val) { return map[val.toLowerCase()]; }\n    : function (val) { return map[val]; }\n}\n\n/**\n * Check if a tag is a built-in tag.\n */\nvar isBuiltInTag = makeMap('slot,component', true);\n\n/**\n * Check if an attribute is a reserved attribute.\n */\nvar isReservedAttribute = makeMap('key,ref,slot,slot-scope,is');\n\n/**\n * Remove an item from an array.\n */\nfunction remove (arr, item) {\n  if (arr.length) {\n    var index = arr.indexOf(item);\n    if (index > -1) {\n      return arr.splice(index, 1)\n    }\n  }\n}\n\n/**\n * Check whether an object has the property.\n */\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction hasOwn (obj, key) {\n  return hasOwnProperty.call(obj, key)\n}\n\n/**\n * Create a cached version of a pure function.\n */\nfunction cached (fn) {\n  var cache = Object.create(null);\n  return (function cachedFn (str) {\n    var hit = cache[str];\n    return hit || (cache[str] = fn(str))\n  })\n}\n\n/**\n * Camelize a hyphen-delimited string.\n */\nvar camelizeRE = /-(\\w)/g;\nvar camelize = cached(function (str) {\n  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })\n});\n\n/**\n * Capitalize a string.\n */\nvar capitalize = cached(function (str) {\n  return str.charAt(0).toUpperCase() + str.slice(1)\n});\n\n/**\n * Hyphenate a camelCase string.\n */\nvar hyphenateRE = /\\B([A-Z])/g;\nvar hyphenate = cached(function (str) {\n  return str.replace(hyphenateRE, '-$1').toLowerCase()\n});\n\n/**\n * Simple bind polyfill for environments that do not support it,\n * e.g., PhantomJS 1.x. Technically, we don't need this anymore\n * since native bind is now performant enough in most browsers.\n * But removing it would mean breaking code that was able to run in\n * PhantomJS 1.x, so this must be kept for backward compatibility.\n */\n\n/* istanbul ignore next */\nfunction polyfillBind (fn, ctx) {\n  function boundFn (a) {\n    var l = arguments.length;\n    return l\n      ? l > 1\n        ? fn.apply(ctx, arguments)\n        : fn.call(ctx, a)\n      : fn.call(ctx)\n  }\n\n  boundFn._length = fn.length;\n  return boundFn\n}\n\nfunction nativeBind (fn, ctx) {\n  return fn.bind(ctx)\n}\n\nvar bind = Function.prototype.bind\n  ? nativeBind\n  : polyfillBind;\n\n/**\n * Convert an Array-like object to a real Array.\n */\nfunction toArray (list, start) {\n  start = start || 0;\n  var i = list.length - start;\n  var ret = new Array(i);\n  while (i--) {\n    ret[i] = list[i + start];\n  }\n  return ret\n}\n\n/**\n * Mix properties into target object.\n */\nfunction extend (to, _from) {\n  for (var key in _from) {\n    to[key] = _from[key];\n  }\n  return to\n}\n\n/**\n * Merge an Array of Objects into a single Object.\n */\nfunction toObject (arr) {\n  var res = {};\n  for (var i = 0; i < arr.length; i++) {\n    if (arr[i]) {\n      extend(res, arr[i]);\n    }\n  }\n  return res\n}\n\n/* eslint-disable no-unused-vars */\n\n/**\n * Perform no operation.\n * Stubbing args to make Flow happy without leaving useless transpiled code\n * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).\n */\nfunction noop (a, b, c) {}\n\n/**\n * Always return false.\n */\nvar no = function (a, b, c) { return false; };\n\n/* eslint-enable no-unused-vars */\n\n/**\n * Return the same value.\n */\nvar identity = function (_) { return _; };\n\n/**\n * Generate a string containing static keys from compiler modules.\n */\nfunction genStaticKeys (modules) {\n  return modules.reduce(function (keys, m) {\n    return keys.concat(m.staticKeys || [])\n  }, []).join(',')\n}\n\n/**\n * Check if two values are loosely equal - that is,\n * if they are plain objects, do they have the same shape?\n */\nfunction looseEqual (a, b) {\n  if (a === b) { return true }\n  var isObjectA = isObject(a);\n  var isObjectB = isObject(b);\n  if (isObjectA && isObjectB) {\n    try {\n      var isArrayA = Array.isArray(a);\n      var isArrayB = Array.isArray(b);\n      if (isArrayA && isArrayB) {\n        return a.length === b.length && a.every(function (e, i) {\n          return looseEqual(e, b[i])\n        })\n      } else if (a instanceof Date && b instanceof Date) {\n        return a.getTime() === b.getTime()\n      } else if (!isArrayA && !isArrayB) {\n        var keysA = Object.keys(a);\n        var keysB = Object.keys(b);\n        return keysA.length === keysB.length && keysA.every(function (key) {\n          return looseEqual(a[key], b[key])\n        })\n      } else {\n        /* istanbul ignore next */\n        return false\n      }\n    } catch (e) {\n      /* istanbul ignore next */\n      return false\n    }\n  } else if (!isObjectA && !isObjectB) {\n    return String(a) === String(b)\n  } else {\n    return false\n  }\n}\n\n/**\n * Return the first index at which a loosely equal value can be\n * found in the array (if value is a plain object, the array must\n * contain an object of the same shape), or -1 if it is not present.\n */\nfunction looseIndexOf (arr, val) {\n  for (var i = 0; i < arr.length; i++) {\n    if (looseEqual(arr[i], val)) { return i }\n  }\n  return -1\n}\n\n/**\n * Ensure a function is called only once.\n */\nfunction once (fn) {\n  var called = false;\n  return function () {\n    if (!called) {\n      called = true;\n      fn.apply(this, arguments);\n    }\n  }\n}\n\nvar SSR_ATTR = 'data-server-rendered';\n\nvar ASSET_TYPES = [\n  'component',\n  'directive',\n  'filter'\n];\n\nvar LIFECYCLE_HOOKS = [\n  'beforeCreate',\n  'created',\n  'beforeMount',\n  'mounted',\n  'beforeUpdate',\n  'updated',\n  'beforeDestroy',\n  'destroyed',\n  'activated',\n  'deactivated',\n  'errorCaptured',\n  'serverPrefetch'\n];\n\n/*  */\n\n\n\nvar config = ({\n  /**\n   * Option merge strategies (used in core/util/options)\n   */\n  // $flow-disable-line\n  optionMergeStrategies: Object.create(null),\n\n  /**\n   * Whether to suppress warnings.\n   */\n  silent: false,\n\n  /**\n   * Show production mode tip message on boot?\n   */\n  productionTip: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Whether to enable devtools\n   */\n  devtools: process.env.NODE_ENV !== 'production',\n\n  /**\n   * Whether to record perf\n   */\n  performance: false,\n\n  /**\n   * Error handler for watcher errors\n   */\n  errorHandler: null,\n\n  /**\n   * Warn handler for watcher warns\n   */\n  warnHandler: null,\n\n  /**\n   * Ignore certain custom elements\n   */\n  ignoredElements: [],\n\n  /**\n   * Custom user key aliases for v-on\n   */\n  // $flow-disable-line\n  keyCodes: Object.create(null),\n\n  /**\n   * Check if a tag is reserved so that it cannot be registered as a\n   * component. This is platform-dependent and may be overwritten.\n   */\n  isReservedTag: no,\n\n  /**\n   * Check if an attribute is reserved so that it cannot be used as a component\n   * prop. This is platform-dependent and may be overwritten.\n   */\n  isReservedAttr: no,\n\n  /**\n   * Check if a tag is an unknown element.\n   * Platform-dependent.\n   */\n  isUnknownElement: no,\n\n  /**\n   * Get the namespace of an element\n   */\n  getTagNamespace: noop,\n\n  /**\n   * Parse the real tag name for the specific platform.\n   */\n  parsePlatformTagName: identity,\n\n  /**\n   * Check if an attribute must be bound using property, e.g. value\n   * Platform-dependent.\n   */\n  mustUseProp: no,\n\n  /**\n   * Perform updates asynchronously. Intended to be used by Vue Test Utils\n   * This will significantly reduce performance if set to false.\n   */\n  async: true,\n\n  /**\n   * Exposed for legacy reasons\n   */\n  _lifecycleHooks: LIFECYCLE_HOOKS\n});\n\n/*  */\n\n/**\n * unicode letters used for parsing html tags, component names and property paths.\n * using https://www.w3.org/TR/html53/semantics-scripting.html#potentialcustomelementname\n * skipping \\u10000-\\uEFFFF due to it freezing up PhantomJS\n */\nvar unicodeRegExp = /a-zA-Z\\u00B7\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u203F-\\u2040\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD/;\n\n/**\n * Check if a string starts with $ or _\n */\nfunction isReserved (str) {\n  var c = (str + '').charCodeAt(0);\n  return c === 0x24 || c === 0x5F\n}\n\n/**\n * Define a property.\n */\nfunction def (obj, key, val, enumerable) {\n  Object.defineProperty(obj, key, {\n    value: val,\n    enumerable: !!enumerable,\n    writable: true,\n    configurable: true\n  });\n}\n\n/**\n * Parse simple path.\n */\nvar bailRE = new RegExp((\"[^\" + (unicodeRegExp.source) + \".$_\\\\d]\"));\nfunction parsePath (path) {\n  if (bailRE.test(path)) {\n    return\n  }\n  var segments = path.split('.');\n  return function (obj) {\n    for (var i = 0; i < segments.length; i++) {\n      if (!obj) { return }\n      obj = obj[segments[i]];\n    }\n    return obj\n  }\n}\n\n/*  */\n\n// can we use __proto__?\nvar hasProto = '__proto__' in {};\n\n// Browser environment sniffing\nvar inBrowser = typeof window !== 'undefined';\nvar inWeex = typeof WXEnvironment !== 'undefined' && !!WXEnvironment.platform;\nvar weexPlatform = inWeex && WXEnvironment.platform.toLowerCase();\nvar UA = inBrowser && window.navigator.userAgent.toLowerCase();\nvar isIE = UA && /msie|trident/.test(UA);\nvar isIE9 = UA && UA.indexOf('msie 9.0') > 0;\nvar isEdge = UA && UA.indexOf('edge/') > 0;\nvar isAndroid = (UA && UA.indexOf('android') > 0) || (weexPlatform === 'android');\nvar isIOS = (UA && /iphone|ipad|ipod|ios/.test(UA)) || (weexPlatform === 'ios');\nvar isChrome = UA && /chrome\\/\\d+/.test(UA) && !isEdge;\nvar isPhantomJS = UA && /phantomjs/.test(UA);\nvar isFF = UA && UA.match(/firefox\\/(\\d+)/);\n\n// Firefox has a \"watch\" function on Object.prototype...\nvar nativeWatch = ({}).watch;\n\nvar supportsPassive = false;\nif (inBrowser) {\n  try {\n    var opts = {};\n    Object.defineProperty(opts, 'passive', ({\n      get: function get () {\n        /* istanbul ignore next */\n        supportsPassive = true;\n      }\n    })); // https://github.com/facebook/flow/issues/285\n    window.addEventListener('test-passive', null, opts);\n  } catch (e) {}\n}\n\n// this needs to be lazy-evaled because vue may be required before\n// vue-server-renderer can set VUE_ENV\nvar _isServer;\nvar isServerRendering = function () {\n  if (_isServer === undefined) {\n    /* istanbul ignore if */\n    if (!inBrowser && !inWeex && typeof global !== 'undefined') {\n      // detect presence of vue-server-renderer and avoid\n      // Webpack shimming the process\n      _isServer = global['process'] && global['process'].env.VUE_ENV === 'server';\n    } else {\n      _isServer = false;\n    }\n  }\n  return _isServer\n};\n\n// detect devtools\nvar devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;\n\n/* istanbul ignore next */\nfunction isNative (Ctor) {\n  return typeof Ctor === 'function' && /native code/.test(Ctor.toString())\n}\n\nvar hasSymbol =\n  typeof Symbol !== 'undefined' && isNative(Symbol) &&\n  typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);\n\nvar _Set;\n/* istanbul ignore if */ // $flow-disable-line\nif (typeof Set !== 'undefined' && isNative(Set)) {\n  // use native Set when available.\n  _Set = Set;\n} else {\n  // a non-standard Set polyfill that only works with primitive keys.\n  _Set = /*@__PURE__*/(function () {\n    function Set () {\n      this.set = Object.create(null);\n    }\n    Set.prototype.has = function has (key) {\n      return this.set[key] === true\n    };\n    Set.prototype.add = function add (key) {\n      this.set[key] = true;\n    };\n    Set.prototype.clear = function clear () {\n      this.set = Object.create(null);\n    };\n\n    return Set;\n  }());\n}\n\n/*  */\n\nvar warn = noop;\nvar tip = noop;\nvar generateComponentTrace = (noop); // work around flow check\nvar formatComponentName = (noop);\n\nif (process.env.NODE_ENV !== 'production') {\n  var hasConsole = typeof console !== 'undefined';\n  var classifyRE = /(?:^|[-_])(\\w)/g;\n  var classify = function (str) { return str\n    .replace(classifyRE, function (c) { return c.toUpperCase(); })\n    .replace(/[-_]/g, ''); };\n\n  warn = function (msg, vm) {\n    var trace = vm ? generateComponentTrace(vm) : '';\n\n    if (config.warnHandler) {\n      config.warnHandler.call(null, msg, vm, trace);\n    } else if (hasConsole && (!config.silent)) {\n      console.error((\"[Vue warn]: \" + msg + trace));\n    }\n  };\n\n  tip = function (msg, vm) {\n    if (hasConsole && (!config.silent)) {\n      console.warn(\"[Vue tip]: \" + msg + (\n        vm ? generateComponentTrace(vm) : ''\n      ));\n    }\n  };\n\n  formatComponentName = function (vm, includeFile) {\n    if (vm.$root === vm) {\n      return '<Root>'\n    }\n    var options = typeof vm === 'function' && vm.cid != null\n      ? vm.options\n      : vm._isVue\n        ? vm.$options || vm.constructor.options\n        : vm;\n    var name = options.name || options._componentTag;\n    var file = options.__file;\n    if (!name && file) {\n      var match = file.match(/([^/\\\\]+)\\.vue$/);\n      name = match && match[1];\n    }\n\n    return (\n      (name ? (\"<\" + (classify(name)) + \">\") : \"<Anonymous>\") +\n      (file && includeFile !== false ? (\" at \" + file) : '')\n    )\n  };\n\n  var repeat = function (str, n) {\n    var res = '';\n    while (n) {\n      if (n % 2 === 1) { res += str; }\n      if (n > 1) { str += str; }\n      n >>= 1;\n    }\n    return res\n  };\n\n  generateComponentTrace = function (vm) {\n    if (vm._isVue && vm.$parent) {\n      var tree = [];\n      var currentRecursiveSequence = 0;\n      while (vm) {\n        if (tree.length > 0) {\n          var last = tree[tree.length - 1];\n          if (last.constructor === vm.constructor) {\n            currentRecursiveSequence++;\n            vm = vm.$parent;\n            continue\n          } else if (currentRecursiveSequence > 0) {\n            tree[tree.length - 1] = [last, currentRecursiveSequence];\n            currentRecursiveSequence = 0;\n          }\n        }\n        tree.push(vm);\n        vm = vm.$parent;\n      }\n      return '\\n\\nfound in\\n\\n' + tree\n        .map(function (vm, i) { return (\"\" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)\n            ? ((formatComponentName(vm[0])) + \"... (\" + (vm[1]) + \" recursive calls)\")\n            : formatComponentName(vm))); })\n        .join('\\n')\n    } else {\n      return (\"\\n\\n(found in \" + (formatComponentName(vm)) + \")\")\n    }\n  };\n}\n\n/*  */\n\nvar uid = 0;\n\n/**\n * A dep is an observable that can have multiple\n * directives subscribing to it.\n */\nvar Dep = function Dep () {\n  this.id = uid++;\n  this.subs = [];\n};\n\nDep.prototype.addSub = function addSub (sub) {\n  this.subs.push(sub);\n};\n\nDep.prototype.removeSub = function removeSub (sub) {\n  remove(this.subs, sub);\n};\n\nDep.prototype.depend = function depend () {\n  if (Dep.target) {\n    Dep.target.addDep(this);\n  }\n};\n\nDep.prototype.notify = function notify () {\n  // stabilize the subscriber list first\n  var subs = this.subs.slice();\n  if (process.env.NODE_ENV !== 'production' && !config.async) {\n    // subs aren't sorted in scheduler if not running async\n    // we need to sort them now to make sure they fire in correct\n    // order\n    subs.sort(function (a, b) { return a.id - b.id; });\n  }\n  for (var i = 0, l = subs.length; i < l; i++) {\n    subs[i].update();\n  }\n};\n\n// The current target watcher being evaluated.\n// This is globally unique because only one watcher\n// can be evaluated at a time.\nDep.target = null;\nvar targetStack = [];\n\nfunction pushTarget (target) {\n  targetStack.push(target);\n  Dep.target = target;\n}\n\nfunction popTarget () {\n  targetStack.pop();\n  Dep.target = targetStack[targetStack.length - 1];\n}\n\n/*  */\n\nvar VNode = function VNode (\n  tag,\n  data,\n  children,\n  text,\n  elm,\n  context,\n  componentOptions,\n  asyncFactory\n) {\n  this.tag = tag;\n  this.data = data;\n  this.children = children;\n  this.text = text;\n  this.elm = elm;\n  this.ns = undefined;\n  this.context = context;\n  this.fnContext = undefined;\n  this.fnOptions = undefined;\n  this.fnScopeId = undefined;\n  this.key = data && data.key;\n  this.componentOptions = componentOptions;\n  this.componentInstance = undefined;\n  this.parent = undefined;\n  this.raw = false;\n  this.isStatic = false;\n  this.isRootInsert = true;\n  this.isComment = false;\n  this.isCloned = false;\n  this.isOnce = false;\n  this.asyncFactory = asyncFactory;\n  this.asyncMeta = undefined;\n  this.isAsyncPlaceholder = false;\n};\n\nvar prototypeAccessors = { child: { configurable: true } };\n\n// DEPRECATED: alias for componentInstance for backwards compat.\n/* istanbul ignore next */\nprototypeAccessors.child.get = function () {\n  return this.componentInstance\n};\n\nObject.defineProperties( VNode.prototype, prototypeAccessors );\n\nvar createEmptyVNode = function (text) {\n  if ( text === void 0 ) text = '';\n\n  var node = new VNode();\n  node.text = text;\n  node.isComment = true;\n  return node\n};\n\nfunction createTextVNode (val) {\n  return new VNode(undefined, undefined, undefined, String(val))\n}\n\n// optimized shallow clone\n// used for static nodes and slot nodes because they may be reused across\n// multiple renders, cloning them avoids errors when DOM manipulations rely\n// on their elm reference.\nfunction cloneVNode (vnode) {\n  var cloned = new VNode(\n    vnode.tag,\n    vnode.data,\n    // #7975\n    // clone children array to avoid mutating original in case of cloning\n    // a child.\n    vnode.children && vnode.children.slice(),\n    vnode.text,\n    vnode.elm,\n    vnode.context,\n    vnode.componentOptions,\n    vnode.asyncFactory\n  );\n  cloned.ns = vnode.ns;\n  cloned.isStatic = vnode.isStatic;\n  cloned.key = vnode.key;\n  cloned.isComment = vnode.isComment;\n  cloned.fnContext = vnode.fnContext;\n  cloned.fnOptions = vnode.fnOptions;\n  cloned.fnScopeId = vnode.fnScopeId;\n  cloned.asyncMeta = vnode.asyncMeta;\n  cloned.isCloned = true;\n  return cloned\n}\n\n/*\n * not type checking this file because flow doesn't play well with\n * dynamically accessing methods on Array prototype\n */\n\nvar arrayProto = Array.prototype;\nvar arrayMethods = Object.create(arrayProto);\n\nvar methodsToPatch = [\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse'\n];\n\n/**\n * Intercept mutating methods and emit events\n */\nmethodsToPatch.forEach(function (method) {\n  // cache original method\n  var original = arrayProto[method];\n  def(arrayMethods, method, function mutator () {\n    var args = [], len = arguments.length;\n    while ( len-- ) args[ len ] = arguments[ len ];\n\n    var result = original.apply(this, args);\n    var ob = this.__ob__;\n    var inserted;\n    switch (method) {\n      case 'push':\n      case 'unshift':\n        inserted = args;\n        break\n      case 'splice':\n        inserted = args.slice(2);\n        break\n    }\n    if (inserted) { ob.observeArray(inserted); }\n    // notify change\n    ob.dep.notify();\n    return result\n  });\n});\n\n/*  */\n\nvar arrayKeys = Object.getOwnPropertyNames(arrayMethods);\n\n/**\n * In some cases we may want to disable observation inside a component's\n * update computation.\n */\nvar shouldObserve = true;\n\nfunction toggleObserving (value) {\n  shouldObserve = value;\n}\n\n/**\n * Observer class that is attached to each observed\n * object. Once attached, the observer converts the target\n * object's property keys into getter/setters that\n * collect dependencies and dispatch updates.\n */\nvar Observer = function Observer (value) {\n  this.value = value;\n  this.dep = new Dep();\n  this.vmCount = 0;\n  def(value, '__ob__', this);\n  if (Array.isArray(value)) {\n    if (hasProto) {\n      protoAugment(value, arrayMethods);\n    } else {\n      copyAugment(value, arrayMethods, arrayKeys);\n    }\n    this.observeArray(value);\n  } else {\n    this.walk(value);\n  }\n};\n\n/**\n * Walk through all properties and convert them into\n * getter/setters. This method should only be called when\n * value type is Object.\n */\nObserver.prototype.walk = function walk (obj) {\n  var keys = Object.keys(obj);\n  for (var i = 0; i < keys.length; i++) {\n    defineReactive$$1(obj, keys[i]);\n  }\n};\n\n/**\n * Observe a list of Array items.\n */\nObserver.prototype.observeArray = function observeArray (items) {\n  for (var i = 0, l = items.length; i < l; i++) {\n    observe(items[i]);\n  }\n};\n\n// helpers\n\n/**\n * Augment a target Object or Array by intercepting\n * the prototype chain using __proto__\n */\nfunction protoAugment (target, src) {\n  /* eslint-disable no-proto */\n  target.__proto__ = src;\n  /* eslint-enable no-proto */\n}\n\n/**\n * Augment a target Object or Array by defining\n * hidden properties.\n */\n/* istanbul ignore next */\nfunction copyAugment (target, src, keys) {\n  for (var i = 0, l = keys.length; i < l; i++) {\n    var key = keys[i];\n    def(target, key, src[key]);\n  }\n}\n\n/**\n * Attempt to create an observer instance for a value,\n * returns the new observer if successfully observed,\n * or the existing observer if the value already has one.\n */\nfunction observe (value, asRootData) {\n  if (!isObject(value) || value instanceof VNode) {\n    return\n  }\n  var ob;\n  if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {\n    ob = value.__ob__;\n  } else if (\n    shouldObserve &&\n    !isServerRendering() &&\n    (Array.isArray(value) || isPlainObject(value)) &&\n    Object.isExtensible(value) &&\n    !value._isVue\n  ) {\n    ob = new Observer(value);\n  }\n  if (asRootData && ob) {\n    ob.vmCount++;\n  }\n  return ob\n}\n\n/**\n * Define a reactive property on an Object.\n */\nfunction defineReactive$$1 (\n  obj,\n  key,\n  val,\n  customSetter,\n  shallow\n) {\n  var dep = new Dep();\n\n  var property = Object.getOwnPropertyDescriptor(obj, key);\n  if (property && property.configurable === false) {\n    return\n  }\n\n  // cater for pre-defined getter/setters\n  var getter = property && property.get;\n  var setter = property && property.set;\n  if ((!getter || setter) && arguments.length === 2) {\n    val = obj[key];\n  }\n\n  var childOb = !shallow && observe(val);\n  Object.defineProperty(obj, key, {\n    enumerable: true,\n    configurable: true,\n    get: function reactiveGetter () {\n      var value = getter ? getter.call(obj) : val;\n      if (Dep.target) {\n        dep.depend();\n        if (childOb) {\n          childOb.dep.depend();\n          if (Array.isArray(value)) {\n            dependArray(value);\n          }\n        }\n      }\n      return value\n    },\n    set: function reactiveSetter (newVal) {\n      var value = getter ? getter.call(obj) : val;\n      /* eslint-disable no-self-compare */\n      if (newVal === value || (newVal !== newVal && value !== value)) {\n        return\n      }\n      /* eslint-enable no-self-compare */\n      if (process.env.NODE_ENV !== 'production' && customSetter) {\n        customSetter();\n      }\n      // #7981: for accessor properties without setter\n      if (getter && !setter) { return }\n      if (setter) {\n        setter.call(obj, newVal);\n      } else {\n        val = newVal;\n      }\n      childOb = !shallow && observe(newVal);\n      dep.notify();\n    }\n  });\n}\n\n/**\n * Set a property on an object. Adds the new property and\n * triggers change notification if the property doesn't\n * already exist.\n */\nfunction set (target, key, val) {\n  if (process.env.NODE_ENV !== 'production' &&\n    (isUndef(target) || isPrimitive(target))\n  ) {\n    warn((\"Cannot set reactive property on undefined, null, or primitive value: \" + ((target))));\n  }\n  if (Array.isArray(target) && isValidArrayIndex(key)) {\n    target.length = Math.max(target.length, key);\n    target.splice(key, 1, val);\n    return val\n  }\n  if (key in target && !(key in Object.prototype)) {\n    target[key] = val;\n    return val\n  }\n  var ob = (target).__ob__;\n  if (target._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid adding reactive properties to a Vue instance or its root $data ' +\n      'at runtime - declare it upfront in the data option.'\n    );\n    return val\n  }\n  if (!ob) {\n    target[key] = val;\n    return val\n  }\n  defineReactive$$1(ob.value, key, val);\n  ob.dep.notify();\n  return val\n}\n\n/**\n * Delete a property and trigger change if necessary.\n */\nfunction del (target, key) {\n  if (process.env.NODE_ENV !== 'production' &&\n    (isUndef(target) || isPrimitive(target))\n  ) {\n    warn((\"Cannot delete reactive property on undefined, null, or primitive value: \" + ((target))));\n  }\n  if (Array.isArray(target) && isValidArrayIndex(key)) {\n    target.splice(key, 1);\n    return\n  }\n  var ob = (target).__ob__;\n  if (target._isVue || (ob && ob.vmCount)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      'Avoid deleting properties on a Vue instance or its root $data ' +\n      '- just set it to null.'\n    );\n    return\n  }\n  if (!hasOwn(target, key)) {\n    return\n  }\n  delete target[key];\n  if (!ob) {\n    return\n  }\n  ob.dep.notify();\n}\n\n/**\n * Collect dependencies on array elements when the array is touched, since\n * we cannot intercept array element access like property getters.\n */\nfunction dependArray (value) {\n  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {\n    e = value[i];\n    e && e.__ob__ && e.__ob__.dep.depend();\n    if (Array.isArray(e)) {\n      dependArray(e);\n    }\n  }\n}\n\n/*  */\n\n/**\n * Option overwriting strategies are functions that handle\n * how to merge a parent option value and a child option\n * value into the final value.\n */\nvar strats = config.optionMergeStrategies;\n\n/**\n * Options with restrictions\n */\nif (process.env.NODE_ENV !== 'production') {\n  strats.el = strats.propsData = function (parent, child, vm, key) {\n    if (!vm) {\n      warn(\n        \"option \\\"\" + key + \"\\\" can only be used during instance \" +\n        'creation with the `new` keyword.'\n      );\n    }\n    return defaultStrat(parent, child)\n  };\n}\n\n/**\n * Helper that recursively merges two data objects together.\n */\nfunction mergeData (to, from) {\n  if (!from) { return to }\n  var key, toVal, fromVal;\n\n  var keys = hasSymbol\n    ? Reflect.ownKeys(from)\n    : Object.keys(from);\n\n  for (var i = 0; i < keys.length; i++) {\n    key = keys[i];\n    // in case the object is already observed...\n    if (key === '__ob__') { continue }\n    toVal = to[key];\n    fromVal = from[key];\n    if (!hasOwn(to, key)) {\n      set(to, key, fromVal);\n    } else if (\n      toVal !== fromVal &&\n      isPlainObject(toVal) &&\n      isPlainObject(fromVal)\n    ) {\n      mergeData(toVal, fromVal);\n    }\n  }\n  return to\n}\n\n/**\n * Data\n */\nfunction mergeDataOrFn (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    // in a Vue.extend merge, both should be functions\n    if (!childVal) {\n      return parentVal\n    }\n    if (!parentVal) {\n      return childVal\n    }\n    // when parentVal & childVal are both present,\n    // we need to return a function that returns the\n    // merged result of both functions... no need to\n    // check if parentVal is a function here because\n    // it has to be a function to pass previous merges.\n    return function mergedDataFn () {\n      return mergeData(\n        typeof childVal === 'function' ? childVal.call(this, this) : childVal,\n        typeof parentVal === 'function' ? parentVal.call(this, this) : parentVal\n      )\n    }\n  } else {\n    return function mergedInstanceDataFn () {\n      // instance merge\n      var instanceData = typeof childVal === 'function'\n        ? childVal.call(vm, vm)\n        : childVal;\n      var defaultData = typeof parentVal === 'function'\n        ? parentVal.call(vm, vm)\n        : parentVal;\n      if (instanceData) {\n        return mergeData(instanceData, defaultData)\n      } else {\n        return defaultData\n      }\n    }\n  }\n}\n\nstrats.data = function (\n  parentVal,\n  childVal,\n  vm\n) {\n  if (!vm) {\n    if (childVal && typeof childVal !== 'function') {\n      process.env.NODE_ENV !== 'production' && warn(\n        'The \"data\" option should be a function ' +\n        'that returns a per-instance value in component ' +\n        'definitions.',\n        vm\n      );\n\n      return parentVal\n    }\n    return mergeDataOrFn(parentVal, childVal)\n  }\n\n  return mergeDataOrFn(parentVal, childVal, vm)\n};\n\n/**\n * Hooks and props are merged as arrays.\n */\nfunction mergeHook (\n  parentVal,\n  childVal\n) {\n  var res = childVal\n    ? parentVal\n      ? parentVal.concat(childVal)\n      : Array.isArray(childVal)\n        ? childVal\n        : [childVal]\n    : parentVal;\n  return res\n    ? dedupeHooks(res)\n    : res\n}\n\nfunction dedupeHooks (hooks) {\n  var res = [];\n  for (var i = 0; i < hooks.length; i++) {\n    if (res.indexOf(hooks[i]) === -1) {\n      res.push(hooks[i]);\n    }\n  }\n  return res\n}\n\nLIFECYCLE_HOOKS.forEach(function (hook) {\n  strats[hook] = mergeHook;\n});\n\n/**\n * Assets\n *\n * When a vm is present (instance creation), we need to do\n * a three-way merge between constructor options, instance\n * options and parent options.\n */\nfunction mergeAssets (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\n  var res = Object.create(parentVal || null);\n  if (childVal) {\n    process.env.NODE_ENV !== 'production' && assertObjectType(key, childVal, vm);\n    return extend(res, childVal)\n  } else {\n    return res\n  }\n}\n\nASSET_TYPES.forEach(function (type) {\n  strats[type + 's'] = mergeAssets;\n});\n\n/**\n * Watchers.\n *\n * Watchers hashes should not overwrite one\n * another, so we merge them as arrays.\n */\nstrats.watch = function (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\n  // work around Firefox's Object.prototype.watch...\n  if (parentVal === nativeWatch) { parentVal = undefined; }\n  if (childVal === nativeWatch) { childVal = undefined; }\n  /* istanbul ignore if */\n  if (!childVal) { return Object.create(parentVal || null) }\n  if (process.env.NODE_ENV !== 'production') {\n    assertObjectType(key, childVal, vm);\n  }\n  if (!parentVal) { return childVal }\n  var ret = {};\n  extend(ret, parentVal);\n  for (var key$1 in childVal) {\n    var parent = ret[key$1];\n    var child = childVal[key$1];\n    if (parent && !Array.isArray(parent)) {\n      parent = [parent];\n    }\n    ret[key$1] = parent\n      ? parent.concat(child)\n      : Array.isArray(child) ? child : [child];\n  }\n  return ret\n};\n\n/**\n * Other object hashes.\n */\nstrats.props =\nstrats.methods =\nstrats.inject =\nstrats.computed = function (\n  parentVal,\n  childVal,\n  vm,\n  key\n) {\n  if (childVal && process.env.NODE_ENV !== 'production') {\n    assertObjectType(key, childVal, vm);\n  }\n  if (!parentVal) { return childVal }\n  var ret = Object.create(null);\n  extend(ret, parentVal);\n  if (childVal) { extend(ret, childVal); }\n  return ret\n};\nstrats.provide = mergeDataOrFn;\n\n/**\n * Default strategy.\n */\nvar defaultStrat = function (parentVal, childVal) {\n  return childVal === undefined\n    ? parentVal\n    : childVal\n};\n\n/**\n * Validate component names\n */\nfunction checkComponents (options) {\n  for (var key in options.components) {\n    validateComponentName(key);\n  }\n}\n\nfunction validateComponentName (name) {\n  if (!new RegExp((\"^[a-zA-Z][\\\\-\\\\.0-9_\" + (unicodeRegExp.source) + \"]*$\")).test(name)) {\n    warn(\n      'Invalid component name: \"' + name + '\". Component names ' +\n      'should conform to valid custom element name in html5 specification.'\n    );\n  }\n  if (isBuiltInTag(name) || config.isReservedTag(name)) {\n    warn(\n      'Do not use built-in or reserved HTML elements as component ' +\n      'id: ' + name\n    );\n  }\n}\n\n/**\n * Ensure all props option syntax are normalized into the\n * Object-based format.\n */\nfunction normalizeProps (options, vm) {\n  var props = options.props;\n  if (!props) { return }\n  var res = {};\n  var i, val, name;\n  if (Array.isArray(props)) {\n    i = props.length;\n    while (i--) {\n      val = props[i];\n      if (typeof val === 'string') {\n        name = camelize(val);\n        res[name] = { type: null };\n      } else if (process.env.NODE_ENV !== 'production') {\n        warn('props must be strings when using array syntax.');\n      }\n    }\n  } else if (isPlainObject(props)) {\n    for (var key in props) {\n      val = props[key];\n      name = camelize(key);\n      res[name] = isPlainObject(val)\n        ? val\n        : { type: val };\n    }\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn(\n      \"Invalid value for option \\\"props\\\": expected an Array or an Object, \" +\n      \"but got \" + (toRawType(props)) + \".\",\n      vm\n    );\n  }\n  options.props = res;\n}\n\n/**\n * Normalize all injections into Object-based format\n */\nfunction normalizeInject (options, vm) {\n  var inject = options.inject;\n  if (!inject) { return }\n  var normalized = options.inject = {};\n  if (Array.isArray(inject)) {\n    for (var i = 0; i < inject.length; i++) {\n      normalized[inject[i]] = { from: inject[i] };\n    }\n  } else if (isPlainObject(inject)) {\n    for (var key in inject) {\n      var val = inject[key];\n      normalized[key] = isPlainObject(val)\n        ? extend({ from: key }, val)\n        : { from: val };\n    }\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn(\n      \"Invalid value for option \\\"inject\\\": expected an Array or an Object, \" +\n      \"but got \" + (toRawType(inject)) + \".\",\n      vm\n    );\n  }\n}\n\n/**\n * Normalize raw function directives into object format.\n */\nfunction normalizeDirectives (options) {\n  var dirs = options.directives;\n  if (dirs) {\n    for (var key in dirs) {\n      var def$$1 = dirs[key];\n      if (typeof def$$1 === 'function') {\n        dirs[key] = { bind: def$$1, update: def$$1 };\n      }\n    }\n  }\n}\n\nfunction assertObjectType (name, value, vm) {\n  if (!isPlainObject(value)) {\n    warn(\n      \"Invalid value for option \\\"\" + name + \"\\\": expected an Object, \" +\n      \"but got \" + (toRawType(value)) + \".\",\n      vm\n    );\n  }\n}\n\n/**\n * Merge two option objects into a new one.\n * Core utility used in both instantiation and inheritance.\n */\nfunction mergeOptions (\n  parent,\n  child,\n  vm\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    checkComponents(child);\n  }\n\n  if (typeof child === 'function') {\n    child = child.options;\n  }\n\n  normalizeProps(child, vm);\n  normalizeInject(child, vm);\n  normalizeDirectives(child);\n\n  // Apply extends and mixins on the child options,\n  // but only if it is a raw options object that isn't\n  // the result of another mergeOptions call.\n  // Only merged options has the _base property.\n  if (!child._base) {\n    if (child.extends) {\n      parent = mergeOptions(parent, child.extends, vm);\n    }\n    if (child.mixins) {\n      for (var i = 0, l = child.mixins.length; i < l; i++) {\n        parent = mergeOptions(parent, child.mixins[i], vm);\n      }\n    }\n  }\n\n  var options = {};\n  var key;\n  for (key in parent) {\n    mergeField(key);\n  }\n  for (key in child) {\n    if (!hasOwn(parent, key)) {\n      mergeField(key);\n    }\n  }\n  function mergeField (key) {\n    var strat = strats[key] || defaultStrat;\n    options[key] = strat(parent[key], child[key], vm, key);\n  }\n  return options\n}\n\n/**\n * Resolve an asset.\n * This function is used because child instances need access\n * to assets defined in its ancestor chain.\n */\nfunction resolveAsset (\n  options,\n  type,\n  id,\n  warnMissing\n) {\n  /* istanbul ignore if */\n  if (typeof id !== 'string') {\n    return\n  }\n  var assets = options[type];\n  // check local registration variations first\n  if (hasOwn(assets, id)) { return assets[id] }\n  var camelizedId = camelize(id);\n  if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }\n  var PascalCaseId = capitalize(camelizedId);\n  if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }\n  // fallback to prototype chain\n  var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];\n  if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {\n    warn(\n      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,\n      options\n    );\n  }\n  return res\n}\n\n/*  */\n\n\n\nfunction validateProp (\n  key,\n  propOptions,\n  propsData,\n  vm\n) {\n  var prop = propOptions[key];\n  var absent = !hasOwn(propsData, key);\n  var value = propsData[key];\n  // boolean casting\n  var booleanIndex = getTypeIndex(Boolean, prop.type);\n  if (booleanIndex > -1) {\n    if (absent && !hasOwn(prop, 'default')) {\n      value = false;\n    } else if (value === '' || value === hyphenate(key)) {\n      // only cast empty string / same name to boolean if\n      // boolean has higher priority\n      var stringIndex = getTypeIndex(String, prop.type);\n      if (stringIndex < 0 || booleanIndex < stringIndex) {\n        value = true;\n      }\n    }\n  }\n  // check default value\n  if (value === undefined) {\n    value = getPropDefaultValue(vm, prop, key);\n    // since the default value is a fresh copy,\n    // make sure to observe it.\n    var prevShouldObserve = shouldObserve;\n    toggleObserving(true);\n    observe(value);\n    toggleObserving(prevShouldObserve);\n  }\n  if (\n    process.env.NODE_ENV !== 'production' &&\n    // skip validation for weex recycle-list child component props\n    !(false)\n  ) {\n    assertProp(prop, key, value, vm, absent);\n  }\n  return value\n}\n\n/**\n * Get the default value of a prop.\n */\nfunction getPropDefaultValue (vm, prop, key) {\n  // no default, return undefined\n  if (!hasOwn(prop, 'default')) {\n    return undefined\n  }\n  var def = prop.default;\n  // warn against non-factory defaults for Object & Array\n  if (process.env.NODE_ENV !== 'production' && isObject(def)) {\n    warn(\n      'Invalid default value for prop \"' + key + '\": ' +\n      'Props with type Object/Array must use a factory function ' +\n      'to return the default value.',\n      vm\n    );\n  }\n  // the raw prop value was also undefined from previous render,\n  // return previous default value to avoid unnecessary watcher trigger\n  if (vm && vm.$options.propsData &&\n    vm.$options.propsData[key] === undefined &&\n    vm._props[key] !== undefined\n  ) {\n    return vm._props[key]\n  }\n  // call factory function for non-Function types\n  // a value is Function if its prototype is function even across different execution context\n  return typeof def === 'function' && getType(prop.type) !== 'Function'\n    ? def.call(vm)\n    : def\n}\n\n/**\n * Assert whether a prop is valid.\n */\nfunction assertProp (\n  prop,\n  name,\n  value,\n  vm,\n  absent\n) {\n  if (prop.required && absent) {\n    warn(\n      'Missing required prop: \"' + name + '\"',\n      vm\n    );\n    return\n  }\n  if (value == null && !prop.required) {\n    return\n  }\n  var type = prop.type;\n  var valid = !type || type === true;\n  var expectedTypes = [];\n  if (type) {\n    if (!Array.isArray(type)) {\n      type = [type];\n    }\n    for (var i = 0; i < type.length && !valid; i++) {\n      var assertedType = assertType(value, type[i]);\n      expectedTypes.push(assertedType.expectedType || '');\n      valid = assertedType.valid;\n    }\n  }\n\n  if (!valid) {\n    warn(\n      getInvalidTypeMessage(name, value, expectedTypes),\n      vm\n    );\n    return\n  }\n  var validator = prop.validator;\n  if (validator) {\n    if (!validator(value)) {\n      warn(\n        'Invalid prop: custom validator check failed for prop \"' + name + '\".',\n        vm\n      );\n    }\n  }\n}\n\nvar simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;\n\nfunction assertType (value, type) {\n  var valid;\n  var expectedType = getType(type);\n  if (simpleCheckRE.test(expectedType)) {\n    var t = typeof value;\n    valid = t === expectedType.toLowerCase();\n    // for primitive wrapper objects\n    if (!valid && t === 'object') {\n      valid = value instanceof type;\n    }\n  } else if (expectedType === 'Object') {\n    valid = isPlainObject(value);\n  } else if (expectedType === 'Array') {\n    valid = Array.isArray(value);\n  } else {\n    valid = value instanceof type;\n  }\n  return {\n    valid: valid,\n    expectedType: expectedType\n  }\n}\n\n/**\n * Use function string name to check built-in types,\n * because a simple equality check will fail when running\n * across different vms / iframes.\n */\nfunction getType (fn) {\n  var match = fn && fn.toString().match(/^\\s*function (\\w+)/);\n  return match ? match[1] : ''\n}\n\nfunction isSameType (a, b) {\n  return getType(a) === getType(b)\n}\n\nfunction getTypeIndex (type, expectedTypes) {\n  if (!Array.isArray(expectedTypes)) {\n    return isSameType(expectedTypes, type) ? 0 : -1\n  }\n  for (var i = 0, len = expectedTypes.length; i < len; i++) {\n    if (isSameType(expectedTypes[i], type)) {\n      return i\n    }\n  }\n  return -1\n}\n\nfunction getInvalidTypeMessage (name, value, expectedTypes) {\n  var message = \"Invalid prop: type check failed for prop \\\"\" + name + \"\\\".\" +\n    \" Expected \" + (expectedTypes.map(capitalize).join(', '));\n  var expectedType = expectedTypes[0];\n  var receivedType = toRawType(value);\n  var expectedValue = styleValue(value, expectedType);\n  var receivedValue = styleValue(value, receivedType);\n  // check if we need to specify expected value\n  if (expectedTypes.length === 1 &&\n      isExplicable(expectedType) &&\n      !isBoolean(expectedType, receivedType)) {\n    message += \" with value \" + expectedValue;\n  }\n  message += \", got \" + receivedType + \" \";\n  // check if we need to specify received value\n  if (isExplicable(receivedType)) {\n    message += \"with value \" + receivedValue + \".\";\n  }\n  return message\n}\n\nfunction styleValue (value, type) {\n  if (type === 'String') {\n    return (\"\\\"\" + value + \"\\\"\")\n  } else if (type === 'Number') {\n    return (\"\" + (Number(value)))\n  } else {\n    return (\"\" + value)\n  }\n}\n\nfunction isExplicable (value) {\n  var explicitTypes = ['string', 'number', 'boolean'];\n  return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })\n}\n\nfunction isBoolean () {\n  var args = [], len = arguments.length;\n  while ( len-- ) args[ len ] = arguments[ len ];\n\n  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })\n}\n\n/*  */\n\nfunction handleError (err, vm, info) {\n  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.\n  // See: https://github.com/vuejs/vuex/issues/1505\n  pushTarget();\n  try {\n    if (vm) {\n      var cur = vm;\n      while ((cur = cur.$parent)) {\n        var hooks = cur.$options.errorCaptured;\n        if (hooks) {\n          for (var i = 0; i < hooks.length; i++) {\n            try {\n              var capture = hooks[i].call(cur, err, vm, info) === false;\n              if (capture) { return }\n            } catch (e) {\n              globalHandleError(e, cur, 'errorCaptured hook');\n            }\n          }\n        }\n      }\n    }\n    globalHandleError(err, vm, info);\n  } finally {\n    popTarget();\n  }\n}\n\nfunction invokeWithErrorHandling (\n  handler,\n  context,\n  args,\n  vm,\n  info\n) {\n  var res;\n  try {\n    res = args ? handler.apply(context, args) : handler.call(context);\n    if (res && !res._isVue && isPromise(res) && !res._handled) {\n      res.catch(function (e) { return handleError(e, vm, info + \" (Promise/async)\"); });\n      // issue #9511\n      // avoid catch triggering multiple times when nested calls\n      res._handled = true;\n    }\n  } catch (e) {\n    handleError(e, vm, info);\n  }\n  return res\n}\n\nfunction globalHandleError (err, vm, info) {\n  if (config.errorHandler) {\n    try {\n      return config.errorHandler.call(null, err, vm, info)\n    } catch (e) {\n      // if the user intentionally throws the original error in the handler,\n      // do not log it twice\n      if (e !== err) {\n        logError(e, null, 'config.errorHandler');\n      }\n    }\n  }\n  logError(err, vm, info);\n}\n\nfunction logError (err, vm, info) {\n  if (process.env.NODE_ENV !== 'production') {\n    warn((\"Error in \" + info + \": \\\"\" + (err.toString()) + \"\\\"\"), vm);\n  }\n  /* istanbul ignore else */\n  if ((inBrowser || inWeex) && typeof console !== 'undefined') {\n    console.error(err);\n  } else {\n    throw err\n  }\n}\n\n/*  */\n\nvar isUsingMicroTask = false;\n\nvar callbacks = [];\nvar pending = false;\n\nfunction flushCallbacks () {\n  pending = false;\n  var copies = callbacks.slice(0);\n  callbacks.length = 0;\n  for (var i = 0; i < copies.length; i++) {\n    copies[i]();\n  }\n}\n\n// Here we have async deferring wrappers using microtasks.\n// In 2.5 we used (macro) tasks (in combination with microtasks).\n// However, it has subtle problems when state is changed right before repaint\n// (e.g. #6813, out-in transitions).\n// Also, using (macro) tasks in event handler would cause some weird behaviors\n// that cannot be circumvented (e.g. #7109, #7153, #7546, #7834, #8109).\n// So we now use microtasks everywhere, again.\n// A major drawback of this tradeoff is that there are some scenarios\n// where microtasks have too high a priority and fire in between supposedly\n// sequential events (e.g. #4521, #6690, which have workarounds)\n// or even between bubbling of the same event (#6566).\nvar timerFunc;\n\n// The nextTick behavior leverages the microtask queue, which can be accessed\n// via either native Promise.then or MutationObserver.\n// MutationObserver has wider support, however it is seriously bugged in\n// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It\n// completely stops working after triggering a few times... so, if native\n// Promise is available, we will use it:\n/* istanbul ignore next, $flow-disable-line */\nif (typeof Promise !== 'undefined' && isNative(Promise)) {\n  var p = Promise.resolve();\n  timerFunc = function () {\n    p.then(flushCallbacks);\n    // In problematic UIWebViews, Promise.then doesn't completely break, but\n    // it can get stuck in a weird state where callbacks are pushed into the\n    // microtask queue but the queue isn't being flushed, until the browser\n    // needs to do some other work, e.g. handle a timer. Therefore we can\n    // \"force\" the microtask queue to be flushed by adding an empty timer.\n    if (isIOS) { setTimeout(noop); }\n  };\n  isUsingMicroTask = true;\n} else if (!isIE && typeof MutationObserver !== 'undefined' && (\n  isNative(MutationObserver) ||\n  // PhantomJS and iOS 7.x\n  MutationObserver.toString() === '[object MutationObserverConstructor]'\n)) {\n  // Use MutationObserver where native Promise is not available,\n  // e.g. PhantomJS, iOS7, Android 4.4\n  // (#6466 MutationObserver is unreliable in IE11)\n  var counter = 1;\n  var observer = new MutationObserver(flushCallbacks);\n  var textNode = document.createTextNode(String(counter));\n  observer.observe(textNode, {\n    characterData: true\n  });\n  timerFunc = function () {\n    counter = (counter + 1) % 2;\n    textNode.data = String(counter);\n  };\n  isUsingMicroTask = true;\n} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {\n  // Fallback to setImmediate.\n  // Technically it leverages the (macro) task queue,\n  // but it is still a better choice than setTimeout.\n  timerFunc = function () {\n    setImmediate(flushCallbacks);\n  };\n} else {\n  // Fallback to setTimeout.\n  timerFunc = function () {\n    setTimeout(flushCallbacks, 0);\n  };\n}\n\nfunction nextTick (cb, ctx) {\n  var _resolve;\n  callbacks.push(function () {\n    if (cb) {\n      try {\n        cb.call(ctx);\n      } catch (e) {\n        handleError(e, ctx, 'nextTick');\n      }\n    } else if (_resolve) {\n      _resolve(ctx);\n    }\n  });\n  if (!pending) {\n    pending = true;\n    timerFunc();\n  }\n  // $flow-disable-line\n  if (!cb && typeof Promise !== 'undefined') {\n    return new Promise(function (resolve) {\n      _resolve = resolve;\n    })\n  }\n}\n\n/*  */\n\nvar mark;\nvar measure;\n\nif (process.env.NODE_ENV !== 'production') {\n  var perf = inBrowser && window.performance;\n  /* istanbul ignore if */\n  if (\n    perf &&\n    perf.mark &&\n    perf.measure &&\n    perf.clearMarks &&\n    perf.clearMeasures\n  ) {\n    mark = function (tag) { return perf.mark(tag); };\n    measure = function (name, startTag, endTag) {\n      perf.measure(name, startTag, endTag);\n      perf.clearMarks(startTag);\n      perf.clearMarks(endTag);\n      // perf.clearMeasures(name)\n    };\n  }\n}\n\n/* not type checking this file because flow doesn't play well with Proxy */\n\nvar initProxy;\n\nif (process.env.NODE_ENV !== 'production') {\n  var allowedGlobals = makeMap(\n    'Infinity,undefined,NaN,isFinite,isNaN,' +\n    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +\n    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +\n    'require' // for Webpack/Browserify\n  );\n\n  var warnNonPresent = function (target, key) {\n    warn(\n      \"Property or method \\\"\" + key + \"\\\" is not defined on the instance but \" +\n      'referenced during render. Make sure that this property is reactive, ' +\n      'either in the data option, or for class-based components, by ' +\n      'initializing the property. ' +\n      'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.',\n      target\n    );\n  };\n\n  var warnReservedPrefix = function (target, key) {\n    warn(\n      \"Property \\\"\" + key + \"\\\" must be accessed with \\\"$data.\" + key + \"\\\" because \" +\n      'properties starting with \"$\" or \"_\" are not proxied in the Vue instance to ' +\n      'prevent conflicts with Vue internals. ' +\n      'See: https://vuejs.org/v2/api/#data',\n      target\n    );\n  };\n\n  var hasProxy =\n    typeof Proxy !== 'undefined' && isNative(Proxy);\n\n  if (hasProxy) {\n    var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta,exact');\n    config.keyCodes = new Proxy(config.keyCodes, {\n      set: function set (target, key, value) {\n        if (isBuiltInModifier(key)) {\n          warn((\"Avoid overwriting built-in modifier in config.keyCodes: .\" + key));\n          return false\n        } else {\n          target[key] = value;\n          return true\n        }\n      }\n    });\n  }\n\n  var hasHandler = {\n    has: function has (target, key) {\n      var has = key in target;\n      var isAllowed = allowedGlobals(key) ||\n        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));\n      if (!has && !isAllowed) {\n        if (key in target.$data) { warnReservedPrefix(target, key); }\n        else { warnNonPresent(target, key); }\n      }\n      return has || !isAllowed\n    }\n  };\n\n  var getHandler = {\n    get: function get (target, key) {\n      if (typeof key === 'string' && !(key in target)) {\n        if (key in target.$data) { warnReservedPrefix(target, key); }\n        else { warnNonPresent(target, key); }\n      }\n      return target[key]\n    }\n  };\n\n  initProxy = function initProxy (vm) {\n    if (hasProxy) {\n      // determine which proxy handler to use\n      var options = vm.$options;\n      var handlers = options.render && options.render._withStripped\n        ? getHandler\n        : hasHandler;\n      vm._renderProxy = new Proxy(vm, handlers);\n    } else {\n      vm._renderProxy = vm;\n    }\n  };\n}\n\n/*  */\n\nvar seenObjects = new _Set();\n\n/**\n * Recursively traverse an object to evoke all converted\n * getters, so that every nested property inside the object\n * is collected as a \"deep\" dependency.\n */\nfunction traverse (val) {\n  _traverse(val, seenObjects);\n  seenObjects.clear();\n}\n\nfunction _traverse (val, seen) {\n  var i, keys;\n  var isA = Array.isArray(val);\n  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {\n    return\n  }\n  if (val.__ob__) {\n    var depId = val.__ob__.dep.id;\n    if (seen.has(depId)) {\n      return\n    }\n    seen.add(depId);\n  }\n  if (isA) {\n    i = val.length;\n    while (i--) { _traverse(val[i], seen); }\n  } else {\n    keys = Object.keys(val);\n    i = keys.length;\n    while (i--) { _traverse(val[keys[i]], seen); }\n  }\n}\n\n/*  */\n\nvar normalizeEvent = cached(function (name) {\n  var passive = name.charAt(0) === '&';\n  name = passive ? name.slice(1) : name;\n  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first\n  name = once$$1 ? name.slice(1) : name;\n  var capture = name.charAt(0) === '!';\n  name = capture ? name.slice(1) : name;\n  return {\n    name: name,\n    once: once$$1,\n    capture: capture,\n    passive: passive\n  }\n});\n\nfunction createFnInvoker (fns, vm) {\n  function invoker () {\n    var arguments$1 = arguments;\n\n    var fns = invoker.fns;\n    if (Array.isArray(fns)) {\n      var cloned = fns.slice();\n      for (var i = 0; i < cloned.length; i++) {\n        invokeWithErrorHandling(cloned[i], null, arguments$1, vm, \"v-on handler\");\n      }\n    } else {\n      // return handler return value for single handlers\n      return invokeWithErrorHandling(fns, null, arguments, vm, \"v-on handler\")\n    }\n  }\n  invoker.fns = fns;\n  return invoker\n}\n\nfunction updateListeners (\n  on,\n  oldOn,\n  add,\n  remove$$1,\n  createOnceHandler,\n  vm\n) {\n  var name, def$$1, cur, old, event;\n  for (name in on) {\n    def$$1 = cur = on[name];\n    old = oldOn[name];\n    event = normalizeEvent(name);\n    if (isUndef(cur)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Invalid handler for event \\\"\" + (event.name) + \"\\\": got \" + String(cur),\n        vm\n      );\n    } else if (isUndef(old)) {\n      if (isUndef(cur.fns)) {\n        cur = on[name] = createFnInvoker(cur, vm);\n      }\n      if (isTrue(event.once)) {\n        cur = on[name] = createOnceHandler(event.name, cur, event.capture);\n      }\n      add(event.name, cur, event.capture, event.passive, event.params);\n    } else if (cur !== old) {\n      old.fns = cur;\n      on[name] = old;\n    }\n  }\n  for (name in oldOn) {\n    if (isUndef(on[name])) {\n      event = normalizeEvent(name);\n      remove$$1(event.name, oldOn[name], event.capture);\n    }\n  }\n}\n\n/*  */\n\nfunction mergeVNodeHook (def, hookKey, hook) {\n  if (def instanceof VNode) {\n    def = def.data.hook || (def.data.hook = {});\n  }\n  var invoker;\n  var oldHook = def[hookKey];\n\n  function wrappedHook () {\n    hook.apply(this, arguments);\n    // important: remove merged hook to ensure it's called only once\n    // and prevent memory leak\n    remove(invoker.fns, wrappedHook);\n  }\n\n  if (isUndef(oldHook)) {\n    // no existing hook\n    invoker = createFnInvoker([wrappedHook]);\n  } else {\n    /* istanbul ignore if */\n    if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {\n      // already a merged invoker\n      invoker = oldHook;\n      invoker.fns.push(wrappedHook);\n    } else {\n      // existing plain hook\n      invoker = createFnInvoker([oldHook, wrappedHook]);\n    }\n  }\n\n  invoker.merged = true;\n  def[hookKey] = invoker;\n}\n\n/*  */\n\nfunction extractPropsFromVNodeData (\n  data,\n  Ctor,\n  tag\n) {\n  // we are only extracting raw values here.\n  // validation and default values are handled in the child\n  // component itself.\n  var propOptions = Ctor.options.props;\n  if (isUndef(propOptions)) {\n    return\n  }\n  var res = {};\n  var attrs = data.attrs;\n  var props = data.props;\n  if (isDef(attrs) || isDef(props)) {\n    for (var key in propOptions) {\n      var altKey = hyphenate(key);\n      if (process.env.NODE_ENV !== 'production') {\n        var keyInLowerCase = key.toLowerCase();\n        if (\n          key !== keyInLowerCase &&\n          attrs && hasOwn(attrs, keyInLowerCase)\n        ) {\n          tip(\n            \"Prop \\\"\" + keyInLowerCase + \"\\\" is passed to component \" +\n            (formatComponentName(tag || Ctor)) + \", but the declared prop name is\" +\n            \" \\\"\" + key + \"\\\". \" +\n            \"Note that HTML attributes are case-insensitive and camelCased \" +\n            \"props need to use their kebab-case equivalents when using in-DOM \" +\n            \"templates. You should probably use \\\"\" + altKey + \"\\\" instead of \\\"\" + key + \"\\\".\"\n          );\n        }\n      }\n      checkProp(res, props, key, altKey, true) ||\n      checkProp(res, attrs, key, altKey, false);\n    }\n  }\n  return res\n}\n\nfunction checkProp (\n  res,\n  hash,\n  key,\n  altKey,\n  preserve\n) {\n  if (isDef(hash)) {\n    if (hasOwn(hash, key)) {\n      res[key] = hash[key];\n      if (!preserve) {\n        delete hash[key];\n      }\n      return true\n    } else if (hasOwn(hash, altKey)) {\n      res[key] = hash[altKey];\n      if (!preserve) {\n        delete hash[altKey];\n      }\n      return true\n    }\n  }\n  return false\n}\n\n/*  */\n\n// The template compiler attempts to minimize the need for normalization by\n// statically analyzing the template at compile time.\n//\n// For plain HTML markup, normalization can be completely skipped because the\n// generated render function is guaranteed to return Array<VNode>. There are\n// two cases where extra normalization is needed:\n\n// 1. When the children contains components - because a functional component\n// may return an Array instead of a single root. In this case, just a simple\n// normalization is needed - if any child is an Array, we flatten the whole\n// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep\n// because functional components already normalize their own children.\nfunction simpleNormalizeChildren (children) {\n  for (var i = 0; i < children.length; i++) {\n    if (Array.isArray(children[i])) {\n      return Array.prototype.concat.apply([], children)\n    }\n  }\n  return children\n}\n\n// 2. When the children contains constructs that always generated nested Arrays,\n// e.g. <template>, <slot>, v-for, or when the children is provided by user\n// with hand-written render functions / JSX. In such cases a full normalization\n// is needed to cater to all possible types of children values.\nfunction normalizeChildren (children) {\n  return isPrimitive(children)\n    ? [createTextVNode(children)]\n    : Array.isArray(children)\n      ? normalizeArrayChildren(children)\n      : undefined\n}\n\nfunction isTextNode (node) {\n  return isDef(node) && isDef(node.text) && isFalse(node.isComment)\n}\n\nfunction normalizeArrayChildren (children, nestedIndex) {\n  var res = [];\n  var i, c, lastIndex, last;\n  for (i = 0; i < children.length; i++) {\n    c = children[i];\n    if (isUndef(c) || typeof c === 'boolean') { continue }\n    lastIndex = res.length - 1;\n    last = res[lastIndex];\n    //  nested\n    if (Array.isArray(c)) {\n      if (c.length > 0) {\n        c = normalizeArrayChildren(c, ((nestedIndex || '') + \"_\" + i));\n        // merge adjacent text nodes\n        if (isTextNode(c[0]) && isTextNode(last)) {\n          res[lastIndex] = createTextVNode(last.text + (c[0]).text);\n          c.shift();\n        }\n        res.push.apply(res, c);\n      }\n    } else if (isPrimitive(c)) {\n      if (isTextNode(last)) {\n        // merge adjacent text nodes\n        // this is necessary for SSR hydration because text nodes are\n        // essentially merged when rendered to HTML strings\n        res[lastIndex] = createTextVNode(last.text + c);\n      } else if (c !== '') {\n        // convert primitive to vnode\n        res.push(createTextVNode(c));\n      }\n    } else {\n      if (isTextNode(c) && isTextNode(last)) {\n        // merge adjacent text nodes\n        res[lastIndex] = createTextVNode(last.text + c.text);\n      } else {\n        // default key for nested array children (likely generated by v-for)\n        if (isTrue(children._isVList) &&\n          isDef(c.tag) &&\n          isUndef(c.key) &&\n          isDef(nestedIndex)) {\n          c.key = \"__vlist\" + nestedIndex + \"_\" + i + \"__\";\n        }\n        res.push(c);\n      }\n    }\n  }\n  return res\n}\n\n/*  */\n\nfunction initProvide (vm) {\n  var provide = vm.$options.provide;\n  if (provide) {\n    vm._provided = typeof provide === 'function'\n      ? provide.call(vm)\n      : provide;\n  }\n}\n\nfunction initInjections (vm) {\n  var result = resolveInject(vm.$options.inject, vm);\n  if (result) {\n    toggleObserving(false);\n    Object.keys(result).forEach(function (key) {\n      /* istanbul ignore else */\n      if (process.env.NODE_ENV !== 'production') {\n        defineReactive$$1(vm, key, result[key], function () {\n          warn(\n            \"Avoid mutating an injected value directly since the changes will be \" +\n            \"overwritten whenever the provided component re-renders. \" +\n            \"injection being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        });\n      } else {\n        defineReactive$$1(vm, key, result[key]);\n      }\n    });\n    toggleObserving(true);\n  }\n}\n\nfunction resolveInject (inject, vm) {\n  if (inject) {\n    // inject is :any because flow is not smart enough to figure out cached\n    var result = Object.create(null);\n    var keys = hasSymbol\n      ? Reflect.ownKeys(inject)\n      : Object.keys(inject);\n\n    for (var i = 0; i < keys.length; i++) {\n      var key = keys[i];\n      // #6574 in case the inject object is observed...\n      if (key === '__ob__') { continue }\n      var provideKey = inject[key].from;\n      var source = vm;\n      while (source) {\n        if (source._provided && hasOwn(source._provided, provideKey)) {\n          result[key] = source._provided[provideKey];\n          break\n        }\n        source = source.$parent;\n      }\n      if (!source) {\n        if ('default' in inject[key]) {\n          var provideDefault = inject[key].default;\n          result[key] = typeof provideDefault === 'function'\n            ? provideDefault.call(vm)\n            : provideDefault;\n        } else if (process.env.NODE_ENV !== 'production') {\n          warn((\"Injection \\\"\" + key + \"\\\" not found\"), vm);\n        }\n      }\n    }\n    return result\n  }\n}\n\n/*  */\n\n\n\n/**\n * Runtime helper for resolving raw children VNodes into a slot object.\n */\nfunction resolveSlots (\n  children,\n  context\n) {\n  if (!children || !children.length) {\n    return {}\n  }\n  var slots = {};\n  for (var i = 0, l = children.length; i < l; i++) {\n    var child = children[i];\n    var data = child.data;\n    // remove slot attribute if the node is resolved as a Vue slot node\n    if (data && data.attrs && data.attrs.slot) {\n      delete data.attrs.slot;\n    }\n    // named slots should only be respected if the vnode was rendered in the\n    // same context.\n    if ((child.context === context || child.fnContext === context) &&\n      data && data.slot != null\n    ) {\n      var name = data.slot;\n      var slot = (slots[name] || (slots[name] = []));\n      if (child.tag === 'template') {\n        slot.push.apply(slot, child.children || []);\n      } else {\n        slot.push(child);\n      }\n    } else {\n      (slots.default || (slots.default = [])).push(child);\n    }\n  }\n  // ignore slots that contains only whitespace\n  for (var name$1 in slots) {\n    if (slots[name$1].every(isWhitespace)) {\n      delete slots[name$1];\n    }\n  }\n  return slots\n}\n\nfunction isWhitespace (node) {\n  return (node.isComment && !node.asyncFactory) || node.text === ' '\n}\n\n/*  */\n\nfunction normalizeScopedSlots (\n  slots,\n  normalSlots,\n  prevSlots\n) {\n  var res;\n  var hasNormalSlots = Object.keys(normalSlots).length > 0;\n  var isStable = slots ? !!slots.$stable : !hasNormalSlots;\n  var key = slots && slots.$key;\n  if (!slots) {\n    res = {};\n  } else if (slots._normalized) {\n    // fast path 1: child component re-render only, parent did not change\n    return slots._normalized\n  } else if (\n    isStable &&\n    prevSlots &&\n    prevSlots !== emptyObject &&\n    key === prevSlots.$key &&\n    !hasNormalSlots &&\n    !prevSlots.$hasNormal\n  ) {\n    // fast path 2: stable scoped slots w/ no normal slots to proxy,\n    // only need to normalize once\n    return prevSlots\n  } else {\n    res = {};\n    for (var key$1 in slots) {\n      if (slots[key$1] && key$1[0] !== '$') {\n        res[key$1] = normalizeScopedSlot(normalSlots, key$1, slots[key$1]);\n      }\n    }\n  }\n  // expose normal slots on scopedSlots\n  for (var key$2 in normalSlots) {\n    if (!(key$2 in res)) {\n      res[key$2] = proxyNormalSlot(normalSlots, key$2);\n    }\n  }\n  // avoriaz seems to mock a non-extensible $scopedSlots object\n  // and when that is passed down this would cause an error\n  if (slots && Object.isExtensible(slots)) {\n    (slots)._normalized = res;\n  }\n  def(res, '$stable', isStable);\n  def(res, '$key', key);\n  def(res, '$hasNormal', hasNormalSlots);\n  return res\n}\n\nfunction normalizeScopedSlot(normalSlots, key, fn) {\n  var normalized = function () {\n    var res = arguments.length ? fn.apply(null, arguments) : fn({});\n    res = res && typeof res === 'object' && !Array.isArray(res)\n      ? [res] // single vnode\n      : normalizeChildren(res);\n    return res && (\n      res.length === 0 ||\n      (res.length === 1 && res[0].isComment) // #9658\n    ) ? undefined\n      : res\n  };\n  // this is a slot using the new v-slot syntax without scope. although it is\n  // compiled as a scoped slot, render fn users would expect it to be present\n  // on this.$slots because the usage is semantically a normal slot.\n  if (fn.proxy) {\n    Object.defineProperty(normalSlots, key, {\n      get: normalized,\n      enumerable: true,\n      configurable: true\n    });\n  }\n  return normalized\n}\n\nfunction proxyNormalSlot(slots, key) {\n  return function () { return slots[key]; }\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering v-for lists.\n */\nfunction renderList (\n  val,\n  render\n) {\n  var ret, i, l, keys, key;\n  if (Array.isArray(val) || typeof val === 'string') {\n    ret = new Array(val.length);\n    for (i = 0, l = val.length; i < l; i++) {\n      ret[i] = render(val[i], i);\n    }\n  } else if (typeof val === 'number') {\n    ret = new Array(val);\n    for (i = 0; i < val; i++) {\n      ret[i] = render(i + 1, i);\n    }\n  } else if (isObject(val)) {\n    if (hasSymbol && val[Symbol.iterator]) {\n      ret = [];\n      var iterator = val[Symbol.iterator]();\n      var result = iterator.next();\n      while (!result.done) {\n        ret.push(render(result.value, ret.length));\n        result = iterator.next();\n      }\n    } else {\n      keys = Object.keys(val);\n      ret = new Array(keys.length);\n      for (i = 0, l = keys.length; i < l; i++) {\n        key = keys[i];\n        ret[i] = render(val[key], key, i);\n      }\n    }\n  }\n  if (!isDef(ret)) {\n    ret = [];\n  }\n  (ret)._isVList = true;\n  return ret\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering <slot>\n */\nfunction renderSlot (\n  name,\n  fallback,\n  props,\n  bindObject\n) {\n  var scopedSlotFn = this.$scopedSlots[name];\n  var nodes;\n  if (scopedSlotFn) { // scoped slot\n    props = props || {};\n    if (bindObject) {\n      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {\n        warn(\n          'slot v-bind without argument expects an Object',\n          this\n        );\n      }\n      props = extend(extend({}, bindObject), props);\n    }\n    nodes = scopedSlotFn(props) || fallback;\n  } else {\n    nodes = this.$slots[name] || fallback;\n  }\n\n  var target = props && props.slot;\n  if (target) {\n    return this.$createElement('template', { slot: target }, nodes)\n  } else {\n    return nodes\n  }\n}\n\n/*  */\n\n/**\n * Runtime helper for resolving filters\n */\nfunction resolveFilter (id) {\n  return resolveAsset(this.$options, 'filters', id, true) || identity\n}\n\n/*  */\n\nfunction isKeyNotMatch (expect, actual) {\n  if (Array.isArray(expect)) {\n    return expect.indexOf(actual) === -1\n  } else {\n    return expect !== actual\n  }\n}\n\n/**\n * Runtime helper for checking keyCodes from config.\n * exposed as Vue.prototype._k\n * passing in eventKeyName as last argument separately for backwards compat\n */\nfunction checkKeyCodes (\n  eventKeyCode,\n  key,\n  builtInKeyCode,\n  eventKeyName,\n  builtInKeyName\n) {\n  var mappedKeyCode = config.keyCodes[key] || builtInKeyCode;\n  if (builtInKeyName && eventKeyName && !config.keyCodes[key]) {\n    return isKeyNotMatch(builtInKeyName, eventKeyName)\n  } else if (mappedKeyCode) {\n    return isKeyNotMatch(mappedKeyCode, eventKeyCode)\n  } else if (eventKeyName) {\n    return hyphenate(eventKeyName) !== key\n  }\n}\n\n/*  */\n\n/**\n * Runtime helper for merging v-bind=\"object\" into a VNode's data.\n */\nfunction bindObjectProps (\n  data,\n  tag,\n  value,\n  asProp,\n  isSync\n) {\n  if (value) {\n    if (!isObject(value)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'v-bind without argument expects an Object or Array value',\n        this\n      );\n    } else {\n      if (Array.isArray(value)) {\n        value = toObject(value);\n      }\n      var hash;\n      var loop = function ( key ) {\n        if (\n          key === 'class' ||\n          key === 'style' ||\n          isReservedAttribute(key)\n        ) {\n          hash = data;\n        } else {\n          var type = data.attrs && data.attrs.type;\n          hash = asProp || config.mustUseProp(tag, type, key)\n            ? data.domProps || (data.domProps = {})\n            : data.attrs || (data.attrs = {});\n        }\n        var camelizedKey = camelize(key);\n        var hyphenatedKey = hyphenate(key);\n        if (!(camelizedKey in hash) && !(hyphenatedKey in hash)) {\n          hash[key] = value[key];\n\n          if (isSync) {\n            var on = data.on || (data.on = {});\n            on[(\"update:\" + key)] = function ($event) {\n              value[key] = $event;\n            };\n          }\n        }\n      };\n\n      for (var key in value) loop( key );\n    }\n  }\n  return data\n}\n\n/*  */\n\n/**\n * Runtime helper for rendering static trees.\n */\nfunction renderStatic (\n  index,\n  isInFor\n) {\n  var cached = this._staticTrees || (this._staticTrees = []);\n  var tree = cached[index];\n  // if has already-rendered static tree and not inside v-for,\n  // we can reuse the same tree.\n  if (tree && !isInFor) {\n    return tree\n  }\n  // otherwise, render a fresh tree.\n  tree = cached[index] = this.$options.staticRenderFns[index].call(\n    this._renderProxy,\n    null,\n    this // for render fns generated for functional component templates\n  );\n  markStatic(tree, (\"__static__\" + index), false);\n  return tree\n}\n\n/**\n * Runtime helper for v-once.\n * Effectively it means marking the node as static with a unique key.\n */\nfunction markOnce (\n  tree,\n  index,\n  key\n) {\n  markStatic(tree, (\"__once__\" + index + (key ? (\"_\" + key) : \"\")), true);\n  return tree\n}\n\nfunction markStatic (\n  tree,\n  key,\n  isOnce\n) {\n  if (Array.isArray(tree)) {\n    for (var i = 0; i < tree.length; i++) {\n      if (tree[i] && typeof tree[i] !== 'string') {\n        markStaticNode(tree[i], (key + \"_\" + i), isOnce);\n      }\n    }\n  } else {\n    markStaticNode(tree, key, isOnce);\n  }\n}\n\nfunction markStaticNode (node, key, isOnce) {\n  node.isStatic = true;\n  node.key = key;\n  node.isOnce = isOnce;\n}\n\n/*  */\n\nfunction bindObjectListeners (data, value) {\n  if (value) {\n    if (!isPlainObject(value)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'v-on without argument expects an Object value',\n        this\n      );\n    } else {\n      var on = data.on = data.on ? extend({}, data.on) : {};\n      for (var key in value) {\n        var existing = on[key];\n        var ours = value[key];\n        on[key] = existing ? [].concat(existing, ours) : ours;\n      }\n    }\n  }\n  return data\n}\n\n/*  */\n\nfunction resolveScopedSlots (\n  fns, // see flow/vnode\n  res,\n  // the following are added in 2.6\n  hasDynamicKeys,\n  contentHashKey\n) {\n  res = res || { $stable: !hasDynamicKeys };\n  for (var i = 0; i < fns.length; i++) {\n    var slot = fns[i];\n    if (Array.isArray(slot)) {\n      resolveScopedSlots(slot, res, hasDynamicKeys);\n    } else if (slot) {\n      // marker for reverse proxying v-slot without scope on this.$slots\n      if (slot.proxy) {\n        slot.fn.proxy = true;\n      }\n      res[slot.key] = slot.fn;\n    }\n  }\n  if (contentHashKey) {\n    (res).$key = contentHashKey;\n  }\n  return res\n}\n\n/*  */\n\nfunction bindDynamicKeys (baseObj, values) {\n  for (var i = 0; i < values.length; i += 2) {\n    var key = values[i];\n    if (typeof key === 'string' && key) {\n      baseObj[values[i]] = values[i + 1];\n    } else if (process.env.NODE_ENV !== 'production' && key !== '' && key !== null) {\n      // null is a special value for explicitly removing a binding\n      warn(\n        (\"Invalid value for dynamic directive argument (expected string or null): \" + key),\n        this\n      );\n    }\n  }\n  return baseObj\n}\n\n// helper to dynamically append modifier runtime markers to event names.\n// ensure only append when value is already string, otherwise it will be cast\n// to string and cause the type check to miss.\nfunction prependModifier (value, symbol) {\n  return typeof value === 'string' ? symbol + value : value\n}\n\n/*  */\n\nfunction installRenderHelpers (target) {\n  target._o = markOnce;\n  target._n = toNumber;\n  target._s = toString;\n  target._l = renderList;\n  target._t = renderSlot;\n  target._q = looseEqual;\n  target._i = looseIndexOf;\n  target._m = renderStatic;\n  target._f = resolveFilter;\n  target._k = checkKeyCodes;\n  target._b = bindObjectProps;\n  target._v = createTextVNode;\n  target._e = createEmptyVNode;\n  target._u = resolveScopedSlots;\n  target._g = bindObjectListeners;\n  target._d = bindDynamicKeys;\n  target._p = prependModifier;\n}\n\n/*  */\n\nfunction FunctionalRenderContext (\n  data,\n  props,\n  children,\n  parent,\n  Ctor\n) {\n  var this$1 = this;\n\n  var options = Ctor.options;\n  // ensure the createElement function in functional components\n  // gets a unique context - this is necessary for correct named slot check\n  var contextVm;\n  if (hasOwn(parent, '_uid')) {\n    contextVm = Object.create(parent);\n    // $flow-disable-line\n    contextVm._original = parent;\n  } else {\n    // the context vm passed in is a functional context as well.\n    // in this case we want to make sure we are able to get a hold to the\n    // real context instance.\n    contextVm = parent;\n    // $flow-disable-line\n    parent = parent._original;\n  }\n  var isCompiled = isTrue(options._compiled);\n  var needNormalization = !isCompiled;\n\n  this.data = data;\n  this.props = props;\n  this.children = children;\n  this.parent = parent;\n  this.listeners = data.on || emptyObject;\n  this.injections = resolveInject(options.inject, parent);\n  this.slots = function () {\n    if (!this$1.$slots) {\n      normalizeScopedSlots(\n        data.scopedSlots,\n        this$1.$slots = resolveSlots(children, parent)\n      );\n    }\n    return this$1.$slots\n  };\n\n  Object.defineProperty(this, 'scopedSlots', ({\n    enumerable: true,\n    get: function get () {\n      return normalizeScopedSlots(data.scopedSlots, this.slots())\n    }\n  }));\n\n  // support for compiled functional template\n  if (isCompiled) {\n    // exposing $options for renderStatic()\n    this.$options = options;\n    // pre-resolve slots for renderSlot()\n    this.$slots = this.slots();\n    this.$scopedSlots = normalizeScopedSlots(data.scopedSlots, this.$slots);\n  }\n\n  if (options._scopeId) {\n    this._c = function (a, b, c, d) {\n      var vnode = createElement(contextVm, a, b, c, d, needNormalization);\n      if (vnode && !Array.isArray(vnode)) {\n        vnode.fnScopeId = options._scopeId;\n        vnode.fnContext = parent;\n      }\n      return vnode\n    };\n  } else {\n    this._c = function (a, b, c, d) { return createElement(contextVm, a, b, c, d, needNormalization); };\n  }\n}\n\ninstallRenderHelpers(FunctionalRenderContext.prototype);\n\nfunction createFunctionalComponent (\n  Ctor,\n  propsData,\n  data,\n  contextVm,\n  children\n) {\n  var options = Ctor.options;\n  var props = {};\n  var propOptions = options.props;\n  if (isDef(propOptions)) {\n    for (var key in propOptions) {\n      props[key] = validateProp(key, propOptions, propsData || emptyObject);\n    }\n  } else {\n    if (isDef(data.attrs)) { mergeProps(props, data.attrs); }\n    if (isDef(data.props)) { mergeProps(props, data.props); }\n  }\n\n  var renderContext = new FunctionalRenderContext(\n    data,\n    props,\n    children,\n    contextVm,\n    Ctor\n  );\n\n  var vnode = options.render.call(null, renderContext._c, renderContext);\n\n  if (vnode instanceof VNode) {\n    return cloneAndMarkFunctionalResult(vnode, data, renderContext.parent, options, renderContext)\n  } else if (Array.isArray(vnode)) {\n    var vnodes = normalizeChildren(vnode) || [];\n    var res = new Array(vnodes.length);\n    for (var i = 0; i < vnodes.length; i++) {\n      res[i] = cloneAndMarkFunctionalResult(vnodes[i], data, renderContext.parent, options, renderContext);\n    }\n    return res\n  }\n}\n\nfunction cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {\n  // #7817 clone node before setting fnContext, otherwise if the node is reused\n  // (e.g. it was from a cached normal slot) the fnContext causes named slots\n  // that should not be matched to match.\n  var clone = cloneVNode(vnode);\n  clone.fnContext = contextVm;\n  clone.fnOptions = options;\n  if (process.env.NODE_ENV !== 'production') {\n    (clone.devtoolsMeta = clone.devtoolsMeta || {}).renderContext = renderContext;\n  }\n  if (data.slot) {\n    (clone.data || (clone.data = {})).slot = data.slot;\n  }\n  return clone\n}\n\nfunction mergeProps (to, from) {\n  for (var key in from) {\n    to[camelize(key)] = from[key];\n  }\n}\n\n/*  */\n\n/*  */\n\n/*  */\n\n/*  */\n\n// inline hooks to be invoked on component VNodes during patch\nvar componentVNodeHooks = {\n  init: function init (vnode, hydrating) {\n    if (\n      vnode.componentInstance &&\n      !vnode.componentInstance._isDestroyed &&\n      vnode.data.keepAlive\n    ) {\n      // kept-alive components, treat as a patch\n      var mountedNode = vnode; // work around flow\n      componentVNodeHooks.prepatch(mountedNode, mountedNode);\n    } else {\n      var child = vnode.componentInstance = createComponentInstanceForVnode(\n        vnode,\n        activeInstance\n      );\n      child.$mount(hydrating ? vnode.elm : undefined, hydrating);\n    }\n  },\n\n  prepatch: function prepatch (oldVnode, vnode) {\n    var options = vnode.componentOptions;\n    var child = vnode.componentInstance = oldVnode.componentInstance;\n    updateChildComponent(\n      child,\n      options.propsData, // updated props\n      options.listeners, // updated listeners\n      vnode, // new parent vnode\n      options.children // new children\n    );\n  },\n\n  insert: function insert (vnode) {\n    var context = vnode.context;\n    var componentInstance = vnode.componentInstance;\n    if (!componentInstance._isMounted) {\n      componentInstance._isMounted = true;\n      callHook(componentInstance, 'mounted');\n    }\n    if (vnode.data.keepAlive) {\n      if (context._isMounted) {\n        // vue-router#1212\n        // During updates, a kept-alive component's child components may\n        // change, so directly walking the tree here may call activated hooks\n        // on incorrect children. Instead we push them into a queue which will\n        // be processed after the whole patch process ended.\n        queueActivatedComponent(componentInstance);\n      } else {\n        activateChildComponent(componentInstance, true /* direct */);\n      }\n    }\n  },\n\n  destroy: function destroy (vnode) {\n    var componentInstance = vnode.componentInstance;\n    if (!componentInstance._isDestroyed) {\n      if (!vnode.data.keepAlive) {\n        componentInstance.$destroy();\n      } else {\n        deactivateChildComponent(componentInstance, true /* direct */);\n      }\n    }\n  }\n};\n\nvar hooksToMerge = Object.keys(componentVNodeHooks);\n\nfunction createComponent (\n  Ctor,\n  data,\n  context,\n  children,\n  tag\n) {\n  if (isUndef(Ctor)) {\n    return\n  }\n\n  var baseCtor = context.$options._base;\n\n  // plain options object: turn it into a constructor\n  if (isObject(Ctor)) {\n    Ctor = baseCtor.extend(Ctor);\n  }\n\n  // if at this stage it's not a constructor or an async component factory,\n  // reject.\n  if (typeof Ctor !== 'function') {\n    if (process.env.NODE_ENV !== 'production') {\n      warn((\"Invalid Component definition: \" + (String(Ctor))), context);\n    }\n    return\n  }\n\n  // async component\n  var asyncFactory;\n  if (isUndef(Ctor.cid)) {\n    asyncFactory = Ctor;\n    Ctor = resolveAsyncComponent(asyncFactory, baseCtor);\n    if (Ctor === undefined) {\n      // return a placeholder node for async component, which is rendered\n      // as a comment node but preserves all the raw information for the node.\n      // the information will be used for async server-rendering and hydration.\n      return createAsyncPlaceholder(\n        asyncFactory,\n        data,\n        context,\n        children,\n        tag\n      )\n    }\n  }\n\n  data = data || {};\n\n  // resolve constructor options in case global mixins are applied after\n  // component constructor creation\n  resolveConstructorOptions(Ctor);\n\n  // transform component v-model data into props & events\n  if (isDef(data.model)) {\n    transformModel(Ctor.options, data);\n  }\n\n  // extract props\n  var propsData = extractPropsFromVNodeData(data, Ctor, tag);\n\n  // functional component\n  if (isTrue(Ctor.options.functional)) {\n    return createFunctionalComponent(Ctor, propsData, data, context, children)\n  }\n\n  // extract listeners, since these needs to be treated as\n  // child component listeners instead of DOM listeners\n  var listeners = data.on;\n  // replace with listeners with .native modifier\n  // so it gets processed during parent component patch.\n  data.on = data.nativeOn;\n\n  if (isTrue(Ctor.options.abstract)) {\n    // abstract components do not keep anything\n    // other than props & listeners & slot\n\n    // work around flow\n    var slot = data.slot;\n    data = {};\n    if (slot) {\n      data.slot = slot;\n    }\n  }\n\n  // install component management hooks onto the placeholder node\n  installComponentHooks(data);\n\n  // return a placeholder vnode\n  var name = Ctor.options.name || tag;\n  var vnode = new VNode(\n    (\"vue-component-\" + (Ctor.cid) + (name ? (\"-\" + name) : '')),\n    data, undefined, undefined, undefined, context,\n    { Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },\n    asyncFactory\n  );\n\n  return vnode\n}\n\nfunction createComponentInstanceForVnode (\n  vnode, // we know it's MountedComponentVNode but flow doesn't\n  parent // activeInstance in lifecycle state\n) {\n  var options = {\n    _isComponent: true,\n    _parentVnode: vnode,\n    parent: parent\n  };\n  // check inline-template render functions\n  var inlineTemplate = vnode.data.inlineTemplate;\n  if (isDef(inlineTemplate)) {\n    options.render = inlineTemplate.render;\n    options.staticRenderFns = inlineTemplate.staticRenderFns;\n  }\n  return new vnode.componentOptions.Ctor(options)\n}\n\nfunction installComponentHooks (data) {\n  var hooks = data.hook || (data.hook = {});\n  for (var i = 0; i < hooksToMerge.length; i++) {\n    var key = hooksToMerge[i];\n    var existing = hooks[key];\n    var toMerge = componentVNodeHooks[key];\n    if (existing !== toMerge && !(existing && existing._merged)) {\n      hooks[key] = existing ? mergeHook$1(toMerge, existing) : toMerge;\n    }\n  }\n}\n\nfunction mergeHook$1 (f1, f2) {\n  var merged = function (a, b) {\n    // flow complains about extra args which is why we use any\n    f1(a, b);\n    f2(a, b);\n  };\n  merged._merged = true;\n  return merged\n}\n\n// transform component v-model info (value and callback) into\n// prop and event handler respectively.\nfunction transformModel (options, data) {\n  var prop = (options.model && options.model.prop) || 'value';\n  var event = (options.model && options.model.event) || 'input'\n  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;\n  var on = data.on || (data.on = {});\n  var existing = on[event];\n  var callback = data.model.callback;\n  if (isDef(existing)) {\n    if (\n      Array.isArray(existing)\n        ? existing.indexOf(callback) === -1\n        : existing !== callback\n    ) {\n      on[event] = [callback].concat(existing);\n    }\n  } else {\n    on[event] = callback;\n  }\n}\n\n/*  */\n\nvar SIMPLE_NORMALIZE = 1;\nvar ALWAYS_NORMALIZE = 2;\n\n// wrapper function for providing a more flexible interface\n// without getting yelled at by flow\nfunction createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType,\n  alwaysNormalize\n) {\n  if (Array.isArray(data) || isPrimitive(data)) {\n    normalizationType = children;\n    children = data;\n    data = undefined;\n  }\n  if (isTrue(alwaysNormalize)) {\n    normalizationType = ALWAYS_NORMALIZE;\n  }\n  return _createElement(context, tag, data, children, normalizationType)\n}\n\nfunction _createElement (\n  context,\n  tag,\n  data,\n  children,\n  normalizationType\n) {\n  if (isDef(data) && isDef((data).__ob__)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Avoid using observed data object as vnode data: \" + (JSON.stringify(data)) + \"\\n\" +\n      'Always create fresh vnode data objects in each render!',\n      context\n    );\n    return createEmptyVNode()\n  }\n  // object syntax in v-bind\n  if (isDef(data) && isDef(data.is)) {\n    tag = data.is;\n  }\n  if (!tag) {\n    // in case of component :is set to falsy value\n    return createEmptyVNode()\n  }\n  // warn against non-primitive key\n  if (process.env.NODE_ENV !== 'production' &&\n    isDef(data) && isDef(data.key) && !isPrimitive(data.key)\n  ) {\n    {\n      warn(\n        'Avoid using non-primitive value as key, ' +\n        'use string/number value instead.',\n        context\n      );\n    }\n  }\n  // support single function children as default scoped slot\n  if (Array.isArray(children) &&\n    typeof children[0] === 'function'\n  ) {\n    data = data || {};\n    data.scopedSlots = { default: children[0] };\n    children.length = 0;\n  }\n  if (normalizationType === ALWAYS_NORMALIZE) {\n    children = normalizeChildren(children);\n  } else if (normalizationType === SIMPLE_NORMALIZE) {\n    children = simpleNormalizeChildren(children);\n  }\n  var vnode, ns;\n  if (typeof tag === 'string') {\n    var Ctor;\n    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);\n    if (config.isReservedTag(tag)) {\n      // platform built-in elements\n      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {\n        warn(\n          (\"The .native modifier for v-on is only valid on components but it was used on <\" + tag + \">.\"),\n          context\n        );\n      }\n      vnode = new VNode(\n        config.parsePlatformTagName(tag), data, children,\n        undefined, undefined, context\n      );\n    } else if ((!data || !data.pre) && isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {\n      // component\n      vnode = createComponent(Ctor, data, context, children, tag);\n    } else {\n      // unknown or unlisted namespaced elements\n      // check at runtime because it may get assigned a namespace when its\n      // parent normalizes children\n      vnode = new VNode(\n        tag, data, children,\n        undefined, undefined, context\n      );\n    }\n  } else {\n    // direct component options / constructor\n    vnode = createComponent(tag, data, context, children);\n  }\n  if (Array.isArray(vnode)) {\n    return vnode\n  } else if (isDef(vnode)) {\n    if (isDef(ns)) { applyNS(vnode, ns); }\n    if (isDef(data)) { registerDeepBindings(data); }\n    return vnode\n  } else {\n    return createEmptyVNode()\n  }\n}\n\nfunction applyNS (vnode, ns, force) {\n  vnode.ns = ns;\n  if (vnode.tag === 'foreignObject') {\n    // use default namespace inside foreignObject\n    ns = undefined;\n    force = true;\n  }\n  if (isDef(vnode.children)) {\n    for (var i = 0, l = vnode.children.length; i < l; i++) {\n      var child = vnode.children[i];\n      if (isDef(child.tag) && (\n        isUndef(child.ns) || (isTrue(force) && child.tag !== 'svg'))) {\n        applyNS(child, ns, force);\n      }\n    }\n  }\n}\n\n// ref #5318\n// necessary to ensure parent re-render when deep bindings like :style and\n// :class are used on slot nodes\nfunction registerDeepBindings (data) {\n  if (isObject(data.style)) {\n    traverse(data.style);\n  }\n  if (isObject(data.class)) {\n    traverse(data.class);\n  }\n}\n\n/*  */\n\nfunction initRender (vm) {\n  vm._vnode = null; // the root of the child tree\n  vm._staticTrees = null; // v-once cached trees\n  var options = vm.$options;\n  var parentVnode = vm.$vnode = options._parentVnode; // the placeholder node in parent tree\n  var renderContext = parentVnode && parentVnode.context;\n  vm.$slots = resolveSlots(options._renderChildren, renderContext);\n  vm.$scopedSlots = emptyObject;\n  // bind the createElement fn to this instance\n  // so that we get proper render context inside it.\n  // args order: tag, data, children, normalizationType, alwaysNormalize\n  // internal version is used by render functions compiled from templates\n  vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };\n  // normalization is always applied for the public version, used in\n  // user-written render functions.\n  vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };\n\n  // $attrs & $listeners are exposed for easier HOC creation.\n  // they need to be reactive so that HOCs using them are always updated\n  var parentData = parentVnode && parentVnode.data;\n\n  /* istanbul ignore else */\n  if (process.env.NODE_ENV !== 'production') {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {\n      !isUpdatingChildComponent && warn(\"$attrs is readonly.\", vm);\n    }, true);\n    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {\n      !isUpdatingChildComponent && warn(\"$listeners is readonly.\", vm);\n    }, true);\n  } else {\n    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, null, true);\n    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, null, true);\n  }\n}\n\nvar currentRenderingInstance = null;\n\nfunction renderMixin (Vue) {\n  // install runtime convenience helpers\n  installRenderHelpers(Vue.prototype);\n\n  Vue.prototype.$nextTick = function (fn) {\n    return nextTick(fn, this)\n  };\n\n  Vue.prototype._render = function () {\n    var vm = this;\n    var ref = vm.$options;\n    var render = ref.render;\n    var _parentVnode = ref._parentVnode;\n\n    if (_parentVnode) {\n      vm.$scopedSlots = normalizeScopedSlots(\n        _parentVnode.data.scopedSlots,\n        vm.$slots,\n        vm.$scopedSlots\n      );\n    }\n\n    // set parent vnode. this allows render functions to have access\n    // to the data on the placeholder node.\n    vm.$vnode = _parentVnode;\n    // render self\n    var vnode;\n    try {\n      // There's no need to maintain a stack because all render fns are called\n      // separately from one another. Nested component's render fns are called\n      // when parent component is patched.\n      currentRenderingInstance = vm;\n      vnode = render.call(vm._renderProxy, vm.$createElement);\n    } catch (e) {\n      handleError(e, vm, \"render\");\n      // return error render result,\n      // or previous vnode to prevent render error causing blank component\n      /* istanbul ignore else */\n      if (process.env.NODE_ENV !== 'production' && vm.$options.renderError) {\n        try {\n          vnode = vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e);\n        } catch (e) {\n          handleError(e, vm, \"renderError\");\n          vnode = vm._vnode;\n        }\n      } else {\n        vnode = vm._vnode;\n      }\n    } finally {\n      currentRenderingInstance = null;\n    }\n    // if the returned array contains only a single node, allow it\n    if (Array.isArray(vnode) && vnode.length === 1) {\n      vnode = vnode[0];\n    }\n    // return empty vnode in case the render function errored out\n    if (!(vnode instanceof VNode)) {\n      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {\n        warn(\n          'Multiple root nodes returned from render function. Render function ' +\n          'should return a single root node.',\n          vm\n        );\n      }\n      vnode = createEmptyVNode();\n    }\n    // set parent\n    vnode.parent = _parentVnode;\n    return vnode\n  };\n}\n\n/*  */\n\nfunction ensureCtor (comp, base) {\n  if (\n    comp.__esModule ||\n    (hasSymbol && comp[Symbol.toStringTag] === 'Module')\n  ) {\n    comp = comp.default;\n  }\n  return isObject(comp)\n    ? base.extend(comp)\n    : comp\n}\n\nfunction createAsyncPlaceholder (\n  factory,\n  data,\n  context,\n  children,\n  tag\n) {\n  var node = createEmptyVNode();\n  node.asyncFactory = factory;\n  node.asyncMeta = { data: data, context: context, children: children, tag: tag };\n  return node\n}\n\nfunction resolveAsyncComponent (\n  factory,\n  baseCtor\n) {\n  if (isTrue(factory.error) && isDef(factory.errorComp)) {\n    return factory.errorComp\n  }\n\n  if (isDef(factory.resolved)) {\n    return factory.resolved\n  }\n\n  var owner = currentRenderingInstance;\n  if (owner && isDef(factory.owners) && factory.owners.indexOf(owner) === -1) {\n    // already pending\n    factory.owners.push(owner);\n  }\n\n  if (isTrue(factory.loading) && isDef(factory.loadingComp)) {\n    return factory.loadingComp\n  }\n\n  if (owner && !isDef(factory.owners)) {\n    var owners = factory.owners = [owner];\n    var sync = true;\n    var timerLoading = null;\n    var timerTimeout = null\n\n    ;(owner).$on('hook:destroyed', function () { return remove(owners, owner); });\n\n    var forceRender = function (renderCompleted) {\n      for (var i = 0, l = owners.length; i < l; i++) {\n        (owners[i]).$forceUpdate();\n      }\n\n      if (renderCompleted) {\n        owners.length = 0;\n        if (timerLoading !== null) {\n          clearTimeout(timerLoading);\n          timerLoading = null;\n        }\n        if (timerTimeout !== null) {\n          clearTimeout(timerTimeout);\n          timerTimeout = null;\n        }\n      }\n    };\n\n    var resolve = once(function (res) {\n      // cache resolved\n      factory.resolved = ensureCtor(res, baseCtor);\n      // invoke callbacks only if this is not a synchronous resolve\n      // (async resolves are shimmed as synchronous during SSR)\n      if (!sync) {\n        forceRender(true);\n      } else {\n        owners.length = 0;\n      }\n    });\n\n    var reject = once(function (reason) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed to resolve async component: \" + (String(factory)) +\n        (reason ? (\"\\nReason: \" + reason) : '')\n      );\n      if (isDef(factory.errorComp)) {\n        factory.error = true;\n        forceRender(true);\n      }\n    });\n\n    var res = factory(resolve, reject);\n\n    if (isObject(res)) {\n      if (isPromise(res)) {\n        // () => Promise\n        if (isUndef(factory.resolved)) {\n          res.then(resolve, reject);\n        }\n      } else if (isPromise(res.component)) {\n        res.component.then(resolve, reject);\n\n        if (isDef(res.error)) {\n          factory.errorComp = ensureCtor(res.error, baseCtor);\n        }\n\n        if (isDef(res.loading)) {\n          factory.loadingComp = ensureCtor(res.loading, baseCtor);\n          if (res.delay === 0) {\n            factory.loading = true;\n          } else {\n            timerLoading = setTimeout(function () {\n              timerLoading = null;\n              if (isUndef(factory.resolved) && isUndef(factory.error)) {\n                factory.loading = true;\n                forceRender(false);\n              }\n            }, res.delay || 200);\n          }\n        }\n\n        if (isDef(res.timeout)) {\n          timerTimeout = setTimeout(function () {\n            timerTimeout = null;\n            if (isUndef(factory.resolved)) {\n              reject(\n                process.env.NODE_ENV !== 'production'\n                  ? (\"timeout (\" + (res.timeout) + \"ms)\")\n                  : null\n              );\n            }\n          }, res.timeout);\n        }\n      }\n    }\n\n    sync = false;\n    // return in case resolved synchronously\n    return factory.loading\n      ? factory.loadingComp\n      : factory.resolved\n  }\n}\n\n/*  */\n\nfunction isAsyncPlaceholder (node) {\n  return node.isComment && node.asyncFactory\n}\n\n/*  */\n\nfunction getFirstComponentChild (children) {\n  if (Array.isArray(children)) {\n    for (var i = 0; i < children.length; i++) {\n      var c = children[i];\n      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {\n        return c\n      }\n    }\n  }\n}\n\n/*  */\n\n/*  */\n\nfunction initEvents (vm) {\n  vm._events = Object.create(null);\n  vm._hasHookEvent = false;\n  // init parent attached events\n  var listeners = vm.$options._parentListeners;\n  if (listeners) {\n    updateComponentListeners(vm, listeners);\n  }\n}\n\nvar target;\n\nfunction add (event, fn) {\n  target.$on(event, fn);\n}\n\nfunction remove$1 (event, fn) {\n  target.$off(event, fn);\n}\n\nfunction createOnceHandler (event, fn) {\n  var _target = target;\n  return function onceHandler () {\n    var res = fn.apply(null, arguments);\n    if (res !== null) {\n      _target.$off(event, onceHandler);\n    }\n  }\n}\n\nfunction updateComponentListeners (\n  vm,\n  listeners,\n  oldListeners\n) {\n  target = vm;\n  updateListeners(listeners, oldListeners || {}, add, remove$1, createOnceHandler, vm);\n  target = undefined;\n}\n\nfunction eventsMixin (Vue) {\n  var hookRE = /^hook:/;\n  Vue.prototype.$on = function (event, fn) {\n    var vm = this;\n    if (Array.isArray(event)) {\n      for (var i = 0, l = event.length; i < l; i++) {\n        vm.$on(event[i], fn);\n      }\n    } else {\n      (vm._events[event] || (vm._events[event] = [])).push(fn);\n      // optimize hook:event cost by using a boolean flag marked at registration\n      // instead of a hash lookup\n      if (hookRE.test(event)) {\n        vm._hasHookEvent = true;\n      }\n    }\n    return vm\n  };\n\n  Vue.prototype.$once = function (event, fn) {\n    var vm = this;\n    function on () {\n      vm.$off(event, on);\n      fn.apply(vm, arguments);\n    }\n    on.fn = fn;\n    vm.$on(event, on);\n    return vm\n  };\n\n  Vue.prototype.$off = function (event, fn) {\n    var vm = this;\n    // all\n    if (!arguments.length) {\n      vm._events = Object.create(null);\n      return vm\n    }\n    // array of events\n    if (Array.isArray(event)) {\n      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {\n        vm.$off(event[i$1], fn);\n      }\n      return vm\n    }\n    // specific event\n    var cbs = vm._events[event];\n    if (!cbs) {\n      return vm\n    }\n    if (!fn) {\n      vm._events[event] = null;\n      return vm\n    }\n    // specific handler\n    var cb;\n    var i = cbs.length;\n    while (i--) {\n      cb = cbs[i];\n      if (cb === fn || cb.fn === fn) {\n        cbs.splice(i, 1);\n        break\n      }\n    }\n    return vm\n  };\n\n  Vue.prototype.$emit = function (event) {\n    var vm = this;\n    if (process.env.NODE_ENV !== 'production') {\n      var lowerCaseEvent = event.toLowerCase();\n      if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {\n        tip(\n          \"Event \\\"\" + lowerCaseEvent + \"\\\" is emitted in component \" +\n          (formatComponentName(vm)) + \" but the handler is registered for \\\"\" + event + \"\\\". \" +\n          \"Note that HTML attributes are case-insensitive and you cannot use \" +\n          \"v-on to listen to camelCase events when using in-DOM templates. \" +\n          \"You should probably use \\\"\" + (hyphenate(event)) + \"\\\" instead of \\\"\" + event + \"\\\".\"\n        );\n      }\n    }\n    var cbs = vm._events[event];\n    if (cbs) {\n      cbs = cbs.length > 1 ? toArray(cbs) : cbs;\n      var args = toArray(arguments, 1);\n      var info = \"event handler for \\\"\" + event + \"\\\"\";\n      for (var i = 0, l = cbs.length; i < l; i++) {\n        invokeWithErrorHandling(cbs[i], vm, args, vm, info);\n      }\n    }\n    return vm\n  };\n}\n\n/*  */\n\nvar activeInstance = null;\nvar isUpdatingChildComponent = false;\n\nfunction setActiveInstance(vm) {\n  var prevActiveInstance = activeInstance;\n  activeInstance = vm;\n  return function () {\n    activeInstance = prevActiveInstance;\n  }\n}\n\nfunction initLifecycle (vm) {\n  var options = vm.$options;\n\n  // locate first non-abstract parent\n  var parent = options.parent;\n  if (parent && !options.abstract) {\n    while (parent.$options.abstract && parent.$parent) {\n      parent = parent.$parent;\n    }\n    parent.$children.push(vm);\n  }\n\n  vm.$parent = parent;\n  vm.$root = parent ? parent.$root : vm;\n\n  vm.$children = [];\n  vm.$refs = {};\n\n  vm._watcher = null;\n  vm._inactive = null;\n  vm._directInactive = false;\n  vm._isMounted = false;\n  vm._isDestroyed = false;\n  vm._isBeingDestroyed = false;\n}\n\nfunction lifecycleMixin (Vue) {\n  Vue.prototype._update = function (vnode, hydrating) {\n    var vm = this;\n    var prevEl = vm.$el;\n    var prevVnode = vm._vnode;\n    var restoreActiveInstance = setActiveInstance(vm);\n    vm._vnode = vnode;\n    // Vue.prototype.__patch__ is injected in entry points\n    // based on the rendering backend used.\n    if (!prevVnode) {\n      // initial render\n      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);\n    } else {\n      // updates\n      vm.$el = vm.__patch__(prevVnode, vnode);\n    }\n    restoreActiveInstance();\n    // update __vue__ reference\n    if (prevEl) {\n      prevEl.__vue__ = null;\n    }\n    if (vm.$el) {\n      vm.$el.__vue__ = vm;\n    }\n    // if parent is an HOC, update its $el as well\n    if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {\n      vm.$parent.$el = vm.$el;\n    }\n    // updated hook is called by the scheduler to ensure that children are\n    // updated in a parent's updated hook.\n  };\n\n  Vue.prototype.$forceUpdate = function () {\n    var vm = this;\n    if (vm._watcher) {\n      vm._watcher.update();\n    }\n  };\n\n  Vue.prototype.$destroy = function () {\n    var vm = this;\n    if (vm._isBeingDestroyed) {\n      return\n    }\n    callHook(vm, 'beforeDestroy');\n    vm._isBeingDestroyed = true;\n    // remove self from parent\n    var parent = vm.$parent;\n    if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {\n      remove(parent.$children, vm);\n    }\n    // teardown watchers\n    if (vm._watcher) {\n      vm._watcher.teardown();\n    }\n    var i = vm._watchers.length;\n    while (i--) {\n      vm._watchers[i].teardown();\n    }\n    // remove reference from data ob\n    // frozen object may not have observer.\n    if (vm._data.__ob__) {\n      vm._data.__ob__.vmCount--;\n    }\n    // call the last hook...\n    vm._isDestroyed = true;\n    // invoke destroy hooks on current rendered tree\n    vm.__patch__(vm._vnode, null);\n    // fire destroyed hook\n    callHook(vm, 'destroyed');\n    // turn off all instance listeners.\n    vm.$off();\n    // remove __vue__ reference\n    if (vm.$el) {\n      vm.$el.__vue__ = null;\n    }\n    // release circular reference (#6759)\n    if (vm.$vnode) {\n      vm.$vnode.parent = null;\n    }\n  };\n}\n\nfunction mountComponent (\n  vm,\n  el,\n  hydrating\n) {\n  vm.$el = el;\n  if (!vm.$options.render) {\n    vm.$options.render = createEmptyVNode;\n    if (process.env.NODE_ENV !== 'production') {\n      /* istanbul ignore if */\n      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||\n        vm.$options.el || el) {\n        warn(\n          'You are using the runtime-only build of Vue where the template ' +\n          'compiler is not available. Either pre-compile the templates into ' +\n          'render functions, or use the compiler-included build.',\n          vm\n        );\n      } else {\n        warn(\n          'Failed to mount component: template or render function not defined.',\n          vm\n        );\n      }\n    }\n  }\n  callHook(vm, 'beforeMount');\n\n  var updateComponent;\n  /* istanbul ignore if */\n  if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n    updateComponent = function () {\n      var name = vm._name;\n      var id = vm._uid;\n      var startTag = \"vue-perf-start:\" + id;\n      var endTag = \"vue-perf-end:\" + id;\n\n      mark(startTag);\n      var vnode = vm._render();\n      mark(endTag);\n      measure((\"vue \" + name + \" render\"), startTag, endTag);\n\n      mark(startTag);\n      vm._update(vnode, hydrating);\n      mark(endTag);\n      measure((\"vue \" + name + \" patch\"), startTag, endTag);\n    };\n  } else {\n    updateComponent = function () {\n      vm._update(vm._render(), hydrating);\n    };\n  }\n\n  // we set this to vm._watcher inside the watcher's constructor\n  // since the watcher's initial patch may call $forceUpdate (e.g. inside child\n  // component's mounted hook), which relies on vm._watcher being already defined\n  new Watcher(vm, updateComponent, noop, {\n    before: function before () {\n      if (vm._isMounted && !vm._isDestroyed) {\n        callHook(vm, 'beforeUpdate');\n      }\n    }\n  }, true /* isRenderWatcher */);\n  hydrating = false;\n\n  // manually mounted instance, call mounted on self\n  // mounted is called for render-created child components in its inserted hook\n  if (vm.$vnode == null) {\n    vm._isMounted = true;\n    callHook(vm, 'mounted');\n  }\n  return vm\n}\n\nfunction updateChildComponent (\n  vm,\n  propsData,\n  listeners,\n  parentVnode,\n  renderChildren\n) {\n  if (process.env.NODE_ENV !== 'production') {\n    isUpdatingChildComponent = true;\n  }\n\n  // determine whether component has slot children\n  // we need to do this before overwriting $options._renderChildren.\n\n  // check if there are dynamic scopedSlots (hand-written or compiled but with\n  // dynamic slot names). Static scoped slots compiled from template has the\n  // \"$stable\" marker.\n  var newScopedSlots = parentVnode.data.scopedSlots;\n  var oldScopedSlots = vm.$scopedSlots;\n  var hasDynamicScopedSlot = !!(\n    (newScopedSlots && !newScopedSlots.$stable) ||\n    (oldScopedSlots !== emptyObject && !oldScopedSlots.$stable) ||\n    (newScopedSlots && vm.$scopedSlots.$key !== newScopedSlots.$key)\n  );\n\n  // Any static slot children from the parent may have changed during parent's\n  // update. Dynamic scoped slots may also have changed. In such cases, a forced\n  // update is necessary to ensure correctness.\n  var needsForceUpdate = !!(\n    renderChildren ||               // has new static slots\n    vm.$options._renderChildren ||  // has old static slots\n    hasDynamicScopedSlot\n  );\n\n  vm.$options._parentVnode = parentVnode;\n  vm.$vnode = parentVnode; // update vm's placeholder node without re-render\n\n  if (vm._vnode) { // update child tree's parent\n    vm._vnode.parent = parentVnode;\n  }\n  vm.$options._renderChildren = renderChildren;\n\n  // update $attrs and $listeners hash\n  // these are also reactive so they may trigger child update if the child\n  // used them during render\n  vm.$attrs = parentVnode.data.attrs || emptyObject;\n  vm.$listeners = listeners || emptyObject;\n\n  // update props\n  if (propsData && vm.$options.props) {\n    toggleObserving(false);\n    var props = vm._props;\n    var propKeys = vm.$options._propKeys || [];\n    for (var i = 0; i < propKeys.length; i++) {\n      var key = propKeys[i];\n      var propOptions = vm.$options.props; // wtf flow?\n      props[key] = validateProp(key, propOptions, propsData, vm);\n    }\n    toggleObserving(true);\n    // keep a copy of raw propsData\n    vm.$options.propsData = propsData;\n  }\n\n  // update listeners\n  listeners = listeners || emptyObject;\n  var oldListeners = vm.$options._parentListeners;\n  vm.$options._parentListeners = listeners;\n  updateComponentListeners(vm, listeners, oldListeners);\n\n  // resolve slots + force update if has children\n  if (needsForceUpdate) {\n    vm.$slots = resolveSlots(renderChildren, parentVnode.context);\n    vm.$forceUpdate();\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    isUpdatingChildComponent = false;\n  }\n}\n\nfunction isInInactiveTree (vm) {\n  while (vm && (vm = vm.$parent)) {\n    if (vm._inactive) { return true }\n  }\n  return false\n}\n\nfunction activateChildComponent (vm, direct) {\n  if (direct) {\n    vm._directInactive = false;\n    if (isInInactiveTree(vm)) {\n      return\n    }\n  } else if (vm._directInactive) {\n    return\n  }\n  if (vm._inactive || vm._inactive === null) {\n    vm._inactive = false;\n    for (var i = 0; i < vm.$children.length; i++) {\n      activateChildComponent(vm.$children[i]);\n    }\n    callHook(vm, 'activated');\n  }\n}\n\nfunction deactivateChildComponent (vm, direct) {\n  if (direct) {\n    vm._directInactive = true;\n    if (isInInactiveTree(vm)) {\n      return\n    }\n  }\n  if (!vm._inactive) {\n    vm._inactive = true;\n    for (var i = 0; i < vm.$children.length; i++) {\n      deactivateChildComponent(vm.$children[i]);\n    }\n    callHook(vm, 'deactivated');\n  }\n}\n\nfunction callHook (vm, hook) {\n  // #7573 disable dep collection when invoking lifecycle hooks\n  pushTarget();\n  var handlers = vm.$options[hook];\n  var info = hook + \" hook\";\n  if (handlers) {\n    for (var i = 0, j = handlers.length; i < j; i++) {\n      invokeWithErrorHandling(handlers[i], vm, null, vm, info);\n    }\n  }\n  if (vm._hasHookEvent) {\n    vm.$emit('hook:' + hook);\n  }\n  popTarget();\n}\n\n/*  */\n\nvar MAX_UPDATE_COUNT = 100;\n\nvar queue = [];\nvar activatedChildren = [];\nvar has = {};\nvar circular = {};\nvar waiting = false;\nvar flushing = false;\nvar index = 0;\n\n/**\n * Reset the scheduler's state.\n */\nfunction resetSchedulerState () {\n  index = queue.length = activatedChildren.length = 0;\n  has = {};\n  if (process.env.NODE_ENV !== 'production') {\n    circular = {};\n  }\n  waiting = flushing = false;\n}\n\n// Async edge case #6566 requires saving the timestamp when event listeners are\n// attached. However, calling performance.now() has a perf overhead especially\n// if the page has thousands of event listeners. Instead, we take a timestamp\n// every time the scheduler flushes and use that for all event listeners\n// attached during that flush.\nvar currentFlushTimestamp = 0;\n\n// Async edge case fix requires storing an event listener's attach timestamp.\nvar getNow = Date.now;\n\n// Determine what event timestamp the browser is using. Annoyingly, the\n// timestamp can either be hi-res (relative to page load) or low-res\n// (relative to UNIX epoch), so in order to compare time we have to use the\n// same timestamp type when saving the flush timestamp.\n// All IE versions use low-res event timestamps, and have problematic clock\n// implementations (#9632)\nif (inBrowser && !isIE) {\n  var performance = window.performance;\n  if (\n    performance &&\n    typeof performance.now === 'function' &&\n    getNow() > document.createEvent('Event').timeStamp\n  ) {\n    // if the event timestamp, although evaluated AFTER the Date.now(), is\n    // smaller than it, it means the event is using a hi-res timestamp,\n    // and we need to use the hi-res version for event listener timestamps as\n    // well.\n    getNow = function () { return performance.now(); };\n  }\n}\n\n/**\n * Flush both queues and run the watchers.\n */\nfunction flushSchedulerQueue () {\n  currentFlushTimestamp = getNow();\n  flushing = true;\n  var watcher, id;\n\n  // Sort queue before flush.\n  // This ensures that:\n  // 1. Components are updated from parent to child. (because parent is always\n  //    created before the child)\n  // 2. A component's user watchers are run before its render watcher (because\n  //    user watchers are created before the render watcher)\n  // 3. If a component is destroyed during a parent component's watcher run,\n  //    its watchers can be skipped.\n  queue.sort(function (a, b) { return a.id - b.id; });\n\n  // do not cache length because more watchers might be pushed\n  // as we run existing watchers\n  for (index = 0; index < queue.length; index++) {\n    watcher = queue[index];\n    if (watcher.before) {\n      watcher.before();\n    }\n    id = watcher.id;\n    has[id] = null;\n    watcher.run();\n    // in dev build, check and stop circular updates.\n    if (process.env.NODE_ENV !== 'production' && has[id] != null) {\n      circular[id] = (circular[id] || 0) + 1;\n      if (circular[id] > MAX_UPDATE_COUNT) {\n        warn(\n          'You may have an infinite update loop ' + (\n            watcher.user\n              ? (\"in watcher with expression \\\"\" + (watcher.expression) + \"\\\"\")\n              : \"in a component render function.\"\n          ),\n          watcher.vm\n        );\n        break\n      }\n    }\n  }\n\n  // keep copies of post queues before resetting state\n  var activatedQueue = activatedChildren.slice();\n  var updatedQueue = queue.slice();\n\n  resetSchedulerState();\n\n  // call component updated and activated hooks\n  callActivatedHooks(activatedQueue);\n  callUpdatedHooks(updatedQueue);\n\n  // devtool hook\n  /* istanbul ignore if */\n  if (devtools && config.devtools) {\n    devtools.emit('flush');\n  }\n}\n\nfunction callUpdatedHooks (queue) {\n  var i = queue.length;\n  while (i--) {\n    var watcher = queue[i];\n    var vm = watcher.vm;\n    if (vm._watcher === watcher && vm._isMounted && !vm._isDestroyed) {\n      callHook(vm, 'updated');\n    }\n  }\n}\n\n/**\n * Queue a kept-alive component that was activated during patch.\n * The queue will be processed after the entire tree has been patched.\n */\nfunction queueActivatedComponent (vm) {\n  // setting _inactive to false here so that a render function can\n  // rely on checking whether it's in an inactive tree (e.g. router-view)\n  vm._inactive = false;\n  activatedChildren.push(vm);\n}\n\nfunction callActivatedHooks (queue) {\n  for (var i = 0; i < queue.length; i++) {\n    queue[i]._inactive = true;\n    activateChildComponent(queue[i], true /* true */);\n  }\n}\n\n/**\n * Push a watcher into the watcher queue.\n * Jobs with duplicate IDs will be skipped unless it's\n * pushed when the queue is being flushed.\n */\nfunction queueWatcher (watcher) {\n  var id = watcher.id;\n  if (has[id] == null) {\n    has[id] = true;\n    if (!flushing) {\n      queue.push(watcher);\n    } else {\n      // if already flushing, splice the watcher based on its id\n      // if already past its id, it will be run next immediately.\n      var i = queue.length - 1;\n      while (i > index && queue[i].id > watcher.id) {\n        i--;\n      }\n      queue.splice(i + 1, 0, watcher);\n    }\n    // queue the flush\n    if (!waiting) {\n      waiting = true;\n\n      if (process.env.NODE_ENV !== 'production' && !config.async) {\n        flushSchedulerQueue();\n        return\n      }\n      nextTick(flushSchedulerQueue);\n    }\n  }\n}\n\n/*  */\n\n\n\nvar uid$2 = 0;\n\n/**\n * A watcher parses an expression, collects dependencies,\n * and fires callback when the expression value changes.\n * This is used for both the $watch() api and directives.\n */\nvar Watcher = function Watcher (\n  vm,\n  expOrFn,\n  cb,\n  options,\n  isRenderWatcher\n) {\n  this.vm = vm;\n  if (isRenderWatcher) {\n    vm._watcher = this;\n  }\n  vm._watchers.push(this);\n  // options\n  if (options) {\n    this.deep = !!options.deep;\n    this.user = !!options.user;\n    this.lazy = !!options.lazy;\n    this.sync = !!options.sync;\n    this.before = options.before;\n  } else {\n    this.deep = this.user = this.lazy = this.sync = false;\n  }\n  this.cb = cb;\n  this.id = ++uid$2; // uid for batching\n  this.active = true;\n  this.dirty = this.lazy; // for lazy watchers\n  this.deps = [];\n  this.newDeps = [];\n  this.depIds = new _Set();\n  this.newDepIds = new _Set();\n  this.expression = process.env.NODE_ENV !== 'production'\n    ? expOrFn.toString()\n    : '';\n  // parse expression for getter\n  if (typeof expOrFn === 'function') {\n    this.getter = expOrFn;\n  } else {\n    this.getter = parsePath(expOrFn);\n    if (!this.getter) {\n      this.getter = noop;\n      process.env.NODE_ENV !== 'production' && warn(\n        \"Failed watching path: \\\"\" + expOrFn + \"\\\" \" +\n        'Watcher only accepts simple dot-delimited paths. ' +\n        'For full control, use a function instead.',\n        vm\n      );\n    }\n  }\n  this.value = this.lazy\n    ? undefined\n    : this.get();\n};\n\n/**\n * Evaluate the getter, and re-collect dependencies.\n */\nWatcher.prototype.get = function get () {\n  pushTarget(this);\n  var value;\n  var vm = this.vm;\n  try {\n    value = this.getter.call(vm, vm);\n  } catch (e) {\n    if (this.user) {\n      handleError(e, vm, (\"getter for watcher \\\"\" + (this.expression) + \"\\\"\"));\n    } else {\n      throw e\n    }\n  } finally {\n    // \"touch\" every property so they are all tracked as\n    // dependencies for deep watching\n    if (this.deep) {\n      traverse(value);\n    }\n    popTarget();\n    this.cleanupDeps();\n  }\n  return value\n};\n\n/**\n * Add a dependency to this directive.\n */\nWatcher.prototype.addDep = function addDep (dep) {\n  var id = dep.id;\n  if (!this.newDepIds.has(id)) {\n    this.newDepIds.add(id);\n    this.newDeps.push(dep);\n    if (!this.depIds.has(id)) {\n      dep.addSub(this);\n    }\n  }\n};\n\n/**\n * Clean up for dependency collection.\n */\nWatcher.prototype.cleanupDeps = function cleanupDeps () {\n  var i = this.deps.length;\n  while (i--) {\n    var dep = this.deps[i];\n    if (!this.newDepIds.has(dep.id)) {\n      dep.removeSub(this);\n    }\n  }\n  var tmp = this.depIds;\n  this.depIds = this.newDepIds;\n  this.newDepIds = tmp;\n  this.newDepIds.clear();\n  tmp = this.deps;\n  this.deps = this.newDeps;\n  this.newDeps = tmp;\n  this.newDeps.length = 0;\n};\n\n/**\n * Subscriber interface.\n * Will be called when a dependency changes.\n */\nWatcher.prototype.update = function update () {\n  /* istanbul ignore else */\n  if (this.lazy) {\n    this.dirty = true;\n  } else if (this.sync) {\n    this.run();\n  } else {\n    queueWatcher(this);\n  }\n};\n\n/**\n * Scheduler job interface.\n * Will be called by the scheduler.\n */\nWatcher.prototype.run = function run () {\n  if (this.active) {\n    var value = this.get();\n    if (\n      value !== this.value ||\n      // Deep watchers and watchers on Object/Arrays should fire even\n      // when the value is the same, because the value may\n      // have mutated.\n      isObject(value) ||\n      this.deep\n    ) {\n      // set new value\n      var oldValue = this.value;\n      this.value = value;\n      if (this.user) {\n        try {\n          this.cb.call(this.vm, value, oldValue);\n        } catch (e) {\n          handleError(e, this.vm, (\"callback for watcher \\\"\" + (this.expression) + \"\\\"\"));\n        }\n      } else {\n        this.cb.call(this.vm, value, oldValue);\n      }\n    }\n  }\n};\n\n/**\n * Evaluate the value of the watcher.\n * This only gets called for lazy watchers.\n */\nWatcher.prototype.evaluate = function evaluate () {\n  this.value = this.get();\n  this.dirty = false;\n};\n\n/**\n * Depend on all deps collected by this watcher.\n */\nWatcher.prototype.depend = function depend () {\n  var i = this.deps.length;\n  while (i--) {\n    this.deps[i].depend();\n  }\n};\n\n/**\n * Remove self from all dependencies' subscriber list.\n */\nWatcher.prototype.teardown = function teardown () {\n  if (this.active) {\n    // remove self from vm's watcher list\n    // this is a somewhat expensive operation so we skip it\n    // if the vm is being destroyed.\n    if (!this.vm._isBeingDestroyed) {\n      remove(this.vm._watchers, this);\n    }\n    var i = this.deps.length;\n    while (i--) {\n      this.deps[i].removeSub(this);\n    }\n    this.active = false;\n  }\n};\n\n/*  */\n\nvar sharedPropertyDefinition = {\n  enumerable: true,\n  configurable: true,\n  get: noop,\n  set: noop\n};\n\nfunction proxy (target, sourceKey, key) {\n  sharedPropertyDefinition.get = function proxyGetter () {\n    return this[sourceKey][key]\n  };\n  sharedPropertyDefinition.set = function proxySetter (val) {\n    this[sourceKey][key] = val;\n  };\n  Object.defineProperty(target, key, sharedPropertyDefinition);\n}\n\nfunction initState (vm) {\n  vm._watchers = [];\n  var opts = vm.$options;\n  if (opts.props) { initProps(vm, opts.props); }\n  if (opts.methods) { initMethods(vm, opts.methods); }\n  if (opts.data) {\n    initData(vm);\n  } else {\n    observe(vm._data = {}, true /* asRootData */);\n  }\n  if (opts.computed) { initComputed(vm, opts.computed); }\n  if (opts.watch && opts.watch !== nativeWatch) {\n    initWatch(vm, opts.watch);\n  }\n}\n\nfunction initProps (vm, propsOptions) {\n  var propsData = vm.$options.propsData || {};\n  var props = vm._props = {};\n  // cache prop keys so that future props updates can iterate using Array\n  // instead of dynamic object key enumeration.\n  var keys = vm.$options._propKeys = [];\n  var isRoot = !vm.$parent;\n  // root instance props should be converted\n  if (!isRoot) {\n    toggleObserving(false);\n  }\n  var loop = function ( key ) {\n    keys.push(key);\n    var value = validateProp(key, propsOptions, propsData, vm);\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      var hyphenatedKey = hyphenate(key);\n      if (isReservedAttribute(hyphenatedKey) ||\n          config.isReservedAttr(hyphenatedKey)) {\n        warn(\n          (\"\\\"\" + hyphenatedKey + \"\\\" is a reserved attribute and cannot be used as component prop.\"),\n          vm\n        );\n      }\n      defineReactive$$1(props, key, value, function () {\n        if (!isRoot && !isUpdatingChildComponent) {\n          warn(\n            \"Avoid mutating a prop directly since the value will be \" +\n            \"overwritten whenever the parent component re-renders. \" +\n            \"Instead, use a data or computed property based on the prop's \" +\n            \"value. Prop being mutated: \\\"\" + key + \"\\\"\",\n            vm\n          );\n        }\n      });\n    } else {\n      defineReactive$$1(props, key, value);\n    }\n    // static props are already proxied on the component's prototype\n    // during Vue.extend(). We only need to proxy props defined at\n    // instantiation here.\n    if (!(key in vm)) {\n      proxy(vm, \"_props\", key);\n    }\n  };\n\n  for (var key in propsOptions) loop( key );\n  toggleObserving(true);\n}\n\nfunction initData (vm) {\n  var data = vm.$options.data;\n  data = vm._data = typeof data === 'function'\n    ? getData(data, vm)\n    : data || {};\n  if (!isPlainObject(data)) {\n    data = {};\n    process.env.NODE_ENV !== 'production' && warn(\n      'data functions should return an object:\\n' +\n      'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',\n      vm\n    );\n  }\n  // proxy data on instance\n  var keys = Object.keys(data);\n  var props = vm.$options.props;\n  var methods = vm.$options.methods;\n  var i = keys.length;\n  while (i--) {\n    var key = keys[i];\n    if (process.env.NODE_ENV !== 'production') {\n      if (methods && hasOwn(methods, key)) {\n        warn(\n          (\"Method \\\"\" + key + \"\\\" has already been defined as a data property.\"),\n          vm\n        );\n      }\n    }\n    if (props && hasOwn(props, key)) {\n      process.env.NODE_ENV !== 'production' && warn(\n        \"The data property \\\"\" + key + \"\\\" is already declared as a prop. \" +\n        \"Use prop default value instead.\",\n        vm\n      );\n    } else if (!isReserved(key)) {\n      proxy(vm, \"_data\", key);\n    }\n  }\n  // observe data\n  observe(data, true /* asRootData */);\n}\n\nfunction getData (data, vm) {\n  // #7573 disable dep collection when invoking data getters\n  pushTarget();\n  try {\n    return data.call(vm, vm)\n  } catch (e) {\n    handleError(e, vm, \"data()\");\n    return {}\n  } finally {\n    popTarget();\n  }\n}\n\nvar computedWatcherOptions = { lazy: true };\n\nfunction initComputed (vm, computed) {\n  // $flow-disable-line\n  var watchers = vm._computedWatchers = Object.create(null);\n  // computed properties are just getters during SSR\n  var isSSR = isServerRendering();\n\n  for (var key in computed) {\n    var userDef = computed[key];\n    var getter = typeof userDef === 'function' ? userDef : userDef.get;\n    if (process.env.NODE_ENV !== 'production' && getter == null) {\n      warn(\n        (\"Getter is missing for computed property \\\"\" + key + \"\\\".\"),\n        vm\n      );\n    }\n\n    if (!isSSR) {\n      // create internal watcher for the computed property.\n      watchers[key] = new Watcher(\n        vm,\n        getter || noop,\n        noop,\n        computedWatcherOptions\n      );\n    }\n\n    // component-defined computed properties are already defined on the\n    // component prototype. We only need to define computed properties defined\n    // at instantiation here.\n    if (!(key in vm)) {\n      defineComputed(vm, key, userDef);\n    } else if (process.env.NODE_ENV !== 'production') {\n      if (key in vm.$data) {\n        warn((\"The computed property \\\"\" + key + \"\\\" is already defined in data.\"), vm);\n      } else if (vm.$options.props && key in vm.$options.props) {\n        warn((\"The computed property \\\"\" + key + \"\\\" is already defined as a prop.\"), vm);\n      }\n    }\n  }\n}\n\nfunction defineComputed (\n  target,\n  key,\n  userDef\n) {\n  var shouldCache = !isServerRendering();\n  if (typeof userDef === 'function') {\n    sharedPropertyDefinition.get = shouldCache\n      ? createComputedGetter(key)\n      : createGetterInvoker(userDef);\n    sharedPropertyDefinition.set = noop;\n  } else {\n    sharedPropertyDefinition.get = userDef.get\n      ? shouldCache && userDef.cache !== false\n        ? createComputedGetter(key)\n        : createGetterInvoker(userDef.get)\n      : noop;\n    sharedPropertyDefinition.set = userDef.set || noop;\n  }\n  if (process.env.NODE_ENV !== 'production' &&\n      sharedPropertyDefinition.set === noop) {\n    sharedPropertyDefinition.set = function () {\n      warn(\n        (\"Computed property \\\"\" + key + \"\\\" was assigned to but it has no setter.\"),\n        this\n      );\n    };\n  }\n  Object.defineProperty(target, key, sharedPropertyDefinition);\n}\n\nfunction createComputedGetter (key) {\n  return function computedGetter () {\n    var watcher = this._computedWatchers && this._computedWatchers[key];\n    if (watcher) {\n      if (watcher.dirty) {\n        watcher.evaluate();\n      }\n      if (Dep.target) {\n        watcher.depend();\n      }\n      return watcher.value\n    }\n  }\n}\n\nfunction createGetterInvoker(fn) {\n  return function computedGetter () {\n    return fn.call(this, this)\n  }\n}\n\nfunction initMethods (vm, methods) {\n  var props = vm.$options.props;\n  for (var key in methods) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof methods[key] !== 'function') {\n        warn(\n          \"Method \\\"\" + key + \"\\\" has type \\\"\" + (typeof methods[key]) + \"\\\" in the component definition. \" +\n          \"Did you reference the function correctly?\",\n          vm\n        );\n      }\n      if (props && hasOwn(props, key)) {\n        warn(\n          (\"Method \\\"\" + key + \"\\\" has already been defined as a prop.\"),\n          vm\n        );\n      }\n      if ((key in vm) && isReserved(key)) {\n        warn(\n          \"Method \\\"\" + key + \"\\\" conflicts with an existing Vue instance method. \" +\n          \"Avoid defining component methods that start with _ or $.\"\n        );\n      }\n    }\n    vm[key] = typeof methods[key] !== 'function' ? noop : bind(methods[key], vm);\n  }\n}\n\nfunction initWatch (vm, watch) {\n  for (var key in watch) {\n    var handler = watch[key];\n    if (Array.isArray(handler)) {\n      for (var i = 0; i < handler.length; i++) {\n        createWatcher(vm, key, handler[i]);\n      }\n    } else {\n      createWatcher(vm, key, handler);\n    }\n  }\n}\n\nfunction createWatcher (\n  vm,\n  expOrFn,\n  handler,\n  options\n) {\n  if (isPlainObject(handler)) {\n    options = handler;\n    handler = handler.handler;\n  }\n  if (typeof handler === 'string') {\n    handler = vm[handler];\n  }\n  return vm.$watch(expOrFn, handler, options)\n}\n\nfunction stateMixin (Vue) {\n  // flow somehow has problems with directly declared definition object\n  // when using Object.defineProperty, so we have to procedurally build up\n  // the object here.\n  var dataDef = {};\n  dataDef.get = function () { return this._data };\n  var propsDef = {};\n  propsDef.get = function () { return this._props };\n  if (process.env.NODE_ENV !== 'production') {\n    dataDef.set = function () {\n      warn(\n        'Avoid replacing instance root $data. ' +\n        'Use nested data properties instead.',\n        this\n      );\n    };\n    propsDef.set = function () {\n      warn(\"$props is readonly.\", this);\n    };\n  }\n  Object.defineProperty(Vue.prototype, '$data', dataDef);\n  Object.defineProperty(Vue.prototype, '$props', propsDef);\n\n  Vue.prototype.$set = set;\n  Vue.prototype.$delete = del;\n\n  Vue.prototype.$watch = function (\n    expOrFn,\n    cb,\n    options\n  ) {\n    var vm = this;\n    if (isPlainObject(cb)) {\n      return createWatcher(vm, expOrFn, cb, options)\n    }\n    options = options || {};\n    options.user = true;\n    var watcher = new Watcher(vm, expOrFn, cb, options);\n    if (options.immediate) {\n      try {\n        cb.call(vm, watcher.value);\n      } catch (error) {\n        handleError(error, vm, (\"callback for immediate watcher \\\"\" + (watcher.expression) + \"\\\"\"));\n      }\n    }\n    return function unwatchFn () {\n      watcher.teardown();\n    }\n  };\n}\n\n/*  */\n\nvar uid$3 = 0;\n\nfunction initMixin (Vue) {\n  Vue.prototype._init = function (options) {\n    var vm = this;\n    // a uid\n    vm._uid = uid$3++;\n\n    var startTag, endTag;\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n      startTag = \"vue-perf-start:\" + (vm._uid);\n      endTag = \"vue-perf-end:\" + (vm._uid);\n      mark(startTag);\n    }\n\n    // a flag to avoid this being observed\n    vm._isVue = true;\n    // merge options\n    if (options && options._isComponent) {\n      // optimize internal component instantiation\n      // since dynamic options merging is pretty slow, and none of the\n      // internal component options needs special treatment.\n      initInternalComponent(vm, options);\n    } else {\n      vm.$options = mergeOptions(\n        resolveConstructorOptions(vm.constructor),\n        options || {},\n        vm\n      );\n    }\n    /* istanbul ignore else */\n    if (process.env.NODE_ENV !== 'production') {\n      initProxy(vm);\n    } else {\n      vm._renderProxy = vm;\n    }\n    // expose real self\n    vm._self = vm;\n    initLifecycle(vm);\n    initEvents(vm);\n    initRender(vm);\n    callHook(vm, 'beforeCreate');\n    initInjections(vm); // resolve injections before data/props\n    initState(vm);\n    initProvide(vm); // resolve provide after data/props\n    callHook(vm, 'created');\n\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n      vm._name = formatComponentName(vm, false);\n      mark(endTag);\n      measure((\"vue \" + (vm._name) + \" init\"), startTag, endTag);\n    }\n\n    if (vm.$options.el) {\n      vm.$mount(vm.$options.el);\n    }\n  };\n}\n\nfunction initInternalComponent (vm, options) {\n  var opts = vm.$options = Object.create(vm.constructor.options);\n  // doing this because it's faster than dynamic enumeration.\n  var parentVnode = options._parentVnode;\n  opts.parent = options.parent;\n  opts._parentVnode = parentVnode;\n\n  var vnodeComponentOptions = parentVnode.componentOptions;\n  opts.propsData = vnodeComponentOptions.propsData;\n  opts._parentListeners = vnodeComponentOptions.listeners;\n  opts._renderChildren = vnodeComponentOptions.children;\n  opts._componentTag = vnodeComponentOptions.tag;\n\n  if (options.render) {\n    opts.render = options.render;\n    opts.staticRenderFns = options.staticRenderFns;\n  }\n}\n\nfunction resolveConstructorOptions (Ctor) {\n  var options = Ctor.options;\n  if (Ctor.super) {\n    var superOptions = resolveConstructorOptions(Ctor.super);\n    var cachedSuperOptions = Ctor.superOptions;\n    if (superOptions !== cachedSuperOptions) {\n      // super option changed,\n      // need to resolve new options.\n      Ctor.superOptions = superOptions;\n      // check if there are any late-modified/attached options (#4976)\n      var modifiedOptions = resolveModifiedOptions(Ctor);\n      // update base extend options\n      if (modifiedOptions) {\n        extend(Ctor.extendOptions, modifiedOptions);\n      }\n      options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);\n      if (options.name) {\n        options.components[options.name] = Ctor;\n      }\n    }\n  }\n  return options\n}\n\nfunction resolveModifiedOptions (Ctor) {\n  var modified;\n  var latest = Ctor.options;\n  var sealed = Ctor.sealedOptions;\n  for (var key in latest) {\n    if (latest[key] !== sealed[key]) {\n      if (!modified) { modified = {}; }\n      modified[key] = latest[key];\n    }\n  }\n  return modified\n}\n\nfunction Vue (options) {\n  if (process.env.NODE_ENV !== 'production' &&\n    !(this instanceof Vue)\n  ) {\n    warn('Vue is a constructor and should be called with the `new` keyword');\n  }\n  this._init(options);\n}\n\ninitMixin(Vue);\nstateMixin(Vue);\neventsMixin(Vue);\nlifecycleMixin(Vue);\nrenderMixin(Vue);\n\n/*  */\n\nfunction initUse (Vue) {\n  Vue.use = function (plugin) {\n    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));\n    if (installedPlugins.indexOf(plugin) > -1) {\n      return this\n    }\n\n    // additional parameters\n    var args = toArray(arguments, 1);\n    args.unshift(this);\n    if (typeof plugin.install === 'function') {\n      plugin.install.apply(plugin, args);\n    } else if (typeof plugin === 'function') {\n      plugin.apply(null, args);\n    }\n    installedPlugins.push(plugin);\n    return this\n  };\n}\n\n/*  */\n\nfunction initMixin$1 (Vue) {\n  Vue.mixin = function (mixin) {\n    this.options = mergeOptions(this.options, mixin);\n    return this\n  };\n}\n\n/*  */\n\nfunction initExtend (Vue) {\n  /**\n   * Each instance constructor, including Vue, has a unique\n   * cid. This enables us to create wrapped \"child\n   * constructors\" for prototypal inheritance and cache them.\n   */\n  Vue.cid = 0;\n  var cid = 1;\n\n  /**\n   * Class inheritance\n   */\n  Vue.extend = function (extendOptions) {\n    extendOptions = extendOptions || {};\n    var Super = this;\n    var SuperId = Super.cid;\n    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});\n    if (cachedCtors[SuperId]) {\n      return cachedCtors[SuperId]\n    }\n\n    var name = extendOptions.name || Super.options.name;\n    if (process.env.NODE_ENV !== 'production' && name) {\n      validateComponentName(name);\n    }\n\n    var Sub = function VueComponent (options) {\n      this._init(options);\n    };\n    Sub.prototype = Object.create(Super.prototype);\n    Sub.prototype.constructor = Sub;\n    Sub.cid = cid++;\n    Sub.options = mergeOptions(\n      Super.options,\n      extendOptions\n    );\n    Sub['super'] = Super;\n\n    // For props and computed properties, we define the proxy getters on\n    // the Vue instances at extension time, on the extended prototype. This\n    // avoids Object.defineProperty calls for each instance created.\n    if (Sub.options.props) {\n      initProps$1(Sub);\n    }\n    if (Sub.options.computed) {\n      initComputed$1(Sub);\n    }\n\n    // allow further extension/mixin/plugin usage\n    Sub.extend = Super.extend;\n    Sub.mixin = Super.mixin;\n    Sub.use = Super.use;\n\n    // create asset registers, so extended classes\n    // can have their private assets too.\n    ASSET_TYPES.forEach(function (type) {\n      Sub[type] = Super[type];\n    });\n    // enable recursive self-lookup\n    if (name) {\n      Sub.options.components[name] = Sub;\n    }\n\n    // keep a reference to the super options at extension time.\n    // later at instantiation we can check if Super's options have\n    // been updated.\n    Sub.superOptions = Super.options;\n    Sub.extendOptions = extendOptions;\n    Sub.sealedOptions = extend({}, Sub.options);\n\n    // cache constructor\n    cachedCtors[SuperId] = Sub;\n    return Sub\n  };\n}\n\nfunction initProps$1 (Comp) {\n  var props = Comp.options.props;\n  for (var key in props) {\n    proxy(Comp.prototype, \"_props\", key);\n  }\n}\n\nfunction initComputed$1 (Comp) {\n  var computed = Comp.options.computed;\n  for (var key in computed) {\n    defineComputed(Comp.prototype, key, computed[key]);\n  }\n}\n\n/*  */\n\nfunction initAssetRegisters (Vue) {\n  /**\n   * Create asset registration methods.\n   */\n  ASSET_TYPES.forEach(function (type) {\n    Vue[type] = function (\n      id,\n      definition\n    ) {\n      if (!definition) {\n        return this.options[type + 's'][id]\n      } else {\n        /* istanbul ignore if */\n        if (process.env.NODE_ENV !== 'production' && type === 'component') {\n          validateComponentName(id);\n        }\n        if (type === 'component' && isPlainObject(definition)) {\n          definition.name = definition.name || id;\n          definition = this.options._base.extend(definition);\n        }\n        if (type === 'directive' && typeof definition === 'function') {\n          definition = { bind: definition, update: definition };\n        }\n        this.options[type + 's'][id] = definition;\n        return definition\n      }\n    };\n  });\n}\n\n/*  */\n\n\n\nfunction getComponentName (opts) {\n  return opts && (opts.Ctor.options.name || opts.tag)\n}\n\nfunction matches (pattern, name) {\n  if (Array.isArray(pattern)) {\n    return pattern.indexOf(name) > -1\n  } else if (typeof pattern === 'string') {\n    return pattern.split(',').indexOf(name) > -1\n  } else if (isRegExp(pattern)) {\n    return pattern.test(name)\n  }\n  /* istanbul ignore next */\n  return false\n}\n\nfunction pruneCache (keepAliveInstance, filter) {\n  var cache = keepAliveInstance.cache;\n  var keys = keepAliveInstance.keys;\n  var _vnode = keepAliveInstance._vnode;\n  for (var key in cache) {\n    var cachedNode = cache[key];\n    if (cachedNode) {\n      var name = getComponentName(cachedNode.componentOptions);\n      if (name && !filter(name)) {\n        pruneCacheEntry(cache, key, keys, _vnode);\n      }\n    }\n  }\n}\n\nfunction pruneCacheEntry (\n  cache,\n  key,\n  keys,\n  current\n) {\n  var cached$$1 = cache[key];\n  if (cached$$1 && (!current || cached$$1.tag !== current.tag)) {\n    cached$$1.componentInstance.$destroy();\n  }\n  cache[key] = null;\n  remove(keys, key);\n}\n\nvar patternTypes = [String, RegExp, Array];\n\nvar KeepAlive = {\n  name: 'keep-alive',\n  abstract: true,\n\n  props: {\n    include: patternTypes,\n    exclude: patternTypes,\n    max: [String, Number]\n  },\n\n  created: function created () {\n    this.cache = Object.create(null);\n    this.keys = [];\n  },\n\n  destroyed: function destroyed () {\n    for (var key in this.cache) {\n      pruneCacheEntry(this.cache, key, this.keys);\n    }\n  },\n\n  mounted: function mounted () {\n    var this$1 = this;\n\n    this.$watch('include', function (val) {\n      pruneCache(this$1, function (name) { return matches(val, name); });\n    });\n    this.$watch('exclude', function (val) {\n      pruneCache(this$1, function (name) { return !matches(val, name); });\n    });\n  },\n\n  render: function render () {\n    var slot = this.$slots.default;\n    var vnode = getFirstComponentChild(slot);\n    var componentOptions = vnode && vnode.componentOptions;\n    if (componentOptions) {\n      // check pattern\n      var name = getComponentName(componentOptions);\n      var ref = this;\n      var include = ref.include;\n      var exclude = ref.exclude;\n      if (\n        // not included\n        (include && (!name || !matches(include, name))) ||\n        // excluded\n        (exclude && name && matches(exclude, name))\n      ) {\n        return vnode\n      }\n\n      var ref$1 = this;\n      var cache = ref$1.cache;\n      var keys = ref$1.keys;\n      var key = vnode.key == null\n        // same constructor may get registered as different local components\n        // so cid alone is not enough (#3269)\n        ? componentOptions.Ctor.cid + (componentOptions.tag ? (\"::\" + (componentOptions.tag)) : '')\n        : vnode.key;\n      if (cache[key]) {\n        vnode.componentInstance = cache[key].componentInstance;\n        // make current key freshest\n        remove(keys, key);\n        keys.push(key);\n      } else {\n        cache[key] = vnode;\n        keys.push(key);\n        // prune oldest entry\n        if (this.max && keys.length > parseInt(this.max)) {\n          pruneCacheEntry(cache, keys[0], keys, this._vnode);\n        }\n      }\n\n      vnode.data.keepAlive = true;\n    }\n    return vnode || (slot && slot[0])\n  }\n};\n\nvar builtInComponents = {\n  KeepAlive: KeepAlive\n};\n\n/*  */\n\nfunction initGlobalAPI (Vue) {\n  // config\n  var configDef = {};\n  configDef.get = function () { return config; };\n  if (process.env.NODE_ENV !== 'production') {\n    configDef.set = function () {\n      warn(\n        'Do not replace the Vue.config object, set individual fields instead.'\n      );\n    };\n  }\n  Object.defineProperty(Vue, 'config', configDef);\n\n  // exposed util methods.\n  // NOTE: these are not considered part of the public API - avoid relying on\n  // them unless you are aware of the risk.\n  Vue.util = {\n    warn: warn,\n    extend: extend,\n    mergeOptions: mergeOptions,\n    defineReactive: defineReactive$$1\n  };\n\n  Vue.set = set;\n  Vue.delete = del;\n  Vue.nextTick = nextTick;\n\n  // 2.6 explicit observable API\n  Vue.observable = function (obj) {\n    observe(obj);\n    return obj\n  };\n\n  Vue.options = Object.create(null);\n  ASSET_TYPES.forEach(function (type) {\n    Vue.options[type + 's'] = Object.create(null);\n  });\n\n  // this is used to identify the \"base\" constructor to extend all plain-object\n  // components with in Weex's multi-instance scenarios.\n  Vue.options._base = Vue;\n\n  extend(Vue.options.components, builtInComponents);\n\n  initUse(Vue);\n  initMixin$1(Vue);\n  initExtend(Vue);\n  initAssetRegisters(Vue);\n}\n\ninitGlobalAPI(Vue);\n\nObject.defineProperty(Vue.prototype, '$isServer', {\n  get: isServerRendering\n});\n\nObject.defineProperty(Vue.prototype, '$ssrContext', {\n  get: function get () {\n    /* istanbul ignore next */\n    return this.$vnode && this.$vnode.ssrContext\n  }\n});\n\n// expose FunctionalRenderContext for ssr runtime helper installation\nObject.defineProperty(Vue, 'FunctionalRenderContext', {\n  value: FunctionalRenderContext\n});\n\nVue.version = '2.6.12';\n\n/*  */\n\n// these are reserved for web because they are directly compiled away\n// during template compilation\nvar isReservedAttr = makeMap('style,class');\n\n// attributes that should be using props for binding\nvar acceptValue = makeMap('input,textarea,option,select,progress');\nvar mustUseProp = function (tag, type, attr) {\n  return (\n    (attr === 'value' && acceptValue(tag)) && type !== 'button' ||\n    (attr === 'selected' && tag === 'option') ||\n    (attr === 'checked' && tag === 'input') ||\n    (attr === 'muted' && tag === 'video')\n  )\n};\n\nvar isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');\n\nvar isValidContentEditableValue = makeMap('events,caret,typing,plaintext-only');\n\nvar convertEnumeratedValue = function (key, value) {\n  return isFalsyAttrValue(value) || value === 'false'\n    ? 'false'\n    // allow arbitrary string value for contenteditable\n    : key === 'contenteditable' && isValidContentEditableValue(value)\n      ? value\n      : 'true'\n};\n\nvar isBooleanAttr = makeMap(\n  'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +\n  'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +\n  'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +\n  'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +\n  'required,reversed,scoped,seamless,selected,sortable,translate,' +\n  'truespeed,typemustmatch,visible'\n);\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\n\nvar isXlink = function (name) {\n  return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'\n};\n\nvar getXlinkProp = function (name) {\n  return isXlink(name) ? name.slice(6, name.length) : ''\n};\n\nvar isFalsyAttrValue = function (val) {\n  return val == null || val === false\n};\n\n/*  */\n\nfunction genClassForVnode (vnode) {\n  var data = vnode.data;\n  var parentNode = vnode;\n  var childNode = vnode;\n  while (isDef(childNode.componentInstance)) {\n    childNode = childNode.componentInstance._vnode;\n    if (childNode && childNode.data) {\n      data = mergeClassData(childNode.data, data);\n    }\n  }\n  while (isDef(parentNode = parentNode.parent)) {\n    if (parentNode && parentNode.data) {\n      data = mergeClassData(data, parentNode.data);\n    }\n  }\n  return renderClass(data.staticClass, data.class)\n}\n\nfunction mergeClassData (child, parent) {\n  return {\n    staticClass: concat(child.staticClass, parent.staticClass),\n    class: isDef(child.class)\n      ? [child.class, parent.class]\n      : parent.class\n  }\n}\n\nfunction renderClass (\n  staticClass,\n  dynamicClass\n) {\n  if (isDef(staticClass) || isDef(dynamicClass)) {\n    return concat(staticClass, stringifyClass(dynamicClass))\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction concat (a, b) {\n  return a ? b ? (a + ' ' + b) : a : (b || '')\n}\n\nfunction stringifyClass (value) {\n  if (Array.isArray(value)) {\n    return stringifyArray(value)\n  }\n  if (isObject(value)) {\n    return stringifyObject(value)\n  }\n  if (typeof value === 'string') {\n    return value\n  }\n  /* istanbul ignore next */\n  return ''\n}\n\nfunction stringifyArray (value) {\n  var res = '';\n  var stringified;\n  for (var i = 0, l = value.length; i < l; i++) {\n    if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {\n      if (res) { res += ' '; }\n      res += stringified;\n    }\n  }\n  return res\n}\n\nfunction stringifyObject (value) {\n  var res = '';\n  for (var key in value) {\n    if (value[key]) {\n      if (res) { res += ' '; }\n      res += key;\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar namespaceMap = {\n  svg: 'http://www.w3.org/2000/svg',\n  math: 'http://www.w3.org/1998/Math/MathML'\n};\n\nvar isHTMLTag = makeMap(\n  'html,body,base,head,link,meta,style,title,' +\n  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +\n  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +\n  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +\n  's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +\n  'embed,object,param,source,canvas,script,noscript,del,ins,' +\n  'caption,col,colgroup,table,thead,tbody,td,th,tr,' +\n  'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +\n  'output,progress,select,textarea,' +\n  'details,dialog,menu,menuitem,summary,' +\n  'content,element,shadow,template,blockquote,iframe,tfoot'\n);\n\n// this map is intentionally selective, only covering SVG elements that may\n// contain child elements.\nvar isSVG = makeMap(\n  'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +\n  'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +\n  'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',\n  true\n);\n\nvar isPreTag = function (tag) { return tag === 'pre'; };\n\nvar isReservedTag = function (tag) {\n  return isHTMLTag(tag) || isSVG(tag)\n};\n\nfunction getTagNamespace (tag) {\n  if (isSVG(tag)) {\n    return 'svg'\n  }\n  // basic support for MathML\n  // note it doesn't support other MathML elements being component roots\n  if (tag === 'math') {\n    return 'math'\n  }\n}\n\nvar unknownElementCache = Object.create(null);\nfunction isUnknownElement (tag) {\n  /* istanbul ignore if */\n  if (!inBrowser) {\n    return true\n  }\n  if (isReservedTag(tag)) {\n    return false\n  }\n  tag = tag.toLowerCase();\n  /* istanbul ignore if */\n  if (unknownElementCache[tag] != null) {\n    return unknownElementCache[tag]\n  }\n  var el = document.createElement(tag);\n  if (tag.indexOf('-') > -1) {\n    // http://stackoverflow.com/a/28210364/1070244\n    return (unknownElementCache[tag] = (\n      el.constructor === window.HTMLUnknownElement ||\n      el.constructor === window.HTMLElement\n    ))\n  } else {\n    return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))\n  }\n}\n\nvar isTextInputType = makeMap('text,number,password,search,email,tel,url');\n\n/*  */\n\n/**\n * Query an element selector if it's not an element already.\n */\nfunction query (el) {\n  if (typeof el === 'string') {\n    var selected = document.querySelector(el);\n    if (!selected) {\n      process.env.NODE_ENV !== 'production' && warn(\n        'Cannot find element: ' + el\n      );\n      return document.createElement('div')\n    }\n    return selected\n  } else {\n    return el\n  }\n}\n\n/*  */\n\nfunction createElement$1 (tagName, vnode) {\n  var elm = document.createElement(tagName);\n  if (tagName !== 'select') {\n    return elm\n  }\n  // false or null will remove the attribute but undefined will not\n  if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {\n    elm.setAttribute('multiple', 'multiple');\n  }\n  return elm\n}\n\nfunction createElementNS (namespace, tagName) {\n  return document.createElementNS(namespaceMap[namespace], tagName)\n}\n\nfunction createTextNode (text) {\n  return document.createTextNode(text)\n}\n\nfunction createComment (text) {\n  return document.createComment(text)\n}\n\nfunction insertBefore (parentNode, newNode, referenceNode) {\n  parentNode.insertBefore(newNode, referenceNode);\n}\n\nfunction removeChild (node, child) {\n  node.removeChild(child);\n}\n\nfunction appendChild (node, child) {\n  node.appendChild(child);\n}\n\nfunction parentNode (node) {\n  return node.parentNode\n}\n\nfunction nextSibling (node) {\n  return node.nextSibling\n}\n\nfunction tagName (node) {\n  return node.tagName\n}\n\nfunction setTextContent (node, text) {\n  node.textContent = text;\n}\n\nfunction setStyleScope (node, scopeId) {\n  node.setAttribute(scopeId, '');\n}\n\nvar nodeOps = /*#__PURE__*/Object.freeze({\n  createElement: createElement$1,\n  createElementNS: createElementNS,\n  createTextNode: createTextNode,\n  createComment: createComment,\n  insertBefore: insertBefore,\n  removeChild: removeChild,\n  appendChild: appendChild,\n  parentNode: parentNode,\n  nextSibling: nextSibling,\n  tagName: tagName,\n  setTextContent: setTextContent,\n  setStyleScope: setStyleScope\n});\n\n/*  */\n\nvar ref = {\n  create: function create (_, vnode) {\n    registerRef(vnode);\n  },\n  update: function update (oldVnode, vnode) {\n    if (oldVnode.data.ref !== vnode.data.ref) {\n      registerRef(oldVnode, true);\n      registerRef(vnode);\n    }\n  },\n  destroy: function destroy (vnode) {\n    registerRef(vnode, true);\n  }\n};\n\nfunction registerRef (vnode, isRemoval) {\n  var key = vnode.data.ref;\n  if (!isDef(key)) { return }\n\n  var vm = vnode.context;\n  var ref = vnode.componentInstance || vnode.elm;\n  var refs = vm.$refs;\n  if (isRemoval) {\n    if (Array.isArray(refs[key])) {\n      remove(refs[key], ref);\n    } else if (refs[key] === ref) {\n      refs[key] = undefined;\n    }\n  } else {\n    if (vnode.data.refInFor) {\n      if (!Array.isArray(refs[key])) {\n        refs[key] = [ref];\n      } else if (refs[key].indexOf(ref) < 0) {\n        // $flow-disable-line\n        refs[key].push(ref);\n      }\n    } else {\n      refs[key] = ref;\n    }\n  }\n}\n\n/**\n * Virtual DOM patching algorithm based on Snabbdom by\n * Simon Friis Vindum (@paldepind)\n * Licensed under the MIT License\n * https://github.com/paldepind/snabbdom/blob/master/LICENSE\n *\n * modified by Evan You (@yyx990803)\n *\n * Not type-checking this because this file is perf-critical and the cost\n * of making flow understand it is not worth it.\n */\n\nvar emptyNode = new VNode('', {}, []);\n\nvar hooks = ['create', 'activate', 'update', 'remove', 'destroy'];\n\nfunction sameVnode (a, b) {\n  return (\n    a.key === b.key && (\n      (\n        a.tag === b.tag &&\n        a.isComment === b.isComment &&\n        isDef(a.data) === isDef(b.data) &&\n        sameInputType(a, b)\n      ) || (\n        isTrue(a.isAsyncPlaceholder) &&\n        a.asyncFactory === b.asyncFactory &&\n        isUndef(b.asyncFactory.error)\n      )\n    )\n  )\n}\n\nfunction sameInputType (a, b) {\n  if (a.tag !== 'input') { return true }\n  var i;\n  var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;\n  var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;\n  return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)\n}\n\nfunction createKeyToOldIdx (children, beginIdx, endIdx) {\n  var i, key;\n  var map = {};\n  for (i = beginIdx; i <= endIdx; ++i) {\n    key = children[i].key;\n    if (isDef(key)) { map[key] = i; }\n  }\n  return map\n}\n\nfunction createPatchFunction (backend) {\n  var i, j;\n  var cbs = {};\n\n  var modules = backend.modules;\n  var nodeOps = backend.nodeOps;\n\n  for (i = 0; i < hooks.length; ++i) {\n    cbs[hooks[i]] = [];\n    for (j = 0; j < modules.length; ++j) {\n      if (isDef(modules[j][hooks[i]])) {\n        cbs[hooks[i]].push(modules[j][hooks[i]]);\n      }\n    }\n  }\n\n  function emptyNodeAt (elm) {\n    return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)\n  }\n\n  function createRmCb (childElm, listeners) {\n    function remove$$1 () {\n      if (--remove$$1.listeners === 0) {\n        removeNode(childElm);\n      }\n    }\n    remove$$1.listeners = listeners;\n    return remove$$1\n  }\n\n  function removeNode (el) {\n    var parent = nodeOps.parentNode(el);\n    // element may have already been removed due to v-html / v-text\n    if (isDef(parent)) {\n      nodeOps.removeChild(parent, el);\n    }\n  }\n\n  function isUnknownElement$$1 (vnode, inVPre) {\n    return (\n      !inVPre &&\n      !vnode.ns &&\n      !(\n        config.ignoredElements.length &&\n        config.ignoredElements.some(function (ignore) {\n          return isRegExp(ignore)\n            ? ignore.test(vnode.tag)\n            : ignore === vnode.tag\n        })\n      ) &&\n      config.isUnknownElement(vnode.tag)\n    )\n  }\n\n  var creatingElmInVPre = 0;\n\n  function createElm (\n    vnode,\n    insertedVnodeQueue,\n    parentElm,\n    refElm,\n    nested,\n    ownerArray,\n    index\n  ) {\n    if (isDef(vnode.elm) && isDef(ownerArray)) {\n      // This vnode was used in a previous render!\n      // now it's used as a new node, overwriting its elm would cause\n      // potential patch errors down the road when it's used as an insertion\n      // reference node. Instead, we clone the node on-demand before creating\n      // associated DOM element for it.\n      vnode = ownerArray[index] = cloneVNode(vnode);\n    }\n\n    vnode.isRootInsert = !nested; // for transition enter check\n    if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {\n      return\n    }\n\n    var data = vnode.data;\n    var children = vnode.children;\n    var tag = vnode.tag;\n    if (isDef(tag)) {\n      if (process.env.NODE_ENV !== 'production') {\n        if (data && data.pre) {\n          creatingElmInVPre++;\n        }\n        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {\n          warn(\n            'Unknown custom element: <' + tag + '> - did you ' +\n            'register the component correctly? For recursive components, ' +\n            'make sure to provide the \"name\" option.',\n            vnode.context\n          );\n        }\n      }\n\n      vnode.elm = vnode.ns\n        ? nodeOps.createElementNS(vnode.ns, tag)\n        : nodeOps.createElement(tag, vnode);\n      setScope(vnode);\n\n      /* istanbul ignore if */\n      {\n        createChildren(vnode, children, insertedVnodeQueue);\n        if (isDef(data)) {\n          invokeCreateHooks(vnode, insertedVnodeQueue);\n        }\n        insert(parentElm, vnode.elm, refElm);\n      }\n\n      if (process.env.NODE_ENV !== 'production' && data && data.pre) {\n        creatingElmInVPre--;\n      }\n    } else if (isTrue(vnode.isComment)) {\n      vnode.elm = nodeOps.createComment(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    } else {\n      vnode.elm = nodeOps.createTextNode(vnode.text);\n      insert(parentElm, vnode.elm, refElm);\n    }\n  }\n\n  function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i = vnode.data;\n    if (isDef(i)) {\n      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;\n      if (isDef(i = i.hook) && isDef(i = i.init)) {\n        i(vnode, false /* hydrating */);\n      }\n      // after calling the init hook, if the vnode is a child component\n      // it should've created a child instance and mounted it. the child\n      // component also has set the placeholder vnode's elm.\n      // in that case we can just return the element and be done.\n      if (isDef(vnode.componentInstance)) {\n        initComponent(vnode, insertedVnodeQueue);\n        insert(parentElm, vnode.elm, refElm);\n        if (isTrue(isReactivated)) {\n          reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);\n        }\n        return true\n      }\n    }\n  }\n\n  function initComponent (vnode, insertedVnodeQueue) {\n    if (isDef(vnode.data.pendingInsert)) {\n      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);\n      vnode.data.pendingInsert = null;\n    }\n    vnode.elm = vnode.componentInstance.$el;\n    if (isPatchable(vnode)) {\n      invokeCreateHooks(vnode, insertedVnodeQueue);\n      setScope(vnode);\n    } else {\n      // empty component root.\n      // skip all element-related modules except for ref (#3455)\n      registerRef(vnode);\n      // make sure to invoke the insert hook\n      insertedVnodeQueue.push(vnode);\n    }\n  }\n\n  function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {\n    var i;\n    // hack for #4339: a reactivated component with inner transition\n    // does not trigger because the inner node's created hooks are not called\n    // again. It's not ideal to involve module-specific logic in here but\n    // there doesn't seem to be a better way to do it.\n    var innerNode = vnode;\n    while (innerNode.componentInstance) {\n      innerNode = innerNode.componentInstance._vnode;\n      if (isDef(i = innerNode.data) && isDef(i = i.transition)) {\n        for (i = 0; i < cbs.activate.length; ++i) {\n          cbs.activate[i](emptyNode, innerNode);\n        }\n        insertedVnodeQueue.push(innerNode);\n        break\n      }\n    }\n    // unlike a newly created component,\n    // a reactivated keep-alive component doesn't insert itself\n    insert(parentElm, vnode.elm, refElm);\n  }\n\n  function insert (parent, elm, ref$$1) {\n    if (isDef(parent)) {\n      if (isDef(ref$$1)) {\n        if (nodeOps.parentNode(ref$$1) === parent) {\n          nodeOps.insertBefore(parent, elm, ref$$1);\n        }\n      } else {\n        nodeOps.appendChild(parent, elm);\n      }\n    }\n  }\n\n  function createChildren (vnode, children, insertedVnodeQueue) {\n    if (Array.isArray(children)) {\n      if (process.env.NODE_ENV !== 'production') {\n        checkDuplicateKeys(children);\n      }\n      for (var i = 0; i < children.length; ++i) {\n        createElm(children[i], insertedVnodeQueue, vnode.elm, null, true, children, i);\n      }\n    } else if (isPrimitive(vnode.text)) {\n      nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));\n    }\n  }\n\n  function isPatchable (vnode) {\n    while (vnode.componentInstance) {\n      vnode = vnode.componentInstance._vnode;\n    }\n    return isDef(vnode.tag)\n  }\n\n  function invokeCreateHooks (vnode, insertedVnodeQueue) {\n    for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n      cbs.create[i$1](emptyNode, vnode);\n    }\n    i = vnode.data.hook; // Reuse variable\n    if (isDef(i)) {\n      if (isDef(i.create)) { i.create(emptyNode, vnode); }\n      if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }\n    }\n  }\n\n  // set scope id attribute for scoped CSS.\n  // this is implemented as a special case to avoid the overhead\n  // of going through the normal attribute patching process.\n  function setScope (vnode) {\n    var i;\n    if (isDef(i = vnode.fnScopeId)) {\n      nodeOps.setStyleScope(vnode.elm, i);\n    } else {\n      var ancestor = vnode;\n      while (ancestor) {\n        if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {\n          nodeOps.setStyleScope(vnode.elm, i);\n        }\n        ancestor = ancestor.parent;\n      }\n    }\n    // for slot content they should also get the scopeId from the host instance.\n    if (isDef(i = activeInstance) &&\n      i !== vnode.context &&\n      i !== vnode.fnContext &&\n      isDef(i = i.$options._scopeId)\n    ) {\n      nodeOps.setStyleScope(vnode.elm, i);\n    }\n  }\n\n  function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);\n    }\n  }\n\n  function invokeDestroyHook (vnode) {\n    var i, j;\n    var data = vnode.data;\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }\n      for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }\n    }\n    if (isDef(i = vnode.children)) {\n      for (j = 0; j < vnode.children.length; ++j) {\n        invokeDestroyHook(vnode.children[j]);\n      }\n    }\n  }\n\n  function removeVnodes (vnodes, startIdx, endIdx) {\n    for (; startIdx <= endIdx; ++startIdx) {\n      var ch = vnodes[startIdx];\n      if (isDef(ch)) {\n        if (isDef(ch.tag)) {\n          removeAndInvokeRemoveHook(ch);\n          invokeDestroyHook(ch);\n        } else { // Text node\n          removeNode(ch.elm);\n        }\n      }\n    }\n  }\n\n  function removeAndInvokeRemoveHook (vnode, rm) {\n    if (isDef(rm) || isDef(vnode.data)) {\n      var i;\n      var listeners = cbs.remove.length + 1;\n      if (isDef(rm)) {\n        // we have a recursively passed down rm callback\n        // increase the listeners count\n        rm.listeners += listeners;\n      } else {\n        // directly removing\n        rm = createRmCb(vnode.elm, listeners);\n      }\n      // recursively invoke hooks on child component root node\n      if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {\n        removeAndInvokeRemoveHook(i, rm);\n      }\n      for (i = 0; i < cbs.remove.length; ++i) {\n        cbs.remove[i](vnode, rm);\n      }\n      if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {\n        i(vnode, rm);\n      } else {\n        rm();\n      }\n    } else {\n      removeNode(vnode.elm);\n    }\n  }\n\n  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {\n    var oldStartIdx = 0;\n    var newStartIdx = 0;\n    var oldEndIdx = oldCh.length - 1;\n    var oldStartVnode = oldCh[0];\n    var oldEndVnode = oldCh[oldEndIdx];\n    var newEndIdx = newCh.length - 1;\n    var newStartVnode = newCh[0];\n    var newEndVnode = newCh[newEndIdx];\n    var oldKeyToIdx, idxInOld, vnodeToMove, refElm;\n\n    // removeOnly is a special flag used only by <transition-group>\n    // to ensure removed elements stay in correct relative positions\n    // during leaving transitions\n    var canMove = !removeOnly;\n\n    if (process.env.NODE_ENV !== 'production') {\n      checkDuplicateKeys(newCh);\n    }\n\n    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {\n      if (isUndef(oldStartVnode)) {\n        oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left\n      } else if (isUndef(oldEndVnode)) {\n        oldEndVnode = oldCh[--oldEndIdx];\n      } else if (sameVnode(oldStartVnode, newStartVnode)) {\n        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n        oldStartVnode = oldCh[++oldStartIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else if (sameVnode(oldEndVnode, newEndVnode)) {\n        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right\n        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);\n        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));\n        oldStartVnode = oldCh[++oldStartIdx];\n        newEndVnode = newCh[--newEndIdx];\n      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left\n        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);\n        oldEndVnode = oldCh[--oldEndIdx];\n        newStartVnode = newCh[++newStartIdx];\n      } else {\n        if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }\n        idxInOld = isDef(newStartVnode.key)\n          ? oldKeyToIdx[newStartVnode.key]\n          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);\n        if (isUndef(idxInOld)) { // New element\n          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n        } else {\n          vnodeToMove = oldCh[idxInOld];\n          if (sameVnode(vnodeToMove, newStartVnode)) {\n            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);\n            oldCh[idxInOld] = undefined;\n            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm);\n          } else {\n            // same key but different element. treat as new element\n            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);\n          }\n        }\n        newStartVnode = newCh[++newStartIdx];\n      }\n    }\n    if (oldStartIdx > oldEndIdx) {\n      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;\n      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);\n    } else if (newStartIdx > newEndIdx) {\n      removeVnodes(oldCh, oldStartIdx, oldEndIdx);\n    }\n  }\n\n  function checkDuplicateKeys (children) {\n    var seenKeys = {};\n    for (var i = 0; i < children.length; i++) {\n      var vnode = children[i];\n      var key = vnode.key;\n      if (isDef(key)) {\n        if (seenKeys[key]) {\n          warn(\n            (\"Duplicate keys detected: '\" + key + \"'. This may cause an update error.\"),\n            vnode.context\n          );\n        } else {\n          seenKeys[key] = true;\n        }\n      }\n    }\n  }\n\n  function findIdxInOld (node, oldCh, start, end) {\n    for (var i = start; i < end; i++) {\n      var c = oldCh[i];\n      if (isDef(c) && sameVnode(node, c)) { return i }\n    }\n  }\n\n  function patchVnode (\n    oldVnode,\n    vnode,\n    insertedVnodeQueue,\n    ownerArray,\n    index,\n    removeOnly\n  ) {\n    if (oldVnode === vnode) {\n      return\n    }\n\n    if (isDef(vnode.elm) && isDef(ownerArray)) {\n      // clone reused vnode\n      vnode = ownerArray[index] = cloneVNode(vnode);\n    }\n\n    var elm = vnode.elm = oldVnode.elm;\n\n    if (isTrue(oldVnode.isAsyncPlaceholder)) {\n      if (isDef(vnode.asyncFactory.resolved)) {\n        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);\n      } else {\n        vnode.isAsyncPlaceholder = true;\n      }\n      return\n    }\n\n    // reuse element for static trees.\n    // note we only do this if the vnode is cloned -\n    // if the new node is not cloned it means the render functions have been\n    // reset by the hot-reload-api and we need to do a proper re-render.\n    if (isTrue(vnode.isStatic) &&\n      isTrue(oldVnode.isStatic) &&\n      vnode.key === oldVnode.key &&\n      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))\n    ) {\n      vnode.componentInstance = oldVnode.componentInstance;\n      return\n    }\n\n    var i;\n    var data = vnode.data;\n    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {\n      i(oldVnode, vnode);\n    }\n\n    var oldCh = oldVnode.children;\n    var ch = vnode.children;\n    if (isDef(data) && isPatchable(vnode)) {\n      for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }\n      if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }\n    }\n    if (isUndef(vnode.text)) {\n      if (isDef(oldCh) && isDef(ch)) {\n        if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }\n      } else if (isDef(ch)) {\n        if (process.env.NODE_ENV !== 'production') {\n          checkDuplicateKeys(ch);\n        }\n        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }\n        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);\n      } else if (isDef(oldCh)) {\n        removeVnodes(oldCh, 0, oldCh.length - 1);\n      } else if (isDef(oldVnode.text)) {\n        nodeOps.setTextContent(elm, '');\n      }\n    } else if (oldVnode.text !== vnode.text) {\n      nodeOps.setTextContent(elm, vnode.text);\n    }\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }\n    }\n  }\n\n  function invokeInsertHook (vnode, queue, initial) {\n    // delay insert hooks for component root nodes, invoke them after the\n    // element is really inserted\n    if (isTrue(initial) && isDef(vnode.parent)) {\n      vnode.parent.data.pendingInsert = queue;\n    } else {\n      for (var i = 0; i < queue.length; ++i) {\n        queue[i].data.hook.insert(queue[i]);\n      }\n    }\n  }\n\n  var hydrationBailed = false;\n  // list of modules that can skip create hook during hydration because they\n  // are already rendered on the client or has no need for initialization\n  // Note: style is excluded because it relies on initial clone for future\n  // deep updates (#7063).\n  var isRenderedModule = makeMap('attrs,class,staticClass,staticStyle,key');\n\n  // Note: this is a browser-only function so we can assume elms are DOM nodes.\n  function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {\n    var i;\n    var tag = vnode.tag;\n    var data = vnode.data;\n    var children = vnode.children;\n    inVPre = inVPre || (data && data.pre);\n    vnode.elm = elm;\n\n    if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {\n      vnode.isAsyncPlaceholder = true;\n      return true\n    }\n    // assert node match\n    if (process.env.NODE_ENV !== 'production') {\n      if (!assertNodeMatch(elm, vnode, inVPre)) {\n        return false\n      }\n    }\n    if (isDef(data)) {\n      if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }\n      if (isDef(i = vnode.componentInstance)) {\n        // child component. it should have hydrated its own tree.\n        initComponent(vnode, insertedVnodeQueue);\n        return true\n      }\n    }\n    if (isDef(tag)) {\n      if (isDef(children)) {\n        // empty element, allow client to pick up and populate children\n        if (!elm.hasChildNodes()) {\n          createChildren(vnode, children, insertedVnodeQueue);\n        } else {\n          // v-html and domProps: innerHTML\n          if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {\n            if (i !== elm.innerHTML) {\n              /* istanbul ignore if */\n              if (process.env.NODE_ENV !== 'production' &&\n                typeof console !== 'undefined' &&\n                !hydrationBailed\n              ) {\n                hydrationBailed = true;\n                console.warn('Parent: ', elm);\n                console.warn('server innerHTML: ', i);\n                console.warn('client innerHTML: ', elm.innerHTML);\n              }\n              return false\n            }\n          } else {\n            // iterate and compare children lists\n            var childrenMatch = true;\n            var childNode = elm.firstChild;\n            for (var i$1 = 0; i$1 < children.length; i$1++) {\n              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {\n                childrenMatch = false;\n                break\n              }\n              childNode = childNode.nextSibling;\n            }\n            // if childNode is not null, it means the actual childNodes list is\n            // longer than the virtual children list.\n            if (!childrenMatch || childNode) {\n              /* istanbul ignore if */\n              if (process.env.NODE_ENV !== 'production' &&\n                typeof console !== 'undefined' &&\n                !hydrationBailed\n              ) {\n                hydrationBailed = true;\n                console.warn('Parent: ', elm);\n                console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);\n              }\n              return false\n            }\n          }\n        }\n      }\n      if (isDef(data)) {\n        var fullInvoke = false;\n        for (var key in data) {\n          if (!isRenderedModule(key)) {\n            fullInvoke = true;\n            invokeCreateHooks(vnode, insertedVnodeQueue);\n            break\n          }\n        }\n        if (!fullInvoke && data['class']) {\n          // ensure collecting deps for deep class bindings for future updates\n          traverse(data['class']);\n        }\n      }\n    } else if (elm.data !== vnode.text) {\n      elm.data = vnode.text;\n    }\n    return true\n  }\n\n  function assertNodeMatch (node, vnode, inVPre) {\n    if (isDef(vnode.tag)) {\n      return vnode.tag.indexOf('vue-component') === 0 || (\n        !isUnknownElement$$1(vnode, inVPre) &&\n        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())\n      )\n    } else {\n      return node.nodeType === (vnode.isComment ? 8 : 3)\n    }\n  }\n\n  return function patch (oldVnode, vnode, hydrating, removeOnly) {\n    if (isUndef(vnode)) {\n      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }\n      return\n    }\n\n    var isInitialPatch = false;\n    var insertedVnodeQueue = [];\n\n    if (isUndef(oldVnode)) {\n      // empty mount (likely as component), create new root element\n      isInitialPatch = true;\n      createElm(vnode, insertedVnodeQueue);\n    } else {\n      var isRealElement = isDef(oldVnode.nodeType);\n      if (!isRealElement && sameVnode(oldVnode, vnode)) {\n        // patch existing root node\n        patchVnode(oldVnode, vnode, insertedVnodeQueue, null, null, removeOnly);\n      } else {\n        if (isRealElement) {\n          // mounting to a real element\n          // check if this is server-rendered content and if we can perform\n          // a successful hydration.\n          if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {\n            oldVnode.removeAttribute(SSR_ATTR);\n            hydrating = true;\n          }\n          if (isTrue(hydrating)) {\n            if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {\n              invokeInsertHook(vnode, insertedVnodeQueue, true);\n              return oldVnode\n            } else if (process.env.NODE_ENV !== 'production') {\n              warn(\n                'The client-side rendered virtual DOM tree is not matching ' +\n                'server-rendered content. This is likely caused by incorrect ' +\n                'HTML markup, for example nesting block-level elements inside ' +\n                '<p>, or missing <tbody>. Bailing hydration and performing ' +\n                'full client-side render.'\n              );\n            }\n          }\n          // either not server-rendered, or hydration failed.\n          // create an empty node and replace it\n          oldVnode = emptyNodeAt(oldVnode);\n        }\n\n        // replacing existing element\n        var oldElm = oldVnode.elm;\n        var parentElm = nodeOps.parentNode(oldElm);\n\n        // create new node\n        createElm(\n          vnode,\n          insertedVnodeQueue,\n          // extremely rare edge case: do not insert if old element is in a\n          // leaving transition. Only happens when combining transition +\n          // keep-alive + HOCs. (#4590)\n          oldElm._leaveCb ? null : parentElm,\n          nodeOps.nextSibling(oldElm)\n        );\n\n        // update parent placeholder node element, recursively\n        if (isDef(vnode.parent)) {\n          var ancestor = vnode.parent;\n          var patchable = isPatchable(vnode);\n          while (ancestor) {\n            for (var i = 0; i < cbs.destroy.length; ++i) {\n              cbs.destroy[i](ancestor);\n            }\n            ancestor.elm = vnode.elm;\n            if (patchable) {\n              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {\n                cbs.create[i$1](emptyNode, ancestor);\n              }\n              // #6513\n              // invoke insert hooks that may have been merged by create hooks.\n              // e.g. for directives that uses the \"inserted\" hook.\n              var insert = ancestor.data.hook.insert;\n              if (insert.merged) {\n                // start at index 1 to avoid re-invoking component mounted hook\n                for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {\n                  insert.fns[i$2]();\n                }\n              }\n            } else {\n              registerRef(ancestor);\n            }\n            ancestor = ancestor.parent;\n          }\n        }\n\n        // destroy old node\n        if (isDef(parentElm)) {\n          removeVnodes([oldVnode], 0, 0);\n        } else if (isDef(oldVnode.tag)) {\n          invokeDestroyHook(oldVnode);\n        }\n      }\n    }\n\n    invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);\n    return vnode.elm\n  }\n}\n\n/*  */\n\nvar directives = {\n  create: updateDirectives,\n  update: updateDirectives,\n  destroy: function unbindDirectives (vnode) {\n    updateDirectives(vnode, emptyNode);\n  }\n};\n\nfunction updateDirectives (oldVnode, vnode) {\n  if (oldVnode.data.directives || vnode.data.directives) {\n    _update(oldVnode, vnode);\n  }\n}\n\nfunction _update (oldVnode, vnode) {\n  var isCreate = oldVnode === emptyNode;\n  var isDestroy = vnode === emptyNode;\n  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);\n  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);\n\n  var dirsWithInsert = [];\n  var dirsWithPostpatch = [];\n\n  var key, oldDir, dir;\n  for (key in newDirs) {\n    oldDir = oldDirs[key];\n    dir = newDirs[key];\n    if (!oldDir) {\n      // new directive, bind\n      callHook$1(dir, 'bind', vnode, oldVnode);\n      if (dir.def && dir.def.inserted) {\n        dirsWithInsert.push(dir);\n      }\n    } else {\n      // existing directive, update\n      dir.oldValue = oldDir.value;\n      dir.oldArg = oldDir.arg;\n      callHook$1(dir, 'update', vnode, oldVnode);\n      if (dir.def && dir.def.componentUpdated) {\n        dirsWithPostpatch.push(dir);\n      }\n    }\n  }\n\n  if (dirsWithInsert.length) {\n    var callInsert = function () {\n      for (var i = 0; i < dirsWithInsert.length; i++) {\n        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);\n      }\n    };\n    if (isCreate) {\n      mergeVNodeHook(vnode, 'insert', callInsert);\n    } else {\n      callInsert();\n    }\n  }\n\n  if (dirsWithPostpatch.length) {\n    mergeVNodeHook(vnode, 'postpatch', function () {\n      for (var i = 0; i < dirsWithPostpatch.length; i++) {\n        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);\n      }\n    });\n  }\n\n  if (!isCreate) {\n    for (key in oldDirs) {\n      if (!newDirs[key]) {\n        // no longer present, unbind\n        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);\n      }\n    }\n  }\n}\n\nvar emptyModifiers = Object.create(null);\n\nfunction normalizeDirectives$1 (\n  dirs,\n  vm\n) {\n  var res = Object.create(null);\n  if (!dirs) {\n    // $flow-disable-line\n    return res\n  }\n  var i, dir;\n  for (i = 0; i < dirs.length; i++) {\n    dir = dirs[i];\n    if (!dir.modifiers) {\n      // $flow-disable-line\n      dir.modifiers = emptyModifiers;\n    }\n    res[getRawDirName(dir)] = dir;\n    dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);\n  }\n  // $flow-disable-line\n  return res\n}\n\nfunction getRawDirName (dir) {\n  return dir.rawName || ((dir.name) + \".\" + (Object.keys(dir.modifiers || {}).join('.')))\n}\n\nfunction callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {\n  var fn = dir.def && dir.def[hook];\n  if (fn) {\n    try {\n      fn(vnode.elm, dir, vnode, oldVnode, isDestroy);\n    } catch (e) {\n      handleError(e, vnode.context, (\"directive \" + (dir.name) + \" \" + hook + \" hook\"));\n    }\n  }\n}\n\nvar baseModules = [\n  ref,\n  directives\n];\n\n/*  */\n\nfunction updateAttrs (oldVnode, vnode) {\n  var opts = vnode.componentOptions;\n  if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {\n    return\n  }\n  if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {\n    return\n  }\n  var key, cur, old;\n  var elm = vnode.elm;\n  var oldAttrs = oldVnode.data.attrs || {};\n  var attrs = vnode.data.attrs || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (isDef(attrs.__ob__)) {\n    attrs = vnode.data.attrs = extend({}, attrs);\n  }\n\n  for (key in attrs) {\n    cur = attrs[key];\n    old = oldAttrs[key];\n    if (old !== cur) {\n      setAttr(elm, key, cur);\n    }\n  }\n  // #4391: in IE9, setting type can reset value for input[type=radio]\n  // #6666: IE/Edge forces progress value down to 1 before setting a max\n  /* istanbul ignore if */\n  if ((isIE || isEdge) && attrs.value !== oldAttrs.value) {\n    setAttr(elm, 'value', attrs.value);\n  }\n  for (key in oldAttrs) {\n    if (isUndef(attrs[key])) {\n      if (isXlink(key)) {\n        elm.removeAttributeNS(xlinkNS, getXlinkProp(key));\n      } else if (!isEnumeratedAttr(key)) {\n        elm.removeAttribute(key);\n      }\n    }\n  }\n}\n\nfunction setAttr (el, key, value) {\n  if (el.tagName.indexOf('-') > -1) {\n    baseSetAttr(el, key, value);\n  } else if (isBooleanAttr(key)) {\n    // set attribute for blank value\n    // e.g. <option disabled>Select one</option>\n    if (isFalsyAttrValue(value)) {\n      el.removeAttribute(key);\n    } else {\n      // technically allowfullscreen is a boolean attribute for <iframe>,\n      // but Flash expects a value of \"true\" when used on <embed> tag\n      value = key === 'allowfullscreen' && el.tagName === 'EMBED'\n        ? 'true'\n        : key;\n      el.setAttribute(key, value);\n    }\n  } else if (isEnumeratedAttr(key)) {\n    el.setAttribute(key, convertEnumeratedValue(key, value));\n  } else if (isXlink(key)) {\n    if (isFalsyAttrValue(value)) {\n      el.removeAttributeNS(xlinkNS, getXlinkProp(key));\n    } else {\n      el.setAttributeNS(xlinkNS, key, value);\n    }\n  } else {\n    baseSetAttr(el, key, value);\n  }\n}\n\nfunction baseSetAttr (el, key, value) {\n  if (isFalsyAttrValue(value)) {\n    el.removeAttribute(key);\n  } else {\n    // #7138: IE10 & 11 fires input event when setting placeholder on\n    // <textarea>... block the first input event and remove the blocker\n    // immediately.\n    /* istanbul ignore if */\n    if (\n      isIE && !isIE9 &&\n      el.tagName === 'TEXTAREA' &&\n      key === 'placeholder' && value !== '' && !el.__ieph\n    ) {\n      var blocker = function (e) {\n        e.stopImmediatePropagation();\n        el.removeEventListener('input', blocker);\n      };\n      el.addEventListener('input', blocker);\n      // $flow-disable-line\n      el.__ieph = true; /* IE placeholder patched */\n    }\n    el.setAttribute(key, value);\n  }\n}\n\nvar attrs = {\n  create: updateAttrs,\n  update: updateAttrs\n};\n\n/*  */\n\nfunction updateClass (oldVnode, vnode) {\n  var el = vnode.elm;\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n  if (\n    isUndef(data.staticClass) &&\n    isUndef(data.class) && (\n      isUndef(oldData) || (\n        isUndef(oldData.staticClass) &&\n        isUndef(oldData.class)\n      )\n    )\n  ) {\n    return\n  }\n\n  var cls = genClassForVnode(vnode);\n\n  // handle transition classes\n  var transitionClass = el._transitionClasses;\n  if (isDef(transitionClass)) {\n    cls = concat(cls, stringifyClass(transitionClass));\n  }\n\n  // set the class\n  if (cls !== el._prevClass) {\n    el.setAttribute('class', cls);\n    el._prevClass = cls;\n  }\n}\n\nvar klass = {\n  create: updateClass,\n  update: updateClass\n};\n\n/*  */\n\nvar validDivisionCharRE = /[\\w).+\\-_$\\]]/;\n\nfunction parseFilters (exp) {\n  var inSingle = false;\n  var inDouble = false;\n  var inTemplateString = false;\n  var inRegex = false;\n  var curly = 0;\n  var square = 0;\n  var paren = 0;\n  var lastFilterIndex = 0;\n  var c, prev, i, expression, filters;\n\n  for (i = 0; i < exp.length; i++) {\n    prev = c;\n    c = exp.charCodeAt(i);\n    if (inSingle) {\n      if (c === 0x27 && prev !== 0x5C) { inSingle = false; }\n    } else if (inDouble) {\n      if (c === 0x22 && prev !== 0x5C) { inDouble = false; }\n    } else if (inTemplateString) {\n      if (c === 0x60 && prev !== 0x5C) { inTemplateString = false; }\n    } else if (inRegex) {\n      if (c === 0x2f && prev !== 0x5C) { inRegex = false; }\n    } else if (\n      c === 0x7C && // pipe\n      exp.charCodeAt(i + 1) !== 0x7C &&\n      exp.charCodeAt(i - 1) !== 0x7C &&\n      !curly && !square && !paren\n    ) {\n      if (expression === undefined) {\n        // first filter, end of expression\n        lastFilterIndex = i + 1;\n        expression = exp.slice(0, i).trim();\n      } else {\n        pushFilter();\n      }\n    } else {\n      switch (c) {\n        case 0x22: inDouble = true; break         // \"\n        case 0x27: inSingle = true; break         // '\n        case 0x60: inTemplateString = true; break // `\n        case 0x28: paren++; break                 // (\n        case 0x29: paren--; break                 // )\n        case 0x5B: square++; break                // [\n        case 0x5D: square--; break                // ]\n        case 0x7B: curly++; break                 // {\n        case 0x7D: curly--; break                 // }\n      }\n      if (c === 0x2f) { // /\n        var j = i - 1;\n        var p = (void 0);\n        // find first non-whitespace prev char\n        for (; j >= 0; j--) {\n          p = exp.charAt(j);\n          if (p !== ' ') { break }\n        }\n        if (!p || !validDivisionCharRE.test(p)) {\n          inRegex = true;\n        }\n      }\n    }\n  }\n\n  if (expression === undefined) {\n    expression = exp.slice(0, i).trim();\n  } else if (lastFilterIndex !== 0) {\n    pushFilter();\n  }\n\n  function pushFilter () {\n    (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());\n    lastFilterIndex = i + 1;\n  }\n\n  if (filters) {\n    for (i = 0; i < filters.length; i++) {\n      expression = wrapFilter(expression, filters[i]);\n    }\n  }\n\n  return expression\n}\n\nfunction wrapFilter (exp, filter) {\n  var i = filter.indexOf('(');\n  if (i < 0) {\n    // _f: resolveFilter\n    return (\"_f(\\\"\" + filter + \"\\\")(\" + exp + \")\")\n  } else {\n    var name = filter.slice(0, i);\n    var args = filter.slice(i + 1);\n    return (\"_f(\\\"\" + name + \"\\\")(\" + exp + (args !== ')' ? ',' + args : args))\n  }\n}\n\n/*  */\n\n\n\n/* eslint-disable no-unused-vars */\nfunction baseWarn (msg, range) {\n  console.error((\"[Vue compiler]: \" + msg));\n}\n/* eslint-enable no-unused-vars */\n\nfunction pluckModuleFunction (\n  modules,\n  key\n) {\n  return modules\n    ? modules.map(function (m) { return m[key]; }).filter(function (_) { return _; })\n    : []\n}\n\nfunction addProp (el, name, value, range, dynamic) {\n  (el.props || (el.props = [])).push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));\n  el.plain = false;\n}\n\nfunction addAttr (el, name, value, range, dynamic) {\n  var attrs = dynamic\n    ? (el.dynamicAttrs || (el.dynamicAttrs = []))\n    : (el.attrs || (el.attrs = []));\n  attrs.push(rangeSetItem({ name: name, value: value, dynamic: dynamic }, range));\n  el.plain = false;\n}\n\n// add a raw attr (use this in preTransforms)\nfunction addRawAttr (el, name, value, range) {\n  el.attrsMap[name] = value;\n  el.attrsList.push(rangeSetItem({ name: name, value: value }, range));\n}\n\nfunction addDirective (\n  el,\n  name,\n  rawName,\n  value,\n  arg,\n  isDynamicArg,\n  modifiers,\n  range\n) {\n  (el.directives || (el.directives = [])).push(rangeSetItem({\n    name: name,\n    rawName: rawName,\n    value: value,\n    arg: arg,\n    isDynamicArg: isDynamicArg,\n    modifiers: modifiers\n  }, range));\n  el.plain = false;\n}\n\nfunction prependModifierMarker (symbol, name, dynamic) {\n  return dynamic\n    ? (\"_p(\" + name + \",\\\"\" + symbol + \"\\\")\")\n    : symbol + name // mark the event as captured\n}\n\nfunction addHandler (\n  el,\n  name,\n  value,\n  modifiers,\n  important,\n  warn,\n  range,\n  dynamic\n) {\n  modifiers = modifiers || emptyObject;\n  // warn prevent and passive modifier\n  /* istanbul ignore if */\n  if (\n    process.env.NODE_ENV !== 'production' && warn &&\n    modifiers.prevent && modifiers.passive\n  ) {\n    warn(\n      'passive and prevent can\\'t be used together. ' +\n      'Passive handler can\\'t prevent default event.',\n      range\n    );\n  }\n\n  // normalize click.right and click.middle since they don't actually fire\n  // this is technically browser-specific, but at least for now browsers are\n  // the only target envs that have right/middle clicks.\n  if (modifiers.right) {\n    if (dynamic) {\n      name = \"(\" + name + \")==='click'?'contextmenu':(\" + name + \")\";\n    } else if (name === 'click') {\n      name = 'contextmenu';\n      delete modifiers.right;\n    }\n  } else if (modifiers.middle) {\n    if (dynamic) {\n      name = \"(\" + name + \")==='click'?'mouseup':(\" + name + \")\";\n    } else if (name === 'click') {\n      name = 'mouseup';\n    }\n  }\n\n  // check capture modifier\n  if (modifiers.capture) {\n    delete modifiers.capture;\n    name = prependModifierMarker('!', name, dynamic);\n  }\n  if (modifiers.once) {\n    delete modifiers.once;\n    name = prependModifierMarker('~', name, dynamic);\n  }\n  /* istanbul ignore if */\n  if (modifiers.passive) {\n    delete modifiers.passive;\n    name = prependModifierMarker('&', name, dynamic);\n  }\n\n  var events;\n  if (modifiers.native) {\n    delete modifiers.native;\n    events = el.nativeEvents || (el.nativeEvents = {});\n  } else {\n    events = el.events || (el.events = {});\n  }\n\n  var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);\n  if (modifiers !== emptyObject) {\n    newHandler.modifiers = modifiers;\n  }\n\n  var handlers = events[name];\n  /* istanbul ignore if */\n  if (Array.isArray(handlers)) {\n    important ? handlers.unshift(newHandler) : handlers.push(newHandler);\n  } else if (handlers) {\n    events[name] = important ? [newHandler, handlers] : [handlers, newHandler];\n  } else {\n    events[name] = newHandler;\n  }\n\n  el.plain = false;\n}\n\nfunction getRawBindingAttr (\n  el,\n  name\n) {\n  return el.rawAttrsMap[':' + name] ||\n    el.rawAttrsMap['v-bind:' + name] ||\n    el.rawAttrsMap[name]\n}\n\nfunction getBindingAttr (\n  el,\n  name,\n  getStatic\n) {\n  var dynamicValue =\n    getAndRemoveAttr(el, ':' + name) ||\n    getAndRemoveAttr(el, 'v-bind:' + name);\n  if (dynamicValue != null) {\n    return parseFilters(dynamicValue)\n  } else if (getStatic !== false) {\n    var staticValue = getAndRemoveAttr(el, name);\n    if (staticValue != null) {\n      return JSON.stringify(staticValue)\n    }\n  }\n}\n\n// note: this only removes the attr from the Array (attrsList) so that it\n// doesn't get processed by processAttrs.\n// By default it does NOT remove it from the map (attrsMap) because the map is\n// needed during codegen.\nfunction getAndRemoveAttr (\n  el,\n  name,\n  removeFromMap\n) {\n  var val;\n  if ((val = el.attrsMap[name]) != null) {\n    var list = el.attrsList;\n    for (var i = 0, l = list.length; i < l; i++) {\n      if (list[i].name === name) {\n        list.splice(i, 1);\n        break\n      }\n    }\n  }\n  if (removeFromMap) {\n    delete el.attrsMap[name];\n  }\n  return val\n}\n\nfunction getAndRemoveAttrByRegex (\n  el,\n  name\n) {\n  var list = el.attrsList;\n  for (var i = 0, l = list.length; i < l; i++) {\n    var attr = list[i];\n    if (name.test(attr.name)) {\n      list.splice(i, 1);\n      return attr\n    }\n  }\n}\n\nfunction rangeSetItem (\n  item,\n  range\n) {\n  if (range) {\n    if (range.start != null) {\n      item.start = range.start;\n    }\n    if (range.end != null) {\n      item.end = range.end;\n    }\n  }\n  return item\n}\n\n/*  */\n\n/**\n * Cross-platform code generation for component v-model\n */\nfunction genComponentModel (\n  el,\n  value,\n  modifiers\n) {\n  var ref = modifiers || {};\n  var number = ref.number;\n  var trim = ref.trim;\n\n  var baseValueExpression = '$$v';\n  var valueExpression = baseValueExpression;\n  if (trim) {\n    valueExpression =\n      \"(typeof \" + baseValueExpression + \" === 'string'\" +\n      \"? \" + baseValueExpression + \".trim()\" +\n      \": \" + baseValueExpression + \")\";\n  }\n  if (number) {\n    valueExpression = \"_n(\" + valueExpression + \")\";\n  }\n  var assignment = genAssignmentCode(value, valueExpression);\n\n  el.model = {\n    value: (\"(\" + value + \")\"),\n    expression: JSON.stringify(value),\n    callback: (\"function (\" + baseValueExpression + \") {\" + assignment + \"}\")\n  };\n}\n\n/**\n * Cross-platform codegen helper for generating v-model value assignment code.\n */\nfunction genAssignmentCode (\n  value,\n  assignment\n) {\n  var res = parseModel(value);\n  if (res.key === null) {\n    return (value + \"=\" + assignment)\n  } else {\n    return (\"$set(\" + (res.exp) + \", \" + (res.key) + \", \" + assignment + \")\")\n  }\n}\n\n/**\n * Parse a v-model expression into a base path and a final key segment.\n * Handles both dot-path and possible square brackets.\n *\n * Possible cases:\n *\n * - test\n * - test[key]\n * - test[test1[key]]\n * - test[\"a\"][key]\n * - xxx.test[a[a].test1[key]]\n * - test.xxx.a[\"asa\"][test1[key]]\n *\n */\n\nvar len, str, chr, index$1, expressionPos, expressionEndPos;\n\n\n\nfunction parseModel (val) {\n  // Fix https://github.com/vuejs/vue/pull/7730\n  // allow v-model=\"obj.val \" (trailing whitespace)\n  val = val.trim();\n  len = val.length;\n\n  if (val.indexOf('[') < 0 || val.lastIndexOf(']') < len - 1) {\n    index$1 = val.lastIndexOf('.');\n    if (index$1 > -1) {\n      return {\n        exp: val.slice(0, index$1),\n        key: '\"' + val.slice(index$1 + 1) + '\"'\n      }\n    } else {\n      return {\n        exp: val,\n        key: null\n      }\n    }\n  }\n\n  str = val;\n  index$1 = expressionPos = expressionEndPos = 0;\n\n  while (!eof()) {\n    chr = next();\n    /* istanbul ignore if */\n    if (isStringStart(chr)) {\n      parseString(chr);\n    } else if (chr === 0x5B) {\n      parseBracket(chr);\n    }\n  }\n\n  return {\n    exp: val.slice(0, expressionPos),\n    key: val.slice(expressionPos + 1, expressionEndPos)\n  }\n}\n\nfunction next () {\n  return str.charCodeAt(++index$1)\n}\n\nfunction eof () {\n  return index$1 >= len\n}\n\nfunction isStringStart (chr) {\n  return chr === 0x22 || chr === 0x27\n}\n\nfunction parseBracket (chr) {\n  var inBracket = 1;\n  expressionPos = index$1;\n  while (!eof()) {\n    chr = next();\n    if (isStringStart(chr)) {\n      parseString(chr);\n      continue\n    }\n    if (chr === 0x5B) { inBracket++; }\n    if (chr === 0x5D) { inBracket--; }\n    if (inBracket === 0) {\n      expressionEndPos = index$1;\n      break\n    }\n  }\n}\n\nfunction parseString (chr) {\n  var stringQuote = chr;\n  while (!eof()) {\n    chr = next();\n    if (chr === stringQuote) {\n      break\n    }\n  }\n}\n\n/*  */\n\nvar warn$1;\n\n// in some cases, the event used has to be determined at runtime\n// so we used some reserved tokens during compile.\nvar RANGE_TOKEN = '__r';\nvar CHECKBOX_RADIO_TOKEN = '__c';\n\nfunction model (\n  el,\n  dir,\n  _warn\n) {\n  warn$1 = _warn;\n  var value = dir.value;\n  var modifiers = dir.modifiers;\n  var tag = el.tag;\n  var type = el.attrsMap.type;\n\n  if (process.env.NODE_ENV !== 'production') {\n    // inputs with type=\"file\" are read only and setting the input's\n    // value will throw an error.\n    if (tag === 'input' && type === 'file') {\n      warn$1(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\" type=\\\"file\\\">:\\n\" +\n        \"File inputs are read only. Use a v-on:change listener instead.\",\n        el.rawAttrsMap['v-model']\n      );\n    }\n  }\n\n  if (el.component) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false\n  } else if (tag === 'select') {\n    genSelect(el, value, modifiers);\n  } else if (tag === 'input' && type === 'checkbox') {\n    genCheckboxModel(el, value, modifiers);\n  } else if (tag === 'input' && type === 'radio') {\n    genRadioModel(el, value, modifiers);\n  } else if (tag === 'input' || tag === 'textarea') {\n    genDefaultModel(el, value, modifiers);\n  } else if (!config.isReservedTag(tag)) {\n    genComponentModel(el, value, modifiers);\n    // component v-model doesn't need extra runtime\n    return false\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn$1(\n      \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n      \"v-model is not supported on this element type. \" +\n      'If you are working with contenteditable, it\\'s recommended to ' +\n      'wrap a library dedicated for that purpose inside a custom component.',\n      el.rawAttrsMap['v-model']\n    );\n  }\n\n  // ensure runtime directive metadata\n  return true\n}\n\nfunction genCheckboxModel (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  var trueValueBinding = getBindingAttr(el, 'true-value') || 'true';\n  var falseValueBinding = getBindingAttr(el, 'false-value') || 'false';\n  addProp(el, 'checked',\n    \"Array.isArray(\" + value + \")\" +\n    \"?_i(\" + value + \",\" + valueBinding + \")>-1\" + (\n      trueValueBinding === 'true'\n        ? (\":(\" + value + \")\")\n        : (\":_q(\" + value + \",\" + trueValueBinding + \")\")\n    )\n  );\n  addHandler(el, 'change',\n    \"var $$a=\" + value + \",\" +\n        '$$el=$event.target,' +\n        \"$$c=$$el.checked?(\" + trueValueBinding + \"):(\" + falseValueBinding + \");\" +\n    'if(Array.isArray($$a)){' +\n      \"var $$v=\" + (number ? '_n(' + valueBinding + ')' : valueBinding) + \",\" +\n          '$$i=_i($$a,$$v);' +\n      \"if($$el.checked){$$i<0&&(\" + (genAssignmentCode(value, '$$a.concat([$$v])')) + \")}\" +\n      \"else{$$i>-1&&(\" + (genAssignmentCode(value, '$$a.slice(0,$$i).concat($$a.slice($$i+1))')) + \")}\" +\n    \"}else{\" + (genAssignmentCode(value, '$$c')) + \"}\",\n    null, true\n  );\n}\n\nfunction genRadioModel (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var valueBinding = getBindingAttr(el, 'value') || 'null';\n  valueBinding = number ? (\"_n(\" + valueBinding + \")\") : valueBinding;\n  addProp(el, 'checked', (\"_q(\" + value + \",\" + valueBinding + \")\"));\n  addHandler(el, 'change', genAssignmentCode(value, valueBinding), null, true);\n}\n\nfunction genSelect (\n  el,\n  value,\n  modifiers\n) {\n  var number = modifiers && modifiers.number;\n  var selectedVal = \"Array.prototype.filter\" +\n    \".call($event.target.options,function(o){return o.selected})\" +\n    \".map(function(o){var val = \\\"_value\\\" in o ? o._value : o.value;\" +\n    \"return \" + (number ? '_n(val)' : 'val') + \"})\";\n\n  var assignment = '$event.target.multiple ? $$selectedVal : $$selectedVal[0]';\n  var code = \"var $$selectedVal = \" + selectedVal + \";\";\n  code = code + \" \" + (genAssignmentCode(value, assignment));\n  addHandler(el, 'change', code, null, true);\n}\n\nfunction genDefaultModel (\n  el,\n  value,\n  modifiers\n) {\n  var type = el.attrsMap.type;\n\n  // warn if v-bind:value conflicts with v-model\n  // except for inputs with v-bind:type\n  if (process.env.NODE_ENV !== 'production') {\n    var value$1 = el.attrsMap['v-bind:value'] || el.attrsMap[':value'];\n    var typeBinding = el.attrsMap['v-bind:type'] || el.attrsMap[':type'];\n    if (value$1 && !typeBinding) {\n      var binding = el.attrsMap['v-bind:value'] ? 'v-bind:value' : ':value';\n      warn$1(\n        binding + \"=\\\"\" + value$1 + \"\\\" conflicts with v-model on the same element \" +\n        'because the latter already expands to a value binding internally',\n        el.rawAttrsMap[binding]\n      );\n    }\n  }\n\n  var ref = modifiers || {};\n  var lazy = ref.lazy;\n  var number = ref.number;\n  var trim = ref.trim;\n  var needCompositionGuard = !lazy && type !== 'range';\n  var event = lazy\n    ? 'change'\n    : type === 'range'\n      ? RANGE_TOKEN\n      : 'input';\n\n  var valueExpression = '$event.target.value';\n  if (trim) {\n    valueExpression = \"$event.target.value.trim()\";\n  }\n  if (number) {\n    valueExpression = \"_n(\" + valueExpression + \")\";\n  }\n\n  var code = genAssignmentCode(value, valueExpression);\n  if (needCompositionGuard) {\n    code = \"if($event.target.composing)return;\" + code;\n  }\n\n  addProp(el, 'value', (\"(\" + value + \")\"));\n  addHandler(el, event, code, null, true);\n  if (trim || number) {\n    addHandler(el, 'blur', '$forceUpdate()');\n  }\n}\n\n/*  */\n\n// normalize v-model event tokens that can only be determined at runtime.\n// it's important to place the event as the first in the array because\n// the whole point is ensuring the v-model callback gets called before\n// user-attached handlers.\nfunction normalizeEvents (on) {\n  /* istanbul ignore if */\n  if (isDef(on[RANGE_TOKEN])) {\n    // IE input[type=range] only supports `change` event\n    var event = isIE ? 'change' : 'input';\n    on[event] = [].concat(on[RANGE_TOKEN], on[event] || []);\n    delete on[RANGE_TOKEN];\n  }\n  // This was originally intended to fix #4521 but no longer necessary\n  // after 2.5. Keeping it for backwards compat with generated code from < 2.4\n  /* istanbul ignore if */\n  if (isDef(on[CHECKBOX_RADIO_TOKEN])) {\n    on.change = [].concat(on[CHECKBOX_RADIO_TOKEN], on.change || []);\n    delete on[CHECKBOX_RADIO_TOKEN];\n  }\n}\n\nvar target$1;\n\nfunction createOnceHandler$1 (event, handler, capture) {\n  var _target = target$1; // save current target element in closure\n  return function onceHandler () {\n    var res = handler.apply(null, arguments);\n    if (res !== null) {\n      remove$2(event, onceHandler, capture, _target);\n    }\n  }\n}\n\n// #9446: Firefox <= 53 (in particular, ESR 52) has incorrect Event.timeStamp\n// implementation and does not fire microtasks in between event propagation, so\n// safe to exclude.\nvar useMicrotaskFix = isUsingMicroTask && !(isFF && Number(isFF[1]) <= 53);\n\nfunction add$1 (\n  name,\n  handler,\n  capture,\n  passive\n) {\n  // async edge case #6566: inner click event triggers patch, event handler\n  // attached to outer element during patch, and triggered again. This\n  // happens because browsers fire microtask ticks between event propagation.\n  // the solution is simple: we save the timestamp when a handler is attached,\n  // and the handler would only fire if the event passed to it was fired\n  // AFTER it was attached.\n  if (useMicrotaskFix) {\n    var attachedTimestamp = currentFlushTimestamp;\n    var original = handler;\n    handler = original._wrapper = function (e) {\n      if (\n        // no bubbling, should always fire.\n        // this is just a safety net in case event.timeStamp is unreliable in\n        // certain weird environments...\n        e.target === e.currentTarget ||\n        // event is fired after handler attachment\n        e.timeStamp >= attachedTimestamp ||\n        // bail for environments that have buggy event.timeStamp implementations\n        // #9462 iOS 9 bug: event.timeStamp is 0 after history.pushState\n        // #9681 QtWebEngine event.timeStamp is negative value\n        e.timeStamp <= 0 ||\n        // #9448 bail if event is fired in another document in a multi-page\n        // electron/nw.js app, since event.timeStamp will be using a different\n        // starting reference\n        e.target.ownerDocument !== document\n      ) {\n        return original.apply(this, arguments)\n      }\n    };\n  }\n  target$1.addEventListener(\n    name,\n    handler,\n    supportsPassive\n      ? { capture: capture, passive: passive }\n      : capture\n  );\n}\n\nfunction remove$2 (\n  name,\n  handler,\n  capture,\n  _target\n) {\n  (_target || target$1).removeEventListener(\n    name,\n    handler._wrapper || handler,\n    capture\n  );\n}\n\nfunction updateDOMListeners (oldVnode, vnode) {\n  if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {\n    return\n  }\n  var on = vnode.data.on || {};\n  var oldOn = oldVnode.data.on || {};\n  target$1 = vnode.elm;\n  normalizeEvents(on);\n  updateListeners(on, oldOn, add$1, remove$2, createOnceHandler$1, vnode.context);\n  target$1 = undefined;\n}\n\nvar events = {\n  create: updateDOMListeners,\n  update: updateDOMListeners\n};\n\n/*  */\n\nvar svgContainer;\n\nfunction updateDOMProps (oldVnode, vnode) {\n  if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {\n    return\n  }\n  var key, cur;\n  var elm = vnode.elm;\n  var oldProps = oldVnode.data.domProps || {};\n  var props = vnode.data.domProps || {};\n  // clone observed objects, as the user probably wants to mutate it\n  if (isDef(props.__ob__)) {\n    props = vnode.data.domProps = extend({}, props);\n  }\n\n  for (key in oldProps) {\n    if (!(key in props)) {\n      elm[key] = '';\n    }\n  }\n\n  for (key in props) {\n    cur = props[key];\n    // ignore children if the node has textContent or innerHTML,\n    // as these will throw away existing DOM nodes and cause removal errors\n    // on subsequent patches (#3360)\n    if (key === 'textContent' || key === 'innerHTML') {\n      if (vnode.children) { vnode.children.length = 0; }\n      if (cur === oldProps[key]) { continue }\n      // #6601 work around Chrome version <= 55 bug where single textNode\n      // replaced by innerHTML/textContent retains its parentNode property\n      if (elm.childNodes.length === 1) {\n        elm.removeChild(elm.childNodes[0]);\n      }\n    }\n\n    if (key === 'value' && elm.tagName !== 'PROGRESS') {\n      // store value as _value as well since\n      // non-string values will be stringified\n      elm._value = cur;\n      // avoid resetting cursor position when value is the same\n      var strCur = isUndef(cur) ? '' : String(cur);\n      if (shouldUpdateValue(elm, strCur)) {\n        elm.value = strCur;\n      }\n    } else if (key === 'innerHTML' && isSVG(elm.tagName) && isUndef(elm.innerHTML)) {\n      // IE doesn't support innerHTML for SVG elements\n      svgContainer = svgContainer || document.createElement('div');\n      svgContainer.innerHTML = \"<svg>\" + cur + \"</svg>\";\n      var svg = svgContainer.firstChild;\n      while (elm.firstChild) {\n        elm.removeChild(elm.firstChild);\n      }\n      while (svg.firstChild) {\n        elm.appendChild(svg.firstChild);\n      }\n    } else if (\n      // skip the update if old and new VDOM state is the same.\n      // `value` is handled separately because the DOM value may be temporarily\n      // out of sync with VDOM state due to focus, composition and modifiers.\n      // This  #4521 by skipping the unnecessary `checked` update.\n      cur !== oldProps[key]\n    ) {\n      // some property updates can throw\n      // e.g. `value` on <progress> w/ non-finite value\n      try {\n        elm[key] = cur;\n      } catch (e) {}\n    }\n  }\n}\n\n// check platforms/web/util/attrs.js acceptValue\n\n\nfunction shouldUpdateValue (elm, checkVal) {\n  return (!elm.composing && (\n    elm.tagName === 'OPTION' ||\n    isNotInFocusAndDirty(elm, checkVal) ||\n    isDirtyWithModifiers(elm, checkVal)\n  ))\n}\n\nfunction isNotInFocusAndDirty (elm, checkVal) {\n  // return true when textbox (.number and .trim) loses focus and its value is\n  // not equal to the updated value\n  var notInFocus = true;\n  // #6157\n  // work around IE bug when accessing document.activeElement in an iframe\n  try { notInFocus = document.activeElement !== elm; } catch (e) {}\n  return notInFocus && elm.value !== checkVal\n}\n\nfunction isDirtyWithModifiers (elm, newVal) {\n  var value = elm.value;\n  var modifiers = elm._vModifiers; // injected by v-model runtime\n  if (isDef(modifiers)) {\n    if (modifiers.number) {\n      return toNumber(value) !== toNumber(newVal)\n    }\n    if (modifiers.trim) {\n      return value.trim() !== newVal.trim()\n    }\n  }\n  return value !== newVal\n}\n\nvar domProps = {\n  create: updateDOMProps,\n  update: updateDOMProps\n};\n\n/*  */\n\nvar parseStyleText = cached(function (cssText) {\n  var res = {};\n  var listDelimiter = /;(?![^(]*\\))/g;\n  var propertyDelimiter = /:(.+)/;\n  cssText.split(listDelimiter).forEach(function (item) {\n    if (item) {\n      var tmp = item.split(propertyDelimiter);\n      tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim());\n    }\n  });\n  return res\n});\n\n// merge static and dynamic style data on the same vnode\nfunction normalizeStyleData (data) {\n  var style = normalizeStyleBinding(data.style);\n  // static style is pre-processed into an object during compilation\n  // and is always a fresh object, so it's safe to merge into it\n  return data.staticStyle\n    ? extend(data.staticStyle, style)\n    : style\n}\n\n// normalize possible array / string values into Object\nfunction normalizeStyleBinding (bindingStyle) {\n  if (Array.isArray(bindingStyle)) {\n    return toObject(bindingStyle)\n  }\n  if (typeof bindingStyle === 'string') {\n    return parseStyleText(bindingStyle)\n  }\n  return bindingStyle\n}\n\n/**\n * parent component style should be after child's\n * so that parent component's style could override it\n */\nfunction getStyle (vnode, checkChild) {\n  var res = {};\n  var styleData;\n\n  if (checkChild) {\n    var childNode = vnode;\n    while (childNode.componentInstance) {\n      childNode = childNode.componentInstance._vnode;\n      if (\n        childNode && childNode.data &&\n        (styleData = normalizeStyleData(childNode.data))\n      ) {\n        extend(res, styleData);\n      }\n    }\n  }\n\n  if ((styleData = normalizeStyleData(vnode.data))) {\n    extend(res, styleData);\n  }\n\n  var parentNode = vnode;\n  while ((parentNode = parentNode.parent)) {\n    if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {\n      extend(res, styleData);\n    }\n  }\n  return res\n}\n\n/*  */\n\nvar cssVarRE = /^--/;\nvar importantRE = /\\s*!important$/;\nvar setProp = function (el, name, val) {\n  /* istanbul ignore if */\n  if (cssVarRE.test(name)) {\n    el.style.setProperty(name, val);\n  } else if (importantRE.test(val)) {\n    el.style.setProperty(hyphenate(name), val.replace(importantRE, ''), 'important');\n  } else {\n    var normalizedName = normalize(name);\n    if (Array.isArray(val)) {\n      // Support values array created by autoprefixer, e.g.\n      // {display: [\"-webkit-box\", \"-ms-flexbox\", \"flex\"]}\n      // Set them one by one, and the browser will only set those it can recognize\n      for (var i = 0, len = val.length; i < len; i++) {\n        el.style[normalizedName] = val[i];\n      }\n    } else {\n      el.style[normalizedName] = val;\n    }\n  }\n};\n\nvar vendorNames = ['Webkit', 'Moz', 'ms'];\n\nvar emptyStyle;\nvar normalize = cached(function (prop) {\n  emptyStyle = emptyStyle || document.createElement('div').style;\n  prop = camelize(prop);\n  if (prop !== 'filter' && (prop in emptyStyle)) {\n    return prop\n  }\n  var capName = prop.charAt(0).toUpperCase() + prop.slice(1);\n  for (var i = 0; i < vendorNames.length; i++) {\n    var name = vendorNames[i] + capName;\n    if (name in emptyStyle) {\n      return name\n    }\n  }\n});\n\nfunction updateStyle (oldVnode, vnode) {\n  var data = vnode.data;\n  var oldData = oldVnode.data;\n\n  if (isUndef(data.staticStyle) && isUndef(data.style) &&\n    isUndef(oldData.staticStyle) && isUndef(oldData.style)\n  ) {\n    return\n  }\n\n  var cur, name;\n  var el = vnode.elm;\n  var oldStaticStyle = oldData.staticStyle;\n  var oldStyleBinding = oldData.normalizedStyle || oldData.style || {};\n\n  // if static style exists, stylebinding already merged into it when doing normalizeStyleData\n  var oldStyle = oldStaticStyle || oldStyleBinding;\n\n  var style = normalizeStyleBinding(vnode.data.style) || {};\n\n  // store normalized style under a different key for next diff\n  // make sure to clone it if it's reactive, since the user likely wants\n  // to mutate it.\n  vnode.data.normalizedStyle = isDef(style.__ob__)\n    ? extend({}, style)\n    : style;\n\n  var newStyle = getStyle(vnode, true);\n\n  for (name in oldStyle) {\n    if (isUndef(newStyle[name])) {\n      setProp(el, name, '');\n    }\n  }\n  for (name in newStyle) {\n    cur = newStyle[name];\n    if (cur !== oldStyle[name]) {\n      // ie9 setting to null has no effect, must use empty string\n      setProp(el, name, cur == null ? '' : cur);\n    }\n  }\n}\n\nvar style = {\n  create: updateStyle,\n  update: updateStyle\n};\n\n/*  */\n\nvar whitespaceRE = /\\s+/;\n\n/**\n * Add class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction addClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !(cls = cls.trim())) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(whitespaceRE).forEach(function (c) { return el.classList.add(c); });\n    } else {\n      el.classList.add(cls);\n    }\n  } else {\n    var cur = \" \" + (el.getAttribute('class') || '') + \" \";\n    if (cur.indexOf(' ' + cls + ' ') < 0) {\n      el.setAttribute('class', (cur + cls).trim());\n    }\n  }\n}\n\n/**\n * Remove class with compatibility for SVG since classList is not supported on\n * SVG elements in IE\n */\nfunction removeClass (el, cls) {\n  /* istanbul ignore if */\n  if (!cls || !(cls = cls.trim())) {\n    return\n  }\n\n  /* istanbul ignore else */\n  if (el.classList) {\n    if (cls.indexOf(' ') > -1) {\n      cls.split(whitespaceRE).forEach(function (c) { return el.classList.remove(c); });\n    } else {\n      el.classList.remove(cls);\n    }\n    if (!el.classList.length) {\n      el.removeAttribute('class');\n    }\n  } else {\n    var cur = \" \" + (el.getAttribute('class') || '') + \" \";\n    var tar = ' ' + cls + ' ';\n    while (cur.indexOf(tar) >= 0) {\n      cur = cur.replace(tar, ' ');\n    }\n    cur = cur.trim();\n    if (cur) {\n      el.setAttribute('class', cur);\n    } else {\n      el.removeAttribute('class');\n    }\n  }\n}\n\n/*  */\n\nfunction resolveTransition (def$$1) {\n  if (!def$$1) {\n    return\n  }\n  /* istanbul ignore else */\n  if (typeof def$$1 === 'object') {\n    var res = {};\n    if (def$$1.css !== false) {\n      extend(res, autoCssTransition(def$$1.name || 'v'));\n    }\n    extend(res, def$$1);\n    return res\n  } else if (typeof def$$1 === 'string') {\n    return autoCssTransition(def$$1)\n  }\n}\n\nvar autoCssTransition = cached(function (name) {\n  return {\n    enterClass: (name + \"-enter\"),\n    enterToClass: (name + \"-enter-to\"),\n    enterActiveClass: (name + \"-enter-active\"),\n    leaveClass: (name + \"-leave\"),\n    leaveToClass: (name + \"-leave-to\"),\n    leaveActiveClass: (name + \"-leave-active\")\n  }\n});\n\nvar hasTransition = inBrowser && !isIE9;\nvar TRANSITION = 'transition';\nvar ANIMATION = 'animation';\n\n// Transition property/event sniffing\nvar transitionProp = 'transition';\nvar transitionEndEvent = 'transitionend';\nvar animationProp = 'animation';\nvar animationEndEvent = 'animationend';\nif (hasTransition) {\n  /* istanbul ignore if */\n  if (window.ontransitionend === undefined &&\n    window.onwebkittransitionend !== undefined\n  ) {\n    transitionProp = 'WebkitTransition';\n    transitionEndEvent = 'webkitTransitionEnd';\n  }\n  if (window.onanimationend === undefined &&\n    window.onwebkitanimationend !== undefined\n  ) {\n    animationProp = 'WebkitAnimation';\n    animationEndEvent = 'webkitAnimationEnd';\n  }\n}\n\n// binding to window is necessary to make hot reload work in IE in strict mode\nvar raf = inBrowser\n  ? window.requestAnimationFrame\n    ? window.requestAnimationFrame.bind(window)\n    : setTimeout\n  : /* istanbul ignore next */ function (fn) { return fn(); };\n\nfunction nextFrame (fn) {\n  raf(function () {\n    raf(fn);\n  });\n}\n\nfunction addTransitionClass (el, cls) {\n  var transitionClasses = el._transitionClasses || (el._transitionClasses = []);\n  if (transitionClasses.indexOf(cls) < 0) {\n    transitionClasses.push(cls);\n    addClass(el, cls);\n  }\n}\n\nfunction removeTransitionClass (el, cls) {\n  if (el._transitionClasses) {\n    remove(el._transitionClasses, cls);\n  }\n  removeClass(el, cls);\n}\n\nfunction whenTransitionEnds (\n  el,\n  expectedType,\n  cb\n) {\n  var ref = getTransitionInfo(el, expectedType);\n  var type = ref.type;\n  var timeout = ref.timeout;\n  var propCount = ref.propCount;\n  if (!type) { return cb() }\n  var event = type === TRANSITION ? transitionEndEvent : animationEndEvent;\n  var ended = 0;\n  var end = function () {\n    el.removeEventListener(event, onEnd);\n    cb();\n  };\n  var onEnd = function (e) {\n    if (e.target === el) {\n      if (++ended >= propCount) {\n        end();\n      }\n    }\n  };\n  setTimeout(function () {\n    if (ended < propCount) {\n      end();\n    }\n  }, timeout + 1);\n  el.addEventListener(event, onEnd);\n}\n\nvar transformRE = /\\b(transform|all)(,|$)/;\n\nfunction getTransitionInfo (el, expectedType) {\n  var styles = window.getComputedStyle(el);\n  // JSDOM may return undefined for transition properties\n  var transitionDelays = (styles[transitionProp + 'Delay'] || '').split(', ');\n  var transitionDurations = (styles[transitionProp + 'Duration'] || '').split(', ');\n  var transitionTimeout = getTimeout(transitionDelays, transitionDurations);\n  var animationDelays = (styles[animationProp + 'Delay'] || '').split(', ');\n  var animationDurations = (styles[animationProp + 'Duration'] || '').split(', ');\n  var animationTimeout = getTimeout(animationDelays, animationDurations);\n\n  var type;\n  var timeout = 0;\n  var propCount = 0;\n  /* istanbul ignore if */\n  if (expectedType === TRANSITION) {\n    if (transitionTimeout > 0) {\n      type = TRANSITION;\n      timeout = transitionTimeout;\n      propCount = transitionDurations.length;\n    }\n  } else if (expectedType === ANIMATION) {\n    if (animationTimeout > 0) {\n      type = ANIMATION;\n      timeout = animationTimeout;\n      propCount = animationDurations.length;\n    }\n  } else {\n    timeout = Math.max(transitionTimeout, animationTimeout);\n    type = timeout > 0\n      ? transitionTimeout > animationTimeout\n        ? TRANSITION\n        : ANIMATION\n      : null;\n    propCount = type\n      ? type === TRANSITION\n        ? transitionDurations.length\n        : animationDurations.length\n      : 0;\n  }\n  var hasTransform =\n    type === TRANSITION &&\n    transformRE.test(styles[transitionProp + 'Property']);\n  return {\n    type: type,\n    timeout: timeout,\n    propCount: propCount,\n    hasTransform: hasTransform\n  }\n}\n\nfunction getTimeout (delays, durations) {\n  /* istanbul ignore next */\n  while (delays.length < durations.length) {\n    delays = delays.concat(delays);\n  }\n\n  return Math.max.apply(null, durations.map(function (d, i) {\n    return toMs(d) + toMs(delays[i])\n  }))\n}\n\n// Old versions of Chromium (below 61.0.3163.100) formats floating pointer numbers\n// in a locale-dependent way, using a comma instead of a dot.\n// If comma is not replaced with a dot, the input will be rounded down (i.e. acting\n// as a floor function) causing unexpected behaviors\nfunction toMs (s) {\n  return Number(s.slice(0, -1).replace(',', '.')) * 1000\n}\n\n/*  */\n\nfunction enter (vnode, toggleDisplay) {\n  var el = vnode.elm;\n\n  // call leave callback now\n  if (isDef(el._leaveCb)) {\n    el._leaveCb.cancelled = true;\n    el._leaveCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (isUndef(data)) {\n    return\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._enterCb) || el.nodeType !== 1) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var enterClass = data.enterClass;\n  var enterToClass = data.enterToClass;\n  var enterActiveClass = data.enterActiveClass;\n  var appearClass = data.appearClass;\n  var appearToClass = data.appearToClass;\n  var appearActiveClass = data.appearActiveClass;\n  var beforeEnter = data.beforeEnter;\n  var enter = data.enter;\n  var afterEnter = data.afterEnter;\n  var enterCancelled = data.enterCancelled;\n  var beforeAppear = data.beforeAppear;\n  var appear = data.appear;\n  var afterAppear = data.afterAppear;\n  var appearCancelled = data.appearCancelled;\n  var duration = data.duration;\n\n  // activeInstance will always be the <transition> component managing this\n  // transition. One edge case to check is when the <transition> is placed\n  // as the root node of a child component. In that case we need to check\n  // <transition>'s parent for appear check.\n  var context = activeInstance;\n  var transitionNode = activeInstance.$vnode;\n  while (transitionNode && transitionNode.parent) {\n    context = transitionNode.context;\n    transitionNode = transitionNode.parent;\n  }\n\n  var isAppear = !context._isMounted || !vnode.isRootInsert;\n\n  if (isAppear && !appear && appear !== '') {\n    return\n  }\n\n  var startClass = isAppear && appearClass\n    ? appearClass\n    : enterClass;\n  var activeClass = isAppear && appearActiveClass\n    ? appearActiveClass\n    : enterActiveClass;\n  var toClass = isAppear && appearToClass\n    ? appearToClass\n    : enterToClass;\n\n  var beforeEnterHook = isAppear\n    ? (beforeAppear || beforeEnter)\n    : beforeEnter;\n  var enterHook = isAppear\n    ? (typeof appear === 'function' ? appear : enter)\n    : enter;\n  var afterEnterHook = isAppear\n    ? (afterAppear || afterEnter)\n    : afterEnter;\n  var enterCancelledHook = isAppear\n    ? (appearCancelled || enterCancelled)\n    : enterCancelled;\n\n  var explicitEnterDuration = toNumber(\n    isObject(duration)\n      ? duration.enter\n      : duration\n  );\n\n  if (process.env.NODE_ENV !== 'production' && explicitEnterDuration != null) {\n    checkDuration(explicitEnterDuration, 'enter', vnode);\n  }\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl = getHookArgumentsLength(enterHook);\n\n  var cb = el._enterCb = once(function () {\n    if (expectsCSS) {\n      removeTransitionClass(el, toClass);\n      removeTransitionClass(el, activeClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, startClass);\n      }\n      enterCancelledHook && enterCancelledHook(el);\n    } else {\n      afterEnterHook && afterEnterHook(el);\n    }\n    el._enterCb = null;\n  });\n\n  if (!vnode.data.show) {\n    // remove pending leave element on enter by injecting an insert hook\n    mergeVNodeHook(vnode, 'insert', function () {\n      var parent = el.parentNode;\n      var pendingNode = parent && parent._pending && parent._pending[vnode.key];\n      if (pendingNode &&\n        pendingNode.tag === vnode.tag &&\n        pendingNode.elm._leaveCb\n      ) {\n        pendingNode.elm._leaveCb();\n      }\n      enterHook && enterHook(el, cb);\n    });\n  }\n\n  // start enter transition\n  beforeEnterHook && beforeEnterHook(el);\n  if (expectsCSS) {\n    addTransitionClass(el, startClass);\n    addTransitionClass(el, activeClass);\n    nextFrame(function () {\n      removeTransitionClass(el, startClass);\n      if (!cb.cancelled) {\n        addTransitionClass(el, toClass);\n        if (!userWantsControl) {\n          if (isValidDuration(explicitEnterDuration)) {\n            setTimeout(cb, explicitEnterDuration);\n          } else {\n            whenTransitionEnds(el, type, cb);\n          }\n        }\n      }\n    });\n  }\n\n  if (vnode.data.show) {\n    toggleDisplay && toggleDisplay();\n    enterHook && enterHook(el, cb);\n  }\n\n  if (!expectsCSS && !userWantsControl) {\n    cb();\n  }\n}\n\nfunction leave (vnode, rm) {\n  var el = vnode.elm;\n\n  // call enter callback now\n  if (isDef(el._enterCb)) {\n    el._enterCb.cancelled = true;\n    el._enterCb();\n  }\n\n  var data = resolveTransition(vnode.data.transition);\n  if (isUndef(data) || el.nodeType !== 1) {\n    return rm()\n  }\n\n  /* istanbul ignore if */\n  if (isDef(el._leaveCb)) {\n    return\n  }\n\n  var css = data.css;\n  var type = data.type;\n  var leaveClass = data.leaveClass;\n  var leaveToClass = data.leaveToClass;\n  var leaveActiveClass = data.leaveActiveClass;\n  var beforeLeave = data.beforeLeave;\n  var leave = data.leave;\n  var afterLeave = data.afterLeave;\n  var leaveCancelled = data.leaveCancelled;\n  var delayLeave = data.delayLeave;\n  var duration = data.duration;\n\n  var expectsCSS = css !== false && !isIE9;\n  var userWantsControl = getHookArgumentsLength(leave);\n\n  var explicitLeaveDuration = toNumber(\n    isObject(duration)\n      ? duration.leave\n      : duration\n  );\n\n  if (process.env.NODE_ENV !== 'production' && isDef(explicitLeaveDuration)) {\n    checkDuration(explicitLeaveDuration, 'leave', vnode);\n  }\n\n  var cb = el._leaveCb = once(function () {\n    if (el.parentNode && el.parentNode._pending) {\n      el.parentNode._pending[vnode.key] = null;\n    }\n    if (expectsCSS) {\n      removeTransitionClass(el, leaveToClass);\n      removeTransitionClass(el, leaveActiveClass);\n    }\n    if (cb.cancelled) {\n      if (expectsCSS) {\n        removeTransitionClass(el, leaveClass);\n      }\n      leaveCancelled && leaveCancelled(el);\n    } else {\n      rm();\n      afterLeave && afterLeave(el);\n    }\n    el._leaveCb = null;\n  });\n\n  if (delayLeave) {\n    delayLeave(performLeave);\n  } else {\n    performLeave();\n  }\n\n  function performLeave () {\n    // the delayed leave may have already been cancelled\n    if (cb.cancelled) {\n      return\n    }\n    // record leaving element\n    if (!vnode.data.show && el.parentNode) {\n      (el.parentNode._pending || (el.parentNode._pending = {}))[(vnode.key)] = vnode;\n    }\n    beforeLeave && beforeLeave(el);\n    if (expectsCSS) {\n      addTransitionClass(el, leaveClass);\n      addTransitionClass(el, leaveActiveClass);\n      nextFrame(function () {\n        removeTransitionClass(el, leaveClass);\n        if (!cb.cancelled) {\n          addTransitionClass(el, leaveToClass);\n          if (!userWantsControl) {\n            if (isValidDuration(explicitLeaveDuration)) {\n              setTimeout(cb, explicitLeaveDuration);\n            } else {\n              whenTransitionEnds(el, type, cb);\n            }\n          }\n        }\n      });\n    }\n    leave && leave(el, cb);\n    if (!expectsCSS && !userWantsControl) {\n      cb();\n    }\n  }\n}\n\n// only used in dev mode\nfunction checkDuration (val, name, vnode) {\n  if (typeof val !== 'number') {\n    warn(\n      \"<transition> explicit \" + name + \" duration is not a valid number - \" +\n      \"got \" + (JSON.stringify(val)) + \".\",\n      vnode.context\n    );\n  } else if (isNaN(val)) {\n    warn(\n      \"<transition> explicit \" + name + \" duration is NaN - \" +\n      'the duration expression might be incorrect.',\n      vnode.context\n    );\n  }\n}\n\nfunction isValidDuration (val) {\n  return typeof val === 'number' && !isNaN(val)\n}\n\n/**\n * Normalize a transition hook's argument length. The hook may be:\n * - a merged hook (invoker) with the original in .fns\n * - a wrapped component method (check ._length)\n * - a plain function (.length)\n */\nfunction getHookArgumentsLength (fn) {\n  if (isUndef(fn)) {\n    return false\n  }\n  var invokerFns = fn.fns;\n  if (isDef(invokerFns)) {\n    // invoker\n    return getHookArgumentsLength(\n      Array.isArray(invokerFns)\n        ? invokerFns[0]\n        : invokerFns\n    )\n  } else {\n    return (fn._length || fn.length) > 1\n  }\n}\n\nfunction _enter (_, vnode) {\n  if (vnode.data.show !== true) {\n    enter(vnode);\n  }\n}\n\nvar transition = inBrowser ? {\n  create: _enter,\n  activate: _enter,\n  remove: function remove$$1 (vnode, rm) {\n    /* istanbul ignore else */\n    if (vnode.data.show !== true) {\n      leave(vnode, rm);\n    } else {\n      rm();\n    }\n  }\n} : {};\n\nvar platformModules = [\n  attrs,\n  klass,\n  events,\n  domProps,\n  style,\n  transition\n];\n\n/*  */\n\n// the directive module should be applied last, after all\n// built-in modules have been applied.\nvar modules = platformModules.concat(baseModules);\n\nvar patch = createPatchFunction({ nodeOps: nodeOps, modules: modules });\n\n/**\n * Not type checking this file because flow doesn't like attaching\n * properties to Elements.\n */\n\n/* istanbul ignore if */\nif (isIE9) {\n  // http://www.matts411.com/post/internet-explorer-9-oninput/\n  document.addEventListener('selectionchange', function () {\n    var el = document.activeElement;\n    if (el && el.vmodel) {\n      trigger(el, 'input');\n    }\n  });\n}\n\nvar directive = {\n  inserted: function inserted (el, binding, vnode, oldVnode) {\n    if (vnode.tag === 'select') {\n      // #6903\n      if (oldVnode.elm && !oldVnode.elm._vOptions) {\n        mergeVNodeHook(vnode, 'postpatch', function () {\n          directive.componentUpdated(el, binding, vnode);\n        });\n      } else {\n        setSelected(el, binding, vnode.context);\n      }\n      el._vOptions = [].map.call(el.options, getValue);\n    } else if (vnode.tag === 'textarea' || isTextInputType(el.type)) {\n      el._vModifiers = binding.modifiers;\n      if (!binding.modifiers.lazy) {\n        el.addEventListener('compositionstart', onCompositionStart);\n        el.addEventListener('compositionend', onCompositionEnd);\n        // Safari < 10.2 & UIWebView doesn't fire compositionend when\n        // switching focus before confirming composition choice\n        // this also fixes the issue where some browsers e.g. iOS Chrome\n        // fires \"change\" instead of \"input\" on autocomplete.\n        el.addEventListener('change', onCompositionEnd);\n        /* istanbul ignore if */\n        if (isIE9) {\n          el.vmodel = true;\n        }\n      }\n    }\n  },\n\n  componentUpdated: function componentUpdated (el, binding, vnode) {\n    if (vnode.tag === 'select') {\n      setSelected(el, binding, vnode.context);\n      // in case the options rendered by v-for have changed,\n      // it's possible that the value is out-of-sync with the rendered options.\n      // detect such cases and filter out values that no longer has a matching\n      // option in the DOM.\n      var prevOptions = el._vOptions;\n      var curOptions = el._vOptions = [].map.call(el.options, getValue);\n      if (curOptions.some(function (o, i) { return !looseEqual(o, prevOptions[i]); })) {\n        // trigger change event if\n        // no matching option found for at least one value\n        var needReset = el.multiple\n          ? binding.value.some(function (v) { return hasNoMatchingOption(v, curOptions); })\n          : binding.value !== binding.oldValue && hasNoMatchingOption(binding.value, curOptions);\n        if (needReset) {\n          trigger(el, 'change');\n        }\n      }\n    }\n  }\n};\n\nfunction setSelected (el, binding, vm) {\n  actuallySetSelected(el, binding, vm);\n  /* istanbul ignore if */\n  if (isIE || isEdge) {\n    setTimeout(function () {\n      actuallySetSelected(el, binding, vm);\n    }, 0);\n  }\n}\n\nfunction actuallySetSelected (el, binding, vm) {\n  var value = binding.value;\n  var isMultiple = el.multiple;\n  if (isMultiple && !Array.isArray(value)) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"<select multiple v-model=\\\"\" + (binding.expression) + \"\\\"> \" +\n      \"expects an Array value for its binding, but got \" + (Object.prototype.toString.call(value).slice(8, -1)),\n      vm\n    );\n    return\n  }\n  var selected, option;\n  for (var i = 0, l = el.options.length; i < l; i++) {\n    option = el.options[i];\n    if (isMultiple) {\n      selected = looseIndexOf(value, getValue(option)) > -1;\n      if (option.selected !== selected) {\n        option.selected = selected;\n      }\n    } else {\n      if (looseEqual(getValue(option), value)) {\n        if (el.selectedIndex !== i) {\n          el.selectedIndex = i;\n        }\n        return\n      }\n    }\n  }\n  if (!isMultiple) {\n    el.selectedIndex = -1;\n  }\n}\n\nfunction hasNoMatchingOption (value, options) {\n  return options.every(function (o) { return !looseEqual(o, value); })\n}\n\nfunction getValue (option) {\n  return '_value' in option\n    ? option._value\n    : option.value\n}\n\nfunction onCompositionStart (e) {\n  e.target.composing = true;\n}\n\nfunction onCompositionEnd (e) {\n  // prevent triggering an input event for no reason\n  if (!e.target.composing) { return }\n  e.target.composing = false;\n  trigger(e.target, 'input');\n}\n\nfunction trigger (el, type) {\n  var e = document.createEvent('HTMLEvents');\n  e.initEvent(type, true, true);\n  el.dispatchEvent(e);\n}\n\n/*  */\n\n// recursively search for possible transition defined inside the component root\nfunction locateNode (vnode) {\n  return vnode.componentInstance && (!vnode.data || !vnode.data.transition)\n    ? locateNode(vnode.componentInstance._vnode)\n    : vnode\n}\n\nvar show = {\n  bind: function bind (el, ref, vnode) {\n    var value = ref.value;\n\n    vnode = locateNode(vnode);\n    var transition$$1 = vnode.data && vnode.data.transition;\n    var originalDisplay = el.__vOriginalDisplay =\n      el.style.display === 'none' ? '' : el.style.display;\n    if (value && transition$$1) {\n      vnode.data.show = true;\n      enter(vnode, function () {\n        el.style.display = originalDisplay;\n      });\n    } else {\n      el.style.display = value ? originalDisplay : 'none';\n    }\n  },\n\n  update: function update (el, ref, vnode) {\n    var value = ref.value;\n    var oldValue = ref.oldValue;\n\n    /* istanbul ignore if */\n    if (!value === !oldValue) { return }\n    vnode = locateNode(vnode);\n    var transition$$1 = vnode.data && vnode.data.transition;\n    if (transition$$1) {\n      vnode.data.show = true;\n      if (value) {\n        enter(vnode, function () {\n          el.style.display = el.__vOriginalDisplay;\n        });\n      } else {\n        leave(vnode, function () {\n          el.style.display = 'none';\n        });\n      }\n    } else {\n      el.style.display = value ? el.__vOriginalDisplay : 'none';\n    }\n  },\n\n  unbind: function unbind (\n    el,\n    binding,\n    vnode,\n    oldVnode,\n    isDestroy\n  ) {\n    if (!isDestroy) {\n      el.style.display = el.__vOriginalDisplay;\n    }\n  }\n};\n\nvar platformDirectives = {\n  model: directive,\n  show: show\n};\n\n/*  */\n\nvar transitionProps = {\n  name: String,\n  appear: Boolean,\n  css: Boolean,\n  mode: String,\n  type: String,\n  enterClass: String,\n  leaveClass: String,\n  enterToClass: String,\n  leaveToClass: String,\n  enterActiveClass: String,\n  leaveActiveClass: String,\n  appearClass: String,\n  appearActiveClass: String,\n  appearToClass: String,\n  duration: [Number, String, Object]\n};\n\n// in case the child is also an abstract component, e.g. <keep-alive>\n// we want to recursively retrieve the real component to be rendered\nfunction getRealChild (vnode) {\n  var compOptions = vnode && vnode.componentOptions;\n  if (compOptions && compOptions.Ctor.options.abstract) {\n    return getRealChild(getFirstComponentChild(compOptions.children))\n  } else {\n    return vnode\n  }\n}\n\nfunction extractTransitionData (comp) {\n  var data = {};\n  var options = comp.$options;\n  // props\n  for (var key in options.propsData) {\n    data[key] = comp[key];\n  }\n  // events.\n  // extract listeners and pass them directly to the transition methods\n  var listeners = options._parentListeners;\n  for (var key$1 in listeners) {\n    data[camelize(key$1)] = listeners[key$1];\n  }\n  return data\n}\n\nfunction placeholder (h, rawChild) {\n  if (/\\d-keep-alive$/.test(rawChild.tag)) {\n    return h('keep-alive', {\n      props: rawChild.componentOptions.propsData\n    })\n  }\n}\n\nfunction hasParentTransition (vnode) {\n  while ((vnode = vnode.parent)) {\n    if (vnode.data.transition) {\n      return true\n    }\n  }\n}\n\nfunction isSameChild (child, oldChild) {\n  return oldChild.key === child.key && oldChild.tag === child.tag\n}\n\nvar isNotTextNode = function (c) { return c.tag || isAsyncPlaceholder(c); };\n\nvar isVShowDirective = function (d) { return d.name === 'show'; };\n\nvar Transition = {\n  name: 'transition',\n  props: transitionProps,\n  abstract: true,\n\n  render: function render (h) {\n    var this$1 = this;\n\n    var children = this.$slots.default;\n    if (!children) {\n      return\n    }\n\n    // filter out text nodes (possible whitespaces)\n    children = children.filter(isNotTextNode);\n    /* istanbul ignore if */\n    if (!children.length) {\n      return\n    }\n\n    // warn multiple elements\n    if (process.env.NODE_ENV !== 'production' && children.length > 1) {\n      warn(\n        '<transition> can only be used on a single element. Use ' +\n        '<transition-group> for lists.',\n        this.$parent\n      );\n    }\n\n    var mode = this.mode;\n\n    // warn invalid mode\n    if (process.env.NODE_ENV !== 'production' &&\n      mode && mode !== 'in-out' && mode !== 'out-in'\n    ) {\n      warn(\n        'invalid <transition> mode: ' + mode,\n        this.$parent\n      );\n    }\n\n    var rawChild = children[0];\n\n    // if this is a component root node and the component's\n    // parent container node also has transition, skip.\n    if (hasParentTransition(this.$vnode)) {\n      return rawChild\n    }\n\n    // apply transition data to child\n    // use getRealChild() to ignore abstract components e.g. keep-alive\n    var child = getRealChild(rawChild);\n    /* istanbul ignore if */\n    if (!child) {\n      return rawChild\n    }\n\n    if (this._leaving) {\n      return placeholder(h, rawChild)\n    }\n\n    // ensure a key that is unique to the vnode type and to this transition\n    // component instance. This key will be used to remove pending leaving nodes\n    // during entering.\n    var id = \"__transition-\" + (this._uid) + \"-\";\n    child.key = child.key == null\n      ? child.isComment\n        ? id + 'comment'\n        : id + child.tag\n      : isPrimitive(child.key)\n        ? (String(child.key).indexOf(id) === 0 ? child.key : id + child.key)\n        : child.key;\n\n    var data = (child.data || (child.data = {})).transition = extractTransitionData(this);\n    var oldRawChild = this._vnode;\n    var oldChild = getRealChild(oldRawChild);\n\n    // mark v-show\n    // so that the transition module can hand over the control to the directive\n    if (child.data.directives && child.data.directives.some(isVShowDirective)) {\n      child.data.show = true;\n    }\n\n    if (\n      oldChild &&\n      oldChild.data &&\n      !isSameChild(child, oldChild) &&\n      !isAsyncPlaceholder(oldChild) &&\n      // #6687 component root is a comment node\n      !(oldChild.componentInstance && oldChild.componentInstance._vnode.isComment)\n    ) {\n      // replace old child transition data with fresh one\n      // important for dynamic transitions!\n      var oldData = oldChild.data.transition = extend({}, data);\n      // handle transition mode\n      if (mode === 'out-in') {\n        // return placeholder node and queue update when leave finishes\n        this._leaving = true;\n        mergeVNodeHook(oldData, 'afterLeave', function () {\n          this$1._leaving = false;\n          this$1.$forceUpdate();\n        });\n        return placeholder(h, rawChild)\n      } else if (mode === 'in-out') {\n        if (isAsyncPlaceholder(child)) {\n          return oldRawChild\n        }\n        var delayedLeave;\n        var performLeave = function () { delayedLeave(); };\n        mergeVNodeHook(data, 'afterEnter', performLeave);\n        mergeVNodeHook(data, 'enterCancelled', performLeave);\n        mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });\n      }\n    }\n\n    return rawChild\n  }\n};\n\n/*  */\n\nvar props = extend({\n  tag: String,\n  moveClass: String\n}, transitionProps);\n\ndelete props.mode;\n\nvar TransitionGroup = {\n  props: props,\n\n  beforeMount: function beforeMount () {\n    var this$1 = this;\n\n    var update = this._update;\n    this._update = function (vnode, hydrating) {\n      var restoreActiveInstance = setActiveInstance(this$1);\n      // force removing pass\n      this$1.__patch__(\n        this$1._vnode,\n        this$1.kept,\n        false, // hydrating\n        true // removeOnly (!important, avoids unnecessary moves)\n      );\n      this$1._vnode = this$1.kept;\n      restoreActiveInstance();\n      update.call(this$1, vnode, hydrating);\n    };\n  },\n\n  render: function render (h) {\n    var tag = this.tag || this.$vnode.data.tag || 'span';\n    var map = Object.create(null);\n    var prevChildren = this.prevChildren = this.children;\n    var rawChildren = this.$slots.default || [];\n    var children = this.children = [];\n    var transitionData = extractTransitionData(this);\n\n    for (var i = 0; i < rawChildren.length; i++) {\n      var c = rawChildren[i];\n      if (c.tag) {\n        if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {\n          children.push(c);\n          map[c.key] = c\n          ;(c.data || (c.data = {})).transition = transitionData;\n        } else if (process.env.NODE_ENV !== 'production') {\n          var opts = c.componentOptions;\n          var name = opts ? (opts.Ctor.options.name || opts.tag || '') : c.tag;\n          warn((\"<transition-group> children must be keyed: <\" + name + \">\"));\n        }\n      }\n    }\n\n    if (prevChildren) {\n      var kept = [];\n      var removed = [];\n      for (var i$1 = 0; i$1 < prevChildren.length; i$1++) {\n        var c$1 = prevChildren[i$1];\n        c$1.data.transition = transitionData;\n        c$1.data.pos = c$1.elm.getBoundingClientRect();\n        if (map[c$1.key]) {\n          kept.push(c$1);\n        } else {\n          removed.push(c$1);\n        }\n      }\n      this.kept = h(tag, null, kept);\n      this.removed = removed;\n    }\n\n    return h(tag, null, children)\n  },\n\n  updated: function updated () {\n    var children = this.prevChildren;\n    var moveClass = this.moveClass || ((this.name || 'v') + '-move');\n    if (!children.length || !this.hasMove(children[0].elm, moveClass)) {\n      return\n    }\n\n    // we divide the work into three loops to avoid mixing DOM reads and writes\n    // in each iteration - which helps prevent layout thrashing.\n    children.forEach(callPendingCbs);\n    children.forEach(recordPosition);\n    children.forEach(applyTranslation);\n\n    // force reflow to put everything in position\n    // assign to this to avoid being removed in tree-shaking\n    // $flow-disable-line\n    this._reflow = document.body.offsetHeight;\n\n    children.forEach(function (c) {\n      if (c.data.moved) {\n        var el = c.elm;\n        var s = el.style;\n        addTransitionClass(el, moveClass);\n        s.transform = s.WebkitTransform = s.transitionDuration = '';\n        el.addEventListener(transitionEndEvent, el._moveCb = function cb (e) {\n          if (e && e.target !== el) {\n            return\n          }\n          if (!e || /transform$/.test(e.propertyName)) {\n            el.removeEventListener(transitionEndEvent, cb);\n            el._moveCb = null;\n            removeTransitionClass(el, moveClass);\n          }\n        });\n      }\n    });\n  },\n\n  methods: {\n    hasMove: function hasMove (el, moveClass) {\n      /* istanbul ignore if */\n      if (!hasTransition) {\n        return false\n      }\n      /* istanbul ignore if */\n      if (this._hasMove) {\n        return this._hasMove\n      }\n      // Detect whether an element with the move class applied has\n      // CSS transitions. Since the element may be inside an entering\n      // transition at this very moment, we make a clone of it and remove\n      // all other transition classes applied to ensure only the move class\n      // is applied.\n      var clone = el.cloneNode();\n      if (el._transitionClasses) {\n        el._transitionClasses.forEach(function (cls) { removeClass(clone, cls); });\n      }\n      addClass(clone, moveClass);\n      clone.style.display = 'none';\n      this.$el.appendChild(clone);\n      var info = getTransitionInfo(clone);\n      this.$el.removeChild(clone);\n      return (this._hasMove = info.hasTransform)\n    }\n  }\n};\n\nfunction callPendingCbs (c) {\n  /* istanbul ignore if */\n  if (c.elm._moveCb) {\n    c.elm._moveCb();\n  }\n  /* istanbul ignore if */\n  if (c.elm._enterCb) {\n    c.elm._enterCb();\n  }\n}\n\nfunction recordPosition (c) {\n  c.data.newPos = c.elm.getBoundingClientRect();\n}\n\nfunction applyTranslation (c) {\n  var oldPos = c.data.pos;\n  var newPos = c.data.newPos;\n  var dx = oldPos.left - newPos.left;\n  var dy = oldPos.top - newPos.top;\n  if (dx || dy) {\n    c.data.moved = true;\n    var s = c.elm.style;\n    s.transform = s.WebkitTransform = \"translate(\" + dx + \"px,\" + dy + \"px)\";\n    s.transitionDuration = '0s';\n  }\n}\n\nvar platformComponents = {\n  Transition: Transition,\n  TransitionGroup: TransitionGroup\n};\n\n/*  */\n\n// install platform specific utils\nVue.config.mustUseProp = mustUseProp;\nVue.config.isReservedTag = isReservedTag;\nVue.config.isReservedAttr = isReservedAttr;\nVue.config.getTagNamespace = getTagNamespace;\nVue.config.isUnknownElement = isUnknownElement;\n\n// install platform runtime directives & components\nextend(Vue.options.directives, platformDirectives);\nextend(Vue.options.components, platformComponents);\n\n// install platform patch function\nVue.prototype.__patch__ = inBrowser ? patch : noop;\n\n// public mount method\nVue.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && inBrowser ? query(el) : undefined;\n  return mountComponent(this, el, hydrating)\n};\n\n// devtools global hook\n/* istanbul ignore next */\nif (inBrowser) {\n  setTimeout(function () {\n    if (config.devtools) {\n      if (devtools) {\n        devtools.emit('init', Vue);\n      } else if (\n        process.env.NODE_ENV !== 'production' &&\n        process.env.NODE_ENV !== 'test'\n      ) {\n        console[console.info ? 'info' : 'log'](\n          'Download the Vue Devtools extension for a better development experience:\\n' +\n          'https://github.com/vuejs/vue-devtools'\n        );\n      }\n    }\n    if (process.env.NODE_ENV !== 'production' &&\n      process.env.NODE_ENV !== 'test' &&\n      config.productionTip !== false &&\n      typeof console !== 'undefined'\n    ) {\n      console[console.info ? 'info' : 'log'](\n        \"You are running Vue in development mode.\\n\" +\n        \"Make sure to turn on production mode when deploying for production.\\n\" +\n        \"See more tips at https://vuejs.org/guide/deployment.html\"\n      );\n    }\n  }, 0);\n}\n\n/*  */\n\nvar defaultTagRE = /\\{\\{((?:.|\\r?\\n)+?)\\}\\}/g;\nvar regexEscapeRE = /[-.*+?^${}()|[\\]\\/\\\\]/g;\n\nvar buildRegex = cached(function (delimiters) {\n  var open = delimiters[0].replace(regexEscapeRE, '\\\\$&');\n  var close = delimiters[1].replace(regexEscapeRE, '\\\\$&');\n  return new RegExp(open + '((?:.|\\\\n)+?)' + close, 'g')\n});\n\n\n\nfunction parseText (\n  text,\n  delimiters\n) {\n  var tagRE = delimiters ? buildRegex(delimiters) : defaultTagRE;\n  if (!tagRE.test(text)) {\n    return\n  }\n  var tokens = [];\n  var rawTokens = [];\n  var lastIndex = tagRE.lastIndex = 0;\n  var match, index, tokenValue;\n  while ((match = tagRE.exec(text))) {\n    index = match.index;\n    // push text token\n    if (index > lastIndex) {\n      rawTokens.push(tokenValue = text.slice(lastIndex, index));\n      tokens.push(JSON.stringify(tokenValue));\n    }\n    // tag token\n    var exp = parseFilters(match[1].trim());\n    tokens.push((\"_s(\" + exp + \")\"));\n    rawTokens.push({ '@binding': exp });\n    lastIndex = index + match[0].length;\n  }\n  if (lastIndex < text.length) {\n    rawTokens.push(tokenValue = text.slice(lastIndex));\n    tokens.push(JSON.stringify(tokenValue));\n  }\n  return {\n    expression: tokens.join('+'),\n    tokens: rawTokens\n  }\n}\n\n/*  */\n\nfunction transformNode (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticClass = getAndRemoveAttr(el, 'class');\n  if (process.env.NODE_ENV !== 'production' && staticClass) {\n    var res = parseText(staticClass, options.delimiters);\n    if (res) {\n      warn(\n        \"class=\\\"\" + staticClass + \"\\\": \" +\n        'Interpolation inside attributes has been removed. ' +\n        'Use v-bind or the colon shorthand instead. For example, ' +\n        'instead of <div class=\"{{ val }}\">, use <div :class=\"val\">.',\n        el.rawAttrsMap['class']\n      );\n    }\n  }\n  if (staticClass) {\n    el.staticClass = JSON.stringify(staticClass);\n  }\n  var classBinding = getBindingAttr(el, 'class', false /* getStatic */);\n  if (classBinding) {\n    el.classBinding = classBinding;\n  }\n}\n\nfunction genData (el) {\n  var data = '';\n  if (el.staticClass) {\n    data += \"staticClass:\" + (el.staticClass) + \",\";\n  }\n  if (el.classBinding) {\n    data += \"class:\" + (el.classBinding) + \",\";\n  }\n  return data\n}\n\nvar klass$1 = {\n  staticKeys: ['staticClass'],\n  transformNode: transformNode,\n  genData: genData\n};\n\n/*  */\n\nfunction transformNode$1 (el, options) {\n  var warn = options.warn || baseWarn;\n  var staticStyle = getAndRemoveAttr(el, 'style');\n  if (staticStyle) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      var res = parseText(staticStyle, options.delimiters);\n      if (res) {\n        warn(\n          \"style=\\\"\" + staticStyle + \"\\\": \" +\n          'Interpolation inside attributes has been removed. ' +\n          'Use v-bind or the colon shorthand instead. For example, ' +\n          'instead of <div style=\"{{ val }}\">, use <div :style=\"val\">.',\n          el.rawAttrsMap['style']\n        );\n      }\n    }\n    el.staticStyle = JSON.stringify(parseStyleText(staticStyle));\n  }\n\n  var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);\n  if (styleBinding) {\n    el.styleBinding = styleBinding;\n  }\n}\n\nfunction genData$1 (el) {\n  var data = '';\n  if (el.staticStyle) {\n    data += \"staticStyle:\" + (el.staticStyle) + \",\";\n  }\n  if (el.styleBinding) {\n    data += \"style:(\" + (el.styleBinding) + \"),\";\n  }\n  return data\n}\n\nvar style$1 = {\n  staticKeys: ['staticStyle'],\n  transformNode: transformNode$1,\n  genData: genData$1\n};\n\n/*  */\n\nvar decoder;\n\nvar he = {\n  decode: function decode (html) {\n    decoder = decoder || document.createElement('div');\n    decoder.innerHTML = html;\n    return decoder.textContent\n  }\n};\n\n/*  */\n\nvar isUnaryTag = makeMap(\n  'area,base,br,col,embed,frame,hr,img,input,isindex,keygen,' +\n  'link,meta,param,source,track,wbr'\n);\n\n// Elements that you can, intentionally, leave open\n// (and which close themselves)\nvar canBeLeftOpenTag = makeMap(\n  'colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr,source'\n);\n\n// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3\n// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content\nvar isNonPhrasingTag = makeMap(\n  'address,article,aside,base,blockquote,body,caption,col,colgroup,dd,' +\n  'details,dialog,div,dl,dt,fieldset,figcaption,figure,footer,form,' +\n  'h1,h2,h3,h4,h5,h6,head,header,hgroup,hr,html,legend,li,menuitem,meta,' +\n  'optgroup,option,param,rp,rt,source,style,summary,tbody,td,tfoot,th,thead,' +\n  'title,tr,track'\n);\n\n/**\n * Not type-checking this file because it's mostly vendor code.\n */\n\n// Regular Expressions for parsing tags and attributes\nvar attribute = /^\\s*([^\\s\"'<>\\/=]+)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\nvar dynamicArgAttribute = /^\\s*((?:v-[\\w-]+:|@|:|#)\\[[^=]+\\][^\\s\"'<>\\/=]*)(?:\\s*(=)\\s*(?:\"([^\"]*)\"+|'([^']*)'+|([^\\s\"'=<>`]+)))?/;\nvar ncname = \"[a-zA-Z_][\\\\-\\\\.0-9_a-zA-Z\" + (unicodeRegExp.source) + \"]*\";\nvar qnameCapture = \"((?:\" + ncname + \"\\\\:)?\" + ncname + \")\";\nvar startTagOpen = new RegExp((\"^<\" + qnameCapture));\nvar startTagClose = /^\\s*(\\/?)>/;\nvar endTag = new RegExp((\"^<\\\\/\" + qnameCapture + \"[^>]*>\"));\nvar doctype = /^<!DOCTYPE [^>]+>/i;\n// #7298: escape - to avoid being passed as HTML comment when inlined in page\nvar comment = /^<!\\--/;\nvar conditionalComment = /^<!\\[/;\n\n// Special Elements (can contain anything)\nvar isPlainTextElement = makeMap('script,style,textarea', true);\nvar reCache = {};\n\nvar decodingMap = {\n  '&lt;': '<',\n  '&gt;': '>',\n  '&quot;': '\"',\n  '&amp;': '&',\n  '&#10;': '\\n',\n  '&#9;': '\\t',\n  '&#39;': \"'\"\n};\nvar encodedAttr = /&(?:lt|gt|quot|amp|#39);/g;\nvar encodedAttrWithNewLines = /&(?:lt|gt|quot|amp|#39|#10|#9);/g;\n\n// #5992\nvar isIgnoreNewlineTag = makeMap('pre,textarea', true);\nvar shouldIgnoreFirstNewline = function (tag, html) { return tag && isIgnoreNewlineTag(tag) && html[0] === '\\n'; };\n\nfunction decodeAttr (value, shouldDecodeNewlines) {\n  var re = shouldDecodeNewlines ? encodedAttrWithNewLines : encodedAttr;\n  return value.replace(re, function (match) { return decodingMap[match]; })\n}\n\nfunction parseHTML (html, options) {\n  var stack = [];\n  var expectHTML = options.expectHTML;\n  var isUnaryTag$$1 = options.isUnaryTag || no;\n  var canBeLeftOpenTag$$1 = options.canBeLeftOpenTag || no;\n  var index = 0;\n  var last, lastTag;\n  while (html) {\n    last = html;\n    // Make sure we're not in a plaintext content element like script/style\n    if (!lastTag || !isPlainTextElement(lastTag)) {\n      var textEnd = html.indexOf('<');\n      if (textEnd === 0) {\n        // Comment:\n        if (comment.test(html)) {\n          var commentEnd = html.indexOf('-->');\n\n          if (commentEnd >= 0) {\n            if (options.shouldKeepComment) {\n              options.comment(html.substring(4, commentEnd), index, index + commentEnd + 3);\n            }\n            advance(commentEnd + 3);\n            continue\n          }\n        }\n\n        // http://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment\n        if (conditionalComment.test(html)) {\n          var conditionalEnd = html.indexOf(']>');\n\n          if (conditionalEnd >= 0) {\n            advance(conditionalEnd + 2);\n            continue\n          }\n        }\n\n        // Doctype:\n        var doctypeMatch = html.match(doctype);\n        if (doctypeMatch) {\n          advance(doctypeMatch[0].length);\n          continue\n        }\n\n        // End tag:\n        var endTagMatch = html.match(endTag);\n        if (endTagMatch) {\n          var curIndex = index;\n          advance(endTagMatch[0].length);\n          parseEndTag(endTagMatch[1], curIndex, index);\n          continue\n        }\n\n        // Start tag:\n        var startTagMatch = parseStartTag();\n        if (startTagMatch) {\n          handleStartTag(startTagMatch);\n          if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {\n            advance(1);\n          }\n          continue\n        }\n      }\n\n      var text = (void 0), rest = (void 0), next = (void 0);\n      if (textEnd >= 0) {\n        rest = html.slice(textEnd);\n        while (\n          !endTag.test(rest) &&\n          !startTagOpen.test(rest) &&\n          !comment.test(rest) &&\n          !conditionalComment.test(rest)\n        ) {\n          // < in plain text, be forgiving and treat it as text\n          next = rest.indexOf('<', 1);\n          if (next < 0) { break }\n          textEnd += next;\n          rest = html.slice(textEnd);\n        }\n        text = html.substring(0, textEnd);\n      }\n\n      if (textEnd < 0) {\n        text = html;\n      }\n\n      if (text) {\n        advance(text.length);\n      }\n\n      if (options.chars && text) {\n        options.chars(text, index - text.length, index);\n      }\n    } else {\n      var endTagLength = 0;\n      var stackedTag = lastTag.toLowerCase();\n      var reStackedTag = reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\\\s\\\\S]*?)(</' + stackedTag + '[^>]*>)', 'i'));\n      var rest$1 = html.replace(reStackedTag, function (all, text, endTag) {\n        endTagLength = endTag.length;\n        if (!isPlainTextElement(stackedTag) && stackedTag !== 'noscript') {\n          text = text\n            .replace(/<!\\--([\\s\\S]*?)-->/g, '$1') // #7298\n            .replace(/<!\\[CDATA\\[([\\s\\S]*?)]]>/g, '$1');\n        }\n        if (shouldIgnoreFirstNewline(stackedTag, text)) {\n          text = text.slice(1);\n        }\n        if (options.chars) {\n          options.chars(text);\n        }\n        return ''\n      });\n      index += html.length - rest$1.length;\n      html = rest$1;\n      parseEndTag(stackedTag, index - endTagLength, index);\n    }\n\n    if (html === last) {\n      options.chars && options.chars(html);\n      if (process.env.NODE_ENV !== 'production' && !stack.length && options.warn) {\n        options.warn((\"Mal-formatted tag at end of template: \\\"\" + html + \"\\\"\"), { start: index + html.length });\n      }\n      break\n    }\n  }\n\n  // Clean up any remaining tags\n  parseEndTag();\n\n  function advance (n) {\n    index += n;\n    html = html.substring(n);\n  }\n\n  function parseStartTag () {\n    var start = html.match(startTagOpen);\n    if (start) {\n      var match = {\n        tagName: start[1],\n        attrs: [],\n        start: index\n      };\n      advance(start[0].length);\n      var end, attr;\n      while (!(end = html.match(startTagClose)) && (attr = html.match(dynamicArgAttribute) || html.match(attribute))) {\n        attr.start = index;\n        advance(attr[0].length);\n        attr.end = index;\n        match.attrs.push(attr);\n      }\n      if (end) {\n        match.unarySlash = end[1];\n        advance(end[0].length);\n        match.end = index;\n        return match\n      }\n    }\n  }\n\n  function handleStartTag (match) {\n    var tagName = match.tagName;\n    var unarySlash = match.unarySlash;\n\n    if (expectHTML) {\n      if (lastTag === 'p' && isNonPhrasingTag(tagName)) {\n        parseEndTag(lastTag);\n      }\n      if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {\n        parseEndTag(tagName);\n      }\n    }\n\n    var unary = isUnaryTag$$1(tagName) || !!unarySlash;\n\n    var l = match.attrs.length;\n    var attrs = new Array(l);\n    for (var i = 0; i < l; i++) {\n      var args = match.attrs[i];\n      var value = args[3] || args[4] || args[5] || '';\n      var shouldDecodeNewlines = tagName === 'a' && args[1] === 'href'\n        ? options.shouldDecodeNewlinesForHref\n        : options.shouldDecodeNewlines;\n      attrs[i] = {\n        name: args[1],\n        value: decodeAttr(value, shouldDecodeNewlines)\n      };\n      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n        attrs[i].start = args.start + args[0].match(/^\\s*/).length;\n        attrs[i].end = args.end;\n      }\n    }\n\n    if (!unary) {\n      stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });\n      lastTag = tagName;\n    }\n\n    if (options.start) {\n      options.start(tagName, attrs, unary, match.start, match.end);\n    }\n  }\n\n  function parseEndTag (tagName, start, end) {\n    var pos, lowerCasedTagName;\n    if (start == null) { start = index; }\n    if (end == null) { end = index; }\n\n    // Find the closest opened tag of the same type\n    if (tagName) {\n      lowerCasedTagName = tagName.toLowerCase();\n      for (pos = stack.length - 1; pos >= 0; pos--) {\n        if (stack[pos].lowerCasedTag === lowerCasedTagName) {\n          break\n        }\n      }\n    } else {\n      // If no tag name is provided, clean shop\n      pos = 0;\n    }\n\n    if (pos >= 0) {\n      // Close all the open elements, up the stack\n      for (var i = stack.length - 1; i >= pos; i--) {\n        if (process.env.NODE_ENV !== 'production' &&\n          (i > pos || !tagName) &&\n          options.warn\n        ) {\n          options.warn(\n            (\"tag <\" + (stack[i].tag) + \"> has no matching end tag.\"),\n            { start: stack[i].start, end: stack[i].end }\n          );\n        }\n        if (options.end) {\n          options.end(stack[i].tag, start, end);\n        }\n      }\n\n      // Remove the open elements from the stack\n      stack.length = pos;\n      lastTag = pos && stack[pos - 1].tag;\n    } else if (lowerCasedTagName === 'br') {\n      if (options.start) {\n        options.start(tagName, [], true, start, end);\n      }\n    } else if (lowerCasedTagName === 'p') {\n      if (options.start) {\n        options.start(tagName, [], false, start, end);\n      }\n      if (options.end) {\n        options.end(tagName, start, end);\n      }\n    }\n  }\n}\n\n/*  */\n\nvar onRE = /^@|^v-on:/;\nvar dirRE = /^v-|^@|^:|^#/;\nvar forAliasRE = /([\\s\\S]*?)\\s+(?:in|of)\\s+([\\s\\S]*)/;\nvar forIteratorRE = /,([^,\\}\\]]*)(?:,([^,\\}\\]]*))?$/;\nvar stripParensRE = /^\\(|\\)$/g;\nvar dynamicArgRE = /^\\[.*\\]$/;\n\nvar argRE = /:(.*)$/;\nvar bindRE = /^:|^\\.|^v-bind:/;\nvar modifierRE = /\\.[^.\\]]+(?=[^\\]]*$)/g;\n\nvar slotRE = /^v-slot(:|$)|^#/;\n\nvar lineBreakRE = /[\\r\\n]/;\nvar whitespaceRE$1 = /\\s+/g;\n\nvar invalidAttributeRE = /[\\s\"'<>\\/=]/;\n\nvar decodeHTMLCached = cached(he.decode);\n\nvar emptySlotScopeToken = \"_empty_\";\n\n// configurable state\nvar warn$2;\nvar delimiters;\nvar transforms;\nvar preTransforms;\nvar postTransforms;\nvar platformIsPreTag;\nvar platformMustUseProp;\nvar platformGetTagNamespace;\nvar maybeComponent;\n\nfunction createASTElement (\n  tag,\n  attrs,\n  parent\n) {\n  return {\n    type: 1,\n    tag: tag,\n    attrsList: attrs,\n    attrsMap: makeAttrsMap(attrs),\n    rawAttrsMap: {},\n    parent: parent,\n    children: []\n  }\n}\n\n/**\n * Convert HTML string to AST.\n */\nfunction parse (\n  template,\n  options\n) {\n  warn$2 = options.warn || baseWarn;\n\n  platformIsPreTag = options.isPreTag || no;\n  platformMustUseProp = options.mustUseProp || no;\n  platformGetTagNamespace = options.getTagNamespace || no;\n  var isReservedTag = options.isReservedTag || no;\n  maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };\n\n  transforms = pluckModuleFunction(options.modules, 'transformNode');\n  preTransforms = pluckModuleFunction(options.modules, 'preTransformNode');\n  postTransforms = pluckModuleFunction(options.modules, 'postTransformNode');\n\n  delimiters = options.delimiters;\n\n  var stack = [];\n  var preserveWhitespace = options.preserveWhitespace !== false;\n  var whitespaceOption = options.whitespace;\n  var root;\n  var currentParent;\n  var inVPre = false;\n  var inPre = false;\n  var warned = false;\n\n  function warnOnce (msg, range) {\n    if (!warned) {\n      warned = true;\n      warn$2(msg, range);\n    }\n  }\n\n  function closeElement (element) {\n    trimEndingWhitespace(element);\n    if (!inVPre && !element.processed) {\n      element = processElement(element, options);\n    }\n    // tree management\n    if (!stack.length && element !== root) {\n      // allow root elements with v-if, v-else-if and v-else\n      if (root.if && (element.elseif || element.else)) {\n        if (process.env.NODE_ENV !== 'production') {\n          checkRootConstraints(element);\n        }\n        addIfCondition(root, {\n          exp: element.elseif,\n          block: element\n        });\n      } else if (process.env.NODE_ENV !== 'production') {\n        warnOnce(\n          \"Component template should contain exactly one root element. \" +\n          \"If you are using v-if on multiple elements, \" +\n          \"use v-else-if to chain them instead.\",\n          { start: element.start }\n        );\n      }\n    }\n    if (currentParent && !element.forbidden) {\n      if (element.elseif || element.else) {\n        processIfConditions(element, currentParent);\n      } else {\n        if (element.slotScope) {\n          // scoped slot\n          // keep it in the children list so that v-else(-if) conditions can\n          // find it as the prev node.\n          var name = element.slotTarget || '\"default\"'\n          ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element;\n        }\n        currentParent.children.push(element);\n        element.parent = currentParent;\n      }\n    }\n\n    // final children cleanup\n    // filter out scoped slots\n    element.children = element.children.filter(function (c) { return !(c).slotScope; });\n    // remove trailing whitespace node again\n    trimEndingWhitespace(element);\n\n    // check pre state\n    if (element.pre) {\n      inVPre = false;\n    }\n    if (platformIsPreTag(element.tag)) {\n      inPre = false;\n    }\n    // apply post-transforms\n    for (var i = 0; i < postTransforms.length; i++) {\n      postTransforms[i](element, options);\n    }\n  }\n\n  function trimEndingWhitespace (el) {\n    // remove trailing whitespace node\n    if (!inPre) {\n      var lastNode;\n      while (\n        (lastNode = el.children[el.children.length - 1]) &&\n        lastNode.type === 3 &&\n        lastNode.text === ' '\n      ) {\n        el.children.pop();\n      }\n    }\n  }\n\n  function checkRootConstraints (el) {\n    if (el.tag === 'slot' || el.tag === 'template') {\n      warnOnce(\n        \"Cannot use <\" + (el.tag) + \"> as component root element because it may \" +\n        'contain multiple nodes.',\n        { start: el.start }\n      );\n    }\n    if (el.attrsMap.hasOwnProperty('v-for')) {\n      warnOnce(\n        'Cannot use v-for on stateful component root element because ' +\n        'it renders multiple elements.',\n        el.rawAttrsMap['v-for']\n      );\n    }\n  }\n\n  parseHTML(template, {\n    warn: warn$2,\n    expectHTML: options.expectHTML,\n    isUnaryTag: options.isUnaryTag,\n    canBeLeftOpenTag: options.canBeLeftOpenTag,\n    shouldDecodeNewlines: options.shouldDecodeNewlines,\n    shouldDecodeNewlinesForHref: options.shouldDecodeNewlinesForHref,\n    shouldKeepComment: options.comments,\n    outputSourceRange: options.outputSourceRange,\n    start: function start (tag, attrs, unary, start$1, end) {\n      // check namespace.\n      // inherit parent ns if there is one\n      var ns = (currentParent && currentParent.ns) || platformGetTagNamespace(tag);\n\n      // handle IE svg bug\n      /* istanbul ignore if */\n      if (isIE && ns === 'svg') {\n        attrs = guardIESVGBug(attrs);\n      }\n\n      var element = createASTElement(tag, attrs, currentParent);\n      if (ns) {\n        element.ns = ns;\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        if (options.outputSourceRange) {\n          element.start = start$1;\n          element.end = end;\n          element.rawAttrsMap = element.attrsList.reduce(function (cumulated, attr) {\n            cumulated[attr.name] = attr;\n            return cumulated\n          }, {});\n        }\n        attrs.forEach(function (attr) {\n          if (invalidAttributeRE.test(attr.name)) {\n            warn$2(\n              \"Invalid dynamic argument expression: attribute names cannot contain \" +\n              \"spaces, quotes, <, >, / or =.\",\n              {\n                start: attr.start + attr.name.indexOf(\"[\"),\n                end: attr.start + attr.name.length\n              }\n            );\n          }\n        });\n      }\n\n      if (isForbiddenTag(element) && !isServerRendering()) {\n        element.forbidden = true;\n        process.env.NODE_ENV !== 'production' && warn$2(\n          'Templates should only be responsible for mapping the state to the ' +\n          'UI. Avoid placing tags with side-effects in your templates, such as ' +\n          \"<\" + tag + \">\" + ', as they will not be parsed.',\n          { start: element.start }\n        );\n      }\n\n      // apply pre-transforms\n      for (var i = 0; i < preTransforms.length; i++) {\n        element = preTransforms[i](element, options) || element;\n      }\n\n      if (!inVPre) {\n        processPre(element);\n        if (element.pre) {\n          inVPre = true;\n        }\n      }\n      if (platformIsPreTag(element.tag)) {\n        inPre = true;\n      }\n      if (inVPre) {\n        processRawAttrs(element);\n      } else if (!element.processed) {\n        // structural directives\n        processFor(element);\n        processIf(element);\n        processOnce(element);\n      }\n\n      if (!root) {\n        root = element;\n        if (process.env.NODE_ENV !== 'production') {\n          checkRootConstraints(root);\n        }\n      }\n\n      if (!unary) {\n        currentParent = element;\n        stack.push(element);\n      } else {\n        closeElement(element);\n      }\n    },\n\n    end: function end (tag, start, end$1) {\n      var element = stack[stack.length - 1];\n      // pop stack\n      stack.length -= 1;\n      currentParent = stack[stack.length - 1];\n      if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n        element.end = end$1;\n      }\n      closeElement(element);\n    },\n\n    chars: function chars (text, start, end) {\n      if (!currentParent) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (text === template) {\n            warnOnce(\n              'Component template requires a root element, rather than just text.',\n              { start: start }\n            );\n          } else if ((text = text.trim())) {\n            warnOnce(\n              (\"text \\\"\" + text + \"\\\" outside root element will be ignored.\"),\n              { start: start }\n            );\n          }\n        }\n        return\n      }\n      // IE textarea placeholder bug\n      /* istanbul ignore if */\n      if (isIE &&\n        currentParent.tag === 'textarea' &&\n        currentParent.attrsMap.placeholder === text\n      ) {\n        return\n      }\n      var children = currentParent.children;\n      if (inPre || text.trim()) {\n        text = isTextTag(currentParent) ? text : decodeHTMLCached(text);\n      } else if (!children.length) {\n        // remove the whitespace-only node right after an opening tag\n        text = '';\n      } else if (whitespaceOption) {\n        if (whitespaceOption === 'condense') {\n          // in condense mode, remove the whitespace node if it contains\n          // line break, otherwise condense to a single space\n          text = lineBreakRE.test(text) ? '' : ' ';\n        } else {\n          text = ' ';\n        }\n      } else {\n        text = preserveWhitespace ? ' ' : '';\n      }\n      if (text) {\n        if (!inPre && whitespaceOption === 'condense') {\n          // condense consecutive whitespaces into single space\n          text = text.replace(whitespaceRE$1, ' ');\n        }\n        var res;\n        var child;\n        if (!inVPre && text !== ' ' && (res = parseText(text, delimiters))) {\n          child = {\n            type: 2,\n            expression: res.expression,\n            tokens: res.tokens,\n            text: text\n          };\n        } else if (text !== ' ' || !children.length || children[children.length - 1].text !== ' ') {\n          child = {\n            type: 3,\n            text: text\n          };\n        }\n        if (child) {\n          if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n            child.start = start;\n            child.end = end;\n          }\n          children.push(child);\n        }\n      }\n    },\n    comment: function comment (text, start, end) {\n      // adding anything as a sibling to the root node is forbidden\n      // comments should still be allowed, but ignored\n      if (currentParent) {\n        var child = {\n          type: 3,\n          text: text,\n          isComment: true\n        };\n        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n          child.start = start;\n          child.end = end;\n        }\n        currentParent.children.push(child);\n      }\n    }\n  });\n  return root\n}\n\nfunction processPre (el) {\n  if (getAndRemoveAttr(el, 'v-pre') != null) {\n    el.pre = true;\n  }\n}\n\nfunction processRawAttrs (el) {\n  var list = el.attrsList;\n  var len = list.length;\n  if (len) {\n    var attrs = el.attrs = new Array(len);\n    for (var i = 0; i < len; i++) {\n      attrs[i] = {\n        name: list[i].name,\n        value: JSON.stringify(list[i].value)\n      };\n      if (list[i].start != null) {\n        attrs[i].start = list[i].start;\n        attrs[i].end = list[i].end;\n      }\n    }\n  } else if (!el.pre) {\n    // non root node in pre blocks with no attributes\n    el.plain = true;\n  }\n}\n\nfunction processElement (\n  element,\n  options\n) {\n  processKey(element);\n\n  // determine whether this is a plain element after\n  // removing structural attributes\n  element.plain = (\n    !element.key &&\n    !element.scopedSlots &&\n    !element.attrsList.length\n  );\n\n  processRef(element);\n  processSlotContent(element);\n  processSlotOutlet(element);\n  processComponent(element);\n  for (var i = 0; i < transforms.length; i++) {\n    element = transforms[i](element, options) || element;\n  }\n  processAttrs(element);\n  return element\n}\n\nfunction processKey (el) {\n  var exp = getBindingAttr(el, 'key');\n  if (exp) {\n    if (process.env.NODE_ENV !== 'production') {\n      if (el.tag === 'template') {\n        warn$2(\n          \"<template> cannot be keyed. Place the key on real elements instead.\",\n          getRawBindingAttr(el, 'key')\n        );\n      }\n      if (el.for) {\n        var iterator = el.iterator2 || el.iterator1;\n        var parent = el.parent;\n        if (iterator && iterator === exp && parent && parent.tag === 'transition-group') {\n          warn$2(\n            \"Do not use v-for index as key on <transition-group> children, \" +\n            \"this is the same as not using keys.\",\n            getRawBindingAttr(el, 'key'),\n            true /* tip */\n          );\n        }\n      }\n    }\n    el.key = exp;\n  }\n}\n\nfunction processRef (el) {\n  var ref = getBindingAttr(el, 'ref');\n  if (ref) {\n    el.ref = ref;\n    el.refInFor = checkInFor(el);\n  }\n}\n\nfunction processFor (el) {\n  var exp;\n  if ((exp = getAndRemoveAttr(el, 'v-for'))) {\n    var res = parseFor(exp);\n    if (res) {\n      extend(el, res);\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn$2(\n        (\"Invalid v-for expression: \" + exp),\n        el.rawAttrsMap['v-for']\n      );\n    }\n  }\n}\n\n\n\nfunction parseFor (exp) {\n  var inMatch = exp.match(forAliasRE);\n  if (!inMatch) { return }\n  var res = {};\n  res.for = inMatch[2].trim();\n  var alias = inMatch[1].trim().replace(stripParensRE, '');\n  var iteratorMatch = alias.match(forIteratorRE);\n  if (iteratorMatch) {\n    res.alias = alias.replace(forIteratorRE, '').trim();\n    res.iterator1 = iteratorMatch[1].trim();\n    if (iteratorMatch[2]) {\n      res.iterator2 = iteratorMatch[2].trim();\n    }\n  } else {\n    res.alias = alias;\n  }\n  return res\n}\n\nfunction processIf (el) {\n  var exp = getAndRemoveAttr(el, 'v-if');\n  if (exp) {\n    el.if = exp;\n    addIfCondition(el, {\n      exp: exp,\n      block: el\n    });\n  } else {\n    if (getAndRemoveAttr(el, 'v-else') != null) {\n      el.else = true;\n    }\n    var elseif = getAndRemoveAttr(el, 'v-else-if');\n    if (elseif) {\n      el.elseif = elseif;\n    }\n  }\n}\n\nfunction processIfConditions (el, parent) {\n  var prev = findPrevElement(parent.children);\n  if (prev && prev.if) {\n    addIfCondition(prev, {\n      exp: el.elseif,\n      block: el\n    });\n  } else if (process.env.NODE_ENV !== 'production') {\n    warn$2(\n      \"v-\" + (el.elseif ? ('else-if=\"' + el.elseif + '\"') : 'else') + \" \" +\n      \"used on element <\" + (el.tag) + \"> without corresponding v-if.\",\n      el.rawAttrsMap[el.elseif ? 'v-else-if' : 'v-else']\n    );\n  }\n}\n\nfunction findPrevElement (children) {\n  var i = children.length;\n  while (i--) {\n    if (children[i].type === 1) {\n      return children[i]\n    } else {\n      if (process.env.NODE_ENV !== 'production' && children[i].text !== ' ') {\n        warn$2(\n          \"text \\\"\" + (children[i].text.trim()) + \"\\\" between v-if and v-else(-if) \" +\n          \"will be ignored.\",\n          children[i]\n        );\n      }\n      children.pop();\n    }\n  }\n}\n\nfunction addIfCondition (el, condition) {\n  if (!el.ifConditions) {\n    el.ifConditions = [];\n  }\n  el.ifConditions.push(condition);\n}\n\nfunction processOnce (el) {\n  var once$$1 = getAndRemoveAttr(el, 'v-once');\n  if (once$$1 != null) {\n    el.once = true;\n  }\n}\n\n// handle content being passed to a component as slot,\n// e.g. <template slot=\"xxx\">, <div slot-scope=\"xxx\">\nfunction processSlotContent (el) {\n  var slotScope;\n  if (el.tag === 'template') {\n    slotScope = getAndRemoveAttr(el, 'scope');\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && slotScope) {\n      warn$2(\n        \"the \\\"scope\\\" attribute for scoped slots have been deprecated and \" +\n        \"replaced by \\\"slot-scope\\\" since 2.5. The new \\\"slot-scope\\\" attribute \" +\n        \"can also be used on plain elements in addition to <template> to \" +\n        \"denote scoped slots.\",\n        el.rawAttrsMap['scope'],\n        true\n      );\n    }\n    el.slotScope = slotScope || getAndRemoveAttr(el, 'slot-scope');\n  } else if ((slotScope = getAndRemoveAttr(el, 'slot-scope'))) {\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production' && el.attrsMap['v-for']) {\n      warn$2(\n        \"Ambiguous combined usage of slot-scope and v-for on <\" + (el.tag) + \"> \" +\n        \"(v-for takes higher priority). Use a wrapper <template> for the \" +\n        \"scoped slot to make it clearer.\",\n        el.rawAttrsMap['slot-scope'],\n        true\n      );\n    }\n    el.slotScope = slotScope;\n  }\n\n  // slot=\"xxx\"\n  var slotTarget = getBindingAttr(el, 'slot');\n  if (slotTarget) {\n    el.slotTarget = slotTarget === '\"\"' ? '\"default\"' : slotTarget;\n    el.slotTargetDynamic = !!(el.attrsMap[':slot'] || el.attrsMap['v-bind:slot']);\n    // preserve slot as an attribute for native shadow DOM compat\n    // only for non-scoped slots.\n    if (el.tag !== 'template' && !el.slotScope) {\n      addAttr(el, 'slot', slotTarget, getRawBindingAttr(el, 'slot'));\n    }\n  }\n\n  // 2.6 v-slot syntax\n  {\n    if (el.tag === 'template') {\n      // v-slot on <template>\n      var slotBinding = getAndRemoveAttrByRegex(el, slotRE);\n      if (slotBinding) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (el.slotTarget || el.slotScope) {\n            warn$2(\n              \"Unexpected mixed usage of different slot syntaxes.\",\n              el\n            );\n          }\n          if (el.parent && !maybeComponent(el.parent)) {\n            warn$2(\n              \"<template v-slot> can only appear at the root level inside \" +\n              \"the receiving component\",\n              el\n            );\n          }\n        }\n        var ref = getSlotName(slotBinding);\n        var name = ref.name;\n        var dynamic = ref.dynamic;\n        el.slotTarget = name;\n        el.slotTargetDynamic = dynamic;\n        el.slotScope = slotBinding.value || emptySlotScopeToken; // force it into a scoped slot for perf\n      }\n    } else {\n      // v-slot on component, denotes default slot\n      var slotBinding$1 = getAndRemoveAttrByRegex(el, slotRE);\n      if (slotBinding$1) {\n        if (process.env.NODE_ENV !== 'production') {\n          if (!maybeComponent(el)) {\n            warn$2(\n              \"v-slot can only be used on components or <template>.\",\n              slotBinding$1\n            );\n          }\n          if (el.slotScope || el.slotTarget) {\n            warn$2(\n              \"Unexpected mixed usage of different slot syntaxes.\",\n              el\n            );\n          }\n          if (el.scopedSlots) {\n            warn$2(\n              \"To avoid scope ambiguity, the default slot should also use \" +\n              \"<template> syntax when there are other named slots.\",\n              slotBinding$1\n            );\n          }\n        }\n        // add the component's children to its default slot\n        var slots = el.scopedSlots || (el.scopedSlots = {});\n        var ref$1 = getSlotName(slotBinding$1);\n        var name$1 = ref$1.name;\n        var dynamic$1 = ref$1.dynamic;\n        var slotContainer = slots[name$1] = createASTElement('template', [], el);\n        slotContainer.slotTarget = name$1;\n        slotContainer.slotTargetDynamic = dynamic$1;\n        slotContainer.children = el.children.filter(function (c) {\n          if (!c.slotScope) {\n            c.parent = slotContainer;\n            return true\n          }\n        });\n        slotContainer.slotScope = slotBinding$1.value || emptySlotScopeToken;\n        // remove children as they are returned from scopedSlots now\n        el.children = [];\n        // mark el non-plain so data gets generated\n        el.plain = false;\n      }\n    }\n  }\n}\n\nfunction getSlotName (binding) {\n  var name = binding.name.replace(slotRE, '');\n  if (!name) {\n    if (binding.name[0] !== '#') {\n      name = 'default';\n    } else if (process.env.NODE_ENV !== 'production') {\n      warn$2(\n        \"v-slot shorthand syntax requires a slot name.\",\n        binding\n      );\n    }\n  }\n  return dynamicArgRE.test(name)\n    // dynamic [name]\n    ? { name: name.slice(1, -1), dynamic: true }\n    // static name\n    : { name: (\"\\\"\" + name + \"\\\"\"), dynamic: false }\n}\n\n// handle <slot/> outlets\nfunction processSlotOutlet (el) {\n  if (el.tag === 'slot') {\n    el.slotName = getBindingAttr(el, 'name');\n    if (process.env.NODE_ENV !== 'production' && el.key) {\n      warn$2(\n        \"`key` does not work on <slot> because slots are abstract outlets \" +\n        \"and can possibly expand into multiple elements. \" +\n        \"Use the key on a wrapping element instead.\",\n        getRawBindingAttr(el, 'key')\n      );\n    }\n  }\n}\n\nfunction processComponent (el) {\n  var binding;\n  if ((binding = getBindingAttr(el, 'is'))) {\n    el.component = binding;\n  }\n  if (getAndRemoveAttr(el, 'inline-template') != null) {\n    el.inlineTemplate = true;\n  }\n}\n\nfunction processAttrs (el) {\n  var list = el.attrsList;\n  var i, l, name, rawName, value, modifiers, syncGen, isDynamic;\n  for (i = 0, l = list.length; i < l; i++) {\n    name = rawName = list[i].name;\n    value = list[i].value;\n    if (dirRE.test(name)) {\n      // mark element as dynamic\n      el.hasBindings = true;\n      // modifiers\n      modifiers = parseModifiers(name.replace(dirRE, ''));\n      // support .foo shorthand syntax for the .prop modifier\n      if (modifiers) {\n        name = name.replace(modifierRE, '');\n      }\n      if (bindRE.test(name)) { // v-bind\n        name = name.replace(bindRE, '');\n        value = parseFilters(value);\n        isDynamic = dynamicArgRE.test(name);\n        if (isDynamic) {\n          name = name.slice(1, -1);\n        }\n        if (\n          process.env.NODE_ENV !== 'production' &&\n          value.trim().length === 0\n        ) {\n          warn$2(\n            (\"The value for a v-bind expression cannot be empty. Found in \\\"v-bind:\" + name + \"\\\"\")\n          );\n        }\n        if (modifiers) {\n          if (modifiers.prop && !isDynamic) {\n            name = camelize(name);\n            if (name === 'innerHtml') { name = 'innerHTML'; }\n          }\n          if (modifiers.camel && !isDynamic) {\n            name = camelize(name);\n          }\n          if (modifiers.sync) {\n            syncGen = genAssignmentCode(value, \"$event\");\n            if (!isDynamic) {\n              addHandler(\n                el,\n                (\"update:\" + (camelize(name))),\n                syncGen,\n                null,\n                false,\n                warn$2,\n                list[i]\n              );\n              if (hyphenate(name) !== camelize(name)) {\n                addHandler(\n                  el,\n                  (\"update:\" + (hyphenate(name))),\n                  syncGen,\n                  null,\n                  false,\n                  warn$2,\n                  list[i]\n                );\n              }\n            } else {\n              // handler w/ dynamic event name\n              addHandler(\n                el,\n                (\"\\\"update:\\\"+(\" + name + \")\"),\n                syncGen,\n                null,\n                false,\n                warn$2,\n                list[i],\n                true // dynamic\n              );\n            }\n          }\n        }\n        if ((modifiers && modifiers.prop) || (\n          !el.component && platformMustUseProp(el.tag, el.attrsMap.type, name)\n        )) {\n          addProp(el, name, value, list[i], isDynamic);\n        } else {\n          addAttr(el, name, value, list[i], isDynamic);\n        }\n      } else if (onRE.test(name)) { // v-on\n        name = name.replace(onRE, '');\n        isDynamic = dynamicArgRE.test(name);\n        if (isDynamic) {\n          name = name.slice(1, -1);\n        }\n        addHandler(el, name, value, modifiers, false, warn$2, list[i], isDynamic);\n      } else { // normal directives\n        name = name.replace(dirRE, '');\n        // parse arg\n        var argMatch = name.match(argRE);\n        var arg = argMatch && argMatch[1];\n        isDynamic = false;\n        if (arg) {\n          name = name.slice(0, -(arg.length + 1));\n          if (dynamicArgRE.test(arg)) {\n            arg = arg.slice(1, -1);\n            isDynamic = true;\n          }\n        }\n        addDirective(el, name, rawName, value, arg, isDynamic, modifiers, list[i]);\n        if (process.env.NODE_ENV !== 'production' && name === 'model') {\n          checkForAliasModel(el, value);\n        }\n      }\n    } else {\n      // literal attribute\n      if (process.env.NODE_ENV !== 'production') {\n        var res = parseText(value, delimiters);\n        if (res) {\n          warn$2(\n            name + \"=\\\"\" + value + \"\\\": \" +\n            'Interpolation inside attributes has been removed. ' +\n            'Use v-bind or the colon shorthand instead. For example, ' +\n            'instead of <div id=\"{{ val }}\">, use <div :id=\"val\">.',\n            list[i]\n          );\n        }\n      }\n      addAttr(el, name, JSON.stringify(value), list[i]);\n      // #6887 firefox doesn't update muted state if set via attribute\n      // even immediately after element creation\n      if (!el.component &&\n          name === 'muted' &&\n          platformMustUseProp(el.tag, el.attrsMap.type, name)) {\n        addProp(el, name, 'true', list[i]);\n      }\n    }\n  }\n}\n\nfunction checkInFor (el) {\n  var parent = el;\n  while (parent) {\n    if (parent.for !== undefined) {\n      return true\n    }\n    parent = parent.parent;\n  }\n  return false\n}\n\nfunction parseModifiers (name) {\n  var match = name.match(modifierRE);\n  if (match) {\n    var ret = {};\n    match.forEach(function (m) { ret[m.slice(1)] = true; });\n    return ret\n  }\n}\n\nfunction makeAttrsMap (attrs) {\n  var map = {};\n  for (var i = 0, l = attrs.length; i < l; i++) {\n    if (\n      process.env.NODE_ENV !== 'production' &&\n      map[attrs[i].name] && !isIE && !isEdge\n    ) {\n      warn$2('duplicate attribute: ' + attrs[i].name, attrs[i]);\n    }\n    map[attrs[i].name] = attrs[i].value;\n  }\n  return map\n}\n\n// for script (e.g. type=\"x/template\") or style, do not decode content\nfunction isTextTag (el) {\n  return el.tag === 'script' || el.tag === 'style'\n}\n\nfunction isForbiddenTag (el) {\n  return (\n    el.tag === 'style' ||\n    (el.tag === 'script' && (\n      !el.attrsMap.type ||\n      el.attrsMap.type === 'text/javascript'\n    ))\n  )\n}\n\nvar ieNSBug = /^xmlns:NS\\d+/;\nvar ieNSPrefix = /^NS\\d+:/;\n\n/* istanbul ignore next */\nfunction guardIESVGBug (attrs) {\n  var res = [];\n  for (var i = 0; i < attrs.length; i++) {\n    var attr = attrs[i];\n    if (!ieNSBug.test(attr.name)) {\n      attr.name = attr.name.replace(ieNSPrefix, '');\n      res.push(attr);\n    }\n  }\n  return res\n}\n\nfunction checkForAliasModel (el, value) {\n  var _el = el;\n  while (_el) {\n    if (_el.for && _el.alias === value) {\n      warn$2(\n        \"<\" + (el.tag) + \" v-model=\\\"\" + value + \"\\\">: \" +\n        \"You are binding v-model directly to a v-for iteration alias. \" +\n        \"This will not be able to modify the v-for source array because \" +\n        \"writing to the alias is like modifying a function local variable. \" +\n        \"Consider using an array of objects and use v-model on an object property instead.\",\n        el.rawAttrsMap['v-model']\n      );\n    }\n    _el = _el.parent;\n  }\n}\n\n/*  */\n\nfunction preTransformNode (el, options) {\n  if (el.tag === 'input') {\n    var map = el.attrsMap;\n    if (!map['v-model']) {\n      return\n    }\n\n    var typeBinding;\n    if (map[':type'] || map['v-bind:type']) {\n      typeBinding = getBindingAttr(el, 'type');\n    }\n    if (!map.type && !typeBinding && map['v-bind']) {\n      typeBinding = \"(\" + (map['v-bind']) + \").type\";\n    }\n\n    if (typeBinding) {\n      var ifCondition = getAndRemoveAttr(el, 'v-if', true);\n      var ifConditionExtra = ifCondition ? (\"&&(\" + ifCondition + \")\") : \"\";\n      var hasElse = getAndRemoveAttr(el, 'v-else', true) != null;\n      var elseIfCondition = getAndRemoveAttr(el, 'v-else-if', true);\n      // 1. checkbox\n      var branch0 = cloneASTElement(el);\n      // process for on the main node\n      processFor(branch0);\n      addRawAttr(branch0, 'type', 'checkbox');\n      processElement(branch0, options);\n      branch0.processed = true; // prevent it from double-processed\n      branch0.if = \"(\" + typeBinding + \")==='checkbox'\" + ifConditionExtra;\n      addIfCondition(branch0, {\n        exp: branch0.if,\n        block: branch0\n      });\n      // 2. add radio else-if condition\n      var branch1 = cloneASTElement(el);\n      getAndRemoveAttr(branch1, 'v-for', true);\n      addRawAttr(branch1, 'type', 'radio');\n      processElement(branch1, options);\n      addIfCondition(branch0, {\n        exp: \"(\" + typeBinding + \")==='radio'\" + ifConditionExtra,\n        block: branch1\n      });\n      // 3. other\n      var branch2 = cloneASTElement(el);\n      getAndRemoveAttr(branch2, 'v-for', true);\n      addRawAttr(branch2, ':type', typeBinding);\n      processElement(branch2, options);\n      addIfCondition(branch0, {\n        exp: ifCondition,\n        block: branch2\n      });\n\n      if (hasElse) {\n        branch0.else = true;\n      } else if (elseIfCondition) {\n        branch0.elseif = elseIfCondition;\n      }\n\n      return branch0\n    }\n  }\n}\n\nfunction cloneASTElement (el) {\n  return createASTElement(el.tag, el.attrsList.slice(), el.parent)\n}\n\nvar model$1 = {\n  preTransformNode: preTransformNode\n};\n\nvar modules$1 = [\n  klass$1,\n  style$1,\n  model$1\n];\n\n/*  */\n\nfunction text (el, dir) {\n  if (dir.value) {\n    addProp(el, 'textContent', (\"_s(\" + (dir.value) + \")\"), dir);\n  }\n}\n\n/*  */\n\nfunction html (el, dir) {\n  if (dir.value) {\n    addProp(el, 'innerHTML', (\"_s(\" + (dir.value) + \")\"), dir);\n  }\n}\n\nvar directives$1 = {\n  model: model,\n  text: text,\n  html: html\n};\n\n/*  */\n\nvar baseOptions = {\n  expectHTML: true,\n  modules: modules$1,\n  directives: directives$1,\n  isPreTag: isPreTag,\n  isUnaryTag: isUnaryTag,\n  mustUseProp: mustUseProp,\n  canBeLeftOpenTag: canBeLeftOpenTag,\n  isReservedTag: isReservedTag,\n  getTagNamespace: getTagNamespace,\n  staticKeys: genStaticKeys(modules$1)\n};\n\n/*  */\n\nvar isStaticKey;\nvar isPlatformReservedTag;\n\nvar genStaticKeysCached = cached(genStaticKeys$1);\n\n/**\n * Goal of the optimizer: walk the generated template AST tree\n * and detect sub-trees that are purely static, i.e. parts of\n * the DOM that never needs to change.\n *\n * Once we detect these sub-trees, we can:\n *\n * 1. Hoist them into constants, so that we no longer need to\n *    create fresh nodes for them on each re-render;\n * 2. Completely skip them in the patching process.\n */\nfunction optimize (root, options) {\n  if (!root) { return }\n  isStaticKey = genStaticKeysCached(options.staticKeys || '');\n  isPlatformReservedTag = options.isReservedTag || no;\n  // first pass: mark all non-static nodes.\n  markStatic$1(root);\n  // second pass: mark static roots.\n  markStaticRoots(root, false);\n}\n\nfunction genStaticKeys$1 (keys) {\n  return makeMap(\n    'type,tag,attrsList,attrsMap,plain,parent,children,attrs,start,end,rawAttrsMap' +\n    (keys ? ',' + keys : '')\n  )\n}\n\nfunction markStatic$1 (node) {\n  node.static = isStatic(node);\n  if (node.type === 1) {\n    // do not make component slot content static. this avoids\n    // 1. components not able to mutate slot nodes\n    // 2. static slot content fails for hot-reloading\n    if (\n      !isPlatformReservedTag(node.tag) &&\n      node.tag !== 'slot' &&\n      node.attrsMap['inline-template'] == null\n    ) {\n      return\n    }\n    for (var i = 0, l = node.children.length; i < l; i++) {\n      var child = node.children[i];\n      markStatic$1(child);\n      if (!child.static) {\n        node.static = false;\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        var block = node.ifConditions[i$1].block;\n        markStatic$1(block);\n        if (!block.static) {\n          node.static = false;\n        }\n      }\n    }\n  }\n}\n\nfunction markStaticRoots (node, isInFor) {\n  if (node.type === 1) {\n    if (node.static || node.once) {\n      node.staticInFor = isInFor;\n    }\n    // For a node to qualify as a static root, it should have children that\n    // are not just static text. Otherwise the cost of hoisting out will\n    // outweigh the benefits and it's better off to just always render it fresh.\n    if (node.static && node.children.length && !(\n      node.children.length === 1 &&\n      node.children[0].type === 3\n    )) {\n      node.staticRoot = true;\n      return\n    } else {\n      node.staticRoot = false;\n    }\n    if (node.children) {\n      for (var i = 0, l = node.children.length; i < l; i++) {\n        markStaticRoots(node.children[i], isInFor || !!node.for);\n      }\n    }\n    if (node.ifConditions) {\n      for (var i$1 = 1, l$1 = node.ifConditions.length; i$1 < l$1; i$1++) {\n        markStaticRoots(node.ifConditions[i$1].block, isInFor);\n      }\n    }\n  }\n}\n\nfunction isStatic (node) {\n  if (node.type === 2) { // expression\n    return false\n  }\n  if (node.type === 3) { // text\n    return true\n  }\n  return !!(node.pre || (\n    !node.hasBindings && // no dynamic bindings\n    !node.if && !node.for && // not v-if or v-for or v-else\n    !isBuiltInTag(node.tag) && // not a built-in\n    isPlatformReservedTag(node.tag) && // not a component\n    !isDirectChildOfTemplateFor(node) &&\n    Object.keys(node).every(isStaticKey)\n  ))\n}\n\nfunction isDirectChildOfTemplateFor (node) {\n  while (node.parent) {\n    node = node.parent;\n    if (node.tag !== 'template') {\n      return false\n    }\n    if (node.for) {\n      return true\n    }\n  }\n  return false\n}\n\n/*  */\n\nvar fnExpRE = /^([\\w$_]+|\\([^)]*?\\))\\s*=>|^function(?:\\s+[\\w$]+)?\\s*\\(/;\nvar fnInvokeRE = /\\([^)]*?\\);*$/;\nvar simplePathRE = /^[A-Za-z_$][\\w$]*(?:\\.[A-Za-z_$][\\w$]*|\\['[^']*?']|\\[\"[^\"]*?\"]|\\[\\d+]|\\[[A-Za-z_$][\\w$]*])*$/;\n\n// KeyboardEvent.keyCode aliases\nvar keyCodes = {\n  esc: 27,\n  tab: 9,\n  enter: 13,\n  space: 32,\n  up: 38,\n  left: 37,\n  right: 39,\n  down: 40,\n  'delete': [8, 46]\n};\n\n// KeyboardEvent.key aliases\nvar keyNames = {\n  // #7880: IE11 and Edge use `Esc` for Escape key name.\n  esc: ['Esc', 'Escape'],\n  tab: 'Tab',\n  enter: 'Enter',\n  // #9112: IE11 uses `Spacebar` for Space key name.\n  space: [' ', 'Spacebar'],\n  // #7806: IE11 uses key names without `Arrow` prefix for arrow keys.\n  up: ['Up', 'ArrowUp'],\n  left: ['Left', 'ArrowLeft'],\n  right: ['Right', 'ArrowRight'],\n  down: ['Down', 'ArrowDown'],\n  // #9112: IE11 uses `Del` for Delete key name.\n  'delete': ['Backspace', 'Delete', 'Del']\n};\n\n// #4868: modifiers that prevent the execution of the listener\n// need to explicitly return null so that we can determine whether to remove\n// the listener for .once\nvar genGuard = function (condition) { return (\"if(\" + condition + \")return null;\"); };\n\nvar modifierCode = {\n  stop: '$event.stopPropagation();',\n  prevent: '$event.preventDefault();',\n  self: genGuard(\"$event.target !== $event.currentTarget\"),\n  ctrl: genGuard(\"!$event.ctrlKey\"),\n  shift: genGuard(\"!$event.shiftKey\"),\n  alt: genGuard(\"!$event.altKey\"),\n  meta: genGuard(\"!$event.metaKey\"),\n  left: genGuard(\"'button' in $event && $event.button !== 0\"),\n  middle: genGuard(\"'button' in $event && $event.button !== 1\"),\n  right: genGuard(\"'button' in $event && $event.button !== 2\")\n};\n\nfunction genHandlers (\n  events,\n  isNative\n) {\n  var prefix = isNative ? 'nativeOn:' : 'on:';\n  var staticHandlers = \"\";\n  var dynamicHandlers = \"\";\n  for (var name in events) {\n    var handlerCode = genHandler(events[name]);\n    if (events[name] && events[name].dynamic) {\n      dynamicHandlers += name + \",\" + handlerCode + \",\";\n    } else {\n      staticHandlers += \"\\\"\" + name + \"\\\":\" + handlerCode + \",\";\n    }\n  }\n  staticHandlers = \"{\" + (staticHandlers.slice(0, -1)) + \"}\";\n  if (dynamicHandlers) {\n    return prefix + \"_d(\" + staticHandlers + \",[\" + (dynamicHandlers.slice(0, -1)) + \"])\"\n  } else {\n    return prefix + staticHandlers\n  }\n}\n\nfunction genHandler (handler) {\n  if (!handler) {\n    return 'function(){}'\n  }\n\n  if (Array.isArray(handler)) {\n    return (\"[\" + (handler.map(function (handler) { return genHandler(handler); }).join(',')) + \"]\")\n  }\n\n  var isMethodPath = simplePathRE.test(handler.value);\n  var isFunctionExpression = fnExpRE.test(handler.value);\n  var isFunctionInvocation = simplePathRE.test(handler.value.replace(fnInvokeRE, ''));\n\n  if (!handler.modifiers) {\n    if (isMethodPath || isFunctionExpression) {\n      return handler.value\n    }\n    return (\"function($event){\" + (isFunctionInvocation ? (\"return \" + (handler.value)) : handler.value) + \"}\") // inline statement\n  } else {\n    var code = '';\n    var genModifierCode = '';\n    var keys = [];\n    for (var key in handler.modifiers) {\n      if (modifierCode[key]) {\n        genModifierCode += modifierCode[key];\n        // left/right\n        if (keyCodes[key]) {\n          keys.push(key);\n        }\n      } else if (key === 'exact') {\n        var modifiers = (handler.modifiers);\n        genModifierCode += genGuard(\n          ['ctrl', 'shift', 'alt', 'meta']\n            .filter(function (keyModifier) { return !modifiers[keyModifier]; })\n            .map(function (keyModifier) { return (\"$event.\" + keyModifier + \"Key\"); })\n            .join('||')\n        );\n      } else {\n        keys.push(key);\n      }\n    }\n    if (keys.length) {\n      code += genKeyFilter(keys);\n    }\n    // Make sure modifiers like prevent and stop get executed after key filtering\n    if (genModifierCode) {\n      code += genModifierCode;\n    }\n    var handlerCode = isMethodPath\n      ? (\"return \" + (handler.value) + \"($event)\")\n      : isFunctionExpression\n        ? (\"return (\" + (handler.value) + \")($event)\")\n        : isFunctionInvocation\n          ? (\"return \" + (handler.value))\n          : handler.value;\n    return (\"function($event){\" + code + handlerCode + \"}\")\n  }\n}\n\nfunction genKeyFilter (keys) {\n  return (\n    // make sure the key filters only apply to KeyboardEvents\n    // #9441: can't use 'keyCode' in $event because Chrome autofill fires fake\n    // key events that do not have keyCode property...\n    \"if(!$event.type.indexOf('key')&&\" +\n    (keys.map(genFilterCode).join('&&')) + \")return null;\"\n  )\n}\n\nfunction genFilterCode (key) {\n  var keyVal = parseInt(key, 10);\n  if (keyVal) {\n    return (\"$event.keyCode!==\" + keyVal)\n  }\n  var keyCode = keyCodes[key];\n  var keyName = keyNames[key];\n  return (\n    \"_k($event.keyCode,\" +\n    (JSON.stringify(key)) + \",\" +\n    (JSON.stringify(keyCode)) + \",\" +\n    \"$event.key,\" +\n    \"\" + (JSON.stringify(keyName)) +\n    \")\"\n  )\n}\n\n/*  */\n\nfunction on (el, dir) {\n  if (process.env.NODE_ENV !== 'production' && dir.modifiers) {\n    warn(\"v-on without argument does not support modifiers.\");\n  }\n  el.wrapListeners = function (code) { return (\"_g(\" + code + \",\" + (dir.value) + \")\"); };\n}\n\n/*  */\n\nfunction bind$1 (el, dir) {\n  el.wrapData = function (code) {\n    return (\"_b(\" + code + \",'\" + (el.tag) + \"',\" + (dir.value) + \",\" + (dir.modifiers && dir.modifiers.prop ? 'true' : 'false') + (dir.modifiers && dir.modifiers.sync ? ',true' : '') + \")\")\n  };\n}\n\n/*  */\n\nvar baseDirectives = {\n  on: on,\n  bind: bind$1,\n  cloak: noop\n};\n\n/*  */\n\n\n\n\n\nvar CodegenState = function CodegenState (options) {\n  this.options = options;\n  this.warn = options.warn || baseWarn;\n  this.transforms = pluckModuleFunction(options.modules, 'transformCode');\n  this.dataGenFns = pluckModuleFunction(options.modules, 'genData');\n  this.directives = extend(extend({}, baseDirectives), options.directives);\n  var isReservedTag = options.isReservedTag || no;\n  this.maybeComponent = function (el) { return !!el.component || !isReservedTag(el.tag); };\n  this.onceId = 0;\n  this.staticRenderFns = [];\n  this.pre = false;\n};\n\n\n\nfunction generate (\n  ast,\n  options\n) {\n  var state = new CodegenState(options);\n  var code = ast ? genElement(ast, state) : '_c(\"div\")';\n  return {\n    render: (\"with(this){return \" + code + \"}\"),\n    staticRenderFns: state.staticRenderFns\n  }\n}\n\nfunction genElement (el, state) {\n  if (el.parent) {\n    el.pre = el.pre || el.parent.pre;\n  }\n\n  if (el.staticRoot && !el.staticProcessed) {\n    return genStatic(el, state)\n  } else if (el.once && !el.onceProcessed) {\n    return genOnce(el, state)\n  } else if (el.for && !el.forProcessed) {\n    return genFor(el, state)\n  } else if (el.if && !el.ifProcessed) {\n    return genIf(el, state)\n  } else if (el.tag === 'template' && !el.slotTarget && !state.pre) {\n    return genChildren(el, state) || 'void 0'\n  } else if (el.tag === 'slot') {\n    return genSlot(el, state)\n  } else {\n    // component or element\n    var code;\n    if (el.component) {\n      code = genComponent(el.component, el, state);\n    } else {\n      var data;\n      if (!el.plain || (el.pre && state.maybeComponent(el))) {\n        data = genData$2(el, state);\n      }\n\n      var children = el.inlineTemplate ? null : genChildren(el, state, true);\n      code = \"_c('\" + (el.tag) + \"'\" + (data ? (\",\" + data) : '') + (children ? (\",\" + children) : '') + \")\";\n    }\n    // module transforms\n    for (var i = 0; i < state.transforms.length; i++) {\n      code = state.transforms[i](el, code);\n    }\n    return code\n  }\n}\n\n// hoist static sub-trees out\nfunction genStatic (el, state) {\n  el.staticProcessed = true;\n  // Some elements (templates) need to behave differently inside of a v-pre\n  // node.  All pre nodes are static roots, so we can use this as a location to\n  // wrap a state change and reset it upon exiting the pre node.\n  var originalPreState = state.pre;\n  if (el.pre) {\n    state.pre = el.pre;\n  }\n  state.staticRenderFns.push((\"with(this){return \" + (genElement(el, state)) + \"}\"));\n  state.pre = originalPreState;\n  return (\"_m(\" + (state.staticRenderFns.length - 1) + (el.staticInFor ? ',true' : '') + \")\")\n}\n\n// v-once\nfunction genOnce (el, state) {\n  el.onceProcessed = true;\n  if (el.if && !el.ifProcessed) {\n    return genIf(el, state)\n  } else if (el.staticInFor) {\n    var key = '';\n    var parent = el.parent;\n    while (parent) {\n      if (parent.for) {\n        key = parent.key;\n        break\n      }\n      parent = parent.parent;\n    }\n    if (!key) {\n      process.env.NODE_ENV !== 'production' && state.warn(\n        \"v-once can only be used inside v-for that is keyed. \",\n        el.rawAttrsMap['v-once']\n      );\n      return genElement(el, state)\n    }\n    return (\"_o(\" + (genElement(el, state)) + \",\" + (state.onceId++) + \",\" + key + \")\")\n  } else {\n    return genStatic(el, state)\n  }\n}\n\nfunction genIf (\n  el,\n  state,\n  altGen,\n  altEmpty\n) {\n  el.ifProcessed = true; // avoid recursion\n  return genIfConditions(el.ifConditions.slice(), state, altGen, altEmpty)\n}\n\nfunction genIfConditions (\n  conditions,\n  state,\n  altGen,\n  altEmpty\n) {\n  if (!conditions.length) {\n    return altEmpty || '_e()'\n  }\n\n  var condition = conditions.shift();\n  if (condition.exp) {\n    return (\"(\" + (condition.exp) + \")?\" + (genTernaryExp(condition.block)) + \":\" + (genIfConditions(conditions, state, altGen, altEmpty)))\n  } else {\n    return (\"\" + (genTernaryExp(condition.block)))\n  }\n\n  // v-if with v-once should generate code like (a)?_m(0):_m(1)\n  function genTernaryExp (el) {\n    return altGen\n      ? altGen(el, state)\n      : el.once\n        ? genOnce(el, state)\n        : genElement(el, state)\n  }\n}\n\nfunction genFor (\n  el,\n  state,\n  altGen,\n  altHelper\n) {\n  var exp = el.for;\n  var alias = el.alias;\n  var iterator1 = el.iterator1 ? (\",\" + (el.iterator1)) : '';\n  var iterator2 = el.iterator2 ? (\",\" + (el.iterator2)) : '';\n\n  if (process.env.NODE_ENV !== 'production' &&\n    state.maybeComponent(el) &&\n    el.tag !== 'slot' &&\n    el.tag !== 'template' &&\n    !el.key\n  ) {\n    state.warn(\n      \"<\" + (el.tag) + \" v-for=\\\"\" + alias + \" in \" + exp + \"\\\">: component lists rendered with \" +\n      \"v-for should have explicit keys. \" +\n      \"See https://vuejs.org/guide/list.html#key for more info.\",\n      el.rawAttrsMap['v-for'],\n      true /* tip */\n    );\n  }\n\n  el.forProcessed = true; // avoid recursion\n  return (altHelper || '_l') + \"((\" + exp + \"),\" +\n    \"function(\" + alias + iterator1 + iterator2 + \"){\" +\n      \"return \" + ((altGen || genElement)(el, state)) +\n    '})'\n}\n\nfunction genData$2 (el, state) {\n  var data = '{';\n\n  // directives first.\n  // directives may mutate the el's other properties before they are generated.\n  var dirs = genDirectives(el, state);\n  if (dirs) { data += dirs + ','; }\n\n  // key\n  if (el.key) {\n    data += \"key:\" + (el.key) + \",\";\n  }\n  // ref\n  if (el.ref) {\n    data += \"ref:\" + (el.ref) + \",\";\n  }\n  if (el.refInFor) {\n    data += \"refInFor:true,\";\n  }\n  // pre\n  if (el.pre) {\n    data += \"pre:true,\";\n  }\n  // record original tag name for components using \"is\" attribute\n  if (el.component) {\n    data += \"tag:\\\"\" + (el.tag) + \"\\\",\";\n  }\n  // module data generation functions\n  for (var i = 0; i < state.dataGenFns.length; i++) {\n    data += state.dataGenFns[i](el);\n  }\n  // attributes\n  if (el.attrs) {\n    data += \"attrs:\" + (genProps(el.attrs)) + \",\";\n  }\n  // DOM props\n  if (el.props) {\n    data += \"domProps:\" + (genProps(el.props)) + \",\";\n  }\n  // event handlers\n  if (el.events) {\n    data += (genHandlers(el.events, false)) + \",\";\n  }\n  if (el.nativeEvents) {\n    data += (genHandlers(el.nativeEvents, true)) + \",\";\n  }\n  // slot target\n  // only for non-scoped slots\n  if (el.slotTarget && !el.slotScope) {\n    data += \"slot:\" + (el.slotTarget) + \",\";\n  }\n  // scoped slots\n  if (el.scopedSlots) {\n    data += (genScopedSlots(el, el.scopedSlots, state)) + \",\";\n  }\n  // component v-model\n  if (el.model) {\n    data += \"model:{value:\" + (el.model.value) + \",callback:\" + (el.model.callback) + \",expression:\" + (el.model.expression) + \"},\";\n  }\n  // inline-template\n  if (el.inlineTemplate) {\n    var inlineTemplate = genInlineTemplate(el, state);\n    if (inlineTemplate) {\n      data += inlineTemplate + \",\";\n    }\n  }\n  data = data.replace(/,$/, '') + '}';\n  // v-bind dynamic argument wrap\n  // v-bind with dynamic arguments must be applied using the same v-bind object\n  // merge helper so that class/style/mustUseProp attrs are handled correctly.\n  if (el.dynamicAttrs) {\n    data = \"_b(\" + data + \",\\\"\" + (el.tag) + \"\\\",\" + (genProps(el.dynamicAttrs)) + \")\";\n  }\n  // v-bind data wrap\n  if (el.wrapData) {\n    data = el.wrapData(data);\n  }\n  // v-on data wrap\n  if (el.wrapListeners) {\n    data = el.wrapListeners(data);\n  }\n  return data\n}\n\nfunction genDirectives (el, state) {\n  var dirs = el.directives;\n  if (!dirs) { return }\n  var res = 'directives:[';\n  var hasRuntime = false;\n  var i, l, dir, needRuntime;\n  for (i = 0, l = dirs.length; i < l; i++) {\n    dir = dirs[i];\n    needRuntime = true;\n    var gen = state.directives[dir.name];\n    if (gen) {\n      // compile-time directive that manipulates AST.\n      // returns true if it also needs a runtime counterpart.\n      needRuntime = !!gen(el, dir, state.warn);\n    }\n    if (needRuntime) {\n      hasRuntime = true;\n      res += \"{name:\\\"\" + (dir.name) + \"\\\",rawName:\\\"\" + (dir.rawName) + \"\\\"\" + (dir.value ? (\",value:(\" + (dir.value) + \"),expression:\" + (JSON.stringify(dir.value))) : '') + (dir.arg ? (\",arg:\" + (dir.isDynamicArg ? dir.arg : (\"\\\"\" + (dir.arg) + \"\\\"\"))) : '') + (dir.modifiers ? (\",modifiers:\" + (JSON.stringify(dir.modifiers))) : '') + \"},\";\n    }\n  }\n  if (hasRuntime) {\n    return res.slice(0, -1) + ']'\n  }\n}\n\nfunction genInlineTemplate (el, state) {\n  var ast = el.children[0];\n  if (process.env.NODE_ENV !== 'production' && (\n    el.children.length !== 1 || ast.type !== 1\n  )) {\n    state.warn(\n      'Inline-template components must have exactly one child element.',\n      { start: el.start }\n    );\n  }\n  if (ast && ast.type === 1) {\n    var inlineRenderFns = generate(ast, state.options);\n    return (\"inlineTemplate:{render:function(){\" + (inlineRenderFns.render) + \"},staticRenderFns:[\" + (inlineRenderFns.staticRenderFns.map(function (code) { return (\"function(){\" + code + \"}\"); }).join(',')) + \"]}\")\n  }\n}\n\nfunction genScopedSlots (\n  el,\n  slots,\n  state\n) {\n  // by default scoped slots are considered \"stable\", this allows child\n  // components with only scoped slots to skip forced updates from parent.\n  // but in some cases we have to bail-out of this optimization\n  // for example if the slot contains dynamic names, has v-if or v-for on them...\n  var needsForceUpdate = el.for || Object.keys(slots).some(function (key) {\n    var slot = slots[key];\n    return (\n      slot.slotTargetDynamic ||\n      slot.if ||\n      slot.for ||\n      containsSlotChild(slot) // is passing down slot from parent which may be dynamic\n    )\n  });\n\n  // #9534: if a component with scoped slots is inside a conditional branch,\n  // it's possible for the same component to be reused but with different\n  // compiled slot content. To avoid that, we generate a unique key based on\n  // the generated code of all the slot contents.\n  var needsKey = !!el.if;\n\n  // OR when it is inside another scoped slot or v-for (the reactivity may be\n  // disconnected due to the intermediate scope variable)\n  // #9438, #9506\n  // TODO: this can be further optimized by properly analyzing in-scope bindings\n  // and skip force updating ones that do not actually use scope variables.\n  if (!needsForceUpdate) {\n    var parent = el.parent;\n    while (parent) {\n      if (\n        (parent.slotScope && parent.slotScope !== emptySlotScopeToken) ||\n        parent.for\n      ) {\n        needsForceUpdate = true;\n        break\n      }\n      if (parent.if) {\n        needsKey = true;\n      }\n      parent = parent.parent;\n    }\n  }\n\n  var generatedSlots = Object.keys(slots)\n    .map(function (key) { return genScopedSlot(slots[key], state); })\n    .join(',');\n\n  return (\"scopedSlots:_u([\" + generatedSlots + \"]\" + (needsForceUpdate ? \",null,true\" : \"\") + (!needsForceUpdate && needsKey ? (\",null,false,\" + (hash(generatedSlots))) : \"\") + \")\")\n}\n\nfunction hash(str) {\n  var hash = 5381;\n  var i = str.length;\n  while(i) {\n    hash = (hash * 33) ^ str.charCodeAt(--i);\n  }\n  return hash >>> 0\n}\n\nfunction containsSlotChild (el) {\n  if (el.type === 1) {\n    if (el.tag === 'slot') {\n      return true\n    }\n    return el.children.some(containsSlotChild)\n  }\n  return false\n}\n\nfunction genScopedSlot (\n  el,\n  state\n) {\n  var isLegacySyntax = el.attrsMap['slot-scope'];\n  if (el.if && !el.ifProcessed && !isLegacySyntax) {\n    return genIf(el, state, genScopedSlot, \"null\")\n  }\n  if (el.for && !el.forProcessed) {\n    return genFor(el, state, genScopedSlot)\n  }\n  var slotScope = el.slotScope === emptySlotScopeToken\n    ? \"\"\n    : String(el.slotScope);\n  var fn = \"function(\" + slotScope + \"){\" +\n    \"return \" + (el.tag === 'template'\n      ? el.if && isLegacySyntax\n        ? (\"(\" + (el.if) + \")?\" + (genChildren(el, state) || 'undefined') + \":undefined\")\n        : genChildren(el, state) || 'undefined'\n      : genElement(el, state)) + \"}\";\n  // reverse proxy v-slot without scope on this.$slots\n  var reverseProxy = slotScope ? \"\" : \",proxy:true\";\n  return (\"{key:\" + (el.slotTarget || \"\\\"default\\\"\") + \",fn:\" + fn + reverseProxy + \"}\")\n}\n\nfunction genChildren (\n  el,\n  state,\n  checkSkip,\n  altGenElement,\n  altGenNode\n) {\n  var children = el.children;\n  if (children.length) {\n    var el$1 = children[0];\n    // optimize single v-for\n    if (children.length === 1 &&\n      el$1.for &&\n      el$1.tag !== 'template' &&\n      el$1.tag !== 'slot'\n    ) {\n      var normalizationType = checkSkip\n        ? state.maybeComponent(el$1) ? \",1\" : \",0\"\n        : \"\";\n      return (\"\" + ((altGenElement || genElement)(el$1, state)) + normalizationType)\n    }\n    var normalizationType$1 = checkSkip\n      ? getNormalizationType(children, state.maybeComponent)\n      : 0;\n    var gen = altGenNode || genNode;\n    return (\"[\" + (children.map(function (c) { return gen(c, state); }).join(',')) + \"]\" + (normalizationType$1 ? (\",\" + normalizationType$1) : ''))\n  }\n}\n\n// determine the normalization needed for the children array.\n// 0: no normalization needed\n// 1: simple normalization needed (possible 1-level deep nested array)\n// 2: full normalization needed\nfunction getNormalizationType (\n  children,\n  maybeComponent\n) {\n  var res = 0;\n  for (var i = 0; i < children.length; i++) {\n    var el = children[i];\n    if (el.type !== 1) {\n      continue\n    }\n    if (needsNormalization(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return needsNormalization(c.block); }))) {\n      res = 2;\n      break\n    }\n    if (maybeComponent(el) ||\n        (el.ifConditions && el.ifConditions.some(function (c) { return maybeComponent(c.block); }))) {\n      res = 1;\n    }\n  }\n  return res\n}\n\nfunction needsNormalization (el) {\n  return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'\n}\n\nfunction genNode (node, state) {\n  if (node.type === 1) {\n    return genElement(node, state)\n  } else if (node.type === 3 && node.isComment) {\n    return genComment(node)\n  } else {\n    return genText(node)\n  }\n}\n\nfunction genText (text) {\n  return (\"_v(\" + (text.type === 2\n    ? text.expression // no need for () because already wrapped in _s()\n    : transformSpecialNewlines(JSON.stringify(text.text))) + \")\")\n}\n\nfunction genComment (comment) {\n  return (\"_e(\" + (JSON.stringify(comment.text)) + \")\")\n}\n\nfunction genSlot (el, state) {\n  var slotName = el.slotName || '\"default\"';\n  var children = genChildren(el, state);\n  var res = \"_t(\" + slotName + (children ? (\",\" + children) : '');\n  var attrs = el.attrs || el.dynamicAttrs\n    ? genProps((el.attrs || []).concat(el.dynamicAttrs || []).map(function (attr) { return ({\n        // slot props are camelized\n        name: camelize(attr.name),\n        value: attr.value,\n        dynamic: attr.dynamic\n      }); }))\n    : null;\n  var bind$$1 = el.attrsMap['v-bind'];\n  if ((attrs || bind$$1) && !children) {\n    res += \",null\";\n  }\n  if (attrs) {\n    res += \",\" + attrs;\n  }\n  if (bind$$1) {\n    res += (attrs ? '' : ',null') + \",\" + bind$$1;\n  }\n  return res + ')'\n}\n\n// componentName is el.component, take it as argument to shun flow's pessimistic refinement\nfunction genComponent (\n  componentName,\n  el,\n  state\n) {\n  var children = el.inlineTemplate ? null : genChildren(el, state, true);\n  return (\"_c(\" + componentName + \",\" + (genData$2(el, state)) + (children ? (\",\" + children) : '') + \")\")\n}\n\nfunction genProps (props) {\n  var staticProps = \"\";\n  var dynamicProps = \"\";\n  for (var i = 0; i < props.length; i++) {\n    var prop = props[i];\n    var value = transformSpecialNewlines(prop.value);\n    if (prop.dynamic) {\n      dynamicProps += (prop.name) + \",\" + value + \",\";\n    } else {\n      staticProps += \"\\\"\" + (prop.name) + \"\\\":\" + value + \",\";\n    }\n  }\n  staticProps = \"{\" + (staticProps.slice(0, -1)) + \"}\";\n  if (dynamicProps) {\n    return (\"_d(\" + staticProps + \",[\" + (dynamicProps.slice(0, -1)) + \"])\")\n  } else {\n    return staticProps\n  }\n}\n\n// #3895, #4268\nfunction transformSpecialNewlines (text) {\n  return text\n    .replace(/\\u2028/g, '\\\\u2028')\n    .replace(/\\u2029/g, '\\\\u2029')\n}\n\n/*  */\n\n\n\n// these keywords should not appear inside expressions, but operators like\n// typeof, instanceof and in are allowed\nvar prohibitedKeywordRE = new RegExp('\\\\b' + (\n  'do,if,for,let,new,try,var,case,else,with,await,break,catch,class,const,' +\n  'super,throw,while,yield,delete,export,import,return,switch,default,' +\n  'extends,finally,continue,debugger,function,arguments'\n).split(',').join('\\\\b|\\\\b') + '\\\\b');\n\n// these unary operators should not be used as property/method names\nvar unaryOperatorsRE = new RegExp('\\\\b' + (\n  'delete,typeof,void'\n).split(',').join('\\\\s*\\\\([^\\\\)]*\\\\)|\\\\b') + '\\\\s*\\\\([^\\\\)]*\\\\)');\n\n// strip strings in expressions\nvar stripStringRE = /'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\"\\\\]|\\\\.)*\"|`(?:[^`\\\\]|\\\\.)*\\$\\{|\\}(?:[^`\\\\]|\\\\.)*`|`(?:[^`\\\\]|\\\\.)*`/g;\n\n// detect problematic expressions in a template\nfunction detectErrors (ast, warn) {\n  if (ast) {\n    checkNode(ast, warn);\n  }\n}\n\nfunction checkNode (node, warn) {\n  if (node.type === 1) {\n    for (var name in node.attrsMap) {\n      if (dirRE.test(name)) {\n        var value = node.attrsMap[name];\n        if (value) {\n          var range = node.rawAttrsMap[name];\n          if (name === 'v-for') {\n            checkFor(node, (\"v-for=\\\"\" + value + \"\\\"\"), warn, range);\n          } else if (name === 'v-slot' || name[0] === '#') {\n            checkFunctionParameterExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), warn, range);\n          } else if (onRE.test(name)) {\n            checkEvent(value, (name + \"=\\\"\" + value + \"\\\"\"), warn, range);\n          } else {\n            checkExpression(value, (name + \"=\\\"\" + value + \"\\\"\"), warn, range);\n          }\n        }\n      }\n    }\n    if (node.children) {\n      for (var i = 0; i < node.children.length; i++) {\n        checkNode(node.children[i], warn);\n      }\n    }\n  } else if (node.type === 2) {\n    checkExpression(node.expression, node.text, warn, node);\n  }\n}\n\nfunction checkEvent (exp, text, warn, range) {\n  var stripped = exp.replace(stripStringRE, '');\n  var keywordMatch = stripped.match(unaryOperatorsRE);\n  if (keywordMatch && stripped.charAt(keywordMatch.index - 1) !== '$') {\n    warn(\n      \"avoid using JavaScript unary operator as property name: \" +\n      \"\\\"\" + (keywordMatch[0]) + \"\\\" in expression \" + (text.trim()),\n      range\n    );\n  }\n  checkExpression(exp, text, warn, range);\n}\n\nfunction checkFor (node, text, warn, range) {\n  checkExpression(node.for || '', text, warn, range);\n  checkIdentifier(node.alias, 'v-for alias', text, warn, range);\n  checkIdentifier(node.iterator1, 'v-for iterator', text, warn, range);\n  checkIdentifier(node.iterator2, 'v-for iterator', text, warn, range);\n}\n\nfunction checkIdentifier (\n  ident,\n  type,\n  text,\n  warn,\n  range\n) {\n  if (typeof ident === 'string') {\n    try {\n      new Function((\"var \" + ident + \"=_\"));\n    } catch (e) {\n      warn((\"invalid \" + type + \" \\\"\" + ident + \"\\\" in expression: \" + (text.trim())), range);\n    }\n  }\n}\n\nfunction checkExpression (exp, text, warn, range) {\n  try {\n    new Function((\"return \" + exp));\n  } catch (e) {\n    var keywordMatch = exp.replace(stripStringRE, '').match(prohibitedKeywordRE);\n    if (keywordMatch) {\n      warn(\n        \"avoid using JavaScript keyword as property name: \" +\n        \"\\\"\" + (keywordMatch[0]) + \"\\\"\\n  Raw expression: \" + (text.trim()),\n        range\n      );\n    } else {\n      warn(\n        \"invalid expression: \" + (e.message) + \" in\\n\\n\" +\n        \"    \" + exp + \"\\n\\n\" +\n        \"  Raw expression: \" + (text.trim()) + \"\\n\",\n        range\n      );\n    }\n  }\n}\n\nfunction checkFunctionParameterExpression (exp, text, warn, range) {\n  try {\n    new Function(exp, '');\n  } catch (e) {\n    warn(\n      \"invalid function parameter expression: \" + (e.message) + \" in\\n\\n\" +\n      \"    \" + exp + \"\\n\\n\" +\n      \"  Raw expression: \" + (text.trim()) + \"\\n\",\n      range\n    );\n  }\n}\n\n/*  */\n\nvar range = 2;\n\nfunction generateCodeFrame (\n  source,\n  start,\n  end\n) {\n  if ( start === void 0 ) start = 0;\n  if ( end === void 0 ) end = source.length;\n\n  var lines = source.split(/\\r?\\n/);\n  var count = 0;\n  var res = [];\n  for (var i = 0; i < lines.length; i++) {\n    count += lines[i].length + 1;\n    if (count >= start) {\n      for (var j = i - range; j <= i + range || end > count; j++) {\n        if (j < 0 || j >= lines.length) { continue }\n        res.push((\"\" + (j + 1) + (repeat$1(\" \", 3 - String(j + 1).length)) + \"|  \" + (lines[j])));\n        var lineLength = lines[j].length;\n        if (j === i) {\n          // push underline\n          var pad = start - (count - lineLength) + 1;\n          var length = end > count ? lineLength - pad : end - start;\n          res.push(\"   |  \" + repeat$1(\" \", pad) + repeat$1(\"^\", length));\n        } else if (j > i) {\n          if (end > count) {\n            var length$1 = Math.min(end - count, lineLength);\n            res.push(\"   |  \" + repeat$1(\"^\", length$1));\n          }\n          count += lineLength + 1;\n        }\n      }\n      break\n    }\n  }\n  return res.join('\\n')\n}\n\nfunction repeat$1 (str, n) {\n  var result = '';\n  if (n > 0) {\n    while (true) { // eslint-disable-line\n      if (n & 1) { result += str; }\n      n >>>= 1;\n      if (n <= 0) { break }\n      str += str;\n    }\n  }\n  return result\n}\n\n/*  */\n\n\n\nfunction createFunction (code, errors) {\n  try {\n    return new Function(code)\n  } catch (err) {\n    errors.push({ err: err, code: code });\n    return noop\n  }\n}\n\nfunction createCompileToFunctionFn (compile) {\n  var cache = Object.create(null);\n\n  return function compileToFunctions (\n    template,\n    options,\n    vm\n  ) {\n    options = extend({}, options);\n    var warn$$1 = options.warn || warn;\n    delete options.warn;\n\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      // detect possible CSP restriction\n      try {\n        new Function('return 1');\n      } catch (e) {\n        if (e.toString().match(/unsafe-eval|CSP/)) {\n          warn$$1(\n            'It seems you are using the standalone build of Vue.js in an ' +\n            'environment with Content Security Policy that prohibits unsafe-eval. ' +\n            'The template compiler cannot work in this environment. Consider ' +\n            'relaxing the policy to allow unsafe-eval or pre-compiling your ' +\n            'templates into render functions.'\n          );\n        }\n      }\n    }\n\n    // check cache\n    var key = options.delimiters\n      ? String(options.delimiters) + template\n      : template;\n    if (cache[key]) {\n      return cache[key]\n    }\n\n    // compile\n    var compiled = compile(template, options);\n\n    // check compilation errors/tips\n    if (process.env.NODE_ENV !== 'production') {\n      if (compiled.errors && compiled.errors.length) {\n        if (options.outputSourceRange) {\n          compiled.errors.forEach(function (e) {\n            warn$$1(\n              \"Error compiling template:\\n\\n\" + (e.msg) + \"\\n\\n\" +\n              generateCodeFrame(template, e.start, e.end),\n              vm\n            );\n          });\n        } else {\n          warn$$1(\n            \"Error compiling template:\\n\\n\" + template + \"\\n\\n\" +\n            compiled.errors.map(function (e) { return (\"- \" + e); }).join('\\n') + '\\n',\n            vm\n          );\n        }\n      }\n      if (compiled.tips && compiled.tips.length) {\n        if (options.outputSourceRange) {\n          compiled.tips.forEach(function (e) { return tip(e.msg, vm); });\n        } else {\n          compiled.tips.forEach(function (msg) { return tip(msg, vm); });\n        }\n      }\n    }\n\n    // turn code into functions\n    var res = {};\n    var fnGenErrors = [];\n    res.render = createFunction(compiled.render, fnGenErrors);\n    res.staticRenderFns = compiled.staticRenderFns.map(function (code) {\n      return createFunction(code, fnGenErrors)\n    });\n\n    // check function generation errors.\n    // this should only happen if there is a bug in the compiler itself.\n    // mostly for codegen development use\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      if ((!compiled.errors || !compiled.errors.length) && fnGenErrors.length) {\n        warn$$1(\n          \"Failed to generate render function:\\n\\n\" +\n          fnGenErrors.map(function (ref) {\n            var err = ref.err;\n            var code = ref.code;\n\n            return ((err.toString()) + \" in\\n\\n\" + code + \"\\n\");\n        }).join('\\n'),\n          vm\n        );\n      }\n    }\n\n    return (cache[key] = res)\n  }\n}\n\n/*  */\n\nfunction createCompilerCreator (baseCompile) {\n  return function createCompiler (baseOptions) {\n    function compile (\n      template,\n      options\n    ) {\n      var finalOptions = Object.create(baseOptions);\n      var errors = [];\n      var tips = [];\n\n      var warn = function (msg, range, tip) {\n        (tip ? tips : errors).push(msg);\n      };\n\n      if (options) {\n        if (process.env.NODE_ENV !== 'production' && options.outputSourceRange) {\n          // $flow-disable-line\n          var leadingSpaceLength = template.match(/^\\s*/)[0].length;\n\n          warn = function (msg, range, tip) {\n            var data = { msg: msg };\n            if (range) {\n              if (range.start != null) {\n                data.start = range.start + leadingSpaceLength;\n              }\n              if (range.end != null) {\n                data.end = range.end + leadingSpaceLength;\n              }\n            }\n            (tip ? tips : errors).push(data);\n          };\n        }\n        // merge custom modules\n        if (options.modules) {\n          finalOptions.modules =\n            (baseOptions.modules || []).concat(options.modules);\n        }\n        // merge custom directives\n        if (options.directives) {\n          finalOptions.directives = extend(\n            Object.create(baseOptions.directives || null),\n            options.directives\n          );\n        }\n        // copy other options\n        for (var key in options) {\n          if (key !== 'modules' && key !== 'directives') {\n            finalOptions[key] = options[key];\n          }\n        }\n      }\n\n      finalOptions.warn = warn;\n\n      var compiled = baseCompile(template.trim(), finalOptions);\n      if (process.env.NODE_ENV !== 'production') {\n        detectErrors(compiled.ast, warn);\n      }\n      compiled.errors = errors;\n      compiled.tips = tips;\n      return compiled\n    }\n\n    return {\n      compile: compile,\n      compileToFunctions: createCompileToFunctionFn(compile)\n    }\n  }\n}\n\n/*  */\n\n// `createCompilerCreator` allows creating compilers that use alternative\n// parser/optimizer/codegen, e.g the SSR optimizing compiler.\n// Here we just export a default compiler using the default parts.\nvar createCompiler = createCompilerCreator(function baseCompile (\n  template,\n  options\n) {\n  var ast = parse(template.trim(), options);\n  if (options.optimize !== false) {\n    optimize(ast, options);\n  }\n  var code = generate(ast, options);\n  return {\n    ast: ast,\n    render: code.render,\n    staticRenderFns: code.staticRenderFns\n  }\n});\n\n/*  */\n\nvar ref$1 = createCompiler(baseOptions);\nvar compile = ref$1.compile;\nvar compileToFunctions = ref$1.compileToFunctions;\n\n/*  */\n\n// check whether current browser encodes a char inside attribute values\nvar div;\nfunction getShouldDecode (href) {\n  div = div || document.createElement('div');\n  div.innerHTML = href ? \"<a href=\\\"\\n\\\"/>\" : \"<div a=\\\"\\n\\\"/>\";\n  return div.innerHTML.indexOf('&#10;') > 0\n}\n\n// #3663: IE encodes newlines inside attribute values while other browsers don't\nvar shouldDecodeNewlines = inBrowser ? getShouldDecode(false) : false;\n// #6828: chrome encodes content in a[href]\nvar shouldDecodeNewlinesForHref = inBrowser ? getShouldDecode(true) : false;\n\n/*  */\n\nvar idToTemplate = cached(function (id) {\n  var el = query(id);\n  return el && el.innerHTML\n});\n\nvar mount = Vue.prototype.$mount;\nVue.prototype.$mount = function (\n  el,\n  hydrating\n) {\n  el = el && query(el);\n\n  /* istanbul ignore if */\n  if (el === document.body || el === document.documentElement) {\n    process.env.NODE_ENV !== 'production' && warn(\n      \"Do not mount Vue to <html> or <body> - mount to normal elements instead.\"\n    );\n    return this\n  }\n\n  var options = this.$options;\n  // resolve template/el and convert to render function\n  if (!options.render) {\n    var template = options.template;\n    if (template) {\n      if (typeof template === 'string') {\n        if (template.charAt(0) === '#') {\n          template = idToTemplate(template);\n          /* istanbul ignore if */\n          if (process.env.NODE_ENV !== 'production' && !template) {\n            warn(\n              (\"Template element not found or is empty: \" + (options.template)),\n              this\n            );\n          }\n        }\n      } else if (template.nodeType) {\n        template = template.innerHTML;\n      } else {\n        if (process.env.NODE_ENV !== 'production') {\n          warn('invalid template option:' + template, this);\n        }\n        return this\n      }\n    } else if (el) {\n      template = getOuterHTML(el);\n    }\n    if (template) {\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n        mark('compile');\n      }\n\n      var ref = compileToFunctions(template, {\n        outputSourceRange: process.env.NODE_ENV !== 'production',\n        shouldDecodeNewlines: shouldDecodeNewlines,\n        shouldDecodeNewlinesForHref: shouldDecodeNewlinesForHref,\n        delimiters: options.delimiters,\n        comments: options.comments\n      }, this);\n      var render = ref.render;\n      var staticRenderFns = ref.staticRenderFns;\n      options.render = render;\n      options.staticRenderFns = staticRenderFns;\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production' && config.performance && mark) {\n        mark('compile end');\n        measure((\"vue \" + (this._name) + \" compile\"), 'compile', 'compile end');\n      }\n    }\n  }\n  return mount.call(this, el, hydrating)\n};\n\n/**\n * Get outerHTML of elements, taking care\n * of SVG elements in IE as well.\n */\nfunction getOuterHTML (el) {\n  if (el.outerHTML) {\n    return el.outerHTML\n  } else {\n    var container = document.createElement('div');\n    container.appendChild(el.cloneNode(true));\n    return container.innerHTML\n  }\n}\n\nVue.compile = compileToFunctions;\n\nexport default Vue;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","/*!\n  * Bootstrap collapse.js v5.1.1 (https://getbootstrap.com/)\n  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n  */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('./dom/data.js'), require('./dom/event-handler.js'), require('./dom/manipulator.js'), require('./dom/selector-engine.js'), require('./base-component.js')) :\n  typeof define === 'function' && define.amd ? define(['./dom/data', './dom/event-handler', './dom/manipulator', './dom/selector-engine', './base-component'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Collapse = factory(global.Data, global.EventHandler, global.Manipulator, global.SelectorEngine, global.Base));\n}(this, (function (Data, EventHandler, Manipulator, SelectorEngine, BaseComponent) { 'use strict';\n\n  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n  var Data__default = /*#__PURE__*/_interopDefaultLegacy(Data);\n  var EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler);\n  var Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator);\n  var SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine);\n  var BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent);\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): util/index.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n\n  const toType = obj => {\n    if (obj === null || obj === undefined) {\n      return `${obj}`;\n    }\n\n    return {}.toString.call(obj).match(/\\s([a-z]+)/i)[1].toLowerCase();\n  };\n\n  const getSelector = element => {\n    let selector = element.getAttribute('data-bs-target');\n\n    if (!selector || selector === '#') {\n      let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,\n      // so everything starting with `#` or `.`. If a \"real\" URL is used as the selector,\n      // `document.querySelector` will rightfully complain it is invalid.\n      // See https://github.com/twbs/bootstrap/issues/32273\n\n      if (!hrefAttr || !hrefAttr.includes('#') && !hrefAttr.startsWith('.')) {\n        return null;\n      } // Just in case some CMS puts out a full URL with the anchor appended\n\n\n      if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {\n        hrefAttr = `#${hrefAttr.split('#')[1]}`;\n      }\n\n      selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;\n    }\n\n    return selector;\n  };\n\n  const getSelectorFromElement = element => {\n    const selector = getSelector(element);\n\n    if (selector) {\n      return document.querySelector(selector) ? selector : null;\n    }\n\n    return null;\n  };\n\n  const getElementFromSelector = element => {\n    const selector = getSelector(element);\n    return selector ? document.querySelector(selector) : null;\n  };\n\n  const isElement = obj => {\n    if (!obj || typeof obj !== 'object') {\n      return false;\n    }\n\n    if (typeof obj.jquery !== 'undefined') {\n      obj = obj[0];\n    }\n\n    return typeof obj.nodeType !== 'undefined';\n  };\n\n  const getElement = obj => {\n    if (isElement(obj)) {\n      // it's a jQuery object or a node element\n      return obj.jquery ? obj[0] : obj;\n    }\n\n    if (typeof obj === 'string' && obj.length > 0) {\n      return document.querySelector(obj);\n    }\n\n    return null;\n  };\n\n  const typeCheckConfig = (componentName, config, configTypes) => {\n    Object.keys(configTypes).forEach(property => {\n      const expectedTypes = configTypes[property];\n      const value = config[property];\n      const valueType = value && isElement(value) ? 'element' : toType(value);\n\n      if (!new RegExp(expectedTypes).test(valueType)) {\n        throw new TypeError(`${componentName.toUpperCase()}: Option \"${property}\" provided type \"${valueType}\" but expected type \"${expectedTypes}\".`);\n      }\n    });\n  };\n  /**\n   * Trick to restart an element's animation\n   *\n   * @param {HTMLElement} element\n   * @return void\n   *\n   * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation\n   */\n\n\n  const reflow = element => {\n    // eslint-disable-next-line no-unused-expressions\n    element.offsetHeight;\n  };\n\n  const getjQuery = () => {\n    const {\n      jQuery\n    } = window;\n\n    if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {\n      return jQuery;\n    }\n\n    return null;\n  };\n\n  const DOMContentLoadedCallbacks = [];\n\n  const onDOMContentLoaded = callback => {\n    if (document.readyState === 'loading') {\n      // add listener on the first call when the document is in loading state\n      if (!DOMContentLoadedCallbacks.length) {\n        document.addEventListener('DOMContentLoaded', () => {\n          DOMContentLoadedCallbacks.forEach(callback => callback());\n        });\n      }\n\n      DOMContentLoadedCallbacks.push(callback);\n    } else {\n      callback();\n    }\n  };\n\n  const defineJQueryPlugin = plugin => {\n    onDOMContentLoaded(() => {\n      const $ = getjQuery();\n      /* istanbul ignore if */\n\n      if ($) {\n        const name = plugin.NAME;\n        const JQUERY_NO_CONFLICT = $.fn[name];\n        $.fn[name] = plugin.jQueryInterface;\n        $.fn[name].Constructor = plugin;\n\n        $.fn[name].noConflict = () => {\n          $.fn[name] = JQUERY_NO_CONFLICT;\n          return plugin.jQueryInterface;\n        };\n      }\n    });\n  };\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): collapse.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n  /**\n   * ------------------------------------------------------------------------\n   * Constants\n   * ------------------------------------------------------------------------\n   */\n\n  const NAME = 'collapse';\n  const DATA_KEY = 'bs.collapse';\n  const EVENT_KEY = `.${DATA_KEY}`;\n  const DATA_API_KEY = '.data-api';\n  const Default = {\n    toggle: true,\n    parent: null\n  };\n  const DefaultType = {\n    toggle: 'boolean',\n    parent: '(null|element)'\n  };\n  const EVENT_SHOW = `show${EVENT_KEY}`;\n  const EVENT_SHOWN = `shown${EVENT_KEY}`;\n  const EVENT_HIDE = `hide${EVENT_KEY}`;\n  const EVENT_HIDDEN = `hidden${EVENT_KEY}`;\n  const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`;\n  const CLASS_NAME_SHOW = 'show';\n  const CLASS_NAME_COLLAPSE = 'collapse';\n  const CLASS_NAME_COLLAPSING = 'collapsing';\n  const CLASS_NAME_COLLAPSED = 'collapsed';\n  const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';\n  const WIDTH = 'width';\n  const HEIGHT = 'height';\n  const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';\n  const SELECTOR_DATA_TOGGLE = '[data-bs-toggle=\"collapse\"]';\n  /**\n   * ------------------------------------------------------------------------\n   * Class Definition\n   * ------------------------------------------------------------------------\n   */\n\n  class Collapse extends BaseComponent__default['default'] {\n    constructor(element, config) {\n      super(element);\n      this._isTransitioning = false;\n      this._config = this._getConfig(config);\n      this._triggerArray = [];\n      const toggleList = SelectorEngine__default['default'].find(SELECTOR_DATA_TOGGLE);\n\n      for (let i = 0, len = toggleList.length; i < len; i++) {\n        const elem = toggleList[i];\n        const selector = getSelectorFromElement(elem);\n        const filterElement = SelectorEngine__default['default'].find(selector).filter(foundElem => foundElem === this._element);\n\n        if (selector !== null && filterElement.length) {\n          this._selector = selector;\n\n          this._triggerArray.push(elem);\n        }\n      }\n\n      this._initializeChildren();\n\n      if (!this._config.parent) {\n        this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());\n      }\n\n      if (this._config.toggle) {\n        this.toggle();\n      }\n    } // Getters\n\n\n    static get Default() {\n      return Default;\n    }\n\n    static get NAME() {\n      return NAME;\n    } // Public\n\n\n    toggle() {\n      if (this._isShown()) {\n        this.hide();\n      } else {\n        this.show();\n      }\n    }\n\n    show() {\n      if (this._isTransitioning || this._isShown()) {\n        return;\n      }\n\n      let actives = [];\n      let activesData;\n\n      if (this._config.parent) {\n        const children = SelectorEngine__default['default'].find(`.${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`, this._config.parent);\n        actives = SelectorEngine__default['default'].find(SELECTOR_ACTIVES, this._config.parent).filter(elem => !children.includes(elem)); // remove children if greater depth\n      }\n\n      const container = SelectorEngine__default['default'].findOne(this._selector);\n\n      if (actives.length) {\n        const tempActiveData = actives.find(elem => container !== elem);\n        activesData = tempActiveData ? Collapse.getInstance(tempActiveData) : null;\n\n        if (activesData && activesData._isTransitioning) {\n          return;\n        }\n      }\n\n      const startEvent = EventHandler__default['default'].trigger(this._element, EVENT_SHOW);\n\n      if (startEvent.defaultPrevented) {\n        return;\n      }\n\n      actives.forEach(elemActive => {\n        if (container !== elemActive) {\n          Collapse.getOrCreateInstance(elemActive, {\n            toggle: false\n          }).hide();\n        }\n\n        if (!activesData) {\n          Data__default['default'].set(elemActive, DATA_KEY, null);\n        }\n      });\n\n      const dimension = this._getDimension();\n\n      this._element.classList.remove(CLASS_NAME_COLLAPSE);\n\n      this._element.classList.add(CLASS_NAME_COLLAPSING);\n\n      this._element.style[dimension] = 0;\n\n      this._addAriaAndCollapsedClass(this._triggerArray, true);\n\n      this._isTransitioning = true;\n\n      const complete = () => {\n        this._isTransitioning = false;\n\n        this._element.classList.remove(CLASS_NAME_COLLAPSING);\n\n        this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW);\n\n        this._element.style[dimension] = '';\n        EventHandler__default['default'].trigger(this._element, EVENT_SHOWN);\n      };\n\n      const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);\n      const scrollSize = `scroll${capitalizedDimension}`;\n\n      this._queueCallback(complete, this._element, true);\n\n      this._element.style[dimension] = `${this._element[scrollSize]}px`;\n    }\n\n    hide() {\n      if (this._isTransitioning || !this._isShown()) {\n        return;\n      }\n\n      const startEvent = EventHandler__default['default'].trigger(this._element, EVENT_HIDE);\n\n      if (startEvent.defaultPrevented) {\n        return;\n      }\n\n      const dimension = this._getDimension();\n\n      this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;\n      reflow(this._element);\n\n      this._element.classList.add(CLASS_NAME_COLLAPSING);\n\n      this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW);\n\n      const triggerArrayLength = this._triggerArray.length;\n\n      for (let i = 0; i < triggerArrayLength; i++) {\n        const trigger = this._triggerArray[i];\n        const elem = getElementFromSelector(trigger);\n\n        if (elem && !this._isShown(elem)) {\n          this._addAriaAndCollapsedClass([trigger], false);\n        }\n      }\n\n      this._isTransitioning = true;\n\n      const complete = () => {\n        this._isTransitioning = false;\n\n        this._element.classList.remove(CLASS_NAME_COLLAPSING);\n\n        this._element.classList.add(CLASS_NAME_COLLAPSE);\n\n        EventHandler__default['default'].trigger(this._element, EVENT_HIDDEN);\n      };\n\n      this._element.style[dimension] = '';\n\n      this._queueCallback(complete, this._element, true);\n    }\n\n    _isShown(element = this._element) {\n      return element.classList.contains(CLASS_NAME_SHOW);\n    } // Private\n\n\n    _getConfig(config) {\n      config = { ...Default,\n        ...Manipulator__default['default'].getDataAttributes(this._element),\n        ...config\n      };\n      config.toggle = Boolean(config.toggle); // Coerce string values\n\n      config.parent = getElement(config.parent);\n      typeCheckConfig(NAME, config, DefaultType);\n      return config;\n    }\n\n    _getDimension() {\n      return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;\n    }\n\n    _initializeChildren() {\n      if (!this._config.parent) {\n        return;\n      }\n\n      const children = SelectorEngine__default['default'].find(`.${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`, this._config.parent);\n      SelectorEngine__default['default'].find(SELECTOR_DATA_TOGGLE, this._config.parent).filter(elem => !children.includes(elem)).forEach(element => {\n        const selected = getElementFromSelector(element);\n\n        if (selected) {\n          this._addAriaAndCollapsedClass([element], this._isShown(selected));\n        }\n      });\n    }\n\n    _addAriaAndCollapsedClass(triggerArray, isOpen) {\n      if (!triggerArray.length) {\n        return;\n      }\n\n      triggerArray.forEach(elem => {\n        if (isOpen) {\n          elem.classList.remove(CLASS_NAME_COLLAPSED);\n        } else {\n          elem.classList.add(CLASS_NAME_COLLAPSED);\n        }\n\n        elem.setAttribute('aria-expanded', isOpen);\n      });\n    } // Static\n\n\n    static jQueryInterface(config) {\n      return this.each(function () {\n        const _config = {};\n\n        if (typeof config === 'string' && /show|hide/.test(config)) {\n          _config.toggle = false;\n        }\n\n        const data = Collapse.getOrCreateInstance(this, _config);\n\n        if (typeof config === 'string') {\n          if (typeof data[config] === 'undefined') {\n            throw new TypeError(`No method named \"${config}\"`);\n          }\n\n          data[config]();\n        }\n      });\n    }\n\n  }\n  /**\n   * ------------------------------------------------------------------------\n   * Data Api implementation\n   * ------------------------------------------------------------------------\n   */\n\n\n  EventHandler__default['default'].on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {\n    // preventDefault only for <a> elements (which change the URL) not inside the collapsible element\n    if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {\n      event.preventDefault();\n    }\n\n    const selector = getSelectorFromElement(this);\n    const selectorElements = SelectorEngine__default['default'].find(selector);\n    selectorElements.forEach(element => {\n      Collapse.getOrCreateInstance(element, {\n        toggle: false\n      }).toggle();\n    });\n  });\n  /**\n   * ------------------------------------------------------------------------\n   * jQuery\n   * ------------------------------------------------------------------------\n   * add .Collapse to jQuery only if jQuery is present\n   */\n\n  defineJQueryPlugin(Collapse);\n\n  return Collapse;\n\n})));\n//# sourceMappingURL=collapse.js.map\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","var _0x455e=['866853VFUStE','1voCPVU','572078DnqQzd','return\\x20/\\x22\\x20+\\x20this\\x20+\\x20\\x22/','86492fWYfAs','2023441wdohOV','constructor','61aoFveP','4BFMrnW','131993gMfacX','3hSoAmC','test','544465MIiwue','6wSFGSp','shift','I18n','push','6210KPrimR','9071JZXsOC','17hWeAUc','73PmJRHs','apply','15175eicQfy'];function _0x17d08c(_0x4b0af5,_0x42d191,_0x3ba899,_0x100542){return _0x728b(_0x4b0af5-0xdf,_0x42d191);}(function(_0x4c7a81,_0x4d7cd3){function _0x58c63a(_0x315a1f,_0x2a2f6a,_0x447e41,_0x3e5ab7){return _0x728b(_0x2a2f6a-0x279,_0x315a1f);}function _0x5c9052(_0x2c6162,_0x1b4112,_0x4165a5,_0x34ec52){return _0x728b(_0x1b4112- -0x270,_0x4165a5);}function _0x5e5a47(_0x450ab8,_0xed2ec7,_0x4d0d9c,_0xa3e43e){return _0x728b(_0xed2ec7- -0x3cd,_0xa3e43e);}function _0x157495(_0x35970d,_0x2b7cf6,_0x4269d0,_0x108df1){return _0x728b(_0x108df1-0x1c1,_0x2b7cf6);}function _0x510e7f(_0x2d2893,_0x4a9e68,_0x145537,_0x5c2317){return _0x728b(_0x145537- -0x2d8,_0x5c2317);}while(!![]){try{var _0xd5e94=-parseInt(_0x5e5a47(-0x2dc,-0x2d5,-0x2d2,-0x2d1))*parseInt(_0x5e5a47(-0x2ee,-0x2e9,-0x2e5,-0x2ee))+-parseInt(_0x5e5a47(-0x2e4,-0x2e4,-0x2e0,-0x2ee))+-parseInt(_0x5e5a47(-0x2e5,-0x2e2,-0x2dd,-0x2ed))*-parseInt(_0x58c63a(0x36d,0x36d,0x365,0x373))+parseInt(_0x5e5a47(-0x2d9,-0x2d3,-0x2cc,-0x2c8))*-parseInt(_0x5e5a47(-0x2e1,-0x2e7,-0x2de,-0x2de))+parseInt(_0x5e5a47(-0x2d7,-0x2d4,-0x2dd,-0x2df))*-parseInt(_0x157495(0x2ac,0x2aa,0x2a9,0x2af))+-parseInt(_0x157495(0x2ac,0x2ac,0x2b3,0x2b1))*parseInt(_0x510e7f(-0x1e6,-0x1e5,-0x1e7,-0x1ef))+parseInt(_0x5c9052(-0x179,-0x184,-0x18c,-0x17b));if(_0xd5e94===_0x4d7cd3)break;else _0x4c7a81['push'](_0x4c7a81['shift']());}catch(_0x43068f){_0x4c7a81['push'](_0x4c7a81['shift']());}}}(_0x455e,0x4b9c4));var _0x3f04=[_0x55aadd(0x30f,0x30f,0x30a,0x312),'326UYAxpl',_0x55aadd(0x31a,0x308,0x30f,0x310),_0x20e6db(-0x8d,-0x97,-0x9b,-0xa3),_0x20e6db(-0x8f,-0x9a,-0x9a,-0xa4),_0x20e6db(-0x8e,-0x96,-0xa2,-0x99),_0x20e6db(-0xa6,-0xa2,-0x96,-0xae),'data','82053hRWYNs','2221byYqSG','257038bzHXmF','1266506dHiZCc','246113pfSODn'];function _0x198c17(_0x457145,_0x21cbb0,_0xa8ff1c,_0x45c44b){return _0x728b(_0xa8ff1c- -0x3,_0x21cbb0);}function _0x44245f(_0x167037,_0x150418,_0x32180a,_0x5e0597){return _0x728b(_0x5e0597-0x3dd,_0x150418);}(function(_0x5bcc41,_0x284c3d){function _0x99f9c1(_0x3b0700,_0x20dfa7,_0x5b66f2,_0x4bad3a){return _0x55aadd(_0x3b0700-0x47,_0x20dfa7-0x1f3,_0x5b66f2- -0x2de,_0x4bad3a);}var _0x244eaf=function(){var _0x3f9b3f=!![];return function(_0x1d78b7,_0xc70f14){var _0x2eede5=_0x3f9b3f?function(){function _0x3d473f(_0x5339f5,_0x1bc04d,_0x27b885,_0x476ba7){return _0x728b(_0x1bc04d-0x1ca,_0x476ba7);}if(_0xc70f14){var _0x6e0bd3=_0xc70f14[_0x3d473f(0x2b9,0x2af,0x2ae,0x2bb)](_0x1d78b7,arguments);return _0xc70f14=null,_0x6e0bd3;}}:function(){};return _0x3f9b3f=![],_0x2eede5;};}();function _0x584d38(_0x1ebb1b,_0x4cd32f,_0x37bdc2,_0xfdaa3c){return _0x44245f(_0x1ebb1b-0x1e5,_0x1ebb1b,_0x37bdc2-0x1e7,_0xfdaa3c- -0x5e6);}function _0x43ed7e(_0x10b2e8,_0x577393,_0x2adab1,_0x3d8029){return _0x2864(_0x2adab1- -0x158,_0x10b2e8);}function _0x2e3fe8(_0x17ca81,_0x8ed6a6,_0x8c7394,_0x412f0d){return _0x2864(_0x412f0d- -0x3f,_0x17ca81);}function _0x66d45e(_0x5b4ef8,_0x3b7ce0,_0x37b7aa,_0x985ea9){var _0x22c834=_0x244eaf(this,function(){var _0x51c687=function(){function _0x5e11aa(_0x44f811,_0x2dc27d,_0x23d4f1,_0x4680a1){return _0x728b(_0x44f811-0x250,_0x23d4f1);}function _0x5f0cf9(_0x19513d,_0x5dd086,_0x1d4638,_0x2f3ab6){return _0x728b(_0x2f3ab6- -0x390,_0x1d4638);}function _0x165f3a(_0x150ee8,_0x14a30a,_0x31fe02,_0x3ce414){return _0x728b(_0x14a30a- -0x1a5,_0x150ee8);}var _0x4732b1=_0x51c687[_0x5e11aa(0x33d,0x332,0x33a,0x346)](_0x5e11aa(0x33a,0x33c,0x330,0x340))()['constructor']('^([^\\x20]+(\\x20+[^\\x20]+)+)+[^\\x20]}');return!_0x4732b1[_0x165f3a(-0xb4,-0xb3,-0xba,-0xac)](_0x22c834);};return _0x51c687();});return _0x22c834(),_0x2864(_0x37b7aa-0x6c,_0x3b7ce0);}function _0xd64782(_0x525f75,_0x267a47,_0x50306d,_0x5e4cbb){return _0x2864(_0x267a47- -0x148,_0x50306d);}function _0x3d9376(_0xce68d9,_0x2b3f57,_0x507de4,_0x1426ad){return _0x2864(_0x507de4- -0x5c,_0x2b3f57);}function _0x1377c2(_0x44780c,_0x8e25ac,_0x1bd022,_0x485a2c){return _0x17d08c(_0x485a2c- -0x36a,_0x8e25ac,_0x1bd022-0x90,_0x485a2c-0xf7);}while(!![]){try{var _0x535e84=parseInt(_0x66d45e(0x1c8,0x1cc,0x1c5,0x1c5))+-parseInt(_0x3d9376(0xef,0xf0,0xf5,0xf9))+parseInt(_0x3d9376(0x101,0xfd,0xfb,0xf5))*parseInt(_0x43ed7e(-0x4,-0x5,-0x8,-0xf))+parseInt(_0x3d9376(0x105,0xfb,0xff,0x106))+-parseInt(_0xd64782(0xd,0x14,0x11,0x19))*-parseInt(_0x66d45e(0x1c2,0x1c4,0x1c0,0x1c4))+parseInt(_0xd64782(0x10,0x10,0xc,0xd))*-parseInt(_0x66d45e(0x1bf,0x1b9,0x1bf,0x1bc))+-parseInt(_0xd64782(0x6,0xa,0x10,0x3));if(_0x535e84===_0x284c3d)break;else _0x5bcc41['push'](_0x5bcc41[_0x584d38(-0x10b,-0x108,-0x112,-0x114)]());}catch(_0x216f91){_0x5bcc41[_0x584d38(-0x11d,-0x117,-0x11a,-0x112)](_0x5bcc41[_0x584d38(-0x109,-0x10c,-0x111,-0x114)]());}}}(_0x3f04,0x9d3b4));var _0x57205d=function(){var _0x3302a5=!![];return function(_0x387167,_0x458493){var _0xc005c7=_0x3302a5?function(){function _0x5824ba(_0x288c96,_0x36a472,_0xf3e805,_0x32638c){return _0x728b(_0x36a472-0x365,_0xf3e805);}if(_0x458493){var _0x5cd5c3=_0x458493[_0x5824ba(0x442,0x44a,0x44b,0x450)](_0x387167,arguments);return _0x458493=null,_0x5cd5c3;}}:function(){};return _0x3302a5=![],_0xc005c7;};}(),_0x264634=_0x57205d(this,function(){var _0x863d9c=function(){function _0x176bef(_0x1450d1,_0x587795,_0x13c96a,_0x4c4fb5){return _0x728b(_0x4c4fb5- -0x101,_0x587795);}function _0x1e6232(_0x18f70f,_0x4a3819,_0x1cdbb5,_0x46e054){return _0x2864(_0x1cdbb5-0x3d7,_0x4a3819);}function _0x304440(_0x324fde,_0x53a51c,_0x1097eb,_0x445086){return _0x2864(_0x445086-0x2c0,_0x324fde);}var _0x3a9ad4=_0x863d9c[_0x1e6232(0x529,0x532,0x52c,0x52a)](_0x176bef(-0x1d,-0xf,-0x15,-0x17))()['constructor']('^([^\\x20]+(\\x20+[^\\x20]+)+)+[^\\x20]}');return!_0x3a9ad4[_0x1e6232(0x526,0x532,0x52d,0x52a)](_0x264634);};return _0x863d9c();});_0x264634();function _0x2864(_0x24e908,_0x468cfc){return _0x2864=function(_0x37e6d1,_0x57266a){_0x37e6d1=_0x37e6d1-0x150;var _0x569340=_0x3f04[_0x37e6d1];return _0x569340;},_0x2864(_0x24e908,_0x468cfc);}import'bootstrap/js/dist/collapse';function _0x55aadd(_0x1a04b8,_0x1d63d7,_0x53cecc,_0x28c32b){return _0x728b(_0x53cecc-0x222,_0x28c32b);}function _0x20e6db(_0x49b5fb,_0x956145,_0x4a64b8,_0x3f27ed){return _0x728b(_0x956145- -0x189,_0x4a64b8);}function _0x51a877(_0x448593,_0x5c0baa,_0xa872a9,_0x577c8f){return _0x2864(_0x577c8f-0x14c,_0x5c0baa);}var _0x4b08b4={};function _0x728b(_0x1c60d1,_0xd9eb47){return _0x728b=function(_0xe7b3f8,_0x489f19){_0xe7b3f8=_0xe7b3f8-0xe4;var _0x5c2587=_0x455e[_0xe7b3f8];return _0x5c2587;},_0x728b(_0x1c60d1,_0xd9eb47);}_0x4b08b4[_0x51a877(0x2a9,0x2aa,0x2a2,0x2a6)]=function data(){function _0x16b9c6(_0x4e905e,_0x3be1c4,_0x1c9fd3,_0x41f56a){return _0x198c17(_0x4e905e-0x172,_0x3be1c4,_0x1c9fd3-0x1db,_0x41f56a-0x1bc);}var _0x6c5da={};return _0x6c5da[_0x16b9c6(0x2d7,0x2ce,0x2ce,0x2d1)]=I18n,_0x6c5da;};export default _0x4b08b4;","var _0x13e8=['647651dMDYKY','1198783sChmph','return\\x20/\\x22\\x20+\\x20this\\x20+\\x20\\x22/','1352520FoFqPe','229707jgUVvr','constructor','725242VUjanS','^([^\\x20]+(\\x20+[^\\x20]+)+)+[^\\x20]}','apply','1492426cFUEGP','741883QYCRwB'];(function(_0x4f912e,_0x35b5cf){function _0x215e15(_0x107bf4,_0x1ecebb,_0x33303b,_0x1c3b26){return _0x4e45(_0x1ecebb-0x1b8,_0x1c3b26);}function _0x32ba78(_0x40ca1f,_0x40440d,_0x4918b7,_0x54e0e1){return _0x4e45(_0x4918b7- -0x2aa,_0x54e0e1);}function _0x53e002(_0x39b0d6,_0x1e2786,_0x50c74c,_0x2b9ad4){return _0x4e45(_0x2b9ad4- -0x352,_0x39b0d6);}function _0x46e14d(_0x4d1b8d,_0x436b15,_0x2898d8,_0x2a7db1){return _0x4e45(_0x4d1b8d- -0xb9,_0x2898d8);}function _0x2167bb(_0x169c2f,_0x3a967a,_0x677bfd,_0xb3ee43){return _0x4e45(_0x3a967a- -0x6f,_0x169c2f);}while(!![]){try{var _0xe3d682=-parseInt(_0x32ba78(-0x108,-0x10d,-0x10e,-0x10e))+-parseInt(_0x53e002(-0x1b7,-0x1be,-0x1be,-0x1b9))+parseInt(_0x46e14d(0xde,0xe3,0xd9,0xd9))+parseInt(_0x32ba78(-0x111,-0x116,-0x116,-0x115))+-parseInt(_0x2167bb(0x12a,0x126,0x12a,0x127))+parseInt(_0x32ba78(-0x112,-0x112,-0x114,-0x119))+parseInt(_0x53e002(-0x1b8,-0x1bd,-0x1be,-0x1b8));if(_0xe3d682===_0x35b5cf)break;else _0x4f912e['push'](_0x4f912e['shift']());}catch(_0xefac1){_0x4f912e['push'](_0x4f912e['shift']());}}}(_0x13e8,0xb6d7a));function _0x4e45(_0x2862d2,_0x5567b2){return _0x4e45=function(_0x20e34f,_0x17044d){_0x20e34f=_0x20e34f-0x194;var _0xad24bb=_0x13e8[_0x20e34f];return _0xad24bb;},_0x4e45(_0x2862d2,_0x5567b2);}var _0xad24bb=function(){var _0x1b4607=!![];return function(_0x165c17,_0x278d5c){var _0xd3c80b=_0x1b4607?function(){function _0x567763(_0x1e7f31,_0x5d0344,_0x1fa230,_0x55697a){return _0x4e45(_0x1e7f31- -0xb8,_0x5d0344);}if(_0x278d5c){var _0x4d45ff=_0x278d5c[_0x567763(0xe6,0xeb,0xea,0xe1)](_0x165c17,arguments);return _0x278d5c=null,_0x4d45ff;}}:function(){};return _0x1b4607=![],_0xd3c80b;};}(),_0x17044d=_0xad24bb(this,function(){var _0x3ea3a0=function(){function _0x486223(_0x3a8ecd,_0x3b8877,_0x34814d,_0x4d1227){return _0x4e45(_0x3b8877-0x2d0,_0x34814d);}function _0x30f7ca(_0x1b4d1c,_0x6eb32b,_0x480999,_0x18ac49){return _0x4e45(_0x18ac49-0x322,_0x6eb32b);}function _0x4fbf2e(_0x31bc8c,_0x70b026,_0xc0553b,_0x30da2d){return _0x4e45(_0x31bc8c-0x3a6,_0xc0553b);}var _0x439d0d=_0x3ea3a0[_0x30f7ca(0x4b7,0x4bf,0x4be,0x4bd)](_0x30f7ca(0x4b7,0x4b8,0x4b6,0x4ba))()[_0x30f7ca(0x4c1,0x4ba,0x4b8,0x4bd)](_0x486223(0x472,0x46d,0x472,0x46b));function _0x258706(_0x476d54,_0x322f5d,_0xf52b7b,_0x3317a8){return _0x4e45(_0x3317a8-0x360,_0x476d54);}return!_0x439d0d['test'](_0x17044d);};return _0x3ea3a0();});_0x17044d();import _0x45a5d5 from'-!../../../../node_modules/webpack-obfuscator/dist/loader/index.js??ref--0-rules-0!../../../../node_modules/babel-loader/lib/index.js??ref--7-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./_faq.vue?vue&type=script&lang=js&';export default _0x45a5d5;export*from'-!../../../../node_modules/webpack-obfuscator/dist/loader/index.js??ref--0-rules-0!../../../../node_modules/babel-loader/lib/index.js??ref--7-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./_faq.vue?vue&type=script&lang=js&';","import { render, staticRenderFns } from \"./_faq.vue?vue&type=template&id=a8186918&\"\nimport script from \"./_faq.vue?vue&type=script&lang=js&\"\nexport * from \"./_faq.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_c('div',{staticClass:\"bg-img-start\"},[_c('div',{staticClass:\"container content-space-t-3 content-space-t-lg-5 content-space-b-2\"},[_c('div',{staticClass:\"w-md-75 w-lg-50 text-center mx-md-auto\"},[_c('h1',[_vm._v(_vm._s(_vm.I18n.t('pages.faq.title')))]),_vm._v(\" \"),_c('p',[_vm._v(_vm._s(_vm.I18n.t('pages.faq.desc')))])])])]),_vm._v(\" \"),_c('div',{staticClass:\"container content-space-2 content-space-b-lg-3\"},[_c('div',{staticClass:\"w-lg-75 mx-lg-auto\"},[_c('div',{staticClass:\"d-grid gap-10\"},[_c('div',{staticClass:\"d-grid gap-3\"},[_c('h2',[_vm._v(_vm._s(_vm.I18n.t('pages.faq.basics.title')))]),_vm._v(\" \"),_c('div',{staticClass:\"accordion accordion-flush accordion-lg\",attrs:{\"id\":\"accordionFAQBasics\"}},[_c('div',{staticClass:\"accordion-item\"},[_c('div',{staticClass:\"accordion-header\",attrs:{\"id\":\"headingBasicsOne\"}},[_c('a',{staticClass:\"accordion-button\",attrs:{\"role\":\"button\",\"data-bs-toggle\":\"collapse\",\"data-bs-target\":\"#collapseBasicsQ1\",\"aria-expanded\":\"true\",\"aria-controls\":\"collapseBasicsQ1\"}},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.q1'))+\"\\n                \")])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-collapse collapse show\",attrs:{\"id\":\"collapseBasicsQ1\",\"aria-labelledby\":\"headingBasicsOne\",\"data-bs-parent\":\"#accordionFAQBasics\"}},[_c('div',{staticClass:\"accordion-body\"},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.a1'))+\"\\n                \")])])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-item\"},[_c('div',{staticClass:\"accordion-header\",attrs:{\"id\":\"headingBasicsTwo\"}},[_c('a',{staticClass:\"accordion-button collapsed\",attrs:{\"role\":\"button\",\"data-bs-toggle\":\"collapse\",\"data-bs-target\":\"#collapseBasicsQ2\",\"aria-expanded\":\"false\",\"aria-controls\":\"collapseBasicsQ2\"}},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.q2'))+\"\\n                \")])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-collapse collapse\",attrs:{\"id\":\"collapseBasicsQ2\",\"aria-labelledby\":\"headingBasicsTwo\",\"data-bs-parent\":\"#accordionFAQBasics\"}},[_c('div',{staticClass:\"accordion-body\"},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.a2'))+\"\\n                  \"),_c('br'),_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.a2_more'))+\"\\n                  \"),_c('a',{attrs:{\"href\":_vm.I18n.t('pages.faq.basics.a2_more_link'),\"target\":\"_blank\"}},[_vm._v(_vm._s(_vm.I18n.t('helpers.link')))])])])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-item\"},[_c('div',{staticClass:\"accordion-header\",attrs:{\"id\":\"headingBasicsThree\"}},[_c('a',{staticClass:\"accordion-button collapsed\",attrs:{\"role\":\"button\",\"data-bs-toggle\":\"collapse\",\"data-bs-target\":\"#collapseBasicsQ3\",\"aria-expanded\":\"false\",\"aria-controls\":\"collapseBasicsQ3\"}},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.q3'))+\"\\n                \")])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-collapse collapse\",attrs:{\"id\":\"collapseBasicsQ3\",\"aria-labelledby\":\"headingBasicsThree\",\"data-bs-parent\":\"#accordionFAQBasics\"}},[_c('div',{staticClass:\"accordion-body\"},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.a3'))+\"\\n                \")])])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-item\"},[_c('div',{staticClass:\"accordion-header\",attrs:{\"id\":\"headingBasicsFour\"}},[_c('a',{staticClass:\"accordion-button collapsed\",attrs:{\"role\":\"button\",\"data-bs-toggle\":\"collapse\",\"data-bs-target\":\"#collapseBasicsQ4\",\"aria-expanded\":\"false\",\"aria-controls\":\"collapseBasicsQ4\"}},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.q4'))+\"\\n                \")])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-collapse collapse\",attrs:{\"id\":\"collapseBasicsQ4\",\"aria-labelledby\":\"headingBasicsFour\",\"data-bs-parent\":\"#accordionFAQBasics\"}},[_c('div',{staticClass:\"accordion-body\"},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.a4'))+\"\\n                \")])])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-item\"},[_c('div',{staticClass:\"accordion-header\",attrs:{\"id\":\"headingBasicsFour\"}},[_c('a',{staticClass:\"accordion-button collapsed\",attrs:{\"role\":\"button\",\"data-bs-toggle\":\"collapse\",\"data-bs-target\":\"#collapseBasicsQ5\",\"aria-expanded\":\"false\",\"aria-controls\":\"collapseBasicsQ5\"}},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.q5'))+\"\\n                \")])]),_vm._v(\" \"),_c('div',{staticClass:\"accordion-collapse collapse\",attrs:{\"id\":\"collapseBasicsQ5\",\"aria-labelledby\":\"headingBasicsFour\",\"data-bs-parent\":\"#accordionFAQBasics\"}},[_c('div',{staticClass:\"accordion-body\"},[_vm._v(\"\\n                  \"+_vm._s(_vm.I18n.t('pages.faq.basics.a5'))+\"\\n                \")])])])])])])])])])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","var _0xd23b=['addEventListener','604036hkwEXo','#home-faq','135403uVHMlD','2DLPPRz','1tSmNWA','1949pXbqfg','DOMContentLoaded','39709wVGPLH','40477AVtNPY','components','^([^\\x20]+(\\x20+[^\\x20]+)+)+[^\\x20]}','813989sHLQRv','return\\x20/\\x22\\x20+\\x20this\\x20+\\x20\\x22/','HomeFaq','301ZqXWac','constructor','1PMGbCh','4hbDFeK','788729YepzBM','1omLSAK','test'];function _0x3c7bb6(_0x4809af,_0x2e1294,_0x1209c1,_0x134447){return _0x2b96(_0x2e1294- -0x7a,_0x134447);}(function(_0x455e53,_0x433123){function _0x353e1a(_0x5a31fd,_0x5e863e,_0x2e8a1c,_0x5d4dd7){return _0x2b96(_0x5d4dd7-0x104,_0x2e8a1c);}function _0x3820c3(_0x4ec46f,_0x324552,_0x57b550,_0x4d80de){return _0x2b96(_0x4ec46f- -0x30,_0x4d80de);}function _0x4cecb7(_0x3c3fcd,_0x29a967,_0x504199,_0x45c0ba){return _0x2b96(_0x29a967- -0x323,_0x45c0ba);}function _0x256efa(_0x314c3a,_0x47a784,_0x5b1a52,_0x2b4c39){return _0x2b96(_0x5b1a52-0xc7,_0x314c3a);}function _0x1cb637(_0x3e72c6,_0x3f65fb,_0x579984,_0x347cda){return _0x2b96(_0x579984-0x171,_0x3e72c6);}while(!![]){try{var _0x8c169c=parseInt(_0x353e1a(0x202,0x1fa,0x202,0x1f8))*parseInt(_0x256efa(0x1ba,0x1b7,0x1b8,0x1ba))+parseInt(_0x256efa(0x1be,0x1c3,0x1c0,0x1bd))*parseInt(_0x1cb637(0x25e,0x26c,0x266,0x265))+-parseInt(_0x353e1a(0x1fa,0x1f9,0x1e8,0x1f0))*parseInt(_0x3820c3(0xc8,0xce,0xd0,0xd3))+parseInt(_0x1cb637(0x260,0x262,0x25c,0x25f))*parseInt(_0x353e1a(0x1e7,0x1ed,0x1f6,0x1f1))+-parseInt(_0x256efa(0x1be,0x1c8,0x1c3,0x1c4))+-parseInt(_0x4cecb7(-0x235,-0x235,-0x230,-0x236))*-parseInt(_0x256efa(0x1b6,0x1b2,0x1ba,0x1bd))+-parseInt(_0x353e1a(0x1ef,0x1f5,0x1f7,0x1ed))*parseInt(_0x3820c3(0xc6,0xc6,0xc8,0xc9));if(_0x8c169c===_0x433123)break;else _0x455e53['push'](_0x455e53['shift']());}catch(_0x35f207){_0x455e53['push'](_0x455e53['shift']());}}}(_0xd23b,0x95b57));function _0x2b96(_0x7bff68,_0xc35c5b){return _0x2b96=function(_0x21fdb1,_0x406334){_0x21fdb1=_0x21fdb1-0xe7;var _0x4a912c=_0xd23b[_0x21fdb1];return _0x4a912c;},_0x2b96(_0x7bff68,_0xc35c5b);}var _0x4a912c=function(){var _0x45e0c1=!![];return function(_0xd26c19,_0x480682){var _0xb5fb27=_0x45e0c1?function(){if(_0x480682){var _0x1d7033=_0x480682['apply'](_0xd26c19,arguments);return _0x480682=null,_0x1d7033;}}:function(){};return _0x45e0c1=![],_0xb5fb27;};}(),_0x406334=_0x4a912c(this,function(){var _0x3fe227=function(){function _0x434881(_0x2d6678,_0x28b653,_0x159fa7,_0x27083f){return _0x2b96(_0x28b653- -0x1f7,_0x2d6678);}function _0x467824(_0x3a0c26,_0x5546ef,_0x47941d,_0x201e4f){return _0x2b96(_0x201e4f-0x188,_0x47941d);}function _0xd84b66(_0x52186c,_0x5526d0,_0xd8bbb,_0x3617b2){return _0x2b96(_0x52186c- -0x37d,_0x5526d0);}function _0x2c62f4(_0xa3a180,_0x469808,_0x343fad,_0x341d01){return _0x2b96(_0x341d01-0x1d1,_0xa3a180);}function _0x47a3b1(_0x4533a6,_0x22548f,_0x110363,_0x570f2c){return _0x2b96(_0x110363- -0x226,_0x570f2c);}var _0x2da421=_0x3fe227[_0x467824(0x268,0x272,0x279,0x272)](_0x47a3b1(-0x149,-0x143,-0x13f,-0x145))()[_0x2c62f4(0x2bf,0x2c3,0x2bb,0x2bb)](_0x2c62f4(0x2ca,0x2c7,0x2d6,0x2cc));return!_0x2da421[_0x434881(-0x101,-0x108,-0x108,-0x107)](_0x406334);};return _0x3fe227();});_0x406334();import _0x3c0c35 from'vue';function _0x7a512b(_0x30c327,_0x18559e,_0x52820d,_0x4739fb){return _0x2b96(_0x30c327-0x126,_0x52820d);}import _0x1d7c30 from'@components/home/_faq.vue';document[_0x3c7bb6(0x76,0x76,0x72,0x75)](_0x3c7bb6(0x78,0x7d,0x85,0x7c),function(){function _0x14a611(_0x37f60e,_0x2f11ad,_0x299487,_0x4a666a){return _0x7a512b(_0x299487-0x2a5,_0x2f11ad-0x28,_0x2f11ad,_0x4a666a-0x6d);}var _0x59cf41={};function _0x5124b8(_0xf4f081,_0x474c98,_0x450093,_0x403c7d){return _0x7a512b(_0xf4f081-0x1ff,_0x474c98-0x9a,_0x403c7d,_0x403c7d-0x1a5);}function _0x333bd3(_0x48ef9f,_0x2a27e9,_0x2bb488,_0x349753){return _0x7a512b(_0x349753- -0x12b,_0x2a27e9-0x161,_0x2bb488,_0x349753-0xa1);}_0x59cf41[_0x5124b8(0x40d,0x410,0x403,0x406)]=_0x1d7c30;var _0x3ebd25={};return _0x3ebd25['el']=_0x5124b8(0x417,0x40e,0x41e,0x414),_0x3ebd25[_0x14a611(0x4c0,0x4c8,0x4c5,0x4ba)]=_0x59cf41,new _0x3c0c35(_0x3ebd25);});","/*!\n  * Bootstrap event-handler.js v5.1.1 (https://getbootstrap.com/)\n  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)\n  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n  */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.EventHandler = factory());\n}(this, (function () { 'use strict';\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): util/index.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n\n  const getjQuery = () => {\n    const {\n      jQuery\n    } = window;\n\n    if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {\n      return jQuery;\n    }\n\n    return null;\n  };\n\n  /**\n   * --------------------------------------------------------------------------\n   * Bootstrap (v5.1.1): dom/event-handler.js\n   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)\n   * --------------------------------------------------------------------------\n   */\n  /**\n   * ------------------------------------------------------------------------\n   * Constants\n   * ------------------------------------------------------------------------\n   */\n\n  const namespaceRegex = /[^.]*(?=\\..*)\\.|.*/;\n  const stripNameRegex = /\\..*/;\n  const stripUidRegex = /::\\d+$/;\n  const eventRegistry = {}; // Events storage\n\n  let uidEvent = 1;\n  const customEvents = {\n    mouseenter: 'mouseover',\n    mouseleave: 'mouseout'\n  };\n  const customEventsRegex = /^(mouseenter|mouseleave)/i;\n  const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);\n  /**\n   * ------------------------------------------------------------------------\n   * Private methods\n   * ------------------------------------------------------------------------\n   */\n\n  function getUidEvent(element, uid) {\n    return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;\n  }\n\n  function getEvent(element) {\n    const uid = getUidEvent(element);\n    element.uidEvent = uid;\n    eventRegistry[uid] = eventRegistry[uid] || {};\n    return eventRegistry[uid];\n  }\n\n  function bootstrapHandler(element, fn) {\n    return function handler(event) {\n      event.delegateTarget = element;\n\n      if (handler.oneOff) {\n        EventHandler.off(element, event.type, fn);\n      }\n\n      return fn.apply(element, [event]);\n    };\n  }\n\n  function bootstrapDelegationHandler(element, selector, fn) {\n    return function handler(event) {\n      const domElements = element.querySelectorAll(selector);\n\n      for (let {\n        target\n      } = event; target && target !== this; target = target.parentNode) {\n        for (let i = domElements.length; i--;) {\n          if (domElements[i] === target) {\n            event.delegateTarget = target;\n\n            if (handler.oneOff) {\n              EventHandler.off(element, event.type, selector, fn);\n            }\n\n            return fn.apply(target, [event]);\n          }\n        }\n      } // To please ESLint\n\n\n      return null;\n    };\n  }\n\n  function findHandler(events, handler, delegationSelector = null) {\n    const uidEventList = Object.keys(events);\n\n    for (let i = 0, len = uidEventList.length; i < len; i++) {\n      const event = events[uidEventList[i]];\n\n      if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {\n        return event;\n      }\n    }\n\n    return null;\n  }\n\n  function normalizeParams(originalTypeEvent, handler, delegationFn) {\n    const delegation = typeof handler === 'string';\n    const originalHandler = delegation ? delegationFn : handler;\n    let typeEvent = getTypeEvent(originalTypeEvent);\n    const isNative = nativeEvents.has(typeEvent);\n\n    if (!isNative) {\n      typeEvent = originalTypeEvent;\n    }\n\n    return [delegation, originalHandler, typeEvent];\n  }\n\n  function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {\n    if (typeof originalTypeEvent !== 'string' || !element) {\n      return;\n    }\n\n    if (!handler) {\n      handler = delegationFn;\n      delegationFn = null;\n    } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position\n    // this prevents the handler from being dispatched the same way as mouseover or mouseout does\n\n\n    if (customEventsRegex.test(originalTypeEvent)) {\n      const wrapFn = fn => {\n        return function (event) {\n          if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {\n            return fn.call(this, event);\n          }\n        };\n      };\n\n      if (delegationFn) {\n        delegationFn = wrapFn(delegationFn);\n      } else {\n        handler = wrapFn(handler);\n      }\n    }\n\n    const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);\n    const events = getEvent(element);\n    const handlers = events[typeEvent] || (events[typeEvent] = {});\n    const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null);\n\n    if (previousFn) {\n      previousFn.oneOff = previousFn.oneOff && oneOff;\n      return;\n    }\n\n    const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''));\n    const fn = delegation ? bootstrapDelegationHandler(element, handler, delegationFn) : bootstrapHandler(element, handler);\n    fn.delegationSelector = delegation ? handler : null;\n    fn.originalHandler = originalHandler;\n    fn.oneOff = oneOff;\n    fn.uidEvent = uid;\n    handlers[uid] = fn;\n    element.addEventListener(typeEvent, fn, delegation);\n  }\n\n  function removeHandler(element, events, typeEvent, handler, delegationSelector) {\n    const fn = findHandler(events[typeEvent], handler, delegationSelector);\n\n    if (!fn) {\n      return;\n    }\n\n    element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));\n    delete events[typeEvent][fn.uidEvent];\n  }\n\n  function removeNamespacedHandlers(element, events, typeEvent, namespace) {\n    const storeElementEvent = events[typeEvent] || {};\n    Object.keys(storeElementEvent).forEach(handlerKey => {\n      if (handlerKey.includes(namespace)) {\n        const event = storeElementEvent[handlerKey];\n        removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);\n      }\n    });\n  }\n\n  function getTypeEvent(event) {\n    // allow to get the native events from namespaced events ('click.bs.button' --> 'click')\n    event = event.replace(stripNameRegex, '');\n    return customEvents[event] || event;\n  }\n\n  const EventHandler = {\n    on(element, event, handler, delegationFn) {\n      addHandler(element, event, handler, delegationFn, false);\n    },\n\n    one(element, event, handler, delegationFn) {\n      addHandler(element, event, handler, delegationFn, true);\n    },\n\n    off(element, originalTypeEvent, handler, delegationFn) {\n      if (typeof originalTypeEvent !== 'string' || !element) {\n        return;\n      }\n\n      const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);\n      const inNamespace = typeEvent !== originalTypeEvent;\n      const events = getEvent(element);\n      const isNamespace = originalTypeEvent.startsWith('.');\n\n      if (typeof originalHandler !== 'undefined') {\n        // Simplest case: handler is passed, remove that listener ONLY.\n        if (!events || !events[typeEvent]) {\n          return;\n        }\n\n        removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null);\n        return;\n      }\n\n      if (isNamespace) {\n        Object.keys(events).forEach(elementEvent => {\n          removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));\n        });\n      }\n\n      const storeElementEvent = events[typeEvent] || {};\n      Object.keys(storeElementEvent).forEach(keyHandlers => {\n        const handlerKey = keyHandlers.replace(stripUidRegex, '');\n\n        if (!inNamespace || originalTypeEvent.includes(handlerKey)) {\n          const event = storeElementEvent[keyHandlers];\n          removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector);\n        }\n      });\n    },\n\n    trigger(element, event, args) {\n      if (typeof event !== 'string' || !element) {\n        return null;\n      }\n\n      const $ = getjQuery();\n      const typeEvent = getTypeEvent(event);\n      const inNamespace = event !== typeEvent;\n      const isNative = nativeEvents.has(typeEvent);\n      let jQueryEvent;\n      let bubbles = true;\n      let nativeDispatch = true;\n      let defaultPrevented = false;\n      let evt = null;\n\n      if (inNamespace && $) {\n        jQueryEvent = $.Event(event, args);\n        $(element).trigger(jQueryEvent);\n        bubbles = !jQueryEvent.isPropagationStopped();\n        nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();\n        defaultPrevented = jQueryEvent.isDefaultPrevented();\n      }\n\n      if (isNative) {\n        evt = document.createEvent('HTMLEvents');\n        evt.initEvent(typeEvent, bubbles, true);\n      } else {\n        evt = new CustomEvent(event, {\n          bubbles,\n          cancelable: true\n        });\n      } // merge custom information in our event\n\n\n      if (typeof args !== 'undefined') {\n        Object.keys(args).forEach(key => {\n          Object.defineProperty(evt, key, {\n            get() {\n              return args[key];\n            }\n\n          });\n        });\n      }\n\n      if (defaultPrevented) {\n        evt.preventDefault();\n      }\n\n      if (nativeDispatch) {\n        element.dispatchEvent(evt);\n      }\n\n      if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {\n        jQueryEvent.preventDefault();\n      }\n\n      return evt;\n    }\n\n  };\n\n  return EventHandler;\n\n})));\n//# sourceMappingURL=event-handler.js.map\n"],"sourceRoot":""}