{"version":3,"sources":["webpack:///./node_modules/es6-shim/es6-shim.js"],"names":["root","factory","this","ArrayIterator","_apply","Function","call","bind","apply","_call","isArray","Array","keys","Object","not","func","arguments","throwsError","e","valueOrFalseIfThrows","isCallableWithoutNew","arePropertyDescriptorsSupported","defineProperty","get","supportsDescriptors","functionsHaveNames","name","_forEach","prototype","forEach","_reduce","reduce","_filter","filter","_some","some","object","value","force","configurable","enumerable","writable","defineProperties","map","forceOverride","method","_toString","toString","isCallable","x","Value","getter","TypeError","proxy","originalObject","key","targetObject","originalDescriptor","getOwnPropertyDescriptor","set","redefine","property","newValue","descriptor","defineByDescriptor","preserveToString","target","source","create","properties","Prototype","supportsSubclassing","C","f","setPrototypeOf","Sub","Subclass","arg","o","constructor","getGlobal","self","window","global","Error","globals","globalIsFinite","isFinite","_indexOf","String","indexOf","_arrayIndexOfApply","_concat","concat","_strSlice","slice","_push","push","_pushApply","_join","join","_shift","shift","_max","Math","max","_min","min","_floor","floor","_abs","abs","_exp","exp","_log","log","_sqrt","sqrt","_hasOwnProperty","hasOwnProperty","noop","OrigMap","Map","origMapDelete","origMapGet","origMapHas","has","origMapSet","Symbol","symbolSpecies","species","numberIsNaN","Number","isNaN","numberIsFinite","_sign","sign","number","_log1p","NaN","Infinity","isStandardArguments","isLegacyArguments","length","callee","isArguments","Type","primitive","string","regex","symbol","overrideNative","replacement","original","hasSymbols","$iterator$","iterator","Set","Reflect","$String","domAll","document","all","isNullOrUndefined","ES","Call","F","V","args","IsCallable","RequireObjectCoercible","optMessage","TypeIsObject","ToObject","IsConstructor","ToInt32","ToNumber","ToUint32","ToInteger","ToLength","len","MAX_SAFE_INTEGER","SameValue","a","b","SameValueZero","IsIterable","GetIterator","itFn","GetMethod","it","p","IteratorComplete","iterResult","done","IteratorClose","completionIsThrow","returnMethod","innerResult","innerException","IteratorNext","result","next","IteratorStep","Construct","newTarget","isES6internal","construct","proto","obj","SpeciesConstructor","O","defaultConstructor","S","CreateHTML","tag","attribute","ToString","p1","escapedV","replace","p2","p3","IsRegExp","argument","isRegExp","match","defineWellKnownSymbol","sym","search","symbolSearch","originalSearch","RegExp","searchShim","regexp","searcher","symbolReplace","originalReplace","replaceValue","replaceShim","searchValue","replacer","split","symbolSplit","originalSplit","limit","splitShim","separator","splitter","symbolMatchExists","stringMatchIgnoresSymbolMatch","symbolMatch","originalMatch","matchShim","matcher","wrapConstructor","keysToSkip","getOwnPropertyNames","defaultSpeciesGetter","addDefaultSpecies","addIterator","impl","implementation","createDataProperty","createDataPropertyOrThrow","emulateES6construct","defaultNewTarget","defaultProto","slots","fromCodePoint","originalFromCodePoint","codePoints","StringShims","i","RangeError","fromCharCode","raw","template","cooked","literalSegments","nextKey","nextSeg","nextSub","stringElements","nextIndex","0","1","stringRepeat","repeat","s","times","half","stringMaxLength","StringPrototypeShims","thisStr","numTimes","startsWith","searchString","position","searchStr","start","endsWith","endPosition","pos","end","includes","codePointAt","first","charCodeAt","isEnd","second","startsWithRejectsRegex","startsWithHandlesInfinity","startsWithSupportsSymbolMatch","re","endsWithSupportsSymbolMatch","includesSupportsSymbolMatch","ws","trimRegexp","trimShim","nonWS","nonWSregex","isBadHexRegex","hasStringTrimBug","trim","iteratorResult","StringIterator","_s","_i","substr","ArrayShims","from","items","mapFn","mapping","T","usingIterator","nextValue","arrayLike","of","A","k","array","kind","retval","arrayOfSupportsSubclassing","Foo","fooArr","ArrayPrototypeShims","copyWithin","relativeTarget","relativeStart","to","relativeEnd","finalItem","count","direction","fill","find","predicate","list","thisArg","findIndex","values","entries","unscopables","originalArrayPrototypeValues","searchElement","getPrototypeOf","arrayFromSwallowsNegativeLengths","arrayFromHandlesIterables","arr","arrayFromHandlesUndefinedMapFunction","origArrayFrom","int32sAsOne","pow","toLengthsCorrectly","reversed","originalForEach","callbackFn","originalMap","originalFilter","originalSome","every","originalEvery","originalReduce","reduceRight","originalReduceRight","lacksOctalSupport","lacksBinarySupport","trimsNonWhitespace","c","OrigNumber","binaryRegex","octalRegex","isBinary","test","isOctal","toPrimitive","hint","valueOf","hasNonWS","isBadHex","NumberShim","primValue","parseInt","receiver","valueOfSucceeds","MAX_VALUE","MIN_VALUE","NEGATIVE_INFINITY","POSITIVE_INFINITY","maxSafeInteger","MIN_SAFE_INTEGER","EPSILON","parseFloat","isInteger","isSafeInteger","isEnumerableOn","propertyIsEnumerable","ensureEnumerable","prop","sliceArgs","initial","desiredArgCount","assignTo","assignReducer","symbols","sourceKeys","getOwnPropertySymbols","ObjectShims","assign","is","assignHasPendingExceptions","preventExtensions","thrower","ES5ObjectShims","magic","checkArgs","polyfill","FAKENULL","gpo","spo","objectKeysAcceptsPrimitives","originalObjectKeys","objectKeysRejectsRegex","regexRejectingObjectKeys","regexKeys","objectGOPNAcceptsPrimitives","cachedWindowNames","originalObjectGetOwnPropertyNames","val","objectGOPDAcceptsPrimitives","originalObjectGetOwnPropertyDescriptor","seal","objectSealAcceptsPrimitives","originalObjectSeal","isSealed","objectIsSealedAcceptsPrimitives","originalObjectIsSealed","freeze","objectFreezeAcceptsPrimitives","originalObjectFreeze","isFrozen","objectIsFrozenAcceptsPrimitives","originalObjectIsFrozen","objectPreventExtensionsAcceptsPrimitives","originalObjectPreventExtensions","isExtensible","objectIsExtensibleAcceptsPrimitives","originalObjectIsExtensible","objectGetProtoAcceptsPrimitives","originalGetProto","hasFlags","desc","regExpFlagsGetter","ignoreCase","multiline","unicode","sticky","regExpSupportsFlagsWithRegex","regExpNeedsToSupportSymbolMatch","regexToStringIsGeneric","regexToStringSupportsGenericFlags","flags","origRegExpToString","R","pattern","flagsGetter","sourceDesc","legacySourceGetter","sourceGetter","OrigRegExp","RegExpShim","patternIsRegExp","calledWithNew","P","$input","regexGlobals","input","lastMatch","lastParen","leftContext","rightContext","inverseEpsilon","roundTiesToEven","n","BINARY_32_EPSILON","BINARY_32_MAX_VALUE","BINARY_32_MIN_VALUE","E","LOG2E","LOG10E","numberCLZ","clz","MathShims","acosh","xInvSquared","halfX","asinh","aSquared","atanh","cbrt","negate","clz32","cosh","t","expm1","sum","hypot","y","largest","log2","log10","log1p","sinh","u","tanh","trunc","imul","ah","al","bh","bl","fround","v","withinULPDistance","expected","distance","expm1OfTen","origMathRound","round","roundHandlesBoundaryConditions","smallestPositiveNumberWhereRoundBreaks","largestPositiveNumberWhereRoundBreaks","roundDoesNotIncreaseIntegers","num","ceil","origImul","PromiseShim","setTimeout","IsPromise","promise","_promise","makeZeroTimeout","PromiseCapability","capability","resolver","resolve","reject","postMessage","timeouts","messageName","setZeroTimeout","fn","handleMessage","event","data","stopPropagation","addEventListener","Promise$prototype","Promise$prototype$then","makePromiseAsap","Promise","pr","task","then","enqueue","setImmediate","process","nextTick","PROMISE_IDENTITY","PROMISE_THROWER","PROMISE_PENDING","PROMISE_FULFILLED","PROMISE_REJECTED","PROMISE_FULFILL_OFFSET","PROMISE_REJECT_OFFSET","PROMISE_CAPABILITY_OFFSET","PROMISE_FAKE_CAPABILITY","enqueuePromiseReactionJob","handler","promiseReactionJob","promiseCapability","handlerResult","fulfillPromise","reactionLength","fulfillReactionHandler0","reactionCapability0","rejectReactions0","idx","state","rejectPromise","reason","rejectReactionHandler0","createResolvingFunctions","alreadyResolved","resolution","promiseResolveThenableJob","optimizedThen","thenable","resolvingFunctions","_promiseAllResolver","index","remaining","alreadyCalled","performPromiseAll","iteratorRecord","resultCapability","nextPromise","resolveElement","performPromiseRace","iterable","exception","ee","race","rejectFunc","resolveFunc","onRejected","onFulfilled","returnValueIsIgnored","fulfillReactionHandler","rejectReactionHandler","accept","defer","chain","promiseSupportsSubclassing","promiseIgnoresNonFunctionThenCallbacks","promiseRequiresObjectContext","promiseResolveBroken","getsThenSynchronously","BadResolverPromise","executor","hasBadResolverPromise","origAll","origRace","origResolve","origReject","r","testOrder","preservesInsertionOrder","preservesNumericInsertionOrder","fastkey","skipInsertionOrderCheck","emptyObject","addIterableToMap","MapConstructor","entry","iter","adder","nextItem","addIterableToSet","SetConstructor","add","collectionShims","empty","MapEntry","prev","isRemoved","Map$prototype","isMap","_es6map","requireMapSlot","MapIterator","head","_head","isMapIterator","MapShim","_map","_size","_storage","fkey","clear","callback","context","Set$prototype","isSet","_es6set","requireSetSlot","SetShim","decodeKey","charAt","ensureMap","m","size","hasFKey","SetIterator","entireSet","isSetIterator","isGoogleTranslate","remove","mapAcceptsArguments","testMap","mapUsesSameValueZero","mapSupportsChaining","testSet","setUsesSameValueZero","setSupportsChaining","origSetAdd","origSetHas","origSetDel","mapSupportsSubclassing","M","mapFailsToSupportSubclassing","mapRequiresNew","setSupportsSubclassing","setFailsToSupportSubclassing","setRequiresNew","OrigSet","newMap","mapIterationThrowsStopIterator","anonymousSetHas","throwUnlessTargetIsObject","ReflectShims","deleteProperty","ownKeys","callAndCatchException","internalGet","parent","internalSet","existingDesc","propertyKey","attributes","objectDotGetPrototypeOf","willCreateCircularPrototype","lastProto","defineOrOverrideReflectProperty","shim","acceptsPrimitives","originalReflectGetProto","basic","extensible","Date","dateToString","shimmedDateToString","stringHTMLshims","anchor","big","blink","bold","fixed","fontcolor","color","fontsize","italics","link","url","small","strike","sub","sup","shouldOverwrite","output","quotesCount","toLowerCase","JSONstringifiesSymbols","stringify","JSON","JSONstringifyAcceptsObjectSymbol","origStringify","replaceFn","wrappedReplacer","parsedValue"],"mappings":"kGAAA;;;;;;;;;IAYC,SAAUA,EAAMC,GAIb,IAAc,qEAJlB,CAcEC,GAAM,WACN,aAEA,IAgLIC,EAhLAC,EAASC,SAASC,KAAKC,KAAKF,SAASG,OACrCC,EAAQJ,SAASC,KAAKC,KAAKF,SAASC,MACpCI,EAAUC,MAAMD,QAChBE,EAAOC,OAAOD,KAEdE,EAAM,SAAoBC,GAC5B,OAAO,WACL,OAAQX,EAAOW,EAAMb,KAAMc,aAG3BC,EAAc,SAAUF,GAC1B,IAEE,OADAA,KACO,EACP,MAAOG,GACP,OAAO,IAGPC,EAAuB,SAA8BJ,GACvD,IACE,OAAOA,IACP,MAAOG,GACP,OAAO,IAIPE,EAAuBN,EAAIG,GAC3BI,EAAkC,WAEpC,OAAQJ,GAAY,WAClB,OAAOJ,OAAOS,eAAe,GAAI,IAAK,CAAEC,IAAK,mBAG7CC,IAAwBX,OAAOS,gBAAkBD,IACjDI,EAAkD,QAA7B,aAAoBC,KAEzCC,EAAWtB,SAASC,KAAKC,KAAKI,MAAMiB,UAAUC,SAC9CC,EAAUzB,SAASC,KAAKC,KAAKI,MAAMiB,UAAUG,QAC7CC,EAAU3B,SAASC,KAAKC,KAAKI,MAAMiB,UAAUK,QAC7CC,EAAQ7B,SAASC,KAAKC,KAAKI,MAAMiB,UAAUO,MAE3Cb,EAAiB,SAAUc,EAAQV,EAAMW,EAAOC,IAC7CA,GAASZ,KAAQU,IAClBZ,EACFX,OAAOS,eAAec,EAAQV,EAAM,CAClCa,cAAc,EACdC,YAAY,EACZC,UAAU,EACVJ,MAAOA,IAGTD,EAAOV,GAAQW,IAMfK,EAAmB,SAAUN,EAAQO,EAAKC,GAC5CjB,EAASf,EAAK+B,IAAM,SAAUjB,GAC5B,IAAImB,EAASF,EAAIjB,GACjBJ,EAAec,EAAQV,EAAMmB,IAAUD,OAIvCE,EAAYzC,SAASC,KAAKC,KAAKM,OAAOe,UAAUmB,UAChDC,EAGA,SAAwBC,GAAK,MAAoB,oBAANA,GAE3CC,EAAQ,CACVC,OAAQ,SAAUf,EAAQV,EAAMyB,GAC9B,IAAK3B,EACH,MAAM,IAAI4B,UAAU,oCAEtBvC,OAAOS,eAAec,EAAQV,EAAM,CAClCa,cAAc,EACdC,YAAY,EACZjB,IAAK4B,KAGTE,MAAO,SAAUC,EAAgBC,EAAKC,GACpC,IAAKhC,EACH,MAAM,IAAI4B,UAAU,oCAEtB,IAAIK,EAAqB5C,OAAO6C,yBAAyBJ,EAAgBC,GACzE1C,OAAOS,eAAekC,EAAcD,EAAK,CACvChB,aAAckB,EAAmBlB,aACjCC,WAAYiB,EAAmBjB,WAC/BjB,IAAK,WAAoB,OAAO+B,EAAeC,IAC/CI,IAAK,SAAgBtB,GAASiB,EAAeC,GAAOlB,MAGxDuB,SAAU,SAAUxB,EAAQyB,EAAUC,GACpC,GAAItC,EAAqB,CACvB,IAAIuC,EAAalD,OAAO6C,yBAAyBtB,EAAQyB,GACzDE,EAAW1B,MAAQyB,EACnBjD,OAAOS,eAAec,EAAQyB,EAAUE,QAExC3B,EAAOyB,GAAYC,GAGvBE,mBAAoB,SAAU5B,EAAQyB,EAAUE,GAC1CvC,EACFX,OAAOS,eAAec,EAAQyB,EAAUE,GAC/B,UAAWA,IACpB3B,EAAOyB,GAAYE,EAAW1B,QAGlC4B,iBAAkB,SAAUC,EAAQC,GAC9BA,GAAUnB,EAAWmB,EAAOpB,WAC9BzB,EAAe4C,EAAQ,WAAYC,EAAOpB,SAASxC,KAAK4D,IAAS,KAOnEC,EAASvD,OAAOuD,QAAU,SAAUxC,EAAWyC,GACjD,IAAIC,EAAY,aAChBA,EAAU1C,UAAYA,EACtB,IAAIQ,EAAS,IAAIkC,EAMjB,MAL0B,qBAAfD,GACTzD,EAAKyD,GAAYxC,SAAQ,SAAU0B,GACjCL,EAAMc,mBAAmB5B,EAAQmB,EAAKc,EAAWd,OAG9CnB,GAGLmC,EAAsB,SAAUC,EAAGC,GACrC,QAAK5D,OAAO6D,gBACLvD,GAAqB,WAC1B,IAAIwD,EAAM,SAASC,EAASC,GAC1B,IAAIC,EAAI,IAAIN,EAAEK,GAEd,OADAhE,OAAO6D,eAAeI,EAAGF,EAAShD,WAC3BkD,GAMT,OAJAjE,OAAO6D,eAAeC,EAAKH,GAC3BG,EAAI/C,UAAYwC,EAAOI,EAAE5C,UAAW,CAClCmD,YAAa,CAAE1C,MAAOsC,KAEjBF,EAAEE,OAITK,EAAY,WAKd,GAAoB,qBAATC,KAAwB,OAAOA,KAC1C,GAAsB,qBAAXC,OAA0B,OAAOA,OAC5C,GAAsB,qBAAXC,EAA0B,OAAOA,EAC5C,MAAM,IAAIC,MAAM,mCAGdC,EAAUL,IACVM,EAAiBD,EAAQE,SACzBC,EAAWnF,SAASC,KAAKC,KAAKkF,OAAO7D,UAAU8D,SAC/CC,EAAqBtF,SAASG,MAAMD,KAAKI,MAAMiB,UAAU8D,SACzDE,EAAUvF,SAASC,KAAKC,KAAKI,MAAMiB,UAAUiE,QAE7CC,EAAYzF,SAASC,KAAKC,KAAKkF,OAAO7D,UAAUmE,OAChDC,EAAQ3F,SAASC,KAAKC,KAAKI,MAAMiB,UAAUqE,MAC3CC,EAAa7F,SAASG,MAAMD,KAAKI,MAAMiB,UAAUqE,MACjDE,EAAQ9F,SAASC,KAAKC,KAAKI,MAAMiB,UAAUwE,MAC3CC,EAAShG,SAASC,KAAKC,KAAKI,MAAMiB,UAAU0E,OAC5CC,EAAOC,KAAKC,IACZC,EAAOF,KAAKG,IACZC,EAASJ,KAAKK,MACdC,EAAON,KAAKO,IACZC,EAAOR,KAAKS,IACZC,EAAOV,KAAKW,IACZC,EAAQZ,KAAKa,KACbC,EAAkBjH,SAASC,KAAKC,KAAKM,OAAOe,UAAU2F,gBAEtDC,EAAO,aAEPC,EAAUpC,EAAQqC,IAClBC,EAAgBF,GAAWA,EAAQ7F,UAAU,UAC7CgG,EAAaH,GAAWA,EAAQ7F,UAAUL,IAC1CsG,EAAaJ,GAAWA,EAAQ7F,UAAUkG,IAC1CC,EAAaN,GAAWA,EAAQ7F,UAAU+B,IAE1CqE,EAAS3C,EAAQ2C,QAAU,GAC3BC,EAAgBD,EAAOE,SAAW,YAElCC,EAAcC,OAAOC,OAAS,SAAehG,GAM/C,OAAOA,IAAUA,GAEfiG,EAAiBF,OAAO7C,UAAY,SAAkBlD,GACxD,MAAwB,kBAAVA,GAAsBiD,EAAejD,IAEjDkG,GAAQvF,EAAWwD,KAAKgC,MAAQhC,KAAKgC,KAAO,SAAcnG,GAC5D,IAAIoG,EAASL,OAAO/F,GACpB,OAAe,IAAXoG,GACAN,EAAYM,GADWA,EAEpBA,EAAS,GAAK,EAAI,GAEvBC,GAAS,SAAerG,GAC1B,IAAIY,EAAImF,OAAO/F,GACf,OAAIY,GAAK,GAAKkF,EAAYlF,GAAa0F,IAC7B,IAAN1F,GAAWA,IAAM2F,IAAmB3F,GAC7B,IAAPA,GAAoB2F,IAEhB,EAAI3F,EAAK,IAAM,EAAIA,EAAIA,GAAKiE,EAAK,EAAIjE,IAAO,EAAIA,EAAK,KAK3D4F,GAAsB,SAAqBxG,GAC7C,MAA4B,uBAArBS,EAAUT,IAEfyG,GAAoB,SAAqBzG,GAC3C,OAAiB,OAAVA,GACY,kBAAVA,GACiB,kBAAjBA,EAAM0G,QACb1G,EAAM0G,QAAU,GACK,mBAArBjG,EAAUT,IACkB,sBAA5BS,EAAUT,EAAM2G,SAEhBC,GAAcJ,GAAoB7H,WAAa6H,GAAsBC,GAErEI,GAAO,CACTC,UAAW,SAAUlG,GAAK,OAAa,OAANA,GAA4B,oBAANA,GAAiC,kBAANA,GAClFmG,OAAQ,SAAUnG,GAAK,MAAwB,oBAAjBH,EAAUG,IACxCoG,MAAO,SAAUpG,GAAK,MAAwB,oBAAjBH,EAAUG,IACvCqG,OAAQ,SAAUrG,GAChB,MAAiC,oBAAnBoC,EAAQ2C,QAAsC,kBAAN/E,IAItDsG,GAAiB,SAAwBnH,EAAQyB,EAAU2F,GAC7D,IAAIC,EAAWrH,EAAOyB,GACtBvC,EAAec,EAAQyB,EAAU2F,GAAa,GAC9CtG,EAAMe,iBAAiB7B,EAAOyB,GAAW4F,IAIvCC,GAA+B,oBAAX1B,GAAkD,oBAAlBA,EAAO,QAAyBkB,GAAKI,OAAOtB,KAOhG2B,GAAaT,GAAKI,OAAOtB,EAAO4B,UAAY5B,EAAO4B,SAAW,sBAI9DvE,EAAQwE,KAAkD,oBAApC,IAAIxE,EAAQwE,KAAM,gBAC1CF,GAAa,cAIVtE,EAAQyE,SACXxI,EAAe+D,EAAS,UAAW,IAAI,GAEzC,IAAIyE,GAAUzE,EAAQyE,QAElBC,GAAUtE,OAGVuE,GAA8B,qBAAbC,UAA6BA,SAAmBA,SAASC,IAAhB,KAC1DC,GAA8B,MAAVH,GAAiB,SAA2B/G,GAClE,OAAY,MAALA,GACL,SAA4CA,GAC9C,OAAY,MAALA,GAAaA,IAAM+G,IAGxBI,GAAK,CAEPC,KAAM,SAAcC,EAAGC,GACrB,IAAIC,EAAOxJ,UAAU+H,OAAS,EAAI/H,UAAU,GAAK,GACjD,IAAKoJ,GAAGK,WAAWH,GACjB,MAAM,IAAIlH,UAAUkH,EAAI,sBAE1B,OAAOlK,EAAOkK,EAAGC,EAAGC,IAGtBE,uBAAwB,SAAUzH,EAAG0H,GACnC,GAAIR,GAAkBlH,GACpB,MAAM,IAAIG,UAAUuH,GAAc,yBAA2B1H,GAE/D,OAAOA,GAYT2H,aAAc,SAAU3H,GACtB,YAAU,IAANA,GAAsB,OAANA,IAAoB,IAANA,IAAoB,IAANA,IAG5B,oBAANA,GAAiC,kBAANA,GAAkBA,IAAM+G,KAGnEa,SAAU,SAAU/F,EAAG6F,GACrB,OAAO9J,OAAOuJ,GAAGM,uBAAuB5F,EAAG6F,KAG7CF,WAAYzH,EAEZ8H,cAAe,SAAU7H,GAEvB,OAAOmH,GAAGK,WAAWxH,IAGvB8H,QAAS,SAAU9H,GACjB,OAAOmH,GAAGY,SAAS/H,IAAM,GAG3BgI,SAAU,SAAUhI,GAClB,OAAOmH,GAAGY,SAAS/H,KAAO,GAG5B+H,SAAU,SAAU3I,GAClB,GAAIqH,IAAmC,oBAArB5G,EAAUT,GAC1B,MAAM,IAAIe,UAAU,6CAEtB,OAAQf,GAGV6I,UAAW,SAAU7I,GACnB,IAAIoG,EAAS2B,GAAGY,SAAS3I,GACzB,OAAI8F,EAAYM,GAAkB,EACnB,IAAXA,GAAiBH,EAAeG,IAC5BA,EAAS,EAAI,GAAK,GAAK7B,EAAOE,EAAK2B,IADWA,GAIxD0C,SAAU,SAAU9I,GAClB,IAAI+I,EAAMhB,GAAGc,UAAU7I,GACvB,OAAI+I,GAAO,EAAY,EACnBA,EAAMhD,OAAOiD,iBAA2BjD,OAAOiD,iBAC5CD,GAGTE,UAAW,SAAUC,EAAGC,GACtB,OAAID,IAAMC,EAEE,IAAND,GAAkB,EAAIA,IAAM,EAAIC,EAG/BrD,EAAYoD,IAAMpD,EAAYqD,IAGvCC,cAAe,SAAUF,EAAGC,GAE1B,OAAQD,IAAMC,GAAOrD,EAAYoD,IAAMpD,EAAYqD,IAGrDE,WAAY,SAAU5G,GACpB,OAAOsF,GAAGQ,aAAa9F,KAAgC,qBAAlBA,EAAE6E,KAA+BV,GAAYnE,KAGpF6G,YAAa,SAAU7G,GACrB,GAAImE,GAAYnE,GAEd,OAAO,IAAI3E,EAAc2E,EAAG,SAE9B,IAAI8G,EAAOxB,GAAGyB,UAAU/G,EAAG6E,IAC3B,IAAKS,GAAGK,WAAWmB,GAEjB,MAAM,IAAIxI,UAAU,4BAEtB,IAAI0I,EAAK1B,GAAGC,KAAKuB,EAAM9G,GACvB,IAAKsF,GAAGQ,aAAakB,GACnB,MAAM,IAAI1I,UAAU,gBAEtB,OAAO0I,GAGTD,UAAW,SAAU/G,EAAGiH,GACtB,IAAIhL,EAAOqJ,GAAGS,SAAS/F,GAAGiH,GAC1B,IAAI5B,GAAkBpJ,GAAtB,CAGA,IAAKqJ,GAAGK,WAAW1J,GACjB,MAAM,IAAIqC,UAAU,wBAA0B2I,GAEhD,OAAOhL,IAGTiL,iBAAkB,SAAUC,GAC1B,QAASA,EAAWC,MAGtBC,cAAe,SAAUvC,EAAUwC,GACjC,IAAIC,EAAejC,GAAGyB,UAAUjC,EAAU,UAC1C,QAAqB,IAAjByC,EAAJ,CAGA,IAAIC,EAAaC,EACjB,IACED,EAAclC,GAAGC,KAAKgC,EAAczC,GACpC,MAAO1I,GACPqL,EAAiBrL,EAEnB,IAAIkL,EAAJ,CAGA,GAAIG,EACF,MAAMA,EAER,IAAKnC,GAAGQ,aAAa0B,GACnB,MAAM,IAAIlJ,UAAU,sDAIxBoJ,aAAc,SAAUV,GACtB,IAAIW,EAASzL,UAAU+H,OAAS,EAAI+C,EAAGY,KAAK1L,UAAU,IAAM8K,EAAGY,OAC/D,IAAKtC,GAAGQ,aAAa6B,GACnB,MAAM,IAAIrJ,UAAU,gBAEtB,OAAOqJ,GAGTE,aAAc,SAAUb,GACtB,IAAIW,EAASrC,GAAGoC,aAAaV,GACzBI,EAAO9B,GAAG4B,iBAAiBS,GAC/B,OAAOP,GAAeO,GAGxBG,UAAW,SAAUpI,EAAGgG,EAAMqC,EAAWC,GACvC,IAAI5I,EAA8B,qBAAd2I,EAA4BrI,EAAIqI,EAEpD,IAAKC,GAAiBhD,GAAQiD,UAE5B,OAAOjD,GAAQiD,UAAUvI,EAAGgG,EAAMtG,GAOpC,IAAI8I,EAAQ9I,EAAOtC,UACdwI,GAAGQ,aAAaoC,KACnBA,EAAQnM,OAAOe,WAEjB,IAAIqL,EAAM7I,EAAO4I,GAEbP,EAASrC,GAAGC,KAAK7F,EAAGyI,EAAKzC,GAC7B,OAAOJ,GAAGQ,aAAa6B,GAAUA,EAASQ,GAG5CC,mBAAoB,SAAUC,EAAGC,GAC/B,IAAI5I,EAAI2I,EAAEpI,YACV,QAAU,IAANP,EACF,OAAO4I,EAET,IAAKhD,GAAGQ,aAAapG,GACnB,MAAM,IAAIpB,UAAU,mBAEtB,IAAIiK,EAAI7I,EAAEyD,GACV,GAAIkC,GAAkBkD,GACpB,OAAOD,EAET,IAAKhD,GAAGU,cAAcuC,GACpB,MAAM,IAAIjK,UAAU,iBAEtB,OAAOiK,GAGTC,WAAY,SAAUlE,EAAQmE,EAAKC,EAAWnL,GAC5C,IAAIgL,EAAIjD,GAAGqD,SAASrE,GAChBsE,EAAK,IAAMH,EACf,GAAkB,KAAdC,EAAkB,CACpB,IAAIjD,EAAIH,GAAGqD,SAASpL,GAChBsL,EAAWpD,EAAEqD,QAAQ,KAAM,UAC/BF,GAAM,IAAMF,EAAY,KAAOG,EAAW,IAE5C,IAAIE,EAAKH,EAAK,IACVI,EAAKD,EAAKR,EACd,OAAOS,EAAK,KAAOP,EAAM,KAG3BQ,SAAU,SAAkBC,GAC1B,IAAK5D,GAAGQ,aAAaoD,GACnB,OAAO,EAET,IAAIC,EAAWD,EAAShG,EAAOkG,OAC/B,MAAwB,qBAAbD,IACAA,EAEJ/E,GAAKG,MAAM2E,IAGpBP,SAAU,SAAkBrE,GAC1B,GAAIM,IAAoC,oBAAtB5G,EAAUsG,GAC1B,MAAM,IAAIhG,UAAU,6CAEtB,OAAO2G,GAAQX,KAKnB,GAAI5H,GAAuBkI,GAAY,CACrC,IAAIyE,GAAwB,SAA+BzM,GACzD,GAAIwH,GAAKI,OAAOtB,EAAOtG,IACrB,OAAOsG,EAAOtG,GAGhB,IAAI0M,EAAMpG,EAAO,OAAO,UAAYtG,GAOpC,OANAb,OAAOS,eAAe0G,EAAQtG,EAAM,CAClCa,cAAc,EACdC,YAAY,EACZC,UAAU,EACVJ,MAAO+L,IAEFA,GAET,IAAKlF,GAAKI,OAAOtB,EAAOqG,QAAS,CAC/B,IAAIC,GAAeH,GAAsB,UACrCI,GAAiB9I,OAAO7D,UAAUyM,OACtC/M,EAAekN,OAAO5M,UAAW0M,IAAc,SAAgBlF,GAC7D,OAAOgB,GAAGC,KAAKkE,GAAgBnF,EAAQ,CAAClJ,UAE1C,IAAIuO,GAAa,SAAgBC,GAC/B,IAAIvB,EAAI/C,GAAGM,uBAAuBxK,MAClC,IAAKiK,GAAkBuE,GAAS,CAC9B,IAAIC,EAAWvE,GAAGyB,UAAU6C,EAAQJ,IACpC,GAAwB,qBAAbK,EACT,OAAOvE,GAAGC,KAAKsE,EAAUD,EAAQ,CAACvB,IAGtC,OAAO/C,GAAGC,KAAKkE,GAAgBpB,EAAG,CAAC/C,GAAGqD,SAASiB,MAEjDnF,GAAe9D,OAAO7D,UAAW,SAAU6M,IAE7C,IAAKvF,GAAKI,OAAOtB,EAAO4F,SAAU,CAChC,IAAIgB,GAAgBT,GAAsB,WACtCU,GAAkBpJ,OAAO7D,UAAUgM,QACvCtM,EAAekN,OAAO5M,UAAWgN,IAAe,SAAiBxF,EAAQ0F,GACvE,OAAO1E,GAAGC,KAAKwE,GAAiBzF,EAAQ,CAAClJ,KAAM4O,OAEjD,IAAIC,GAAc,SAAiBC,EAAaF,GAC9C,IAAI3B,EAAI/C,GAAGM,uBAAuBxK,MAClC,IAAKiK,GAAkB6E,GAAc,CACnC,IAAIC,EAAW7E,GAAGyB,UAAUmD,EAAaJ,IACzC,GAAwB,qBAAbK,EACT,OAAO7E,GAAGC,KAAK4E,EAAUD,EAAa,CAAC7B,EAAG2B,IAG9C,OAAO1E,GAAGC,KAAKwE,GAAiB1B,EAAG,CAAC/C,GAAGqD,SAASuB,GAAcF,KAEhEvF,GAAe9D,OAAO7D,UAAW,UAAWmN,IAE9C,IAAK7F,GAAKI,OAAOtB,EAAOkH,OAAQ,CAC9B,IAAIC,GAAchB,GAAsB,SACpCiB,GAAgB3J,OAAO7D,UAAUsN,MACrC5N,EAAekN,OAAO5M,UAAWuN,IAAa,SAAe/F,EAAQiG,GACnE,OAAOjF,GAAGC,KAAK+E,GAAehG,EAAQ,CAAClJ,KAAMmP,OAE/C,IAAIC,GAAY,SAAeC,EAAWF,GACxC,IAAIlC,EAAI/C,GAAGM,uBAAuBxK,MAClC,IAAKiK,GAAkBoF,GAAY,CACjC,IAAIC,EAAWpF,GAAGyB,UAAU0D,EAAWJ,IACvC,GAAwB,qBAAbK,EACT,OAAOpF,GAAGC,KAAKmF,EAAUD,EAAW,CAACpC,EAAGkC,IAG5C,OAAOjF,GAAGC,KAAK+E,GAAejC,EAAG,CAAC/C,GAAGqD,SAAS8B,GAAYF,KAE5D9F,GAAe9D,OAAO7D,UAAW,QAAS0N,IAE5C,IAAIG,GAAoBvG,GAAKI,OAAOtB,EAAOkG,OACvCwB,GAAgCD,IAAsB,WAGxD,IAAI3K,EAAI,GAER,OADAA,EAAEkD,EAAOkG,OAAS,WAAc,OAAO,IACf,KAAjB,IAAIA,MAAMpJ,GALsC,GAOzD,IAAK2K,IAAqBC,GAA+B,CACvD,IAAIC,GAAcxB,GAAsB,SAEpCyB,GAAgBnK,OAAO7D,UAAUsM,MACrC5M,EAAekN,OAAO5M,UAAW+N,IAAa,SAAevG,GAC3D,OAAOgB,GAAGC,KAAKuF,GAAexG,EAAQ,CAAClJ,UAGzC,IAAI2P,GAAY,SAAenB,GAC7B,IAAIvB,EAAI/C,GAAGM,uBAAuBxK,MAClC,IAAKiK,GAAkBuE,GAAS,CAC9B,IAAIoB,EAAU1F,GAAGyB,UAAU6C,EAAQiB,IACnC,GAAuB,qBAAZG,EACT,OAAO1F,GAAGC,KAAKyF,EAASpB,EAAQ,CAACvB,IAGrC,OAAO/C,GAAGC,KAAKuF,GAAezC,EAAG,CAAC/C,GAAGqD,SAASiB,MAEhDnF,GAAe9D,OAAO7D,UAAW,QAASiO,KAI9C,IAAIE,GAAkB,SAAyBtG,EAAUD,EAAawG,GACpE9M,EAAMe,iBAAiBuF,EAAaC,GAChC5I,OAAO6D,gBAET7D,OAAO6D,eAAe+E,EAAUD,GAE9BhI,EACFG,EAASd,OAAOoP,oBAAoBxG,IAAW,SAAUlG,GACnDA,KAAOiE,GAAQwI,EAAWzM,IAC9BL,EAAMG,MAAMoG,EAAUlG,EAAKiG,MAG7B7H,EAASd,OAAOD,KAAK6I,IAAW,SAAUlG,GACpCA,KAAOiE,GAAQwI,EAAWzM,KAC9BiG,EAAYjG,GAAOkG,EAASlG,OAGhCiG,EAAY5H,UAAY6H,EAAS7H,UACjCsB,EAAMU,SAAS6F,EAAS7H,UAAW,cAAe4H,IAGhD0G,GAAuB,WAAc,OAAOhQ,MAC5CiQ,GAAoB,SAAU3L,GAC5BhD,IAAwB8F,EAAgB9C,EAAGyD,IAC7C/E,EAAMC,OAAOqB,EAAGyD,EAAeiI,KAI/BE,GAAc,SAAUxO,EAAWyO,GACrC,IAAIC,EAAiBD,GAAQ,WAAsB,OAAOnQ,MAC1DoB,EAAeM,EAAW+H,GAAY2G,IACjC1O,EAAU+H,KAAeT,GAAKI,OAAOK,MAExC/H,EAAU+H,IAAc2G,IAIxBC,GAAqB,SAA4BnO,EAAQV,EAAMW,GAC7Db,EACFX,OAAOS,eAAec,EAAQV,EAAM,CAClCa,cAAc,EACdC,YAAY,EACZC,UAAU,EACVJ,MAAOA,IAGTD,EAAOV,GAAQW,GAGfmO,GAA4B,SAAmCpO,EAAQV,EAAMW,GAE/E,GADAkO,GAAmBnO,EAAQV,EAAMW,IAC5B+H,GAAGkB,UAAUlJ,EAAOV,GAAOW,GAC9B,MAAM,IAAIe,UAAU,gCAIpBqN,GAAsB,SAAU3L,EAAG4L,EAAkBC,EAAcC,GAWrE,IAAKxG,GAAGQ,aAAa9F,GACnB,MAAM,IAAI1B,UAAU,+BAAiCsN,EAAiBhP,MAExE,IAAIsL,EAAQ0D,EAAiB9O,UACxBwI,GAAGQ,aAAaoC,KACnBA,EAAQ2D,GAEV,IAAI1D,EAAM7I,EAAO4I,GACjB,IAAK,IAAItL,KAAQkP,EACf,GAAItJ,EAAgBsJ,EAAOlP,GAAO,CAChC,IAAIW,EAAQuO,EAAMlP,GAClBJ,EAAe2L,EAAKvL,EAAMW,GAAO,GAGrC,OAAO4K,GAKT,GAAIxH,OAAOoL,eAAiD,IAAhCpL,OAAOoL,cAAc9H,OAAc,CAC7D,IAAI+H,GAAwBrL,OAAOoL,cACnCtH,GAAe9D,OAAQ,iBAAiB,SAAuBsL,GAC7D,OAAO3G,GAAGC,KAAKyG,GAAuB5Q,KAAMc,cAIhD,IAAIgQ,GAAc,CAChBH,cAAe,SAAuBE,GAGpC,IAFA,IACIrE,EADAD,EAAS,GAEJwE,EAAI,EAAGlI,EAAS/H,UAAU+H,OAAQkI,EAAIlI,EAAQkI,IAAK,CAE1D,GADAvE,EAAOtE,OAAOpH,UAAUiQ,KACnB7G,GAAGkB,UAAUoB,EAAMtC,GAAGc,UAAUwB,KAAUA,EAAO,GAAKA,EAAO,QAChE,MAAM,IAAIwE,WAAW,sBAAwBxE,GAG3CA,EAAO,MACT1G,EAAMyG,EAAQhH,OAAO0L,aAAazE,KAElCA,GAAQ,MACR1G,EAAMyG,EAAQhH,OAAO0L,aAA4B,OAAdzE,GAAQ,MAC3C1G,EAAMyG,EAAQhH,OAAO0L,aAAczE,EAAO,KAAS,SAGvD,OAAOvG,EAAMsG,EAAQ,KAGvB2E,IAAK,SAAaC,GAChB,IACIC,EAASlH,GAAGS,SAASwG,EAAU,gBAC/BD,EAAMhH,GAAGS,SAASyG,EAAOF,IAAK,iBAC9BhG,EAAMgG,EAAIrI,OACVwI,EAAkBnH,GAAGe,SAASC,GAClC,GAAImG,GAAmB,EACrB,MAAO,GAGT,IAEIC,EAAS9E,EAAM+E,EAASC,EAFxBC,EAAiB,GACjBC,EAAY,EAEhB,MAAOA,EAAYL,EAAiB,CAIlC,GAHAC,EAAUpH,GAAGqD,SAASmE,GACtBH,EAAUrH,GAAGqD,SAAS2D,EAAII,IAC1BxL,EAAM2L,EAAgBF,GAClBG,EAAY,GAAKL,EACnB,MAEF7E,EAAOkF,EAAY,EAAI5Q,UAAU+H,OAAS/H,UAAU4Q,EAAY,GAAK,GACrEF,EAAUtH,GAAGqD,SAASf,GACtB1G,EAAM2L,EAAgBD,GACtBE,GAAa,EAEf,OAAOzL,EAAMwL,EAAgB,MAG7BlM,OAAO2L,KAA8D,OAAvD3L,OAAO2L,IAAI,CAAEA,IAAK,CAAES,EAAG,IAAKC,EAAG,IAAK/I,OAAQ,MAE5DQ,GAAe9D,OAAQ,MAAOuL,GAAYI,KAE5C1O,EAAiB+C,OAAQuL,IAIzB,IAAIe,GAAe,SAASC,EAAOC,EAAGC,GACpC,GAAIA,EAAQ,EAAK,MAAO,GACxB,GAAIA,EAAQ,EAAK,OAAOF,EAAOC,EAAGC,EAAQ,GAAKD,EAC/C,IAAIE,EAAOH,EAAOC,EAAGC,EAAQ,GAC7B,OAAOC,EAAOA,GAEZC,GAAkBxJ,IAElByJ,GAAuB,CACzBL,OAAQ,SAAgBE,GACtB,IAAII,EAAUlI,GAAGqD,SAASrD,GAAGM,uBAAuBxK,OAChDqS,EAAWnI,GAAGc,UAAUgH,GAC5B,GAAIK,EAAW,GAAKA,GAAYH,GAC9B,MAAM,IAAIlB,WAAW,gFAEvB,OAAOa,GAAaO,EAASC,IAG/BC,WAAY,SAAoBC,GAC9B,IAAIpF,EAAIjD,GAAGqD,SAASrD,GAAGM,uBAAuBxK,OAC9C,GAAIkK,GAAG2D,SAAS0E,GACd,MAAM,IAAIrP,UAAU,gDAEtB,IACIsP,EADAC,EAAYvI,GAAGqD,SAASgF,GAExBzR,UAAU+H,OAAS,IACrB2J,EAAW1R,UAAU,IAEvB,IAAI4R,EAAQrM,EAAK6D,GAAGc,UAAUwH,GAAW,GACzC,OAAO5M,EAAUuH,EAAGuF,EAAOA,EAAQD,EAAU5J,UAAY4J,GAG3DE,SAAU,SAAkBJ,GAC1B,IAAIpF,EAAIjD,GAAGqD,SAASrD,GAAGM,uBAAuBxK,OAC9C,GAAIkK,GAAG2D,SAAS0E,GACd,MAAM,IAAIrP,UAAU,8CAEtB,IAEI0P,EAFAH,EAAYvI,GAAGqD,SAASgF,GACxBrH,EAAMiC,EAAEtE,OAER/H,UAAU+H,OAAS,IACrB+J,EAAc9R,UAAU,IAE1B,IAAI+R,EAA6B,qBAAhBD,EAA8B1H,EAAMhB,GAAGc,UAAU4H,GAC9DE,EAAMtM,EAAKH,EAAKwM,EAAK,GAAI3H,GAC7B,OAAOtF,EAAUuH,EAAG2F,EAAML,EAAU5J,OAAQiK,KAASL,GAGvDM,SAAU,SAAkBR,GAC1B,GAAIrI,GAAG2D,SAAS0E,GACd,MAAM,IAAIrP,UAAU,uCAEtB,IACIsP,EADAC,EAAYvI,GAAGqD,SAASgF,GAM5B,OAJIzR,UAAU+H,OAAS,IACrB2J,EAAW1R,UAAU,KAGyB,IAAzCwE,EAAStF,KAAMyS,EAAWD,IAGnCQ,YAAa,SAAqBH,GAChC,IAAIT,EAAUlI,GAAGqD,SAASrD,GAAGM,uBAAuBxK,OAChDwS,EAAWtI,GAAGc,UAAU6H,GACxBhK,EAASuJ,EAAQvJ,OACrB,GAAI2J,GAAY,GAAKA,EAAW3J,EAAQ,CACtC,IAAIoK,EAAQb,EAAQc,WAAWV,GAC3BW,EAAQX,EAAW,IAAM3J,EAC7B,GAAIoK,EAAQ,OAAUA,EAAQ,OAAUE,EAAS,OAAOF,EACxD,IAAIG,EAAShB,EAAQc,WAAWV,EAAW,GAC3C,OAAIY,EAAS,OAAUA,EAAS,MAAiBH,EACtB,MAAlBA,EAAQ,QAAmBG,EAAS,OAAU,SAQ7D,GAJI7N,OAAO7D,UAAUqR,WAA4C,IAAhC,IAAIA,SAAS,IAAKrK,MACjDW,GAAe9D,OAAO7D,UAAW,WAAYyQ,GAAqBY,UAGhExN,OAAO7D,UAAU4Q,YAAc/M,OAAO7D,UAAUiR,SAAU,CAC5D,IAAIU,GAAyBtS,GAAY,WAEvC,MAAO,MAAMuR,WAAW,QAEtBgB,GAA4BrS,GAAqB,WACnD,OAA2C,IAApC,MAAMqR,WAAW,IAAK5J,QAE1B2K,IAA2BC,KAE9BjK,GAAe9D,OAAO7D,UAAW,aAAcyQ,GAAqBG,YACpEjJ,GAAe9D,OAAO7D,UAAW,WAAYyQ,GAAqBQ,WAGtE,GAAInJ,GAAY,CACd,IAAI+J,GAAgCtS,GAAqB,WACvD,IAAIuS,EAAK,IAET,OADAA,EAAG1L,EAAOkG,QAAS,EACZ,MAAMsE,WAAWkB,MAErBD,IACHlK,GAAe9D,OAAO7D,UAAW,aAAcyQ,GAAqBG,YAEtE,IAAImB,GAA8BxS,GAAqB,WACrD,IAAIuS,EAAK,IAET,OADAA,EAAG1L,EAAOkG,QAAS,EACZ,MAAM2E,SAASa,MAEnBC,IACHpK,GAAe9D,OAAO7D,UAAW,WAAYyQ,GAAqBQ,UAEpE,IAAIe,GAA8BzS,GAAqB,WACrD,IAAIuS,EAAK,IAET,OADAA,EAAG1L,EAAOkG,QAAS,EACZ,MAAM+E,SAASS,MAEnBE,IACHrK,GAAe9D,OAAO7D,UAAW,WAAYyQ,GAAqBY,UAItEvQ,EAAiB+C,OAAO7D,UAAWyQ,IAInC,IAAIwB,GAAK,CACP,qBACA,mBACA,gBACAzN,KAAK,IACH0N,GAAa,IAAItF,OAAO,MAAQqF,GAAK,SAAWA,GAAK,OAAQ,KAC7DE,GAAW,WACb,OAAO3J,GAAGqD,SAASrD,GAAGM,uBAAuBxK,OAAO0N,QAAQkG,GAAY,KAEtEE,GAAQ,CAAC,IAAU,IAAU,KAAU5N,KAAK,IAC5C6N,GAAa,IAAIzF,OAAO,IAAMwF,GAAQ,IAAK,KAC3CE,GAAgB,qBAChBC,GAAmBH,GAAMI,OAAOrL,SAAWiL,GAAMjL,OACrDzH,EAAemE,OAAO7D,UAAW,OAAQmS,GAAUI,IAKnD,IAAIE,GAAiB,SAAUpR,GAC7B,MAAO,CAAEZ,MAAOY,EAAGiJ,KAA2B,IAArBlL,UAAU+H,SAIjCuL,GAAiB,SAAUrC,GAC7B7H,GAAGM,uBAAuBuH,GAC1B/R,KAAKqU,GAAKnK,GAAGqD,SAASwE,GACtB/R,KAAKsU,GAAK,GAEZF,GAAe1S,UAAU8K,KAAO,WAC9B,IAAIuF,EAAI/R,KAAKqU,GACTtD,EAAI/Q,KAAKsU,GACb,GAAiB,qBAANvC,GAAqBhB,GAAKgB,EAAElJ,OAErC,OADA7I,KAAKqU,QAAK,EACHF,KAET,IACIf,EAAQlI,EADR+H,EAAQlB,EAAEmB,WAAWnC,GASzB,OAPIkC,EAAQ,OAAUA,EAAQ,OAAWlC,EAAI,IAAOgB,EAAElJ,OACpDqC,EAAM,GAENkI,EAASrB,EAAEmB,WAAWnC,EAAI,GAC1B7F,EAAOkI,EAAS,OAAUA,EAAS,MAAU,EAAI,GAEnDpT,KAAKsU,GAAKvD,EAAI7F,EACPiJ,GAAepC,EAAEwC,OAAOxD,EAAG7F,KAEpCgF,GAAYkE,GAAe1S,WAC3BwO,GAAY3K,OAAO7D,WAAW,WAC5B,OAAO,IAAI0S,GAAepU,SAG5B,IAAIwU,GAAa,CACfC,KAAM,SAAcC,GAClB,IACIC,EAIAC,EAASC,EALTvQ,EAAItE,KAMR,GAJIc,UAAU+H,OAAS,IACrB8L,EAAQ7T,UAAU,IAGC,qBAAV6T,EACTC,GAAU,MACL,CACL,IAAK1K,GAAGK,WAAWoK,GACjB,MAAM,IAAIzR,UAAU,qEAElBpC,UAAU+H,OAAS,IACrBgM,EAAI/T,UAAU,IAEhB8T,GAAU,EAKZ,IAEI/L,EAAQ0D,EAAQwE,EAFhB+D,EAAmF,qBAA3D/L,GAAY2L,IAAUxK,GAAGyB,UAAU+I,EAAOjL,KAGtE,GAAIqL,EAAe,CACjBvI,EAASrC,GAAGU,cAActG,GAAK3D,OAAO,IAAI2D,GAAO,GACjD,IACIkI,EAAMuI,EADNrL,EAAWQ,GAAGuB,YAAYiJ,GAG9B3D,EAAI,EACJ,MAAO,EAAM,CAEX,GADAvE,EAAOtC,GAAGuC,aAAa/C,IACV,IAAT8C,EACF,MAEFuI,EAAYvI,EAAKrK,MACjB,IACMyS,IACFG,EAAyB,qBAANF,EAAoBF,EAAMI,EAAWhE,GAAKxQ,EAAMoU,EAAOE,EAAGE,EAAWhE,IAE1FxE,EAAOwE,GAAKgE,EACZ,MAAO/T,GAEP,MADAkJ,GAAG+B,cAAcvC,GAAU,GACrB1I,EAER+P,GAAK,EAEPlI,EAASkI,MACJ,CACL,IAGI5O,EAHA6S,EAAY9K,GAAGS,SAAS+J,GAI5B,IAHA7L,EAASqB,GAAGe,SAAS+J,EAAUnM,QAC/B0D,EAASrC,GAAGU,cAActG,GAAK3D,OAAO,IAAI2D,EAAEuE,IAAW,IAAIpI,MAAMoI,GAE5DkI,EAAI,EAAGA,EAAIlI,IAAUkI,EACxB5O,EAAQ6S,EAAUjE,GACd6D,IACFzS,EAAqB,qBAAN0S,EAAoBF,EAAMxS,EAAO4O,GAAKxQ,EAAMoU,EAAOE,EAAG1S,EAAO4O,IAE9ET,GAA0B/D,EAAQwE,EAAG5O,GAKzC,OADAoK,EAAO1D,OAASA,EACT0D,GAGT0I,GAAI,WAIF,IAHA,IAAI/J,EAAMpK,UAAU+H,OAChBvE,EAAItE,KACJkV,EAAI1U,EAAQ8D,KAAO4F,GAAGK,WAAWjG,GAAK,IAAI7D,MAAMyK,GAAOhB,GAAGwC,UAAUpI,EAAG,CAAC4G,IACnEiK,EAAI,EAAGA,EAAIjK,IAAOiK,EACzB7E,GAA0B4E,EAAGC,EAAGrU,UAAUqU,IAG5C,OADAD,EAAErM,OAASqC,EACJgK,IAGX1S,EAAiB/B,MAAO+T,IACxBvE,GAAkBxP,OAIlBR,EAAgB,SAAUmV,EAAOC,GAC/BrV,KAAK+Q,EAAI,EACT/Q,KAAKoV,MAAQA,EACbpV,KAAKqV,KAAOA,GAGd7S,EAAiBvC,EAAcyB,UAAW,CACxC8K,KAAM,WACJ,IAAIuE,EAAI/Q,KAAK+Q,EACTqE,EAAQpV,KAAKoV,MACjB,KAAMpV,gBAAgBC,GACpB,MAAM,IAAIiD,UAAU,wBAEtB,GAAqB,qBAAVkS,EAAuB,CAChC,IAAIlK,EAAMhB,GAAGe,SAASmK,EAAMvM,QAC5B,GAAIkI,EAAI7F,EAAK,CAEX,IACIoK,EADAD,EAAOrV,KAAKqV,KAUhB,MARa,QAATA,EACFC,EAASvE,EACS,UAATsE,EACTC,EAASF,EAAMrE,GACG,UAATsE,IACTC,EAAS,CAACvE,EAAGqE,EAAMrE,KAErB/Q,KAAK+Q,EAAIA,EAAI,EACNoD,GAAemB,IAI1B,OADAtV,KAAKoV,WAAQ,EACNjB,QAGXjE,GAAYjQ,EAAcyB,WAgC1B,IAAI6T,GAA6B9U,MAAMwU,KAAOT,GAAWS,IAAO,WAE9D,IAAIO,EAAM,SAAatK,GAAOlL,KAAK6I,OAASqC,GAC5CsK,EAAI9T,UAAY,GAChB,IAAI+T,EAAShV,MAAMwU,GAAG3U,MAAMkV,EAAK,CAAC,EAAG,IACrC,OAAOC,aAAkBD,GAAyB,IAAlBC,EAAO5M,OALsB,GAO1D0M,IACHlM,GAAe5I,MAAO,KAAM+T,GAAWS,IAGzC,IAAIS,GAAsB,CACxBC,WAAY,SAAoB3R,EAAQ0O,GACtC,IAMII,EANAlO,EAAIsF,GAAGS,SAAS3K,MAChBkL,EAAMhB,GAAGe,SAASrG,EAAEiE,QACpB+M,EAAiB1L,GAAGc,UAAUhH,GAC9B6R,EAAgB3L,GAAGc,UAAU0H,GAC7BoD,EAAKF,EAAiB,EAAIvP,EAAK6E,EAAM0K,EAAgB,GAAKpP,EAAKoP,EAAgB1K,GAC/EuJ,EAAOoB,EAAgB,EAAIxP,EAAK6E,EAAM2K,EAAe,GAAKrP,EAAKqP,EAAe3K,GAE9EpK,UAAU+H,OAAS,IACrBiK,EAAMhS,UAAU,IAElB,IAAIiV,EAA6B,qBAARjD,EAAsB5H,EAAMhB,GAAGc,UAAU8H,GAC9DkD,EAAYD,EAAc,EAAI1P,EAAK6E,EAAM6K,EAAa,GAAKvP,EAAKuP,EAAa7K,GAC7E+K,EAAQzP,EAAKwP,EAAYvB,EAAMvJ,EAAM4K,GACrCI,EAAY,EACZzB,EAAOqB,GAAMA,EAAMrB,EAAOwB,IAC5BC,GAAa,EACbzB,GAAQwB,EAAQ,EAChBH,GAAMG,EAAQ,GAEhB,MAAOA,EAAQ,EACTxB,KAAQ7P,EACVA,EAAEkR,GAAMlR,EAAE6P,UAEH7P,EAAEkR,GAEXrB,GAAQyB,EACRJ,GAAMI,EACND,GAAS,EAEX,OAAOrR,GAGTuR,KAAM,SAAchU,GAClB,IAAIuQ,EAIAI,EAHAhS,UAAU+H,OAAS,IACrB6J,EAAQ5R,UAAU,IAGhBA,UAAU+H,OAAS,IACrBiK,EAAMhS,UAAU,IAElB,IAAImM,EAAI/C,GAAGS,SAAS3K,MAChBkL,EAAMhB,GAAGe,SAASgC,EAAEpE,QACxB6J,EAAQxI,GAAGc,UAA2B,qBAAV0H,EAAwB,EAAIA,GACxDI,EAAM5I,GAAGc,UAAyB,qBAAR8H,EAAsB5H,EAAM4H,GAKtD,IAHA,IAAI+C,EAAgBnD,EAAQ,EAAIrM,EAAK6E,EAAMwH,EAAO,GAAKlM,EAAKkM,EAAOxH,GAC/D6K,EAAcjD,EAAM,EAAI5H,EAAM4H,EAAMA,EAE/B/B,EAAI8E,EAAe9E,EAAI7F,GAAO6F,EAAIgF,IAAehF,EACxD9D,EAAE8D,GAAK5O,EAET,OAAO8K,GAGTmJ,KAAM,SAAcC,GAClB,IAAIC,EAAOpM,GAAGS,SAAS3K,MACnB6I,EAASqB,GAAGe,SAASqL,EAAKzN,QAC9B,IAAKqB,GAAGK,WAAW8L,GACjB,MAAM,IAAInT,UAAU,4CAGtB,IADA,IACgBf,EADZoU,EAAUzV,UAAU+H,OAAS,EAAI/H,UAAU,GAAK,KAC3CiQ,EAAI,EAAUA,EAAIlI,EAAQkI,IAEjC,GADA5O,EAAQmU,EAAKvF,GACTwF,GACF,GAAIhW,EAAM8V,EAAWE,EAASpU,EAAO4O,EAAGuF,GACtC,OAAOnU,OAEJ,GAAIkU,EAAUlU,EAAO4O,EAAGuF,GAC7B,OAAOnU,GAKbqU,UAAW,SAAmBH,GAC5B,IAAIC,EAAOpM,GAAGS,SAAS3K,MACnB6I,EAASqB,GAAGe,SAASqL,EAAKzN,QAC9B,IAAKqB,GAAGK,WAAW8L,GACjB,MAAM,IAAInT,UAAU,iDAGtB,IADA,IAAIqT,EAAUzV,UAAU+H,OAAS,EAAI/H,UAAU,GAAK,KAC3CiQ,EAAI,EAAGA,EAAIlI,EAAQkI,IAC1B,GAAIwF,GACF,GAAIhW,EAAM8V,EAAWE,EAASD,EAAKvF,GAAIA,EAAGuF,GACxC,OAAOvF,OAEJ,GAAIsF,EAAUC,EAAKvF,GAAIA,EAAGuF,GAC/B,OAAOvF,EAGX,OAAQ,GAGVrQ,KAAM,WACJ,OAAO,IAAIT,EAAcD,KAAM,QAGjCyW,OAAQ,WACN,OAAO,IAAIxW,EAAcD,KAAM,UAGjC0W,QAAS,WACP,OAAO,IAAIzW,EAAcD,KAAM,WAsBnC,GAjBIS,MAAMiB,UAAUhB,OAASwJ,GAAGK,WAAW,CAAC,GAAG7J,OAAO8L,cAC7C/L,MAAMiB,UAAUhB,KAErBD,MAAMiB,UAAUgV,UAAYxM,GAAGK,WAAW,CAAC,GAAGmM,UAAUlK,cACnD/L,MAAMiB,UAAUgV,QAIrBjW,MAAMiB,UAAUhB,MAAQD,MAAMiB,UAAUgV,UAAYjW,MAAMiB,UAAU+U,QAAUhW,MAAMiB,UAAU+H,MAChGjH,EAAiB/B,MAAMiB,UAAW,CAChC+U,OAAQhW,MAAMiB,UAAU+H,MAEtBT,GAAKI,OAAOtB,EAAO6O,eACrBlW,MAAMiB,UAAUoG,EAAO6O,aAAaF,QAAS,IAI7ClV,GAAsBd,MAAMiB,UAAU+U,QAA0C,WAAhChW,MAAMiB,UAAU+U,OAAOjV,KAAmB,CAC5F,IAAIoV,GAA+BnW,MAAMiB,UAAU+U,OACnDpN,GAAe5I,MAAMiB,UAAW,UAAU,WAAoB,OAAOwI,GAAGC,KAAKyM,GAA8B5W,KAAMc,cACjHM,EAAeX,MAAMiB,UAAW+H,GAAYhJ,MAAMiB,UAAU+U,QAAQ,GAEtEjU,EAAiB/B,MAAMiB,UAAWgU,IAE9B,EAAI,EAAC,GAAMlQ,SAAQ,GAAO,GAAK,GAGjCpE,EAAeX,MAAMiB,UAAW,WAAW,SAAiBmV,GAC1D,IAAI1U,EAAQsD,EAAmBzF,KAAMc,WACrC,OAAc,IAAVqB,GAAgB,EAAIA,EAAS,EACxB,EAEFA,KACN,GAGL+N,GAAYzP,MAAMiB,WAAW,WAAc,OAAO1B,KAAKyW,YAGnD9V,OAAOmW,gBACT5G,GAAYvP,OAAOmW,eAAe,GAAGL,WAIvC,IAAIM,GAAoC,WAGtC,OAAO9V,GAAqB,WAC1B,OAA6C,IAAtCR,MAAMgU,KAAK,CAAE5L,QAAS,IAAKA,UAJC,GAOnCmO,GAA6B,WAE/B,IAAIC,EAAMxW,MAAMgU,KAAK,CAAC,GAAGiC,WACzB,OAAsB,IAAfO,EAAIpO,QAAgBrI,EAAQyW,EAAI,KAAqB,IAAdA,EAAI,GAAG,IAA0B,IAAdA,EAAI,GAAG,GAH1C,GAK3BF,IAAqCC,IACxC3N,GAAe5I,MAAO,OAAQ+T,GAAWC,MAE3C,IAAIyC,GAAwC,WAG1C,OAAOjW,GAAqB,WAC1B,OAAOR,MAAMgU,KAAK,CAAC,QAAI,MAJgB,GAO3C,IAAKyC,GAAsC,CACzC,IAAIC,GAAgB1W,MAAMgU,KAC1BpL,GAAe5I,MAAO,QAAQ,SAAciU,GAC1C,OAAI5T,UAAU+H,OAAS,GAA6B,qBAAjB/H,UAAU,GACpCoJ,GAAGC,KAAKgN,GAAenX,KAAMc,WAE7BP,EAAM4W,GAAenX,KAAM0U,MAKxC,IAAI0C,KAAgB9Q,KAAK+Q,IAAI,EAAG,IAAM,GAClCC,GAAqB,SAAU3U,EAAQ4U,GACzC,IAAIxK,EAAM,CAAElE,OAAQuO,IAEpB,OADArK,EAAIwK,GAAYxK,EAAIlE,SAAW,GAAK,EAAI,IAAK,EACtC5H,GAAqB,WAM1B,OALAV,EAAMoC,EAAQoK,GAAK,WAGjB,MAAM,IAAIiE,WAAW,2BACpB,KACI,MAGX,IAAKsG,GAAmB7W,MAAMiB,UAAUC,SAAU,CAChD,IAAI6V,GAAkB/W,MAAMiB,UAAUC,QACtC0H,GAAe5I,MAAMiB,UAAW,WAAW,SAAiB+V,GAC1D,OAAOvN,GAAGC,KAAKqN,GAAiBxX,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAGlE,IAAKwW,GAAmB7W,MAAMiB,UAAUe,KAAM,CAC5C,IAAIiV,GAAcjX,MAAMiB,UAAUe,IAClC4G,GAAe5I,MAAMiB,UAAW,OAAO,SAAa+V,GAClD,OAAOvN,GAAGC,KAAKuN,GAAa1X,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAG9D,IAAKwW,GAAmB7W,MAAMiB,UAAUK,QAAS,CAC/C,IAAI4V,GAAiBlX,MAAMiB,UAAUK,OACrCsH,GAAe5I,MAAMiB,UAAW,UAAU,SAAgB+V,GACxD,OAAOvN,GAAGC,KAAKwN,GAAgB3X,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAGjE,IAAKwW,GAAmB7W,MAAMiB,UAAUO,MAAO,CAC7C,IAAI2V,GAAenX,MAAMiB,UAAUO,KACnCoH,GAAe5I,MAAMiB,UAAW,QAAQ,SAAc+V,GACpD,OAAOvN,GAAGC,KAAKyN,GAAc5X,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAG/D,IAAKwW,GAAmB7W,MAAMiB,UAAUmW,OAAQ,CAC9C,IAAIC,GAAgBrX,MAAMiB,UAAUmW,MACpCxO,GAAe5I,MAAMiB,UAAW,SAAS,SAAe+V,GACtD,OAAOvN,GAAGC,KAAK2N,GAAe9X,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAGhE,IAAKwW,GAAmB7W,MAAMiB,UAAUG,QAAS,CAC/C,IAAIkW,GAAiBtX,MAAMiB,UAAUG,OACrCwH,GAAe5I,MAAMiB,UAAW,UAAU,SAAgB+V,GACxD,OAAOvN,GAAGC,KAAK4N,GAAgB/X,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAGjE,IAAKwW,GAAmB7W,MAAMiB,UAAUsW,aAAa,GAAO,CAC1D,IAAIC,GAAsBxX,MAAMiB,UAAUsW,YAC1C3O,GAAe5I,MAAMiB,UAAW,eAAe,SAAqB+V,GAClE,OAAOvN,GAAGC,KAAK8N,GAAqBjY,KAAK6I,QAAU,EAAI7I,KAAO,GAAIc,cAItE,IAAIoX,GAAuC,IAAnBhQ,OAAO,QAC3BiQ,GAAwC,IAAnBjQ,OAAO,QAC5BkQ,GAAqBpW,EAAM8R,IAAO,SAAUuE,GAC9C,OAA6B,IAAtBnQ,OAAOmQ,EAAI,EAAIA,MAExB,GAAIH,IAAqBC,IAAsBC,GAAoB,CACjE,IAAIE,GAAapQ,OACbqQ,GAAc,aACdC,GAAa,cAEbC,GAAWF,GAAYG,KAAKrY,KAAKkY,IACjCI,GAAUH,GAAWE,KAAKrY,KAAKmY,IAC/BI,GAAc,SAAU3L,EAAG4L,GAC7B,IAAItM,EACJ,GAAyB,oBAAdU,EAAE6L,UACXvM,EAASU,EAAE6L,UACP9P,GAAKC,UAAUsD,IACjB,OAAOA,EAGX,GAA0B,oBAAfU,EAAEpK,WACX0J,EAASU,EAAEpK,WACPmG,GAAKC,UAAUsD,IACjB,OAAOA,EAGX,MAAM,IAAIrJ,UAAU,qBAElB6V,GAAWhF,GAAW2E,KAAKrY,KAAK0T,IAChCiF,GAAWhF,GAAc0E,KAAKrY,KAAK2T,IACnCiF,GAAc,WAEhB,IAAIA,EAAa,SAAgB9W,GAC/B,IAAI+W,EAEFA,EADEpY,UAAU+H,OAAS,EACTG,GAAKC,UAAU9G,GAASA,EAAQyW,GAAYzW,EAAO,UAEnD,EAEW,kBAAd+W,IACTA,EAAYhP,GAAGC,KAAK0J,GAAUqF,GAC1BT,GAASS,GACXA,EAAYC,SAASvT,EAAUsT,EAAW,GAAI,GACrCP,GAAQO,GACjBA,EAAYC,SAASvT,EAAUsT,EAAW,GAAI,IACrCH,GAASG,IAAcF,GAASE,MACzCA,EAAYzQ,MAGhB,IAAI2Q,EAAWpZ,KACXqZ,EAAkBpY,GAAqB,WAEzC,OADAqX,GAAW5W,UAAUoX,QAAQ1Y,KAAKgZ,IAC3B,KAET,OAAIA,aAAoBH,IAAeI,EAC9B,IAAIf,GAAWY,GAEjBZ,GAAWY,IAEpB,OAAOD,EA7BQ,GA+BjBpJ,GAAgByI,GAAYW,GAAY,IAExCzW,EAAiByW,GAAY,CAC3BxQ,IAAK6P,GAAW7P,IAChB6Q,UAAWhB,GAAWgB,UACtBC,UAAWjB,GAAWiB,UACtBC,kBAAmBlB,GAAWkB,kBAC9BC,kBAAmBnB,GAAWmB,oBAGhCvR,OAAS+Q,GACTjW,EAAMU,SAASyB,EAAS,SAAU8T,IAIpC,IAAIS,GAAiBpT,KAAK+Q,IAAI,EAAG,IAAM,EACvC7U,EAAiB0F,OAAQ,CACvBiD,iBAAkBuO,GAClBC,kBAAmBD,GACnBE,QAAS,qBAETT,SAAUhU,EAAQgU,SAClBU,WAAY1U,EAAQ0U,WAEpBxU,SAAU+C,EAEV0R,UAAW,SAAmB3X,GAC5B,OAAOiG,EAAejG,IAAU+H,GAAGc,UAAU7I,KAAWA,GAG1D4X,cAAe,SAAuB5X,GACpC,OAAO+F,OAAO4R,UAAU3X,IAAUyE,EAAKzE,IAAU+F,OAAOiD,kBAG1DhD,MAAOF,IAGT7G,EAAe8G,OAAQ,WAAY/C,EAAQgU,SAAUjR,OAAOiR,WAAahU,EAAQgU,UAOhC,IAA7C,CAAC,CAAE,GAAG/C,MAAK,WAAc,OAAO,MAClC/M,GAAe5I,MAAMiB,UAAW,OAAQgU,GAAoBU,MAER,IAAlD,CAAC,CAAE,GAAGI,WAAU,WAAc,OAAO,MACvCnN,GAAe5I,MAAMiB,UAAW,YAAagU,GAAoBc,WAInE,IAAIwD,GAAiB7Z,SAASE,KAAKD,KAAKD,SAASE,KAAMM,OAAOe,UAAUuY,sBACpEC,GAAmB,SAA0BnN,EAAKoN,GAChD7Y,GAAuB0Y,GAAejN,EAAKoN,IAC7CxZ,OAAOS,eAAe2L,EAAKoN,EAAM,CAAE7X,YAAY,KAG/C8X,GAAY,WAOd,IAJA,IAAIC,EAAUnS,OAAOlI,MACjBkL,EAAMpK,UAAU+H,OAChByR,EAAkBpP,EAAMmP,EACxB/P,EAAO,IAAI7J,MAAM6Z,EAAkB,EAAI,EAAIA,GACtCvJ,EAAIsJ,EAAStJ,EAAI7F,IAAO6F,EAC/BzG,EAAKyG,EAAIsJ,GAAWvZ,UAAUiQ,GAEhC,OAAOzG,GAELiQ,GAAW,SAAkBtW,GAC/B,OAAO,SAAwBD,EAAQX,GAErC,OADAW,EAAOX,GAAOY,EAAOZ,GACdW,IAGPwW,GAAgB,SAAUxW,EAAQC,GACpC,IACIwW,EADAC,EAAaha,EAAKC,OAAOsD,IAK7B,OAHIiG,GAAGK,WAAW5J,OAAOga,yBACvBF,EAAU3Y,EAAQnB,OAAOga,sBAAsBha,OAAOsD,IAAU+V,GAAe/V,KAE1ErC,EAAQ8D,EAAQgV,EAAYD,GAAW,IAAKF,GAAStW,GAASD,IAGnE4W,GAAc,CAEhBC,OAAQ,SAAU7W,EAAQC,GACxB,IAAI6R,EAAK5L,GAAGS,SAAS3G,EAAQ,8CAC7B,OAAOpC,EAAQsI,GAAGC,KAAKiQ,GAAW,EAAGtZ,WAAY0Z,GAAe1E,IAIlEgF,GAAI,SAAYzP,EAAGC,GACjB,OAAOpB,GAAGkB,UAAUC,EAAGC,KAGvByP,GAA6Bpa,OAAOka,QAAUla,OAAOqa,mBAAsB,WAG7E,IAAIC,EAAUta,OAAOqa,kBAAkB,CAAEpJ,EAAG,IAC5C,IACEjR,OAAOka,OAAOI,EAAS,MACvB,MAAOja,GACP,MAAsB,MAAfia,EAAQ,IAP2D,GAe9E,GALIF,IACF1R,GAAe1I,OAAQ,SAAUia,GAAYC,QAE/CrY,EAAiB7B,OAAQia,IAErBtZ,EAAqB,CACvB,IAAI4Z,GAAiB,CAGnB1W,eAAiB,SAAU7D,EAAQwa,GACjC,IAAI1X,EAEA2X,EAAY,SAAUnO,EAAGH,GAC3B,IAAK5C,GAAGQ,aAAauC,GACnB,MAAM,IAAI/J,UAAU,wCAEtB,GAAgB,OAAV4J,IAAkB5C,GAAGQ,aAAaoC,GACtC,MAAM,IAAI5J,UAAU,8CAAgD4J,IAIpEtI,EAAiB,SAAUyI,EAAGH,GAGhC,OAFAsO,EAAUnO,EAAGH,GACbvM,EAAMkD,EAAKwJ,EAAGH,GACPG,GAGT,IAEExJ,EAAM9C,EAAO6C,yBAAyB7C,EAAOe,UAAWyZ,GAAO1X,IAC/DlD,EAAMkD,EAAK,GAAI,MACf,MAAOzC,GACP,GAAIL,EAAOe,YAAc,GAAGyZ,GAE1B,OAGF1X,EAAM,SAAUqJ,GACd9M,KAAKmb,GAASrO,GAOhBtI,EAAe6W,SAAW7W,EACxBA,EAAe,GAAI,MACnB7D,EAAOe,qBACIf,EASf,OAAO6D,EAhDO,CAiDd7D,OAAQ,cAGZ6B,EAAiB7B,OAAQua,IAKvBva,OAAO6D,gBAAkB7D,OAAOmW,gBAC2B,OAA3DnW,OAAOmW,eAAenW,OAAO6D,eAAe,GAAI,QACD,OAA/C7D,OAAOmW,eAAenW,OAAOuD,OAAO,QACrC,WACC,IAAIoX,EAAW3a,OAAOuD,OAAO,MACzBqX,EAAM5a,OAAOmW,eACb0E,EAAM7a,OAAO6D,eACjB7D,OAAOmW,eAAiB,SAAUlS,GAChC,IAAI2H,EAASgP,EAAI3W,GACjB,OAAO2H,IAAW+O,EAAW,KAAO/O,GAEtC5L,OAAO6D,eAAiB,SAAUI,EAAGiH,GACnC,IAAIiB,EAAc,OAANjB,EAAayP,EAAWzP,EACpC,OAAO2P,EAAI5W,EAAGkI,IAEhBnM,OAAO6D,eAAe6W,UAAW,EAZnC,GAgBF,IAAII,IAA+B1a,GAAY,WAAc,OAAOJ,OAAOD,KAAK,UAChF,IAAK+a,GAA6B,CAChC,IAAIC,GAAqB/a,OAAOD,KAChC2I,GAAe1I,OAAQ,QAAQ,SAAcwB,GAC3C,OAAOuZ,GAAmBxR,GAAGS,SAASxI,OAExCzB,EAAOC,OAAOD,KAEhB,IAAIib,GAAyB5a,GAAY,WAAc,OAAOJ,OAAOD,KAAK,SAC1E,GAAIib,GAAwB,CAC1B,IAAIC,GAA2Bjb,OAAOD,KACtC2I,GAAe1I,OAAQ,QAAQ,SAAcwB,GAC3C,GAAI6G,GAAKG,MAAMhH,GAAQ,CACrB,IAAI0Z,EAAY,GAChB,IAAK,IAAI1G,KAAKhT,EACRiF,EAAgBjF,EAAOgT,IACzBrP,EAAM+V,EAAW1G,GAGrB,OAAO0G,EAET,OAAOD,GAAyBzZ,MAElCzB,EAAOC,OAAOD,KAGhB,GAAIC,OAAOoP,oBAAqB,CAC9B,IAAI+L,IAA+B/a,GAAY,WAAc,OAAOJ,OAAOoP,oBAAoB,UAC/F,IAAK+L,GAA6B,CAChC,IAAIC,GAAsC,kBAAX/W,OAAsBrE,OAAOoP,oBAAoB/K,QAAU,GACtFgX,GAAoCrb,OAAOoP,oBAC/C1G,GAAe1I,OAAQ,uBAAuB,SAA6BwB,GACzE,IAAI8Z,EAAM/R,GAAGS,SAASxI,GACtB,GAAuB,oBAAnBS,EAAUqZ,GACZ,IACE,OAAOD,GAAkCC,GACzC,MAAOjb,GAEP,OAAO0E,EAAQ,GAAIqW,IAGvB,OAAOC,GAAkCC,OAI/C,GAAItb,OAAO6C,yBAA0B,CACnC,IAAI0Y,IAA+Bnb,GAAY,WAAc,OAAOJ,OAAO6C,yBAAyB,MAAO,UAC3G,IAAK0Y,GAA6B,CAChC,IAAIC,GAAyCxb,OAAO6C,yBACpD6F,GAAe1I,OAAQ,4BAA4B,SAAkCwB,EAAOwB,GAC1F,OAAOwY,GAAuCjS,GAAGS,SAASxI,GAAQwB,OAIxE,GAAIhD,OAAOyb,KAAM,CACf,IAAIC,IAA+Btb,GAAY,WAAc,OAAOJ,OAAOyb,KAAK,UAChF,IAAKC,GAA6B,CAChC,IAAIC,GAAqB3b,OAAOyb,KAChC/S,GAAe1I,OAAQ,QAAQ,SAAcwB,GAC3C,OAAK+H,GAAGQ,aAAavI,GACdma,GAAmBna,GADYA,MAK5C,GAAIxB,OAAO4b,SAAU,CACnB,IAAIC,IAAmCzb,GAAY,WAAc,OAAOJ,OAAO4b,SAAS,UACxF,IAAKC,GAAiC,CACpC,IAAIC,GAAyB9b,OAAO4b,SACpClT,GAAe1I,OAAQ,YAAY,SAAkBwB,GACnD,OAAK+H,GAAGQ,aAAavI,IACdsa,GAAuBta,OAIpC,GAAIxB,OAAO+b,OAAQ,CACjB,IAAIC,IAAiC5b,GAAY,WAAc,OAAOJ,OAAO+b,OAAO,UACpF,IAAKC,GAA+B,CAClC,IAAIC,GAAuBjc,OAAO+b,OAClCrT,GAAe1I,OAAQ,UAAU,SAAgBwB,GAC/C,OAAK+H,GAAGQ,aAAavI,GACdya,GAAqBza,GADUA,MAK5C,GAAIxB,OAAOkc,SAAU,CACnB,IAAIC,IAAmC/b,GAAY,WAAc,OAAOJ,OAAOkc,SAAS,UACxF,IAAKC,GAAiC,CACpC,IAAIC,GAAyBpc,OAAOkc,SACpCxT,GAAe1I,OAAQ,YAAY,SAAkBwB,GACnD,OAAK+H,GAAGQ,aAAavI,IACd4a,GAAuB5a,OAIpC,GAAIxB,OAAOqa,kBAAmB,CAC5B,IAAIgC,IAA4Cjc,GAAY,WAAc,OAAOJ,OAAOqa,kBAAkB,UAC1G,IAAKgC,GAA0C,CAC7C,IAAIC,GAAkCtc,OAAOqa,kBAC7C3R,GAAe1I,OAAQ,qBAAqB,SAA2BwB,GACrE,OAAK+H,GAAGQ,aAAavI,GACd8a,GAAgC9a,GADDA,MAK5C,GAAIxB,OAAOuc,aAAc,CACvB,IAAIC,IAAuCpc,GAAY,WAAc,OAAOJ,OAAOuc,aAAa,UAChG,IAAKC,GAAqC,CACxC,IAAIC,GAA6Bzc,OAAOuc,aACxC7T,GAAe1I,OAAQ,gBAAgB,SAAsBwB,GAC3D,QAAK+H,GAAGQ,aAAavI,IACdib,GAA2Bjb,OAIxC,GAAIxB,OAAOmW,eAAgB,CACzB,IAAIuG,IAAmCtc,GAAY,WAAc,OAAOJ,OAAOmW,eAAe,UAC9F,IAAKuG,GAAiC,CACpC,IAAIC,GAAmB3c,OAAOmW,eAC9BzN,GAAe1I,OAAQ,kBAAkB,SAAwBwB,GAC/D,OAAOmb,GAAiBpT,GAAGS,SAASxI,QAK1C,IAAIob,GAAWjc,GAAwB,WACrC,IAAIkc,EAAO7c,OAAO6C,yBAAyB8K,OAAO5M,UAAW,SAC7D,OAAO8b,GAAQtT,GAAGK,WAAWiT,EAAKnc,KAFE,GAItC,GAAIC,IAAwBic,GAAU,CACpC,IAAIE,GAAoB,WACtB,IAAKvT,GAAGQ,aAAa1K,MACnB,MAAM,IAAIkD,UAAU,0DAEtB,IAAIqJ,EAAS,GAgBb,OAfIvM,KAAKiF,SACPsH,GAAU,KAERvM,KAAK0d,aACPnR,GAAU,KAERvM,KAAK2d,YACPpR,GAAU,KAERvM,KAAK4d,UACPrR,GAAU,KAERvM,KAAK6d,SACPtR,GAAU,KAELA,GAGTvJ,EAAMC,OAAOqL,OAAO5M,UAAW,QAAS+b,IAG1C,IAAIK,GAA+Bxc,GAAuBL,GAAqB,WAC7E,MAAyC,SAAlCsE,OAAO,IAAI+I,OAAO,KAAM,SAE7ByP,GAAkCvU,IAAclI,GAAwB,WAE1E,IAAI6H,EAAQ,IAEZ,OADAA,EAAMrB,EAAOkG,QAAS,EACfM,OAAOnF,KAAWA,EAJgD,GAOvE6U,GAAyB/c,GAAqB,WAChD,MAA6D,UAAtDqN,OAAO5M,UAAUmB,SAASzC,KAAK,CAAE6D,OAAQ,WAE9Cga,GAAoCD,IAA0B/c,GAAqB,WACrF,MAAuE,SAAhEqN,OAAO5M,UAAUmB,SAASzC,KAAK,CAAE6D,OAAQ,IAAKia,MAAO,SAE9D,IAAKF,KAA2BC,GAAmC,CACjE,IAAIE,GAAqB7P,OAAO5M,UAAUmB,SAC1CzB,EAAekN,OAAO5M,UAAW,YAAY,WAC3C,IAAI0c,EAAIlU,GAAGM,uBAAuBxK,MAClC,GAAIgJ,GAAKG,MAAMiV,GACb,OAAO7d,EAAM4d,GAAoBC,GAEnC,IAAIC,EAAUxU,GAAQuU,EAAEna,QACpBia,EAAQrU,GAAQuU,EAAEF,OACtB,MAAO,IAAMG,EAAU,IAAMH,KAC5B,GACHlb,EAAMe,iBAAiBuK,OAAO5M,UAAUmB,SAAUsb,IAGpD,GAAI7c,KAAyBwc,IAAgCC,IAAkC,CAC7F,IAAIO,GAAc3d,OAAO6C,yBAAyB8K,OAAO5M,UAAW,SAASL,IACzEkd,GAAa5d,OAAO6C,yBAAyB8K,OAAO5M,UAAW,WAAa,GAC5E8c,GAAqB,WAEvB,OAAOxe,KAAKiE,QAEVwa,GAAevU,GAAGK,WAAWgU,GAAWld,KAAOkd,GAAWld,IAAMmd,GAEhEE,GAAapQ,OACbqQ,GAAc,WAChB,OAAO,SAASrQ,EAAO+P,EAASH,GAC9B,IAAIU,EAAkB1U,GAAG2D,SAASwQ,GAC9BQ,EAAgB7e,gBAAgBsO,EACpC,IAAKuQ,GAAiBD,GAAoC,qBAAVV,GAAyBG,EAAQxZ,cAAgByJ,EAC/F,OAAO+P,EAGT,IAAIS,EAAIT,EACJjU,EAAI8T,EACR,OAAIlV,GAAKG,MAAMkV,IACbS,EAAI5U,GAAGC,KAAKsU,GAAcJ,GAC1BjU,EAAqB,qBAAV8T,EAAwBhU,GAAGC,KAAKmU,GAAaD,GAAWH,EAC5D,IAAI5P,EAAOwQ,EAAG1U,KACZwU,IACTE,EAAIT,EAAQpa,OACZmG,EAAqB,qBAAV8T,EAAwBG,EAAQH,MAAQA,GAE9C,IAAIQ,GAAWL,EAASH,KAlBlB,GAqBjBrO,GAAgB6O,GAAYC,GAAY,CACtCI,QAAQ,IAGVzQ,OAASqQ,GACT3b,EAAMU,SAASyB,EAAS,SAAUwZ,IAIpC,GAAIrd,EAAqB,CACvB,IAAI0d,GAAe,CACjBC,MAAO,KACPC,UAAW,KACXC,UAAW,KACXC,YAAa,KACbC,aAAc,MAEhB5d,EAASf,EAAKse,KAAe,SAAU7E,GACjCA,KAAQ7L,UAAY0Q,GAAa7E,KAAS7L,SAC5CtL,EAAMC,OAAOqL,OAAQ0Q,GAAa7E,IAAO,WACvC,OAAO7L,OAAO6L,SAKtBlK,GAAkB3B,QAElB,IAAIgR,GAAiB,EAAIpX,OAAO0R,QAC5B2F,GAAkB,SAAyBC,GAE7C,OAAQA,EAAIF,GAAkBA,IAE5BG,GAAoBnZ,KAAK+Q,IAAI,GAAI,IACjCqI,GAAsBpZ,KAAK+Q,IAAI,EAAG,MAAQ,EAAIoI,IAC9CE,GAAsBrZ,KAAK+Q,IAAI,GAAI,KACnCuI,GAAItZ,KAAKsZ,EACTC,GAAQvZ,KAAKuZ,MACbC,GAASxZ,KAAKwZ,OACdC,GAAY7X,OAAOxG,UAAUse,WAC1B9X,OAAOxG,UAAUse,IAExB,IAAIC,GAAY,CACdC,MAAO,SAAe/d,GACpB,IAAIY,EAAImF,OAAO/F,GACf,GAAI8F,EAAYlF,IAAMZ,EAAQ,EAAK,OAAOsG,IAC1C,GAAU,IAAN1F,EAAW,OAAO,EACtB,GAAIA,IAAM2F,IAAY,OAAO3F,EAE7B,IAAIod,EAAc,GAAKpd,EAAIA,GAC3B,GAAIA,EAAI,EACN,OAAOyF,GAAOzF,EAAI,EAAKmE,EAAM,EAAIiZ,GAAepd,GAElD,IAAIqd,EAAQrd,EAAI,EAChB,OAAOyF,GAAO4X,EAASlZ,EAAM,EAAIiZ,GAAeC,EAAS,GAAM,EAAIP,IAGrEQ,MAAO,SAAele,GACpB,IAAIY,EAAImF,OAAO/F,GACf,GAAU,IAANY,IAAYqC,EAAerC,GAC7B,OAAOA,EAGT,IAAIsI,EAAIzE,EAAK7D,GACTud,EAAWjV,EAAIA,EACf0G,EAAI1J,GAAMtF,GACd,OAAIsI,EAAI,EACC0G,EAAIvJ,GAAO6C,EAAKiV,GAAYpZ,EAAMoZ,EAAW,GAAK,IAEpDvO,GAAKvJ,GAAQ6C,EAAI,EAAMnE,EAAM,EAAK,EAAIoZ,GAAajV,EAAI,EAAK,GAAM,EAAIwU,KAG/EU,MAAO,SAAepe,GACpB,IAAIY,EAAImF,OAAO/F,GAEf,GAAU,IAANY,EAAW,OAAOA,EACtB,IAAW,IAAPA,EAAY,OAAQ2F,IACxB,GAAU,IAAN3F,EAAW,OAAO2F,IACtB,GAAIT,EAAYlF,IAAMA,GAAK,GAAKA,EAAI,EAClC,OAAO0F,IAGT,IAAI4C,EAAIzE,EAAK7D,GACb,OAAOsF,GAAMtF,GAAKyF,GAAO,EAAI6C,GAAK,EAAIA,IAAM,GAG9CmV,KAAM,SAAcre,GAClB,IAAIY,EAAImF,OAAO/F,GACf,GAAU,IAANY,EAAW,OAAOA,EACtB,IACIwJ,EADAkU,EAAS1d,EAAI,EAUjB,OARI0d,IAAU1d,GAAKA,GACfA,IAAM2F,IACR6D,EAAS7D,KAET6D,EAASzF,EAAKE,EAAKjE,GAAK,GAExBwJ,GAAWxJ,GAAKwJ,EAASA,GAAY,EAAIA,GAAW,GAE/CkU,GAAUlU,EAASA,GAG5BmU,MAAO,SAAeve,GAEpB,IAAIY,EAAImF,OAAO/F,GACXoG,EAAS2B,GAAGa,SAAShI,GACzB,OAAe,IAAXwF,EACK,GAEFwX,GAAY7V,GAAGC,KAAK4V,GAAWxX,GAAU,GAAK7B,EAAOM,EAAKuB,EAAS,IAAOsX,KAGnFc,KAAM,SAAcxe,GAClB,IAAIY,EAAImF,OAAO/F,GACf,GAAU,IAANY,EAAW,OAAO,EACtB,GAAIkF,EAAYlF,GAAM,OAAO0F,IAC7B,IAAKrD,EAAerC,GAAM,OAAO2F,IAEjC,IAAIkY,EAAI9Z,EAAKF,EAAK7D,GAAK,GACvB,OAAQ6d,EAAK,GAAKA,EAAIhB,GAAIA,MAAQA,GAAI,IAGxCiB,MAAO,SAAe1e,GACpB,IAAIY,EAAImF,OAAO/F,GACf,GAAIY,KAAO2F,IAAY,OAAQ,EAC/B,IAAKtD,EAAerC,IAAY,IAANA,EAAW,OAAOA,EAC5C,GAAI6D,EAAK7D,GAAK,GACZ,OAAO+D,EAAK/D,GAAK,EAInB,IAAI6d,EAAI7d,EACJ+d,EAAM,EACNtB,EAAI,EACR,MAAOsB,EAAMF,IAAME,EACjBA,GAAOF,EACPpB,GAAK,EACLoB,GAAK7d,EAAIyc,EAEX,OAAOsB,GAGTC,MAAO,SAAehe,EAAGie,GAGvB,IAFA,IAAIzU,EAAS,EACT0U,EAAU,EACLlQ,EAAI,EAAGA,EAAIjQ,UAAU+H,SAAUkI,EAAG,CACzC,IAAI5O,EAAQyE,EAAKsB,OAAOpH,UAAUiQ,KAC9BkQ,EAAU9e,GACZoK,GAAW0U,EAAU9e,GAAU8e,EAAU9e,GACzCoK,GAAU,EACV0U,EAAU9e,GAEVoK,GAAUpK,EAAQ,EAAKA,EAAQ8e,GAAY9e,EAAQ8e,GAAW9e,EAGlE,OAAO8e,IAAYvY,IAAWA,IAAWuY,EAAU/Z,EAAMqF,IAG3D2U,KAAM,SAAc/e,GAClB,OAAO6E,EAAK7E,GAAS0d,IAGvBsB,MAAO,SAAehf,GACpB,OAAO6E,EAAK7E,GAAS2d,IAGvBsB,MAAO5Y,GAEPF,KAAMD,GAENgZ,KAAM,SAAclf,GAClB,IAAIY,EAAImF,OAAO/F,GACf,IAAKiD,EAAerC,IAAY,IAANA,EAAW,OAAOA,EAE5C,IAAIsI,EAAIzE,EAAK7D,GACb,GAAIsI,EAAI,EAAG,CACT,IAAIiW,EAAIhb,KAAKua,MAAMxV,GACnB,OAAOhD,GAAMtF,GAAKue,GAAK,EAAK,GAAKA,EAAI,IAAO,EAE9C,IAAIV,EAAI9Z,EAAKuE,EAAI,GACjB,OAAOhD,GAAMtF,IAAM6d,EAAK,GAAKA,EAAIhB,GAAIA,MAAQA,GAAI,IAGnD2B,KAAM,SAAcpf,GAClB,IAAIY,EAAImF,OAAO/F,GACf,OAAI8F,EAAYlF,IAAY,IAANA,EAAkBA,EAEpCA,GAAK,GAAa,EAClBA,IAAM,IAAc,GAEhBuD,KAAKua,MAAM9d,GAAKuD,KAAKua,OAAO9d,KAAO+D,EAAK/D,GAAK+D,GAAM/D,KAG7Dye,MAAO,SAAerf,GACpB,IAAIY,EAAImF,OAAO/F,GACf,OAAOY,EAAI,GAAK2D,GAAQ3D,GAAK2D,EAAO3D,IAGtC0e,KAAM,SAAc1e,EAAGie,GAErB,IAAI3V,EAAInB,GAAGa,SAAShI,GAChBuI,EAAIpB,GAAGa,SAASiW,GAChBU,EAAMrW,IAAM,GAAM,MAClBsW,EAAS,MAAJtW,EACLuW,EAAMtW,IAAM,GAAM,MAClBuW,EAAS,MAAJvW,EAGT,OAAQqW,EAAKE,GAAUH,EAAKG,EAAOF,EAAKC,GAAQ,KAAQ,GAAK,GAG/DE,OAAQ,SAAgB/e,GACtB,IAAIgf,EAAI7Z,OAAOnF,GACf,GAAU,IAANgf,GAAWA,IAAMrZ,KAAYqZ,KAAOrZ,KAAYT,EAAY8Z,GAC9D,OAAOA,EAET,IAAIzZ,EAAOD,GAAM0Z,GACblb,EAAMD,EAAKmb,GACf,GAAIlb,EAAM8Y,GACR,OAAOrX,EAAOiX,GAAgB1Y,EAAM8Y,GAAsBF,IAAqBE,GAAsBF,GAGvG,IAAIpU,GAAK,EAAKoU,GAAoBvX,OAAO0R,SAAY/S,EACjD0F,EAASlB,GAAKA,EAAIxE,GACtB,OAAI0F,EAASmT,IAAuBzX,EAAYsE,GACvCjE,GAAOI,KAETJ,EAAOiE,IAIdyV,GAAoB,SAA2BzV,EAAQ0V,EAAUC,GACnE,OAAOtb,EAAK,EAAK2F,EAAS0V,GAAa/Z,OAAO0R,SAAWsI,GAAY,IAGvE1f,EAAiB8D,KAAM2Z,IAEvB7e,EAAekF,KAAM,OAAQ2Z,GAAUoB,KAAM/a,KAAK+a,KAAK,OAAS3Y,KAEhEtH,EAAekF,KAAM,OAAQ2Z,GAAUU,KAAMra,KAAKqa,KAAK,OAASjY,KAEhEtH,EAAekF,KAAM,QAAS2Z,GAAUmB,OAA+B,QAAxB9a,KAAK8a,OAAO,QAE3DhgB,EAAekF,KAAM,QAAS2Z,GAAUI,MAAO/Z,KAAK+Z,OAAO,QAAU/Z,KAAK+Z,MAAM,MAEhFjf,EAAekF,KAAM,QAAS2Z,GAAUI,MAAO/Z,KAAK+Z,MAAM,SAAY3X,KAEtEtH,EAAekF,KAAM,QAAS2Z,GAAUM,MAA8B,IAAvBja,KAAKia,MAAM,SAE1Dnf,EAAekF,KAAM,OAAQ2Z,GAAUsB,MAA6B,QAAvBjb,KAAKib,MAAM,QAExDngB,EAAekF,KAAM,QAAS2Z,GAAUC,MAAO5Z,KAAK4Z,MAAMhY,OAAOoR,aAAe5Q,KAEhFtH,EAAekF,KAAM,QAAS2Z,GAAUC,OAAQ8B,GAAkB1b,KAAK4Z,MAAM,EAAIhY,OAAO0R,SAAUtT,KAAKa,KAAK,EAAIe,OAAO0R,WAEvHxY,EAAekF,KAAM,OAAQ2Z,GAAUO,MAAOwB,GAAkB1b,KAAKka,KAAK,QAAS,SAEnFpf,EAAekF,KAAM,OAAQ2Z,GAAUoB,MAA6B,QAAvB/a,KAAK+a,MAAM,QAExD,IAAIc,GAAa7b,KAAKua,MAAM,IAC5Bzf,EAAekF,KAAM,QAAS2Z,GAAUY,MAAOsB,GAAa,oBAAsBA,GAAa,oBAE/F/gB,EAAekF,KAAM,QAAS2Z,GAAUc,MAAOza,KAAKya,MAAMrY,IAAUD,OAASC,KAE7E,IAAI0Z,GAAgB9b,KAAK+b,MAErBC,GAA4E,IAA3Chc,KAAK+b,MAAM,GAAOna,OAAO0R,QAAU,IACvB,IAA/CtT,KAAK+b,MAAcna,OAAO0R,QAAU,KAAxB,IAMV2I,GAAyCjD,GAAiB,EAC1DkD,GAAyC,EAAIlD,GAAkB,EAC/DmD,GAA+B,CACjCF,GACAC,IACA3K,OAAM,SAAU6K,GAChB,OAAOpc,KAAK+b,MAAMK,KAASA,KAE7BthB,EAAekF,KAAM,SAAS,SAAevD,GAC3C,IAAI4D,EAAQD,EAAO3D,GACf4f,GAAkB,IAAXhc,GAAgB,EAAIA,EAAQ,EACvC,OAAO5D,EAAI4D,EAAQ,GAAMA,EAAQgc,KAC/BL,KAAmCG,IACvCzf,EAAMe,iBAAiBuC,KAAK+b,MAAOD,IAEnC,IAAIQ,GAAWtc,KAAKmb,MACc,IAA9Bnb,KAAKmb,KAAK,WAAY,KAExBnb,KAAKmb,KAAOxB,GAAUwB,KACtBze,EAAMe,iBAAiBuC,KAAKmb,KAAMmB,KAEX,IAArBtc,KAAKmb,KAAK5Y,QAGZQ,GAAe/C,KAAM,QAAQ,SAAcvD,EAAGie,GAC5C,OAAO9W,GAAGC,KAAKyY,GAAUtc,KAAMxF,cAOnC,IAAI+hB,GAAe,WACjB,IAAIC,EAAa3d,EAAQ2d,WAEzB,GAA0B,oBAAfA,GAAmD,kBAAfA,EAA/C,CAEA5Y,GAAG6Y,UAAY,SAAUC,GACvB,QAAK9Y,GAAGQ,aAAasY,IAGW,qBAArBA,EAAQC,UAQrB,IAsBIC,EAtBAC,EAAoB,SAAU7e,GAChC,IAAK4F,GAAGU,cAActG,GACpB,MAAM,IAAIpB,UAAU,2BAEtB,IAAIkgB,EAAapjB,KACbqjB,EAAW,SAAUC,EAASC,GAChC,QAA2B,IAAvBH,EAAWE,cAA4C,IAAtBF,EAAWG,OAC9C,MAAM,IAAIrgB,UAAU,+BAEtBkgB,EAAWE,QAAUA,EACrBF,EAAWG,OAASA,GAMtB,GAHAH,EAAWE,aAAU,EACrBF,EAAWG,YAAS,EACpBH,EAAWJ,QAAU,IAAI1e,EAAE+e,IACrBnZ,GAAGK,WAAW6Y,EAAWE,WAAYpZ,GAAGK,WAAW6Y,EAAWG,QAClE,MAAM,IAAIrgB,UAAU,4BAMF,qBAAX8B,QAA0BkF,GAAGK,WAAWvF,OAAOwe,eACxDN,EAAkB,WAEhB,IAAIO,EAAW,GACXC,EAAc,uBACdC,EAAiB,SAAUC,GAC7B9d,EAAM2d,EAAUG,GAChB5e,OAAOwe,YAAYE,EAAa,MAE9BG,EAAgB,SAAUC,GAC5B,GAAIA,EAAM7f,SAAWe,QAAU8e,EAAMC,OAASL,EAAa,CAEzD,GADAI,EAAME,kBACkB,IAApBP,EAAS5a,OAAgB,OAC7B,IAAI+a,EAAKzd,EAAOsd,GAChBG,MAIJ,OADA5e,OAAOif,iBAAiB,UAAWJ,GAAe,GAC3CF,IAGX,IAsKIO,EAAmBC,EAtKnBC,EAAkB,WAKpB,IAAItF,EAAI3Z,EAAQkf,QACZC,EAAKxF,GAAKA,EAAEwE,SAAWxE,EAAEwE,UAC7B,OAAOgB,GAAM,SAAUC,GACrB,OAAOD,EAAGE,KAAKD,KAGfE,EAAUva,GAAGK,WAAWpF,EAAQuf,cAClCvf,EAAQuf,aACW,kBAAZC,GAAwBA,EAAQC,SAAWD,EAAQC,SAAWR,MACpEla,GAAGK,WAAW2Y,GAAmBA,IAAoB,SAAUqB,GAAQzB,EAAWyB,EAAM,KAGvFM,EAAmB,SAAU9hB,GAAK,OAAOA,GACzC+hB,EAAkB,SAAU9jB,GAAK,MAAMA,GACvC+jB,EAAkB,EAClBC,EAAoB,EACpBC,EAAmB,EAEnBC,EAAyB,EACzBC,EAAwB,EACxBC,EAA4B,EAE5BC,EAA0B,GAE1BC,EAA4B,SAAUC,EAASnC,EAAYtV,GAC7D2W,GAAQ,WACNe,EAAmBD,EAASnC,EAAYtV,OAIxC0X,EAAqB,SAAUD,EAASE,EAAmB3X,GAC7D,IAAI4X,EAAenhB,EACnB,GAAIkhB,IAAsBJ,EAGxB,OAAOE,EAAQzX,GAEjB,IACE4X,EAAgBH,EAAQzX,GACxBvJ,EAAIkhB,EAAkBnC,QACtB,MAAOtiB,GACP0kB,EAAgB1kB,EAChBuD,EAAIkhB,EAAkBlC,OAExBhf,EAAEmhB,IAGAC,EAAiB,SAAU3C,EAAS7gB,GACtC,IAAI8gB,EAAWD,EAAQC,SACnBpa,EAASoa,EAAS2C,eACtB,GAAI/c,EAAS,IACXyc,EACErC,EAAS4C,wBACT5C,EAAS6C,oBACT3jB,GAEF8gB,EAAS4C,6BAA0B,EACnC5C,EAAS8C,sBAAmB,EAC5B9C,EAAS6C,yBAAsB,EAC3Bjd,EAAS,GACX,IAAK,IAAIkI,EAAI,EAAGiV,EAAM,EAAGjV,EAAIlI,EAAQkI,IAAKiV,GAAO,EAC/CV,EACErC,EAAS+C,EAAMd,GACfjC,EAAS+C,EAAMZ,GACfjjB,GAEF6gB,EAAQgD,EAAMd,QAA0B,EACxClC,EAAQgD,EAAMb,QAAyB,EACvCnC,EAAQgD,EAAMZ,QAA6B,EAIjDnC,EAAS1W,OAASpK,EAClB8gB,EAASgD,MAAQjB,EACjB/B,EAAS2C,eAAiB,GAGxBM,EAAgB,SAAUlD,EAASmD,GACrC,IAAIlD,EAAWD,EAAQC,SACnBpa,EAASoa,EAAS2C,eACtB,GAAI/c,EAAS,IACXyc,EACErC,EAASmD,uBACTnD,EAAS6C,oBACTK,GAEFlD,EAAS4C,6BAA0B,EACnC5C,EAAS8C,sBAAmB,EAC5B9C,EAAS6C,yBAAsB,EAC3Bjd,EAAS,GACX,IAAK,IAAIkI,EAAI,EAAGiV,EAAM,EAAGjV,EAAIlI,EAAQkI,IAAKiV,GAAO,EAC/CV,EACErC,EAAS+C,EAAMb,GACflC,EAAS+C,EAAMZ,GACfe,GAEFnD,EAAQgD,EAAMd,QAA0B,EACxClC,EAAQgD,EAAMb,QAAyB,EACvCnC,EAAQgD,EAAMZ,QAA6B,EAIjDnC,EAAS1W,OAAS4Z,EAClBlD,EAASgD,MAAQhB,EACjBhC,EAAS2C,eAAiB,GAGxBS,EAA2B,SAAUrD,GACvC,IAAIsD,GAAkB,EAClBhD,EAAU,SAAUiD,GACtB,IAAI/B,EACJ,IAAI8B,EAAJ,CAEA,GADAA,GAAkB,EACdC,IAAevD,EACjB,OAAOkD,EAAclD,EAAS,IAAI9f,UAAU,oBAE9C,IAAKgH,GAAGQ,aAAa6b,GACnB,OAAOZ,EAAe3C,EAASuD,GAEjC,IACE/B,EAAO+B,EAAW/B,KAClB,MAAOxjB,GACP,OAAOklB,EAAclD,EAAShiB,GAEhC,IAAKkJ,GAAGK,WAAWia,GACjB,OAAOmB,EAAe3C,EAASuD,GAEjC9B,GAAQ,WACN+B,EAA0BxD,EAASuD,EAAY/B,QAG/CjB,EAAS,SAAU4C,GACrB,IAAIG,EAEJ,OADAA,GAAkB,EACXJ,EAAclD,EAASmD,IAEhC,MAAO,CAAE7C,QAASA,EAASC,OAAQA,IAGjCkD,EAAgB,SAAUjC,EAAMkC,EAAUpD,EAASC,GAKjDiB,IAASL,EACX5jB,EAAMikB,EAAMkC,EAAUpD,EAASC,EAAQ8B,GAEvC9kB,EAAMikB,EAAMkC,EAAUpD,EAASC,IAG/BiD,EAA4B,SAAUxD,EAAS0D,EAAUlC,GAC3D,IAAImC,EAAqBN,EAAyBrD,GAC9CM,EAAUqD,EAAmBrD,QAC7BC,EAASoD,EAAmBpD,OAChC,IACEkD,EAAcjC,EAAMkC,EAAUpD,EAASC,GACvC,MAAOviB,GACPuiB,EAAOviB,KAKPqjB,EAAW,WACb,IAAIxB,EAAc,SAAiBQ,GACjC,KAAMrjB,gBAAgB6iB,GACpB,MAAM,IAAI3f,UAAU,sCAEtB,GAAIlD,MAAQA,KAAKijB,SACf,MAAM,IAAI/f,UAAU,oBAGtB,IAAKgH,GAAGK,WAAW8Y,GACjB,MAAM,IAAIngB,UAAU,wBAEtB,IAAI8f,EAAUzS,GAAoBvQ,KAAM6iB,EAAaqB,EAAmB,CACtEjB,SAAU,CACR1W,YAAQ,EACR0Z,MAAOlB,EAMPa,eAAgB,EAChBC,6BAAyB,EACzBO,4BAAwB,EACxBN,yBAAqB,KAGrBa,EAAqBN,EAAyBrD,GAC9CO,EAASoD,EAAmBpD,OAChC,IACEF,EAASsD,EAAmBrD,QAASC,GACrC,MAAOviB,GACPuiB,EAAOviB,GAET,OAAOgiB,GAET,OAAOH,EApCK,GAsCdqB,EAAoBG,EAAQ3iB,UAE5B,IAAIklB,EAAsB,SAAUC,EAAOpQ,EAAQ2M,EAAY0D,GAC7D,IAAIC,GAAgB,EACpB,OAAO,SAAUhkB,GACf,IAAIgkB,IACJA,GAAgB,EAChBtQ,EAAOoQ,GAAS9jB,EACY,MAArB+jB,EAAU7Q,OAAc,CAC7B,IAAIqN,EAAUF,EAAWE,QACzBA,EAAQ7M,MAKVuQ,EAAoB,SAAUC,EAAgB3iB,EAAG4iB,GACnD,IAGI1a,EAAMuI,EAHNnJ,EAAKqb,EAAevd,SACpB+M,EAAS,GACTqQ,EAAY,CAAE7Q,MAAO,GAErB4Q,EAAQ,EACZ,MAAO,EAAM,CACX,IAEE,GADAra,EAAOtC,GAAGuC,aAAab,IACV,IAATY,EAAgB,CAClBya,EAAejb,MAAO,EACtB,MAEF+I,EAAYvI,EAAKrK,MACjB,MAAOnB,GAEP,MADAimB,EAAejb,MAAO,EAChBhL,EAERyV,EAAOoQ,QAAS,EAChB,IAAIM,EAAc7iB,EAAEgf,QAAQvO,GACxBqS,EAAiBR,EACnBC,EACApQ,EACAyQ,EACAJ,GAEFA,EAAU7Q,OAAS,EACnBwQ,EAAcU,EAAY3C,KAAM2C,EAAaC,EAAgBF,EAAiB3D,QAC9EsD,GAAS,EAEX,GAA4B,MAArBC,EAAU7Q,MAAc,CAC7B,IAAIqN,EAAU4D,EAAiB5D,QAC/BA,EAAQ7M,GAEV,OAAOyQ,EAAiBlE,SAGtBqE,EAAqB,SAAUJ,EAAgB3iB,EAAG4iB,GACpD,IACI1a,EAAMuI,EAAWoS,EADjBvb,EAAKqb,EAAevd,SAExB,MAAO,EAAM,CACX,IAEE,GADA8C,EAAOtC,GAAGuC,aAAab,IACV,IAATY,EAAgB,CAKlBya,EAAejb,MAAO,EACtB,MAEF+I,EAAYvI,EAAKrK,MACjB,MAAOnB,GAEP,MADAimB,EAAejb,MAAO,EAChBhL,EAERmmB,EAAc7iB,EAAEgf,QAAQvO,GACxB0R,EAAcU,EAAY3C,KAAM2C,EAAaD,EAAiB5D,QAAS4D,EAAiB3D,QAE1F,OAAO2D,EAAiBlE,SAmJ1B,OAhJAxgB,EAAiB6hB,EAAS,CACxBra,IAAK,SAAasd,GAChB,IAAIhjB,EAAItE,KACR,IAAKkK,GAAGQ,aAAapG,GACnB,MAAM,IAAIpB,UAAU,yBAEtB,IACIwG,EAAUud,EADV7D,EAAa,IAAID,EAAkB7e,GAEvC,IAGE,OAFAoF,EAAWQ,GAAGuB,YAAY6b,GAC1BL,EAAiB,CAAEvd,SAAUA,EAAUsC,MAAM,GACtCgb,EAAkBC,EAAgB3iB,EAAG8e,GAC5C,MAAOpiB,GACP,IAAIumB,EAAYvmB,EAChB,GAAIimB,IAAmBA,EAAejb,KACpC,IACE9B,GAAG+B,cAAcvC,GAAU,GAC3B,MAAO8d,GACPD,EAAYC,EAGhB,IAAIjE,EAASH,EAAWG,OAExB,OADAA,EAAOgE,GACAnE,EAAWJ,UAItByE,KAAM,SAAcH,GAClB,IAAIhjB,EAAItE,KACR,IAAKkK,GAAGQ,aAAapG,GACnB,MAAM,IAAIpB,UAAU,yBAEtB,IACIwG,EAAUud,EADV7D,EAAa,IAAID,EAAkB7e,GAEvC,IAGE,OAFAoF,EAAWQ,GAAGuB,YAAY6b,GAC1BL,EAAiB,CAAEvd,SAAUA,EAAUsC,MAAM,GACtCqb,EAAmBJ,EAAgB3iB,EAAG8e,GAC7C,MAAOpiB,GACP,IAAIumB,EAAYvmB,EAChB,GAAIimB,IAAmBA,EAAejb,KACpC,IACE9B,GAAG+B,cAAcvC,GAAU,GAC3B,MAAO8d,GACPD,EAAYC,EAGhB,IAAIjE,EAASH,EAAWG,OAExB,OADAA,EAAOgE,GACAnE,EAAWJ,UAItBO,OAAQ,SAAgB4C,GACtB,IAAI7hB,EAAItE,KACR,IAAKkK,GAAGQ,aAAapG,GACnB,MAAM,IAAIpB,UAAU,2BAEtB,IAAIkgB,EAAa,IAAID,EAAkB7e,GACnCojB,EAAatE,EAAWG,OAE5B,OADAmE,EAAWvB,GACJ/C,EAAWJ,SAGpBM,QAAS,SAAiBvB,GAExB,IAAIzd,EAAItE,KACR,IAAKkK,GAAGQ,aAAapG,GACnB,MAAM,IAAIpB,UAAU,2BAEtB,GAAIgH,GAAG6Y,UAAUhB,GAAI,CACnB,IAAIld,EAAckd,EAAEld,YACpB,GAAIA,IAAgBP,EAClB,OAAOyd,EAGX,IAAIqB,EAAa,IAAID,EAAkB7e,GACnCqjB,EAAcvE,EAAWE,QAE7B,OADAqE,EAAY5F,GACLqB,EAAWJ,WAItBxgB,EAAiB0hB,EAAmB,CAClC,MAAS,SAAU0D,GACjB,OAAO5nB,KAAKwkB,KAAK,KAAMoD,IAGzBpD,KAAM,SAAcqD,EAAaD,GAC/B,IAAI5E,EAAUhjB,KACd,IAAKkK,GAAG6Y,UAAUC,GAAY,MAAM,IAAI9f,UAAU,iBAClD,IACIgkB,EADA5iB,EAAI4F,GAAG8C,mBAAmBgW,EAASqB,GAEnCyD,EAAuBhnB,UAAU+H,OAAS,GAAK/H,UAAU,KAAOukB,EAElE6B,EADEY,GAAwBxjB,IAAM+f,EACbgB,EAEA,IAAIlC,EAAkB7e,GAM3C,IAGInC,EAHA4lB,EAAyB7d,GAAGK,WAAWsd,GAAeA,EAAchD,EACpEmD,EAAwB9d,GAAGK,WAAWqd,GAAcA,EAAa9C,EACjE7B,EAAWD,EAAQC,SAEvB,GAAIA,EAASgD,QAAUlB,EAAiB,CACtC,GAAgC,IAA5B9B,EAAS2C,eACX3C,EAAS4C,wBAA0BkC,EACnC9E,EAASmD,uBAAyB4B,EAClC/E,EAAS6C,oBAAsBoB,MAC1B,CACL,IAAIlB,EAAM,GAAK/C,EAAS2C,eAAiB,GACzC3C,EAAS+C,EAAMd,GAA0B6C,EACzC9E,EAAS+C,EAAMb,GAAyB6C,EACxC/E,EAAS+C,EAAMZ,GAA6B8B,EAE9CjE,EAAS2C,gBAAkB,OACtB,GAAI3C,EAASgD,QAAUjB,EAC5B7iB,EAAQ8gB,EAAS1W,OACjB+Y,EACEyC,EACAb,EACA/kB,OAEG,IAAI8gB,EAASgD,QAAUhB,EAQ5B,MAAM,IAAI/hB,UAAU,4BAPpBf,EAAQ8gB,EAAS1W,OACjB+Y,EACE0C,EACAd,EACA/kB,GAKJ,OAAO+kB,EAAiBlE,WAK5BqC,EAA0B,IAAIlC,EAAkBkB,GAChDF,EAAyBD,EAAkBM,KAEpCH,GAveS,GAiflB,GANIlf,EAAQkf,iBACHlf,EAAQkf,QAAQ4D,cAChB9iB,EAAQkf,QAAQ6D,aAChB/iB,EAAQkf,QAAQ3iB,UAAUymB,OAGR,oBAAhBtF,GAA4B,CAErCrgB,EAAiB2C,EAAS,CAAEkf,QAASxB,KAIrC,IAAIuF,GAA6B/jB,EAAoBc,EAAQkf,SAAS,SAAUlX,GAC9E,OAAOA,EAAEmW,QAAQ,IAAIkB,MAAK,yBAA2BrX,KAEnDkb,IAA0CtnB,GAAY,WACxD,OAAOoE,EAAQkf,QAAQd,OAAO,IAAIiB,KAAK,KAAM,GAAGA,KAAK,KAAMld,MAEzDghB,GAA+BvnB,GAAY,WAAc,OAAOoE,EAAQkf,QAAQjkB,KAAK,EAAGkH,MAMxFihB,GAAwB,SAAUlE,GACpC,IAAIxY,EAAIwY,EAAQf,QAAQ,GACxBzX,EAAEhH,YAAc,GAChB,IAAI8I,EAAK0W,EAAQf,QAAQzX,GACzB,IACE8B,EAAG6W,KAAK,KAAMld,GAAMkd,KAAK,KAAMld,GAC/B,MAAOtG,GACP,OAAO,EAET,OAAO6K,IAAM8B,EATY,CAUzBxI,EAAQkf,SAGNmE,GAAwBlnB,GAAwB,WAClD,IAAI2U,EAAQ,EAERyQ,EAAW/lB,OAAOS,eAAe,GAAI,OAAQ,CAAEC,IAAK,WAAc4U,GAAS,KAE/E,OADAoO,QAAQf,QAAQoD,GACC,IAAVzQ,EAL0C,GAQ/CwS,GAAqB,SAASA,EAAmBC,GACnD,IAAI7c,EAAI,IAAIwY,QAAQqE,GACpBA,EAAS,GAAG,eACZ1oB,KAAKwkB,KAAO3Y,EAAE2Y,KACdxkB,KAAK6E,YAAc4jB,GAErBA,GAAmB/mB,UAAY2iB,QAAQ3iB,UACvC+mB,GAAmBze,IAAMqa,QAAQra,IAEjC,IAAI2e,GAAwB1nB,GAAqB,WAC/C,QAASwnB,GAAmBze,IAAI,CAAC,EAAG,OAYtC,GATKoe,IAA+BC,IAC/BC,KAAgCC,IAChCC,KAAyBG,KAG5BtE,QAAUxB,GAEVxZ,GAAelE,EAAS,UAAW0d,KAEV,IAAvBwB,QAAQra,IAAInB,OAAc,CAC5B,IAAI+f,GAAUvE,QAAQra,IACtBX,GAAegb,QAAS,OAAO,SAAaiD,GAC1C,OAAOpd,GAAGC,KAAKye,GAAS5oB,KAAMc,cAGlC,GAA4B,IAAxBujB,QAAQoD,KAAK5e,OAAc,CAC7B,IAAIggB,GAAWxE,QAAQoD,KACvBpe,GAAegb,QAAS,QAAQ,SAAciD,GAC5C,OAAOpd,GAAGC,KAAK0e,GAAU7oB,KAAMc,cAGnC,GAA+B,IAA3BujB,QAAQf,QAAQza,OAAc,CAChC,IAAIigB,GAAczE,QAAQf,QAC1Bja,GAAegb,QAAS,WAAW,SAAiBthB,GAClD,OAAOmH,GAAGC,KAAK2e,GAAa9oB,KAAMc,cAGtC,GAA8B,IAA1BujB,QAAQd,OAAO1a,OAAc,CAC/B,IAAIkgB,GAAa1E,QAAQd,OACzBla,GAAegb,QAAS,UAAU,SAAgB2E,GAChD,OAAO9e,GAAGC,KAAK4e,GAAY/oB,KAAMc,cAGrCoZ,GAAiBmK,QAAS,OAC1BnK,GAAiBmK,QAAS,QAC1BnK,GAAiBmK,QAAS,WAC1BnK,GAAiBmK,QAAS,UAC1BpU,GAAkBoU,SAMpB,IAAI4E,GAAY,SAAU5d,GACxB,IAAIC,EAAI5K,EAAKkB,EAAQyJ,GAAG,SAAUzG,EAAGuQ,GAEnC,OADAvQ,EAAEuQ,IAAK,EACAvQ,IACN,KACH,OAAOyG,EAAEnF,KAAK,OAASoF,EAAEpF,KAAK,MAE5BgjB,GAA0BD,GAAU,CAAC,IAAK,IAAK,OAE/CE,GAAiCF,GAAU,CAAC,IAAK,EAAG,IAAK,IAAK,IAElE,GAAI3nB,EAAqB,CAEvB,IAAI8nB,GAAU,SAAiB/lB,EAAKgmB,GAClC,OAAKA,GAA4BH,GAG7Bjf,GAAkB5G,GACb,IAAM6G,GAAGqD,SAASlK,GACD,kBAARA,EACT,IAAMA,EACW,kBAARA,EAEX8lB,GAGE9lB,EAFE,IAAMA,EAGS,mBAARA,EACT,IAAMA,EAER,KAfE,MAkBPimB,GAAc,WAEhB,OAAO3oB,OAAOuD,OAASvD,OAAOuD,OAAO,MAAQ,IAG3CqlB,GAAmB,SAA0BC,EAAgB/mB,EAAK6kB,GACpE,GAAI9mB,EAAQ8mB,IAAate,GAAKE,OAAOoe,GACnC7lB,EAAS6lB,GAAU,SAAUmC,GAC3B,IAAKvf,GAAGQ,aAAa+e,GACnB,MAAM,IAAIvmB,UAAU,kBAAoBumB,EAAQ,2BAElDhnB,EAAIgB,IAAIgmB,EAAM,GAAIA,EAAM,YAErB,GAAInC,aAAoBkC,EAC7BjpB,EAAMipB,EAAe9nB,UAAUC,QAAS2lB,GAAU,SAAUnlB,EAAOkB,GACjEZ,EAAIgB,IAAIJ,EAAKlB,UAEV,CACL,IAAIunB,EAAMC,EACV,IAAK1f,GAAkBqd,GAAW,CAEhC,GADAqC,EAAQlnB,EAAIgB,KACPyG,GAAGK,WAAWof,GAAU,MAAM,IAAIzmB,UAAU,WACjDwmB,EAAOxf,GAAGuB,YAAY6b,GAExB,GAAoB,qBAAToC,EACT,MAAO,EAAM,CACX,IAAIld,EAAOtC,GAAGuC,aAAaid,GAC3B,IAAa,IAATld,EAAkB,MACtB,IAAIod,EAAWpd,EAAKrK,MACpB,IACE,IAAK+H,GAAGQ,aAAakf,GACnB,MAAM,IAAI1mB,UAAU,kBAAoB0mB,EAAW,2BAErDrpB,EAAMopB,EAAOlnB,EAAKmnB,EAAS,GAAIA,EAAS,IACxC,MAAO5oB,GAEP,MADAkJ,GAAG+B,cAAcyd,GAAM,GACjB1oB,MAMZ6oB,GAAmB,SAA0BC,EAAgBrmB,EAAK6jB,GACpE,GAAI9mB,EAAQ8mB,IAAate,GAAKE,OAAOoe,GACnC7lB,EAAS6lB,GAAU,SAAUnlB,GAC3BsB,EAAIsmB,IAAI5nB,WAEL,GAAImlB,aAAoBwC,EAC7BvpB,EAAMupB,EAAepoB,UAAUC,QAAS2lB,GAAU,SAAUnlB,GAC1DsB,EAAIsmB,IAAI5nB,UAEL,CACL,IAAIunB,EAAMC,EACV,IAAK1f,GAAkBqd,GAAW,CAEhC,GADAqC,EAAQlmB,EAAIsmB,KACP7f,GAAGK,WAAWof,GAAU,MAAM,IAAIzmB,UAAU,WACjDwmB,EAAOxf,GAAGuB,YAAY6b,GAExB,GAAoB,qBAAToC,EACT,MAAO,EAAM,CACX,IAAIld,EAAOtC,GAAGuC,aAAaid,GAC3B,IAAa,IAATld,EAAkB,MACtB,IAAIuI,EAAYvI,EAAKrK,MACrB,IACE5B,EAAMopB,EAAOlmB,EAAKsR,GAClB,MAAO/T,GAEP,MADAkJ,GAAG+B,cAAcyd,GAAM,GACjB1oB,MAOZgpB,GAAkB,CACpBxiB,IAAM,WAEJ,IAAIyiB,EAAQ,GAERC,EAAW,SAAkB7mB,EAAKlB,GACpCnC,KAAKqD,IAAMA,EACXrD,KAAKmC,MAAQA,EACbnC,KAAKwM,KAAO,KACZxM,KAAKmqB,KAAO,MAGdD,EAASxoB,UAAU0oB,UAAY,WAC7B,OAAOpqB,KAAKqD,MAAQ4mB,GAGtB,IAwDII,EAxDAC,EAAQ,SAAe7nB,GACzB,QAASA,EAAI8nB,SAGXC,EAAiB,SAAwB/nB,EAAKE,GAChD,IAAKuH,GAAGQ,aAAajI,KAAS6nB,EAAM7nB,GAClC,MAAM,IAAIS,UAAU,wBAA0BP,EAAS,oCAAsCuH,GAAGqD,SAAS9K,KAIzGgoB,EAAc,SAAqBhoB,EAAK4S,GAC1CmV,EAAe/nB,EAAK,mBACpBzC,KAAK0qB,KAAOjoB,EAAIkoB,MAChB3qB,KAAK+Q,EAAI/Q,KAAK0qB,KACd1qB,KAAKqV,KAAOA,GAGdoV,EAAY/oB,UAAY,CACtBkpB,eAAe,EACfpe,KAAM,WACJ,IAAKxM,KAAK4qB,cACR,MAAM,IAAI1nB,UAAU,qBAEtB,IAWIqJ,EAXAwE,EAAI/Q,KAAK+Q,EACTsE,EAAOrV,KAAKqV,KACZqV,EAAO1qB,KAAK0qB,KAChB,GAAsB,qBAAX1qB,KAAK+Q,EACd,OAAOoD,KAET,MAAOpD,EAAEqZ,aAAerZ,IAAM2Z,EAE5B3Z,EAAIA,EAAEoZ,KAIR,MAAOpZ,EAAEvE,OAASke,EAEhB,GADA3Z,EAAIA,EAAEvE,MACDuE,EAAEqZ,YASL,OAPE7d,EADW,QAAT8I,EACOtE,EAAE1N,IACO,UAATgS,EACAtE,EAAE5O,MAEF,CAAC4O,EAAE1N,IAAK0N,EAAE5O,OAErBnC,KAAK+Q,EAAIA,EACFoD,GAAe5H,GAK1B,OADAvM,KAAK+Q,OAAI,EACFoD,OAGXjE,GAAYua,EAAY/oB,WAGxB,IAAImpB,EAAU,SAASrjB,IACrB,KAAMxH,gBAAgBwH,GACpB,MAAM,IAAItE,UAAU,kCAEtB,GAAIlD,MAAQA,KAAKuqB,QACf,MAAM,IAAIrnB,UAAU,oBAEtB,IAAIT,EAAM8N,GAAoBvQ,KAAMwH,EAAK6iB,EAAe,CACtDE,SAAS,EACTI,MAAO,KACPG,KAAMvjB,EAAU,IAAIA,EAAY,KAChCwjB,MAAO,EACPC,SAAU1B,OAGRoB,EAAO,IAAIR,EAAS,KAAM,MAU9B,OAPAQ,EAAKle,KAAOke,EAAKP,KAAOO,EACxBjoB,EAAIkoB,MAAQD,EAGR5pB,UAAU+H,OAAS,GACrB0gB,GAAiB/hB,EAAK/E,EAAK3B,UAAU,IAEhC2B,GAgMT,OA9LA4nB,EAAgBQ,EAAQnpB,UAExBsB,EAAMC,OAAOonB,EAAe,QAAQ,WAClC,GAA0B,qBAAfrqB,KAAK+qB,MACd,MAAM,IAAI7nB,UAAU,0CAEtB,OAAOlD,KAAK+qB,SAGdvoB,EAAiB6nB,EAAe,CAC9BhpB,IAAK,SAAagC,GAEhB,IAAIomB,EADJe,EAAexqB,KAAM,OAErB,IAAIirB,EAAO7B,GAAQ/lB,GAAK,GACxB,GAAa,OAAT4nB,EAGF,OADAxB,EAAQzpB,KAAKgrB,SAASC,GAClBxB,EACKA,EAAMtnB,WAEb,EAGJ,GAAInC,KAAK8qB,KAGP,OADArB,EAAQ/hB,EAAWtH,KAAKJ,KAAK8qB,KAAMznB,GAC/BomB,EACKA,EAAMtnB,WAEb,EAGJ,IAAIuoB,EAAO1qB,KAAK2qB,MACZ5Z,EAAI2Z,EACR,OAAQ3Z,EAAIA,EAAEvE,QAAUke,EACtB,GAAIxgB,GAAGqB,cAAcwF,EAAE1N,IAAKA,GAC1B,OAAO0N,EAAE5O,OAKfyF,IAAK,SAAavE,GAChBmnB,EAAexqB,KAAM,OACrB,IAAIirB,EAAO7B,GAAQ/lB,GAAK,GACxB,GAAa,OAAT4nB,EAEF,MAAsC,qBAAxBjrB,KAAKgrB,SAASC,GAE9B,GAAIjrB,KAAK8qB,KAEP,OAAOnjB,EAAWvH,KAAKJ,KAAK8qB,KAAMznB,GAEpC,IAAIqnB,EAAO1qB,KAAK2qB,MACZ5Z,EAAI2Z,EACR,OAAQ3Z,EAAIA,EAAEvE,QAAUke,EACtB,GAAIxgB,GAAGqB,cAAcwF,EAAE1N,IAAKA,GAC1B,OAAO,EAGX,OAAO,GAGTI,IAAK,SAAaJ,EAAKlB,GACrBqoB,EAAexqB,KAAM,OACrB,IAEIypB,EAFAiB,EAAO1qB,KAAK2qB,MACZ5Z,EAAI2Z,EAEJO,EAAO7B,GAAQ/lB,GAAK,GACxB,GAAa,OAAT4nB,EAAe,CAEjB,GAAmC,qBAAxBjrB,KAAKgrB,SAASC,GAEvB,OADAjrB,KAAKgrB,SAASC,GAAM9oB,MAAQA,EACrBnC,KAEPypB,EAAQzpB,KAAKgrB,SAASC,GAAQ,IAAIf,EAAS7mB,EAAKlB,GAChD4O,EAAI2Z,EAAKP,UAGFnqB,KAAK8qB,OAEVnjB,EAAWvH,KAAKJ,KAAK8qB,KAAMznB,GAC7BqE,EAAWtH,KAAKJ,KAAK8qB,KAAMznB,GAAKlB,MAAQA,GAExCsnB,EAAQ,IAAIS,EAAS7mB,EAAKlB,GAC1B0F,EAAWzH,KAAKJ,KAAK8qB,KAAMznB,EAAKomB,GAChC1Y,EAAI2Z,EAAKP,OAIb,OAAQpZ,EAAIA,EAAEvE,QAAUke,EACtB,GAAIxgB,GAAGqB,cAAcwF,EAAE1N,IAAKA,GAE1B,OADA0N,EAAE5O,MAAQA,EACHnC,KAYX,OATAypB,EAAQA,GAAS,IAAIS,EAAS7mB,EAAKlB,GAC/B+H,GAAGkB,WAAW,EAAG/H,KACnBomB,EAAMpmB,IAAM,GAEdomB,EAAMjd,KAAOxM,KAAK2qB,MAClBlB,EAAMU,KAAOnqB,KAAK2qB,MAAMR,KACxBV,EAAMU,KAAK3d,KAAOid,EAClBA,EAAMjd,KAAK2d,KAAOV,EAClBzpB,KAAK+qB,OAAS,EACP/qB,MAGT,OAAU,SAAUqD,GAClBmnB,EAAexqB,KAAM,UACrB,IAAI0qB,EAAO1qB,KAAK2qB,MACZ5Z,EAAI2Z,EACJO,EAAO7B,GAAQ/lB,GAAK,GACxB,GAAa,OAAT4nB,EAAe,CAEjB,GAAmC,qBAAxBjrB,KAAKgrB,SAASC,GACvB,OAAO,EAETla,EAAI/Q,KAAKgrB,SAASC,GAAMd,YACjBnqB,KAAKgrB,SAASC,QAEhB,GAAIjrB,KAAK8qB,KAAM,CAEpB,IAAKnjB,EAAWvH,KAAKJ,KAAK8qB,KAAMznB,GAC9B,OAAO,EAET0N,EAAIrJ,EAAWtH,KAAKJ,KAAK8qB,KAAMznB,GAAK8mB,KACpC1iB,EAAcrH,KAAKJ,KAAK8qB,KAAMznB,GAGhC,OAAQ0N,EAAIA,EAAEvE,QAAUke,EACtB,GAAIxgB,GAAGqB,cAAcwF,EAAE1N,IAAKA,GAM1B,OALA0N,EAAE1N,IAAM4mB,EACRlZ,EAAE5O,MAAQ8nB,EACVlZ,EAAEoZ,KAAK3d,KAAOuE,EAAEvE,KAChBuE,EAAEvE,KAAK2d,KAAOpZ,EAAEoZ,KAChBnqB,KAAK+qB,OAAS,GACP,EAGX,OAAO,GAGTG,MAAO,WAELV,EAAexqB,KAAM,SACrBA,KAAK8qB,KAAOvjB,EAAU,IAAIA,EAAY,KACtCvH,KAAK+qB,MAAQ,EACb/qB,KAAKgrB,SAAW1B,KAChB,IAAIoB,EAAO1qB,KAAK2qB,MACZ5Z,EAAI2Z,EACJ7e,EAAIkF,EAAEvE,KACV,OAAQuE,EAAIlF,KAAO6e,EACjB3Z,EAAE1N,IAAM4mB,EACRlZ,EAAE5O,MAAQ8nB,EACVpe,EAAIkF,EAAEvE,KACNuE,EAAEvE,KAAOuE,EAAEoZ,KAAOO,EAEpBA,EAAKle,KAAOke,EAAKP,KAAOO,GAG1BhqB,KAAM,WAEJ,OADA8pB,EAAexqB,KAAM,QACd,IAAIyqB,EAAYzqB,KAAM,QAG/ByW,OAAQ,WAEN,OADA+T,EAAexqB,KAAM,UACd,IAAIyqB,EAAYzqB,KAAM,UAG/B0W,QAAS,WAEP,OADA8T,EAAexqB,KAAM,WACd,IAAIyqB,EAAYzqB,KAAM,cAG/B2B,QAAS,SAAiBwpB,GACxBX,EAAexqB,KAAM,WAGrB,IAFA,IAAIorB,EAAUtqB,UAAU+H,OAAS,EAAI/H,UAAU,GAAK,KAChD8K,EAAK5L,KAAK0W,UACL+S,EAAQ7d,EAAGY,QAASid,EAAMzd,KAAMyd,EAAQ7d,EAAGY,OAC9C4e,EACF7qB,EAAM4qB,EAAUC,EAAS3B,EAAMtnB,MAAM,GAAIsnB,EAAMtnB,MAAM,GAAInC,MAEzDmrB,EAAS1B,EAAMtnB,MAAM,GAAIsnB,EAAMtnB,MAAM,GAAInC,SAKjDkQ,GAAYma,EAAeA,EAAc3T,SAElCmU,EAjSJ,GAoSLlhB,IAAM,WACJ,IAcI0hB,EAdAC,EAAQ,SAAe7nB,GACzB,OAAOA,EAAI8nB,SAAmC,qBAAjB9nB,EAAIunB,UAE/BQ,EAAiB,SAAwB/nB,EAAKd,GAChD,IAAKuH,GAAGQ,aAAajH,KAAS6nB,EAAM7nB,GAElC,MAAM,IAAIP,UAAU,iBAAmBP,EAAS,oCAAsCuH,GAAGqD,SAAS9J,KASlGgoB,EAAU,SAAS9hB,IACrB,KAAM3J,gBAAgB2J,GACpB,MAAM,IAAIzG,UAAU,kCAEtB,GAAIlD,MAAQA,KAAKurB,QACf,MAAM,IAAIroB,UAAU,oBAEtB,IAAIO,EAAM8M,GAAoBvQ,KAAM2J,EAAK0hB,EAAe,CACtDE,SAAS,EACT,cAAe,KACfP,SAAU1B,OAEZ,IAAK7lB,EAAI8nB,QACP,MAAM,IAAIroB,UAAU,WAOtB,OAHIpC,UAAU+H,OAAS,GACrBghB,GAAiBlgB,EAAKlG,EAAK3C,UAAU,IAEhC2C,GAET4nB,EAAgBI,EAAQ/pB,UAExB,IAAIgqB,EAAY,SAAUroB,GACxB,IAAI8R,EAAI9R,EACR,GAAU,UAAN8R,EACF,OAAO,KACF,GAAU,eAANA,EAAJ,CAGL,IAAIlC,EAAQkC,EAAEwW,OAAO,GACrB,MAAc,MAAV1Y,EACKrN,EAAUuP,EAAG,GACD,MAAVlC,GACDrN,EAAUuP,EAAG,GACF,MAAVlC,EACI,UAANkC,GAGHA,IAGNyW,EAAY,SAAmBnoB,GACjC,IAAKA,EAAI,eAAgB,CACvB,IAAIooB,EAAI,IAAI7B,GAAgBxiB,IAC5B/D,EAAI,eAAiBooB,EACrBpqB,EAASf,EAAK+C,EAAIunB,WAAW,SAAU3nB,GACrC,IAAI8R,EAAIuW,EAAUroB,GAClBwoB,EAAEpoB,IAAI0R,EAAGA,MAEX1R,EAAI,eAAiBooB,EAEvBpoB,EAAIunB,SAAW,MAGjBhoB,EAAMC,OAAOwoB,EAAQ/pB,UAAW,QAAQ,WAEtC,OADA8pB,EAAexrB,KAAM,QACjBA,KAAKgrB,SACAtqB,EAAKV,KAAKgrB,UAAUniB,QAE7B+iB,EAAU5rB,MACHA,KAAK,eAAe8rB,SAG7BtpB,EAAiBipB,EAAQ/pB,UAAW,CAClCkG,IAAK,SAAavE,GAEhB,IAAI4nB,EACJ,OAFAO,EAAexrB,KAAM,OAEjBA,KAAKgrB,UAAsC,QAAzBC,EAAO7B,GAAQ/lB,MAC1BrD,KAAKgrB,SAASC,IAEzBW,EAAU5rB,MACHA,KAAK,eAAe4H,IAAIvE,KAGjC0mB,IAAK,SAAa1mB,GAEhB,IAAI4nB,EACJ,OAFAO,EAAexrB,KAAM,OAEjBA,KAAKgrB,UAAsC,QAAzBC,EAAO7B,GAAQ/lB,KACnCrD,KAAKgrB,SAASC,IAAQ,EACfjrB,OAET4rB,EAAU5rB,MACVA,KAAK,eAAeyD,IAAIJ,EAAKA,GACtBrD,OAGT,OAAU,SAAUqD,GAElB,IAAI4nB,EACJ,GAFAO,EAAexrB,KAAM,UAEjBA,KAAKgrB,UAAsC,QAAzBC,EAAO7B,GAAQ/lB,IAAgB,CACnD,IAAI0oB,EAAU3kB,EAAgBpH,KAAKgrB,SAAUC,GAC7C,cAAejrB,KAAKgrB,SAASC,IAAUc,EAGzC,OADAH,EAAU5rB,MACHA,KAAK,eAAe,UAAUqD,IAGvC6nB,MAAO,WACLM,EAAexrB,KAAM,SACjBA,KAAKgrB,WACPhrB,KAAKgrB,SAAW1B,MAEdtpB,KAAK,gBACPA,KAAK,eAAekrB,SAIxBzU,OAAQ,WAGN,OAFA+U,EAAexrB,KAAM,UACrB4rB,EAAU5rB,MACH,IAAIgsB,EAAYhsB,KAAK,eAAeyW,WAG7CC,QAAS,WAGP,OAFA8U,EAAexrB,KAAM,WACrB4rB,EAAU5rB,MACH,IAAIgsB,EAAYhsB,KAAK,eAAe0W,YAG7C/U,QAAS,SAAiBwpB,GACxBK,EAAexrB,KAAM,WACrB,IAAIorB,EAAUtqB,UAAU+H,OAAS,EAAI/H,UAAU,GAAK,KAChDmrB,EAAYjsB,KAChB4rB,EAAUK,GACVjsB,KAAK,eAAe2B,SAAQ,SAAUQ,EAAOkB,GACvC+nB,EACF7qB,EAAM4qB,EAAUC,EAAS/nB,EAAKA,EAAK4oB,GAEnCd,EAAS9nB,EAAKA,EAAK4oB,SAK3B7qB,EAAeqqB,EAAQ/pB,UAAW,OAAQ+pB,EAAQ/pB,UAAU+U,QAAQ,GACpEvG,GAAYub,EAAQ/pB,UAAW+pB,EAAQ/pB,UAAU+U,QAEjD,IAAIuV,EAAc,SAAqBpgB,GACrC5L,KAAK4L,GAAKA,GAaZ,OAXAogB,EAAYtqB,UAAY,CACtBwqB,eAAe,EACf1f,KAAM,WACJ,IAAKxM,KAAKksB,cACR,MAAM,IAAIhpB,UAAU,qBAEtB,OAAOlD,KAAK4L,GAAGY,SAGnB0D,GAAY8b,EAAYtqB,WAEjB+pB,EAxKJ,IA4KHU,GAAoBhnB,EAAQwE,MAAQA,IAAIjI,UAAU,WAAaiI,IAAIjI,UAAU0qB,QAAUziB,IAAIjI,UAAUgT,OAAS/K,IAAIjI,UAAUe,KAAOhC,MAAMD,SAAQ,IAAImJ,KAAMjJ,MAM/J,GALIyrB,KAGFhnB,EAAQwE,IAAMqgB,GAAgBrgB,KAE5BxE,EAAQqC,KAAOrC,EAAQwE,IAAK,CAE9B,IAAI0iB,GAAsBprB,GAAqB,WAAc,OAAoC,IAA7B,IAAIuG,IAAI,CAAC,CAAC,EAAG,KAAKnG,IAAI,MACrFgrB,KACHlnB,EAAQqC,IAAM,SAASA,IACrB,KAAMxH,gBAAgBwH,GACpB,MAAM,IAAItE,UAAU,kCAEtB,IAAI2oB,EAAI,IAAItkB,EAMZ,OALIzG,UAAU+H,OAAS,GACrB0gB,GAAiB/hB,EAAKqkB,EAAG/qB,UAAU,WAE9B+qB,EAAEhnB,YACTlE,OAAO6D,eAAeqnB,EAAG1mB,EAAQqC,IAAI9F,WAC9BmqB,GAET1mB,EAAQqC,IAAI9F,UAAYwC,EAAOqD,EAAQ7F,WACvCN,EAAe+D,EAAQqC,IAAI9F,UAAW,cAAeyD,EAAQqC,KAAK,GAClExE,EAAMe,iBAAiBoB,EAAQqC,IAAKD,IAEtC,IAAI+kB,GAAU,IAAI9kB,IACd+kB,GAAwB,WAE1B,IAAIV,EAAI,IAAIrkB,IAAI,CAAC,CAAC,EAAG,GAAI,CAAC,EAAG,GAAI,CAAC,EAAG,GAAI,CAAC,EAAG,KAE7C,OADAqkB,EAAEpoB,KAAK,EAAGooB,GACHA,EAAExqB,IAAI,KAAOwqB,GAAKA,EAAExqB,KAAK,KAAOwqB,GAAKA,EAAEjkB,IAAI,IAAMikB,EAAEjkB,KAAK,GAJtC,GAMvB4kB,GAAsBF,GAAQ7oB,IAAI,EAAG,KAAO6oB,GAC3CC,IAAyBC,IAC5BnjB,GAAe7B,IAAI9F,UAAW,OAAO,SAAayT,EAAG4M,GAEnD,OADAxhB,EAAMsH,EAAY7H,KAAY,IAANmV,EAAU,EAAIA,EAAG4M,GAClC/hB,QAGNusB,KACH/pB,EAAiBgF,IAAI9F,UAAW,CAC9BL,IAAK,SAAa8T,GAChB,OAAO5U,EAAMmH,EAAY1H,KAAY,IAANmV,EAAU,EAAIA,IAE/CvN,IAAK,SAAauN,GAChB,OAAO5U,EAAMoH,EAAY3H,KAAY,IAANmV,EAAU,EAAIA,MAE9C,GACHnS,EAAMe,iBAAiByD,IAAI9F,UAAUL,IAAKqG,GAC1C1E,EAAMe,iBAAiByD,IAAI9F,UAAUkG,IAAKD,IAE5C,IAAI8kB,GAAU,IAAI9iB,IACd+iB,GAAuB/iB,IAAIjI,UAAU,WAAaiI,IAAIjI,UAAUqoB,KAAOpgB,IAAIjI,UAAUkG,KAAQ,SAAUmK,GAGzG,OAFAA,EAAE,UAAU,GACZA,EAAEgY,KAAK,IACChY,EAAEnK,IAAI,GAHgF,CAI9F6kB,IACEE,GAAsBF,GAAQ1C,IAAI,KAAO0C,GAC7C,IAAKC,KAAyBC,GAAqB,CACjD,IAAIC,GAAajjB,IAAIjI,UAAUqoB,IAC/BpgB,IAAIjI,UAAUqoB,IAAM,SAAahI,GAE/B,OADAxhB,EAAMqsB,GAAY5sB,KAAY,IAAN+hB,EAAU,EAAIA,GAC/B/hB,MAETgD,EAAMe,iBAAiB4F,IAAIjI,UAAUqoB,IAAK6C,IAE5C,IAAKF,GAAsB,CACzB,IAAIG,GAAaljB,IAAIjI,UAAUkG,IAC/B+B,IAAIjI,UAAUkG,IAAM,SAAama,GAC/B,OAAOxhB,EAAMssB,GAAY7sB,KAAY,IAAN+hB,EAAU,EAAIA,IAE/C/e,EAAMe,iBAAiB4F,IAAIjI,UAAUkG,IAAKilB,IAC1C,IAAIC,GAAanjB,IAAIjI,UAAU,UAC/BiI,IAAIjI,UAAU,UAAY,SAAmBqgB,GAC3C,OAAOxhB,EAAMusB,GAAY9sB,KAAY,IAAN+hB,EAAU,EAAIA,IAE/C/e,EAAMe,iBAAiB4F,IAAIjI,UAAU,UAAWorB,IAElD,IAAIC,GAAyB1oB,EAAoBc,EAAQqC,KAAK,SAAUwlB,GACtE,IAAInB,EAAI,IAAImB,EAAE,IAId,OADAnB,EAAEpoB,IAAI,GAAI,IACHooB,aAAamB,KAGlBC,GAA+BtsB,OAAO6D,iBAAmBuoB,GACzDG,GAAkB,WACpB,IACE,QAAS/nB,EAAQqC,gBAAiBrC,EAAQqC,KAC1C,MAAOxG,GACP,OAAOA,aAAakC,WAJH,GAOM,IAAvBiC,EAAQqC,IAAIqB,SAAgBokB,IAAiCC,KAC/D/nB,EAAQqC,IAAM,SAASA,IACrB,KAAMxH,gBAAgBwH,GACpB,MAAM,IAAItE,UAAU,kCAEtB,IAAI2oB,EAAI,IAAItkB,EAMZ,OALIzG,UAAU+H,OAAS,GACrB0gB,GAAiB/hB,EAAKqkB,EAAG/qB,UAAU,WAE9B+qB,EAAEhnB,YACTlE,OAAO6D,eAAeqnB,EAAGrkB,EAAI9F,WACtBmqB,GAET1mB,EAAQqC,IAAI9F,UAAY6F,EAAQ7F,UAChCN,EAAe+D,EAAQqC,IAAI9F,UAAW,cAAeyD,EAAQqC,KAAK,GAClExE,EAAMe,iBAAiBoB,EAAQqC,IAAKD,IAEtC,IAAI4lB,GAAyB9oB,EAAoBc,EAAQwE,KAAK,SAAUwD,GACtE,IAAI4E,EAAI,IAAI5E,EAAE,IAEd,OADA4E,EAAEgY,IAAI,GAAI,IACHhY,aAAa5E,KAGlBigB,GAA+BzsB,OAAO6D,iBAAmB2oB,GACzDE,GAAkB,WACpB,IACE,QAASloB,EAAQwE,gBAAiBxE,EAAQwE,KAC1C,MAAO3I,GACP,OAAOA,aAAakC,WAJH,GAOrB,GAA2B,IAAvBiC,EAAQwE,IAAId,QAAgBukB,KAAiCC,GAAgB,CAC/E,IAAIC,GAAUnoB,EAAQwE,IACtBxE,EAAQwE,IAAM,SAASA,IACrB,KAAM3J,gBAAgB2J,GACpB,MAAM,IAAIzG,UAAU,kCAEtB,IAAI6O,EAAI,IAAIub,GAMZ,OALIxsB,UAAU+H,OAAS,GACrBghB,GAAiBlgB,EAAKoI,EAAGjR,UAAU,WAE9BiR,EAAElN,YACTlE,OAAO6D,eAAeuN,EAAGpI,EAAIjI,WACtBqQ,GAET5M,EAAQwE,IAAIjI,UAAY4rB,GAAQ5rB,UAChCN,EAAe+D,EAAQwE,IAAIjI,UAAW,cAAeyD,EAAQwE,KAAK,GAClE3G,EAAMe,iBAAiBoB,EAAQwE,IAAK2jB,IAEtC,IAAIC,GAAS,IAAIpoB,EAAQqC,IACrBgmB,IAAkCvsB,GAAqB,WACzD,OAAOssB,GAAO7sB,OAAO8L,OAAOR,QAsC9B,IA5ByC,oBAAhC7G,EAAQqC,IAAI9F,UAAUwpB,OACF,KAA3B,IAAI/lB,EAAQwE,KAAMmiB,MACF,IAAhByB,GAAOzB,MAC+B,oBAA/B3mB,EAAQqC,IAAI9F,UAAUhB,MACS,oBAA/ByE,EAAQwE,IAAIjI,UAAUhB,MACY,oBAAlCyE,EAAQqC,IAAI9F,UAAUC,SACY,oBAAlCwD,EAAQwE,IAAIjI,UAAUC,SAC7BT,EAAqBiE,EAAQqC,MAC7BtG,EAAqBiE,EAAQwE,MACC,oBAAvB4jB,GAAO7sB,OAAO8L,MACrBghB,KACCT,KAEDvqB,EAAiB2C,EAAS,CACxBqC,IAAKwiB,GAAgBxiB,IACrBmC,IAAKqgB,GAAgBrgB,MACpB,GAGDxE,EAAQwE,IAAIjI,UAAUhB,OAASyE,EAAQwE,IAAIjI,UAAU+U,QAEvDrV,EAAe+D,EAAQwE,IAAIjI,UAAW,OAAQyD,EAAQwE,IAAIjI,UAAU+U,QAAQ,GAI9EvG,GAAYvP,OAAOmW,gBAAe,IAAK3R,EAAQqC,KAAO9G,SACtDwP,GAAYvP,OAAOmW,gBAAe,IAAK3R,EAAQwE,KAAOjJ,SAElDa,GAAyD,QAAnC4D,EAAQwE,IAAIjI,UAAUkG,IAAIpG,KAAgB,CAElE,IAAIisB,GAAkBtoB,EAAQwE,IAAIjI,UAAUkG,IAC5CyB,GAAelE,EAAQwE,IAAIjI,UAAW,OAAO,SAAa2B,GACxD,OAAO9C,EAAMktB,GAAiBztB,KAAMqD,OAI1Cb,EAAiB2C,EAAS6kB,IAC1B/Z,GAAkB9K,EAAQqC,KAC1ByI,GAAkB9K,EAAQwE,KAG5B,IAAI+jB,GAA4B,SAAmC1pB,GACjE,IAAKkG,GAAGQ,aAAa1G,GACnB,MAAM,IAAId,UAAU,6BAQpByqB,GAAe,CAEjBrtB,MAAO,WACL,OAAO4J,GAAGC,KAAKD,GAAGC,KAAM,KAAMrJ,YAIhC+L,UAAW,SAAmBhI,EAAayF,GACzC,IAAKJ,GAAGU,cAAc/F,GACpB,MAAM,IAAI3B,UAAU,yCAEtB,IAAIyJ,EAAY7L,UAAU+H,OAAS,EAAI/H,UAAU,GAAK+D,EACtD,IAAKqF,GAAGU,cAAc+B,GACpB,MAAM,IAAIzJ,UAAU,qCAEtB,OAAOgH,GAAGwC,UAAU7H,EAAayF,EAAMqC,EAAW,aAOpDihB,eAAgB,SAAwB5pB,EAAQX,GAE9C,GADAqqB,GAA0B1pB,GACtB1C,EAAqB,CACvB,IAAIkc,EAAO7c,OAAO6C,yBAAyBQ,EAAQX,GAEnD,GAAIma,IAASA,EAAKnb,aAChB,OAAO,EAKX,cAAc2B,EAAOX,IAGvBuE,IAAK,SAAa5D,EAAQX,GAExB,OADAqqB,GAA0B1pB,GACnBX,KAAOW,IAIdrD,OAAOoP,qBACTpP,OAAOka,OAAO8S,GAAc,CAM1BE,QAAS,SAAiB7pB,GACxB0pB,GAA0B1pB,GAC1B,IAAItD,EAAOC,OAAOoP,oBAAoB/L,GAMtC,OAJIkG,GAAGK,WAAW5J,OAAOga,wBACvB3U,EAAWtF,EAAMC,OAAOga,sBAAsB3W,IAGzCtD,KAKb,IAAIotB,GAAwB,SAAmCjtB,GAC7D,OAAQE,EAAYF,IAkBtB,GAfIF,OAAOqa,mBACTra,OAAOka,OAAO8S,GAAc,CAC1BzQ,aAAc,SAAsBlZ,GAElC,OADA0pB,GAA0B1pB,GACnBrD,OAAOuc,aAAalZ,IAE7BgX,kBAAmB,SAA2BhX,GAE5C,OADA0pB,GAA0B1pB,GACnB8pB,IAAsB,WAC3B,OAAOntB,OAAOqa,kBAAkBhX,SAMpC1C,EAAqB,CACvB,IAAIysB,GAAc,SAAa/pB,EAAQX,EAAK+V,GAC1C,IAAIoE,EAAO7c,OAAO6C,yBAAyBQ,EAAQX,GAEnD,IAAKma,EAAM,CACT,IAAIwQ,EAASrtB,OAAOmW,eAAe9S,GAEnC,GAAe,OAAXgqB,EACF,OAGF,OAAOD,GAAYC,EAAQ3qB,EAAK+V,GAGlC,MAAI,UAAWoE,EACNA,EAAKrb,MAGVqb,EAAKnc,IACA6I,GAAGC,KAAKqT,EAAKnc,IAAK+X,QAD3B,GAOE6U,GAAc,SAAajqB,EAAQX,EAAKlB,EAAOiX,GACjD,IAAIoE,EAAO7c,OAAO6C,yBAAyBQ,EAAQX,GAEnD,IAAKma,EAAM,CACT,IAAIwQ,EAASrtB,OAAOmW,eAAe9S,GAEnC,GAAe,OAAXgqB,EACF,OAAOC,GAAYD,EAAQ3qB,EAAKlB,EAAOiX,GAGzCoE,EAAO,CACLrb,WAAO,EACPI,UAAU,EACVD,YAAY,EACZD,cAAc,GAIlB,GAAI,UAAWmb,EAAM,CACnB,IAAKA,EAAKjb,SACR,OAAO,EAGT,IAAK2H,GAAGQ,aAAa0O,GACnB,OAAO,EAGT,IAAI8U,EAAevtB,OAAO6C,yBAAyB4V,EAAU/V,GAE7D,OAAI6qB,EACKtkB,GAAQxI,eAAegY,EAAU/V,EAAK,CAC3ClB,MAAOA,IAGFyH,GAAQxI,eAAegY,EAAU/V,EAAK,CAC3ClB,MAAOA,EACPI,UAAU,EACVD,YAAY,EACZD,cAAc,IAKpB,QAAImb,EAAK/Z,MACPlD,EAAMid,EAAK/Z,IAAK2V,EAAUjX,IACnB,IAMXxB,OAAOka,OAAO8S,GAAc,CAC1BvsB,eAAgB,SAAwB4C,EAAQmqB,EAAaC,GAE3D,OADAV,GAA0B1pB,GACnB8pB,IAAsB,WAC3B,OAAOntB,OAAOS,eAAe4C,EAAQmqB,EAAaC,OAItD5qB,yBAA0B,SAAkCQ,EAAQmqB,GAElE,OADAT,GAA0B1pB,GACnBrD,OAAO6C,yBAAyBQ,EAAQmqB,IAIjD9sB,IAAK,SAAa2C,EAAQX,GACxBqqB,GAA0B1pB,GAC1B,IAAIoV,EAAWtY,UAAU+H,OAAS,EAAI/H,UAAU,GAAKkD,EAErD,OAAO+pB,GAAY/pB,EAAQX,EAAK+V,IAGlC3V,IAAK,SAAaO,EAAQX,EAAKlB,GAC7BurB,GAA0B1pB,GAC1B,IAAIoV,EAAWtY,UAAU+H,OAAS,EAAI/H,UAAU,GAAKkD,EAErD,OAAOiqB,GAAYjqB,EAAQX,EAAKlB,EAAOiX,MAK7C,GAAIzY,OAAOmW,eAAgB,CACzB,IAAIuX,GAA0B1tB,OAAOmW,eACrC6W,GAAa7W,eAAiB,SAAwB9S,GAEpD,OADA0pB,GAA0B1pB,GACnBqqB,GAAwBrqB,IAInC,GAAIrD,OAAO6D,gBAAkBmpB,GAAa7W,eAAgB,CACxD,IAAIwX,GAA8B,SAAUpsB,EAAQqsB,GAClD,IAAIzhB,EAAQyhB,EACZ,MAAOzhB,EAAO,CACZ,GAAI5K,IAAW4K,EACb,OAAO,EAETA,EAAQ6gB,GAAa7W,eAAehK,GAEtC,OAAO,GAGTnM,OAAOka,OAAO8S,GAAc,CAG1BnpB,eAAgB,SAAwBtC,EAAQ4K,GAE9C,GADA4gB,GAA0BxrB,GACZ,OAAV4K,IAAmB5C,GAAGQ,aAAaoC,GACrC,MAAM,IAAI5J,UAAU,mCAItB,OAAI4J,IAAUlD,GAAQkN,eAAe5U,MAKjC0H,GAAQsT,eAAiBtT,GAAQsT,aAAahb,OAK9CosB,GAA4BpsB,EAAQ4K,KAIxCnM,OAAO6D,eAAetC,EAAQ4K,IAEvB,OAIb,IAAI0hB,GAAkC,SAAUnrB,EAAKorB,GACnD,GAAKvkB,GAAGK,WAAWpF,EAAQyE,QAAQvG,IAE5B,CACL,IAAIqrB,EAAoBztB,GAAqB,WAI3C,OAHAkE,EAAQyE,QAAQvG,GAAK,GACrB8B,EAAQyE,QAAQvG,GAAKoF,KACrBtD,EAAQyE,QAAQvG,IAAK,IACd,KAELqrB,GACFrlB,GAAelE,EAAQyE,QAASvG,EAAKorB,QATvCrtB,EAAe+D,EAAQyE,QAASvG,EAAKorB,IAazC9tB,OAAOD,KAAKitB,IAAchsB,SAAQ,SAAU0B,GAC1CmrB,GAAgCnrB,EAAKsqB,GAAatqB,OAEpD,IAAIsrB,GAA0BxpB,EAAQyE,QAAQkN,eAiC9C,GAhCIvV,GAAsBotB,IAA4D,mBAAjCA,GAAwBntB,MAC3E6H,GAAelE,EAAQyE,QAAS,kBAAkB,SAAwB5F,GACxE,OAAOzD,EAAMouB,GAAyBxpB,EAAQyE,QAAS5F,MAGvDmB,EAAQyE,QAAQpF,gBACdvD,GAAqB,WAEvB,OADAkE,EAAQyE,QAAQpF,eAAe,EAAG,KAC3B,MAEP6E,GAAelE,EAAQyE,QAAS,iBAAkB+jB,GAAanpB,gBAG/DW,EAAQyE,QAAQxI,iBACbH,GAAqB,WACxB,IAAI2tB,GAASzpB,EAAQyE,QAAQxI,eAAe,EAAG,OAAQ,CAAEe,MAAO,IAE5D0sB,EAAiD,oBAA7BluB,OAAOqa,oBAAqC7V,EAAQyE,QAAQxI,eAAeT,OAAOqa,kBAAkB,IAAK,OAAQ,IACzI,OAAO4T,GAASC,MAEhBxlB,GAAelE,EAAQyE,QAAS,iBAAkB+jB,GAAavsB,iBAG/D+D,EAAQyE,QAAQiD,YACb5L,GAAqB,WACxB,IAAImJ,EAAI,aACR,OAAOjF,EAAQyE,QAAQiD,WAAU,cAAgB,GAAIzC,aAAcA,MAEnEf,GAAelE,EAAQyE,QAAS,YAAa+jB,GAAa9gB,YAIhC,iBAA1BtH,OAAO,IAAIupB,KAAKrmB,MAA0B,CAC5C,IAAIsmB,GAAeD,KAAKptB,UAAUmB,SAC9BmsB,GAAsB,WACxB,IAAIlW,GAAW9Y,KACf,OAAI8Y,IAAYA,EACP,eAEF5O,GAAGC,KAAK4kB,GAAc/uB,OAE/BqJ,GAAeylB,KAAKptB,UAAW,WAAYstB,IAK7C,IAAIC,GAAkB,CACpBC,OAAQ,SAAgB1tB,GAAQ,OAAO0I,GAAGkD,WAAWpN,KAAM,IAAK,OAAQwB,IACxE2tB,IAAK,WAAiB,OAAOjlB,GAAGkD,WAAWpN,KAAM,MAAO,GAAI,KAC5DovB,MAAO,WAAmB,OAAOllB,GAAGkD,WAAWpN,KAAM,QAAS,GAAI,KAClEqvB,KAAM,WAAkB,OAAOnlB,GAAGkD,WAAWpN,KAAM,IAAK,GAAI,KAC5DsvB,MAAO,WAAmB,OAAOplB,GAAGkD,WAAWpN,KAAM,KAAM,GAAI,KAC/DuvB,UAAW,SAAmBC,GAAS,OAAOtlB,GAAGkD,WAAWpN,KAAM,OAAQ,QAASwvB,IACnFC,SAAU,SAAkB3D,GAAQ,OAAO5hB,GAAGkD,WAAWpN,KAAM,OAAQ,OAAQ8rB,IAC/E4D,QAAS,WAAqB,OAAOxlB,GAAGkD,WAAWpN,KAAM,IAAK,GAAI,KAClE2vB,KAAM,SAAcC,GAAO,OAAO1lB,GAAGkD,WAAWpN,KAAM,IAAK,OAAQ4vB,IACnEC,MAAO,WAAmB,OAAO3lB,GAAGkD,WAAWpN,KAAM,QAAS,GAAI,KAClE8vB,OAAQ,WAAoB,OAAO5lB,GAAGkD,WAAWpN,KAAM,SAAU,GAAI,KACrE+vB,IAAK,WAAiB,OAAO7lB,GAAGkD,WAAWpN,KAAM,MAAO,GAAI,KAC5DgwB,IAAK,WAAiB,OAAO9lB,GAAGkD,WAAWpN,KAAM,MAAO,GAAI,MAE9DyB,EAASd,OAAOD,KAAKuuB,KAAkB,SAAU5rB,GAC/C,IAAIV,EAAS4C,OAAO7D,UAAU2B,GAC1B4sB,GAAkB,EACtB,GAAI/lB,GAAGK,WAAW5H,GAAS,CACzB,IAAIutB,EAAS3vB,EAAMoC,EAAQ,GAAI,OAC3BwtB,EAAczqB,EAAQ,GAAIwqB,EAAOliB,MAAM,OAAOnF,OAClDonB,EAAkBC,IAAWA,EAAOE,eAAiBD,EAAc,OAEnEF,GAAkB,EAEhBA,GACF5mB,GAAe9D,OAAO7D,UAAW2B,EAAK4rB,GAAgB5rB,OAI1D,IAAIgtB,GAA0B,WAE5B,IAAK7mB,GAAc,OAAO,EAC1B,IAAI8mB,EAA4B,kBAATC,MAA+C,oBAAnBA,KAAKD,UAA2BC,KAAKD,UAAY,KACpG,IAAKA,EAAa,OAAO,EACzB,GAAmC,qBAAxBA,EAAUxoB,KAA6B,OAAO,EACzD,GAA8B,WAA1BwoB,EAAU,CAACxoB,MAA2B,OAAO,EACjD,IAAIiF,EAAM,CAAE1B,EAAGvD,KAEf,OADAiF,EAAIjF,MAAY,EACO,OAAnBwoB,EAAUvjB,GATa,GAYzByjB,GAAmCvvB,GAAqB,WAE1D,OAAKuI,IACuC,OAArC+mB,KAAKD,UAAU3vB,OAAOmH,OAA8D,SAAvCyoB,KAAKD,UAAU,CAAC3vB,OAAOmH,UAE7E,GAAIuoB,KAA2BG,GAAkC,CAC/D,IAAIC,GAAgBF,KAAKD,UACzBjnB,GAAeknB,KAAM,aAAa,SAAmBpuB,GACnD,GAAqB,kBAAVA,EAAX,CACA,IAAI4M,EACAjO,UAAU+H,OAAS,IACrBkG,EAAWjO,UAAU,IAEvB,IAAIwJ,EAAO,CAACnI,GACZ,GAAK3B,EAAQuO,GAeXzE,EAAKvE,KAAKgJ,OAfY,CACtB,IAAI2hB,EAAYxmB,GAAGK,WAAWwE,GAAYA,EAAW,KACjD4hB,EAAkB,SAAUttB,EAAK4Y,GACnC,IAAI2U,EAAcF,EAAYnwB,EAAMmwB,EAAW1wB,KAAMqD,EAAK4Y,GAAOA,EACjE,GAA2B,kBAAhB2U,EACT,OAAI5nB,GAAKI,OAAOwnB,GACPrW,GAAS,GAATA,CAAaqW,GAEbA,GAIbtmB,EAAKvE,KAAK4qB,GAQZ,OAHI7vB,UAAU+H,OAAS,GACrByB,EAAKvE,KAAKjF,UAAU,IAEf2vB,GAAcnwB,MAAMN,KAAMsK,OAIrC,OAAOnF,O","file":"js/npm.es6-shim.e5f6969e.js","sourcesContent":["/*!\n * https://github.com/paulmillr/es6-shim\n * @license es6-shim Copyright 2013-2016 by Paul Miller (http://paulmillr.com)\n *   and contributors,  MIT License\n * es6-shim: v0.35.4\n * see https://github.com/paulmillr/es6-shim/blob/0.35.3/LICENSE\n * Details and documentation:\n * https://github.com/paulmillr/es6-shim/\n */\n\n// UMD (Universal Module Definition)\n// see https://github.com/umdjs/umd/blob/master/returnExports.js\n(function (root, factory) {\n  /*global define */\n  if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define(factory);\n  } else if (typeof exports === 'object') {\n    // Node. Does not work with strict CommonJS, but\n    // only CommonJS-like environments that support module.exports,\n    // like Node.\n    module.exports = factory();\n  } else {\n    // Browser globals (root is window)\n    root.returnExports = factory();\n  }\n}(this, function () {\n  'use strict';\n\n  var _apply = Function.call.bind(Function.apply);\n  var _call = Function.call.bind(Function.call);\n  var isArray = Array.isArray;\n  var keys = Object.keys;\n\n  var not = function notThunker(func) {\n    return function notThunk() {\n      return !_apply(func, this, arguments);\n    };\n  };\n  var throwsError = function (func) {\n    try {\n      func();\n      return false;\n    } catch (e) {\n      return true;\n    }\n  };\n  var valueOrFalseIfThrows = function valueOrFalseIfThrows(func) {\n    try {\n      return func();\n    } catch (e) {\n      return false;\n    }\n  };\n\n  var isCallableWithoutNew = not(throwsError);\n  var arePropertyDescriptorsSupported = function () {\n    // if Object.defineProperty exists but throws, it's IE 8\n    return !throwsError(function () {\n      return Object.defineProperty({}, 'x', { get: function () { } }); // eslint-disable-line getter-return\n    });\n  };\n  var supportsDescriptors = !!Object.defineProperty && arePropertyDescriptorsSupported();\n  var functionsHaveNames = (function foo() {}).name === 'foo'; // eslint-disable-line no-extra-parens\n\n  var _forEach = Function.call.bind(Array.prototype.forEach);\n  var _reduce = Function.call.bind(Array.prototype.reduce);\n  var _filter = Function.call.bind(Array.prototype.filter);\n  var _some = Function.call.bind(Array.prototype.some);\n\n  var defineProperty = function (object, name, value, force) {\n    if (!force && name in object) { return; }\n    if (supportsDescriptors) {\n      Object.defineProperty(object, name, {\n        configurable: true,\n        enumerable: false,\n        writable: true,\n        value: value\n      });\n    } else {\n      object[name] = value;\n    }\n  };\n\n  // Define configurable, writable and non-enumerable props\n  // if they don’t exist.\n  var defineProperties = function (object, map, forceOverride) {\n    _forEach(keys(map), function (name) {\n      var method = map[name];\n      defineProperty(object, name, method, !!forceOverride);\n    });\n  };\n\n  var _toString = Function.call.bind(Object.prototype.toString);\n  var isCallable = typeof /abc/ === 'function' ? function IsCallableSlow(x) {\n    // Some old browsers (IE, FF) say that typeof /abc/ === 'function'\n    return typeof x === 'function' && _toString(x) === '[object Function]';\n  } : function IsCallableFast(x) { return typeof x === 'function'; };\n\n  var Value = {\n    getter: function (object, name, getter) {\n      if (!supportsDescriptors) {\n        throw new TypeError('getters require true ES5 support');\n      }\n      Object.defineProperty(object, name, {\n        configurable: true,\n        enumerable: false,\n        get: getter\n      });\n    },\n    proxy: function (originalObject, key, targetObject) {\n      if (!supportsDescriptors) {\n        throw new TypeError('getters require true ES5 support');\n      }\n      var originalDescriptor = Object.getOwnPropertyDescriptor(originalObject, key);\n      Object.defineProperty(targetObject, key, {\n        configurable: originalDescriptor.configurable,\n        enumerable: originalDescriptor.enumerable,\n        get: function getKey() { return originalObject[key]; },\n        set: function setKey(value) { originalObject[key] = value; }\n      });\n    },\n    redefine: function (object, property, newValue) {\n      if (supportsDescriptors) {\n        var descriptor = Object.getOwnPropertyDescriptor(object, property);\n        descriptor.value = newValue;\n        Object.defineProperty(object, property, descriptor);\n      } else {\n        object[property] = newValue;\n      }\n    },\n    defineByDescriptor: function (object, property, descriptor) {\n      if (supportsDescriptors) {\n        Object.defineProperty(object, property, descriptor);\n      } else if ('value' in descriptor) {\n        object[property] = descriptor.value;\n      }\n    },\n    preserveToString: function (target, source) {\n      if (source && isCallable(source.toString)) {\n        defineProperty(target, 'toString', source.toString.bind(source), true);\n      }\n    }\n  };\n\n  // Simple shim for Object.create on ES3 browsers\n  // (unlike real shim, no attempt to support `prototype === null`)\n  var create = Object.create || function (prototype, properties) {\n    var Prototype = function Prototype() {};\n    Prototype.prototype = prototype;\n    var object = new Prototype();\n    if (typeof properties !== 'undefined') {\n      keys(properties).forEach(function (key) {\n        Value.defineByDescriptor(object, key, properties[key]);\n      });\n    }\n    return object;\n  };\n\n  var supportsSubclassing = function (C, f) {\n    if (!Object.setPrototypeOf) { return false; /* skip test on IE < 11 */ }\n    return valueOrFalseIfThrows(function () {\n      var Sub = function Subclass(arg) {\n        var o = new C(arg);\n        Object.setPrototypeOf(o, Subclass.prototype);\n        return o;\n      };\n      Object.setPrototypeOf(Sub, C);\n      Sub.prototype = create(C.prototype, {\n        constructor: { value: Sub }\n      });\n      return f(Sub);\n    });\n  };\n\n  var getGlobal = function () {\n    /* global self, window */\n    // the only reliable means to get the global object is\n    // `Function('return this')()`\n    // However, this causes CSP violations in Chrome apps.\n    if (typeof self !== 'undefined') { return self; }\n    if (typeof window !== 'undefined') { return window; }\n    if (typeof global !== 'undefined') { return global; }\n    throw new Error('unable to locate global object');\n  };\n\n  var globals = getGlobal();\n  var globalIsFinite = globals.isFinite;\n  var _indexOf = Function.call.bind(String.prototype.indexOf);\n  var _arrayIndexOfApply = Function.apply.bind(Array.prototype.indexOf);\n  var _concat = Function.call.bind(Array.prototype.concat);\n  // var _sort = Function.call.bind(Array.prototype.sort);\n  var _strSlice = Function.call.bind(String.prototype.slice);\n  var _push = Function.call.bind(Array.prototype.push);\n  var _pushApply = Function.apply.bind(Array.prototype.push);\n  var _join = Function.call.bind(Array.prototype.join);\n  var _shift = Function.call.bind(Array.prototype.shift);\n  var _max = Math.max;\n  var _min = Math.min;\n  var _floor = Math.floor;\n  var _abs = Math.abs;\n  var _exp = Math.exp;\n  var _log = Math.log;\n  var _sqrt = Math.sqrt;\n  var _hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);\n  var ArrayIterator; // make our implementation private\n  var noop = function () {};\n\n  var OrigMap = globals.Map;\n  var origMapDelete = OrigMap && OrigMap.prototype['delete'];\n  var origMapGet = OrigMap && OrigMap.prototype.get;\n  var origMapHas = OrigMap && OrigMap.prototype.has;\n  var origMapSet = OrigMap && OrigMap.prototype.set;\n\n  var Symbol = globals.Symbol || {};\n  var symbolSpecies = Symbol.species || '@@species';\n\n  var numberIsNaN = Number.isNaN || function isNaN(value) {\n    // NaN !== NaN, but they are identical.\n    // NaNs are the only non-reflexive value, i.e., if x !== x,\n    // then x is NaN.\n    // isNaN is broken: it converts its argument to number, so\n    // isNaN('foo') => true\n    return value !== value;\n  };\n  var numberIsFinite = Number.isFinite || function isFinite(value) {\n    return typeof value === 'number' && globalIsFinite(value);\n  };\n  var _sign = isCallable(Math.sign) ? Math.sign : function sign(value) {\n    var number = Number(value);\n    if (number === 0) { return number; }\n    if (numberIsNaN(number)) { return number; }\n    return number < 0 ? -1 : 1;\n  };\n  var _log1p = function log1p(value) {\n    var x = Number(value);\n    if (x < -1 || numberIsNaN(x)) { return NaN; }\n    if (x === 0 || x === Infinity) { return x; }\n    if (x === -1) { return -Infinity; }\n\n    return (1 + x) - 1 === 0 ? x : x * (_log(1 + x) / ((1 + x) - 1));\n  };\n\n  // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js\n  // can be replaced with require('is-arguments') if we ever use a build process instead\n  var isStandardArguments = function isArguments(value) {\n    return _toString(value) === '[object Arguments]';\n  };\n  var isLegacyArguments = function isArguments(value) {\n    return value !== null &&\n      typeof value === 'object' &&\n      typeof value.length === 'number' &&\n      value.length >= 0 &&\n      _toString(value) !== '[object Array]' &&\n      _toString(value.callee) === '[object Function]';\n  };\n  var isArguments = isStandardArguments(arguments) ? isStandardArguments : isLegacyArguments;\n\n  var Type = {\n    primitive: function (x) { return x === null || (typeof x !== 'function' && typeof x !== 'object'); },\n    string: function (x) { return _toString(x) === '[object String]'; },\n    regex: function (x) { return _toString(x) === '[object RegExp]'; },\n    symbol: function (x) {\n      return typeof globals.Symbol === 'function' && typeof x === 'symbol';\n    }\n  };\n\n  var overrideNative = function overrideNative(object, property, replacement) {\n    var original = object[property];\n    defineProperty(object, property, replacement, true);\n    Value.preserveToString(object[property], original);\n  };\n\n  // eslint-disable-next-line no-restricted-properties\n  var hasSymbols = typeof Symbol === 'function' && typeof Symbol['for'] === 'function' && Type.symbol(Symbol());\n\n  // This is a private name in the es6 spec, equal to '[Symbol.iterator]'\n  // we're going to use an arbitrary _-prefixed name to make our shims\n  // work properly with each other, even though we don't have full Iterator\n  // support.  That is, `Array.from(map.keys())` will work, but we don't\n  // pretend to export a \"real\" Iterator interface.\n  var $iterator$ = Type.symbol(Symbol.iterator) ? Symbol.iterator : '_es6-shim iterator_';\n  // Firefox ships a partial implementation using the name @@iterator.\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14\n  // So use that name if we detect it.\n  if (globals.Set && typeof new globals.Set()['@@iterator'] === 'function') {\n    $iterator$ = '@@iterator';\n  }\n\n  // Reflect\n  if (!globals.Reflect) {\n    defineProperty(globals, 'Reflect', {}, true);\n  }\n  var Reflect = globals.Reflect;\n\n  var $String = String;\n\n  /* global document */\n  var domAll = (typeof document === 'undefined' || !document) ? null : document.all;\n  var isNullOrUndefined = domAll == null ? function isNullOrUndefined(x) {\n    return x == null;\n  } : function isNullOrUndefinedAndNotDocumentAll(x) {\n    return x == null && x !== domAll;\n  };\n\n  var ES = {\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-call\n    Call: function Call(F, V) {\n      var args = arguments.length > 2 ? arguments[2] : [];\n      if (!ES.IsCallable(F)) {\n        throw new TypeError(F + ' is not a function');\n      }\n      return _apply(F, V, args);\n    },\n\n    RequireObjectCoercible: function (x, optMessage) {\n      if (isNullOrUndefined(x)) {\n        throw new TypeError(optMessage || 'Cannot call method on ' + x);\n      }\n      return x;\n    },\n\n    // This might miss the \"(non-standard exotic and does not implement\n    // [[Call]])\" case from\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-typeof-operator-runtime-semantics-evaluation\n    // but we can't find any evidence these objects exist in practice.\n    // If we find some in the future, you could test `Object(x) === x`,\n    // which is reliable according to\n    // http://www.ecma-international.org/ecma-262/6.0/#sec-toobject\n    // but is not well optimized by runtimes and creates an object\n    // whenever it returns false, and thus is very slow.\n    TypeIsObject: function (x) {\n      if (x === void 0 || x === null || x === true || x === false) {\n        return false;\n      }\n      return typeof x === 'function' || typeof x === 'object' || x === domAll;\n    },\n\n    ToObject: function (o, optMessage) {\n      return Object(ES.RequireObjectCoercible(o, optMessage));\n    },\n\n    IsCallable: isCallable,\n\n    IsConstructor: function (x) {\n      // We can't tell callables from constructors in ES5\n      return ES.IsCallable(x);\n    },\n\n    ToInt32: function (x) {\n      return ES.ToNumber(x) >> 0;\n    },\n\n    ToUint32: function (x) {\n      return ES.ToNumber(x) >>> 0;\n    },\n\n    ToNumber: function (value) {\n      if (hasSymbols && _toString(value) === '[object Symbol]') {\n        throw new TypeError('Cannot convert a Symbol value to a number');\n      }\n      return +value;\n    },\n\n    ToInteger: function (value) {\n      var number = ES.ToNumber(value);\n      if (numberIsNaN(number)) { return 0; }\n      if (number === 0 || !numberIsFinite(number)) { return number; }\n      return (number > 0 ? 1 : -1) * _floor(_abs(number));\n    },\n\n    ToLength: function (value) {\n      var len = ES.ToInteger(value);\n      if (len <= 0) { return 0; } // includes converting -0 to +0\n      if (len > Number.MAX_SAFE_INTEGER) { return Number.MAX_SAFE_INTEGER; }\n      return len;\n    },\n\n    SameValue: function (a, b) {\n      if (a === b) {\n        // 0 === -0, but they are not identical.\n        if (a === 0) { return 1 / a === 1 / b; }\n        return true;\n      }\n      return numberIsNaN(a) && numberIsNaN(b);\n    },\n\n    SameValueZero: function (a, b) {\n      // same as SameValue except for SameValueZero(+0, -0) == true\n      return (a === b) || (numberIsNaN(a) && numberIsNaN(b));\n    },\n\n    IsIterable: function (o) {\n      return ES.TypeIsObject(o) && (typeof o[$iterator$] !== 'undefined' || isArguments(o));\n    },\n\n    GetIterator: function (o) {\n      if (isArguments(o)) {\n        // special case support for `arguments`\n        return new ArrayIterator(o, 'value');\n      }\n      var itFn = ES.GetMethod(o, $iterator$);\n      if (!ES.IsCallable(itFn)) {\n        // Better diagnostics if itFn is null or undefined\n        throw new TypeError('value is not an iterable');\n      }\n      var it = ES.Call(itFn, o);\n      if (!ES.TypeIsObject(it)) {\n        throw new TypeError('bad iterator');\n      }\n      return it;\n    },\n\n    GetMethod: function (o, p) {\n      var func = ES.ToObject(o)[p];\n      if (isNullOrUndefined(func)) {\n        return void 0;\n      }\n      if (!ES.IsCallable(func)) {\n        throw new TypeError('Method not callable: ' + p);\n      }\n      return func;\n    },\n\n    IteratorComplete: function (iterResult) {\n      return !!iterResult.done;\n    },\n\n    IteratorClose: function (iterator, completionIsThrow) {\n      var returnMethod = ES.GetMethod(iterator, 'return');\n      if (returnMethod === void 0) {\n        return;\n      }\n      var innerResult, innerException;\n      try {\n        innerResult = ES.Call(returnMethod, iterator);\n      } catch (e) {\n        innerException = e;\n      }\n      if (completionIsThrow) {\n        return;\n      }\n      if (innerException) {\n        throw innerException;\n      }\n      if (!ES.TypeIsObject(innerResult)) {\n        throw new TypeError(\"Iterator's return method returned a non-object.\");\n      }\n    },\n\n    IteratorNext: function (it) {\n      var result = arguments.length > 1 ? it.next(arguments[1]) : it.next();\n      if (!ES.TypeIsObject(result)) {\n        throw new TypeError('bad iterator');\n      }\n      return result;\n    },\n\n    IteratorStep: function (it) {\n      var result = ES.IteratorNext(it);\n      var done = ES.IteratorComplete(result);\n      return done ? false : result;\n    },\n\n    Construct: function (C, args, newTarget, isES6internal) {\n      var target = typeof newTarget === 'undefined' ? C : newTarget;\n\n      if (!isES6internal && Reflect.construct) {\n        // Try to use Reflect.construct if available\n        return Reflect.construct(C, args, target);\n      }\n      // OK, we have to fake it.  This will only work if the\n      // C.[[ConstructorKind]] == \"base\" -- but that's the only\n      // kind we can make in ES5 code anyway.\n\n      // OrdinaryCreateFromConstructor(target, \"%ObjectPrototype%\")\n      var proto = target.prototype;\n      if (!ES.TypeIsObject(proto)) {\n        proto = Object.prototype;\n      }\n      var obj = create(proto);\n      // Call the constructor.\n      var result = ES.Call(C, obj, args);\n      return ES.TypeIsObject(result) ? result : obj;\n    },\n\n    SpeciesConstructor: function (O, defaultConstructor) {\n      var C = O.constructor;\n      if (C === void 0) {\n        return defaultConstructor;\n      }\n      if (!ES.TypeIsObject(C)) {\n        throw new TypeError('Bad constructor');\n      }\n      var S = C[symbolSpecies];\n      if (isNullOrUndefined(S)) {\n        return defaultConstructor;\n      }\n      if (!ES.IsConstructor(S)) {\n        throw new TypeError('Bad @@species');\n      }\n      return S;\n    },\n\n    CreateHTML: function (string, tag, attribute, value) {\n      var S = ES.ToString(string);\n      var p1 = '<' + tag;\n      if (attribute !== '') {\n        var V = ES.ToString(value);\n        var escapedV = V.replace(/\"/g, '&quot;');\n        p1 += ' ' + attribute + '=\"' + escapedV + '\"';\n      }\n      var p2 = p1 + '>';\n      var p3 = p2 + S;\n      return p3 + '</' + tag + '>';\n    },\n\n    IsRegExp: function IsRegExp(argument) {\n      if (!ES.TypeIsObject(argument)) {\n        return false;\n      }\n      var isRegExp = argument[Symbol.match];\n      if (typeof isRegExp !== 'undefined') {\n        return !!isRegExp;\n      }\n      return Type.regex(argument);\n    },\n\n    ToString: function ToString(string) {\n      if (hasSymbols && _toString(string) === '[object Symbol]') {\n        throw new TypeError('Cannot convert a Symbol value to a number');\n      }\n      return $String(string);\n    }\n  };\n\n  // Well-known Symbol shims\n  if (supportsDescriptors && hasSymbols) {\n    var defineWellKnownSymbol = function defineWellKnownSymbol(name) {\n      if (Type.symbol(Symbol[name])) {\n        return Symbol[name];\n      }\n      // eslint-disable-next-line no-restricted-properties\n      var sym = Symbol['for']('Symbol.' + name);\n      Object.defineProperty(Symbol, name, {\n        configurable: false,\n        enumerable: false,\n        writable: false,\n        value: sym\n      });\n      return sym;\n    };\n    if (!Type.symbol(Symbol.search)) {\n      var symbolSearch = defineWellKnownSymbol('search');\n      var originalSearch = String.prototype.search;\n      defineProperty(RegExp.prototype, symbolSearch, function search(string) {\n        return ES.Call(originalSearch, string, [this]);\n      });\n      var searchShim = function search(regexp) {\n        var O = ES.RequireObjectCoercible(this);\n        if (!isNullOrUndefined(regexp)) {\n          var searcher = ES.GetMethod(regexp, symbolSearch);\n          if (typeof searcher !== 'undefined') {\n            return ES.Call(searcher, regexp, [O]);\n          }\n        }\n        return ES.Call(originalSearch, O, [ES.ToString(regexp)]);\n      };\n      overrideNative(String.prototype, 'search', searchShim);\n    }\n    if (!Type.symbol(Symbol.replace)) {\n      var symbolReplace = defineWellKnownSymbol('replace');\n      var originalReplace = String.prototype.replace;\n      defineProperty(RegExp.prototype, symbolReplace, function replace(string, replaceValue) {\n        return ES.Call(originalReplace, string, [this, replaceValue]);\n      });\n      var replaceShim = function replace(searchValue, replaceValue) {\n        var O = ES.RequireObjectCoercible(this);\n        if (!isNullOrUndefined(searchValue)) {\n          var replacer = ES.GetMethod(searchValue, symbolReplace);\n          if (typeof replacer !== 'undefined') {\n            return ES.Call(replacer, searchValue, [O, replaceValue]);\n          }\n        }\n        return ES.Call(originalReplace, O, [ES.ToString(searchValue), replaceValue]);\n      };\n      overrideNative(String.prototype, 'replace', replaceShim);\n    }\n    if (!Type.symbol(Symbol.split)) {\n      var symbolSplit = defineWellKnownSymbol('split');\n      var originalSplit = String.prototype.split;\n      defineProperty(RegExp.prototype, symbolSplit, function split(string, limit) {\n        return ES.Call(originalSplit, string, [this, limit]);\n      });\n      var splitShim = function split(separator, limit) {\n        var O = ES.RequireObjectCoercible(this);\n        if (!isNullOrUndefined(separator)) {\n          var splitter = ES.GetMethod(separator, symbolSplit);\n          if (typeof splitter !== 'undefined') {\n            return ES.Call(splitter, separator, [O, limit]);\n          }\n        }\n        return ES.Call(originalSplit, O, [ES.ToString(separator), limit]);\n      };\n      overrideNative(String.prototype, 'split', splitShim);\n    }\n    var symbolMatchExists = Type.symbol(Symbol.match);\n    var stringMatchIgnoresSymbolMatch = symbolMatchExists && (function () {\n      // Firefox 41, through Nightly 45 has Symbol.match, but String#match ignores it.\n      // Firefox 40 and below have Symbol.match but String#match works fine.\n      var o = {};\n      o[Symbol.match] = function () { return 42; };\n      return 'a'.match(o) !== 42;\n    }());\n    if (!symbolMatchExists || stringMatchIgnoresSymbolMatch) {\n      var symbolMatch = defineWellKnownSymbol('match');\n\n      var originalMatch = String.prototype.match;\n      defineProperty(RegExp.prototype, symbolMatch, function match(string) {\n        return ES.Call(originalMatch, string, [this]);\n      });\n\n      var matchShim = function match(regexp) {\n        var O = ES.RequireObjectCoercible(this);\n        if (!isNullOrUndefined(regexp)) {\n          var matcher = ES.GetMethod(regexp, symbolMatch);\n          if (typeof matcher !== 'undefined') {\n            return ES.Call(matcher, regexp, [O]);\n          }\n        }\n        return ES.Call(originalMatch, O, [ES.ToString(regexp)]);\n      };\n      overrideNative(String.prototype, 'match', matchShim);\n    }\n  }\n\n  var wrapConstructor = function wrapConstructor(original, replacement, keysToSkip) {\n    Value.preserveToString(replacement, original);\n    if (Object.setPrototypeOf) {\n      // sets up proper prototype chain where possible\n      Object.setPrototypeOf(original, replacement);\n    }\n    if (supportsDescriptors) {\n      _forEach(Object.getOwnPropertyNames(original), function (key) {\n        if (key in noop || keysToSkip[key]) { return; }\n        Value.proxy(original, key, replacement);\n      });\n    } else {\n      _forEach(Object.keys(original), function (key) {\n        if (key in noop || keysToSkip[key]) { return; }\n        replacement[key] = original[key];\n      });\n    }\n    replacement.prototype = original.prototype;\n    Value.redefine(original.prototype, 'constructor', replacement);\n  };\n\n  var defaultSpeciesGetter = function () { return this; };\n  var addDefaultSpecies = function (C) {\n    if (supportsDescriptors && !_hasOwnProperty(C, symbolSpecies)) {\n      Value.getter(C, symbolSpecies, defaultSpeciesGetter);\n    }\n  };\n\n  var addIterator = function (prototype, impl) {\n    var implementation = impl || function iterator() { return this; };\n    defineProperty(prototype, $iterator$, implementation);\n    if (!prototype[$iterator$] && Type.symbol($iterator$)) {\n      // implementations are buggy when $iterator$ is a Symbol\n      prototype[$iterator$] = implementation;\n    }\n  };\n\n  var createDataProperty = function createDataProperty(object, name, value) {\n    if (supportsDescriptors) {\n      Object.defineProperty(object, name, {\n        configurable: true,\n        enumerable: true,\n        writable: true,\n        value: value\n      });\n    } else {\n      object[name] = value;\n    }\n  };\n  var createDataPropertyOrThrow = function createDataPropertyOrThrow(object, name, value) {\n    createDataProperty(object, name, value);\n    if (!ES.SameValue(object[name], value)) {\n      throw new TypeError('property is nonconfigurable');\n    }\n  };\n\n  var emulateES6construct = function (o, defaultNewTarget, defaultProto, slots) {\n    // This is an es5 approximation to es6 construct semantics.  in es6,\n    // 'new Foo' invokes Foo.[[Construct]] which (for almost all objects)\n    // just sets the internal variable NewTarget (in es6 syntax `new.target`)\n    // to Foo and then returns Foo().\n\n    // Many ES6 object then have constructors of the form:\n    // 1. If NewTarget is undefined, throw a TypeError exception\n    // 2. Let xxx by OrdinaryCreateFromConstructor(NewTarget, yyy, zzz)\n\n    // So we're going to emulate those first two steps.\n    if (!ES.TypeIsObject(o)) {\n      throw new TypeError('Constructor requires `new`: ' + defaultNewTarget.name);\n    }\n    var proto = defaultNewTarget.prototype;\n    if (!ES.TypeIsObject(proto)) {\n      proto = defaultProto;\n    }\n    var obj = create(proto);\n    for (var name in slots) {\n      if (_hasOwnProperty(slots, name)) {\n        var value = slots[name];\n        defineProperty(obj, name, value, true);\n      }\n    }\n    return obj;\n  };\n\n  // Firefox 31 reports this function's length as 0\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=1062484\n  if (String.fromCodePoint && String.fromCodePoint.length !== 1) {\n    var originalFromCodePoint = String.fromCodePoint;\n    overrideNative(String, 'fromCodePoint', function fromCodePoint(codePoints) {\n      return ES.Call(originalFromCodePoint, this, arguments);\n    });\n  }\n\n  var StringShims = {\n    fromCodePoint: function fromCodePoint(codePoints) {\n      var result = [];\n      var next;\n      for (var i = 0, length = arguments.length; i < length; i++) {\n        next = Number(arguments[i]);\n        if (!ES.SameValue(next, ES.ToInteger(next)) || next < 0 || next > 0x10FFFF) {\n          throw new RangeError('Invalid code point ' + next);\n        }\n\n        if (next < 0x10000) {\n          _push(result, String.fromCharCode(next));\n        } else {\n          next -= 0x10000;\n          _push(result, String.fromCharCode((next >> 10) + 0xD800));\n          _push(result, String.fromCharCode((next % 0x400) + 0xDC00));\n        }\n      }\n      return _join(result, '');\n    },\n\n    raw: function raw(template) {\n      var numberOfSubstitutions = arguments.length - 1;\n      var cooked = ES.ToObject(template, 'bad template');\n      var raw = ES.ToObject(cooked.raw, 'bad raw value');\n      var len = raw.length;\n      var literalSegments = ES.ToLength(len);\n      if (literalSegments <= 0) {\n        return '';\n      }\n\n      var stringElements = [];\n      var nextIndex = 0;\n      var nextKey, next, nextSeg, nextSub;\n      while (nextIndex < literalSegments) {\n        nextKey = ES.ToString(nextIndex);\n        nextSeg = ES.ToString(raw[nextKey]);\n        _push(stringElements, nextSeg);\n        if (nextIndex + 1 >= literalSegments) {\n          break;\n        }\n        next = nextIndex + 1 < arguments.length ? arguments[nextIndex + 1] : '';\n        nextSub = ES.ToString(next);\n        _push(stringElements, nextSub);\n        nextIndex += 1;\n      }\n      return _join(stringElements, '');\n    }\n  };\n  if (String.raw && String.raw({ raw: { 0: 'x', 1: 'y', length: 2 } }) !== 'xy') {\n    // IE 11 TP has a broken String.raw implementation\n    overrideNative(String, 'raw', StringShims.raw);\n  }\n  defineProperties(String, StringShims);\n\n  // Fast repeat, uses the `Exponentiation by squaring` algorithm.\n  // Perf: http://jsperf.com/string-repeat2/2\n  var stringRepeat = function repeat(s, times) {\n    if (times < 1) { return ''; }\n    if (times % 2) { return repeat(s, times - 1) + s; }\n    var half = repeat(s, times / 2);\n    return half + half;\n  };\n  var stringMaxLength = Infinity;\n\n  var StringPrototypeShims = {\n    repeat: function repeat(times) {\n      var thisStr = ES.ToString(ES.RequireObjectCoercible(this));\n      var numTimes = ES.ToInteger(times);\n      if (numTimes < 0 || numTimes >= stringMaxLength) {\n        throw new RangeError('repeat count must be less than infinity and not overflow maximum string size');\n      }\n      return stringRepeat(thisStr, numTimes);\n    },\n\n    startsWith: function startsWith(searchString) {\n      var S = ES.ToString(ES.RequireObjectCoercible(this));\n      if (ES.IsRegExp(searchString)) {\n        throw new TypeError('Cannot call method \"startsWith\" with a regex');\n      }\n      var searchStr = ES.ToString(searchString);\n      var position;\n      if (arguments.length > 1) {\n        position = arguments[1];\n      }\n      var start = _max(ES.ToInteger(position), 0);\n      return _strSlice(S, start, start + searchStr.length) === searchStr;\n    },\n\n    endsWith: function endsWith(searchString) {\n      var S = ES.ToString(ES.RequireObjectCoercible(this));\n      if (ES.IsRegExp(searchString)) {\n        throw new TypeError('Cannot call method \"endsWith\" with a regex');\n      }\n      var searchStr = ES.ToString(searchString);\n      var len = S.length;\n      var endPosition;\n      if (arguments.length > 1) {\n        endPosition = arguments[1];\n      }\n      var pos = typeof endPosition === 'undefined' ? len : ES.ToInteger(endPosition);\n      var end = _min(_max(pos, 0), len);\n      return _strSlice(S, end - searchStr.length, end) === searchStr;\n    },\n\n    includes: function includes(searchString) {\n      if (ES.IsRegExp(searchString)) {\n        throw new TypeError('\"includes\" does not accept a RegExp');\n      }\n      var searchStr = ES.ToString(searchString);\n      var position;\n      if (arguments.length > 1) {\n        position = arguments[1];\n      }\n      // Somehow this trick makes method 100% compat with the spec.\n      return _indexOf(this, searchStr, position) !== -1;\n    },\n\n    codePointAt: function codePointAt(pos) {\n      var thisStr = ES.ToString(ES.RequireObjectCoercible(this));\n      var position = ES.ToInteger(pos);\n      var length = thisStr.length;\n      if (position >= 0 && position < length) {\n        var first = thisStr.charCodeAt(position);\n        var isEnd = position + 1 === length;\n        if (first < 0xD800 || first > 0xDBFF || isEnd) { return first; }\n        var second = thisStr.charCodeAt(position + 1);\n        if (second < 0xDC00 || second > 0xDFFF) { return first; }\n        return ((first - 0xD800) * 1024) + (second - 0xDC00) + 0x10000;\n      }\n    }\n  };\n  if (String.prototype.includes && 'a'.includes('a', Infinity) !== false) {\n    overrideNative(String.prototype, 'includes', StringPrototypeShims.includes);\n  }\n\n  if (String.prototype.startsWith && String.prototype.endsWith) {\n    var startsWithRejectsRegex = throwsError(function () {\n      /* throws if spec-compliant */\n      return '/a/'.startsWith(/a/);\n    });\n    var startsWithHandlesInfinity = valueOrFalseIfThrows(function () {\n      return 'abc'.startsWith('a', Infinity) === false;\n    });\n    if (!startsWithRejectsRegex || !startsWithHandlesInfinity) {\n      // Firefox (< 37?) and IE 11 TP have a noncompliant startsWith implementation\n      overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith);\n      overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith);\n    }\n  }\n  if (hasSymbols) {\n    var startsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n      var re = /a/;\n      re[Symbol.match] = false;\n      return '/a/'.startsWith(re);\n    });\n    if (!startsWithSupportsSymbolMatch) {\n      overrideNative(String.prototype, 'startsWith', StringPrototypeShims.startsWith);\n    }\n    var endsWithSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n      var re = /a/;\n      re[Symbol.match] = false;\n      return '/a/'.endsWith(re);\n    });\n    if (!endsWithSupportsSymbolMatch) {\n      overrideNative(String.prototype, 'endsWith', StringPrototypeShims.endsWith);\n    }\n    var includesSupportsSymbolMatch = valueOrFalseIfThrows(function () {\n      var re = /a/;\n      re[Symbol.match] = false;\n      return '/a/'.includes(re);\n    });\n    if (!includesSupportsSymbolMatch) {\n      overrideNative(String.prototype, 'includes', StringPrototypeShims.includes);\n    }\n  }\n\n  defineProperties(String.prototype, StringPrototypeShims);\n\n  // whitespace from: http://es5.github.io/#x15.5.4.20\n  // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324\n  var ws = [\n    '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003',\n    '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028',\n    '\\u2029\\uFEFF'\n  ].join('');\n  var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');\n  var trimShim = function trim() {\n    return ES.ToString(ES.RequireObjectCoercible(this)).replace(trimRegexp, '');\n  };\n  var nonWS = ['\\u0085', '\\u200b', '\\ufffe'].join('');\n  var nonWSregex = new RegExp('[' + nonWS + ']', 'g');\n  var isBadHexRegex = /^[-+]0x[0-9a-f]+$/i;\n  var hasStringTrimBug = nonWS.trim().length !== nonWS.length;\n  defineProperty(String.prototype, 'trim', trimShim, hasStringTrimBug);\n\n  // Given an argument x, it will return an IteratorResult object,\n  // with value set to x and done to false.\n  // Given no arguments, it will return an iterator completion object.\n  var iteratorResult = function (x) {\n    return { value: x, done: arguments.length === 0 };\n  };\n\n  // see http://www.ecma-international.org/ecma-262/6.0/#sec-string.prototype-@@iterator\n  var StringIterator = function (s) {\n    ES.RequireObjectCoercible(s);\n    this._s = ES.ToString(s);\n    this._i = 0;\n  };\n  StringIterator.prototype.next = function () {\n    var s = this._s;\n    var i = this._i;\n    if (typeof s === 'undefined' || i >= s.length) {\n      this._s = void 0;\n      return iteratorResult();\n    }\n    var first = s.charCodeAt(i);\n    var second, len;\n    if (first < 0xD800 || first > 0xDBFF || (i + 1) === s.length) {\n      len = 1;\n    } else {\n      second = s.charCodeAt(i + 1);\n      len = (second < 0xDC00 || second > 0xDFFF) ? 1 : 2;\n    }\n    this._i = i + len;\n    return iteratorResult(s.substr(i, len));\n  };\n  addIterator(StringIterator.prototype);\n  addIterator(String.prototype, function () {\n    return new StringIterator(this);\n  });\n\n  var ArrayShims = {\n    from: function from(items) {\n      var C = this;\n      var mapFn;\n      if (arguments.length > 1) {\n        mapFn = arguments[1];\n      }\n      var mapping, T;\n      if (typeof mapFn === 'undefined') {\n        mapping = false;\n      } else {\n        if (!ES.IsCallable(mapFn)) {\n          throw new TypeError('Array.from: when provided, the second argument must be a function');\n        }\n        if (arguments.length > 2) {\n          T = arguments[2];\n        }\n        mapping = true;\n      }\n\n      // Note that that Arrays will use ArrayIterator:\n      // https://bugs.ecmascript.org/show_bug.cgi?id=2416\n      var usingIterator = typeof (isArguments(items) || ES.GetMethod(items, $iterator$)) !== 'undefined';\n\n      var length, result, i;\n      if (usingIterator) {\n        result = ES.IsConstructor(C) ? Object(new C()) : [];\n        var iterator = ES.GetIterator(items);\n        var next, nextValue;\n\n        i = 0;\n        while (true) {\n          next = ES.IteratorStep(iterator);\n          if (next === false) {\n            break;\n          }\n          nextValue = next.value;\n          try {\n            if (mapping) {\n              nextValue = typeof T === 'undefined' ? mapFn(nextValue, i) : _call(mapFn, T, nextValue, i);\n            }\n            result[i] = nextValue;\n          } catch (e) {\n            ES.IteratorClose(iterator, true);\n            throw e;\n          }\n          i += 1;\n        }\n        length = i;\n      } else {\n        var arrayLike = ES.ToObject(items);\n        length = ES.ToLength(arrayLike.length);\n        result = ES.IsConstructor(C) ? Object(new C(length)) : new Array(length);\n        var value;\n        for (i = 0; i < length; ++i) {\n          value = arrayLike[i];\n          if (mapping) {\n            value = typeof T === 'undefined' ? mapFn(value, i) : _call(mapFn, T, value, i);\n          }\n          createDataPropertyOrThrow(result, i, value);\n        }\n      }\n\n      result.length = length;\n      return result;\n    },\n\n    of: function of() {\n      var len = arguments.length;\n      var C = this;\n      var A = isArray(C) || !ES.IsCallable(C) ? new Array(len) : ES.Construct(C, [len]);\n      for (var k = 0; k < len; ++k) {\n        createDataPropertyOrThrow(A, k, arguments[k]);\n      }\n      A.length = len;\n      return A;\n    }\n  };\n  defineProperties(Array, ArrayShims);\n  addDefaultSpecies(Array);\n\n  // Our ArrayIterator is private; see\n  // https://github.com/paulmillr/es6-shim/issues/252\n  ArrayIterator = function (array, kind) {\n    this.i = 0;\n    this.array = array;\n    this.kind = kind;\n  };\n\n  defineProperties(ArrayIterator.prototype, {\n    next: function () {\n      var i = this.i;\n      var array = this.array;\n      if (!(this instanceof ArrayIterator)) {\n        throw new TypeError('Not an ArrayIterator');\n      }\n      if (typeof array !== 'undefined') {\n        var len = ES.ToLength(array.length);\n        if (i < len) {\n        //for (; i < len; i++) {\n          var kind = this.kind;\n          var retval;\n          if (kind === 'key') {\n            retval = i;\n          } else if (kind === 'value') {\n            retval = array[i];\n          } else if (kind === 'entry') {\n            retval = [i, array[i]];\n          }\n          this.i = i + 1;\n          return iteratorResult(retval);\n        }\n      }\n      this.array = void 0;\n      return iteratorResult();\n    }\n  });\n  addIterator(ArrayIterator.prototype);\n\n  /*\n  var orderKeys = function orderKeys(a, b) {\n    var aNumeric = String(ES.ToInteger(a)) === a;\n    var bNumeric = String(ES.ToInteger(b)) === b;\n    if (aNumeric && bNumeric) {\n      return b - a;\n    } else if (aNumeric && !bNumeric) {\n      return -1;\n    } else if (!aNumeric && bNumeric) {\n      return 1;\n    } else {\n      return a.localeCompare(b);\n    }\n  };\n\n  var getAllKeys = function getAllKeys(object) {\n    var ownKeys = [];\n    var keys = [];\n\n    for (var key in object) {\n      _push(_hasOwnProperty(object, key) ? ownKeys : keys, key);\n    }\n    _sort(ownKeys, orderKeys);\n    _sort(keys, orderKeys);\n\n    return _concat(ownKeys, keys);\n  };\n  */\n\n  // note: this is positioned here because it depends on ArrayIterator\n  var arrayOfSupportsSubclassing = Array.of === ArrayShims.of || (function () {\n    // Detects a bug in Webkit nightly r181886\n    var Foo = function Foo(len) { this.length = len; };\n    Foo.prototype = [];\n    var fooArr = Array.of.apply(Foo, [1, 2]);\n    return fooArr instanceof Foo && fooArr.length === 2;\n  }());\n  if (!arrayOfSupportsSubclassing) {\n    overrideNative(Array, 'of', ArrayShims.of);\n  }\n\n  var ArrayPrototypeShims = {\n    copyWithin: function copyWithin(target, start) {\n      var o = ES.ToObject(this);\n      var len = ES.ToLength(o.length);\n      var relativeTarget = ES.ToInteger(target);\n      var relativeStart = ES.ToInteger(start);\n      var to = relativeTarget < 0 ? _max(len + relativeTarget, 0) : _min(relativeTarget, len);\n      var from = relativeStart < 0 ? _max(len + relativeStart, 0) : _min(relativeStart, len);\n      var end;\n      if (arguments.length > 2) {\n        end = arguments[2];\n      }\n      var relativeEnd = typeof end === 'undefined' ? len : ES.ToInteger(end);\n      var finalItem = relativeEnd < 0 ? _max(len + relativeEnd, 0) : _min(relativeEnd, len);\n      var count = _min(finalItem - from, len - to);\n      var direction = 1;\n      if (from < to && to < (from + count)) {\n        direction = -1;\n        from += count - 1;\n        to += count - 1;\n      }\n      while (count > 0) {\n        if (from in o) {\n          o[to] = o[from];\n        } else {\n          delete o[to];\n        }\n        from += direction;\n        to += direction;\n        count -= 1;\n      }\n      return o;\n    },\n\n    fill: function fill(value) {\n      var start;\n      if (arguments.length > 1) {\n        start = arguments[1];\n      }\n      var end;\n      if (arguments.length > 2) {\n        end = arguments[2];\n      }\n      var O = ES.ToObject(this);\n      var len = ES.ToLength(O.length);\n      start = ES.ToInteger(typeof start === 'undefined' ? 0 : start);\n      end = ES.ToInteger(typeof end === 'undefined' ? len : end);\n\n      var relativeStart = start < 0 ? _max(len + start, 0) : _min(start, len);\n      var relativeEnd = end < 0 ? len + end : end;\n\n      for (var i = relativeStart; i < len && i < relativeEnd; ++i) {\n        O[i] = value;\n      }\n      return O;\n    },\n\n    find: function find(predicate) {\n      var list = ES.ToObject(this);\n      var length = ES.ToLength(list.length);\n      if (!ES.IsCallable(predicate)) {\n        throw new TypeError('Array#find: predicate must be a function');\n      }\n      var thisArg = arguments.length > 1 ? arguments[1] : null;\n      for (var i = 0, value; i < length; i++) {\n        value = list[i];\n        if (thisArg) {\n          if (_call(predicate, thisArg, value, i, list)) {\n            return value;\n          }\n        } else if (predicate(value, i, list)) {\n          return value;\n        }\n      }\n    },\n\n    findIndex: function findIndex(predicate) {\n      var list = ES.ToObject(this);\n      var length = ES.ToLength(list.length);\n      if (!ES.IsCallable(predicate)) {\n        throw new TypeError('Array#findIndex: predicate must be a function');\n      }\n      var thisArg = arguments.length > 1 ? arguments[1] : null;\n      for (var i = 0; i < length; i++) {\n        if (thisArg) {\n          if (_call(predicate, thisArg, list[i], i, list)) {\n            return i;\n          }\n        } else if (predicate(list[i], i, list)) {\n          return i;\n        }\n      }\n      return -1;\n    },\n\n    keys: function keys() {\n      return new ArrayIterator(this, 'key');\n    },\n\n    values: function values() {\n      return new ArrayIterator(this, 'value');\n    },\n\n    entries: function entries() {\n      return new ArrayIterator(this, 'entry');\n    }\n  };\n  // Safari 7.1 defines Array#keys and Array#entries natively,\n  // but the resulting ArrayIterator objects don't have a \"next\" method.\n  if (Array.prototype.keys && !ES.IsCallable([1].keys().next)) {\n    delete Array.prototype.keys;\n  }\n  if (Array.prototype.entries && !ES.IsCallable([1].entries().next)) {\n    delete Array.prototype.entries;\n  }\n\n  // Chrome 38 defines Array#keys and Array#entries, and Array#@@iterator, but not Array#values\n  if (Array.prototype.keys && Array.prototype.entries && !Array.prototype.values && Array.prototype[$iterator$]) {\n    defineProperties(Array.prototype, {\n      values: Array.prototype[$iterator$]\n    });\n    if (Type.symbol(Symbol.unscopables)) {\n      Array.prototype[Symbol.unscopables].values = true;\n    }\n  }\n  // Chrome 40 defines Array#values with the incorrect name, although Array#{keys,entries} have the correct name\n  if (functionsHaveNames && Array.prototype.values && Array.prototype.values.name !== 'values') {\n    var originalArrayPrototypeValues = Array.prototype.values;\n    overrideNative(Array.prototype, 'values', function values() { return ES.Call(originalArrayPrototypeValues, this, arguments); });\n    defineProperty(Array.prototype, $iterator$, Array.prototype.values, true);\n  }\n  defineProperties(Array.prototype, ArrayPrototypeShims);\n\n  if (1 / [true].indexOf(true, -0) < 0) {\n    // indexOf when given a position arg of -0 should return +0.\n    // https://github.com/tc39/ecma262/pull/316\n    defineProperty(Array.prototype, 'indexOf', function indexOf(searchElement) {\n      var value = _arrayIndexOfApply(this, arguments);\n      if (value === 0 && (1 / value) < 0) {\n        return 0;\n      }\n      return value;\n    }, true);\n  }\n\n  addIterator(Array.prototype, function () { return this.values(); });\n  // Chrome defines keys/values/entries on Array, but doesn't give us\n  // any way to identify its iterator.  So add our own shimmed field.\n  if (Object.getPrototypeOf) {\n    addIterator(Object.getPrototypeOf([].values()));\n  }\n\n  // note: this is positioned here because it relies on Array#entries\n  var arrayFromSwallowsNegativeLengths = (function () {\n    // Detects a Firefox bug in v32\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1063993\n    return valueOrFalseIfThrows(function () {\n      return Array.from({ length: -1 }).length === 0;\n    });\n  }());\n  var arrayFromHandlesIterables = (function () {\n    // Detects a bug in Webkit nightly r181886\n    var arr = Array.from([0].entries());\n    return arr.length === 1 && isArray(arr[0]) && arr[0][0] === 0 && arr[0][1] === 0;\n  }());\n  if (!arrayFromSwallowsNegativeLengths || !arrayFromHandlesIterables) {\n    overrideNative(Array, 'from', ArrayShims.from);\n  }\n  var arrayFromHandlesUndefinedMapFunction = (function () {\n    // Microsoft Edge v0.11 throws if the mapFn argument is *provided* but undefined,\n    // but the spec doesn't care if it's provided or not - undefined doesn't throw.\n    return valueOrFalseIfThrows(function () {\n      return Array.from([0], void 0);\n    });\n  }());\n  if (!arrayFromHandlesUndefinedMapFunction) {\n    var origArrayFrom = Array.from;\n    overrideNative(Array, 'from', function from(items) {\n      if (arguments.length > 1 && typeof arguments[1] !== 'undefined') {\n        return ES.Call(origArrayFrom, this, arguments);\n      } else {\n        return _call(origArrayFrom, this, items);\n      }\n    });\n  }\n\n  var int32sAsOne = -(Math.pow(2, 32) - 1);\n  var toLengthsCorrectly = function (method, reversed) {\n    var obj = { length: int32sAsOne };\n    obj[reversed ? (obj.length >>> 0) - 1 : 0] = true;\n    return valueOrFalseIfThrows(function () {\n      _call(method, obj, function () {\n        // note: in nonconforming browsers, this will be called\n        // -1 >>> 0 times, which is 4294967295, so the throw matters.\n        throw new RangeError('should not reach here');\n      }, []);\n      return true;\n    });\n  };\n  if (!toLengthsCorrectly(Array.prototype.forEach)) {\n    var originalForEach = Array.prototype.forEach;\n    overrideNative(Array.prototype, 'forEach', function forEach(callbackFn) {\n      return ES.Call(originalForEach, this.length >= 0 ? this : [], arguments);\n    });\n  }\n  if (!toLengthsCorrectly(Array.prototype.map)) {\n    var originalMap = Array.prototype.map;\n    overrideNative(Array.prototype, 'map', function map(callbackFn) {\n      return ES.Call(originalMap, this.length >= 0 ? this : [], arguments);\n    });\n  }\n  if (!toLengthsCorrectly(Array.prototype.filter)) {\n    var originalFilter = Array.prototype.filter;\n    overrideNative(Array.prototype, 'filter', function filter(callbackFn) {\n      return ES.Call(originalFilter, this.length >= 0 ? this : [], arguments);\n    });\n  }\n  if (!toLengthsCorrectly(Array.prototype.some)) {\n    var originalSome = Array.prototype.some;\n    overrideNative(Array.prototype, 'some', function some(callbackFn) {\n      return ES.Call(originalSome, this.length >= 0 ? this : [], arguments);\n    });\n  }\n  if (!toLengthsCorrectly(Array.prototype.every)) {\n    var originalEvery = Array.prototype.every;\n    overrideNative(Array.prototype, 'every', function every(callbackFn) {\n      return ES.Call(originalEvery, this.length >= 0 ? this : [], arguments);\n    });\n  }\n  if (!toLengthsCorrectly(Array.prototype.reduce)) {\n    var originalReduce = Array.prototype.reduce;\n    overrideNative(Array.prototype, 'reduce', function reduce(callbackFn) {\n      return ES.Call(originalReduce, this.length >= 0 ? this : [], arguments);\n    });\n  }\n  if (!toLengthsCorrectly(Array.prototype.reduceRight, true)) {\n    var originalReduceRight = Array.prototype.reduceRight;\n    overrideNative(Array.prototype, 'reduceRight', function reduceRight(callbackFn) {\n      return ES.Call(originalReduceRight, this.length >= 0 ? this : [], arguments);\n    });\n  }\n\n  var lacksOctalSupport = Number('0o10') !== 8;\n  var lacksBinarySupport = Number('0b10') !== 2;\n  var trimsNonWhitespace = _some(nonWS, function (c) {\n    return Number(c + 0 + c) === 0;\n  });\n  if (lacksOctalSupport || lacksBinarySupport || trimsNonWhitespace) {\n    var OrigNumber = Number;\n    var binaryRegex = /^0b[01]+$/i;\n    var octalRegex = /^0o[0-7]+$/i;\n    // Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is an own property of regexes. wtf.\n    var isBinary = binaryRegex.test.bind(binaryRegex);\n    var isOctal = octalRegex.test.bind(octalRegex);\n    var toPrimitive = function (O, hint) { // need to replace this with `es-to-primitive/es6`\n      var result;\n      if (typeof O.valueOf === 'function') {\n        result = O.valueOf();\n        if (Type.primitive(result)) {\n          return result;\n        }\n      }\n      if (typeof O.toString === 'function') {\n        result = O.toString();\n        if (Type.primitive(result)) {\n          return result;\n        }\n      }\n      throw new TypeError('No default value');\n    };\n    var hasNonWS = nonWSregex.test.bind(nonWSregex);\n    var isBadHex = isBadHexRegex.test.bind(isBadHexRegex);\n    var NumberShim = (function () {\n      // this is wrapped in an IIFE because of IE 6-8's wacky scoping issues with named function expressions.\n      var NumberShim = function Number(value) {\n        var primValue;\n        if (arguments.length > 0) {\n          primValue = Type.primitive(value) ? value : toPrimitive(value, 'number');\n        } else {\n          primValue = 0;\n        }\n        if (typeof primValue === 'string') {\n          primValue = ES.Call(trimShim, primValue);\n          if (isBinary(primValue)) {\n            primValue = parseInt(_strSlice(primValue, 2), 2);\n          } else if (isOctal(primValue)) {\n            primValue = parseInt(_strSlice(primValue, 2), 8);\n          } else if (hasNonWS(primValue) || isBadHex(primValue)) {\n            primValue = NaN;\n          }\n        }\n        var receiver = this;\n        var valueOfSucceeds = valueOrFalseIfThrows(function () {\n          OrigNumber.prototype.valueOf.call(receiver);\n          return true;\n        });\n        if (receiver instanceof NumberShim && !valueOfSucceeds) {\n          return new OrigNumber(primValue);\n        }\n        return OrigNumber(primValue);\n      };\n      return NumberShim;\n    }());\n    wrapConstructor(OrigNumber, NumberShim, {});\n    // this is necessary for ES3 browsers, where these properties are non-enumerable.\n    defineProperties(NumberShim, {\n      NaN: OrigNumber.NaN,\n      MAX_VALUE: OrigNumber.MAX_VALUE,\n      MIN_VALUE: OrigNumber.MIN_VALUE,\n      NEGATIVE_INFINITY: OrigNumber.NEGATIVE_INFINITY,\n      POSITIVE_INFINITY: OrigNumber.POSITIVE_INFINITY\n    });\n    /* eslint-disable no-undef, no-global-assign */\n    Number = NumberShim;\n    Value.redefine(globals, 'Number', NumberShim);\n    /* eslint-enable no-undef, no-global-assign */\n  }\n\n  var maxSafeInteger = Math.pow(2, 53) - 1;\n  defineProperties(Number, {\n    MAX_SAFE_INTEGER: maxSafeInteger,\n    MIN_SAFE_INTEGER: -maxSafeInteger,\n    EPSILON: 2.220446049250313e-16,\n\n    parseInt: globals.parseInt,\n    parseFloat: globals.parseFloat,\n\n    isFinite: numberIsFinite,\n\n    isInteger: function isInteger(value) {\n      return numberIsFinite(value) && ES.ToInteger(value) === value;\n    },\n\n    isSafeInteger: function isSafeInteger(value) {\n      return Number.isInteger(value) && _abs(value) <= Number.MAX_SAFE_INTEGER;\n    },\n\n    isNaN: numberIsNaN\n  });\n  // Firefox 37 has a conforming Number.parseInt, but it's not === to the global parseInt (fixed in v40)\n  defineProperty(Number, 'parseInt', globals.parseInt, Number.parseInt !== globals.parseInt);\n\n  // Work around bugs in Array#find and Array#findIndex -- early\n  // implementations skipped holes in sparse arrays. (Note that the\n  // implementations of find/findIndex indirectly use shimmed\n  // methods of Number, so this test has to happen down here.)\n  /* eslint-disable no-sparse-arrays */\n  if ([, 1].find(function () { return true; }) === 1) {\n    overrideNative(Array.prototype, 'find', ArrayPrototypeShims.find);\n  }\n  if ([, 1].findIndex(function () { return true; }) !== 0) {\n    overrideNative(Array.prototype, 'findIndex', ArrayPrototypeShims.findIndex);\n  }\n  /* eslint-enable no-sparse-arrays */\n\n  var isEnumerableOn = Function.bind.call(Function.bind, Object.prototype.propertyIsEnumerable);\n  var ensureEnumerable = function ensureEnumerable(obj, prop) {\n    if (supportsDescriptors && isEnumerableOn(obj, prop)) {\n      Object.defineProperty(obj, prop, { enumerable: false });\n    }\n  };\n  var sliceArgs = function sliceArgs() {\n    // per https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments\n    // and https://gist.github.com/WebReflection/4327762cb87a8c634a29\n    var initial = Number(this);\n    var len = arguments.length;\n    var desiredArgCount = len - initial;\n    var args = new Array(desiredArgCount < 0 ? 0 : desiredArgCount);\n    for (var i = initial; i < len; ++i) {\n      args[i - initial] = arguments[i];\n    }\n    return args;\n  };\n  var assignTo = function assignTo(source) {\n    return function assignToSource(target, key) {\n      target[key] = source[key];\n      return target;\n    };\n  };\n  var assignReducer = function (target, source) {\n    var sourceKeys = keys(Object(source));\n    var symbols;\n    if (ES.IsCallable(Object.getOwnPropertySymbols)) {\n      symbols = _filter(Object.getOwnPropertySymbols(Object(source)), isEnumerableOn(source));\n    }\n    return _reduce(_concat(sourceKeys, symbols || []), assignTo(source), target);\n  };\n\n  var ObjectShims = {\n    // 19.1.3.1\n    assign: function (target, source) {\n      var to = ES.ToObject(target, 'Cannot convert undefined or null to object');\n      return _reduce(ES.Call(sliceArgs, 1, arguments), assignReducer, to);\n    },\n\n    // Added in WebKit in https://bugs.webkit.org/show_bug.cgi?id=143865\n    is: function is(a, b) {\n      return ES.SameValue(a, b);\n    }\n  };\n  var assignHasPendingExceptions = Object.assign && Object.preventExtensions && (function () {\n    // Firefox 37 still has \"pending exception\" logic in its Object.assign implementation,\n    // which is 72% slower than our shim, and Firefox 40's native implementation.\n    var thrower = Object.preventExtensions({ 1: 2 });\n    try {\n      Object.assign(thrower, 'xy');\n    } catch (e) {\n      return thrower[1] === 'y';\n    }\n  }());\n  if (assignHasPendingExceptions) {\n    overrideNative(Object, 'assign', ObjectShims.assign);\n  }\n  defineProperties(Object, ObjectShims);\n\n  if (supportsDescriptors) {\n    var ES5ObjectShims = {\n      // 19.1.3.9\n      // shim from https://gist.github.com/WebReflection/5593554\n      setPrototypeOf: (function (Object, magic) {\n        var set;\n\n        var checkArgs = function (O, proto) {\n          if (!ES.TypeIsObject(O)) {\n            throw new TypeError('cannot set prototype on a non-object');\n          }\n          if (!(proto === null || ES.TypeIsObject(proto))) {\n            throw new TypeError('can only set prototype to an object or null' + proto);\n          }\n        };\n\n        var setPrototypeOf = function (O, proto) {\n          checkArgs(O, proto);\n          _call(set, O, proto);\n          return O;\n        };\n\n        try {\n          // this works already in Firefox and Safari\n          set = Object.getOwnPropertyDescriptor(Object.prototype, magic).set;\n          _call(set, {}, null);\n        } catch (e) {\n          if (Object.prototype !== {}[magic]) {\n            // IE < 11 cannot be shimmed\n            return;\n          }\n          // probably Chrome or some old Mobile stock browser\n          set = function (proto) {\n            this[magic] = proto;\n          };\n          // please note that this will **not** work\n          // in those browsers that do not inherit\n          // __proto__ by mistake from Object.prototype\n          // in these cases we should probably throw an error\n          // or at least be informed about the issue\n          setPrototypeOf.polyfill = setPrototypeOf(\n            setPrototypeOf({}, null),\n            Object.prototype\n          ) instanceof Object;\n          // setPrototypeOf.polyfill === true means it works as meant\n          // setPrototypeOf.polyfill === false means it's not 100% reliable\n          // setPrototypeOf.polyfill === undefined\n          // or\n          // setPrototypeOf.polyfill ==  null means it's not a polyfill\n          // which means it works as expected\n          // we can even delete Object.prototype.__proto__;\n        }\n        return setPrototypeOf;\n      }(Object, '__proto__'))\n    };\n\n    defineProperties(Object, ES5ObjectShims);\n  }\n\n  // Workaround bug in Opera 12 where setPrototypeOf(x, null) doesn't work,\n  // but Object.create(null) does.\n  if (Object.setPrototypeOf && Object.getPrototypeOf &&\n      Object.getPrototypeOf(Object.setPrototypeOf({}, null)) !== null &&\n      Object.getPrototypeOf(Object.create(null)) === null) {\n    (function () {\n      var FAKENULL = Object.create(null);\n      var gpo = Object.getPrototypeOf;\n      var spo = Object.setPrototypeOf;\n      Object.getPrototypeOf = function (o) {\n        var result = gpo(o);\n        return result === FAKENULL ? null : result;\n      };\n      Object.setPrototypeOf = function (o, p) {\n        var proto = p === null ? FAKENULL : p;\n        return spo(o, proto);\n      };\n      Object.setPrototypeOf.polyfill = false;\n    }());\n  }\n\n  var objectKeysAcceptsPrimitives = !throwsError(function () { return Object.keys('foo'); });\n  if (!objectKeysAcceptsPrimitives) {\n    var originalObjectKeys = Object.keys;\n    overrideNative(Object, 'keys', function keys(value) {\n      return originalObjectKeys(ES.ToObject(value));\n    });\n    keys = Object.keys;\n  }\n  var objectKeysRejectsRegex = throwsError(function () { return Object.keys(/a/g); });\n  if (objectKeysRejectsRegex) {\n    var regexRejectingObjectKeys = Object.keys;\n    overrideNative(Object, 'keys', function keys(value) {\n      if (Type.regex(value)) {\n        var regexKeys = [];\n        for (var k in value) {\n          if (_hasOwnProperty(value, k)) {\n            _push(regexKeys, k);\n          }\n        }\n        return regexKeys;\n      }\n      return regexRejectingObjectKeys(value);\n    });\n    keys = Object.keys;\n  }\n\n  if (Object.getOwnPropertyNames) {\n    var objectGOPNAcceptsPrimitives = !throwsError(function () { return Object.getOwnPropertyNames('foo'); });\n    if (!objectGOPNAcceptsPrimitives) {\n      var cachedWindowNames = typeof window === 'object' ? Object.getOwnPropertyNames(window) : [];\n      var originalObjectGetOwnPropertyNames = Object.getOwnPropertyNames;\n      overrideNative(Object, 'getOwnPropertyNames', function getOwnPropertyNames(value) {\n        var val = ES.ToObject(value);\n        if (_toString(val) === '[object Window]') {\n          try {\n            return originalObjectGetOwnPropertyNames(val);\n          } catch (e) {\n            // IE bug where layout engine calls userland gOPN for cross-domain `window` objects\n            return _concat([], cachedWindowNames);\n          }\n        }\n        return originalObjectGetOwnPropertyNames(val);\n      });\n    }\n  }\n  if (Object.getOwnPropertyDescriptor) {\n    var objectGOPDAcceptsPrimitives = !throwsError(function () { return Object.getOwnPropertyDescriptor('foo', 'bar'); });\n    if (!objectGOPDAcceptsPrimitives) {\n      var originalObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n      overrideNative(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(value, property) {\n        return originalObjectGetOwnPropertyDescriptor(ES.ToObject(value), property);\n      });\n    }\n  }\n  if (Object.seal) {\n    var objectSealAcceptsPrimitives = !throwsError(function () { return Object.seal('foo'); });\n    if (!objectSealAcceptsPrimitives) {\n      var originalObjectSeal = Object.seal;\n      overrideNative(Object, 'seal', function seal(value) {\n        if (!ES.TypeIsObject(value)) { return value; }\n        return originalObjectSeal(value);\n      });\n    }\n  }\n  if (Object.isSealed) {\n    var objectIsSealedAcceptsPrimitives = !throwsError(function () { return Object.isSealed('foo'); });\n    if (!objectIsSealedAcceptsPrimitives) {\n      var originalObjectIsSealed = Object.isSealed;\n      overrideNative(Object, 'isSealed', function isSealed(value) {\n        if (!ES.TypeIsObject(value)) { return true; }\n        return originalObjectIsSealed(value);\n      });\n    }\n  }\n  if (Object.freeze) {\n    var objectFreezeAcceptsPrimitives = !throwsError(function () { return Object.freeze('foo'); });\n    if (!objectFreezeAcceptsPrimitives) {\n      var originalObjectFreeze = Object.freeze;\n      overrideNative(Object, 'freeze', function freeze(value) {\n        if (!ES.TypeIsObject(value)) { return value; }\n        return originalObjectFreeze(value);\n      });\n    }\n  }\n  if (Object.isFrozen) {\n    var objectIsFrozenAcceptsPrimitives = !throwsError(function () { return Object.isFrozen('foo'); });\n    if (!objectIsFrozenAcceptsPrimitives) {\n      var originalObjectIsFrozen = Object.isFrozen;\n      overrideNative(Object, 'isFrozen', function isFrozen(value) {\n        if (!ES.TypeIsObject(value)) { return true; }\n        return originalObjectIsFrozen(value);\n      });\n    }\n  }\n  if (Object.preventExtensions) {\n    var objectPreventExtensionsAcceptsPrimitives = !throwsError(function () { return Object.preventExtensions('foo'); });\n    if (!objectPreventExtensionsAcceptsPrimitives) {\n      var originalObjectPreventExtensions = Object.preventExtensions;\n      overrideNative(Object, 'preventExtensions', function preventExtensions(value) {\n        if (!ES.TypeIsObject(value)) { return value; }\n        return originalObjectPreventExtensions(value);\n      });\n    }\n  }\n  if (Object.isExtensible) {\n    var objectIsExtensibleAcceptsPrimitives = !throwsError(function () { return Object.isExtensible('foo'); });\n    if (!objectIsExtensibleAcceptsPrimitives) {\n      var originalObjectIsExtensible = Object.isExtensible;\n      overrideNative(Object, 'isExtensible', function isExtensible(value) {\n        if (!ES.TypeIsObject(value)) { return false; }\n        return originalObjectIsExtensible(value);\n      });\n    }\n  }\n  if (Object.getPrototypeOf) {\n    var objectGetProtoAcceptsPrimitives = !throwsError(function () { return Object.getPrototypeOf('foo'); });\n    if (!objectGetProtoAcceptsPrimitives) {\n      var originalGetProto = Object.getPrototypeOf;\n      overrideNative(Object, 'getPrototypeOf', function getPrototypeOf(value) {\n        return originalGetProto(ES.ToObject(value));\n      });\n    }\n  }\n\n  var hasFlags = supportsDescriptors && (function () {\n    var desc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags');\n    return desc && ES.IsCallable(desc.get);\n  }());\n  if (supportsDescriptors && !hasFlags) {\n    var regExpFlagsGetter = function flags() {\n      if (!ES.TypeIsObject(this)) {\n        throw new TypeError('Method called on incompatible type: must be an object.');\n      }\n      var result = '';\n      if (this.global) {\n        result += 'g';\n      }\n      if (this.ignoreCase) {\n        result += 'i';\n      }\n      if (this.multiline) {\n        result += 'm';\n      }\n      if (this.unicode) {\n        result += 'u';\n      }\n      if (this.sticky) {\n        result += 'y';\n      }\n      return result;\n    };\n\n    Value.getter(RegExp.prototype, 'flags', regExpFlagsGetter);\n  }\n\n  var regExpSupportsFlagsWithRegex = supportsDescriptors && valueOrFalseIfThrows(function () {\n    return String(new RegExp(/a/g, 'i')) === '/a/i';\n  });\n  var regExpNeedsToSupportSymbolMatch = hasSymbols && supportsDescriptors && (function () {\n    // Edge 0.12 supports flags fully, but does not support Symbol.match\n    var regex = /./;\n    regex[Symbol.match] = false;\n    return RegExp(regex) === regex;\n  }());\n\n  var regexToStringIsGeneric = valueOrFalseIfThrows(function () {\n    return RegExp.prototype.toString.call({ source: 'abc' }) === '/abc/';\n  });\n  var regexToStringSupportsGenericFlags = regexToStringIsGeneric && valueOrFalseIfThrows(function () {\n    return RegExp.prototype.toString.call({ source: 'a', flags: 'b' }) === '/a/b';\n  });\n  if (!regexToStringIsGeneric || !regexToStringSupportsGenericFlags) {\n    var origRegExpToString = RegExp.prototype.toString;\n    defineProperty(RegExp.prototype, 'toString', function toString() {\n      var R = ES.RequireObjectCoercible(this);\n      if (Type.regex(R)) {\n        return _call(origRegExpToString, R);\n      }\n      var pattern = $String(R.source);\n      var flags = $String(R.flags);\n      return '/' + pattern + '/' + flags;\n    }, true);\n    Value.preserveToString(RegExp.prototype.toString, origRegExpToString);\n  }\n\n  if (supportsDescriptors && (!regExpSupportsFlagsWithRegex || regExpNeedsToSupportSymbolMatch)) {\n    var flagsGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get;\n    var sourceDesc = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source') || {};\n    var legacySourceGetter = function () {\n      // prior to it being a getter, it's own + nonconfigurable\n      return this.source;\n    };\n    var sourceGetter = ES.IsCallable(sourceDesc.get) ? sourceDesc.get : legacySourceGetter;\n\n    var OrigRegExp = RegExp;\n    var RegExpShim = (function () {\n      return function RegExp(pattern, flags) {\n        var patternIsRegExp = ES.IsRegExp(pattern);\n        var calledWithNew = this instanceof RegExp;\n        if (!calledWithNew && patternIsRegExp && typeof flags === 'undefined' && pattern.constructor === RegExp) {\n          return pattern;\n        }\n\n        var P = pattern;\n        var F = flags;\n        if (Type.regex(pattern)) {\n          P = ES.Call(sourceGetter, pattern);\n          F = typeof flags === 'undefined' ? ES.Call(flagsGetter, pattern) : flags;\n          return new RegExp(P, F);\n        } else if (patternIsRegExp) {\n          P = pattern.source;\n          F = typeof flags === 'undefined' ? pattern.flags : flags;\n        }\n        return new OrigRegExp(pattern, flags);\n      };\n    }());\n    wrapConstructor(OrigRegExp, RegExpShim, {\n      $input: true // Chrome < v39 & Opera < 26 have a nonstandard \"$input\" property\n    });\n    /* eslint-disable no-undef, no-global-assign */\n    RegExp = RegExpShim;\n    Value.redefine(globals, 'RegExp', RegExpShim);\n    /* eslint-enable no-undef, no-global-assign */\n  }\n\n  if (supportsDescriptors) {\n    var regexGlobals = {\n      input: '$_',\n      lastMatch: '$&',\n      lastParen: '$+',\n      leftContext: '$`',\n      rightContext: '$\\''\n    };\n    _forEach(keys(regexGlobals), function (prop) {\n      if (prop in RegExp && !(regexGlobals[prop] in RegExp)) {\n        Value.getter(RegExp, regexGlobals[prop], function get() {\n          return RegExp[prop];\n        });\n      }\n    });\n  }\n  addDefaultSpecies(RegExp);\n\n  var inverseEpsilon = 1 / Number.EPSILON;\n  var roundTiesToEven = function roundTiesToEven(n) {\n    // Even though this reduces down to `return n`, it takes advantage of built-in rounding.\n    return (n + inverseEpsilon) - inverseEpsilon;\n  };\n  var BINARY_32_EPSILON = Math.pow(2, -23);\n  var BINARY_32_MAX_VALUE = Math.pow(2, 127) * (2 - BINARY_32_EPSILON);\n  var BINARY_32_MIN_VALUE = Math.pow(2, -126);\n  var E = Math.E;\n  var LOG2E = Math.LOG2E;\n  var LOG10E = Math.LOG10E;\n  var numberCLZ = Number.prototype.clz;\n  delete Number.prototype.clz; // Safari 8 has Number#clz\n\n  var MathShims = {\n    acosh: function acosh(value) {\n      var x = Number(value);\n      if (numberIsNaN(x) || value < 1) { return NaN; }\n      if (x === 1) { return 0; }\n      if (x === Infinity) { return x; }\n\n      var xInvSquared = 1 / (x * x);\n      if (x < 2) {\n        return _log1p(x - 1 + (_sqrt(1 - xInvSquared) * x));\n      }\n      var halfX = x / 2;\n      return _log1p(halfX + (_sqrt(1 - xInvSquared) * halfX) - 1) + (1 / LOG2E);\n    },\n\n    asinh: function asinh(value) {\n      var x = Number(value);\n      if (x === 0 || !globalIsFinite(x)) {\n        return x;\n      }\n\n      var a = _abs(x);\n      var aSquared = a * a;\n      var s = _sign(x);\n      if (a < 1) {\n        return s * _log1p(a + (aSquared / (_sqrt(aSquared + 1) + 1)));\n      }\n      return s * (_log1p((a / 2) + (_sqrt(1 + (1 / aSquared)) * a / 2) - 1) + (1 / LOG2E));\n    },\n\n    atanh: function atanh(value) {\n      var x = Number(value);\n\n      if (x === 0) { return x; }\n      if (x === -1) { return -Infinity; }\n      if (x === 1) { return Infinity; }\n      if (numberIsNaN(x) || x < -1 || x > 1) {\n        return NaN;\n      }\n\n      var a = _abs(x);\n      return _sign(x) * _log1p(2 * a / (1 - a)) / 2;\n    },\n\n    cbrt: function cbrt(value) {\n      var x = Number(value);\n      if (x === 0) { return x; }\n      var negate = x < 0;\n      var result;\n      if (negate) { x = -x; }\n      if (x === Infinity) {\n        result = Infinity;\n      } else {\n        result = _exp(_log(x) / 3);\n        // from http://en.wikipedia.org/wiki/Cube_root#Numerical_methods\n        result = ((x / (result * result)) + (2 * result)) / 3;\n      }\n      return negate ? -result : result;\n    },\n\n    clz32: function clz32(value) {\n      // See https://bugs.ecmascript.org/show_bug.cgi?id=2465\n      var x = Number(value);\n      var number = ES.ToUint32(x);\n      if (number === 0) {\n        return 32;\n      }\n      return numberCLZ ? ES.Call(numberCLZ, number) : 31 - _floor(_log(number + 0.5) * LOG2E);\n    },\n\n    cosh: function cosh(value) {\n      var x = Number(value);\n      if (x === 0) { return 1; } // +0 or -0\n      if (numberIsNaN(x)) { return NaN; }\n      if (!globalIsFinite(x)) { return Infinity; }\n\n      var t = _exp(_abs(x) - 1);\n      return (t + (1 / (t * E * E))) * (E / 2);\n    },\n\n    expm1: function expm1(value) {\n      var x = Number(value);\n      if (x === -Infinity) { return -1; }\n      if (!globalIsFinite(x) || x === 0) { return x; }\n      if (_abs(x) > 0.5) {\n        return _exp(x) - 1;\n      }\n      // A more precise approximation using Taylor series expansion\n      // from https://github.com/paulmillr/es6-shim/issues/314#issuecomment-70293986\n      var t = x;\n      var sum = 0;\n      var n = 1;\n      while (sum + t !== sum) {\n        sum += t;\n        n += 1;\n        t *= x / n;\n      }\n      return sum;\n    },\n\n    hypot: function hypot(x, y) {\n      var result = 0;\n      var largest = 0;\n      for (var i = 0; i < arguments.length; ++i) {\n        var value = _abs(Number(arguments[i]));\n        if (largest < value) {\n          result *= (largest / value) * (largest / value);\n          result += 1;\n          largest = value;\n        } else {\n          result += value > 0 ? (value / largest) * (value / largest) : value;\n        }\n      }\n      return largest === Infinity ? Infinity : largest * _sqrt(result);\n    },\n\n    log2: function log2(value) {\n      return _log(value) * LOG2E;\n    },\n\n    log10: function log10(value) {\n      return _log(value) * LOG10E;\n    },\n\n    log1p: _log1p,\n\n    sign: _sign,\n\n    sinh: function sinh(value) {\n      var x = Number(value);\n      if (!globalIsFinite(x) || x === 0) { return x; }\n\n      var a = _abs(x);\n      if (a < 1) {\n        var u = Math.expm1(a);\n        return _sign(x) * u * (1 + (1 / (u + 1))) / 2;\n      }\n      var t = _exp(a - 1);\n      return _sign(x) * (t - (1 / (t * E * E))) * (E / 2);\n    },\n\n    tanh: function tanh(value) {\n      var x = Number(value);\n      if (numberIsNaN(x) || x === 0) { return x; }\n      // can exit early at +-20 as JS loses precision for true value at this integer\n      if (x >= 20) { return 1; }\n      if (x <= -20) { return -1; }\n\n      return (Math.expm1(x) - Math.expm1(-x)) / (_exp(x) + _exp(-x));\n    },\n\n    trunc: function trunc(value) {\n      var x = Number(value);\n      return x < 0 ? -_floor(-x) : _floor(x);\n    },\n\n    imul: function imul(x, y) {\n      // taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\n      var a = ES.ToUint32(x);\n      var b = ES.ToUint32(y);\n      var ah = (a >>> 16) & 0xffff;\n      var al = a & 0xffff;\n      var bh = (b >>> 16) & 0xffff;\n      var bl = b & 0xffff;\n      // the shift by 0 fixes the sign on the high part\n      // the final |0 converts the unsigned value into a signed value\n      return (al * bl) + ((((ah * bl) + (al * bh)) << 16) >>> 0) | 0;\n    },\n\n    fround: function fround(x) {\n      var v = Number(x);\n      if (v === 0 || v === Infinity || v === -Infinity || numberIsNaN(v)) {\n        return v;\n      }\n      var sign = _sign(v);\n      var abs = _abs(v);\n      if (abs < BINARY_32_MIN_VALUE) {\n        return sign * roundTiesToEven(abs / BINARY_32_MIN_VALUE / BINARY_32_EPSILON) * BINARY_32_MIN_VALUE * BINARY_32_EPSILON;\n      }\n      // Veltkamp's splitting (?)\n      var a = (1 + (BINARY_32_EPSILON / Number.EPSILON)) * abs;\n      var result = a - (a - abs);\n      if (result > BINARY_32_MAX_VALUE || numberIsNaN(result)) {\n        return sign * Infinity;\n      }\n      return sign * result;\n    }\n  };\n\n  var withinULPDistance = function withinULPDistance(result, expected, distance) {\n    return _abs(1 - (result / expected)) / Number.EPSILON < (distance || 8);\n  };\n\n  defineProperties(Math, MathShims);\n  // Chrome < 40 sinh returns ∞ for large numbers\n  defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(710) === Infinity);\n  // Chrome < 40 cosh returns ∞ for large numbers\n  defineProperty(Math, 'cosh', MathShims.cosh, Math.cosh(710) === Infinity);\n  // IE 11 TP has an imprecise log1p: reports Math.log1p(-1e-17) as 0\n  defineProperty(Math, 'log1p', MathShims.log1p, Math.log1p(-1e-17) !== -1e-17);\n  // IE 11 TP has an imprecise asinh: reports Math.asinh(-1e7) as not exactly equal to -Math.asinh(1e7)\n  defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(-1e7) !== -Math.asinh(1e7));\n  // Chrome < 54 asinh returns ∞ for large numbers and should not\n  defineProperty(Math, 'asinh', MathShims.asinh, Math.asinh(1e+300) === Infinity);\n  // Chrome < 54 atanh incorrectly returns 0 for large numbers\n  defineProperty(Math, 'atanh', MathShims.atanh, Math.atanh(1e-300) === 0);\n  // Chrome 40 has an imprecise Math.tanh with very small numbers\n  defineProperty(Math, 'tanh', MathShims.tanh, Math.tanh(-2e-17) !== -2e-17);\n  // Chrome 40 loses Math.acosh precision with high numbers\n  defineProperty(Math, 'acosh', MathShims.acosh, Math.acosh(Number.MAX_VALUE) === Infinity);\n  // Chrome < 54 has an inaccurate acosh for EPSILON deltas\n  defineProperty(Math, 'acosh', MathShims.acosh, !withinULPDistance(Math.acosh(1 + Number.EPSILON), Math.sqrt(2 * Number.EPSILON)));\n  // Firefox 38 on Windows\n  defineProperty(Math, 'cbrt', MathShims.cbrt, !withinULPDistance(Math.cbrt(1e-300), 1e-100));\n  // node 0.11 has an imprecise Math.sinh with very small numbers\n  defineProperty(Math, 'sinh', MathShims.sinh, Math.sinh(-2e-17) !== -2e-17);\n  // FF 35 on Linux reports 22025.465794806725 for Math.expm1(10)\n  var expm1OfTen = Math.expm1(10);\n  defineProperty(Math, 'expm1', MathShims.expm1, expm1OfTen > 22025.465794806719 || expm1OfTen < 22025.4657948067165168);\n  // node v12.11 - v12.15 report NaN\n  defineProperty(Math, 'hypot', MathShims.hypot, Math.hypot(Infinity, NaN) !== Infinity);\n\n  var origMathRound = Math.round;\n  // breaks in e.g. Safari 8, Internet Explorer 11, Opera 12\n  var roundHandlesBoundaryConditions = Math.round(0.5 - (Number.EPSILON / 4)) === 0 &&\n    Math.round(-0.5 + (Number.EPSILON / 3.99)) === 1;\n\n  // When engines use Math.floor(x + 0.5) internally, Math.round can be buggy for large integers.\n  // This behavior should be governed by \"round to nearest, ties to even mode\"\n  // see http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-number-type\n  // These are the boundary cases where it breaks.\n  var smallestPositiveNumberWhereRoundBreaks = inverseEpsilon + 1;\n  var largestPositiveNumberWhereRoundBreaks = (2 * inverseEpsilon) - 1;\n  var roundDoesNotIncreaseIntegers = [\n    smallestPositiveNumberWhereRoundBreaks,\n    largestPositiveNumberWhereRoundBreaks\n  ].every(function (num) {\n    return Math.round(num) === num;\n  });\n  defineProperty(Math, 'round', function round(x) {\n    var floor = _floor(x);\n    var ceil = floor === -1 ? -0 : floor + 1;\n    return x - floor < 0.5 ? floor : ceil;\n  }, !roundHandlesBoundaryConditions || !roundDoesNotIncreaseIntegers);\n  Value.preserveToString(Math.round, origMathRound);\n\n  var origImul = Math.imul;\n  if (Math.imul(0xffffffff, 5) !== -5) {\n    // Safari 6.1, at least, reports \"0\" for this value\n    Math.imul = MathShims.imul;\n    Value.preserveToString(Math.imul, origImul);\n  }\n  if (Math.imul.length !== 2) {\n    // Safari 8.0.4 has a length of 1\n    // fixed in https://bugs.webkit.org/show_bug.cgi?id=143658\n    overrideNative(Math, 'imul', function imul(x, y) {\n      return ES.Call(origImul, Math, arguments);\n    });\n  }\n\n  // Promises\n  // Simplest possible implementation; use a 3rd-party library if you\n  // want the best possible speed and/or long stack traces.\n  var PromiseShim = (function () {\n    var setTimeout = globals.setTimeout;\n    // some environments don't have setTimeout - no way to shim here.\n    if (typeof setTimeout !== 'function' && typeof setTimeout !== 'object') { return; }\n\n    ES.IsPromise = function (promise) {\n      if (!ES.TypeIsObject(promise)) {\n        return false;\n      }\n      if (typeof promise._promise === 'undefined') {\n        return false; // uninitialized, or missing our hidden field.\n      }\n      return true;\n    };\n\n    // \"PromiseCapability\" in the spec is what most promise implementations\n    // call a \"deferred\".\n    var PromiseCapability = function (C) {\n      if (!ES.IsConstructor(C)) {\n        throw new TypeError('Bad promise constructor');\n      }\n      var capability = this;\n      var resolver = function (resolve, reject) {\n        if (capability.resolve !== void 0 || capability.reject !== void 0) {\n          throw new TypeError('Bad Promise implementation!');\n        }\n        capability.resolve = resolve;\n        capability.reject = reject;\n      };\n      // Initialize fields to inform optimizers about the object shape.\n      capability.resolve = void 0;\n      capability.reject = void 0;\n      capability.promise = new C(resolver);\n      if (!(ES.IsCallable(capability.resolve) && ES.IsCallable(capability.reject))) {\n        throw new TypeError('Bad promise constructor');\n      }\n    };\n\n    // find an appropriate setImmediate-alike\n    var makeZeroTimeout;\n    if (typeof window !== 'undefined' && ES.IsCallable(window.postMessage)) {\n      makeZeroTimeout = function () {\n        // from http://dbaron.org/log/20100309-faster-timeouts\n        var timeouts = [];\n        var messageName = 'zero-timeout-message';\n        var setZeroTimeout = function (fn) {\n          _push(timeouts, fn);\n          window.postMessage(messageName, '*');\n        };\n        var handleMessage = function (event) {\n          if (event.source === window && event.data === messageName) {\n            event.stopPropagation();\n            if (timeouts.length === 0) { return; }\n            var fn = _shift(timeouts);\n            fn();\n          }\n        };\n        window.addEventListener('message', handleMessage, true);\n        return setZeroTimeout;\n      };\n    }\n    var makePromiseAsap = function () {\n      // An efficient task-scheduler based on a pre-existing Promise\n      // implementation, which we can use even if we override the\n      // global Promise below (in order to workaround bugs)\n      // https://github.com/Raynos/observ-hash/issues/2#issuecomment-35857671\n      var P = globals.Promise;\n      var pr = P && P.resolve && P.resolve();\n      return pr && function (task) {\n        return pr.then(task);\n      };\n    };\n    var enqueue = ES.IsCallable(globals.setImmediate) ?\n      globals.setImmediate :\n      typeof process === 'object' && process.nextTick ? process.nextTick : makePromiseAsap() ||\n      (ES.IsCallable(makeZeroTimeout) ? makeZeroTimeout() : function (task) { setTimeout(task, 0); }); // fallback\n\n    // Constants for Promise implementation\n    var PROMISE_IDENTITY = function (x) { return x; };\n    var PROMISE_THROWER = function (e) { throw e; };\n    var PROMISE_PENDING = 0;\n    var PROMISE_FULFILLED = 1;\n    var PROMISE_REJECTED = 2;\n    // We store fulfill/reject handlers and capabilities in a single array.\n    var PROMISE_FULFILL_OFFSET = 0;\n    var PROMISE_REJECT_OFFSET = 1;\n    var PROMISE_CAPABILITY_OFFSET = 2;\n    // This is used in an optimization for chaining promises via then.\n    var PROMISE_FAKE_CAPABILITY = {};\n\n    var enqueuePromiseReactionJob = function (handler, capability, argument) {\n      enqueue(function () {\n        promiseReactionJob(handler, capability, argument);\n      });\n    };\n\n    var promiseReactionJob = function (handler, promiseCapability, argument) {\n      var handlerResult, f;\n      if (promiseCapability === PROMISE_FAKE_CAPABILITY) {\n        // Fast case, when we don't actually need to chain through to a\n        // (real) promiseCapability.\n        return handler(argument);\n      }\n      try {\n        handlerResult = handler(argument);\n        f = promiseCapability.resolve;\n      } catch (e) {\n        handlerResult = e;\n        f = promiseCapability.reject;\n      }\n      f(handlerResult);\n    };\n\n    var fulfillPromise = function (promise, value) {\n      var _promise = promise._promise;\n      var length = _promise.reactionLength;\n      if (length > 0) {\n        enqueuePromiseReactionJob(\n          _promise.fulfillReactionHandler0,\n          _promise.reactionCapability0,\n          value\n        );\n        _promise.fulfillReactionHandler0 = void 0;\n        _promise.rejectReactions0 = void 0;\n        _promise.reactionCapability0 = void 0;\n        if (length > 1) {\n          for (var i = 1, idx = 0; i < length; i++, idx += 3) {\n            enqueuePromiseReactionJob(\n              _promise[idx + PROMISE_FULFILL_OFFSET],\n              _promise[idx + PROMISE_CAPABILITY_OFFSET],\n              value\n            );\n            promise[idx + PROMISE_FULFILL_OFFSET] = void 0;\n            promise[idx + PROMISE_REJECT_OFFSET] = void 0;\n            promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0;\n          }\n        }\n      }\n      _promise.result = value;\n      _promise.state = PROMISE_FULFILLED;\n      _promise.reactionLength = 0;\n    };\n\n    var rejectPromise = function (promise, reason) {\n      var _promise = promise._promise;\n      var length = _promise.reactionLength;\n      if (length > 0) {\n        enqueuePromiseReactionJob(\n          _promise.rejectReactionHandler0,\n          _promise.reactionCapability0,\n          reason\n        );\n        _promise.fulfillReactionHandler0 = void 0;\n        _promise.rejectReactions0 = void 0;\n        _promise.reactionCapability0 = void 0;\n        if (length > 1) {\n          for (var i = 1, idx = 0; i < length; i++, idx += 3) {\n            enqueuePromiseReactionJob(\n              _promise[idx + PROMISE_REJECT_OFFSET],\n              _promise[idx + PROMISE_CAPABILITY_OFFSET],\n              reason\n            );\n            promise[idx + PROMISE_FULFILL_OFFSET] = void 0;\n            promise[idx + PROMISE_REJECT_OFFSET] = void 0;\n            promise[idx + PROMISE_CAPABILITY_OFFSET] = void 0;\n          }\n        }\n      }\n      _promise.result = reason;\n      _promise.state = PROMISE_REJECTED;\n      _promise.reactionLength = 0;\n    };\n\n    var createResolvingFunctions = function (promise) {\n      var alreadyResolved = false;\n      var resolve = function (resolution) {\n        var then;\n        if (alreadyResolved) { return; }\n        alreadyResolved = true;\n        if (resolution === promise) {\n          return rejectPromise(promise, new TypeError('Self resolution'));\n        }\n        if (!ES.TypeIsObject(resolution)) {\n          return fulfillPromise(promise, resolution);\n        }\n        try {\n          then = resolution.then;\n        } catch (e) {\n          return rejectPromise(promise, e);\n        }\n        if (!ES.IsCallable(then)) {\n          return fulfillPromise(promise, resolution);\n        }\n        enqueue(function () {\n          promiseResolveThenableJob(promise, resolution, then);\n        });\n      };\n      var reject = function (reason) {\n        if (alreadyResolved) { return; }\n        alreadyResolved = true;\n        return rejectPromise(promise, reason);\n      };\n      return { resolve: resolve, reject: reject };\n    };\n\n    var optimizedThen = function (then, thenable, resolve, reject) {\n      // Optimization: since we discard the result, we can pass our\n      // own then implementation a special hint to let it know it\n      // doesn't have to create it.  (The PROMISE_FAKE_CAPABILITY\n      // object is local to this implementation and unforgeable outside.)\n      if (then === Promise$prototype$then) {\n        _call(then, thenable, resolve, reject, PROMISE_FAKE_CAPABILITY);\n      } else {\n        _call(then, thenable, resolve, reject);\n      }\n    };\n    var promiseResolveThenableJob = function (promise, thenable, then) {\n      var resolvingFunctions = createResolvingFunctions(promise);\n      var resolve = resolvingFunctions.resolve;\n      var reject = resolvingFunctions.reject;\n      try {\n        optimizedThen(then, thenable, resolve, reject);\n      } catch (e) {\n        reject(e);\n      }\n    };\n\n    var Promise$prototype, Promise$prototype$then;\n    var Promise = (function () {\n      var PromiseShim = function Promise(resolver) {\n        if (!(this instanceof PromiseShim)) {\n          throw new TypeError('Constructor Promise requires \"new\"');\n        }\n        if (this && this._promise) {\n          throw new TypeError('Bad construction');\n        }\n        // see https://bugs.ecmascript.org/show_bug.cgi?id=2482\n        if (!ES.IsCallable(resolver)) {\n          throw new TypeError('not a valid resolver');\n        }\n        var promise = emulateES6construct(this, PromiseShim, Promise$prototype, {\n          _promise: {\n            result: void 0,\n            state: PROMISE_PENDING,\n            // The first member of the \"reactions\" array is inlined here,\n            // since most promises only have one reaction.\n            // We've also exploded the 'reaction' object to inline the\n            // \"handler\" and \"capability\" fields, since both fulfill and\n            // reject reactions share the same capability.\n            reactionLength: 0,\n            fulfillReactionHandler0: void 0,\n            rejectReactionHandler0: void 0,\n            reactionCapability0: void 0\n          }\n        });\n        var resolvingFunctions = createResolvingFunctions(promise);\n        var reject = resolvingFunctions.reject;\n        try {\n          resolver(resolvingFunctions.resolve, reject);\n        } catch (e) {\n          reject(e);\n        }\n        return promise;\n      };\n      return PromiseShim;\n    }());\n    Promise$prototype = Promise.prototype;\n\n    var _promiseAllResolver = function (index, values, capability, remaining) {\n      var alreadyCalled = false;\n      return function (x) {\n        if (alreadyCalled) { return; }\n        alreadyCalled = true;\n        values[index] = x;\n        if ((--remaining.count) === 0) {\n          var resolve = capability.resolve;\n          resolve(values); // call w/ this===undefined\n        }\n      };\n    };\n\n    var performPromiseAll = function (iteratorRecord, C, resultCapability) {\n      var it = iteratorRecord.iterator;\n      var values = [];\n      var remaining = { count: 1 };\n      var next, nextValue;\n      var index = 0;\n      while (true) {\n        try {\n          next = ES.IteratorStep(it);\n          if (next === false) {\n            iteratorRecord.done = true;\n            break;\n          }\n          nextValue = next.value;\n        } catch (e) {\n          iteratorRecord.done = true;\n          throw e;\n        }\n        values[index] = void 0;\n        var nextPromise = C.resolve(nextValue);\n        var resolveElement = _promiseAllResolver(\n          index,\n          values,\n          resultCapability,\n          remaining\n        );\n        remaining.count += 1;\n        optimizedThen(nextPromise.then, nextPromise, resolveElement, resultCapability.reject);\n        index += 1;\n      }\n      if ((--remaining.count) === 0) {\n        var resolve = resultCapability.resolve;\n        resolve(values); // call w/ this===undefined\n      }\n      return resultCapability.promise;\n    };\n\n    var performPromiseRace = function (iteratorRecord, C, resultCapability) {\n      var it = iteratorRecord.iterator;\n      var next, nextValue, nextPromise;\n      while (true) {\n        try {\n          next = ES.IteratorStep(it);\n          if (next === false) {\n            // NOTE: If iterable has no items, resulting promise will never\n            // resolve; see:\n            // https://github.com/domenic/promises-unwrapping/issues/75\n            // https://bugs.ecmascript.org/show_bug.cgi?id=2515\n            iteratorRecord.done = true;\n            break;\n          }\n          nextValue = next.value;\n        } catch (e) {\n          iteratorRecord.done = true;\n          throw e;\n        }\n        nextPromise = C.resolve(nextValue);\n        optimizedThen(nextPromise.then, nextPromise, resultCapability.resolve, resultCapability.reject);\n      }\n      return resultCapability.promise;\n    };\n\n    defineProperties(Promise, {\n      all: function all(iterable) {\n        var C = this;\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Promise is not object');\n        }\n        var capability = new PromiseCapability(C);\n        var iterator, iteratorRecord;\n        try {\n          iterator = ES.GetIterator(iterable);\n          iteratorRecord = { iterator: iterator, done: false };\n          return performPromiseAll(iteratorRecord, C, capability);\n        } catch (e) {\n          var exception = e;\n          if (iteratorRecord && !iteratorRecord.done) {\n            try {\n              ES.IteratorClose(iterator, true);\n            } catch (ee) {\n              exception = ee;\n            }\n          }\n          var reject = capability.reject;\n          reject(exception);\n          return capability.promise;\n        }\n      },\n\n      race: function race(iterable) {\n        var C = this;\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Promise is not object');\n        }\n        var capability = new PromiseCapability(C);\n        var iterator, iteratorRecord;\n        try {\n          iterator = ES.GetIterator(iterable);\n          iteratorRecord = { iterator: iterator, done: false };\n          return performPromiseRace(iteratorRecord, C, capability);\n        } catch (e) {\n          var exception = e;\n          if (iteratorRecord && !iteratorRecord.done) {\n            try {\n              ES.IteratorClose(iterator, true);\n            } catch (ee) {\n              exception = ee;\n            }\n          }\n          var reject = capability.reject;\n          reject(exception);\n          return capability.promise;\n        }\n      },\n\n      reject: function reject(reason) {\n        var C = this;\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Bad promise constructor');\n        }\n        var capability = new PromiseCapability(C);\n        var rejectFunc = capability.reject;\n        rejectFunc(reason); // call with this===undefined\n        return capability.promise;\n      },\n\n      resolve: function resolve(v) {\n        // See https://esdiscuss.org/topic/fixing-promise-resolve for spec\n        var C = this;\n        if (!ES.TypeIsObject(C)) {\n          throw new TypeError('Bad promise constructor');\n        }\n        if (ES.IsPromise(v)) {\n          var constructor = v.constructor;\n          if (constructor === C) {\n            return v;\n          }\n        }\n        var capability = new PromiseCapability(C);\n        var resolveFunc = capability.resolve;\n        resolveFunc(v); // call with this===undefined\n        return capability.promise;\n      }\n    });\n\n    defineProperties(Promise$prototype, {\n      'catch': function (onRejected) {\n        return this.then(null, onRejected);\n      },\n\n      then: function then(onFulfilled, onRejected) {\n        var promise = this;\n        if (!ES.IsPromise(promise)) { throw new TypeError('not a promise'); }\n        var C = ES.SpeciesConstructor(promise, Promise);\n        var resultCapability;\n        var returnValueIsIgnored = arguments.length > 2 && arguments[2] === PROMISE_FAKE_CAPABILITY;\n        if (returnValueIsIgnored && C === Promise) {\n          resultCapability = PROMISE_FAKE_CAPABILITY;\n        } else {\n          resultCapability = new PromiseCapability(C);\n        }\n        // PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability)\n        // Note that we've split the 'reaction' object into its two\n        // components, \"capabilities\" and \"handler\"\n        // \"capabilities\" is always equal to `resultCapability`\n        var fulfillReactionHandler = ES.IsCallable(onFulfilled) ? onFulfilled : PROMISE_IDENTITY;\n        var rejectReactionHandler = ES.IsCallable(onRejected) ? onRejected : PROMISE_THROWER;\n        var _promise = promise._promise;\n        var value;\n        if (_promise.state === PROMISE_PENDING) {\n          if (_promise.reactionLength === 0) {\n            _promise.fulfillReactionHandler0 = fulfillReactionHandler;\n            _promise.rejectReactionHandler0 = rejectReactionHandler;\n            _promise.reactionCapability0 = resultCapability;\n          } else {\n            var idx = 3 * (_promise.reactionLength - 1);\n            _promise[idx + PROMISE_FULFILL_OFFSET] = fulfillReactionHandler;\n            _promise[idx + PROMISE_REJECT_OFFSET] = rejectReactionHandler;\n            _promise[idx + PROMISE_CAPABILITY_OFFSET] = resultCapability;\n          }\n          _promise.reactionLength += 1;\n        } else if (_promise.state === PROMISE_FULFILLED) {\n          value = _promise.result;\n          enqueuePromiseReactionJob(\n            fulfillReactionHandler,\n            resultCapability,\n            value\n          );\n        } else if (_promise.state === PROMISE_REJECTED) {\n          value = _promise.result;\n          enqueuePromiseReactionJob(\n            rejectReactionHandler,\n            resultCapability,\n            value\n          );\n        } else {\n          throw new TypeError('unexpected Promise state');\n        }\n        return resultCapability.promise;\n      }\n    });\n    // This helps the optimizer by ensuring that methods which take\n    // capabilities aren't polymorphic.\n    PROMISE_FAKE_CAPABILITY = new PromiseCapability(Promise);\n    Promise$prototype$then = Promise$prototype.then;\n\n    return Promise;\n  }());\n\n  // Chrome's native Promise has extra methods that it shouldn't have. Let's remove them.\n  if (globals.Promise) {\n    delete globals.Promise.accept;\n    delete globals.Promise.defer;\n    delete globals.Promise.prototype.chain;\n  }\n\n  if (typeof PromiseShim === 'function') {\n    // export the Promise constructor.\n    defineProperties(globals, { Promise: PromiseShim });\n    // In Chrome 33 (and thereabouts) Promise is defined, but the\n    // implementation is buggy in a number of ways.  Let's check subclassing\n    // support to see if we have a buggy implementation.\n    var promiseSupportsSubclassing = supportsSubclassing(globals.Promise, function (S) {\n      return S.resolve(42).then(function () {}) instanceof S;\n    });\n    var promiseIgnoresNonFunctionThenCallbacks = !throwsError(function () {\n      return globals.Promise.reject(42).then(null, 5).then(null, noop);\n    });\n    var promiseRequiresObjectContext = throwsError(function () { return globals.Promise.call(3, noop); });\n    // Promise.resolve() was errata'ed late in the ES6 process.\n    // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1170742\n    //      https://code.google.com/p/v8/issues/detail?id=4161\n    // It serves as a proxy for a number of other bugs in early Promise\n    // implementations.\n    var promiseResolveBroken = (function (Promise) {\n      var p = Promise.resolve(5);\n      p.constructor = {};\n      var p2 = Promise.resolve(p);\n      try {\n        p2.then(null, noop).then(null, noop); // avoid \"uncaught rejection\" warnings in console\n      } catch (e) {\n        return true; // v8 native Promises break here https://code.google.com/p/chromium/issues/detail?id=575314\n      }\n      return p === p2; // This *should* be false!\n    }(globals.Promise));\n\n    // Chrome 46 (probably older too) does not retrieve a thenable's .then synchronously\n    var getsThenSynchronously = supportsDescriptors && (function () {\n      var count = 0;\n      // eslint-disable-next-line getter-return\n      var thenable = Object.defineProperty({}, 'then', { get: function () { count += 1; } });\n      Promise.resolve(thenable);\n      return count === 1;\n    }());\n\n    var BadResolverPromise = function BadResolverPromise(executor) {\n      var p = new Promise(executor);\n      executor(3, function () {});\n      this.then = p.then;\n      this.constructor = BadResolverPromise;\n    };\n    BadResolverPromise.prototype = Promise.prototype;\n    BadResolverPromise.all = Promise.all;\n    // Chrome Canary 49 (probably older too) has some implementation bugs\n    var hasBadResolverPromise = valueOrFalseIfThrows(function () {\n      return !!BadResolverPromise.all([1, 2]);\n    });\n\n    if (!promiseSupportsSubclassing || !promiseIgnoresNonFunctionThenCallbacks ||\n        !promiseRequiresObjectContext || promiseResolveBroken ||\n        !getsThenSynchronously || hasBadResolverPromise) {\n      /* globals Promise: true */\n      /* eslint-disable no-undef, no-global-assign */\n      Promise = PromiseShim;\n      /* eslint-enable no-undef, no-global-assign */\n      overrideNative(globals, 'Promise', PromiseShim);\n    }\n    if (Promise.all.length !== 1) {\n      var origAll = Promise.all;\n      overrideNative(Promise, 'all', function all(iterable) {\n        return ES.Call(origAll, this, arguments);\n      });\n    }\n    if (Promise.race.length !== 1) {\n      var origRace = Promise.race;\n      overrideNative(Promise, 'race', function race(iterable) {\n        return ES.Call(origRace, this, arguments);\n      });\n    }\n    if (Promise.resolve.length !== 1) {\n      var origResolve = Promise.resolve;\n      overrideNative(Promise, 'resolve', function resolve(x) {\n        return ES.Call(origResolve, this, arguments);\n      });\n    }\n    if (Promise.reject.length !== 1) {\n      var origReject = Promise.reject;\n      overrideNative(Promise, 'reject', function reject(r) {\n        return ES.Call(origReject, this, arguments);\n      });\n    }\n    ensureEnumerable(Promise, 'all');\n    ensureEnumerable(Promise, 'race');\n    ensureEnumerable(Promise, 'resolve');\n    ensureEnumerable(Promise, 'reject');\n    addDefaultSpecies(Promise);\n  }\n\n  // Map and Set require a true ES5 environment\n  // Their fast path also requires that the environment preserve\n  // property insertion order, which is not guaranteed by the spec.\n  var testOrder = function (a) {\n    var b = keys(_reduce(a, function (o, k) {\n      o[k] = true;\n      return o;\n    }, {}));\n    return a.join(':') === b.join(':');\n  };\n  var preservesInsertionOrder = testOrder(['z', 'a', 'bb']);\n  // some engines (eg, Chrome) only preserve insertion order for string keys\n  var preservesNumericInsertionOrder = testOrder(['z', 1, 'a', '3', 2]);\n\n  if (supportsDescriptors) {\n\n    var fastkey = function fastkey(key, skipInsertionOrderCheck) {\n      if (!skipInsertionOrderCheck && !preservesInsertionOrder) {\n        return null;\n      }\n      if (isNullOrUndefined(key)) {\n        return '^' + ES.ToString(key);\n      } else if (typeof key === 'string') {\n        return '$' + key;\n      } else if (typeof key === 'number') {\n        // note that -0 will get coerced to \"0\" when used as a property key\n        if (!preservesNumericInsertionOrder) {\n          return 'n' + key;\n        }\n        return key;\n      } else if (typeof key === 'boolean') {\n        return 'b' + key;\n      }\n      return null;\n    };\n\n    var emptyObject = function emptyObject() {\n      // accomodate some older not-quite-ES5 browsers\n      return Object.create ? Object.create(null) : {};\n    };\n\n    var addIterableToMap = function addIterableToMap(MapConstructor, map, iterable) {\n      if (isArray(iterable) || Type.string(iterable)) {\n        _forEach(iterable, function (entry) {\n          if (!ES.TypeIsObject(entry)) {\n            throw new TypeError('Iterator value ' + entry + ' is not an entry object');\n          }\n          map.set(entry[0], entry[1]);\n        });\n      } else if (iterable instanceof MapConstructor) {\n        _call(MapConstructor.prototype.forEach, iterable, function (value, key) {\n          map.set(key, value);\n        });\n      } else {\n        var iter, adder;\n        if (!isNullOrUndefined(iterable)) {\n          adder = map.set;\n          if (!ES.IsCallable(adder)) { throw new TypeError('bad map'); }\n          iter = ES.GetIterator(iterable);\n        }\n        if (typeof iter !== 'undefined') {\n          while (true) {\n            var next = ES.IteratorStep(iter);\n            if (next === false) { break; }\n            var nextItem = next.value;\n            try {\n              if (!ES.TypeIsObject(nextItem)) {\n                throw new TypeError('Iterator value ' + nextItem + ' is not an entry object');\n              }\n              _call(adder, map, nextItem[0], nextItem[1]);\n            } catch (e) {\n              ES.IteratorClose(iter, true);\n              throw e;\n            }\n          }\n        }\n      }\n    };\n    var addIterableToSet = function addIterableToSet(SetConstructor, set, iterable) {\n      if (isArray(iterable) || Type.string(iterable)) {\n        _forEach(iterable, function (value) {\n          set.add(value);\n        });\n      } else if (iterable instanceof SetConstructor) {\n        _call(SetConstructor.prototype.forEach, iterable, function (value) {\n          set.add(value);\n        });\n      } else {\n        var iter, adder;\n        if (!isNullOrUndefined(iterable)) {\n          adder = set.add;\n          if (!ES.IsCallable(adder)) { throw new TypeError('bad set'); }\n          iter = ES.GetIterator(iterable);\n        }\n        if (typeof iter !== 'undefined') {\n          while (true) {\n            var next = ES.IteratorStep(iter);\n            if (next === false) { break; }\n            var nextValue = next.value;\n            try {\n              _call(adder, set, nextValue);\n            } catch (e) {\n              ES.IteratorClose(iter, true);\n              throw e;\n            }\n          }\n        }\n      }\n    };\n\n    var collectionShims = {\n      Map: (function () {\n\n        var empty = {};\n\n        var MapEntry = function MapEntry(key, value) {\n          this.key = key;\n          this.value = value;\n          this.next = null;\n          this.prev = null;\n        };\n\n        MapEntry.prototype.isRemoved = function isRemoved() {\n          return this.key === empty;\n        };\n\n        var isMap = function isMap(map) {\n          return !!map._es6map;\n        };\n\n        var requireMapSlot = function requireMapSlot(map, method) {\n          if (!ES.TypeIsObject(map) || !isMap(map)) {\n            throw new TypeError('Method Map.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(map));\n          }\n        };\n\n        var MapIterator = function MapIterator(map, kind) {\n          requireMapSlot(map, '[[MapIterator]]');\n          this.head = map._head;\n          this.i = this.head;\n          this.kind = kind;\n        };\n\n        MapIterator.prototype = {\n          isMapIterator: true,\n          next: function next() {\n            if (!this.isMapIterator) {\n              throw new TypeError('Not a MapIterator');\n            }\n            var i = this.i;\n            var kind = this.kind;\n            var head = this.head;\n            if (typeof this.i === 'undefined') {\n              return iteratorResult();\n            }\n            while (i.isRemoved() && i !== head) {\n              // back up off of removed entries\n              i = i.prev;\n            }\n            // advance to next unreturned element.\n            var result;\n            while (i.next !== head) {\n              i = i.next;\n              if (!i.isRemoved()) {\n                if (kind === 'key') {\n                  result = i.key;\n                } else if (kind === 'value') {\n                  result = i.value;\n                } else {\n                  result = [i.key, i.value];\n                }\n                this.i = i;\n                return iteratorResult(result);\n              }\n            }\n            // once the iterator is done, it is done forever.\n            this.i = void 0;\n            return iteratorResult();\n          }\n        };\n        addIterator(MapIterator.prototype);\n\n        var Map$prototype;\n        var MapShim = function Map() {\n          if (!(this instanceof Map)) {\n            throw new TypeError('Constructor Map requires \"new\"');\n          }\n          if (this && this._es6map) {\n            throw new TypeError('Bad construction');\n          }\n          var map = emulateES6construct(this, Map, Map$prototype, {\n            _es6map: true,\n            _head: null,\n            _map: OrigMap ? new OrigMap() : null,\n            _size: 0,\n            _storage: emptyObject()\n          });\n\n          var head = new MapEntry(null, null);\n          // circular doubly-linked list.\n          /* eslint no-multi-assign: 1 */\n          head.next = head.prev = head;\n          map._head = head;\n\n          // Optionally initialize map from iterable\n          if (arguments.length > 0) {\n            addIterableToMap(Map, map, arguments[0]);\n          }\n          return map;\n        };\n        Map$prototype = MapShim.prototype;\n\n        Value.getter(Map$prototype, 'size', function () {\n          if (typeof this._size === 'undefined') {\n            throw new TypeError('size method called on incompatible Map');\n          }\n          return this._size;\n        });\n\n        defineProperties(Map$prototype, {\n          get: function get(key) {\n            requireMapSlot(this, 'get');\n            var entry;\n            var fkey = fastkey(key, true);\n            if (fkey !== null) {\n              // fast O(1) path\n              entry = this._storage[fkey];\n              if (entry) {\n                return entry.value;\n              } else {\n                return;\n              }\n            }\n            if (this._map) {\n              // fast object key path\n              entry = origMapGet.call(this._map, key);\n              if (entry) {\n                return entry.value;\n              } else {\n                return;\n              }\n            }\n            var head = this._head;\n            var i = head;\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                return i.value;\n              }\n            }\n          },\n\n          has: function has(key) {\n            requireMapSlot(this, 'has');\n            var fkey = fastkey(key, true);\n            if (fkey !== null) {\n              // fast O(1) path\n              return typeof this._storage[fkey] !== 'undefined';\n            }\n            if (this._map) {\n              // fast object key path\n              return origMapHas.call(this._map, key);\n            }\n            var head = this._head;\n            var i = head;\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                return true;\n              }\n            }\n            return false;\n          },\n\n          set: function set(key, value) {\n            requireMapSlot(this, 'set');\n            var head = this._head;\n            var i = head;\n            var entry;\n            var fkey = fastkey(key, true);\n            if (fkey !== null) {\n              // fast O(1) path\n              if (typeof this._storage[fkey] !== 'undefined') {\n                this._storage[fkey].value = value;\n                return this;\n              } else {\n                entry = this._storage[fkey] = new MapEntry(key, value); /* eslint no-multi-assign: 1 */\n                i = head.prev;\n                // fall through\n              }\n            } else if (this._map) {\n              // fast object key path\n              if (origMapHas.call(this._map, key)) {\n                origMapGet.call(this._map, key).value = value;\n              } else {\n                entry = new MapEntry(key, value);\n                origMapSet.call(this._map, key, entry);\n                i = head.prev;\n                // fall through\n              }\n            }\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                i.value = value;\n                return this;\n              }\n            }\n            entry = entry || new MapEntry(key, value);\n            if (ES.SameValue(-0, key)) {\n              entry.key = +0; // coerce -0 to +0 in entry\n            }\n            entry.next = this._head;\n            entry.prev = this._head.prev;\n            entry.prev.next = entry;\n            entry.next.prev = entry;\n            this._size += 1;\n            return this;\n          },\n\n          'delete': function (key) {\n            requireMapSlot(this, 'delete');\n            var head = this._head;\n            var i = head;\n            var fkey = fastkey(key, true);\n            if (fkey !== null) {\n              // fast O(1) path\n              if (typeof this._storage[fkey] === 'undefined') {\n                return false;\n              }\n              i = this._storage[fkey].prev;\n              delete this._storage[fkey];\n              // fall through\n            } else if (this._map) {\n              // fast object key path\n              if (!origMapHas.call(this._map, key)) {\n                return false;\n              }\n              i = origMapGet.call(this._map, key).prev;\n              origMapDelete.call(this._map, key);\n              // fall through\n            }\n            while ((i = i.next) !== head) {\n              if (ES.SameValueZero(i.key, key)) {\n                i.key = empty;\n                i.value = empty;\n                i.prev.next = i.next;\n                i.next.prev = i.prev;\n                this._size -= 1;\n                return true;\n              }\n            }\n            return false;\n          },\n\n          clear: function clear() {\n            /* eslint no-multi-assign: 1 */\n            requireMapSlot(this, 'clear');\n            this._map = OrigMap ? new OrigMap() : null;\n            this._size = 0;\n            this._storage = emptyObject();\n            var head = this._head;\n            var i = head;\n            var p = i.next;\n            while ((i = p) !== head) {\n              i.key = empty;\n              i.value = empty;\n              p = i.next;\n              i.next = i.prev = head;\n            }\n            head.next = head.prev = head;\n          },\n\n          keys: function keys() {\n            requireMapSlot(this, 'keys');\n            return new MapIterator(this, 'key');\n          },\n\n          values: function values() {\n            requireMapSlot(this, 'values');\n            return new MapIterator(this, 'value');\n          },\n\n          entries: function entries() {\n            requireMapSlot(this, 'entries');\n            return new MapIterator(this, 'key+value');\n          },\n\n          forEach: function forEach(callback) {\n            requireMapSlot(this, 'forEach');\n            var context = arguments.length > 1 ? arguments[1] : null;\n            var it = this.entries();\n            for (var entry = it.next(); !entry.done; entry = it.next()) {\n              if (context) {\n                _call(callback, context, entry.value[1], entry.value[0], this);\n              } else {\n                callback(entry.value[1], entry.value[0], this);\n              }\n            }\n          }\n        });\n        addIterator(Map$prototype, Map$prototype.entries);\n\n        return MapShim;\n      }()),\n\n      Set: (function () {\n        var isSet = function isSet(set) {\n          return set._es6set && typeof set._storage !== 'undefined';\n        };\n        var requireSetSlot = function requireSetSlot(set, method) {\n          if (!ES.TypeIsObject(set) || !isSet(set)) {\n            // https://github.com/paulmillr/es6-shim/issues/176\n            throw new TypeError('Set.prototype.' + method + ' called on incompatible receiver ' + ES.ToString(set));\n          }\n        };\n\n        // Creating a Map is expensive.  To speed up the common case of\n        // Sets containing only string or numeric keys, we use an object\n        // as backing storage and lazily create a full Map only when\n        // required.\n        var Set$prototype;\n        var SetShim = function Set() {\n          if (!(this instanceof Set)) {\n            throw new TypeError('Constructor Set requires \"new\"');\n          }\n          if (this && this._es6set) {\n            throw new TypeError('Bad construction');\n          }\n          var set = emulateES6construct(this, Set, Set$prototype, {\n            _es6set: true,\n            '[[SetData]]': null,\n            _storage: emptyObject()\n          });\n          if (!set._es6set) {\n            throw new TypeError('bad set');\n          }\n\n          // Optionally initialize Set from iterable\n          if (arguments.length > 0) {\n            addIterableToSet(Set, set, arguments[0]);\n          }\n          return set;\n        };\n        Set$prototype = SetShim.prototype;\n\n        var decodeKey = function (key) {\n          var k = key;\n          if (k === '^null') {\n            return null;\n          } else if (k === '^undefined') {\n            return void 0;\n          } else {\n            var first = k.charAt(0);\n            if (first === '$') {\n              return _strSlice(k, 1);\n            } else if (first === 'n') {\n              return +_strSlice(k, 1);\n            } else if (first === 'b') {\n              return k === 'btrue';\n            }\n          }\n          return +k;\n        };\n        // Switch from the object backing storage to a full Map.\n        var ensureMap = function ensureMap(set) {\n          if (!set['[[SetData]]']) {\n            var m = new collectionShims.Map();\n            set['[[SetData]]'] = m;\n            _forEach(keys(set._storage), function (key) {\n              var k = decodeKey(key);\n              m.set(k, k);\n            });\n            set['[[SetData]]'] = m;\n          }\n          set._storage = null; // free old backing storage\n        };\n\n        Value.getter(SetShim.prototype, 'size', function () {\n          requireSetSlot(this, 'size');\n          if (this._storage) {\n            return keys(this._storage).length;\n          }\n          ensureMap(this);\n          return this['[[SetData]]'].size;\n        });\n\n        defineProperties(SetShim.prototype, {\n          has: function has(key) {\n            requireSetSlot(this, 'has');\n            var fkey;\n            if (this._storage && (fkey = fastkey(key)) !== null) {\n              return !!this._storage[fkey];\n            }\n            ensureMap(this);\n            return this['[[SetData]]'].has(key);\n          },\n\n          add: function add(key) {\n            requireSetSlot(this, 'add');\n            var fkey;\n            if (this._storage && (fkey = fastkey(key)) !== null) {\n              this._storage[fkey] = true;\n              return this;\n            }\n            ensureMap(this);\n            this['[[SetData]]'].set(key, key);\n            return this;\n          },\n\n          'delete': function (key) {\n            requireSetSlot(this, 'delete');\n            var fkey;\n            if (this._storage && (fkey = fastkey(key)) !== null) {\n              var hasFKey = _hasOwnProperty(this._storage, fkey);\n              return (delete this._storage[fkey]) && hasFKey;\n            }\n            ensureMap(this);\n            return this['[[SetData]]']['delete'](key);\n          },\n\n          clear: function clear() {\n            requireSetSlot(this, 'clear');\n            if (this._storage) {\n              this._storage = emptyObject();\n            }\n            if (this['[[SetData]]']) {\n              this['[[SetData]]'].clear();\n            }\n          },\n\n          values: function values() {\n            requireSetSlot(this, 'values');\n            ensureMap(this);\n            return new SetIterator(this['[[SetData]]'].values());\n          },\n\n          entries: function entries() {\n            requireSetSlot(this, 'entries');\n            ensureMap(this);\n            return new SetIterator(this['[[SetData]]'].entries());\n          },\n\n          forEach: function forEach(callback) {\n            requireSetSlot(this, 'forEach');\n            var context = arguments.length > 1 ? arguments[1] : null;\n            var entireSet = this;\n            ensureMap(entireSet);\n            this['[[SetData]]'].forEach(function (value, key) {\n              if (context) {\n                _call(callback, context, key, key, entireSet);\n              } else {\n                callback(key, key, entireSet);\n              }\n            });\n          }\n        });\n        defineProperty(SetShim.prototype, 'keys', SetShim.prototype.values, true);\n        addIterator(SetShim.prototype, SetShim.prototype.values);\n\n        var SetIterator = function SetIterator(it) {\n          this.it = it;\n        };\n        SetIterator.prototype = {\n          isSetIterator: true,\n          next: function next() {\n            if (!this.isSetIterator) {\n              throw new TypeError('Not a SetIterator');\n            }\n            return this.it.next();\n          }\n        };\n        addIterator(SetIterator.prototype);\n\n        return SetShim;\n      }())\n    };\n\n    var isGoogleTranslate = globals.Set && !Set.prototype['delete'] && Set.prototype.remove && Set.prototype.items && Set.prototype.map && Array.isArray(new Set().keys);\n    if (isGoogleTranslate) {\n      // special-case force removal of wildly invalid Set implementation in Google Translate iframes\n      // see https://github.com/paulmillr/es6-shim/issues/438 / https://twitter.com/ljharb/status/849335573114363904\n      globals.Set = collectionShims.Set;\n    }\n    if (globals.Map || globals.Set) {\n      // Safari 8, for example, doesn't accept an iterable.\n      var mapAcceptsArguments = valueOrFalseIfThrows(function () { return new Map([[1, 2]]).get(1) === 2; });\n      if (!mapAcceptsArguments) {\n        globals.Map = function Map() {\n          if (!(this instanceof Map)) {\n            throw new TypeError('Constructor Map requires \"new\"');\n          }\n          var m = new OrigMap();\n          if (arguments.length > 0) {\n            addIterableToMap(Map, m, arguments[0]);\n          }\n          delete m.constructor;\n          Object.setPrototypeOf(m, globals.Map.prototype);\n          return m;\n        };\n        globals.Map.prototype = create(OrigMap.prototype);\n        defineProperty(globals.Map.prototype, 'constructor', globals.Map, true);\n        Value.preserveToString(globals.Map, OrigMap);\n      }\n      var testMap = new Map();\n      var mapUsesSameValueZero = (function () {\n        // Chrome 38-42, node 0.11/0.12, iojs 1/2 also have a bug when the Map has a size > 4\n        var m = new Map([[1, 0], [2, 0], [3, 0], [4, 0]]);\n        m.set(-0, m);\n        return m.get(0) === m && m.get(-0) === m && m.has(0) && m.has(-0);\n      }());\n      var mapSupportsChaining = testMap.set(1, 2) === testMap;\n      if (!mapUsesSameValueZero || !mapSupportsChaining) {\n        overrideNative(Map.prototype, 'set', function set(k, v) {\n          _call(origMapSet, this, k === 0 ? 0 : k, v);\n          return this;\n        });\n      }\n      if (!mapUsesSameValueZero) {\n        defineProperties(Map.prototype, {\n          get: function get(k) {\n            return _call(origMapGet, this, k === 0 ? 0 : k);\n          },\n          has: function has(k) {\n            return _call(origMapHas, this, k === 0 ? 0 : k);\n          }\n        }, true);\n        Value.preserveToString(Map.prototype.get, origMapGet);\n        Value.preserveToString(Map.prototype.has, origMapHas);\n      }\n      var testSet = new Set();\n      var setUsesSameValueZero = Set.prototype['delete'] && Set.prototype.add && Set.prototype.has && (function (s) {\n        s['delete'](0);\n        s.add(-0);\n        return !s.has(0);\n      }(testSet));\n      var setSupportsChaining = testSet.add(1) === testSet;\n      if (!setUsesSameValueZero || !setSupportsChaining) {\n        var origSetAdd = Set.prototype.add;\n        Set.prototype.add = function add(v) {\n          _call(origSetAdd, this, v === 0 ? 0 : v);\n          return this;\n        };\n        Value.preserveToString(Set.prototype.add, origSetAdd);\n      }\n      if (!setUsesSameValueZero) {\n        var origSetHas = Set.prototype.has;\n        Set.prototype.has = function has(v) {\n          return _call(origSetHas, this, v === 0 ? 0 : v);\n        };\n        Value.preserveToString(Set.prototype.has, origSetHas);\n        var origSetDel = Set.prototype['delete'];\n        Set.prototype['delete'] = function SetDelete(v) {\n          return _call(origSetDel, this, v === 0 ? 0 : v);\n        };\n        Value.preserveToString(Set.prototype['delete'], origSetDel);\n      }\n      var mapSupportsSubclassing = supportsSubclassing(globals.Map, function (M) {\n        var m = new M([]);\n        // Firefox 32 is ok with the instantiating the subclass but will\n        // throw when the map is used.\n        m.set(42, 42);\n        return m instanceof M;\n      });\n      // without Object.setPrototypeOf, subclassing is not possible\n      var mapFailsToSupportSubclassing = Object.setPrototypeOf && !mapSupportsSubclassing;\n      var mapRequiresNew = (function () {\n        try {\n          return !(globals.Map() instanceof globals.Map);\n        } catch (e) {\n          return e instanceof TypeError;\n        }\n      }());\n      if (globals.Map.length !== 0 || mapFailsToSupportSubclassing || !mapRequiresNew) {\n        globals.Map = function Map() {\n          if (!(this instanceof Map)) {\n            throw new TypeError('Constructor Map requires \"new\"');\n          }\n          var m = new OrigMap();\n          if (arguments.length > 0) {\n            addIterableToMap(Map, m, arguments[0]);\n          }\n          delete m.constructor;\n          Object.setPrototypeOf(m, Map.prototype);\n          return m;\n        };\n        globals.Map.prototype = OrigMap.prototype;\n        defineProperty(globals.Map.prototype, 'constructor', globals.Map, true);\n        Value.preserveToString(globals.Map, OrigMap);\n      }\n      var setSupportsSubclassing = supportsSubclassing(globals.Set, function (S) {\n        var s = new S([]);\n        s.add(42, 42);\n        return s instanceof S;\n      });\n      // without Object.setPrototypeOf, subclassing is not possible\n      var setFailsToSupportSubclassing = Object.setPrototypeOf && !setSupportsSubclassing;\n      var setRequiresNew = (function () {\n        try {\n          return !(globals.Set() instanceof globals.Set);\n        } catch (e) {\n          return e instanceof TypeError;\n        }\n      }());\n      if (globals.Set.length !== 0 || setFailsToSupportSubclassing || !setRequiresNew) {\n        var OrigSet = globals.Set;\n        globals.Set = function Set() {\n          if (!(this instanceof Set)) {\n            throw new TypeError('Constructor Set requires \"new\"');\n          }\n          var s = new OrigSet();\n          if (arguments.length > 0) {\n            addIterableToSet(Set, s, arguments[0]);\n          }\n          delete s.constructor;\n          Object.setPrototypeOf(s, Set.prototype);\n          return s;\n        };\n        globals.Set.prototype = OrigSet.prototype;\n        defineProperty(globals.Set.prototype, 'constructor', globals.Set, true);\n        Value.preserveToString(globals.Set, OrigSet);\n      }\n      var newMap = new globals.Map();\n      var mapIterationThrowsStopIterator = !valueOrFalseIfThrows(function () {\n        return newMap.keys().next().done;\n      });\n      /*\n        - In Firefox < 23, Map#size is a function.\n        - In all current Firefox, Set#entries/keys/values & Map#clear do not exist\n        - https://bugzilla.mozilla.org/show_bug.cgi?id=869996\n        - In Firefox 24, Map and Set do not implement forEach\n        - In Firefox 25 at least, Map and Set are callable without \"new\"\n      */\n      if (\n        typeof globals.Map.prototype.clear !== 'function' ||\n        new globals.Set().size !== 0 ||\n        newMap.size !== 0 ||\n        typeof globals.Map.prototype.keys !== 'function' ||\n        typeof globals.Set.prototype.keys !== 'function' ||\n        typeof globals.Map.prototype.forEach !== 'function' ||\n        typeof globals.Set.prototype.forEach !== 'function' ||\n        isCallableWithoutNew(globals.Map) ||\n        isCallableWithoutNew(globals.Set) ||\n        typeof newMap.keys().next !== 'function' || // Safari 8\n        mapIterationThrowsStopIterator || // Firefox 25\n        !mapSupportsSubclassing\n      ) {\n        defineProperties(globals, {\n          Map: collectionShims.Map,\n          Set: collectionShims.Set\n        }, true);\n      }\n\n      if (globals.Set.prototype.keys !== globals.Set.prototype.values) {\n        // Fixed in WebKit with https://bugs.webkit.org/show_bug.cgi?id=144190\n        defineProperty(globals.Set.prototype, 'keys', globals.Set.prototype.values, true);\n      }\n\n      // Shim incomplete iterator implementations.\n      addIterator(Object.getPrototypeOf((new globals.Map()).keys()));\n      addIterator(Object.getPrototypeOf((new globals.Set()).keys()));\n\n      if (functionsHaveNames && globals.Set.prototype.has.name !== 'has') {\n        // Microsoft Edge v0.11.10074.0 is missing a name on Set#has\n        var anonymousSetHas = globals.Set.prototype.has;\n        overrideNative(globals.Set.prototype, 'has', function has(key) {\n          return _call(anonymousSetHas, this, key);\n        });\n      }\n    }\n    defineProperties(globals, collectionShims);\n    addDefaultSpecies(globals.Map);\n    addDefaultSpecies(globals.Set);\n  }\n\n  var throwUnlessTargetIsObject = function throwUnlessTargetIsObject(target) {\n    if (!ES.TypeIsObject(target)) {\n      throw new TypeError('target must be an object');\n    }\n  };\n\n  // Some Reflect methods are basically the same as\n  // those on the Object global, except that a TypeError is thrown if\n  // target isn't an object. As well as returning a boolean indicating\n  // the success of the operation.\n  var ReflectShims = {\n    // Apply method in a functional form.\n    apply: function apply() {\n      return ES.Call(ES.Call, null, arguments);\n    },\n\n    // New operator in a functional form.\n    construct: function construct(constructor, args) {\n      if (!ES.IsConstructor(constructor)) {\n        throw new TypeError('First argument must be a constructor.');\n      }\n      var newTarget = arguments.length > 2 ? arguments[2] : constructor;\n      if (!ES.IsConstructor(newTarget)) {\n        throw new TypeError('new.target must be a constructor.');\n      }\n      return ES.Construct(constructor, args, newTarget, 'internal');\n    },\n\n    // When deleting a non-existent or configurable property,\n    // true is returned.\n    // When attempting to delete a non-configurable property,\n    // it will return false.\n    deleteProperty: function deleteProperty(target, key) {\n      throwUnlessTargetIsObject(target);\n      if (supportsDescriptors) {\n        var desc = Object.getOwnPropertyDescriptor(target, key);\n\n        if (desc && !desc.configurable) {\n          return false;\n        }\n      }\n\n      // Will return true.\n      return delete target[key];\n    },\n\n    has: function has(target, key) {\n      throwUnlessTargetIsObject(target);\n      return key in target;\n    }\n  };\n\n  if (Object.getOwnPropertyNames) {\n    Object.assign(ReflectShims, {\n      // Basically the result of calling the internal [[OwnPropertyKeys]].\n      // Concatenating propertyNames and propertySymbols should do the trick.\n      // This should continue to work together with a Symbol shim\n      // which overrides Object.getOwnPropertyNames and implements\n      // Object.getOwnPropertySymbols.\n      ownKeys: function ownKeys(target) {\n        throwUnlessTargetIsObject(target);\n        var keys = Object.getOwnPropertyNames(target);\n\n        if (ES.IsCallable(Object.getOwnPropertySymbols)) {\n          _pushApply(keys, Object.getOwnPropertySymbols(target));\n        }\n\n        return keys;\n      }\n    });\n  }\n\n  var callAndCatchException = function ConvertExceptionToBoolean(func) {\n    return !throwsError(func);\n  };\n\n  if (Object.preventExtensions) {\n    Object.assign(ReflectShims, {\n      isExtensible: function isExtensible(target) {\n        throwUnlessTargetIsObject(target);\n        return Object.isExtensible(target);\n      },\n      preventExtensions: function preventExtensions(target) {\n        throwUnlessTargetIsObject(target);\n        return callAndCatchException(function () {\n          return Object.preventExtensions(target);\n        });\n      }\n    });\n  }\n\n  if (supportsDescriptors) {\n    var internalGet = function get(target, key, receiver) {\n      var desc = Object.getOwnPropertyDescriptor(target, key);\n\n      if (!desc) {\n        var parent = Object.getPrototypeOf(target);\n\n        if (parent === null) {\n          return void 0;\n        }\n\n        return internalGet(parent, key, receiver);\n      }\n\n      if ('value' in desc) {\n        return desc.value;\n      }\n\n      if (desc.get) {\n        return ES.Call(desc.get, receiver);\n      }\n\n      return void 0;\n    };\n\n    var internalSet = function set(target, key, value, receiver) {\n      var desc = Object.getOwnPropertyDescriptor(target, key);\n\n      if (!desc) {\n        var parent = Object.getPrototypeOf(target);\n\n        if (parent !== null) {\n          return internalSet(parent, key, value, receiver);\n        }\n\n        desc = {\n          value: void 0,\n          writable: true,\n          enumerable: true,\n          configurable: true\n        };\n      }\n\n      if ('value' in desc) {\n        if (!desc.writable) {\n          return false;\n        }\n\n        if (!ES.TypeIsObject(receiver)) {\n          return false;\n        }\n\n        var existingDesc = Object.getOwnPropertyDescriptor(receiver, key);\n\n        if (existingDesc) {\n          return Reflect.defineProperty(receiver, key, {\n            value: value\n          });\n        } else {\n          return Reflect.defineProperty(receiver, key, {\n            value: value,\n            writable: true,\n            enumerable: true,\n            configurable: true\n          });\n        }\n      }\n\n      if (desc.set) {\n        _call(desc.set, receiver, value);\n        return true;\n      }\n\n      return false;\n    };\n\n    Object.assign(ReflectShims, {\n      defineProperty: function defineProperty(target, propertyKey, attributes) {\n        throwUnlessTargetIsObject(target);\n        return callAndCatchException(function () {\n          return Object.defineProperty(target, propertyKey, attributes);\n        });\n      },\n\n      getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {\n        throwUnlessTargetIsObject(target);\n        return Object.getOwnPropertyDescriptor(target, propertyKey);\n      },\n\n      // Syntax in a functional form.\n      get: function get(target, key) {\n        throwUnlessTargetIsObject(target);\n        var receiver = arguments.length > 2 ? arguments[2] : target;\n\n        return internalGet(target, key, receiver);\n      },\n\n      set: function set(target, key, value) {\n        throwUnlessTargetIsObject(target);\n        var receiver = arguments.length > 3 ? arguments[3] : target;\n\n        return internalSet(target, key, value, receiver);\n      }\n    });\n  }\n\n  if (Object.getPrototypeOf) {\n    var objectDotGetPrototypeOf = Object.getPrototypeOf;\n    ReflectShims.getPrototypeOf = function getPrototypeOf(target) {\n      throwUnlessTargetIsObject(target);\n      return objectDotGetPrototypeOf(target);\n    };\n  }\n\n  if (Object.setPrototypeOf && ReflectShims.getPrototypeOf) {\n    var willCreateCircularPrototype = function (object, lastProto) {\n      var proto = lastProto;\n      while (proto) {\n        if (object === proto) {\n          return true;\n        }\n        proto = ReflectShims.getPrototypeOf(proto);\n      }\n      return false;\n    };\n\n    Object.assign(ReflectShims, {\n      // Sets the prototype of the given object.\n      // Returns true on success, otherwise false.\n      setPrototypeOf: function setPrototypeOf(object, proto) {\n        throwUnlessTargetIsObject(object);\n        if (proto !== null && !ES.TypeIsObject(proto)) {\n          throw new TypeError('proto must be an object or null');\n        }\n\n        // If they already are the same, we're done.\n        if (proto === Reflect.getPrototypeOf(object)) {\n          return true;\n        }\n\n        // Cannot alter prototype if object not extensible.\n        if (Reflect.isExtensible && !Reflect.isExtensible(object)) {\n          return false;\n        }\n\n        // Ensure that we do not create a circular prototype chain.\n        if (willCreateCircularPrototype(object, proto)) {\n          return false;\n        }\n\n        Object.setPrototypeOf(object, proto);\n\n        return true;\n      }\n    });\n  }\n  var defineOrOverrideReflectProperty = function (key, shim) {\n    if (!ES.IsCallable(globals.Reflect[key])) {\n      defineProperty(globals.Reflect, key, shim);\n    } else {\n      var acceptsPrimitives = valueOrFalseIfThrows(function () {\n        globals.Reflect[key](1);\n        globals.Reflect[key](NaN);\n        globals.Reflect[key](true);\n        return true;\n      });\n      if (acceptsPrimitives) {\n        overrideNative(globals.Reflect, key, shim);\n      }\n    }\n  };\n  Object.keys(ReflectShims).forEach(function (key) {\n    defineOrOverrideReflectProperty(key, ReflectShims[key]);\n  });\n  var originalReflectGetProto = globals.Reflect.getPrototypeOf;\n  if (functionsHaveNames && originalReflectGetProto && originalReflectGetProto.name !== 'getPrototypeOf') {\n    overrideNative(globals.Reflect, 'getPrototypeOf', function getPrototypeOf(target) {\n      return _call(originalReflectGetProto, globals.Reflect, target);\n    });\n  }\n  if (globals.Reflect.setPrototypeOf) {\n    if (valueOrFalseIfThrows(function () {\n      globals.Reflect.setPrototypeOf(1, {});\n      return true;\n    })) {\n      overrideNative(globals.Reflect, 'setPrototypeOf', ReflectShims.setPrototypeOf);\n    }\n  }\n  if (globals.Reflect.defineProperty) {\n    if (!valueOrFalseIfThrows(function () {\n      var basic = !globals.Reflect.defineProperty(1, 'test', { value: 1 });\n      // \"extensible\" fails on Edge 0.12\n      var extensible = typeof Object.preventExtensions !== 'function' || !globals.Reflect.defineProperty(Object.preventExtensions({}), 'test', {});\n      return basic && extensible;\n    })) {\n      overrideNative(globals.Reflect, 'defineProperty', ReflectShims.defineProperty);\n    }\n  }\n  if (globals.Reflect.construct) {\n    if (!valueOrFalseIfThrows(function () {\n      var F = function F() {};\n      return globals.Reflect.construct(function () {}, [], F) instanceof F;\n    })) {\n      overrideNative(globals.Reflect, 'construct', ReflectShims.construct);\n    }\n  }\n\n  if (String(new Date(NaN)) !== 'Invalid Date') {\n    var dateToString = Date.prototype.toString;\n    var shimmedDateToString = function toString() {\n      var valueOf = +this;\n      if (valueOf !== valueOf) {\n        return 'Invalid Date';\n      }\n      return ES.Call(dateToString, this);\n    };\n    overrideNative(Date.prototype, 'toString', shimmedDateToString);\n  }\n\n  // Annex B HTML methods\n  // http://www.ecma-international.org/ecma-262/6.0/#sec-additional-properties-of-the-string.prototype-object\n  var stringHTMLshims = {\n    anchor: function anchor(name) { return ES.CreateHTML(this, 'a', 'name', name); },\n    big: function big() { return ES.CreateHTML(this, 'big', '', ''); },\n    blink: function blink() { return ES.CreateHTML(this, 'blink', '', ''); },\n    bold: function bold() { return ES.CreateHTML(this, 'b', '', ''); },\n    fixed: function fixed() { return ES.CreateHTML(this, 'tt', '', ''); },\n    fontcolor: function fontcolor(color) { return ES.CreateHTML(this, 'font', 'color', color); },\n    fontsize: function fontsize(size) { return ES.CreateHTML(this, 'font', 'size', size); },\n    italics: function italics() { return ES.CreateHTML(this, 'i', '', ''); },\n    link: function link(url) { return ES.CreateHTML(this, 'a', 'href', url); },\n    small: function small() { return ES.CreateHTML(this, 'small', '', ''); },\n    strike: function strike() { return ES.CreateHTML(this, 'strike', '', ''); },\n    sub: function sub() { return ES.CreateHTML(this, 'sub', '', ''); },\n    sup: function sub() { return ES.CreateHTML(this, 'sup', '', ''); }\n  };\n  _forEach(Object.keys(stringHTMLshims), function (key) {\n    var method = String.prototype[key];\n    var shouldOverwrite = false;\n    if (ES.IsCallable(method)) {\n      var output = _call(method, '', ' \" ');\n      var quotesCount = _concat([], output.match(/\"/g)).length;\n      shouldOverwrite = output !== output.toLowerCase() || quotesCount > 2;\n    } else {\n      shouldOverwrite = true;\n    }\n    if (shouldOverwrite) {\n      overrideNative(String.prototype, key, stringHTMLshims[key]);\n    }\n  });\n\n  var JSONstringifiesSymbols = (function () {\n    // Microsoft Edge v0.12 stringifies Symbols incorrectly\n    if (!hasSymbols) { return false; } // Symbols are not supported\n    var stringify = typeof JSON === 'object' && typeof JSON.stringify === 'function' ? JSON.stringify : null;\n    if (!stringify) { return false; } // JSON.stringify is not supported\n    if (typeof stringify(Symbol()) !== 'undefined') { return true; } // Symbols should become `undefined`\n    if (stringify([Symbol()]) !== '[null]') { return true; } // Symbols in arrays should become `null`\n    var obj = { a: Symbol() };\n    obj[Symbol()] = true;\n    if (stringify(obj) !== '{}') { return true; } // Symbol-valued keys *and* Symbol-valued properties should be omitted\n    return false;\n  }());\n  var JSONstringifyAcceptsObjectSymbol = valueOrFalseIfThrows(function () {\n    // Chrome 45 throws on stringifying object symbols\n    if (!hasSymbols) { return true; } // Symbols are not supported\n    return JSON.stringify(Object(Symbol())) === '{}' && JSON.stringify([Object(Symbol())]) === '[{}]';\n  });\n  if (JSONstringifiesSymbols || !JSONstringifyAcceptsObjectSymbol) {\n    var origStringify = JSON.stringify;\n    overrideNative(JSON, 'stringify', function stringify(value) {\n      if (typeof value === 'symbol') { return; }\n      var replacer;\n      if (arguments.length > 1) {\n        replacer = arguments[1];\n      }\n      var args = [value];\n      if (!isArray(replacer)) {\n        var replaceFn = ES.IsCallable(replacer) ? replacer : null;\n        var wrappedReplacer = function (key, val) {\n          var parsedValue = replaceFn ? _call(replaceFn, this, key, val) : val;\n          if (typeof parsedValue !== 'symbol') {\n            if (Type.symbol(parsedValue)) {\n              return assignTo({})(parsedValue);\n            } else {\n              return parsedValue;\n            }\n          }\n        };\n        args.push(wrappedReplacer);\n      } else {\n        // create wrapped replacer that handles an array replacer?\n        args.push(replacer);\n      }\n      if (arguments.length > 2) {\n        args.push(arguments[2]);\n      }\n      return origStringify.apply(this, args);\n    });\n  }\n\n  return globals;\n}));\n"],"sourceRoot":""}