{"version":3,"sources":["../../node_modules/fp-ts/es6/ReadonlyArray.js","../../node_modules/fp-ts/es6/Record.js","../../node_modules/fp-ts/es6/ReadonlyNonEmptyArray.js","../../node_modules/fp-ts/es6/ReadonlyRecord.js","../../node_modules/fp-ts/es6/Set.js","../../node_modules/fp-ts/es6/ReadonlyMap.js","../../node_modules/fp-ts/es6/Task.js","../../node_modules/fp-ts/es6/TaskEither.js","../../node_modules/fp-ts/es6/ReadonlyTuple.js","../../node_modules/fp-ts/es6/ReadonlySet.js","../../node_modules/fp-ts/es6/Semigroup.js"],"names":["fromArray","as","l","length","empty","ras","Array","i","toArray","getShow","S","show","map","join","concat","x","y","lenx","leny","r","getMonoid","getEq","E","equals","xs","ys","every","getOrd","O","fromCompare","a","b","aLen","bLen","len","Math","min","ordering","compare","ordNumber","makeBy","n","f","push","range","start","end","replicate","flatten","mma","rLen","arr","j","foldLeft","onEmpty","onCons","isEmpty","slice","foldRight","scanLeft","scanRight","isNonEmpty","isOutOfBound","lookup","undefined","cons","head","tail","snoc","init","last","takeLeft","takeRight","takeLeftWhile","predicate","spanIndexUncurry","spanLeft","rest","dropLeft","dropRight","dropLeftWhile","findIndex","findFirst","findFirstMap","v","findLast","findLastMap","findLastIndex","insertAt","unsafeInsertAt","updateAt","unsafeUpdateAt","deleteAt","unsafeDeleteAt","modifyAt","reverse","rights","_tag","right","lefts","left","sort","zipWith","fa","fb","fc","zip","bs","unzip","prependToAll","e","_i","xs_1","intersperse","rotate","abs","elem","elemE_1","element","uniq","elemS","sortBy","ords","M","getOrdMonoid","reduce","chop","result","cs","_a","c","splitAt","chunksOf","comprehension","input","g","go","scope","apply","chain_","union","elemE","unionE_1","filter","intersection","intersectionE_1","difference","differenceE_1","of","zero","map_","pipe","mapWithIndex_","mapWithIndex","ap_","fab","ap","ma","chain","filter_","filterMap_","filterMap","partitionWithIndex_","predicateWithIndex","partitionWithIndex","partition_","partition","partitionMap_","partitionMap","partitionMapWithIndex_","partitionMapWithIndex","alt_","that","alt","reduce_","foldMap_","foldMapM","foldMap","reduceRight_","reduceRight","reduceWithIndex_","foldMapWithIndex_","reduceRightWithIndex_","reduceRightWithIndex","filterMapWithIndex_","filterMapWithIndex","filterWithIndex_","filterWithIndex","extend_","extend","traverse_","F","traverseF","traverse","ta","traverseWithIndex_","traverseWithIndexF","traverseWithIndex","wither_","witherF","wither","wilt_","wiltF","wilt","altW","apFirst","flow","apSecond","chainWithIndex","_","outLen","temp","out","l_1","chainFirst","separate","fa_1","optionB","value","compact","identity","wa","duplicate","foldMapWithIndex","foldMapWithIndexM","reduceWithIndex","sequence","fas","fbs","unfold","ret","bb","mt","b_1","URI","Functor","FunctorWithIndex","Applicative","Monad","Alt","Alternative","Extend","Filterable","FilterableWithIndex","Foldable","FoldableWithIndex","Traversable","TraversableWithIndex","Witherable","splice","some","bindTo","name","bindTo_","bind","bind_","apS","RR","size","keys","collect","toUnfoldable","U","k","hasOwnProperty","pop","isSubrecord","singleton","fromFoldable","fromFoldableMap","Compactable","record","RA","fromReadonlyArray","none","uncons","nea","unsnoc","ord","getMeetSemigroup","max","getJoinSemigroup","getSemigroup","group","groupSort","sortO","groupO","groupBy","as_1","fx","fy","fold","s","Comonad","extract","elements","JSON","stringify","Object","key","toReadonlyArray","optionSome","assign","_hasOwnProperty","prototype","call","this","deleteAtk","oa","isNone","me","isSubrecordE_1","isSubrecordE","fromEquals","keys_1","ks","fr","_loop_1","ks_1","keys_2","keys_3","keys_4","isSome","changed","fromFoldableMapM","fka","keys_5","optionA","keys_6","RS","Set","subset","getUnionMonoid","getIntersectionSemigroup","insert","remove","toggle","removeE","insertE","set","SK","SA","m","forEach","substring","d","member","lookupE","memberE_1","values","next","done","from","keysO","get","toArrayO","lookupWithKeyE","lookupWithKey","found","Map","delete","deleteAtE","deleteAtEk","lookupWithKeyE_1","entries","ka","lookupE_1","isSubmap","lookupWithKeyS","isSubmapSKSA_1","d2OptA","isSubmap_","mx","my","mxOptA","bOpt","ei","isLeft","p","o","getFilterableWithIndex","_E","getWitherable","fm","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","rejected","then","__generator","body","t","label","sent","trys","ops","verb","Symbol","iterator","op","TypeError","fromIO","delay","millis","setTimeout","fromIOK","arguments","chainIOK","apPar_","apSeq_","all","fromTask","rx","ry","getRaceMonoid","race","never","ApplicativePar","ApplicativeSeq","task","taskSeq","Do","traverseArrayWithIndex","traverseArray","sequenceArray","traverseSeqArrayWithIndex","traverseSeqArray","sequenceSeqArray","T","rightTask","leftTask","rightIO","leftIO","fromIOEither","fromEither","fromOption","onNone","fromPredicate","onFalse","tryCatch","onRejected","reason","getOrElseW","onLeft","getOrElse","orElse","swap","filterOrElseW","chainW","filterOrElse","tryCatchK","fromEitherK","fromIOEitherK","chainEitherKW","chainEitherK","chainIOEitherKW","chainIOEitherK","bimap_","bimap","mapLeft_","mapLeft","apW","gab","ga","chainFirstW","throwError","getApplySemigroup","getApplyMonoid","getApplicativeTaskValidation","A","SE","AV","fga","fgab","h","getAltTaskValidation","e1","e2","getTaskValidation","applicativeTaskValidation","altTaskValidation","getFilterable","W","getFilterableComposition","Bifunctor","taskEither","taskEitherSeq","taskify","args","bracket","acquire","use","release","bindW","apSW","fst","ea","snd","getApply","getApplicative","getChain","getMonad","C","getChainRec","chainRec","acc","compose_","bc","ab","compose","Semigroupoid","readonlyTuple","subsetE","isSubset","add","not","isSubsetE_1","EB","EC","hasB","hasC","ax","has","EE","EA","elemEE","elemEA","ob","startWith","foldS_1","getFirstSemigroup","getLastSemigroup","getTupleSemigroup","semigroups","getDualSemigroup","getFunctionSemigroup","getStructSemigroup","getObjectSemigroup","semigroupAll","semigroupAny","semigroupSum","semigroupProduct","semigroupString","semigroupVoid","getIntercalateSemigroup"],"mappings":"kGAAA,snIAWO,SAASA,EAAUC,GACtB,IAAIC,EAAID,EAAGE,OACX,GAAU,IAAND,EACA,OAAOE,GAGX,IADA,IAAIC,EAAMC,MAAMJ,GACPK,EAAI,EAAGA,EAAIL,EAAGK,IACnBF,EAAIE,GAAKN,EAAGM,GAEhB,OAAOF,EAOJ,SAASG,EAAQH,GAGpB,IAFA,IAAIH,EAAIG,EAAIF,OACRF,EAAKK,MAAMJ,GACNK,EAAI,EAAGA,EAAIL,EAAGK,IACnBN,EAAGM,GAAKF,EAAIE,GAEhB,OAAON,EAMJ,SAASQ,EAAQC,GACpB,MAAO,CACHC,KAAM,SAAUV,GAAM,MAAO,IAAMA,EAAGW,IAAIF,EAAEC,MAAME,KAAK,MAAQ,MAGvE,IAAIC,EAAS,SAAUC,EAAGC,GACtB,IAAIC,EAAOF,EAAEZ,OACb,GAAa,IAATc,EACA,OAAOD,EAEX,IAAIE,EAAOF,EAAEb,OACb,GAAa,IAATe,EACA,OAAOH,EAGX,IADA,IAAII,EAAIb,MAAMW,EAAOC,GACZX,EAAI,EAAGA,EAAIU,EAAMV,IACtBY,EAAEZ,GAAKQ,EAAER,GAEb,IAASA,EAAI,EAAGA,EAAIW,EAAMX,IACtBY,EAAEZ,EAAIU,GAAQD,EAAET,GAEpB,OAAOY,GAcJ,SAASC,IACZ,MAAO,CACHN,OAAQA,EACRV,MAAOA,IAmBR,SAASiB,EAAMC,GAClB,MAAO,CACHC,OAAQ,SAAUC,EAAIC,GAAM,OAAOD,IAAOC,GAAOD,EAAGrB,SAAWsB,EAAGtB,QAAUqB,EAAGE,OAAM,SAAUX,EAAGR,GAAK,OAAOe,EAAEC,OAAOR,EAAGU,EAAGlB,SAsB9H,SAASoB,EAAOC,GACnB,OAAOC,uBAAY,SAAUC,EAAGC,GAI5B,IAHA,IAAIC,EAAOF,EAAE3B,OACT8B,EAAOF,EAAE5B,OACT+B,EAAMC,KAAKC,IAAIJ,EAAMC,GAChB1B,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAI8B,EAAWT,EAAEU,QAAQR,EAAEvB,GAAIwB,EAAExB,IACjC,GAAiB,IAAb8B,EACA,OAAOA,EAGf,OAAOE,YAAUD,QAAQN,EAAMC,MAehC,SAASO,EAAOC,EAAGC,GAGtB,IADA,IAAIvB,EAAI,GACCZ,EAAI,EAAGA,EAAIkC,EAAGlC,IACnBY,EAAEwB,KAAKD,EAAEnC,IAEb,OAAOY,EAaJ,SAASyB,EAAMC,EAAOC,GACzB,OAAON,EAAOM,EAAMD,EAAQ,GAAG,SAAUtC,GAAK,OAAOsC,EAAQtC,KAa1D,SAASwC,EAAUN,EAAGX,GACzB,OAAOU,EAAOC,GAAG,WAAc,OAAOX,KAenC,SAASkB,EAAQC,GAGpB,IAFA,IAAIC,EAAO,EACPhB,EAAMe,EAAI9C,OACLI,EAAI,EAAGA,EAAI2B,EAAK3B,IACrB2C,GAAQD,EAAI1C,GAAGJ,OAEnB,IAAIgB,EAAIb,MAAM4C,GACVL,EAAQ,EACZ,IAAStC,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAG1B,IAFA,IAAI4C,EAAMF,EAAI1C,GACVL,EAAIiD,EAAIhD,OACHiD,EAAI,EAAGA,EAAIlD,EAAGkD,IACnBjC,EAAEiC,EAAIP,GAASM,EAAIC,GAEvBP,GAAS3C,EAEb,OAAOiB,EAcJ,SAASkC,EAASC,EAASC,GAC9B,OAAO,SAAUtD,GAAM,OAAQuD,EAAQvD,GAAMqD,IAAYC,EAAOtD,EAAG,GAAIA,EAAGwD,MAAM,KAQ7E,SAASC,EAAUJ,EAASC,GAC/B,OAAO,SAAUtD,GAAM,OAAQuD,EAAQvD,GAAMqD,IAAYC,EAAOtD,EAAGwD,MAAM,EAAGxD,EAAGE,OAAS,GAAIF,EAAGA,EAAGE,OAAS,KAaxG,SAASwD,EAAS5B,EAAGW,GACxB,OAAO,SAAUzC,GACb,IAAIC,EAAID,EAAGE,OAEPgB,EAAI,IAAIb,MAAMJ,EAAI,GACtBiB,EAAE,GAAKY,EACP,IAAK,IAAIxB,EAAI,EAAGA,EAAIL,EAAGK,IACnBY,EAAEZ,EAAI,GAAKmC,EAAEvB,EAAEZ,GAAIN,EAAGM,IAE1B,OAAOY,GAcR,SAASyC,EAAU7B,EAAGW,GACzB,OAAO,SAAUzC,GACb,IAAIC,EAAID,EAAGE,OAEPgB,EAAI,IAAIb,MAAMJ,EAAI,GACtBiB,EAAEjB,GAAK6B,EACP,IAAK,IAAIxB,EAAIL,EAAI,EAAGK,GAAK,EAAGA,IACxBY,EAAEZ,GAAKmC,EAAEzC,EAAGM,GAAIY,EAAEZ,EAAI,IAE1B,OAAOY,GAaR,SAASqC,EAAQvD,GACpB,OAAqB,IAAdA,EAAGE,OAQP,SAAS0D,EAAW5D,GACvB,OAAOA,EAAGE,OAAS,EAOhB,SAAS2D,EAAavD,EAAGN,GAC5B,OAAOM,EAAI,GAAKA,GAAKN,EAAGE,OAErB,SAAS4D,EAAOxD,EAAGN,GACtB,YAAc+D,IAAP/D,EAAmB,SAAUA,GAAM,OAAO8D,EAAOxD,EAAGN,IAAS6D,EAAavD,EAAGN,GAAM2B,OAASA,OAAO3B,EAAGM,IAE1G,SAAS0D,EAAKC,EAAMC,GACvB,QAAaH,IAATG,EACA,OAAO,SAAUA,GAAQ,OAAOF,EAAKC,EAAMC,IAI/C,IAFA,IAAIjC,EAAMiC,EAAKhE,OACXgB,EAAIb,MAAM4B,EAAM,GACX3B,EAAI,EAAGA,EAAI2B,EAAK3B,IACrBY,EAAEZ,EAAI,GAAK4D,EAAK5D,GAGpB,OADAY,EAAE,GAAK+C,EACA/C,EAcJ,SAASiD,EAAKC,EAAMvB,GAGvB,IAFA,IAAIZ,EAAMmC,EAAKlE,OACXgB,EAAIb,MAAM4B,EAAM,GACX3B,EAAI,EAAGA,EAAI2B,EAAK3B,IACrBY,EAAEZ,GAAK8D,EAAK9D,GAGhB,OADAY,EAAEe,GAAOY,EACF3B,EAcJ,SAAS+C,EAAKjE,GACjB,OAAOuD,EAAQvD,GAAM2B,OAASA,OAAO3B,EAAG,IAcrC,SAASqE,EAAKrE,GACjB,OAAO8D,EAAO9D,EAAGE,OAAS,EAAGF,GAc1B,SAASkE,EAAKlE,GACjB,OAAOuD,EAAQvD,GAAM2B,OAASA,OAAO3B,EAAGwD,MAAM,IAc3C,SAASY,EAAKpE,GACjB,IAAIiC,EAAMjC,EAAGE,OACb,OAAe,IAAR+B,EAAYN,OAASA,OAAO3B,EAAGwD,MAAM,EAAGvB,EAAM,IAclD,SAASqC,EAAS9B,GACrB,OAAO,SAAUxC,GAAM,OAAOA,EAAGwD,MAAM,EAAGhB,IAavC,SAAS+B,EAAU/B,GACtB,OAAO,SAAUxC,GAAM,OAAc,IAANwC,EAAUrC,GAAQH,EAAGwD,OAAOhB,IAExD,SAASgC,EAAcC,GAC1B,OAAO,SAAUzE,GAGb,IAFA,IAAIM,EAAIoE,EAAiB1E,EAAIyE,GACzBL,EAAO/D,MAAMC,GACR6C,EAAI,EAAGA,EAAI7C,EAAG6C,IACnBiB,EAAKjB,GAAKnD,EAAGmD,GAEjB,OAAOiB,GAGf,IAAIM,EAAmB,SAAU1E,EAAIyE,GAGjC,IAFA,IAAIxE,EAAID,EAAGE,OACPI,EAAI,EACDA,EAAIL,GACFwE,EAAUzE,EAAGM,IADRA,KAKd,OAAOA,GAEJ,SAASqE,EAASF,GACrB,OAAO,SAAUzE,GAGb,IAFA,IAAIM,EAAIoE,EAAiB1E,EAAIyE,GACzBL,EAAO/D,MAAMC,GACR6C,EAAI,EAAGA,EAAI7C,EAAG6C,IACnBiB,EAAKjB,GAAKnD,EAAGmD,GAEjB,IAAIlD,EAAID,EAAGE,OACP0E,EAAOvE,MAAMJ,EAAIK,GACrB,IAAS6C,EAAI7C,EAAG6C,EAAIlD,EAAGkD,IACnByB,EAAKzB,EAAI7C,GAAKN,EAAGmD,GAErB,MAAO,CAAEiB,KAAMA,EAAMQ,KAAMA,IAc5B,SAASC,EAASrC,GACrB,OAAO,SAAUxC,GAAM,OAAOA,EAAGwD,MAAMhB,EAAGxC,EAAGE,SAa1C,SAAS4E,EAAUtC,GACtB,OAAO,SAAUxC,GAAM,OAAOA,EAAGwD,MAAM,EAAGxD,EAAGE,OAASsC,IAanD,SAASuC,EAAcN,GAC1B,OAAO,SAAUzE,GAIb,IAHA,IAAIM,EAAIoE,EAAiB1E,EAAIyE,GACzBxE,EAAID,EAAGE,OACP0E,EAAOvE,MAAMJ,EAAIK,GACZ6C,EAAI7C,EAAG6C,EAAIlD,EAAGkD,IACnByB,EAAKzB,EAAI7C,GAAKN,EAAGmD,GAErB,OAAOyB,GAeR,SAASI,EAAUP,GACtB,OAAO,SAAUzE,GAEb,IADA,IAAIiC,EAAMjC,EAAGE,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IACrB,GAAImE,EAAUzE,EAAGM,IACb,OAAOqB,OAAOrB,GAGtB,OAAOqB,QAGR,SAASsD,EAAUR,GACtB,OAAO,SAAUzE,GAEb,IADA,IAAIiC,EAAMjC,EAAGE,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IACrB,GAAImE,EAAUzE,EAAGM,IACb,OAAOqB,OAAO3B,EAAGM,IAGzB,OAAOqB,QAsBR,SAASuD,EAAazC,GACzB,OAAO,SAAUzC,GAEb,IADA,IAAIiC,EAAMjC,EAAGE,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAI6E,EAAI1C,EAAEzC,EAAGM,IACb,GAAIqB,SAASwD,GACT,OAAOA,EAGf,OAAOxD,QAGR,SAASyD,EAASX,GACrB,OAAO,SAAUzE,GAEb,IADA,IACSM,EADCN,EAAGE,OACM,EAAGI,GAAK,EAAGA,IAC1B,GAAImE,EAAUzE,EAAGM,IACb,OAAOqB,OAAO3B,EAAGM,IAGzB,OAAOqB,QAsBR,SAAS0D,EAAY5C,GACxB,OAAO,SAAUzC,GAEb,IADA,IACSM,EADCN,EAAGE,OACM,EAAGI,GAAK,EAAGA,IAAK,CAC/B,IAAI6E,EAAI1C,EAAEzC,EAAGM,IACb,GAAIqB,SAASwD,GACT,OAAOA,EAGf,OAAOxD,QAqBR,SAAS2D,EAAcb,GAC1B,OAAO,SAAUzE,GAEb,IADA,IACSM,EADCN,EAAGE,OACM,EAAGI,GAAK,EAAGA,IAC1B,GAAImE,EAAUzE,EAAGM,IACb,OAAOqB,OAAOrB,GAGtB,OAAOqB,QAcR,SAAS4D,EAASjF,EAAGuB,GACxB,OAAO,SAAU7B,GAAM,OAAQM,EAAI,GAAKA,EAAIN,EAAGE,OAASyB,OAASA,OAAO6D,GAAelF,EAAGuB,EAAG7B,KAc1F,SAASyF,EAASnF,EAAGuB,GACxB,OAAO,SAAU7B,GAAM,OAAQ6D,EAAavD,EAAGN,GAAM2B,OAASA,OAAO+D,GAAepF,EAAGuB,EAAG7B,KAcvF,SAAS2F,EAASrF,GACrB,OAAO,SAAUN,GAAM,OAAQ6D,EAAavD,EAAGN,GAAM2B,OAASA,OAAOiE,GAAetF,EAAGN,KAgBpF,SAAS6F,EAASvF,EAAGmC,GACxB,OAAO,SAAUzC,GAAM,OAAQ6D,EAAavD,EAAGN,GAAM2B,OAASA,OAAO+D,GAAepF,EAAGmC,EAAEzC,EAAGM,IAAKN,KAa9F,SAAS8F,EAAQ9F,GACpB,OAAIuD,EAAQvD,GACDA,EAEJA,EAAGwD,QAAQsC,UAcf,SAASC,EAAO/F,GAInB,IAFA,IAAIkB,EAAI,GACJe,EAAMjC,EAAGE,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIuB,EAAI7B,EAAGM,GACI,UAAXuB,EAAEmE,MACF9E,EAAEwB,KAAKb,EAAEoE,OAGjB,OAAO/E,EAaJ,SAASgF,EAAMlG,GAIlB,IAFA,IAAIkB,EAAI,GACJe,EAAMjC,EAAGE,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIuB,EAAI7B,EAAGM,GACI,SAAXuB,EAAEmE,MACF9E,EAAEwB,KAAKb,EAAEsE,MAGjB,OAAOjF,EAcJ,IAAIkF,EAAO,SAAUzE,GAAK,OAAO,SAAU3B,GAC9C,OAAOA,EAAGE,QAAU,EAAIF,EAAKA,EAAGwD,QAAQ4C,KAAKzE,EAAEU,WAe5C,SAASgE,EAAQC,EAAIC,EAAI9D,GAI5B,IAFA,IAAI+D,EAAK,GACLvE,EAAMC,KAAKC,IAAImE,EAAGpG,OAAQqG,EAAGrG,QACxBI,EAAI,EAAGA,EAAI2B,EAAK3B,IACrBkG,EAAGlG,GAAKmC,EAAE6D,EAAGhG,GAAIiG,EAAGjG,IAExB,OAAOkG,EAEJ,SAASC,GAAIzG,EAAI0G,GACpB,YAAW3C,IAAP2C,EACO,SAAUA,GAAM,OAAOD,GAAIC,EAAI1G,IAEnCqG,EAAQrG,EAAI0G,GAAI,SAAU7E,EAAGC,GAAK,MAAO,CAACD,EAAGC,MAYjD,SAAS6E,GAAM3G,GAKlB,IAHA,IAAIsG,EAAK,GAELC,EAAK,GACAjG,EAAI,EAAGA,EAAIN,EAAGE,OAAQI,IAC3BgG,EAAGhG,GAAKN,EAAGM,GAAG,GACdiG,EAAGjG,GAAKN,EAAGM,GAAG,GAElB,MAAO,CAACgG,EAAIC,GAaT,IAAIK,GAAe,SAAUC,GAAK,OAAO,SAAUtF,GAGtD,IADA,IAAIC,EAAK,GACAsF,EAAK,EAAGC,EAAOxF,EAAIuF,EAAKC,EAAK7G,OAAQ4G,IAAM,CAChD,IAAIhG,EAAIiG,EAAKD,GACbtF,EAAGkB,KAAKmE,EAAG/F,GAEf,OAAOU,IAaJ,SAASwF,GAAYH,GACxB,OAAO,SAAU7G,GAEb,OAAe,IADFA,EAAGE,OAELF,EAEJgE,EAAKhE,EAAG,GAAI4G,GAAaC,EAAbD,CAAgB5G,EAAGwD,MAAM,EAAGxD,EAAGE,WAcnD,SAAS+G,GAAOzE,GACnB,OAAO,SAAUxC,GACb,IAAIiC,EAAMjC,EAAGE,OACb,OAAU,IAANsC,GAAWP,GAAO,GAAKA,IAAQC,KAAKgF,IAAI1E,GACjCxC,EAEFwC,EAAI,EACFyE,GAAOhF,EAAMO,EAAbyE,CAAgBjH,GAGhBA,EAAGwD,OAAOhB,GAAG3B,OAAOb,EAAGwD,MAAM,EAAGvB,EAAMO,KAIlD,SAAS2E,GAAK9F,GACjB,OAAO,SAAUQ,EAAG7B,GAChB,QAAW+D,IAAP/D,EAAkB,CAClB,IAAIoH,EAAUD,GAAK9F,GACnB,OAAO,SAAUrB,GAAM,OAAOoH,EAAQvF,EAAG7B,IAK7C,IAHA,IAA0BqH,EACtB/G,EAAI,EACJ2B,EAAMjC,EAAGE,OACNI,EAAI2B,EAAK3B,IACZ,GAJsB+G,EAIRrH,EAAGM,GAJuBe,EAAEC,OAAO+F,EAASxF,GAKtD,OAAO,EAGf,OAAO,GAeR,SAASyF,GAAKjG,GACjB,IAAIkG,EAAQJ,GAAK9F,GACjB,OAAO,SAAUrB,GACb,IAAIiC,EAAMjC,EAAGE,OACb,GAAI+B,GAAO,EACP,OAAOjC,EAKX,IAFA,IAAIkB,EAAI,GACJZ,EAAI,EACDA,EAAI2B,EAAK3B,IAAK,CACjB,IAAIuB,EAAI7B,EAAGM,GACNiH,EAAM1F,EAAGX,IACVA,EAAEwB,KAAKb,GAGf,OAAOI,IAAQf,EAAEhB,OAASF,EAAKkB,GA+BhC,SAASsG,GAAOC,GACnB,IAAIC,EAAIC,sBACR,OAAOvB,EAAKqB,EAAKG,OAAOF,EAAE7G,OAAQ6G,EAAEvH,QAsBjC,IAAI0H,GAAO,SAAUpF,GAAK,OAAO,SAAUzC,GAI9C,IAFA,IAAI8H,EAAS,GACTC,EAAK/H,EACF4D,EAAWmE,IAAK,CACnB,IAAIC,EAAKvF,EAAEsF,GAAKjG,EAAIkG,EAAG,GAAIC,EAAID,EAAG,GAClCF,EAAOpF,KAAKZ,GACZiG,EAAKE,EAET,OAAOH,IAYJ,SAASI,GAAQ1F,GACpB,OAAO,SAAUxC,GAAM,MAAO,CAACA,EAAGwD,MAAM,EAAGhB,GAAIxC,EAAGwD,MAAMhB,KAqBrD,SAAS2F,GAAS3F,GACrB,IAAIC,EAAIoF,GAAKK,GAAQ1F,IACrB,OAAO,SAAUxC,GAAM,OAAsB,IAAdA,EAAGE,OAAeC,GAAQ0D,EAAarB,EAAI,EAAGxC,GAAM,CAACA,GAAMyC,EAAEzC,IAEzF,SAASoI,GAAcC,EAAO5F,EAAG6F,QAC1B,IAANA,IAAgBA,EAAI,WAAc,OAAO,IAC7C,IAAIC,EAAK,SAAUC,EAAOH,GACtB,OAAqB,IAAjBA,EAAMnI,OACCoI,EAAEG,WAAM,EAAQD,GAAS,CAAC/F,EAAEgG,WAAM,EAAQD,IAAUrI,GAGpDuI,GAAOL,EAAM,IAAI,SAAUvH,GAAK,OAAOyH,EAAGpE,EAAKqE,EAAO1H,GAAIuH,EAAM7E,MAAM,QAGrF,OAAO+E,EAAGpI,GAAOkI,GAEd,SAASM,GAAMtH,GAClB,IAAIuH,EAAQzB,GAAK9F,GACjB,OAAO,SAAUE,EAAIC,GACjB,QAAWuC,IAAPvC,EAAkB,CAClB,IAAIqH,EAAWF,GAAMtH,GACrB,OAAO,SAAUG,GAAM,OAAOqH,EAASrH,EAAID,IAE/C,OAAOV,EAAOU,EAAIC,EAAGsH,QAAO,SAAUjH,GAAK,OAAQ+G,EAAM/G,EAAGN,QAG7D,SAASwH,GAAa1H,GACzB,IAAIuH,EAAQzB,GAAK9F,GACjB,OAAO,SAAUE,EAAIC,GACjB,QAAWuC,IAAPvC,EAAkB,CAClB,IAAIwH,EAAkBD,GAAa1H,GACnC,OAAO,SAAUG,GAAM,OAAOwH,EAAgBxH,EAAID,IAEtD,OAAOA,EAAGuH,QAAO,SAAUjH,GAAK,OAAO+G,EAAM/G,EAAGL,OAGjD,SAASyH,GAAW5H,GACvB,IAAIuH,EAAQzB,GAAK9F,GACjB,OAAO,SAAUE,EAAIC,GACjB,QAAWuC,IAAPvC,EAAkB,CAClB,IAAI0H,EAAgBD,GAAW5H,GAC/B,OAAO,SAAUG,GAAM,OAAO0H,EAAc1H,EAAID,IAEpD,OAAOA,EAAGuH,QAAO,SAAUjH,GAAK,OAAQ+G,EAAM/G,EAAGL,OASlD,IAAI2H,GAAK,SAAUtH,GAAK,MAAO,CAACA,IAK5BuH,GAAO,WAAc,OAAOjJ,IAInCkJ,GAAO,SAAU/C,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI3F,GAAI8B,KAC9C8G,GAAgB,SAAUjD,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIkD,GAAa/G,KAChEgH,GAAM,SAAUC,EAAKpD,GAAM,OAAOgD,YAAKI,EAAKC,GAAGrD,KAC/CoC,GAAS,SAAUkB,EAAInH,GACvB,OAAO6G,YAAKM,EAAIC,GAAMpH,KAEtBqH,GAAU,SAAUxD,EAAI7B,GAAa,OAAO6E,YAAKhD,EAAIwC,GAAOrE,KAC5DsF,GAAa,SAAUzD,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI0D,GAAUvH,KAC1DwH,GAAsB,SAAU3D,EAAI4D,GAAsB,OAAOZ,YAAKhD,EAAI6D,GAAmBD,KAC7FE,GAAa,SAAU9D,EAAI7B,GAAa,OAAO6E,YAAKhD,EAAI+D,GAAU5F,KAClE6F,GAAgB,SAAUhE,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIiE,GAAa9H,KAChE+H,GAAyB,SAAUlE,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAImE,GAAsBhI,KAClFiI,GAAO,SAAUpE,EAAIqE,GAAQ,OAAOrB,YAAKhD,EAAIsE,GAAID,KACjDE,GAAU,SAAUvE,EAAIxE,EAAGW,GAAK,OAAO6G,YAAKhD,EAAIsB,GAAO9F,EAAGW,KAC1DqI,GAAW,SAAUpD,GACrB,IAAIqD,EAAWC,GAAQtD,GACvB,OAAO,SAAUpB,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIyE,EAAStI,MAEnDwI,GAAe,SAAU3E,EAAIxE,EAAGW,GAAK,OAAO6G,YAAKhD,EAAI4E,GAAYpJ,EAAGW,KACpE0I,GAAmB,SAAU7E,EAAIxE,EAAGW,GAGpC,IAFA,IAAIxC,EAAIqG,EAAGpG,OACPgB,EAAIY,EACCxB,EAAI,EAAGA,EAAIL,EAAGK,IACnBY,EAAIuB,EAAEnC,EAAGY,EAAGoF,EAAGhG,IAEnB,OAAOY,GAEPkK,GAAoB,SAAU1D,GAAK,OAAO,SAAUpB,EAAI7D,GACxD,OAAO6D,EAAGsB,QAAO,SAAU9F,EAAGD,EAAGvB,GAAK,OAAOoH,EAAE7G,OAAOiB,EAAGW,EAAEnC,EAAGuB,MAAQ6F,EAAEvH,SAExEkL,GAAwB,SAAU/E,EAAIxE,EAAGW,GACzC,OAAO6G,YAAKhD,EAAIgF,GAAqBxJ,EAAGW,KAExC8I,GAAsB,SAAUjF,EAAI7D,GACpC,OAAO6G,YAAKhD,EAAIkF,GAAmB/I,KAEnCgJ,GAAmB,SAAUnF,EAAI4D,GAAsB,OAAOZ,YAAKhD,EAAIoF,GAAgBxB,KACvFyB,GAAU,SAAUrF,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIsF,GAAOnJ,KACpDoJ,GAAY,SAAUC,GACtB,IAAIC,EAAYC,GAASF,GACzB,OAAO,SAAUG,EAAIxJ,GAAK,OAAO6G,YAAK2C,EAAIF,EAAUtJ,MAGpDyJ,GAAqB,SAAUJ,GAC/B,IAAIK,EAAqBC,GAAkBN,GAC3C,OAAO,SAAUG,EAAIxJ,GAAK,OAAO6G,YAAK2C,EAAIE,EAAmB1J,MAG7D4J,GAAU,SAAUP,GACpB,IAAIQ,EAAUC,GAAOT,GACrB,OAAO,SAAUxF,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIgG,EAAQ7J,MAGlD+J,GAAQ,SAAUV,GAClB,IAAIW,EAAQC,GAAKZ,GACjB,OAAO,SAAUxF,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAImG,EAAMhK,MAWzCkK,GAAO,SAAUhC,GAAQ,OAAO,SAAUrE,GAAM,OAAOzF,EAAOyF,EAAIqE,OAQlEC,GAAM+B,GAONhD,GAAK,SAAUrD,GACtB,OAAOuD,IAAM,SAAUpH,GAAK,OAAO6G,YAAKhD,EAAI3F,GAAI8B,QAUzCmK,GAAU,SAAUrG,GAC3B,OAAOsG,YAAKlM,IAAI,SAAUkB,GAAK,OAAO,WAAc,OAAOA,MAAU8H,GAAGpD,KAUjEuG,GAAW,SAAUvG,GAC5B,OAAOsG,YAAKlM,IAAI,WAAc,OAAO,SAAUmB,GAAK,OAAOA,MAAU6H,GAAGpD,KAQjEsD,GAAQ,SAAUpH,GAAK,OAAO,SAAUmH,GAC/C,OAAON,YAAKM,EAAImD,IAAe,SAAUC,EAAGnL,GAAK,OAAOY,EAAEZ,SAKnDkL,GAAiB,SAAUtK,GAAK,OAAO,SAAUmH,GAIxD,IAHA,IAAIqD,EAAS,EACThN,EAAI2J,EAAG1J,OACPgN,EAAO,IAAI7M,MAAMJ,GACZK,EAAI,EAAGA,EAAIL,EAAGK,IAAK,CACxB,IAAIuG,EAAI+C,EAAGtJ,GAEX2M,IADI/J,EAAMT,EAAEnC,EAAGuG,IACD3G,OACdgN,EAAK5M,GAAK4C,EAEd,IAAIiK,EAAM9M,MAAM4M,GACZrK,EAAQ,EACZ,IAAStC,EAAI,EAAGA,EAAIL,EAAGK,IAAK,CAGxB,IAFA,IAAI4C,EACAkK,GADAlK,EAAMgK,EAAK5M,IACDJ,OACLiD,EAAI,EAAGA,EAAIiK,EAAKjK,IACrBgK,EAAIhK,EAAIP,GAASM,EAAIC,GAEzBP,GAASwK,EAEb,OAAOD,IAWAE,GAAa,SAAU5K,GAC9B,OAAOoH,IAAM,SAAUhI,GACnB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,IAAI,WAAc,OAAOkB,UAUxClB,GAAM,SAAU8B,GAAK,OAAO,SAAU6D,GAC7C,OAAOA,EAAG3F,KAAI,SAAUkB,GAAK,OAAOY,EAAEZ,QAM/B2H,GAAe,SAAU/G,GAAK,OAAO,SAAU6D,GAAM,OAAOA,EAAG3F,KAAI,SAAUkB,EAAGvB,GAAK,OAAOmC,EAAEnC,EAAGuB,QAKjGyL,GAAW,SAAUhH,GAK5B,IAHA,IAAIH,EAAO,GAEPF,EAAQ,GACHa,EAAK,EAAGyG,EAAOjH,EAAIQ,EAAKyG,EAAKrN,OAAQ4G,IAAM,CAChD,IAAID,EAAI0G,EAAKzG,GACE,SAAXD,EAAEb,KACFG,EAAKzD,KAAKmE,EAAEV,MAGZF,EAAMvD,KAAKmE,EAAEZ,OAGrB,MAAO,CACHE,KAAMA,EACNF,MAAOA,IAOJ6C,GAAS,SAAUrE,GAAa,OAAO,SAAU6B,GAAM,OAAOA,EAAGwC,OAAOrE,KAKxE+G,GAAqB,SAAU/I,GAAK,OAAO,SAAU6D,GAG5D,IADA,IAAIwB,EAAS,GACJxH,EAAI,EAAGA,EAAIgG,EAAGpG,OAAQI,IAAK,CAChC,IAAIkN,EAAU/K,EAAEnC,EAAGgG,EAAGhG,IAClBqB,SAAS6L,IACT1F,EAAOpF,KAAK8K,EAAQC,OAG5B,OAAO3F,IAMAkC,GAAY,SAAUvH,GAC7B,OAAO+I,IAAmB,SAAUwB,EAAGnL,GAAK,OAAOY,EAAEZ,OAM9C6L,GAEX1D,GAAU2D,KAKCtD,GAAY,SAAU5F,GAC7B,OAAO0F,IAAmB,SAAU6C,EAAGnL,GAAK,OAAO4C,EAAU5C,OAMtDsI,GAAqB,SAAUD,GAAsB,OAAO,SAAU5D,GAK7E,IAHA,IAAIH,EAAO,GAEPF,EAAQ,GACH3F,EAAI,EAAGA,EAAIgG,EAAGpG,OAAQI,IAAK,CAChC,IAAIuB,EAAIyE,EAAGhG,GACP4J,EAAmB5J,EAAGuB,GACtBoE,EAAMvD,KAAKb,GAGXsE,EAAKzD,KAAKb,GAGlB,MAAO,CACHsE,KAAMA,EACNF,MAAOA,KAOJsE,GAAe,SAAU9H,GAChC,OAAOgI,IAAsB,SAAUuC,EAAGnL,GAAK,OAAOY,EAAEZ,OAMjD4I,GAAwB,SAAUhI,GAAK,OAAO,SAAU6D,GAK/D,IAHA,IAAIH,EAAO,GAEPF,EAAQ,GACH3F,EAAI,EAAGA,EAAIgG,EAAGpG,OAAQI,IAAK,CAChC,IAAIuG,EAAIpE,EAAEnC,EAAGgG,EAAGhG,IACD,SAAXuG,EAAEb,KACFG,EAAKzD,KAAKmE,EAAEV,MAGZF,EAAMvD,KAAKmE,EAAEZ,OAGrB,MAAO,CACHE,KAAMA,EACNF,MAAOA,KAOJyF,GAAkB,SAAUxB,GAAsB,OAAO,SAAU5D,GAC1E,OAAOA,EAAGwC,QAAO,SAAUjH,EAAGvB,GAAK,OAAO4J,EAAmB5J,EAAGuB,QAMzD+J,GAAS,SAAUnJ,GAAK,OAAO,SAAUmL,GAAM,OAAOA,EAAGjN,KAAI,SAAUqM,EAAG1M,EAAGN,GAAM,OAAOyC,EAAEzC,EAAGwD,MAAMlD,SAOrGuN,GAEXjC,GAAO+B,KAKIG,GAAmB,SAAUpG,GACpC,IAAIqG,EAAoB3C,GAAkB1D,GAC1C,OAAO,SAAUjF,GAAK,OAAO,SAAU6D,GAAM,OAAOyH,EAAkBzH,EAAI7D,MAMnEmF,GAAS,SAAU9F,EAAGW,GAC7B,OAAOuL,GAAgBlM,GAAG,SAAUkL,EAAGlL,EAAGD,GAAK,OAAOY,EAAEX,EAAGD,OAMpDmJ,GAAU,SAAUtD,GAC3B,IAAIqG,EAAoBD,GAAiBpG,GACzC,OAAO,SAAUjF,GAAK,OAAOsL,GAAkB,SAAUf,EAAGnL,GAAK,OAAOY,EAAEZ,QAMnEmM,GAAkB,SAAUlM,EAAGW,GAAK,OAAO,SAAU6D,GAAM,OAAO6E,GAAiB7E,EAAIxE,EAAGW,KAK1FyI,GAAc,SAAUpJ,EAAGW,GAClC,OAAO6I,GAAqBxJ,GAAG,SAAUkL,EAAGnL,EAAGC,GAAK,OAAOW,EAAEZ,EAAGC,OAMzDwJ,GAAuB,SAAUxJ,EAAGW,GAAK,OAAO,SAAU6D,GAAM,OAAOA,EAAG4E,aAAY,SAAUpJ,EAAGD,EAAGvB,GAAK,OAAOmC,EAAEnC,EAAGuB,EAAGC,KAAOA,KAMjIkK,GAAW,SAAUF,GAC5B,IAAIK,EAAqBC,GAAkBN,GAC3C,OAAO,SAAUrJ,GAAK,OAAO0J,GAAmB,SAAUa,EAAGnL,GAAK,OAAOY,EAAEZ,QAOpEoM,GAAW,SAAUnC,GAAK,OAAO,SAAUG,GAClD,OAAOpB,GAAQoB,EAAIH,EAAE3C,GAAGC,OAAS,SAAU8E,EAAK5H,GAC5C,OAAOwF,EAAEnC,GAAGmC,EAAEnL,IAAIuN,GAAK,SAAUlO,GAAM,OAAO,SAAU6B,GAAK,OAAOsC,EAAKnE,EAAI6B,OAAWyE,QAQrF8F,GAAoB,SAAUN,GAAK,OAAO,SAAUrJ,GAC3D,OAAOuL,GAAgBlC,EAAE3C,GAAGC,OAAS,SAAU9I,EAAG6N,EAAKtM,GACnD,OAAOiK,EAAEnC,GAAGmC,EAAEnL,IAAIwN,GAAK,SAAUzH,GAAM,OAAO,SAAU5E,GAAK,OAAOqC,EAAKuC,EAAI5E,OAAWW,EAAEnC,EAAGuB,SAO1F0K,GAAS,SAAUT,GAC1B,IAAIC,EAAYC,GAASF,GACzB,OAAO,SAAUrJ,GAAK,OAAO,SAAU6D,GAAM,OAAOwF,EAAEnL,IAAI2I,YAAKhD,EAAIyF,EAAUtJ,IAAKiL,OAM3EhB,GAAO,SAAUZ,GACxB,IAAIC,EAAYC,GAASF,GACzB,OAAO,SAAUrJ,GAAK,OAAO,SAAU6D,GAAM,OAAOwF,EAAEnL,IAAI2I,YAAKhD,EAAIyF,EAAUtJ,IAAK6K,OAM3Ec,GAAS,SAAUtM,EAAGW,GAI7B,IAFA,IAAI4L,EAAM,GACNC,EAAKxM,IACI,CACT,IAAIyM,EAAK9L,EAAE6L,GACX,IAAI3M,SAAS4M,GAMT,MALA,IAAIvG,EAAKuG,EAAGd,MAAO5L,EAAImG,EAAG,GAAIwG,EAAMxG,EAAG,GACvCqG,EAAI3L,KAAKb,GACTyM,EAAKE,EAMb,OAAOH,GASAI,GAAM,gBAKNC,GAAU,CACjBD,IAAKA,GACL9N,IAAK0I,IAMEsF,GAAmB,CAC1BF,IAAKA,GACL9N,IAAK0I,GACLG,aAAcD,IAMPqF,GAAc,CACrBH,IAAKA,GACL9N,IAAK0I,GACLM,GAAIF,GACJN,GAAIA,IAMG0F,GAAQ,CACfJ,IAAKA,GACL9N,IAAK0I,GACLM,GAAIF,GACJN,GAAIA,GACJU,MAAOnB,IAcAoG,GAAM,CACbL,IAAKA,GACL9N,IAAK0I,GACLuB,IAAKF,IAMEqE,GAAc,CACrBN,IAAKA,GACL9N,IAAK0I,GACLM,GAAIF,GACJN,GAAIA,GACJyB,IAAKF,GACLtB,KAAMA,IAMC4F,GAAS,CAChBP,IAAKA,GACL9N,IAAK0I,GACLuC,OAAQD,IAeDsD,GAAa,CACpBR,IAAKA,GACL9N,IAAK0I,GACLqE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,GACRE,UAAWD,GACXM,UAAWD,GACXG,aAAcD,IAMP4E,GAAsB,CAC7BT,IAAKA,GACL9N,IAAK0I,GACLG,aAAcD,GACdmE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,GACRE,UAAWD,GACXM,UAAWD,GACXG,aAAcD,GACdG,sBAAuBD,GACvBL,mBAAoBF,GACpBuB,mBAAoBD,GACpBG,gBAAiBD,IAMV0D,GAAW,CAClBV,IAAKA,GACL7G,OAAQiD,GACRG,QAASF,GACTI,YAAaD,IAMNmE,GAAoB,CAC3BX,IAAKA,GACL7G,OAAQiD,GACRG,QAASF,GACTI,YAAaD,GACb+C,gBAAiB7C,GACjB2C,iBAAkB1C,GAClBE,qBAAsBD,IAMfgE,GAAc,CACrBZ,IAAKA,GACL9N,IAAK0I,GACLzB,OAAQiD,GACRG,QAASF,GACTI,YAAaD,GACbe,SAAUH,GACVoC,SAAUA,IAMHqB,GAAuB,CAC9Bb,IAAKA,GACL9N,IAAK0I,GACLG,aAAcD,GACd3B,OAAQiD,GACRG,QAASF,GACTI,YAAaD,GACb+C,gBAAiB7C,GACjB2C,iBAAkB1C,GAClBE,qBAAsBD,GACtBW,SAAUH,GACVoC,SAAUA,GACV7B,kBAAmBF,IAMZqD,GAAa,CACpBd,IAAKA,GACL9N,IAAK0I,GACLqE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,GACRE,UAAWD,GACXM,UAAWD,GACXG,aAAcD,GACd1C,OAAQiD,GACRG,QAASF,GACTI,YAAaD,GACbe,SAAUH,GACVoC,SAAUA,GACV1B,OAAQF,GACRK,KAAMF,IA+CH,SAAShH,GAAelF,EAAGuB,EAAG7B,GACjC,IAAIuB,EAAKvB,EAAGwD,QAEZ,OADAjC,EAAGiO,OAAOlP,EAAG,EAAGuB,GACTN,EAMJ,SAASmE,GAAepF,EAAGuB,EAAG7B,GACjC,GAAIA,EAAGM,KAAOuB,EACV,OAAO7B,EAGP,IAAIuB,EAAKvB,EAAGwD,QAEZ,OADAjC,EAAGjB,GAAKuB,EACDN,EAOR,SAASqE,GAAetF,EAAGN,GAC9B,IAAIuB,EAAKvB,EAAGwD,QAEZ,OADAjC,EAAGiO,OAAOlP,EAAG,GACNiB,EAUJ,IAAIpB,GAAQ,GAeRsB,GAAQ,SAAUgD,GAAa,OAAO,SAAUzE,GAAM,OAAOA,EAAGyB,MAAMgD,KAetEgL,GAAO,SAAUhL,GAAa,OAAO,SAAUzE,GAAM,OAAOA,EAAGyP,KAAKhL,KAapEiL,GAAS,SAAUC,GAC1B,OAAOhP,GAAIiP,YAAQD,KAKZE,GAAO,SAAUF,EAAMlN,GAC9B,OAAOoH,IAAM,SAAUhI,GACnB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,IAAI,SAAUmB,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,WASxDiO,GAAM,SAAUJ,EAAMpJ,GAC7B,OAAOsG,YAAKlM,IAAI,SAAUkB,GAAK,OAAO,SAAUC,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,OAAW6H,GAAGpD,M,iCCl1D7F,mgFAQW/F,EAAUwP,IAMVC,EAAOD,IAMPzM,EAAUyM,IAIVE,EAAOF,IAePG,EAAUH,IAIVzP,EAAUyP,IACd,SAASI,EAAaC,GACzB,OAAOL,IAAgBK,GAEpB,SAAS9K,EAAS+K,EAAGzO,GACxB,OAAOmO,IAAYM,EAAGzO,GAKnB,IAAI0O,EAAiBP,IACrB,SAASrK,EAAS2K,GACrB,OAAON,IAAYM,GAKhB,IAAI7K,EAAWuK,IAIXnK,EAAWmK,IACf,SAASQ,EAAIF,GAChB,OAAON,IAAOM,GAQX,IAAIG,EAAcT,IAClB,SAAS5O,EAAMC,GAClB,OAAO2O,IAAS3O,GAEb,SAASF,EAAUV,GACtB,OAAOuP,IAAavP,GAQjB,IAAIqD,EAASkM,IAIT7P,EAAQ,GACZ,SAASqJ,EAAa/G,GACzB,OAAOuN,IAAgBvN,GAEpB,SAAS9B,EAAI8B,GAChB,OAAOuN,IAAOvN,GAEX,SAASuL,EAAgBlM,EAAGW,GAC/B,OAAOuN,IAAmBlO,EAAGW,GAE1B,SAASqL,EAAiBpG,GAC7B,OAAOsI,IAAoBtI,GAExB,SAAS4D,EAAqBxJ,EAAGW,GACpC,OAAOuN,IAAwBlO,EAAGW,GAO/B,IAAIiO,EAAYV,IAChB,SAAS5D,EAAkBN,GAC9B,OAAOkE,IAAqBlE,GAEzB,SAASE,EAASF,GACrB,OAAOkE,IAAYlE,GAEhB,SAASmC,EAASnC,GACrB,OAAOkE,IAAYlE,GAMhB,IAAIS,EAASyD,KAKTtD,EAAOsD,KACX,SAASvF,EAAsBhI,GAClC,OAAOuN,IAAyBvN,GAE7B,SAAS0H,EAAmBD,GAC/B,OAAO8F,IAAsB9F,GAE1B,SAASsB,EAAmB/I,GAC/B,OAAOuN,IAAsBvN,GAE1B,SAASiJ,EAAgBxB,GAC5B,OAAO8F,IAAmB9F,GAEvB,SAASyG,EAAajJ,EAAGoE,GAC5B,OAAOkE,IAAgBtI,EAAGoE,GAEvB,SAAS8E,EAAgBlJ,EAAGoE,GAC/B,OAAOkE,IAAmBtI,EAAGoE,GAK1B,IAAIrK,EAAQuO,IAIRP,EAAOO,IAKP7I,EAAO6I,IAId3G,EAAO2G,IAAWrP,IAClB4I,EAAgByG,IAAoBxG,aACpCqB,EAAUmF,IAAYpI,OACtBkD,EAAWkF,IAAYhF,QACvBC,EAAe+E,IAAY9E,YAC3BC,EAAmB6E,IAAqBhC,gBACxC5C,EAAoB4E,IAAqBlC,iBACzCzC,EAAwB2E,IAAqB1E,qBAC7CxB,EAAUkG,IAAclH,OACxBiB,EAAaiG,IAAchG,UAC3BI,EAAa4F,IAAc3F,UAC3BC,EAAgB0F,IAAczF,aAC9BkB,GAAmBuE,IAClBtE,gBACDH,GAAsByE,IAAuBxE,mBAC7CvB,GAAsB+F,IACrB7F,mBACDK,GAAyBwF,IAAuBvF,sBAChDyB,GAAqB8D,IACpB5D,kBACDC,GAAU2D,IAAczD,OACxBC,GAAQwD,IAActD,KACtBb,GAAY,SAAUC,GACtB,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAUG,EAAIxJ,GAAK,OAAOsJ,EAAUtJ,EAAVsJ,CAAaE,KASvCnD,GAASkH,IAKThG,GAAYgG,IAKZhF,GAAUgF,IAKV3F,GAAY2F,IAKZzF,GAAeyF,IAKfpI,GAASoI,IAKT9E,GAAc8E,IAKdtC,GAAUsC,IAKV1C,GAAW0C,IAQXvB,GAAM,SAKNC,GAAU,CACjBD,IAAKA,GACL9N,IAAK0I,GAMEsF,GAAmB,CAC1BF,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,GAMP4F,GAAW,CAClBV,IAAKA,GACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,GAMNmE,GAAoB,CAC3BX,IAAKA,GACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACb+C,gBAAiB7C,EACjB2C,iBAAkB1C,EAClBE,qBAAsBD,GAMfwF,GAAc,CACrBpC,IAAKA,GACLf,QAASA,GACTJ,SAAUA,IAMH2B,GAAa,CACpBR,IAAKA,GACL9N,IAAK0I,EACLqE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,GAMP4E,GAAsB,CAC7BT,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,EACdmE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,EACdkB,mBAAoBD,GACpBG,gBAAiBD,GACjBhB,sBAAuBD,GACvBL,mBAAoBF,IAMboF,GAAc,CACrBZ,IAAKA,GACL9N,IAAK0I,EACLzB,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,GACVoC,SAAUA,GAMHqB,GAAuB,CAC9Bb,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,EACd3B,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACb+C,gBAAiB7C,EACjB2C,iBAAkB1C,EAClBE,qBAAsBD,EACtBW,SAAUH,GACVoC,SAAUA,EACV7B,kBAAmBF,IAMZqD,GAAa,CACpBd,IAAKA,GACL9N,IAAK0I,EACLzB,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,GACVoC,SAAUA,EACVP,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,EACdiC,OAAQF,GACRK,KAAMF,IAOCsE,GAAS,CAChBrC,IAAKA,GACL9N,IAAK0I,EACLzB,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,GACVoC,SAAUA,EACVP,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,EACdd,aAAcD,EACdyE,gBAAiB7C,EACjB2C,iBAAkB1C,EAClBE,qBAAsBD,EACtBG,mBAAoBD,GACpBG,gBAAiBD,GACjBhB,sBAAuBD,GACvBL,mBAAoBF,GACpBmC,kBAAmBF,GACnBK,OAAQF,GACRK,KAAMF,K,gCC3ZV,uxEAeWxI,EAAO+M,IAYP5M,EAAO4M,KAOX,SAASC,EAAkBhR,GAC9B,OAAO+Q,KAAc/Q,GAAMyP,eAAKzP,GAAMiR,OAOnC,SAASlR,EAAUC,GACtB,OAAOgR,EAAkBD,KAAa/Q,IAanC,SAASkR,EAAOC,GACnB,MAAO,CAACA,EAAI,GAAIA,EAAI3N,MAAM,IAavB,SAAS4N,EAAOD,GACnB,IAAIlR,EAAIkR,EAAIjR,OAAS,EACrB,MAAO,CAACiR,EAAI3N,MAAM,EAAGvD,GAAIkR,EAAIlR,IAM1B,IAAIO,EAAUuQ,KAId,SAAS9M,EAAKkN,GACjB,OAAOA,EAAI,GAKR,SAASjN,EAAKiN,GACjB,OAAOA,EAAI3N,MAAM,GAMd,IAAIsC,EAAUiL,KAId,SAAS5O,EAAIkP,GAChB,IAAI5Q,EAAI6Q,2BAAiBD,GACzB,OAAO,SAAUF,GAAO,OAAOA,EAAIvJ,OAAOnH,EAAEI,SAKzC,SAAS0Q,EAAIF,GAChB,IAAI5Q,EAAI+Q,2BAAiBH,GACzB,OAAO,SAAUF,GAAO,OAAOA,EAAIvJ,OAAOnH,EAAEI,SAQzC,SAAS4Q,IACZ,MAAO,CACH5Q,OAAQA,GAeT,IAAIO,EAAQ2P,KACZ,SAASW,EAAMrQ,GAClB,OAAO,SAAUrB,GACb,IAAIiC,EAAMjC,EAAGE,OACb,GAAY,IAAR+B,EACA,OAAO8O,IAMX,IAHA,IAAI7P,EAAI,GACJ+C,EAAOjE,EAAG,GACVmR,EAAM,CAAClN,GACF3D,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIQ,EAAId,EAAGM,GACPe,EAAEC,OAAOR,EAAGmD,GACZkN,EAAIzO,KAAK5B,IAGTI,EAAEwB,KAAKyO,GAEPA,EAAM,CADNlN,EAAOnD,IAKf,OADAI,EAAEwB,KAAKyO,GACAjQ,GAGR,SAASyQ,EAAUhQ,GACtB,IAAIiQ,EAAQb,KAAQpP,GAChBkQ,EAASH,EAAM/P,GACnB,OAAO,SAAU3B,GAAM,OAAO6R,EAAOD,EAAM5R,KAiBxC,SAAS8R,EAAQrP,GACpB,OAAO,SAAUzC,GAEb,IADA,IAAIkB,EAAI,GACC4F,EAAK,EAAGiL,EAAO/R,EAAI8G,EAAKiL,EAAK7R,OAAQ4G,IAAM,CAChD,IAAIjF,EAAIkQ,EAAKjL,GACTwJ,EAAI7N,EAAEZ,GACNX,EAAEqP,eAAeD,GACjBpP,EAAEoP,GAAG5N,KAAKb,GAGVX,EAAEoP,GAAK,CAACzO,GAGhB,OAAOX,GAMR,SAASmD,EAAK8M,GACjB,OAAOA,EAAIA,EAAIjR,OAAS,GAarB,SAASkE,EAAK+M,GACjB,OAAOA,EAAI3N,MAAM,GAAI,GAMlB,SAAS4C,EAAKzE,GACjB,OAAOoP,KAAQpP,GAKZ,SAAS4D,EAASjF,EAAGuB,GACxB,OAAOkP,KAAYzQ,EAAGuB,GAKnB,SAAS4D,EAASnF,EAAGuB,GACxB,OAAOkP,KAAYzQ,EAAGuB,GAKnB,SAASgE,EAASvF,EAAGmC,GACxB,OAAOsO,KAAYzQ,EAAGmC,GAEnB,SAASqG,EAAOrE,GACnB,OAAOiH,GAAgB,SAAUsB,EAAGnL,GAAK,OAAO4C,EAAU5C,MAKvD,SAAS6J,EAAgBjH,GAC5B,OAAO,SAAU0M,GAAO,OAAOH,EAAkBG,EAAIrI,QAAO,SAAUjH,EAAGvB,GAAK,OAAOmE,EAAUnE,EAAGuB,QAQ/F,IAAIsH,EAAK4H,KACT,SAASlQ,EAAOmR,EAAIC,GACvB,OAAOD,EAAGnR,OAAOoR,GAKd,SAASC,EAAKzR,GACjB,OAAO,SAAU6F,GAAM,OAAOA,EAAGsB,OAAOnH,EAAEI,SAMvC,IAAIwF,EAAU0K,KAKVtK,EAAMsK,KAINpK,EAAQoK,KAYRnK,EAAemK,KAYf/J,EAAc+J,KAIrB1H,EAAO0H,IAAWpQ,IAClB4I,EAAgBwH,IAAoBvH,aACpCC,EAAMsH,IAAepH,GACrBjB,EAASqI,IAASlH,MAClB8B,EAAUoF,IAAUnF,OACpBf,EAAUkG,IAAYnJ,OACtBkD,EAAWiG,IAAY/F,QACvBC,EAAe8F,IAAY7F,YAC3BW,EAAYkF,IAAe/E,SAC3BtB,EAAOqG,IAAOnG,IACdO,EAAmB4F,IAAqB/C,gBACxC5C,EAAoB2F,IACnBjD,iBACDzC,EAAwB0F,IACvBzF,qBACDY,EAAqB6E,IACpB3E,kBAQM0B,GAAmB,SAAUrN,GAAK,OAAO,SAAUgC,GAAK,OAAO,SAAU6D,GAAM,OAAOA,EAAG9C,MAAM,GAAGoE,QAAO,SAAUuK,EAAGtQ,EAAGvB,GAAK,OAAOG,EAAEI,OAAOsR,EAAG1P,EAAEnC,EAAI,EAAGuB,MAAQY,EAAE,EAAG6D,EAAG,QAK1K0E,GAAU,SAAUvK,GAAK,OAAO,SAAUgC,GAAK,OAAO,SAAU6D,GACvE,OAAOA,EAAG9C,MAAM,GAAGoE,QAAO,SAAUuK,EAAGtQ,GAAK,OAAOpB,EAAEI,OAAOsR,EAAG1P,EAAEZ,MAAQY,EAAE6D,EAAG,QAQvEqG,GAAOoE,IAQPnG,GAAMmG,IAKNpH,GAAKoH,IASLnE,GAAUmE,IASVjE,GAAWiE,IAOXlH,GAAQkH,IAUR1D,GAAa0D,IAOblD,GAAYkD,IAKZnF,GAASmF,IAOThO,GAAUgO,IAQVpQ,GAAMoQ,KAKNvH,GAAeuH,KAKfnJ,GAASmJ,KAKT/C,GAAkB+C,KAKlB7F,GAAc6F,KAKdzF,GAAuByF,KAIvB/E,GAAW+E,KAIX9C,GAAW8C,KAIX3E,GAAoB2E,KAYpBtC,GAAM,wBAKNC,GAAU,CACjBD,IAAKA,GACL9N,IAAK0I,GAMEsF,GAAmB,CAC1BF,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,GAMPqF,GAAc,CACrBH,IAAKA,GACL9N,IAAK0I,EACLM,GAAIF,EACJN,GAAIA,GAMG0F,GAAQ,CACfJ,IAAKA,GACL9N,IAAK0I,EACLM,GAAIF,EACJN,GAAIA,EACJU,MAAOnB,GAMAyG,GAAW,CAClBV,IAAKA,GACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,GAMNmE,GAAoB,CAC3BX,IAAKA,GACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACb+C,gBAAiB7C,EACjB2C,iBAAkB1C,EAClBE,qBAAsBD,GAMfgE,GAAc,CACrBZ,IAAKA,GACL9N,IAAK0I,EACLzB,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,EACVoC,SAAUA,IAMHqB,GAAuB,CAC9Bb,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,EACd3B,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,EACVoC,SAAUA,GACVD,gBAAiB7C,EACjB2C,iBAAkB1C,EAClBE,qBAAsBD,EACtBe,kBAAmBF,GAMZ4C,GAAM,CACbL,IAAKA,GACL9N,IAAK0I,EACLuB,IAAKF,GAME0H,GAAU,CACjB3D,IAAKA,GACL9N,IAAK0I,EACLuC,OAAQD,EACR0G,QAtHiBpO,GA6JVyL,GAAS,SAAUC,GAAQ,OAAOhP,GAAIiP,YAAQD,KAI9CE,GAAO,SAAUF,EAAMlN,GAC9B,OAAOoH,IAAM,SAAUhI,GACnB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,IAAI,SAAUmB,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,WASxDiO,GAAM,SAAUJ,EAAMpJ,GAC7B,OAAOsG,YAAKlM,IAAI,SAAUkB,GAAK,OAAO,SAAUC,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,OAAW6H,GAAGpD,M,gCCznB7F,01DAqBO,SAAS/F,EAAQC,GACpB,MAAO,CACHC,KAAM,SAAUQ,GACZ,IAAIoR,EAAWnC,GAAQ,SAAUG,EAAGzO,GAAK,OAAO0Q,KAAKC,UAAUlC,GAAK,KAAO7P,EAAEC,KAAKmB,KAAnEsO,CAA0EjP,GAAGN,KAAK,MACjG,MAAoB,KAAb0R,EAAkB,KAAO,KAAOA,EAAW,OASvD,SAASrC,EAAK/O,GACjB,OAAOuR,OAAOvC,KAAKhP,GAAGhB,OAOnB,SAASqD,EAAQrC,GACpB,OAAiC,IAA1BuR,OAAOvC,KAAKhP,GAAGhB,OAKnB,SAASgQ,EAAKhP,GACjB,OAAOuR,OAAOvC,KAAKhP,GAAGkF,OAgBnB,SAAS+J,EAAQ1N,GACpB,OAAO,SAAUvB,GAGb,IADA,IAAIiM,EAAM,GACDrG,EAAK,EAAGkB,EAAKkI,EAAKhP,GAAI4F,EAAKkB,EAAG9H,OAAQ4G,IAAM,CACjD,IAAI4L,EAAM1K,EAAGlB,GACbqG,EAAIzK,KAAKD,EAAEiQ,EAAKxR,EAAEwR,KAEtB,OAAOvF,GAOR,IAAIwF,EAEXxC,GAAQ,SAAUG,EAAGzO,GAAK,MAAO,CAACyO,EAAGzO,MAC9B,SAASuO,EAAaC,GACzB,OAAO,SAAUnP,GACb,IAAIgC,EAAMyP,EAAgBzR,GACtBe,EAAMiB,EAAIhD,OACd,OAAOmQ,EAAEjC,OAAO,GAAG,SAAUtM,GAAK,OAAQA,EAAIG,EAAM2Q,eAAW,CAAC1P,EAAIpB,GAAIA,EAAI,IAAMmP,WAGnF,SAAS1L,EAAS+K,EAAGzO,GACxB,OAAO,SAAUX,GACb,GAAIA,EAAEoP,KAAOzO,EACT,OAAOX,EAEX,IAAIiM,EAAMsF,OAAOI,OAAO,GAAI3R,GAE5B,OADAiM,EAAImD,GAAKzO,EACFsL,GAGf,IAAI2F,EAAkBL,OAAOM,UAAUxC,eAChC,SAASA,EAAeD,EAAGpP,GAC9B,OAAO4R,EAAgBE,UAAWjP,IAAN7C,EAAkB+R,KAAO/R,EAAGoP,GAErD,SAAS3K,EAAS2K,GACrB,OAAO,SAAUpP,GACb,IAAK4R,EAAgBE,KAAK9R,EAAGoP,GACzB,OAAOpP,EAEX,IAAIiM,EAAMsF,OAAOI,OAAO,GAAI3R,GAE5B,cADOiM,EAAImD,GACJnD,GAMR,SAAS1H,EAAS6K,EAAGzO,GACxB,OAAO,SAAUX,GACb,IAAKqP,EAAeD,EAAGpP,GACnB,OAAO+P,OAEX,GAAI/P,EAAEoP,KAAOzO,EACT,OAAO+Q,eAAW1R,GAEtB,IAAIiM,EAAMsF,OAAOI,OAAO,GAAI3R,GAE5B,OADAiM,EAAImD,GAAKzO,EACF+Q,eAAWzF,IAMnB,SAAStH,EAASyK,EAAG7N,GACxB,OAAO,SAAUvB,GACb,IAAKqP,EAAeD,EAAGpP,GACnB,OAAO+P,OAEX,IAAI9D,EAAMsF,OAAOI,OAAO,GAAI3R,GAE5B,OADAiM,EAAImD,GAAK7N,EAAEvB,EAAEoP,IACNsC,eAAWzF,IAGnB,SAASqD,EAAIF,GAChB,IAAI4C,EAAYvN,EAAS2K,GACzB,OAAO,SAAUpP,GACb,IAAIiS,EAAKrP,EAAOwM,EAAGpP,GACnB,OAAOkS,iBAAOD,GAAMlC,OAAO2B,eAAW,CAACO,EAAG1F,MAAOyF,EAAUhS,MAG5D,SAASuP,EAAYpP,GACxB,OAAO,SAAUgS,EAAI1I,GACjB,QAAa5G,IAAT4G,EAAoB,CACpB,IAAI2I,EAAiB7C,EAAYpP,GACjC,OAAO,SAAUsJ,GAAQ,OAAO2I,EAAe3I,EAAM0I,IAEzD,IAAK,IAAI/C,KAAK+C,EACV,IAAKP,EAAgBE,KAAKrI,EAAM2F,KAAOjP,EAAEC,OAAO+R,EAAG/C,GAAI3F,EAAK2F,IACxD,OAAO,EAGf,OAAO,GAGR,SAASlP,EAAMC,GAClB,IAAIkS,EAAe9C,EAAYpP,GAC/B,OAAOmS,sBAAW,SAAU1S,EAAGC,GAAK,OAAOwS,EAAazS,EAAbyS,CAAgBxS,IAAMwS,EAAaxS,EAAbwS,CAAgBzS,MAE9E,SAASK,EAAUV,GACtB,MAAO,CACHI,OAAQ,SAAUC,EAAGC,GACjB,GAAID,IAAMX,EACN,OAAOY,EAEX,GAAIA,IAAMZ,EACN,OAAOW,EAEX,IAAIoP,EAAOuC,OAAOvC,KAAKnP,GACnBkB,EAAMiO,EAAKhQ,OACf,GAAY,IAAR+B,EACA,OAAOnB,EAGX,IADA,IAAII,EAAIuR,OAAOI,OAAO,GAAI/R,GACjBR,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIgQ,EAAIJ,EAAK5P,GACbY,EAAEoP,GAAKwC,EAAgBE,KAAKlS,EAAGwP,GAAK7P,EAAEI,OAAOC,EAAEwP,GAAIvP,EAAEuP,IAAMvP,EAAEuP,GAEjE,OAAOpP,GAEXf,MAAOA,GAGR,SAAS2D,EAAOwM,EAAGpP,GACtB,YAAU6C,IAAN7C,EACO,SAAUA,GAAK,OAAO4C,EAAOwM,EAAGpP,IAEpC4R,EAAgBE,KAAK9R,EAAGoP,GAAKsC,eAAW1R,EAAEoP,IAAMW,OAKpD,IAAI9Q,EAAQ,GACZ,SAASqJ,EAAa/G,GACzB,OAAO,SAAU6D,GAGb,IAFA,IAAI6G,EAAM,GAEDrG,EAAK,EAAG2M,EADNhB,OAAOvC,KAAK5J,GACSQ,EAAK2M,EAAOvT,OAAQ4G,IAAM,CACtD,IAAI4L,EAAMe,EAAO3M,GACjBqG,EAAIuF,GAAOjQ,EAAEiQ,EAAKpM,EAAGoM,IAEzB,OAAOvF,GAGR,SAASxM,EAAI8B,GAChB,OAAO+G,GAAa,SAAUwD,EAAGnL,GAAK,OAAOY,EAAEZ,MAE5C,SAASmM,EAAgBlM,EAAGW,GAC/B,OAAO,SAAU6D,GAIb,IAHA,IAAI6G,EAAMrL,EACN4R,EAAKxD,EAAK5J,GACVrE,EAAMyR,EAAGxT,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIgQ,EAAIoD,EAAGpT,GACX6M,EAAM1K,EAAE6N,EAAGnD,EAAK7G,EAAGgK,IAEvB,OAAOnD,GAGR,SAASW,EAAiBpG,GAC7B,OAAO,SAAUjF,GAAK,OAAO,SAAU6D,GAInC,IAHA,IAAI6G,EAAMzF,EAAEvH,MACRuT,EAAKxD,EAAK5J,GACVrE,EAAMyR,EAAGxT,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIgQ,EAAIoD,EAAGpT,GACX6M,EAAMzF,EAAE7G,OAAOsM,EAAK1K,EAAE6N,EAAGhK,EAAGgK,KAEhC,OAAOnD,IAGR,SAAS7B,EAAqBxJ,EAAGW,GACpC,OAAO,SAAU6D,GAIb,IAHA,IAAI6G,EAAMrL,EACN4R,EAAKxD,EAAK5J,GAELhG,EADCoT,EAAGxT,OACM,EAAGI,GAAK,EAAGA,IAAK,CAC/B,IAAIgQ,EAAIoD,EAAGpT,GACX6M,EAAM1K,EAAE6N,EAAGhK,EAAGgK,GAAInD,GAEtB,OAAOA,GASR,SAASuD,EAAUJ,EAAGzO,GACzB,IAAImG,EACJ,OAAOA,EAAK,IAAOsI,GAAKzO,EAAGmG,EAExB,SAASoE,EAAkBN,GAC9B,OAAO,SAAUrJ,GAAK,OAAO,SAAUwJ,GACnC,IAAIyH,EAAKxD,EAAKjE,GACd,GAAkB,IAAdyH,EAAGxT,OACH,OAAO4L,EAAE3C,GAAGhJ,GAShB,IAPA,IAAIwT,EAAK7H,EAAE3C,GAAG,IACVyK,EAAU,SAAUlB,GACpBiB,EAAK7H,EAAEnC,GAAGmC,EAAEnL,IAAIgT,GAAI,SAAUzS,GAAK,OAAO,SAAUY,GAEhD,OADAZ,EAAEwR,GAAO5Q,EACFZ,MACJuB,EAAEiQ,EAAKzG,EAAGyG,MAEZ5L,EAAK,EAAG+M,EAAOH,EAAI5M,EAAK+M,EAAK3T,OAAQ4G,IAAM,CAEhD8M,EADUC,EAAK/M,IAGnB,OAAO6M,IAGR,SAAS3H,EAASF,GACrB,IAAIK,EAAqBC,EAAkBN,GAC3C,OAAO,SAAUrJ,GAAK,OAAO0J,GAAmB,SAAUa,EAAGnL,GAAK,OAAOY,EAAEZ,OAExE,SAASoM,EAASnC,GACrB,OAAOM,EAAkBN,EAAlBM,EAAqB,SAAUY,EAAGnL,GAAK,OAAOA,KAMlD,IAAI0K,EAAS,SAAUT,GAC1B,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAUrJ,GAAK,OAAO,SAAU6D,GAAM,OAAOwF,EAAEnL,IAAI2I,YAAKhD,EAAIyF,EAAUtJ,IAAKiL,OAM3EhB,EAAO,SAAUZ,GACxB,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAUrJ,GAAK,OAAO,SAAU6D,GAAM,OAAOwF,EAAEnL,IAAI2I,YAAKhD,EAAIyF,EAAUtJ,IAAK6K,OAE/E,SAAS7C,EAAsBhI,GAClC,OAAO,SAAU6D,GAIb,IAHA,IAAIH,EAAO,GACPF,EAAQ,GAEHa,EAAK,EAAGgN,EADNrB,OAAOvC,KAAK5J,GACSQ,EAAKgN,EAAO5T,OAAQ4G,IAAM,CACtD,IAAI4L,EAAMoB,EAAOhN,GACbD,EAAIpE,EAAEiQ,EAAKpM,EAAGoM,IAClB,OAAQ7L,EAAEb,MACN,IAAK,OACDG,EAAKuM,GAAO7L,EAAEV,KACd,MACJ,IAAK,QACDF,EAAMyM,GAAO7L,EAAEZ,OAI3B,MAAO,CACHE,KAAMA,EACNF,MAAOA,IAIZ,SAASkE,EAAmBD,GAC/B,OAAO,SAAU5D,GAIb,IAHA,IAAIH,EAAO,GACPF,EAAQ,GAEHa,EAAK,EAAGiN,EADNtB,OAAOvC,KAAK5J,GACSQ,EAAKiN,EAAO7T,OAAQ4G,IAAM,CACtD,IAAI4L,EAAMqB,EAAOjN,GACbjF,EAAIyE,EAAGoM,GACPxI,EAAmBwI,EAAK7Q,GACxBoE,EAAMyM,GAAO7Q,EAGbsE,EAAKuM,GAAO7Q,EAGpB,MAAO,CACHsE,KAAMA,EACNF,MAAOA,IAIZ,SAASuF,EAAmB/I,GAC/B,OAAO,SAAU6D,GAGb,IAFA,IAAIpF,EAAI,GAEC4F,EAAK,EAAGkN,EADNvB,OAAOvC,KAAK5J,GACSQ,EAAKkN,EAAO9T,OAAQ4G,IAAM,CACtD,IAAI4L,EAAMsB,EAAOlN,GACb0G,EAAU/K,EAAEiQ,EAAKpM,EAAGoM,IACpBuB,iBAAOzG,KACPtM,EAAEwR,GAAOlF,EAAQC,OAGzB,OAAOvM,GAGR,SAASwK,EAAgBxB,GAC5B,OAAO,SAAU5D,GACb,IAAI6G,EAAM,GACN+G,GAAU,EACd,IAAK,IAAIxB,KAAOpM,EACZ,GAAIwM,EAAgBE,KAAK1M,EAAIoM,GAAM,CAC/B,IAAI7Q,EAAIyE,EAAGoM,GACPxI,EAAmBwI,EAAK7Q,GACxBsL,EAAIuF,GAAO7Q,EAGXqS,GAAU,EAItB,OAAOA,EAAU/G,EAAM7G,GAGxB,SAASqK,EAAajJ,EAAGoE,GAC5B,IAAIqI,EAAmBvD,EAAgBlJ,EAAGoE,GAC1C,OAAO,SAAUsI,GAAO,OAAOD,EAAiBC,EAAKzG,MAElD,SAASiD,EAAgBlJ,EAAGoE,GAC/B,OAAO,SAAUG,EAAIxJ,GACjB,OAAOqJ,EAAElE,OAAOqE,EAAI,IAAI,SAAU/K,EAAGW,GACjC,IAAImG,EAAKvF,EAAEZ,GAAIyO,EAAItI,EAAG,GAAIlG,EAAIkG,EAAG,GAEjC,OADA9G,EAAEoP,GAAKwC,EAAgBE,KAAK9R,EAAGoP,GAAK5I,EAAE7G,OAAOK,EAAEoP,GAAIxO,GAAKA,EACjDZ,MAOZ,SAASO,EAAMgD,GAClB,OAAO,SAAUvD,GACb,IAAK,IAAIoP,KAAKpP,EACV,IAAKuD,EAAUvD,EAAEoP,IACb,OAAO,EAGf,OAAO,GAMR,SAASb,EAAKhL,GACjB,OAAO,SAAUvD,GACb,IAAK,IAAIoP,KAAKpP,EACV,GAAIuD,EAAUvD,EAAEoP,IACZ,OAAO,EAGf,OAAO,GAGR,SAASnJ,EAAK9F,GACjB,OAAO,SAAUQ,EAAGyE,GAChB,QAAWvC,IAAPuC,EAAkB,CAClB,IAAIc,EAAUD,EAAK9F,GACnB,OAAO,SAAUiF,GAAM,OAAOc,EAAQvF,EAAGyE,IAE7C,IAAK,IAAIgK,KAAKhK,EACV,GAAIjF,EAAEC,OAAOgF,EAAGgK,GAAIzO,GAChB,OAAO,EAGf,OAAO,GAMf,IAAIwH,EAAO,SAAU/C,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI3F,EAAI8B,KAE9C8G,EAAgB,SAAUjD,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIkD,EAAa/G,KAEhEoI,EAAU,SAAUvE,EAAIxE,EAAGW,GAAK,OAAO6G,YAAKhD,EAAIsB,GAAO9F,EAAGW,KAE1DqI,EAAW,SAAUpD,GACrB,IAAIqD,EAAWC,GAAQtD,GACvB,OAAO,SAAUpB,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIyE,EAAStI,MAGnDwI,EAAe,SAAU3E,EAAIxE,EAAGW,GAAK,OAAO6G,YAAKhD,EAAI4E,GAAYpJ,EAAGW,KAEpEoJ,EAAY,SAAUC,GACtB,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAUG,EAAIxJ,GAAK,OAAO6G,YAAK2C,EAAIF,EAAUtJ,MAGpDqH,EAAU,SAAUxD,EAAI7B,GACxB,OAAO6E,YAAKhD,EAAIwC,GAAOrE,KAGvBsF,EAAa,SAAUzD,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI0D,GAAUvH,KAE1D2H,EAAa,SAAU9D,EAAI7B,GAAa,OAAO6E,YAAKhD,EAAI+D,GAAU5F,KAElE6F,GAAgB,SAAUhE,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIiE,GAAa9H,KAEhE0I,GAAmB,SAAU7E,EAAIxE,EAAGW,GACpC,OAAO6G,YAAKhD,EAAI0H,EAAgBlM,EAAGW,KAGnC2I,GAAoB,SAAU1D,GAC9B,IAAIqG,EAAoBD,EAAiBpG,GACzC,OAAO,SAAUpB,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIyH,EAAkBtL,MAG5D4I,GAAwB,SAAU/E,EAAIxE,EAAGW,GACzC,OAAO6G,YAAKhD,EAAIgF,EAAqBxJ,EAAGW,KAGxC+H,GAAyB,SAAUlE,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAImE,EAAsBhI,KAElFwH,GAAsB,SAAU3D,EAAI4D,GACpC,OAAOZ,YAAKhD,EAAI6D,EAAmBD,KAGnCqB,GAAsB,SAAUjF,EAAI7D,GACpC,OAAO6G,YAAKhD,EAAIkF,EAAmB/I,KAGnCgJ,GAAmB,SAAUnF,EAAI4D,GACjC,OAAOZ,YAAKhD,EAAIoF,EAAgBxB,KAGhCgC,GAAqB,SAAUJ,GAC/B,IAAIK,EAAqBC,EAAkBN,GAC3C,OAAO,SAAUG,EAAIxJ,GAAK,OAAO6G,YAAK2C,EAAIE,EAAmB1J,MAG7D4J,GAAU,SAAUP,GACpB,IAAIQ,EAAUC,EAAOT,GACrB,OAAO,SAAUxF,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIgG,EAAQ7J,MAGlD+J,GAAQ,SAAUV,GAClB,IAAIW,EAAQC,EAAKZ,GACjB,OAAO,SAAUxF,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAImG,EAAMhK,MASzCqG,GAAS,SAAUrE,GAC1B,OAAOiH,GAAgB,SAAUsB,EAAGnL,GAAK,OAAO4C,EAAU5C,OAMnDmI,GAAY,SAAUvH,GAAK,OAAO+I,GAAmB,SAAUwB,EAAGnL,GAAK,OAAOY,EAAEZ,OAKhFwI,GAAY,SAAU5F,GAC7B,OAAO0F,GAAmB,SAAU6C,EAAGnL,GAAK,OAAO4C,EAAU5C,OAMtD0I,GAAe,SAAU9H,GAChC,OAAOgI,GAAsB,SAAUuC,EAAGnL,GAAK,OAAOY,EAAEZ,OAMjD+F,GAAS,SAAU9F,EAAGW,GAC7B,OAAOuL,EAAgBlM,GAAG,SAAUkL,EAAGlL,EAAGD,GAAK,OAAOY,EAAEX,EAAGD,OAMpDmJ,GAAU,SAAUtD,GAC3B,IAAIqG,EAAoBD,EAAiBpG,GACzC,OAAO,SAAUjF,GAAK,OAAOsL,GAAkB,SAAUf,EAAGnL,GAAK,OAAOY,EAAEZ,QAMnEqJ,GAAc,SAAUpJ,EAAGW,GAClC,OAAO6I,EAAqBxJ,GAAG,SAAUkL,EAAGnL,EAAGC,GAAK,OAAOW,EAAEZ,EAAGC,OAMzD4L,GAAU,SAAUpH,GAG3B,IAFA,IAAIpF,EAAI,GAEC4F,EAAK,EAAGuN,EADN5B,OAAOvC,KAAK5J,GACSQ,EAAKuN,EAAOnU,OAAQ4G,IAAM,CACtD,IAAI4L,EAAM2B,EAAOvN,GACbwN,EAAUhO,EAAGoM,GACbuB,iBAAOK,KACPpT,EAAEwR,GAAO4B,EAAQ7G,OAGzB,OAAOvM,GAMAoM,GAAW,SAAUhH,GAI5B,IAHA,IAAIH,EAAO,GACPF,EAAQ,GAEHa,EAAK,EAAGyN,EADN9B,OAAOvC,KAAK5J,GACSQ,EAAKyN,EAAOrU,OAAQ4G,IAAM,CACtD,IAAI4L,EAAM6B,EAAOzN,GACbD,EAAIP,EAAGoM,GACX,OAAQ7L,EAAEb,MACN,IAAK,OACDG,EAAKuM,GAAO7L,EAAEV,KACd,MACJ,IAAK,QACDF,EAAMyM,GAAO7L,EAAEZ,OAI3B,MAAO,CACHE,KAAMA,EACNF,MAAOA,IAUJwI,GAAM,iBAKNC,GAAU,CACjBD,IAAKA,GACL9N,IAAK0I,GAMEsF,GAAmB,CAC1BF,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,GAMP4F,GAAW,CAClBV,IAAKA,GACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,GAMNmE,GAAoB,CAC3BX,IAAKA,GACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACb+C,gBAAiB7C,GACjB2C,iBAAkB1C,GAClBE,qBAAsBD,IAef4D,GAAa,CACpBR,IAAKA,GACL9N,IAAK0I,EACLqE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,IAMP4E,GAAsB,CAC7BT,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,EACdmE,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,GACdkB,mBAAoBD,GACpBG,gBAAiBD,GACjBhB,sBAAuBD,GACvBL,mBAAoBF,IAmBbqF,GAAuB,CAC9Bb,IAAKA,GACL9N,IAAK0I,EACLG,aAAcD,EACd3B,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACb+C,gBAAiB7C,GACjB2C,iBAAkB1C,GAClBE,qBAAsBD,GACtBW,SAAUH,EACVoC,SAAUA,EACV7B,kBAAmBF,IAMZqD,GAAa,CACpBd,IAAKA,GACL9N,IAAK0I,EACLzB,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,EACVoC,SAAUA,EACVP,QAASA,GACTJ,SAAUA,GACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,GACdiC,OAAQF,GACRK,KAAMF,K,iCCluBV,uoCAKWhM,EAAUgU,IAIVrU,EAAQ,IAAIsU,IAMZlU,EAAUiU,IAKVpT,EAAQoT,IAIR/E,EAAO+E,IAQP7T,EAAM6T,IAIN/S,EAAQ+S,IAOR3K,EAAQ2K,IAORE,EAASF,IACb,SAAS1L,EAAOrE,GACnB,OAAO+P,IAAU/P,GAEd,SAAS4F,EAAU5F,GACtB,OAAO+P,IAAa/P,GAQjB,IAAI0C,EAAOqN,IAQP7L,EAAQ6L,IAQRzL,EAAeyL,IAIfjK,EAAeiK,IAefvL,EAAauL,IAKbG,EAAiBH,IAKjBI,EAA2BJ,IAI3B5M,EAAS4M,IAITxJ,EAAUwJ,IAOV9D,EAAY8D,IAOZK,EAASL,IAOTM,EAASN,IASb,SAASO,EAAO1T,GACnB,IAAIuH,EAAQzB,EAAK9F,GACb2T,EAAUF,EAAOzT,GACjB4T,EAAUJ,EAAOxT,GACrB,OAAO,SAAUQ,GAAK,OAAO,SAAUqT,GAAO,OAAQtM,EAAM/G,EAAGqT,GAAOF,EAAUC,GAASpT,EAApC,CAAuCqT,KASzF,IAAInV,EAAYyU,IAKZ9G,EAAU8G,IAIVlH,EAAWkH,IAKXxK,EAAYwK,K,gCC7KvB,uqCAsBO,SAAShU,EAAQ2U,EAAIC,GACxB,MAAO,CACH1U,KAAM,SAAU2U,GACZ,IAAI/C,EAAW,GAOf,OANA+C,EAAEC,SAAQ,SAAUzT,EAAGyO,GACnBgC,GAAY,IAAM6C,EAAGzU,KAAK4P,GAAK,KAAO8E,EAAG1U,KAAKmB,GAAK,SAEtC,KAAbyQ,IACAA,EAAWA,EAASiD,UAAU,EAAGjD,EAASpS,OAAS,IAEhD,YAAcoS,EAAW,OASrC,SAASrC,EAAKuF,GACjB,OAAOA,EAAEvF,KAON,SAAS1M,EAAQiS,GACpB,OAAkB,IAAXA,EAAEvF,KAEN,SAASwF,EAAOpU,GACnB,IAAIqU,EAAU5R,EAAOzC,GACrB,OAAO,SAAUiP,EAAG+E,GAChB,QAAUtR,IAANsR,EAAiB,CACjB,IAAIM,EAAYF,EAAOpU,GACvB,OAAO,SAAUgU,GAAK,OAAOM,EAAUrF,EAAG+E,IAE9C,OAAO1T,SAAS+T,EAAQpF,EAAG+E,KAG5B,SAASlO,EAAK9F,GACjB,OAAO,SAAUQ,EAAGwT,GAChB,QAAUtR,IAANsR,EAAiB,CACjB,IAAIjO,EAAUD,EAAK9F,GACnB,OAAO,SAAUgU,GAAK,OAAOjO,EAAQvF,EAAGwT,IAK5C,IAHA,IACIxO,EADA+O,EAASP,EAAEO,WAGN/O,EAAI+O,EAAOC,QAAQC,MAAM,CAC9B,IAAI3Q,EAAI0B,EAAE4G,MACV,GAAIpM,EAAEC,OAAOO,EAAGsD,GACZ,OAAO,EAGf,OAAO,GAQR,SAAS+K,EAAKvO,GACjB,OAAO,SAAU0T,GAAK,OAAOhV,MAAM0V,KAAKV,EAAEnF,QAAQ9J,KAAKzE,EAAEU,UAOtD,SAASuT,EAAOjU,GACnB,OAAO,SAAU0T,GAAK,OAAOhV,MAAM0V,KAAKV,EAAEO,UAAUxP,KAAKzE,EAAEU,UAKxD,SAAS8N,EAAQxO,GACpB,IAAIqU,EAAQ9F,EAAKvO,GACjB,OAAO,SAAUc,GAAK,OAAO,SAAU4S,GAInC,IAFA,IAAIlI,EAAM,GAEDrG,EAAK,EAAG+M,EADRmC,EAAMX,GACavO,EAAK+M,EAAK3T,OAAQ4G,IAAM,CAChD,IAAI4L,EAAMmB,EAAK/M,GACfqG,EAAIzK,KAAKD,EAAEiQ,EAAK2C,EAAEY,IAAIvD,KAE1B,OAAOvF,IASR,SAASwF,EAAgBhR,GAC5B,OAAOwO,EAAQxO,EAARwO,EAAW,SAAUG,EAAGzO,GAAK,MAAO,CAACyO,EAAGzO,MAE5C,SAASuO,EAAaiB,EAAKhB,GAC9B,IAAI6F,EAAWvD,EAAgBtB,GAC/B,OAAO,SAAUmE,GACb,IAAItS,EAAMgT,EAASV,GACfvT,EAAMiB,EAAIhD,OACd,OAAOmQ,EAAEjC,OAAO,GAAG,SAAUtM,GAAK,OAAQA,EAAIG,EAAMN,OAAO,CAACuB,EAAIpB,GAAIA,EAAI,IAAMH,WAS/E,SAAS4D,EAASlE,GACrB,IAAI8U,EAAiBC,EAAc/U,GACnC,OAAO,SAAUiP,EAAGzO,GAAK,OAAO,SAAUwT,GACtC,IAOQnU,EAPJmV,EAAQF,EAAe7F,EAAG+E,GAC9B,OAAI1T,SAAS0U,KACLnV,EAAI,IAAIoV,IAAIjB,IACdH,IAAI5E,EAAGzO,GACFX,GAEFmV,EAAM5I,MAAM,KAAO5L,IACpBX,EAAI,IAAIoV,IAAIjB,IACdH,IAAImB,EAAM5I,MAAM,GAAI5L,GACfX,GAEJmU,IASR,SAAS1P,EAAStE,GACrB,IAAI8U,EAAiBC,EAAc/U,GACnC,OAAO,SAAUiP,GAAK,OAAO,SAAU+E,GACnC,IAAIgB,EAAQF,EAAe7F,EAAG+E,GAC9B,GAAI1T,SAAS0U,GAAQ,CACjB,IAAInV,EAAI,IAAIoV,IAAIjB,GAEhB,OADAnU,EAAEqV,OAAOF,EAAM5I,MAAM,IACdvM,EAEX,OAAOmU,IAMR,SAAS5P,EAASpE,GACrB,IAAI8U,EAAiBC,EAAc/U,GACnC,OAAO,SAAUiP,EAAGzO,GAAK,OAAO,SAAUwT,GACtC,IAAIgB,EAAQF,EAAe7F,EAAG+E,GAC9B,GAAI1T,SAAS0U,GACT,OAAO1U,OAEX,IAAIT,EAAI,IAAIoV,IAAIjB,GAEhB,OADAnU,EAAEgU,IAAImB,EAAM5I,MAAM,GAAI5L,GACfF,OAAOT,KAMf,SAAS2E,EAASxE,GACrB,IAAI8U,EAAiBC,EAAc/U,GACnC,OAAO,SAAUiP,EAAG7N,GAAK,OAAO,SAAU4S,GACtC,IAAIgB,EAAQF,EAAe7F,EAAG+E,GAC9B,GAAI1T,SAAS0U,GACT,OAAO1U,OAEX,IAAIT,EAAI,IAAIoV,IAAIjB,GAEhB,OADAnU,EAAEgU,IAAImB,EAAM5I,MAAM,GAAIhL,EAAE4T,EAAM5I,MAAM,KAC7B9L,OAAOT,KAQf,SAASsP,EAAInP,GAChB,IAAIqU,EAAU5R,EAAOzC,GACjBmV,EAAY7Q,EAAStE,GACzB,OAAO,SAAUiP,GACb,IAAImG,EAAaD,EAAUlG,GAC3B,OAAO,SAAU+E,GACb,OAAO/L,YAAKoM,EAAQpF,EAAG+E,GAAI1T,OAAM,SAAUE,GAAK,MAAO,CAACA,EAAG4U,EAAWpB,UAI3E,SAASe,EAAc/U,GAC1B,OAAO,SAAUiP,EAAG+E,GAChB,QAAUtR,IAANsR,EAAiB,CACjB,IAAIqB,EAAmBN,EAAc/U,GACrC,OAAO,SAAUgU,GAAK,OAAOqB,EAAiBpG,EAAG+E,IAKrD,IAHA,IACIxO,EADA8P,EAAUtB,EAAEsB,YAGP9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAOmJ,EAAK5O,EAAG,GAAInG,EAAImG,EAAG,GACrC,GAAI3G,EAAEC,OAAOsV,EAAItG,GACb,OAAO3O,OAAO,CAACiV,EAAI/U,IAG3B,OAAOF,QAGR,SAASmC,EAAOzC,GACnB,IAAI8U,EAAiBC,EAAc/U,GACnC,OAAO,SAAUiP,EAAG+E,GAChB,QAAUtR,IAANsR,EAAiB,CACjB,IAAIwB,EAAY/S,EAAOzC,GACvB,OAAO,SAAUgU,GAAK,OAAOwB,EAAUvG,EAAG+E,IAE9C,OAAO/L,YAAK6M,EAAe7F,EAAG+E,GAAI1T,OAAM,SAAUqG,GACtCA,EAAG,GACX,OADmBA,EAAG,QAK3B,SAAS8O,EAAS3B,EAAIC,GACzB,IAAI2B,EAAiBX,EAAcjB,GACnC,OAAO,SAAU9B,EAAI1I,GACjB,QAAa5G,IAAT4G,EAAoB,CACpB,IAAIqM,EAAiBF,EAAS3B,EAAIC,GAClC,OAAO,SAAUzK,GAAQ,OAAOqM,EAAerM,EAAM0I,IAKzD,IAHA,IACIxM,EADA8P,EAAUtD,EAAGsD,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GAAInG,EAAImG,EAAG,GAChCiP,EAASF,EAAezG,EAAG3F,GAC/B,GAAIhJ,SAASsV,KAAY9B,EAAG7T,OAAOgP,EAAG2G,EAAOxJ,MAAM,MAAQ2H,EAAG9T,OAAOO,EAAGoV,EAAOxJ,MAAM,IACjF,OAAO,EAGf,OAAO,GAMR,IAAItN,EAAQ,IAAImW,IAKhB,SAASlV,EAAM+T,EAAIC,GACtB,IAAI8B,EAAYJ,EAAS3B,EAAIC,GAC7B,OAAO5B,sBAAW,SAAU1S,EAAGC,GAAK,OAAOmW,EAAUpW,EAAGC,IAAMmW,EAAUnW,EAAGD,MAQxE,SAASK,EAAUgU,EAAIC,GAC1B,IAAI2B,EAAiBX,EAAcjB,GACnC,MAAO,CACHtU,OAAQ,SAAUsW,EAAIC,GAClB,GAAID,IAAOhX,EACP,OAAOiX,EAEX,GAAIA,IAAOjX,EACP,OAAOgX,EAMX,IAJA,IAEItQ,EAFA3F,EAAI,IAAIoV,IAAIa,GACZR,EAAUS,EAAGT,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GAAInG,EAAImG,EAAG,GAChCqP,EAASN,EAAezG,EAAG6G,GAC3BxV,SAAS0V,GACTnW,EAAEgU,IAAImC,EAAO5J,MAAM,GAAI2H,EAAGvU,OAAOwW,EAAO5J,MAAM,GAAI5L,IAGlDX,EAAEgU,IAAI5E,EAAGzO,GAGjB,OAAOX,GAEXf,MAAOA,GASR,SAASuQ,EAAUJ,EAAGzO,GACzB,OAAO,IAAIyU,IAAI,CAAC,CAAChG,EAAGzO,KAEjB,SAAS8O,EAAatP,EAAGqG,EAAGoE,GAC/B,OAAO,SAAUsI,GACb,IAAI+B,EAAiBC,EAAc/U,GACnC,OAAOyK,EAAElE,OAAOwM,EAAK,IAAIkC,KAAO,SAAUxU,EAAGkG,GACzC,IAAIsI,EAAItI,EAAG,GAAInG,EAAImG,EAAG,GAClBsP,EAAOnB,EAAe7F,EAAGxO,GAO7B,OANIH,SAAS2V,GACTxV,EAAEoT,IAAIoC,EAAK7J,MAAM,GAAI/F,EAAE7G,OAAOyW,EAAK7J,MAAM,GAAI5L,IAG7CC,EAAEoT,IAAI5E,EAAGzO,GAENC,MAInB,IAAIyH,EAAgB,SAAUjD,EAAI7D,GAK9B,IAJA,IAEIoE,EAFAwO,EAAI,IAAIiB,IACRK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAOiF,EAAM1K,EAAG,GAAInG,EAAImG,EAAG,GACtCqN,EAAEH,IAAIxC,EAAKjQ,EAAEiQ,EAAK7Q,IAEtB,OAAOwT,GAEP7K,EAAyB,SAAUlE,EAAI7D,GAMvC,IALA,IAGIoE,EAHAV,EAAO,IAAImQ,IACXrQ,EAAQ,IAAIqQ,IACZK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GACrBuP,EAAK9U,EAAE6N,EADsBtI,EAAG,IAEhCwP,iBAAOD,GACPpR,EAAK+O,IAAI5E,EAAGiH,EAAGpR,MAGfF,EAAMiP,IAAI5E,EAAGiH,EAAGtR,OAGxB,MAAO,CACHE,KAAMA,EACNF,MAAOA,IAGXgE,EAAsB,SAAU3D,EAAImR,GAMpC,IALA,IAGI5Q,EAHAV,EAAO,IAAImQ,IACXrQ,EAAQ,IAAIqQ,IACZK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GAAInG,EAAImG,EAAG,GAChCyP,EAAEnH,EAAGzO,GACLoE,EAAMiP,IAAI5E,EAAGzO,GAGbsE,EAAK+O,IAAI5E,EAAGzO,GAGpB,MAAO,CACHsE,KAAMA,EACNF,MAAOA,IAGXsF,EAAsB,SAAUjF,EAAI7D,GAKpC,IAJA,IAEIoE,EAFAwO,EAAI,IAAIiB,IACRK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GACrB0P,EAAIjV,EAAE6N,EADuBtI,EAAG,IAEhCrG,SAAS+V,IACTrC,EAAEH,IAAI5E,EAAGoH,EAAEjK,OAGnB,OAAO4H,GAEP5J,EAAmB,SAAUnF,EAAImR,GAKjC,IAJA,IAEI5Q,EAFAwO,EAAI,IAAIiB,IACRK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GAAInG,EAAImG,EAAG,GAChCyP,EAAEnH,EAAGzO,IACLwT,EAAEH,IAAI5E,EAAGzO,GAGjB,OAAOwT,GAKPhM,EAAO,SAAU/C,EAAI7D,GAAK,OAAO8G,EAAcjD,GAAI,SAAU0G,EAAGnL,GAAK,OAAOY,EAAEZ,OAC9EiI,EAAU,SAAUxD,EAAImR,GACxB,OAAOhM,EAAiBnF,GAAI,SAAU0G,EAAGnL,GAAK,OAAO4V,EAAE5V,OAEvDkI,EAAa,SAAUzD,EAAI7D,GAAK,OAAO8I,EAAoBjF,GAAI,SAAU0G,EAAGnL,GAAK,OAAOY,EAAEZ,OAC1FuI,EAAa,SAAU9D,EAAI7B,GAAa,OAAOwF,EAAoB3D,GAAI,SAAU0G,EAAGnL,GAAK,OAAO4C,EAAU5C,OAC1GyI,EAAgB,SAAUhE,EAAI7D,GAAK,OAAO+H,EAAuBlE,GAAI,SAAU0G,EAAGnL,GAAK,OAAOY,EAAEZ,OAQzF6L,EAAU,SAAUpH,GAK3B,IAJA,IAEIO,EAFAwO,EAAI,IAAIiB,IACRK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GAAImL,EAAKnL,EAAG,GACjCrG,SAASwR,IACTkC,EAAEH,IAAI5E,EAAG6C,EAAG1F,OAGpB,OAAO4H,GAMAvM,EAAS,SAAUrE,GAAa,OAAO,SAAU6B,GAAM,OAAOwD,EAAQxD,EAAI7B,KAK1EuF,EAAY,SAAUvH,GAAK,OAAO,SAAU6D,GAAM,OAAOyD,EAAWzD,EAAI7D,KAQxE9B,EAAM,SAAU8B,GAAK,OAAO,SAAU6D,GAAM,OAAO+C,EAAK/C,EAAI7D,KAK5D+G,EAAe,SAAU/G,GAAK,OAAO,SAAU6D,GAAM,OAAOiD,EAAcjD,EAAI7D,KAK9E4H,EAAY,SAAU5F,GAAa,OAAO,SAAU6B,GAAM,OAAO8D,EAAW9D,EAAI7B,KAKhF8F,EAAe,SAAU9H,GAAK,OAAO,SAAU6D,GAAM,OAAOgE,EAAchE,EAAI7D,KAK9E6K,EAAW,SAAUhH,GAM5B,IALA,IAGIO,EAHAV,EAAO,IAAImQ,IACXrQ,EAAQ,IAAIqQ,IACZK,EAAUrQ,EAAGqQ,YAGR9P,EAAI8P,EAAQd,QAAQC,MAAM,CAC/B,IAAI9N,EAAKnB,EAAE4G,MAAO6C,EAAItI,EAAG,GAAIuP,EAAKvP,EAAG,GACjCwP,iBAAOD,GACPpR,EAAK+O,IAAI5E,EAAGiH,EAAGpR,MAGfF,EAAMiP,IAAI5E,EAAGiH,EAAGtR,OAGxB,MAAO,CACHE,KAAMA,EACNF,MAAOA,IAUJwI,EAAM,cAKV,SAASkJ,IACZ,MAAO,CACHlJ,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAK0I,EACLG,aAAcD,EACdmE,QAASA,EACTJ,SAAUA,EACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,EACdG,sBAAuBD,EACvBL,mBAAoBF,EACpBuB,mBAAoBD,EACpBG,gBAAiBD,GAOlB,SAASoM,EAAclW,GAC1B,IAAIqU,EAAQ9F,EAAKvO,GACbqM,EAAkB,SAAU1H,EAAIxE,EAAGW,GAInC,IAHA,IAAI0K,EAAMrL,EACN4R,EAAKsC,EAAM1P,GACXrE,EAAMyR,EAAGxT,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIgQ,EAAIoD,EAAGpT,GACX6M,EAAM1K,EAAE6N,EAAGnD,EAAK7G,EAAG2P,IAAI3F,IAE3B,OAAOnD,GAEPW,EAAmB,SAAUpG,GAAK,OAAO,SAAUpB,EAAI7D,GAIvD,IAHA,IAAI0K,EAAMzF,EAAEvH,MACRuT,EAAKsC,EAAM1P,GACXrE,EAAMyR,EAAGxT,OACJI,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIgQ,EAAIoD,EAAGpT,GACX6M,EAAMzF,EAAE7G,OAAOsM,EAAK1K,EAAE6N,EAAGhK,EAAG2P,IAAI3F,KAEpC,OAAOnD,IAEP7B,EAAuB,SAAUhF,EAAIxE,EAAGW,GAIxC,IAHA,IAAI0K,EAAMrL,EACN4R,EAAKsC,EAAM1P,GAENhG,EADCoT,EAAGxT,OACM,EAAGI,GAAK,EAAGA,IAAK,CAC/B,IAAIgQ,EAAIoD,EAAGpT,GACX6M,EAAM1K,EAAE6N,EAAGhK,EAAG2P,IAAI3F,GAAInD,GAE1B,OAAOA,GAEPf,EAAoB,SAAUN,GAC9B,OAAO,SAAUG,EAAIxJ,GASjB,IARA,IAAIqV,EAAKhM,EAAE3C,GAAGhJ,GACVuT,EAAKsC,EAAM/J,GACXhK,EAAMyR,EAAGxT,OACT0T,EAAU,SAAUtT,GACpB,IAAIoS,EAAMgB,EAAGpT,GACTuB,EAAIoK,EAAGgK,IAAIvD,GACfoF,EAAKhM,EAAEnC,GAAGmC,EAAEnL,IAAImX,GAAI,SAAUzC,GAAK,OAAO,SAAUvT,GAAK,OAAO,IAAIwU,IAAIjB,GAAGH,IAAIxC,EAAK5Q,OAAWW,EAAEiQ,EAAK7Q,KAEjGvB,EAAI,EAAGA,EAAI2B,EAAK3B,IACrBsT,EAAQtT,GAEZ,OAAOwX,IAGX9L,EAAW,SAAUF,GACrB,IAAIK,EAAqBC,EAAkBN,GAC3C,OAAO,SAAUG,EAAIxJ,GAAK,OAAO0J,EAAmBF,GAAI,SAAUe,EAAGnL,GAAK,OAAOY,EAAEZ,QAMvF,MAAO,CACH4M,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAK0I,EACLqE,QAASA,EACTJ,SAAUA,EACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,EACd1C,OAAQ,SAAUtB,EAAIxE,EAAGW,GAAK,OAAOuL,EAAgB1H,EAAIxE,GAAG,SAAUkL,EAAGlL,EAAGD,GAAK,OAAOY,EAAEX,EAAGD,OAC7FmJ,QAAS,SAAUtD,GACf,IAAIqG,EAAoBD,EAAiBpG,GACzC,OAAO,SAAUpB,EAAI7D,GAAK,OAAOsL,EAAkBzH,GAAI,SAAU0G,EAAGnL,GAAK,OAAOY,EAAEZ,QAEtFqJ,YAAa,SAAU5E,EAAIxE,EAAGW,GAAK,OAAO6I,EAAqBhF,EAAIxE,GAAG,SAAUkL,EAAGnL,EAAGC,GAAK,OAAOW,EAAEZ,EAAGC,OACvGkK,SAAUA,EACViC,SArBW,SAAUnC,GACrB,IAAIK,EAAqBC,EAAkBN,GAC3C,OAAO,SAAUG,GAAM,OAAOE,EAAmBF,GAAI,SAAUe,EAAGnL,GAAK,OAAOA,OAoB9E2H,aAAcD,EACdyE,gBAAiBA,EACjBF,iBAAkBA,EAClBxC,qBAAsBA,EACtBc,kBAAmBA,EACnBM,KAAM,SAAUZ,GACZ,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAU8B,EAAInL,GAAK,OAAOqJ,EAAEnL,IAAIoL,EAAU6B,EAAInL,GAAI6K,KAE7Df,OAAQ,SAAUT,GACd,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAU8B,EAAInL,GAAK,OAAOqJ,EAAEnL,IAAIoL,EAAU6B,EAAInL,GAAIiL,MAQ9D,IAAIgB,EAAU,CACjBD,IAAKA,EACL9N,IAAK0I,GAeE4F,EAAa,CACpBR,IAAKA,EACL9N,IAAK0I,EACLqE,QAASA,EACTJ,SAAUA,EACVxE,OAAQgB,EACRE,UAAWD,EACXM,UAAWD,EACXG,aAAcD,I,gCChpBlB,u5CAAIyN,EAAwC,SAAUC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAIE,WAAU,SAAUC,EAASC,GAC/C,SAASC,EAAU9K,GAAS,IAAM+K,EAAKL,EAAUtC,KAAKpI,IAAW,MAAO5G,GAAKyR,EAAOzR,IACpF,SAAS4R,EAAShL,GAAS,IAAM+K,EAAKL,EAAS,MAAU1K,IAAW,MAAO5G,GAAKyR,EAAOzR,IACvF,SAAS2R,EAAK1Q,GAJlB,IAAe2F,EAIa3F,EAAOgO,KAAOuC,EAAQvQ,EAAO2F,QAJ1CA,EAIyD3F,EAAO2F,MAJhDA,aAAiByK,EAAIzK,EAAQ,IAAIyK,GAAE,SAAUG,GAAWA,EAAQ5K,OAITiL,KAAKH,EAAWE,GAClGD,GAAML,EAAYA,EAAU1P,MAAMuP,EAASC,GAAc,KAAKpC,YAGlE8C,EAA4C,SAAUX,EAASY,GAC/D,IAAsGnW,EAAG1B,EAAG8X,EAAGvQ,EAA3G0E,EAAI,CAAE8L,MAAO,EAAGC,KAAM,WAAa,GAAW,EAAPF,EAAE,GAAQ,MAAMA,EAAE,GAAI,OAAOA,EAAE,IAAOG,KAAM,GAAIC,IAAK,IAChG,OAAO3Q,EAAI,CAAEuN,KAAMqD,EAAK,GAAI,MAASA,EAAK,GAAI,OAAUA,EAAK,IAAwB,mBAAXC,SAA0B7Q,EAAE6Q,OAAOC,UAAY,WAAa,OAAOnG,OAAU3K,EACvJ,SAAS4Q,EAAK1W,GAAK,OAAO,SAAU2C,GAAK,OACzC,SAAckU,GACV,GAAI5W,EAAG,MAAM,IAAI6W,UAAU,mCAC3B,KAAOtM,GAAG,IACN,GAAIvK,EAAI,EAAG1B,IAAM8X,EAAY,EAARQ,EAAG,GAAStY,EAAC,OAAasY,EAAG,GAAKtY,EAAC,SAAe8X,EAAI9X,EAAC,SAAe8X,EAAE7F,KAAKjS,GAAI,GAAKA,EAAE8U,SAAWgD,EAAIA,EAAE7F,KAAKjS,EAAGsY,EAAG,KAAKvD,KAAM,OAAO+C,EAE3J,OADI9X,EAAI,EAAG8X,IAAGQ,EAAK,CAAS,EAARA,EAAG,GAAQR,EAAEpL,QACzB4L,EAAG,IACP,KAAK,EAAG,KAAK,EAAGR,EAAIQ,EAAI,MACxB,KAAK,EAAc,OAAXrM,EAAE8L,QAAgB,CAAErL,MAAO4L,EAAG,GAAIvD,MAAM,GAChD,KAAK,EAAG9I,EAAE8L,QAAS/X,EAAIsY,EAAG,GAAIA,EAAK,CAAC,GAAI,SACxC,KAAK,EAAGA,EAAKrM,EAAEiM,IAAIzI,MAAOxD,EAAEgM,KAAKxI,MAAO,SACxC,QACI,KAAMqI,EAAI7L,EAAEgM,MAAMH,EAAIA,EAAE3Y,OAAS,GAAK2Y,EAAEA,EAAE3Y,OAAS,KAAkB,IAAVmZ,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAErM,EAAI,EAAG,SACjG,GAAc,IAAVqM,EAAG,MAAcR,GAAMQ,EAAG,GAAKR,EAAE,IAAMQ,EAAG,GAAKR,EAAE,IAAM,CAAE7L,EAAE8L,MAAQO,EAAG,GAAI,MAC9E,GAAc,IAAVA,EAAG,IAAYrM,EAAE8L,MAAQD,EAAE,GAAI,CAAE7L,EAAE8L,MAAQD,EAAE,GAAIA,EAAIQ,EAAI,MAC7D,GAAIR,GAAK7L,EAAE8L,MAAQD,EAAE,GAAI,CAAE7L,EAAE8L,MAAQD,EAAE,GAAI7L,EAAEiM,IAAIvW,KAAK2W,GAAK,MACvDR,EAAE,IAAI7L,EAAEiM,IAAIzI,MAChBxD,EAAEgM,KAAKxI,MAAO,SAEtB6I,EAAKT,EAAK5F,KAAKgF,EAAShL,GAC1B,MAAOnG,GAAKwS,EAAK,CAAC,EAAGxS,GAAI9F,EAAI,EAjBrB,QAiBoC0B,EAAIoW,EAAI,EACtD,GAAY,EAARQ,EAAG,GAAQ,MAAMA,EAAG,GAAI,MAAO,CAAE5L,MAAO4L,EAAG,GAAKA,EAAG,QAAK,EAAQvD,MAAM,GArB9B0C,CAAK,CAAChW,EAAG2C,OAgClDoU,EAAS,SAAU3P,GAAM,OAAO,WAAc,OAAOwO,QAAQC,QAAQzO,OA8BzE,SAAS4P,EAAMC,GAClB,OAAO,SAAU7P,GAAM,OAAO,WAC1B,OAAO,IAAIwO,SAAQ,SAAUC,GACzBqB,YAAW,WAEP9P,IAAK8O,KAAKL,KACXoB,QAQR,SAASE,EAAQlX,GACpB,OAAO,WAEH,IADA,IAAIZ,EAAI,GACCiF,EAAK,EAAGA,EAAK8S,UAAU1Z,OAAQ4G,IACpCjF,EAAEiF,GAAM8S,UAAU9S,GAEtB,OAAOyS,EAAO9W,EAAEgG,WAAM,EAAQ5G,KAO/B,SAASgY,EAASpX,GACrB,OAAOoH,EAAM8P,EAAQlX,IAKzB,IAAI4G,EAAO,SAAU/C,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI3F,EAAI8B,KAC9CqX,EAAS,SAAUpQ,EAAKpD,GAAM,OAAOgD,YAAKI,EAAKC,EAAGrD,KAClDyT,EAAS,SAAUrQ,EAAKpD,GACxB,OAAOgD,YAAKI,EAAKG,GAAM,SAAUpH,GAAK,OAAO6G,YAAKhD,EAAI3F,EAAI8B,SAE1DiG,EAAS,SAAUkB,EAAInH,GAAK,OAAO6G,YAAKM,EAAIC,EAAMpH,KAW3C9B,EAAM,SAAU8B,GAAK,OAAO,SAAU6D,GAAM,OAAO,WAAc,OAAOA,IAAKoS,KAAKjW,MAOlFkH,EAAK,SAAUrD,GAAM,OAAO,SAAUoD,GAAO,OAAO,WAC3D,OAAO0O,QAAQ4B,IAAI,CAACtQ,IAAOpD,MAAOoS,MAAK,SAAU1Q,GAE7C,OAAOvF,EADCuF,EAAG,IAAQA,EAAG,UAYnB4E,EAAU,SAAUrG,GAC3B,OAAOsG,YAAKlM,GAAI,SAAUkB,GAAK,OAAO,WAAc,OAAOA,MAAU8H,EAAGpD,KAUjEuG,EAAW,SAAUvG,GAC5B,OAAOsG,YAAKlM,GAAI,WAAc,OAAO,SAAUmB,GAAK,OAAOA,MAAU6H,EAAGpD,KAQjE4C,EAAK,SAAUtH,GAAK,OAAO,WAAc,OAAOuW,QAAQC,QAAQxW,KAOhEgI,EAAQ,SAAUpH,GAAK,OAAO,SAAUmH,GAAM,OAAO,WAC5D,OAAOA,IAAK8O,MAAK,SAAU7W,GAAK,OAAOY,EAAEZ,EAAFY,SAWhC4K,EAAa,SAAU5K,GAC9B,OAAOoH,GAAM,SAAUhI,GACnB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,GAAI,WAAc,OAAOkB,UASxCkB,EAEX8G,EAAM8D,KAKKsM,EAAWtM,IAQXc,EAAM,OAoBV,SAASgD,EAAahR,GACzB,MAAO,CACHI,OAAQ,SAAUC,EAAGC,GAAK,OAAO,WAAc,OAAOD,IAAI4X,MAAK,SAAUwB,GAAM,OAAOnZ,IAAI2X,MAAK,SAAUyB,GAAM,OAAO1Z,EAAEI,OAAOqZ,EAAIC,YASpI,SAAShZ,EAAUuG,GACtB,MAAO,CACH7G,OAAQ4Q,EAAa/J,GAAG7G,OACxBV,MAAOgJ,EAAGzB,EAAEvH,QAuBb,SAASia,IACZ,MAAO,CACHvZ,OAAQ,SAAUC,EAAGC,GAAK,OAAO,WAAc,OAAOqX,QAAQiC,KAAK,CAACvZ,IAAKC,QACzEZ,MAAOma,GAOR,IAAI5L,EAAU,CACjBD,IAAKA,EACL9N,IAAK0I,GAMEkR,EAAiB,CACxB9L,IAAKA,EACL9N,IAAK0I,EACLM,GAAImQ,EACJ3Q,GAAIA,GAMGqR,EAAiB,CACxB/L,IAAKA,EACL9N,IAAK0I,EACLM,GAAIoQ,EACJ5Q,GAAIA,GAOG0F,EAAQ,CACfJ,IAAKA,EACL9N,IAAK0I,EACLF,GAAIA,EACJQ,GAAImQ,EACJjQ,MAAOnB,GAOA+R,EAAO,CACdhM,IAAKA,EACL9N,IAAK0I,EACLF,GAAIA,EACJQ,GAAImQ,EACJjQ,MAAOnB,EACP6Q,OAAQA,EACRU,SAAUA,GASHS,EAAU,CACjBjM,IAAKA,EACL9N,IAAK0I,EACLF,GAAIA,EACJQ,GAAIoQ,EACJlQ,MAAOnB,EACP6Q,OAAQA,EACRU,SAAUA,GAUHK,EAAQ,WAAc,OAAO,IAAIlC,SAAQ,SAAUpL,QAOnD2N,EAEXxR,EAAG,IAIQuG,EAAS,SAAUC,GAAQ,OAAOhP,EAAIiP,YAAQD,KAI9CE,EAAO,SAAUF,EAAMlN,GAC9B,OAAOoH,GAAM,SAAUhI,GACnB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,GAAI,SAAUmB,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,WASxDiO,EAAM,SAAUJ,EAAMpJ,GAC7B,OAAOsG,YAAKlM,GAAI,SAAUkB,GAAK,OAAO,SAAUC,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,OAAW6H,EAAGpD,KAQlFqU,EAAyB,SAAUnY,GAAK,OAAO,SAAUS,GAAO,OAAO,WAAc,OAAOkV,QAAQ4B,IAAI9W,EAAIvC,KAAI,SAAUG,EAAGR,GAAK,OAAOmC,EAAEnC,EAAGQ,EAAL2B,UAqBzIoY,EAAgB,SAAUpY,GACjC,OAAOmY,GAAuB,SAAU5N,EAAGnL,GAAK,OAAOY,EAAEZ,OAuBlDiZ,EAAgB,SAAU5X,GAAO,OAAO,WAC/C,OAAOkV,QAAQ4B,IAAI9W,EAAIvC,KAAI,SAAUG,GAAK,OAAOA,UAK1Cia,EAA4B,SAAUtY,GAAK,OAAO,SAAUS,GAAO,OAAO,WAAc,OAAO6U,OAAU,OAAQ,OAAQ,GAAQ,WACxI,IAAIjQ,EAAQxH,EAAGY,EACf,OAAOyX,EAAY1F,MAAM,SAAUjL,GAC/B,OAAQA,EAAG8Q,OACP,KAAK,EACDhR,EAAS,GACTxH,EAAI,EACJ0H,EAAG8Q,MAAQ,EACf,KAAK,EACD,OAAMxY,EAAI4C,EAAIhD,OACP,CAAC,EAAauC,EAAEnC,EAAG4C,EAAI5C,GAATmC,IADS,CAAC,EAAa,GAEhD,KAAK,EACDvB,EAAI8G,EAAG+Q,OACPjR,EAAOpF,KAAKxB,GACZ8G,EAAG8Q,MAAQ,EACf,KAAK,EAED,OADAxY,IACO,CAAC,EAAa,GACzB,KAAK,EAAG,MAAO,CAAC,EAAcwH,aAc/BkT,EAAmB,SAAUvY,GAAK,OAAOsY,GAA0B,SAAU/N,EAAGnL,GAAK,OAAOY,EAAEZ,OAU9FoZ,EAEXD,EAAiBrN,M,gCClejB,8jGAAIoK,EAAwC,SAAUC,EAASC,EAAYC,EAAGC,GAE1E,OAAO,IAAKD,IAAMA,EAAIE,WAAU,SAAUC,EAASC,GAC/C,SAASC,EAAU9K,GAAS,IAAM+K,EAAKL,EAAUtC,KAAKpI,IAAW,MAAO5G,GAAKyR,EAAOzR,IACpF,SAAS4R,EAAShL,GAAS,IAAM+K,EAAKL,EAAS,MAAU1K,IAAW,MAAO5G,GAAKyR,EAAOzR,IACvF,SAAS2R,EAAK1Q,GAJlB,IAAe2F,EAIa3F,EAAOgO,KAAOuC,EAAQvQ,EAAO2F,QAJ1CA,EAIyD3F,EAAO2F,MAJhDA,aAAiByK,EAAIzK,EAAQ,IAAIyK,GAAE,SAAUG,GAAWA,EAAQ5K,OAITiL,KAAKH,EAAWE,GAClGD,GAAML,EAAYA,EAAU1P,MAAMuP,EAASC,GAAc,KAAKpC,YAGlE8C,EAA4C,SAAUX,EAASY,GAC/D,IAAsGnW,EAAG1B,EAAG8X,EAAGvQ,EAA3G0E,EAAI,CAAE8L,MAAO,EAAGC,KAAM,WAAa,GAAW,EAAPF,EAAE,GAAQ,MAAMA,EAAE,GAAI,OAAOA,EAAE,IAAOG,KAAM,GAAIC,IAAK,IAChG,OAAO3Q,EAAI,CAAEuN,KAAMqD,EAAK,GAAI,MAASA,EAAK,GAAI,OAAUA,EAAK,IAAwB,mBAAXC,SAA0B7Q,EAAE6Q,OAAOC,UAAY,WAAa,OAAOnG,OAAU3K,EACvJ,SAAS4Q,EAAK1W,GAAK,OAAO,SAAU2C,GAAK,OACzC,SAAckU,GACV,GAAI5W,EAAG,MAAM,IAAI6W,UAAU,mCAC3B,KAAOtM,GAAG,IACN,GAAIvK,EAAI,EAAG1B,IAAM8X,EAAY,EAARQ,EAAG,GAAStY,EAAC,OAAasY,EAAG,GAAKtY,EAAC,SAAe8X,EAAI9X,EAAC,SAAe8X,EAAE7F,KAAKjS,GAAI,GAAKA,EAAE8U,SAAWgD,EAAIA,EAAE7F,KAAKjS,EAAGsY,EAAG,KAAKvD,KAAM,OAAO+C,EAE3J,OADI9X,EAAI,EAAG8X,IAAGQ,EAAK,CAAS,EAARA,EAAG,GAAQR,EAAEpL,QACzB4L,EAAG,IACP,KAAK,EAAG,KAAK,EAAGR,EAAIQ,EAAI,MACxB,KAAK,EAAc,OAAXrM,EAAE8L,QAAgB,CAAErL,MAAO4L,EAAG,GAAIvD,MAAM,GAChD,KAAK,EAAG9I,EAAE8L,QAAS/X,EAAIsY,EAAG,GAAIA,EAAK,CAAC,GAAI,SACxC,KAAK,EAAGA,EAAKrM,EAAEiM,IAAIzI,MAAOxD,EAAEgM,KAAKxI,MAAO,SACxC,QACI,KAAMqI,EAAI7L,EAAEgM,MAAMH,EAAIA,EAAE3Y,OAAS,GAAK2Y,EAAEA,EAAE3Y,OAAS,KAAkB,IAAVmZ,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAErM,EAAI,EAAG,SACjG,GAAc,IAAVqM,EAAG,MAAcR,GAAMQ,EAAG,GAAKR,EAAE,IAAMQ,EAAG,GAAKR,EAAE,IAAM,CAAE7L,EAAE8L,MAAQO,EAAG,GAAI,MAC9E,GAAc,IAAVA,EAAG,IAAYrM,EAAE8L,MAAQD,EAAE,GAAI,CAAE7L,EAAE8L,MAAQD,EAAE,GAAIA,EAAIQ,EAAI,MAC7D,GAAIR,GAAK7L,EAAE8L,MAAQD,EAAE,GAAI,CAAE7L,EAAE8L,MAAQD,EAAE,GAAI7L,EAAEiM,IAAIvW,KAAK2W,GAAK,MACvDR,EAAE,IAAI7L,EAAEiM,IAAIzI,MAChBxD,EAAEgM,KAAKxI,MAAO,SAEtB6I,EAAKT,EAAK5F,KAAKgF,EAAShL,GAC1B,MAAOnG,GAAKwS,EAAK,CAAC,EAAGxS,GAAI9F,EAAI,EAjBrB,QAiBoC0B,EAAIoW,EAAI,EACtD,GAAY,EAARQ,EAAG,GAAQ,MAAMA,EAAG,GAAI,MAAO,CAAE5L,MAAO4L,EAAG,GAAKA,EAAG,QAAK,EAAQvD,MAAM,GArB9B0C,CAAK,CAAChW,EAAG2C,OAmClDgB,EAEX0G,YAAKxL,OAAQ6Z,MAKFjV,EAEX4G,YAAKxL,QAAS6Z,MAKHC,EAEXD,MAAM7Z,SAKK+Z,EAEXF,MAAM7Z,QAKKga,EAEXxO,YAAKqO,SAAUC,GAKJG,EAEXzO,YAAKqO,SAAUE,GAKJG,EAAeL,SAOfM,EAEXna,OAAO8E,GAAM,SAAUtE,GAAK,OAAOoE,EAAMpE,MAO9B4Z,EAAa,SAAUC,GAAU,OAAO,SAAU9R,GACzD,MAAmB,SAAZA,EAAG5D,KAAkBG,EAAKuV,KAAYzV,EAAM2D,EAAG6D,SAQ/CkO,EAAgB,SAAUlX,EAAWmX,GAAW,OAAO,SAAU/Z,GAAK,OAAQ4C,EAAU5C,GAAKoE,EAAMpE,GAAKsE,EAAKyV,EAAQ/Z,MAoBzH,SAASga,EAASpZ,EAAGqZ,GACxB,OAAO,WAAc,OAAOrZ,IAAIiW,KAAKrX,SAAS,SAAU0a,GAAU,OAAO1a,OAAOya,EAAWC,QASxF,IAAI7J,EAEXrF,YAAKxL,OAAQ6Z,SAOFc,EAAa,SAAUC,GAAU,OAAO,SAAUrS,GACzD,OAAON,YAAKM,EAAIsR,QAAQ7Z,OAAO4a,EAAQf,UAMhCgB,EAAYF,EAyBZG,EAAS,SAAU1Z,GAAK,OAAOyY,QAAQ7Z,OAAOoB,EAAGwD,KAKjDmW,EAEXlB,MAAM7Z,QAMKgb,EAAgB,SAAU5X,EAAWmX,GAC5C,OAAOU,GAAO,SAAUza,GAAK,OAAQ4C,EAAU5C,GAAKoE,EAAMpE,GAAKsE,EAAKyV,EAAQ/Z,QAQrE0a,EAAeF,EAOnB,SAASG,EAAU/Z,EAAGqZ,GACzB,OAAO,WAEH,IADA,IAAIja,EAAI,GACCiF,EAAK,EAAGA,EAAK8S,UAAU1Z,OAAQ4G,IACpCjF,EAAEiF,GAAM8S,UAAU9S,GAEtB,OAAO+U,GAAS,WAAc,OAAOpZ,EAAEgG,WAAM,EAAQ5G,KAAOia,IAO7D,SAASW,EAAYha,GACxB,OAAO,WAEH,IADA,IAAIZ,EAAI,GACCiF,EAAK,EAAGA,EAAK8S,UAAU1Z,OAAQ4G,IACpCjF,EAAEiF,GAAM8S,UAAU9S,GAEtB,OAAO0U,EAAW/Y,EAAEgG,WAAM,EAAQ5G,KAOnC,SAAS6a,EAAcja,GAC1B,OAAO,WAEH,IADA,IAAIZ,EAAI,GACCiF,EAAK,EAAGA,EAAK8S,UAAU1Z,OAAQ4G,IACpCjF,EAAEiF,GAAM8S,UAAU9S,GAEtB,OAAOyU,EAAa9Y,EAAEgG,WAAM,EAAQ5G,KASrC,IAAI8a,EAAgB,SAAUla,GAAK,OAAO6Z,EAAOG,EAAYha,KAKzDma,EAAeD,EAOfE,EAAkB,SAAUpa,GAAK,OAAO6Z,EAAOI,EAAcja,KAK7Dqa,EAAiBD,EAIxBxT,EAAO,SAAU/C,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI3F,EAAI8B,KAE9Csa,EAAS,SAAUzW,EAAI7D,EAAG6F,GAAK,OAAOgB,YAAKhD,EAAI0W,EAAMva,EAAG6F,KAExD2U,EAAW,SAAU3W,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI4W,EAAQza,KACtDqX,EAAS,SAAUpQ,EAAKpD,GAAM,OAAOgD,YAAKI,EAAKC,EAAGrD,KAClDyT,EAAS,SAAUrQ,EAAKpD,GACxB,OAAOgD,YAAKI,EAAKG,GAAM,SAAUpH,GAAK,OAAO6G,YAAKhD,EAAI3F,EAAI8B,SAG1DiG,EAAS,SAAUkB,EAAInH,GAAK,OAAO6G,YAAKM,EAAIC,EAAMpH,KAElDiI,EAAO,SAAUpE,EAAIqE,GAAQ,OAAOrB,YAAKhD,EAAIsE,GAAID,KAW1ChK,EAAM,SAAU8B,GAAK,OAAOyY,MAAM7Z,MAAMoB,KAOxCua,EAEXnQ,YAAKxL,QAAS6Z,OAOHgC,EAAU,SAAUza,GAC3B,OAAOyY,MAAM7Z,UAAUoB,KAQhB0a,EAAM,SAAU7W,GACvB,OAAOuG,YAAKqO,OAAM,SAAUkC,GAAO,OAAO,SAAUC,GAAM,OAAOhc,MAAMgc,EAANhc,CAAU+b,OAAalC,KAAK5U,KAQtFqD,EAAKwT,EASLvQ,EAAU,SAAUrG,GAC3B,OAAOsG,YAAKlM,GAAI,SAAUkB,GAAK,OAAO,WAAc,OAAOA,MAAU8H,EAAGpD,KAUjEuG,EAAW,SAAUvG,GAC5B,OAAOsG,YAAKlM,GAAI,WAAc,OAAO,SAAUmB,GAAK,OAAOA,MAAU6H,EAAGpD,KAQjE+V,EAAS,SAAU7Z,GAAK,OAAO,SAAUmH,GAChD,OAAON,YAAKM,EAAIsR,QAAQ7Z,OAAO8E,EAAM1D,OAQ9BoH,EAAQyS,EASRgB,EAAc,SAAU7a,GAC/B,OAAO6Z,GAAO,SAAUza,GACpB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,GAAI,WAAc,OAAOkB,UAYxCwL,EAAaiQ,EAObva,EAEX8G,EAAM8D,KAOKhB,EAAO,SAAUhC,GAAQ,OAAO,SAAUrE,GAAM,OAAOgD,YAAKhD,EAAI4U,QAAQ7Z,OAAOsJ,EAAM1E,OA2CrF2E,GAAM+B,EASNxD,GAAKlD,EAKLsT,GAAS8B,EAKTpB,GAAWkB,EAKXoC,GAAapX,EAQbsI,GAAM,aAQV,SAASgD,GAAahR,GACzB,OAAOya,eAAe7Z,eAAeZ,IASlC,SAAS+c,GAAkB/c,GAC9B,OAAOya,eAAe7Z,oBAAoBZ,IAMvC,SAASgd,GAAe/V,GAC3B,MAAO,CACH7G,OAAQ2c,GAAkB9V,GAAG7G,OAC7BV,MAAO8F,EAAMyB,EAAEvH,QAOhB,SAASud,GAA6BC,EAAGC,GAC5C,IAAIC,EAAKxc,2BAA2Buc,GAIpC,MAAO,CACHnP,IAAKA,GACLmJ,QAAI7T,EACJpD,IAAK0I,EACLM,GAAI,SAAUD,EAAKpD,GAAM,OAAOgD,YAAKI,GAPtBoU,EAO8BxX,EAPhB,SAAUyX,GACvC,OAAOJ,EAAEhU,GAAGgU,EAAEhd,IAAIod,GAAM,SAAUC,GAAK,OAAO,SAAUX,GAAM,OAAOQ,EAAGlU,GAAGqU,EAAGX,OAAYS,MADrF,IAAUA,GAQf3U,GAAIA,IAOL,SAAS8U,GAAqBL,GACjC,MAAO,CACHnP,IAAKA,GACLmJ,QAAI7T,EACJpD,IAAK0I,EACLuB,IAAK,SAAUyI,EAAI1I,GACf,OAAOrB,YAAK+J,EAAI6H,SAAQ,SAAUgD,GAC9B,OAAO7c,UAAU6c,GACXhD,KAAKgD,GACL5U,YAAKqB,IAAQuQ,OAAM,SAAUiD,GAAM,OAAQ9c,SAAS8c,GAAM9c,OAAOuc,EAAG/c,OAAOqd,EAAG/X,KAAMgY,EAAGhY,OAASgY,YAU/G,SAASC,GAAkBR,GAC9B,IAAIS,EAA4BX,GAA6BxC,iBAAkB0C,GAC3EU,EAAoBL,GAAqBL,GAC7C,MAAO,CACHnP,IAAKA,GACLmJ,QAAI7T,EACJpD,IAAK0I,EACLM,GAAI0U,EAA0B1U,GAC9BR,GAAIA,GACJU,MAAOnB,EACPsU,MAAOD,EACPG,QAASD,EACTrS,IAAK0T,EAAkB1T,IACvB2O,OAAQA,GACRU,SAAUA,GACVsD,WAAYA,IAOb,SAASgB,GAAc7W,GAC1B,IAAI8W,EAAInd,gBAAgBqG,GACpBoE,EAAI2S,YAAyBvD,QAASsD,GAC1C,MAAO,CACH/P,IAAKA,GACLmJ,QAAI7T,EACJpD,IAAK0I,EACLqE,QAAS5B,EAAE4B,QACXJ,SAAUxB,EAAEwB,SACZxE,OAAQgD,EAAEhD,OACVkB,UAAW8B,EAAE9B,UACbK,UAAWyB,EAAEzB,UACbE,aAAcuB,EAAEvB,cAOjB,IAAImE,GAAU,CACjBD,IAAKA,GACL9N,IAAK0I,GAMEkR,GAAiB,CACxB9L,IAAKA,GACL9N,IAAK0I,EACLM,GAAImQ,EACJ3Q,GAAIA,IAMGqR,GAAiB,CACxB/L,IAAKA,GACL9N,IAAK0I,EACLM,GAAIoQ,EACJ5Q,GAAIA,IAMGuV,GAAY,CACnBjQ,IAAKA,GACLuO,MAAOD,EACPG,QAASD,GAMFnO,GAAM,CACbL,IAAKA,GACL9N,IAAK0I,EACLuB,IAAKF,GAOEiU,GAAa,CACpBlQ,IAAKA,GACLuO,MAAOD,EACPG,QAASD,EACTtc,IAAK0I,EACLF,GAAIA,GACJQ,GAAImQ,EACJjQ,MAAOnB,EACPkC,IAAKF,EACL6O,OAAQA,GACRU,SAAUA,GACVsD,WAAYA,IASLqB,GAAgB,CACvBnQ,IAAKA,GACLuO,MAAOD,EACPG,QAASD,EACTtc,IAAK0I,EACLF,GAAIA,GACJQ,GAAIoQ,EACJlQ,MAAOnB,EACPkC,IAAKF,EACL6O,OAAQA,GACRU,SAAUA,GACVsD,WAAYA,IAET,SAASsB,GAAQpc,GACpB,OAAO,WACH,IAAIqc,EAAOze,MAAM0S,UAAUvP,MAAMwP,KAAK4G,WACtC,OAAO,WACH,OAAO,IAAIxB,SAAQ,SAAUC,GAEzB5V,EAAEgG,MAAM,KAAMqW,EAAKje,QADF,SAAUgG,EAAG3F,GAAK,OAAoBmX,EAAP,MAALxR,EAAoBxF,OAAOwF,GAAcxF,QAAQH,aAgBrG,IAAI6d,GAAU,SAAUC,EAASC,EAAKC,GACzC,OAAO5V,YAAK0V,EAASnV,GAAM,SAAUhI,GACjC,OAAOyH,YAAKA,YAAK2V,EAAIpd,GAAIqZ,MAAM7Z,UAAWwI,GAAM,SAAUhD,GACtD,OAAOyC,YAAK4V,EAAQrd,EAAGgF,GAAIgD,GAAM,WAAc,OAAQxI,SAASwF,GAAKV,EAAKU,EAAEV,MAAQgD,GAAGtC,EAAEZ,oBAU1F0U,GAEXxR,GAAG,IAIQuG,GAAS,SAAUC,GAC1B,OAAOhP,EAAIiP,YAAQD,KAKZwP,GAAQ,SAAUxP,EAAMlN,GAC/B,OAAO6Z,GAAO,SAAUza,GACpB,OAAOyH,YAAK7G,EAAEZ,GAAIlB,GAAI,SAAUmB,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,WAMxD+N,GAAOsP,GAOPC,GAAO,SAAUzP,EAAMpJ,GAC9B,OAAOsG,YAAKlM,GAAI,SAAUkB,GAAK,OAAO,SAAUC,GAAK,OAAOgO,YAAMjO,EAAG8N,EAAM7N,OAAWqb,EAAI5W,KAKnFwJ,GAAMqP,GAONxE,GAAyB,SAAUnY,GAAK,OAAO,SAAUS,GAChE,OAAOoG,YAAKpG,EAAKgY,yBAAyBzY,GAAIyY,MAAM7Z,oBAsC7CwZ,GAAgB,SAAUpY,GAAK,OAAOmY,IAAuB,SAAU5N,EAAGnL,GAAK,OAAOY,EAAEZ,OAqCxFiZ,GAEXD,GAAclN,KAIHoN,GAA4B,SAAUtY,GAAK,OAAO,SAAUS,GAAO,OAAO,WAAc,OAAO6U,OAAU,OAAQ,OAAQ,GAAQ,WACxI,IAAIjQ,EAAQxH,EAAGuG,EACf,OAAO8R,EAAY1F,MAAM,SAAUjL,GAC/B,OAAQA,EAAG8Q,OACP,KAAK,EACDhR,EAAS,GACTxH,EAAI,EACJ0H,EAAG8Q,MAAQ,EACf,KAAK,EACD,OAAMxY,EAAI4C,EAAIhD,OACP,CAAC,EAAauC,EAAEnC,EAAG4C,EAAI5C,GAATmC,IADS,CAAC,EAAa,GAEhD,KAAK,EAED,GADAoE,EAAImB,EAAG+Q,OACH1X,SAASwF,GACT,MAAO,CAAC,EAAcA,GAE1BiB,EAAOpF,KAAKmE,EAAEZ,OACd+B,EAAG8Q,MAAQ,EACf,KAAK,EAED,OADAxY,IACO,CAAC,EAAa,GACzB,KAAK,EAAG,MAAO,CAAC,EAAce,QAAQyG,cAWvCkT,GAAmB,SAAUvY,GAAK,OAAOsY,IAA0B,SAAU/N,EAAGnL,GAAK,OAAOY,EAAEZ,OAQ9FoZ,GAEXD,GAAiBrN,M,gCC32BjB,moCAQO,SAAS0R,EAAIC,GAChB,OAAOA,EAAG,GAMP,SAASC,EAAID,GAChB,OAAOA,EAAG,GAMP,SAASlD,EAAKkD,GACjB,MAAO,CAACC,EAAID,GAAKD,EAAIC,IAMlB,SAASE,EAAS/e,GACrB,MAAO,CACHgO,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAK0I,EACLM,GAAI,SAAUD,EAAKpD,GAAM,MAAO,CAAC+Y,EAAI3V,EAAJ2V,CAASA,EAAI/Y,IAAM7F,EAAEI,OAAO0e,EAAI7V,GAAM6V,EAAIjZ,OAGnF,IAAI6C,EAAK,SAAUzB,GAAK,OAAO,SAAU7F,GACrC,MAAO,CAACA,EAAG6F,EAAEvH,SAMV,SAASsf,EAAe/X,GAC3B,IAAIiW,EAAI6B,EAAS9X,GACjB,MAAO,CACH+G,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAKgd,EAAEhd,IACPgJ,GAAIgU,EAAEhU,GACNR,GAAIA,EAAGzB,IAOR,SAASgY,EAASjf,GACrB,IAAIkd,EAAI6B,EAAS/e,GACjB,MAAO,CACHgO,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAKgd,EAAEhd,IACPgJ,GAAIgU,EAAEhU,GACNE,MAAO,SAAUD,EAAInH,GACjB,IAAIuF,EAAKvF,EAAE4c,EAAIzV,IAAM9H,EAAIkG,EAAG,GAAImK,EAAInK,EAAG,GACvC,MAAO,CAAClG,EAAGrB,EAAEI,OAAO0e,EAAI3V,GAAKuI,MAQlC,SAASwN,EAASjY,GACrB,IAAIkY,EAAIF,EAAShY,GACjB,MAAO,CACH+G,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAKif,EAAEjf,IACPgJ,GAAIiW,EAAEjW,GACNE,MAAO+V,EAAE/V,MACTV,GAAIA,EAAGzB,IAQR,SAASmY,EAAYnY,GACxB,IAWIkY,EAAIF,EAAShY,GACjB,MAAO,CACH+G,IAAKA,EACLmJ,QAAI7T,EACJpD,IAAKif,EAAEjf,IACPgJ,GAAIiW,EAAEjW,GACNE,MAAO+V,EAAE/V,MACTiW,SAlBW,SAAUje,EAAGY,GAIxB,IAHA,IAAIqF,EAASrF,EAAEZ,GACXke,EAAMrY,EAAEvH,MACRgS,EAAIkN,EAAIvX,GACM,SAAXqK,EAAEnM,MACL+Z,EAAMrY,EAAE7G,OAAOkf,EAAKR,EAAIzX,IAExBqK,EAAIkN,EADJvX,EAASrF,EAAE0P,EAAEhM,OAGjB,MAAO,CAACgM,EAAElM,MAAOyB,EAAE7G,OAAOkf,EAAKR,EAAIzX,OAgB3C,IAAIkY,EAAW,SAAUC,EAAIC,GAAM,OAAO5W,YAAK2W,EAAIE,EAAQD,KAEvD7W,EAAO,SAAU/C,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI3F,EAAI8B,KAE9Csa,EAAS,SAAUzW,EAAI7D,EAAG6F,GAAK,OAAOgB,YAAKhD,EAAI0W,EAAMva,EAAG6F,KAExD2U,EAAW,SAAU3W,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAI4W,EAAQza,KAEtDkJ,EAAU,SAAUiC,EAAInL,GAAK,OAAO6G,YAAKsE,EAAIhC,EAAOnJ,KAEpDoI,EAAU,SAAUvE,EAAIxE,EAAGW,GAAK,OAAO6G,YAAKhD,EAAIsB,EAAO9F,EAAGW,KAE1DqI,EAAW,SAAUpD,GACrB,IAAIqD,EAAWC,EAAQtD,GACvB,OAAO,SAAUpB,EAAI7D,GAAK,OAAO6G,YAAKhD,EAAIyE,EAAStI,MAGnDwI,EAAe,SAAU3E,EAAIxE,EAAGW,GAAK,OAAO6G,YAAKhD,EAAI4E,EAAYpJ,EAAGW,KAEpEoJ,EAAY,SAAUC,GACtB,IAAIC,EAAYC,EAASF,GACzB,OAAO,SAAUG,EAAIxJ,GAAK,OAAO6G,YAAK2C,EAAIF,EAAUtJ,MAW7Cua,EAAQ,SAAUva,EAAG6F,GAAK,OAAO,SAAUhC,GAAM,MAAO,CAACgC,EAAE+W,EAAI/Y,IAAM7D,EAAE8c,EAAIjZ,OAO3E4W,EAAU,SAAUza,GAAK,OAAO,SAAU6D,GAAM,MAAO,CAC9D+Y,EAAI/Y,GACJ7D,EAAE8c,EAAIjZ,OAMC6Z,EAAU,SAAUD,GAAM,OAAO,SAAUD,GAAM,MAAO,CAC/DZ,EAAIY,GACJV,EAAIW,MAMGtU,EAAS,SAAUnJ,GAAK,OAAO,SAAUmL,GAAM,MAAO,CAACnL,EAAEmL,GAAK2R,EAAI3R,MAKlEyE,EAAUgN,EAOVxR,EAEXjC,EAAO+B,KAQIhN,EAAM,SAAU8B,GAAK,OAAO,SAAU6D,GAAM,MAAO,CAC1D7D,EAAE4c,EAAI/Y,IACNiZ,EAAIjZ,MAMGsB,EAAS,SAAU9F,EAAGW,GAAK,OAAO,SAAU6D,GACnD,OAAO7D,EAAEX,EAAGud,EAAI/Y,MAMT0E,EAAU,WACjB,OAAO,SAAUvI,GAAK,OAAO,SAAU6D,GAAM,OAAO7D,EAAE4c,EAAI/Y,OAMnD4E,EAAc,SAAUpJ,EAAGW,GAAK,OAAO,SAAU6D,GACxD,OAAO7D,EAAE4c,EAAI/Y,GAAKxE,KAKXkK,EAAW,SAAUF,GAC5B,OAAO,SAAUrJ,GAAK,OAAO,SAAUwJ,GAAM,OAAOH,EAAEnL,IAAI8B,EAAE4c,EAAIpT,KAAM,SAAUnK,GAAK,MAAO,CAACA,EAAGyd,EAAItT,UAK7FgC,EAAW,SAAUnC,GAAK,OAAO,SAAUoC,GAClD,OAAOpC,EAAEnL,IAAI0e,EAAInR,IAAM,SAAUrM,GAAK,MAAO,CAACA,EAAG0d,EAAIrR,SAS9CO,EAAM,gBAKNC,EAAU,CACjBD,IAAKA,EACL9N,IAAK0I,GAMEqV,EAAY,CACnBjQ,IAAKA,EACLuO,MAAOD,EACPG,QAASD,GAMFmD,EAAe,CACtB3R,IAAKA,EACL0R,QAASH,GAMF5N,EAAU,CACjB3D,IAAKA,EACL9N,IAAK0I,EACLuC,OAAQD,EACR0G,QAASA,GAMFlD,EAAW,CAClBV,IAAKA,EACL7G,OAAQiD,EACRG,QAASF,EACTI,YAAaD,GAMNoE,EAAc,CACrBZ,IAAKA,EACL9N,IAAK0I,EACLzB,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,EACVoC,SAAUA,GAOHoS,EAAgB,CACvB5R,IAAKA,EACL0R,QAASH,EACTrf,IAAK0I,EACL2T,MAAOD,EACPG,QAASD,EACT5K,QAASA,EACTzG,OAAQD,EACR/D,OAAQiD,EACRG,QAASF,EACTI,YAAaD,EACbe,SAAUH,EACVoC,SAAUA,I,gCC1Td,u4BAoBO,SAASzN,EAAQC,GACpB,MAAO,CACHC,KAAM,SAAUyR,GACZ,IAAIG,EAAW,GAOf,OANAH,EAAEmD,SAAQ,SAAUzT,GAChByQ,GAAY7R,EAAEC,KAAKmB,GAAK,QAEX,KAAbyQ,IACAA,EAAWA,EAASiD,UAAU,EAAGjD,EAASpS,OAAS,IAEhD,YAAcoS,EAAW,OAOrC,IAAInS,EAAQ,IAAIsU,IAKhB,SAAS9B,EAAgBhR,GAC5B,OAAO,SAAUb,GAEb,IAAII,EAAI,GAER,OADAJ,EAAEwU,SAAQ,SAAUzO,GAAK,OAAO3F,EAAEwB,KAAKmE,MAChC3F,EAAEkF,KAAKzE,EAAEU,UAOjB,SAASjB,EAAMC,GAClB,IAAIif,EAAUC,EAASlf,GACvB,OAAOmS,sBAAW,SAAU1S,EAAGC,GAAK,OAAOuf,EAAQxf,EAAGC,IAAMuf,EAAQvf,EAAGD,MAKpE,SAAS2O,EAAKhL,GACjB,OAAO,SAAUyQ,GAKb,IAJA,IACIrO,EADA+O,EAASV,EAAIU,SAEbS,GAAQ,GAEJA,KAAWxP,EAAI+O,EAAOC,QAAQC,MAClCO,EAAQ5R,EAAUoC,EAAE4G,OAExB,OAAO4I,GASR,SAAS1V,EAAIU,GAChB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUoB,GAAK,OAAO,SAAUyS,GACnC,IAAIhU,EAAI,IAAIuT,IAOZ,OANAS,EAAII,SAAQ,SAAUzO,GAClB,IAAI1B,EAAI1C,EAAEoE,GACL+B,EAAMzD,EAAGjE,IACVA,EAAEsf,IAAIrb,MAGPjE,IAMR,SAASO,EAAMgD,GAClB,OAAOgc,YAAIhR,EAAKgR,YAAIhc,KAMjB,SAASoF,EAAMxI,GAClB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUoB,GAAK,OAAO,SAAUyS,GACnC,IAAIhU,EAAI,IAAIuT,IAQZ,OAPAS,EAAII,SAAQ,SAAUzO,GAClBpE,EAAEoE,GAAGyO,SAAQ,SAAUzO,GACd+B,EAAM/B,EAAG3F,IACVA,EAAEsf,IAAI3Z,SAIX3F,IAGR,SAASqf,EAASlf,GACrB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUgS,EAAI1I,GACjB,QAAa5G,IAAT4G,EAAoB,CACpB,IAAI+V,EAAcH,EAASlf,GAC3B,OAAO,SAAUsJ,GAAQ,OAAO+V,EAAY/V,EAAM0I,IAEtD,OAAO5R,GAAM,SAAUI,GAAK,OAAO+G,EAAM/G,EAAG8I,KAArClJ,CAA+C4R,IAGvD,SAASvK,EAAOrE,GACnB,OAAO,SAAUyQ,GAKb,IAJA,IACIrO,EADA+O,EAASV,EAAIU,SAEb1U,EAAI,IAAIuT,MAEH5N,EAAI+O,EAAOC,QAAQC,MAAM,CAC9B,IAAIrI,EAAQ5G,EAAE4G,MACVhJ,EAAUgJ,IACVvM,EAAEsf,IAAI/S,GAGd,OAAOvM,GAGR,SAASmJ,EAAU5F,GACtB,OAAO,SAAUyQ,GAMb,IALA,IACIrO,EADA+O,EAASV,EAAIU,SAEb3P,EAAQ,IAAIwO,IACZtO,EAAO,IAAIsO,MAEN5N,EAAI+O,EAAOC,QAAQC,MAAM,CAC9B,IAAIrI,EAAQ5G,EAAE4G,MACVhJ,EAAUgJ,GACVxH,EAAMua,IAAI/S,GAGVtH,EAAKqa,IAAI/S,GAGjB,MAAO,CAAEtH,KAAMA,EAAMF,MAAOA,IAG7B,SAASkB,EAAK9F,GACjB,OAAO,SAAUQ,EAAGqT,GAChB,QAAYnR,IAARmR,EAAmB,CACnB,IAAI9N,EAAUD,EAAK9F,GACnB,OAAO,SAAU6T,GAAO,OAAO9N,EAAQvF,EAAGqT,IAM9C,IAJA,IACIrO,EADA+O,EAASV,EAAIU,SAEbS,GAAQ,GAEJA,KAAWxP,EAAI+O,EAAOC,QAAQC,MAClCO,EAAQhV,EAAEC,OAAOO,EAAGgF,EAAE4G,OAE1B,OAAO4I,GAGR,SAAS1N,EAAMtH,GAClB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUgS,EAAI1I,GACjB,QAAa5G,IAAT4G,EAAoB,CACpB,IAAI9B,EAAWF,EAAMtH,GACrB,OAAO,SAAUsJ,GAAQ,OAAO9B,EAASwK,EAAI1I,IAEjD,GAAI0I,IAAOlT,EACP,OAAOwK,EAEX,GAAIA,IAASxK,EACT,OAAOkT,EAEX,IAAInS,EAAI,IAAIuT,IAAIpB,GAMhB,OALA1I,EAAK2K,SAAQ,SAAUzO,GACd+B,EAAM/B,EAAG3F,IACVA,EAAEsf,IAAI3Z,MAGP3F,GAGR,SAAS6H,EAAa1H,GACzB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUgS,EAAI1I,GACjB,QAAa5G,IAAT4G,EAAoB,CACpB,IAAI3B,EAAkBD,EAAa1H,GACnC,OAAO,SAAUsJ,GAAQ,OAAO3B,EAAgB2B,EAAM0I,IAE1D,GAAIA,IAAOlT,GAASwK,IAASxK,EACzB,OAAOA,EAEX,IAAIe,EAAI,IAAIuT,IAMZ,OALApB,EAAGiC,SAAQ,SAAUzO,GACb+B,EAAM/B,EAAG8D,IACTzJ,EAAEsf,IAAI3Z,MAGP3F,GAMR,SAASqJ,EAAaoW,EAAIC,GAC7B,OAAO,SAAUne,GAAK,OAAO,SAAUyS,GAQnC,IAPA,IACIrO,EADA+O,EAASV,EAAIU,SAEbzP,EAAO,IAAIsO,IACXxO,EAAQ,IAAIwO,IACZoM,EAAO1Z,EAAKwZ,GACZG,EAAO3Z,EAAKyZ,KAEP/Z,EAAI+O,EAAOC,QAAQC,MAAM,CAC9B,IAAI3Q,EAAI1C,EAAEoE,EAAE4G,OACZ,OAAQtI,EAAEa,MACN,IAAK,OACI6a,EAAK1b,EAAEgB,KAAMA,IACdA,EAAKqa,IAAIrb,EAAEgB,MAEf,MACJ,IAAK,QACI2a,EAAK3b,EAAEc,MAAOA,IACfA,EAAMua,IAAIrb,EAAEc,QAK5B,MAAO,CAAEE,KAAMA,EAAMF,MAAOA,KAG7B,SAASgD,EAAW5H,GACvB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUgS,EAAI1I,GACjB,QAAa5G,IAAT4G,EAAoB,CACpB,IAAIzB,EAAgBD,EAAW5H,GAC/B,OAAO,SAAUsJ,GAAQ,OAAOzB,EAAcyB,EAAM0I,IAExD,OAAOvK,GAAO,SAAUjH,GAAK,OAAQ+G,EAAM/G,EAAG8I,KAAvC7B,CAAiDuK,IAOzD,SAASsB,EAAetT,GAC3B,MAAO,CACHR,OAAQ8H,EAAMtH,GACdlB,MAAOA,GAOR,SAASyU,EAAyBvT,GACrC,MAAO,CACHR,OAAQkI,EAAa1H,IAMtB,SAASuG,EAAOjG,GACnB,IAAIuU,EAAWvD,EAAgBhR,GAC/B,OAAO,SAAUG,EAAGW,GAAK,OAAO,SAAU6D,GAAM,OAAO4P,EAAS5P,GAAIsB,OAAOnF,EAAGX,KAK3E,SAASkJ,EAAQrJ,EAAG+F,GACvB,IAAIwO,EAAWvD,EAAgBhR,GAC/B,OAAO,SAAUc,GAAK,OAAO,SAAU6D,GAAM,OAAO4P,EAAS5P,GAAIsB,QAAO,SAAU9F,EAAGD,GAAK,OAAO6F,EAAE7G,OAAOiB,EAAGW,EAAEZ,MAAQ6F,EAAEvH,SAQtH,SAASuQ,EAAU7O,GACtB,OAAO,IAAI4S,IAAI,CAAC5S,IAQb,SAASgT,EAAOxT,GACnB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUQ,GAAK,OAAO,SAAUqT,GACnC,GAAKtM,EAAM/G,EAAN+G,CAASsM,GAMV,OAAOA,EALP,IAAIhU,EAAI,IAAIuT,IAAIS,GAEhB,OADAhU,EAAEsf,IAAI3e,GACCX,IAaZ,SAAS4T,EAAOzT,GACnB,OAAO,SAAUQ,GAAK,OAAO,SAAUqT,GAAO,OAAOpM,GAAO,SAAUiY,GAAM,OAAQ1f,EAAEC,OAAOO,EAAGkf,KAA3CjY,CAAmDoM,KAQrG,SAASnV,EAAUsB,GACtB,OAAO,SAAUrB,GAIb,IAHA,IAAIiC,EAAMjC,EAAGE,OACTgB,EAAI,IAAIuT,IACRuM,EAAM7Z,EAAK9F,GACNf,EAAI,EAAGA,EAAI2B,EAAK3B,IAAK,CAC1B,IAAIuB,EAAI7B,EAAGM,GACN0gB,EAAInf,EAAGX,IACRA,EAAEsf,IAAI3e,GAGd,OAAOX,GAOR,SAASwM,EAAQrM,GACpB,OAAO2I,EAAU3I,EAAV2I,CAAa2D,KAKjB,SAASL,EAAS2T,EAAIC,GACzB,OAAO,SAAU5a,GACb,IAAI6a,EAASha,EAAK8Z,GACdG,EAASja,EAAK+Z,GACd/a,EAAO,IAAIsO,IACXxO,EAAQ,IAAIwO,IAehB,OAdAnO,EAAGgP,SAAQ,SAAUzO,GACjB,OAAQA,EAAEb,MACN,IAAK,OACImb,EAAOta,EAAEV,KAAMA,IAChBA,EAAKqa,IAAI3Z,EAAEV,MAEf,MACJ,IAAK,QACIib,EAAOva,EAAEZ,MAAOA,IACjBA,EAAMua,IAAI3Z,EAAEZ,WAKrB,CAAEE,KAAMA,EAAMF,MAAOA,IAO7B,SAAS+D,EAAU3I,GACtB,IAAIuH,EAAQzB,EAAK9F,GACjB,OAAO,SAAUoB,GAAK,OAAO,SAAU6D,GACnC,IAAIpF,EAAI,IAAIuT,IAOZ,OANAnO,EAAGgP,SAAQ,SAAUzT,GACjB,IAAIwf,EAAK5e,EAAEZ,GACK,SAAZwf,EAAGrb,MAAoB4C,EAAMyY,EAAG5T,MAAOvM,IACvCA,EAAEsf,IAAIa,EAAG5T,UAGVvM,M,gCC1Yf,i1BAyCO,SAASgR,EAAKzR,GACjB,OAAO,SAAU6gB,EAAWthB,GACxB,QAAW+D,IAAP/D,EAAkB,CAClB,IAAIuhB,EAAUrP,EAAKzR,GACnB,OAAO,SAAUT,GAAM,OAAOuhB,EAAQD,EAAWthB,IAErD,OAAOA,EAAG4H,OAAOnH,EAAEI,OAAQygB,IAc5B,SAASE,IACZ,MAAO,CAAE3gB,OAAQ8M,KAad,SAAS8T,IACZ,MAAO,CAAE5gB,OAAQ,SAAUmM,EAAGjM,GAAK,OAAOA,IAiBvC,SAAS2gB,IAEZ,IADA,IAAIC,EAAa,GACR7a,EAAK,EAAGA,EAAK8S,UAAU1Z,OAAQ4G,IACpC6a,EAAW7a,GAAM8S,UAAU9S,GAE/B,MAAO,CACHjG,OAAQ,SAAUC,EAAGC,GAAK,OAAO4gB,EAAWhhB,KAAI,SAAUwR,EAAG7R,GAAK,OAAO6R,EAAEtR,OAAOC,EAAER,GAAIS,EAAET,SAc3F,SAASshB,EAAiBnhB,GAC7B,MAAO,CACHI,OAAQ,SAAUC,EAAGC,GAAK,OAAON,EAAEI,OAAOE,EAAGD,KA0B9C,SAAS+gB,EAAqBphB,GACjC,OAAO,WAAc,MAAQ,CACzBI,OAAQ,SAAU4B,EAAG6F,GAAK,OAAO,SAAUzG,GAAK,OAAOpB,EAAEI,OAAO4B,EAAEZ,GAAIyG,EAAEzG,QAwBzE,SAASigB,EAAmBH,GAC/B,MAAO,CACH9gB,OAAQ,SAAUC,EAAGC,GAEjB,IADA,IAAIG,EAAI,GACC4F,EAAK,EAAGkB,EAAKyK,OAAOvC,KAAKyR,GAAa7a,EAAKkB,EAAG9H,OAAQ4G,IAAM,CACjE,IAAI4L,EAAM1K,EAAGlB,GACb5F,EAAEwR,GAAOiP,EAAWjP,GAAK7R,OAAOC,EAAE4R,GAAM3R,EAAE2R,IAE9C,OAAOxR,IAkBZ,SAASoQ,EAAiB3P,GAC7B,MAAO,CACHd,OAAQsB,cAAIR,IAiBb,SAAS6P,EAAiB7P,GAC7B,MAAO,CACHd,OAAQ0Q,cAAI5P,IAoBb,SAASogB,IACZ,MAAO,CACHlhB,OAAQ,SAAUC,EAAGC,GAAK,OAAO0R,OAAOI,OAAO,GAAI/R,EAAGC,KAevD,IAAIihB,EAAe,CACtBnhB,OAAQ,SAAUC,EAAGC,GAAK,OAAOD,GAAKC,IAe/BkhB,EAAe,CACtBphB,OAAQ,SAAUC,EAAGC,GAAK,OAAOD,GAAKC,IAa/BmhB,EAAe,CACtBrhB,OAAQ,SAAUC,EAAGC,GAAK,OAAOD,EAAIC,IAa9BohB,EAAmB,CAC1BthB,OAAQ,SAAUC,EAAGC,GAAK,OAAOD,EAAIC,IAa9BqhB,EAAkB,CACzBvhB,OAAQ,SAAUC,EAAGC,GAAK,OAAOD,EAAIC,IAM9BshB,EAAgB,CACvBxhB,OAAQ,cAgBL,SAASyhB,EAAwBzgB,GACpC,OAAO,SAAUpB,GAAK,MAAQ,CAC1BI,OAAQ,SAAUC,EAAGC,GAAK,OAAON,EAAEI,OAAOC,EAAGL,EAAEI,OAAOgB,EAAGd","file":"static/js/index~19263644.eb231043.chunk.js","sourcesContent":["import { identity, pipe, bind_, bindTo_, flow } from './function';\nimport * as O from './Option';\nimport { fromCompare, getMonoid as getOrdMonoid, ordNumber } from './Ord';\n// -------------------------------------------------------------------------------------\n// model\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.5.0\n */\n// tslint:disable-next-line: readonly-array\nexport function fromArray(as) {\n    var l = as.length;\n    if (l === 0) {\n        return empty;\n    }\n    var ras = Array(l);\n    for (var i = 0; i < l; i++) {\n        ras[i] = as[i];\n    }\n    return ras;\n}\n/**\n * @category destructors\n * @since 2.5.0\n */\n// tslint:disable-next-line: readonly-array\nexport function toArray(ras) {\n    var l = ras.length;\n    var as = Array(l);\n    for (var i = 0; i < l; i++) {\n        as[i] = ras[i];\n    }\n    return as;\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getShow(S) {\n    return {\n        show: function (as) { return \"[\" + as.map(S.show).join(', ') + \"]\"; }\n    };\n}\nvar concat = function (x, y) {\n    var lenx = x.length;\n    if (lenx === 0) {\n        return y;\n    }\n    var leny = y.length;\n    if (leny === 0) {\n        return x;\n    }\n    var r = Array(lenx + leny);\n    for (var i = 0; i < lenx; i++) {\n        r[i] = x[i];\n    }\n    for (var i = 0; i < leny; i++) {\n        r[i + lenx] = y[i];\n    }\n    return r;\n};\n/**\n * Returns a `Monoid` for `ReadonlyArray<A>`\n *\n * @example\n * import { getMonoid } from 'fp-ts/ReadonlyArray'\n *\n * const M = getMonoid<number>()\n * assert.deepStrictEqual(M.concat([1, 2], [3, 4]), [1, 2, 3, 4])\n *\n * @category instances\n * @since 2.5.0\n */\nexport function getMonoid() {\n    return {\n        concat: concat,\n        empty: empty\n    };\n}\n/**\n * Derives an `Eq` over the `ReadonlyArray` of a given element type from the `Eq` of that type. The derived `Eq` defines two\n * arrays as equal if all elements of both arrays are compared equal pairwise with the given `E`. In case of arrays of\n * different lengths, the result is non equality.\n *\n * @example\n * import { eqString } from 'fp-ts/Eq'\n * import { getEq } from 'fp-ts/ReadonlyArray'\n *\n * const E = getEq(eqString)\n * assert.strictEqual(E.equals(['a', 'b'], ['a', 'b']), true)\n * assert.strictEqual(E.equals(['a'], []), false)\n *\n * @category instances\n * @since 2.5.0\n */\nexport function getEq(E) {\n    return {\n        equals: function (xs, ys) { return xs === ys || (xs.length === ys.length && xs.every(function (x, i) { return E.equals(x, ys[i]); })); }\n    };\n}\n/**\n * Derives an `Ord` over the `ReadonlyArray` of a given element type from the `Ord` of that type. The ordering between two such\n * arrays is equal to: the first non equal comparison of each arrays elements taken pairwise in increasing order, in\n * case of equality over all the pairwise elements; the longest array is considered the greatest, if both arrays have\n * the same length, the result is equality.\n *\n * @example\n * import { getOrd } from 'fp-ts/ReadonlyArray'\n * import { ordString } from 'fp-ts/Ord'\n *\n * const O = getOrd(ordString)\n * assert.strictEqual(O.compare(['b'], ['a']), 1)\n * assert.strictEqual(O.compare(['a'], ['a']), 0)\n * assert.strictEqual(O.compare(['a'], ['b']), -1)\n *\n *\n * @category instances\n * @since 2.5.0\n */\nexport function getOrd(O) {\n    return fromCompare(function (a, b) {\n        var aLen = a.length;\n        var bLen = b.length;\n        var len = Math.min(aLen, bLen);\n        for (var i = 0; i < len; i++) {\n            var ordering = O.compare(a[i], b[i]);\n            if (ordering !== 0) {\n                return ordering;\n            }\n        }\n        return ordNumber.compare(aLen, bLen);\n    });\n}\n/**\n * Return a list of length `n` with element `i` initialized with `f(i)`\n *\n * @example\n * import { makeBy } from 'fp-ts/ReadonlyArray'\n *\n * const double = (n: number): number => n * 2\n * assert.deepStrictEqual(makeBy(5, double), [0, 2, 4, 6, 8])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function makeBy(n, f) {\n    // tslint:disable-next-line: readonly-array\n    var r = [];\n    for (var i = 0; i < n; i++) {\n        r.push(f(i));\n    }\n    return r;\n}\n/**\n * Create an array containing a range of integers, including both endpoints\n *\n * @example\n * import { range } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(range(1, 5), [1, 2, 3, 4, 5])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function range(start, end) {\n    return makeBy(end - start + 1, function (i) { return start + i; });\n}\n/**\n * Create an array containing a value repeated the specified number of times\n *\n * @example\n * import { replicate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(replicate(3, 'a'), ['a', 'a', 'a'])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function replicate(n, a) {\n    return makeBy(n, function () { return a; });\n}\n/**\n * Removes one level of nesting\n *\n * Derivable from `Monad`.\n *\n * @example\n * import { flatten } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function flatten(mma) {\n    var rLen = 0;\n    var len = mma.length;\n    for (var i = 0; i < len; i++) {\n        rLen += mma[i].length;\n    }\n    var r = Array(rLen);\n    var start = 0;\n    for (var i = 0; i < len; i++) {\n        var arr = mma[i];\n        var l = arr.length;\n        for (var j = 0; j < l; j++) {\n            r[j + start] = arr[j];\n        }\n        start += l;\n    }\n    return r;\n}\n/**\n * Break an array into its first element and remaining elements\n *\n * @example\n * import { foldLeft } from 'fp-ts/ReadonlyArray'\n *\n * const len: <A>(as: ReadonlyArray<A>) => number = foldLeft(() => 0, (_, tail) => 1 + len(tail))\n * assert.strictEqual(len([1, 2, 3]), 3)\n *\n * @category destructors\n * @since 2.5.0\n */\nexport function foldLeft(onEmpty, onCons) {\n    return function (as) { return (isEmpty(as) ? onEmpty() : onCons(as[0], as.slice(1))); };\n}\n/**\n * Break an array into its initial elements and the last element\n *\n * @category destructors\n * @since 2.5.0\n */\nexport function foldRight(onEmpty, onCons) {\n    return function (as) { return (isEmpty(as) ? onEmpty() : onCons(as.slice(0, as.length - 1), as[as.length - 1])); };\n}\n/**\n * Same as `reduce` but it carries over the intermediate steps\n *\n * @example\n * import { scanLeft } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(scanLeft(10, (b, a: number) => b - a)([1, 2, 3]), [10, 9, 7, 4])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function scanLeft(b, f) {\n    return function (as) {\n        var l = as.length;\n        // tslint:disable-next-line: readonly-array\n        var r = new Array(l + 1);\n        r[0] = b;\n        for (var i = 0; i < l; i++) {\n            r[i + 1] = f(r[i], as[i]);\n        }\n        return r;\n    };\n}\n/**\n * Fold an array from the right, keeping all intermediate results instead of only the final result\n *\n * @example\n * import { scanRight } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(scanRight(10, (a: number, b) => b - a)([1, 2, 3]), [4, 5, 7, 10])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function scanRight(b, f) {\n    return function (as) {\n        var l = as.length;\n        // tslint:disable-next-line: readonly-array\n        var r = new Array(l + 1);\n        r[l] = b;\n        for (var i = l - 1; i >= 0; i--) {\n            r[i] = f(as[i], r[i + 1]);\n        }\n        return r;\n    };\n}\n/**\n * Test whether an array is empty\n *\n * @example\n * import { isEmpty } from 'fp-ts/ReadonlyArray'\n *\n * assert.strictEqual(isEmpty([]), true)\n *\n * @since 2.5.0\n */\nexport function isEmpty(as) {\n    return as.length === 0;\n}\n/**\n * Test whether an array is non empty narrowing down the type to `NonEmptyReadonlyArray<A>`\n *\n * @category guards\n * @since 2.5.0\n */\nexport function isNonEmpty(as) {\n    return as.length > 0;\n}\n/**\n * Test whether an array contains a particular index\n *\n * @since 2.5.0\n */\nexport function isOutOfBound(i, as) {\n    return i < 0 || i >= as.length;\n}\nexport function lookup(i, as) {\n    return as === undefined ? function (as) { return lookup(i, as); } : isOutOfBound(i, as) ? O.none : O.some(as[i]);\n}\nexport function cons(head, tail) {\n    if (tail === undefined) {\n        return function (tail) { return cons(head, tail); };\n    }\n    var len = tail.length;\n    var r = Array(len + 1);\n    for (var i = 0; i < len; i++) {\n        r[i + 1] = tail[i];\n    }\n    r[0] = head;\n    return r;\n}\n// TODO: curry and make data-last in v3\n/**\n * Append an element to the end of an array, creating a new non empty array\n *\n * @example\n * import { snoc } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function snoc(init, end) {\n    var len = init.length;\n    var r = Array(len + 1);\n    for (var i = 0; i < len; i++) {\n        r[i] = init[i];\n    }\n    r[len] = end;\n    return r;\n}\n/**\n * Get the first element in an array, or `None` if the array is empty\n *\n * @example\n * import { head } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(head([1, 2, 3]), some(1))\n * assert.deepStrictEqual(head([]), none)\n *\n * @since 2.5.0\n */\nexport function head(as) {\n    return isEmpty(as) ? O.none : O.some(as[0]);\n}\n/**\n * Get the last element in an array, or `None` if the array is empty\n *\n * @example\n * import { last } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(last([1, 2, 3]), some(3))\n * assert.deepStrictEqual(last([]), none)\n *\n * @since 2.5.0\n */\nexport function last(as) {\n    return lookup(as.length - 1, as);\n}\n/**\n * Get all but the first element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { tail } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(tail([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(tail([]), none)\n *\n * @since 2.5.0\n */\nexport function tail(as) {\n    return isEmpty(as) ? O.none : O.some(as.slice(1));\n}\n/**\n * Get all but the last element of an array, creating a new array, or `None` if the array is empty\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), some([1, 2]))\n * assert.deepStrictEqual(init([]), none)\n *\n * @since 2.5.0\n */\nexport function init(as) {\n    var len = as.length;\n    return len === 0 ? O.none : O.some(as.slice(0, len - 1));\n}\n/**\n * Keep only a number of elements from the start of an array, creating a new array.\n * `n` must be a natural number\n *\n * @example\n * import { takeLeft } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(takeLeft(2)([1, 2, 3]), [1, 2])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function takeLeft(n) {\n    return function (as) { return as.slice(0, n); };\n}\n/**\n * Keep only a number of elements from the end of an array, creating a new array.\n * `n` must be a natural number\n *\n * @example\n * import { takeRight } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(takeRight(2)([1, 2, 3, 4, 5]), [4, 5])\n *\n * @since 2.5.0\n */\nexport function takeRight(n) {\n    return function (as) { return (n === 0 ? empty : as.slice(-n)); };\n}\nexport function takeLeftWhile(predicate) {\n    return function (as) {\n        var i = spanIndexUncurry(as, predicate);\n        var init = Array(i);\n        for (var j = 0; j < i; j++) {\n            init[j] = as[j];\n        }\n        return init;\n    };\n}\nvar spanIndexUncurry = function (as, predicate) {\n    var l = as.length;\n    var i = 0;\n    for (; i < l; i++) {\n        if (!predicate(as[i])) {\n            break;\n        }\n    }\n    return i;\n};\nexport function spanLeft(predicate) {\n    return function (as) {\n        var i = spanIndexUncurry(as, predicate);\n        var init = Array(i);\n        for (var j = 0; j < i; j++) {\n            init[j] = as[j];\n        }\n        var l = as.length;\n        var rest = Array(l - i);\n        for (var j = i; j < l; j++) {\n            rest[j - i] = as[j];\n        }\n        return { init: init, rest: rest };\n    };\n}\n/**\n * Drop a number of elements from the start of an array, creating a new array\n *\n * @example\n * import { dropLeft } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(dropLeft(2)([1, 2, 3]), [3])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function dropLeft(n) {\n    return function (as) { return as.slice(n, as.length); };\n}\n/**\n * Drop a number of elements from the end of an array, creating a new array\n *\n * @example\n * import { dropRight } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(dropRight(2)([1, 2, 3, 4, 5]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function dropRight(n) {\n    return function (as) { return as.slice(0, as.length - n); };\n}\n/**\n * Remove the longest initial subarray for which all element satisfy the specified predicate, creating a new array\n *\n * @example\n * import { dropLeftWhile } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(dropLeftWhile((n: number) => n % 2 === 1)([1, 3, 2, 4, 5]), [2, 4, 5])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function dropLeftWhile(predicate) {\n    return function (as) {\n        var i = spanIndexUncurry(as, predicate);\n        var l = as.length;\n        var rest = Array(l - i);\n        for (var j = i; j < l; j++) {\n            rest[j - i] = as[j];\n        }\n        return rest;\n    };\n}\n/**\n * Find the first index for which a predicate holds\n *\n * @example\n * import { findIndex } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([1, 2, 3]), some(1))\n * assert.deepStrictEqual(findIndex((n: number) => n === 2)([]), none)\n *\n * @since 2.5.0\n */\nexport function findIndex(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = 0; i < len; i++) {\n            if (predicate(as[i])) {\n                return O.some(i);\n            }\n        }\n        return O.none;\n    };\n}\nexport function findFirst(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = 0; i < len; i++) {\n            if (predicate(as[i])) {\n                return O.some(as[i]);\n            }\n        }\n        return O.none;\n    };\n}\n/**\n * Find the first element returned by an option based selector function\n *\n * @example\n * import { findFirstMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   name: string\n *   age?: number\n * }\n *\n * const persons: ReadonlyArray<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]\n *\n * // returns the name of the first person that has an age\n * assert.deepStrictEqual(findFirstMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Mary'))\n *\n * @since 2.5.0\n */\nexport function findFirstMap(f) {\n    return function (as) {\n        var len = as.length;\n        for (var i = 0; i < len; i++) {\n            var v = f(as[i]);\n            if (O.isSome(v)) {\n                return v;\n            }\n        }\n        return O.none;\n    };\n}\nexport function findLast(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = len - 1; i >= 0; i--) {\n            if (predicate(as[i])) {\n                return O.some(as[i]);\n            }\n        }\n        return O.none;\n    };\n}\n/**\n * Find the last element returned by an option based selector function\n *\n * @example\n * import { findLastMap } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface Person {\n *   name: string\n *   age?: number\n * }\n *\n * const persons: ReadonlyArray<Person> = [{ name: 'John' }, { name: 'Mary', age: 45 }, { name: 'Joey', age: 28 }]\n *\n * // returns the name of the last person that has an age\n * assert.deepStrictEqual(findLastMap((p: Person) => (p.age === undefined ? none : some(p.name)))(persons), some('Joey'))\n *\n * @since 2.5.0\n */\nexport function findLastMap(f) {\n    return function (as) {\n        var len = as.length;\n        for (var i = len - 1; i >= 0; i--) {\n            var v = f(as[i]);\n            if (O.isSome(v)) {\n                return v;\n            }\n        }\n        return O.none;\n    };\n}\n/**\n * Returns the index of the last element of the list which matches the predicate\n *\n * @example\n * import { findLastIndex } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * interface X {\n *   a: number\n *   b: number\n * }\n * const xs: ReadonlyArray<X> = [{ a: 1, b: 0 }, { a: 1, b: 1 }]\n * assert.deepStrictEqual(findLastIndex((x: { a: number }) => x.a === 1)(xs), some(1))\n * assert.deepStrictEqual(findLastIndex((x: { a: number }) => x.a === 4)(xs), none)\n *\n *\n * @since 2.5.0\n */\nexport function findLastIndex(predicate) {\n    return function (as) {\n        var len = as.length;\n        for (var i = len - 1; i >= 0; i--) {\n            if (predicate(as[i])) {\n                return O.some(i);\n            }\n        }\n        return O.none;\n    };\n}\n/**\n * Insert an element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { insertAt } from 'fp-ts/ReadonlyArray'\n * import { some } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(insertAt(2, 5)([1, 2, 3, 4]), some([1, 2, 5, 3, 4]))\n *\n * @since 2.5.0\n */\nexport function insertAt(i, a) {\n    return function (as) { return (i < 0 || i > as.length ? O.none : O.some(unsafeInsertAt(i, a, as))); };\n}\n/**\n * Change the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { updateAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(updateAt(1, 1)([1, 2, 3]), some([1, 1, 3]))\n * assert.deepStrictEqual(updateAt(1, 1)([]), none)\n *\n * @since 2.5.0\n */\nexport function updateAt(i, a) {\n    return function (as) { return (isOutOfBound(i, as) ? O.none : O.some(unsafeUpdateAt(i, a, as))); };\n}\n/**\n * Delete the element at the specified index, creating a new array, or returning `None` if the index is out of bounds\n *\n * @example\n * import { deleteAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * assert.deepStrictEqual(deleteAt(0)([1, 2, 3]), some([2, 3]))\n * assert.deepStrictEqual(deleteAt(1)([]), none)\n *\n * @since 2.5.0\n */\nexport function deleteAt(i) {\n    return function (as) { return (isOutOfBound(i, as) ? O.none : O.some(unsafeDeleteAt(i, as))); };\n}\n/**\n * Apply a function to the element at the specified index, creating a new array, or returning `None` if the index is out\n * of bounds\n *\n * @example\n * import { modifyAt } from 'fp-ts/ReadonlyArray'\n * import { some, none } from 'fp-ts/Option'\n *\n * const double = (x: number): number => x * 2\n * assert.deepStrictEqual(modifyAt(1, double)([1, 2, 3]), some([1, 4, 3]))\n * assert.deepStrictEqual(modifyAt(1, double)([]), none)\n *\n * @since 2.5.0\n */\nexport function modifyAt(i, f) {\n    return function (as) { return (isOutOfBound(i, as) ? O.none : O.some(unsafeUpdateAt(i, f(as[i]), as))); };\n}\n/**\n * Reverse an array, creating a new array\n *\n * @example\n * import { reverse } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(reverse([1, 2, 3]), [3, 2, 1])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function reverse(as) {\n    if (isEmpty(as)) {\n        return as;\n    }\n    return as.slice().reverse();\n}\n/**\n * Extracts from an array of `Either` all the `Right` elements. All the `Right` elements are extracted in order\n *\n * @example\n * import { rights } from 'fp-ts/ReadonlyArray'\n * import { right, left } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(rights([right(1), left('foo'), right(2)]), [1, 2])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function rights(as) {\n    // tslint:disable-next-line: readonly-array\n    var r = [];\n    var len = as.length;\n    for (var i = 0; i < len; i++) {\n        var a = as[i];\n        if (a._tag === 'Right') {\n            r.push(a.right);\n        }\n    }\n    return r;\n}\n/**\n * Extracts from an array of `Either` all the `Left` elements. All the `Left` elements are extracted in order\n *\n * @example\n * import { lefts } from 'fp-ts/ReadonlyArray'\n * import { left, right } from 'fp-ts/Either'\n *\n * assert.deepStrictEqual(lefts([right(1), left('foo'), right(2)]), ['foo'])\n *\n * @since 2.5.0\n */\nexport function lefts(as) {\n    // tslint:disable-next-line: readonly-array\n    var r = [];\n    var len = as.length;\n    for (var i = 0; i < len; i++) {\n        var a = as[i];\n        if (a._tag === 'Left') {\n            r.push(a.left);\n        }\n    }\n    return r;\n}\n/**\n * Sort the elements of an array in increasing order, creating a new array\n *\n * @example\n * import { sort } from 'fp-ts/ReadonlyArray'\n * import { ordNumber } from 'fp-ts/Ord'\n *\n * assert.deepStrictEqual(sort(ordNumber)([3, 2, 1]), [1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var sort = function (O) { return function (as) {\n    return as.length <= 1 ? as : as.slice().sort(O.compare);\n}; };\n// TODO: curry and make data-last in v3\n/**\n * Apply a function to pairs of elements at the same index in two arrays, collecting the results in a new array. If one\n * input array is short, excess elements of the longer array are discarded.\n *\n * @example\n * import { zipWith } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(zipWith([1, 2, 3], ['a', 'b', 'c', 'd'], (n, s) => s + n), ['a1', 'b2', 'c3'])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function zipWith(fa, fb, f) {\n    // tslint:disable-next-line: readonly-array\n    var fc = [];\n    var len = Math.min(fa.length, fb.length);\n    for (var i = 0; i < len; i++) {\n        fc[i] = f(fa[i], fb[i]);\n    }\n    return fc;\n}\nexport function zip(as, bs) {\n    if (bs === undefined) {\n        return function (bs) { return zip(bs, as); };\n    }\n    return zipWith(as, bs, function (a, b) { return [a, b]; });\n}\n/**\n * The function is reverse of `zip`. Takes an array of pairs and return two corresponding arrays\n *\n * @example\n * import { unzip } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(unzip([[1, 'a'], [2, 'b'], [3, 'c']]), [[1, 2, 3], ['a', 'b', 'c']])\n *\n * @since 2.5.0\n */\nexport function unzip(as) {\n    // tslint:disable-next-line: readonly-array\n    var fa = [];\n    // tslint:disable-next-line: readonly-array\n    var fb = [];\n    for (var i = 0; i < as.length; i++) {\n        fa[i] = as[i][0];\n        fb[i] = as[i][1];\n    }\n    return [fa, fb];\n}\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { prependToAll } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(prependToAll(9)([1, 2, 3, 4]), [9, 1, 9, 2, 9, 3, 9, 4])\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var prependToAll = function (e) { return function (xs) {\n    // tslint:disable-next-line: readonly-array\n    var ys = [];\n    for (var _i = 0, xs_1 = xs; _i < xs_1.length; _i++) {\n        var x = xs_1[_i];\n        ys.push(e, x);\n    }\n    return ys;\n}; };\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { intersperse } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(intersperse(9)([1, 2, 3, 4]), [1, 9, 2, 9, 3, 9, 4])\n *\n * @category combinators\n * @since 2.9.0\n */\nexport function intersperse(e) {\n    return function (as) {\n        var length = as.length;\n        if (length === 0) {\n            return as;\n        }\n        return cons(as[0], prependToAll(e)(as.slice(1, as.length)));\n    };\n}\n/**\n * Rotate an array to the right by `n` steps\n *\n * @example\n * import { rotate } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(rotate(2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function rotate(n) {\n    return function (as) {\n        var len = as.length;\n        if (n === 0 || len <= 1 || len === Math.abs(n)) {\n            return as;\n        }\n        else if (n < 0) {\n            return rotate(len + n)(as);\n        }\n        else {\n            return as.slice(-n).concat(as.slice(0, len - n));\n        }\n    };\n}\nexport function elem(E) {\n    return function (a, as) {\n        if (as === undefined) {\n            var elemE_1 = elem(E);\n            return function (as) { return elemE_1(a, as); };\n        }\n        var predicate = function (element) { return E.equals(element, a); };\n        var i = 0;\n        var len = as.length;\n        for (; i < len; i++) {\n            if (predicate(as[i])) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\n/**\n * Remove duplicates from an array, keeping the first occurrence of an element.\n *\n * @example\n * import { uniq } from 'fp-ts/ReadonlyArray'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * assert.deepStrictEqual(uniq(eqNumber)([1, 2, 1]), [1, 2])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function uniq(E) {\n    var elemS = elem(E);\n    return function (as) {\n        var len = as.length;\n        if (len <= 1) {\n            return as;\n        }\n        // tslint:disable-next-line: readonly-array\n        var r = [];\n        var i = 0;\n        for (; i < len; i++) {\n            var a = as[i];\n            if (!elemS(a, r)) {\n                r.push(a);\n            }\n        }\n        return len === r.length ? as : r;\n    };\n}\n/**\n * Sort the elements of an array in increasing order, where elements are compared using first `ords[0]`, then `ords[1]`,\n * etc...\n *\n * @example\n * import { sortBy } from 'fp-ts/ReadonlyArray'\n * import { ord, ordString, ordNumber } from 'fp-ts/Ord'\n *\n * interface Person {\n *   name: string\n *   age: number\n * }\n * const byName = ord.contramap(ordString, (p: Person) => p.name)\n * const byAge = ord.contramap(ordNumber, (p: Person) => p.age)\n *\n * const sortByNameByAge = sortBy([byName, byAge])\n *\n * const persons = [{ name: 'a', age: 1 }, { name: 'b', age: 3 }, { name: 'c', age: 2 }, { name: 'b', age: 2 }]\n * assert.deepStrictEqual(sortByNameByAge(persons), [\n *   { name: 'a', age: 1 },\n *   { name: 'b', age: 2 },\n *   { name: 'b', age: 3 },\n *   { name: 'c', age: 2 }\n * ])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function sortBy(ords) {\n    var M = getOrdMonoid();\n    return sort(ords.reduce(M.concat, M.empty));\n}\n/**\n * A useful recursion pattern for processing an array to produce a new array, often used for \"chopping\" up the input\n * array. Typically chop is called with some function that will consume an initial prefix of the array and produce a\n * value and the rest of the array.\n *\n * @example\n * import { Eq, eqNumber } from 'fp-ts/Eq'\n * import { chop, spanLeft } from 'fp-ts/ReadonlyArray'\n *\n * const group = <A>(S: Eq<A>): ((as: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<A>>) => {\n *   return chop(as => {\n *     const { init, rest } = spanLeft((a: A) => S.equals(a, as[0]))(as)\n *     return [init, rest]\n *   })\n * }\n * assert.deepStrictEqual(group(eqNumber)([1, 1, 2, 3, 3, 4]), [[1, 1], [2], [3, 3], [4]])\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var chop = function (f) { return function (as) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    var cs = as;\n    while (isNonEmpty(cs)) {\n        var _a = f(cs), b = _a[0], c = _a[1];\n        result.push(b);\n        cs = c;\n    }\n    return result;\n}; };\n/**\n * Splits an array into two pieces, the first piece has `n` elements.\n *\n * @example\n * import { splitAt } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(splitAt(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4, 5]])\n *\n * @since 2.5.0\n */\nexport function splitAt(n) {\n    return function (as) { return [as.slice(0, n), as.slice(n)]; };\n}\n/**\n * Splits an array into length-`n` pieces. The last piece will be shorter if `n` does not evenly divide the length of\n * the array. Note that `chunksOf(n)([])` is `[]`, not `[[]]`. This is intentional, and is consistent with a recursive\n * definition of `chunksOf`; it satisfies the property that\n *\n * ```ts\n * chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))\n * ```\n *\n * whenever `n` evenly divides the length of `xs`.\n *\n * @example\n * import { chunksOf } from 'fp-ts/ReadonlyArray'\n *\n * assert.deepStrictEqual(chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])\n *\n *\n * @since 2.5.0\n */\nexport function chunksOf(n) {\n    var f = chop(splitAt(n));\n    return function (as) { return (as.length === 0 ? empty : isOutOfBound(n - 1, as) ? [as] : f(as)); };\n}\nexport function comprehension(input, f, g) {\n    if (g === void 0) { g = function () { return true; }; }\n    var go = function (scope, input) {\n        if (input.length === 0) {\n            return g.apply(void 0, scope) ? [f.apply(void 0, scope)] : empty;\n        }\n        else {\n            return chain_(input[0], function (x) { return go(snoc(scope, x), input.slice(1)); });\n        }\n    };\n    return go(empty, input);\n}\nexport function union(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var unionE_1 = union(E);\n            return function (ys) { return unionE_1(ys, xs); };\n        }\n        return concat(xs, ys.filter(function (a) { return !elemE(a, xs); }));\n    };\n}\nexport function intersection(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var intersectionE_1 = intersection(E);\n            return function (ys) { return intersectionE_1(ys, xs); };\n        }\n        return xs.filter(function (a) { return elemE(a, ys); });\n    };\n}\nexport function difference(E) {\n    var elemE = elem(E);\n    return function (xs, ys) {\n        if (ys === undefined) {\n            var differenceE_1 = difference(E);\n            return function (ys) { return differenceE_1(ys, xs); };\n        }\n        return xs.filter(function (a) { return !elemE(a, ys); });\n    };\n}\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.5.0\n */\nexport var of = function (a) { return [a]; };\n/**\n * @category Alternative\n * @since 2.7.0\n */\nexport var zero = function () { return empty; };\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\nvar mapWithIndex_ = function (fa, f) { return pipe(fa, mapWithIndex(f)); };\nvar ap_ = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar chain_ = function (ma, f) {\n    return pipe(ma, chain(f));\n};\nvar filter_ = function (fa, predicate) { return pipe(fa, filter(predicate)); };\nvar filterMap_ = function (fa, f) { return pipe(fa, filterMap(f)); };\nvar partitionWithIndex_ = function (fa, predicateWithIndex) { return pipe(fa, partitionWithIndex(predicateWithIndex)); };\nvar partition_ = function (fa, predicate) { return pipe(fa, partition(predicate)); };\nvar partitionMap_ = function (fa, f) { return pipe(fa, partitionMap(f)); };\nvar partitionMapWithIndex_ = function (fa, f) { return pipe(fa, partitionMapWithIndex(f)); };\nvar alt_ = function (fa, that) { return pipe(fa, alt(that)); };\nvar reduce_ = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\nvar foldMap_ = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\nvar reduceRight_ = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\nvar reduceWithIndex_ = function (fa, b, f) {\n    var l = fa.length;\n    var r = b;\n    for (var i = 0; i < l; i++) {\n        r = f(i, r, fa[i]);\n    }\n    return r;\n};\nvar foldMapWithIndex_ = function (M) { return function (fa, f) {\n    return fa.reduce(function (b, a, i) { return M.concat(b, f(i, a)); }, M.empty);\n}; };\nvar reduceRightWithIndex_ = function (fa, b, f) {\n    return pipe(fa, reduceRightWithIndex(b, f));\n};\nvar filterMapWithIndex_ = function (fa, f) {\n    return pipe(fa, filterMapWithIndex(f));\n};\nvar filterWithIndex_ = function (fa, predicateWithIndex) { return pipe(fa, filterWithIndex(predicateWithIndex)); };\nvar extend_ = function (fa, f) { return pipe(fa, extend(f)); };\nvar traverse_ = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar traverseWithIndex_ = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (ta, f) { return pipe(ta, traverseWithIndexF(f)); };\n};\n/* istanbul ignore next */\nvar wither_ = function (F) {\n    var witherF = wither(F);\n    return function (fa, f) { return pipe(fa, witherF(f)); };\n};\n/* istanbul ignore next */\nvar wilt_ = function (F) {\n    var wiltF = wilt(F);\n    return function (fa, f) { return pipe(fa, wiltF(f)); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = function (that) { return function (fa) { return concat(fa, that()); }; };\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * @category Alt\n * @since 2.5.0\n */\nexport var alt = altW;\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.5.0\n */\nexport var ap = function (fa) {\n    return chain(function (f) { return pipe(fa, map(f)); });\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.5.0\n */\nexport var chain = function (f) { return function (ma) {\n    return pipe(ma, chainWithIndex(function (_, a) { return f(a); }));\n}; };\n/**\n * @since 2.7.0\n */\nexport var chainWithIndex = function (f) { return function (ma) {\n    var outLen = 0;\n    var l = ma.length;\n    var temp = new Array(l);\n    for (var i = 0; i < l; i++) {\n        var e = ma[i];\n        var arr = f(i, e);\n        outLen += arr.length;\n        temp[i] = arr;\n    }\n    var out = Array(outLen);\n    var start = 0;\n    for (var i = 0; i < l; i++) {\n        var arr = temp[i];\n        var l_1 = arr.length;\n        for (var j = 0; j < l_1; j++) {\n            out[j + start] = arr[j];\n        }\n        start += l_1;\n    }\n    return out;\n}; };\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var chainFirst = function (f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\n};\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.5.0\n */\nexport var map = function (f) { return function (fa) {\n    return fa.map(function (a) { return f(a); });\n}; };\n/**\n * @category FunctorWithIndex\n * @since 2.5.0\n */\nexport var mapWithIndex = function (f) { return function (fa) { return fa.map(function (a, i) { return f(i, a); }); }; };\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexport var separate = function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var left = [];\n    // tslint:disable-next-line: readonly-array\n    var right = [];\n    for (var _i = 0, fa_1 = fa; _i < fa_1.length; _i++) {\n        var e = fa_1[_i];\n        if (e._tag === 'Left') {\n            left.push(e.left);\n        }\n        else {\n            right.push(e.right);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n};\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var filter = function (predicate) { return function (fa) { return fa.filter(predicate); }; };\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nexport var filterMapWithIndex = function (f) { return function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var result = [];\n    for (var i = 0; i < fa.length; i++) {\n        var optionB = f(i, fa[i]);\n        if (O.isSome(optionB)) {\n            result.push(optionB.value);\n        }\n    }\n    return result;\n}; };\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var filterMap = function (f) {\n    return filterMapWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexport var compact = \n/*#__PURE__*/\nfilterMap(identity);\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var partition = function (predicate) {\n    return partitionWithIndex(function (_, a) { return predicate(a); });\n};\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nexport var partitionWithIndex = function (predicateWithIndex) { return function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var left = [];\n    // tslint:disable-next-line: readonly-array\n    var right = [];\n    for (var i = 0; i < fa.length; i++) {\n        var a = fa[i];\n        if (predicateWithIndex(i, a)) {\n            right.push(a);\n        }\n        else {\n            left.push(a);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n}; };\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var partitionMap = function (f) {\n    return partitionMapWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nexport var partitionMapWithIndex = function (f) { return function (fa) {\n    // tslint:disable-next-line: readonly-array\n    var left = [];\n    // tslint:disable-next-line: readonly-array\n    var right = [];\n    for (var i = 0; i < fa.length; i++) {\n        var e = f(i, fa[i]);\n        if (e._tag === 'Left') {\n            left.push(e.left);\n        }\n        else {\n            right.push(e.right);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n}; };\n/**\n * @category FilterableWithIndex\n * @since 2.5.0\n */\nexport var filterWithIndex = function (predicateWithIndex) { return function (fa) {\n    return fa.filter(function (a, i) { return predicateWithIndex(i, a); });\n}; };\n/**\n * @category Extend\n * @since 2.5.0\n */\nexport var extend = function (f) { return function (wa) { return wa.map(function (_, i, as) { return f(as.slice(i)); }); }; };\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var duplicate = \n/*#__PURE__*/\nextend(identity);\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexport var foldMapWithIndex = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex_(M);\n    return function (f) { return function (fa) { return foldMapWithIndexM(fa, f); }; };\n};\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduce = function (b, f) {\n    return reduceWithIndex(b, function (_, b, a) { return f(b, a); });\n};\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var foldMap = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex(M);\n    return function (f) { return foldMapWithIndexM(function (_, a) { return f(a); }); };\n};\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexport var reduceWithIndex = function (b, f) { return function (fa) { return reduceWithIndex_(fa, b, f); }; };\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) {\n    return reduceRightWithIndex(b, function (_, a, b) { return f(a, b); });\n};\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexport var reduceRightWithIndex = function (b, f) { return function (fa) { return fa.reduceRight(function (b, a, i) { return f(i, a, b); }, b); }; };\n/**\n * **for optimized and stack safe version check the data types `traverseArray` function**\n * @category Traversable\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };\n};\n/**\n * **for optimized and stack safe version check the data types `sequenceArray` function**\n * @category Traversable\n * @since 2.6.3\n */\nexport var sequence = function (F) { return function (ta) {\n    return reduce_(ta, F.of(zero()), function (fas, fa) {\n        return F.ap(F.map(fas, function (as) { return function (a) { return snoc(as, a); }; }), fa);\n    });\n}; };\n/**\n * **for optimized and stack safe version check the data types `traverseArrayWithIndex` function**\n * @category TraversableWithIndex\n * @since 2.6.3\n */\nexport var traverseWithIndex = function (F) { return function (f) {\n    return reduceWithIndex(F.of(zero()), function (i, fbs, a) {\n        return F.ap(F.map(fbs, function (bs) { return function (b) { return snoc(bs, b); }; }), f(i, a));\n    });\n}; };\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wither = function (F) {\n    var traverseF = traverse(F);\n    return function (f) { return function (fa) { return F.map(pipe(fa, traverseF(f)), compact); }; };\n};\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n    var traverseF = traverse(F);\n    return function (f) { return function (fa) { return F.map(pipe(fa, traverseF(f)), separate); }; };\n};\n/**\n * @category Unfoldable\n * @since 2.6.6\n */\nexport var unfold = function (b, f) {\n    // tslint:disable-next-line: readonly-array\n    var ret = [];\n    var bb = b;\n    while (true) {\n        var mt = f(bb);\n        if (O.isSome(mt)) {\n            var _a = mt.value, a = _a[0], b_1 = _a[1];\n            ret.push(a);\n            bb = b_1;\n        }\n        else {\n            break;\n        }\n    }\n    return ret;\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyArray';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Unfoldable = {\n    URI: URI,\n    unfold: unfold\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alternative = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    alt: alt_,\n    zero: zero\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Extend = {\n    URI: URI,\n    map: map_,\n    extend: extend_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverse: traverse_,\n    sequence: sequence,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    wither: wither_,\n    wilt: wilt_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var readonlyArray = {\n    URI: URI,\n    compact: compact,\n    separate: separate,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    mapWithIndex: mapWithIndex_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_,\n    alt: alt_,\n    zero: zero,\n    unfold: unfold,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    extend: extend_,\n    wither: wither_,\n    wilt: wilt_\n};\n// -------------------------------------------------------------------------------------\n// unsafe\n// -------------------------------------------------------------------------------------\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport function unsafeInsertAt(i, a, as) {\n    var xs = as.slice();\n    xs.splice(i, 0, a);\n    return xs;\n}\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport function unsafeUpdateAt(i, a, as) {\n    if (as[i] === a) {\n        return as;\n    }\n    else {\n        var xs = as.slice();\n        xs[i] = a;\n        return xs;\n    }\n}\n/**\n * @category unsafe\n * @since 2.5.0\n */\nexport function unsafeDeleteAt(i, as) {\n    var xs = as.slice();\n    xs.splice(i, 1);\n    return xs;\n}\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * An empty array\n *\n * @since 2.5.0\n */\nexport var empty = [];\n/**\n * Check if a predicate holds true for every array member.\n *\n * @example\n * import { every } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const isPositive = (n: number): boolean => n > 0\n *\n * assert.deepStrictEqual(pipe([1, 2, 3], every(isPositive)), true)\n * assert.deepStrictEqual(pipe([1, 2, -3], every(isPositive)), false)\n *\n * @since 2.9.0\n */\nexport var every = function (predicate) { return function (as) { return as.every(predicate); }; };\n/**\n * Check if a predicate holds true for any array member.\n *\n * @example\n * import { some } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n *\n * const isPositive = (n: number): boolean => n > 0\n *\n * assert.deepStrictEqual(pipe([-1, -2, 3], some(isPositive)), true)\n * assert.deepStrictEqual(pipe([-1, -2, -3], some(isPositive)), false)\n *\n * @since 2.9.0\n */\nexport var some = function (predicate) { return function (as) { return as.some(predicate); }; };\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) {\n    return map(bindTo_(name));\n};\n/**\n * @since 2.8.0\n */\nexport var bind = function (name, f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), ap(fb));\n};\n","import * as RR from './ReadonlyRecord';\n/* tslint:disable:readonly-array */\n// -------------------------------------------------------------------------------------\n// model\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.0.0\n */\nexport var getShow = RR.getShow;\n/**\n * Calculate the number of key/value pairs in a record\n *\n * @since 2.0.0\n */\nexport var size = RR.size;\n/**\n * Test whether a record is empty\n *\n * @since 2.0.0\n */\nexport var isEmpty = RR.isEmpty;\n/**\n * @since 2.0.0\n */\nexport var keys = RR.keys;\n/**\n * Map a record into an array\n *\n * @example\n * import {collect} from 'fp-ts/Record'\n *\n * const x: { a: string, b: boolean } = { a: 'foo', b: false }\n * assert.deepStrictEqual(\n *   collect((key, val) => ({key: key, value: val}))(x),\n *   [{key: 'a', value: 'foo'}, {key: 'b', value: false}]\n * )\n *\n * @since 2.0.0\n */\nexport var collect = RR.collect;\n/**\n * @since 2.0.0\n */\nexport var toArray = RR.toReadonlyArray;\nexport function toUnfoldable(U) {\n    return RR.toUnfoldable(U);\n}\nexport function insertAt(k, a) {\n    return RR.insertAt(k, a);\n}\n/**\n * @since 2.0.0\n */\nexport var hasOwnProperty = RR.hasOwnProperty;\nexport function deleteAt(k) {\n    return RR.deleteAt(k);\n}\n/**\n * @since 2.0.0\n */\nexport var updateAt = RR.updateAt;\n/**\n * @since 2.0.0\n */\nexport var modifyAt = RR.modifyAt;\nexport function pop(k) {\n    return RR.pop(k);\n}\n// TODO: remove non-curried overloading in v3\n/**\n * Test whether one record contains all of the keys and values contained in another record\n *\n * @since 2.0.0\n */\nexport var isSubrecord = RR.isSubrecord;\nexport function getEq(E) {\n    return RR.getEq(E);\n}\nexport function getMonoid(S) {\n    return RR.getMonoid(S);\n}\n// TODO: remove non-curried overloading in v3\n/**\n * Lookup the value for a key in a record\n *\n * @since 2.0.0\n */\nexport var lookup = RR.lookup;\n/**\n * @since 2.0.0\n */\nexport var empty = {};\nexport function mapWithIndex(f) {\n    return RR.mapWithIndex(f);\n}\nexport function map(f) {\n    return RR.map(f);\n}\nexport function reduceWithIndex(b, f) {\n    return RR.reduceWithIndex(b, f);\n}\nexport function foldMapWithIndex(M) {\n    return RR.foldMapWithIndex(M);\n}\nexport function reduceRightWithIndex(b, f) {\n    return RR.reduceRightWithIndex(b, f);\n}\n/**\n * Create a record with one key/value pair\n *\n * @since 2.0.0\n */\nexport var singleton = RR.singleton;\nexport function traverseWithIndex(F) {\n    return RR.traverseWithIndex(F);\n}\nexport function traverse(F) {\n    return RR.traverse(F);\n}\nexport function sequence(F) {\n    return RR.sequence(F);\n}\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wither = RR.wither;\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wilt = RR.wilt;\nexport function partitionMapWithIndex(f) {\n    return RR.partitionMapWithIndex(f);\n}\nexport function partitionWithIndex(predicateWithIndex) {\n    return RR.partitionWithIndex(predicateWithIndex);\n}\nexport function filterMapWithIndex(f) {\n    return RR.filterMapWithIndex(f);\n}\nexport function filterWithIndex(predicateWithIndex) {\n    return RR.filterWithIndex(predicateWithIndex);\n}\nexport function fromFoldable(M, F) {\n    return RR.fromFoldable(M, F);\n}\nexport function fromFoldableMap(M, F) {\n    return RR.fromFoldableMap(M, F);\n}\n/**\n * @since 2.0.0\n */\nexport var every = RR.every;\n/**\n * @since 2.0.0\n */\nexport var some = RR.some;\n// TODO: remove non-curried overloading in v3\n/**\n * @since 2.0.0\n */\nexport var elem = RR.elem;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = RR.Functor.map;\nvar mapWithIndex_ = RR.FunctorWithIndex.mapWithIndex;\nvar reduce_ = RR.Foldable.reduce;\nvar foldMap_ = RR.Foldable.foldMap;\nvar reduceRight_ = RR.Foldable.reduceRight;\nvar reduceWithIndex_ = RR.FoldableWithIndex.reduceWithIndex;\nvar foldMapWithIndex_ = RR.FoldableWithIndex.foldMapWithIndex;\nvar reduceRightWithIndex_ = RR.FoldableWithIndex.reduceRightWithIndex;\nvar filter_ = RR.Filterable.filter;\nvar filterMap_ = RR.Filterable.filterMap;\nvar partition_ = RR.Filterable.partition;\nvar partitionMap_ = RR.Filterable.partitionMap;\nvar filterWithIndex_ = RR.FilterableWithIndex\n    .filterWithIndex;\nvar filterMapWithIndex_ = RR.FilterableWithIndex.filterMapWithIndex;\nvar partitionWithIndex_ = RR.FilterableWithIndex\n    .partitionWithIndex;\nvar partitionMapWithIndex_ = RR.FilterableWithIndex.partitionMapWithIndex;\nvar traverseWithIndex_ = RR.TraversableWithIndex\n    .traverseWithIndex;\nvar wither_ = RR.Witherable.wither;\nvar wilt_ = RR.Witherable.wilt;\nvar traverse_ = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return traverseF(f)(ta); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filter = RR.filter;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var filterMap = RR.filterMap;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var foldMap = RR.foldMap;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partition = RR.partition;\n/**\n * @category Filterable\n * @since 2.0.0\n */\nexport var partitionMap = RR.partitionMap;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduce = RR.reduce;\n/**\n * @category Foldable\n * @since 2.0.0\n */\nexport var reduceRight = RR.reduceRight;\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var compact = RR.compact;\n/**\n * @category Compactable\n * @since 2.0.0\n */\nexport var separate = RR.separate;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Record';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverse: traverse_,\n    sequence: sequence,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    wither: wither_,\n    wilt: wilt_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var record = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    mapWithIndex: mapWithIndex_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    wither: wither_,\n    wilt: wilt_\n};\n","import { pipe, bind_, bindTo_, flow } from './function';\nimport { none, some } from './Option';\nimport * as RA from './ReadonlyArray';\nimport { getJoinSemigroup, getMeetSemigroup } from './Semigroup';\n/**\n * Append an element to the front of an array, creating a new non empty array\n *\n * @example\n * import { cons } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(cons(1, [2, 3, 4]), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport var cons = RA.cons;\n/**\n * Append an element to the end of an array, creating a new non empty array\n *\n * @example\n * import { snoc } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(snoc([1, 2, 3], 4), [1, 2, 3, 4])\n *\n * @category constructors\n * @since 2.5.0\n */\nexport var snoc = RA.snoc;\n/**\n * Builds a `ReadonlyNonEmptyArray` from an array returning `none` if `as` is an empty array\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function fromReadonlyArray(as) {\n    return RA.isNonEmpty(as) ? some(as) : none;\n}\n/**\n * @category constructors\n * @since 2.5.0\n */\n// tslint:disable-next-line: readonly-array\nexport function fromArray(as) {\n    return fromReadonlyArray(RA.fromArray(as));\n}\n/**\n * Produces a couple of the first element of the array, and a new array of the remaining elements, if any\n *\n * @example\n * import { cons, uncons } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(uncons(cons(1, [2, 3, 4])), [1, [2, 3, 4]])\n *\n * @category destructors\n * @since 2.9.0\n */\nexport function uncons(nea) {\n    return [nea[0], nea.slice(1)];\n}\n/**\n * Produces a couple of a copy of the array without its last element, and that last element\n *\n * @example\n * import { snoc, unsnoc } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(unsnoc(snoc([1, 2, 3], 4)), [[1, 2, 3], 4])\n *\n * @category destructors\n * @since 2.9.0\n */\nexport function unsnoc(nea) {\n    var l = nea.length - 1;\n    return [nea.slice(0, l), nea[l]];\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var getShow = RA.getShow;\n/**\n * @since 2.5.0\n */\nexport function head(nea) {\n    return nea[0];\n}\n/**\n * @since 2.5.0\n */\nexport function tail(nea) {\n    return nea.slice(1);\n}\n/**\n * @category combinators\n * @since 2.5.0\n */\nexport var reverse = RA.reverse;\n/**\n * @since 2.5.0\n */\nexport function min(ord) {\n    var S = getMeetSemigroup(ord);\n    return function (nea) { return nea.reduce(S.concat); };\n}\n/**\n * @since 2.5.0\n */\nexport function max(ord) {\n    var S = getJoinSemigroup(ord);\n    return function (nea) { return nea.reduce(S.concat); };\n}\n/**\n * Builds a `Semigroup` instance for `ReadonlyNonEmptyArray`\n *\n * @category instances\n * @since 2.5.0\n */\nexport function getSemigroup() {\n    return {\n        concat: concat\n    };\n}\n/**\n * @example\n * import { getEq, cons } from 'fp-ts/ReadonlyNonEmptyArray'\n * import { eqNumber } from 'fp-ts/Eq'\n *\n * const E = getEq(eqNumber)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 2]), true)\n * assert.strictEqual(E.equals(cons(1, [2]), [1, 3]), false)\n *\n * @category instances\n * @since 2.5.0\n */\nexport var getEq = RA.getEq;\nexport function group(E) {\n    return function (as) {\n        var len = as.length;\n        if (len === 0) {\n            return RA.empty;\n        }\n        // tslint:disable-next-line: readonly-array\n        var r = [];\n        var head = as[0];\n        var nea = [head];\n        for (var i = 1; i < len; i++) {\n            var x = as[i];\n            if (E.equals(x, head)) {\n                nea.push(x);\n            }\n            else {\n                r.push(nea);\n                head = x;\n                nea = [head];\n            }\n        }\n        r.push(nea);\n        return r;\n    };\n}\nexport function groupSort(O) {\n    var sortO = RA.sort(O);\n    var groupO = group(O);\n    return function (as) { return groupO(sortO(as)); };\n}\n/**\n * Splits an array into sub-non-empty-arrays stored in an object, based on the result of calling a `string`-returning\n * function on each element, and grouping the results according to values returned\n *\n * @example\n * import { cons, groupBy } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(groupBy((s: string) => String(s.length))(['foo', 'bar', 'foobar']), {\n *   '3': cons('foo', ['bar']),\n *   '6': cons('foobar', [])\n * })\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function groupBy(f) {\n    return function (as) {\n        var r = {};\n        for (var _i = 0, as_1 = as; _i < as_1.length; _i++) {\n            var a = as_1[_i];\n            var k = f(a);\n            if (r.hasOwnProperty(k)) {\n                r[k].push(a);\n            }\n            else {\n                r[k] = [a];\n            }\n        }\n        return r;\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function last(nea) {\n    return nea[nea.length - 1];\n}\n/**\n * Get all but the last element of a non empty array, creating a new array.\n *\n * @example\n * import { init } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(init([1, 2, 3]), [1, 2])\n * assert.deepStrictEqual(init([1]), [])\n *\n * @since 2.5.0\n */\nexport function init(nea) {\n    return nea.slice(0, -1);\n}\n/**\n * @category combinators\n * @since 2.5.0\n */\nexport function sort(O) {\n    return RA.sort(O);\n}\n/**\n * @since 2.5.0\n */\nexport function insertAt(i, a) {\n    return RA.insertAt(i, a);\n}\n/**\n * @since 2.5.0\n */\nexport function updateAt(i, a) {\n    return RA.updateAt(i, a);\n}\n/**\n * @since 2.5.0\n */\nexport function modifyAt(i, f) {\n    return RA.modifyAt(i, f);\n}\nexport function filter(predicate) {\n    return filterWithIndex(function (_, a) { return predicate(a); });\n}\n/**\n * @since 2.5.0\n */\nexport function filterWithIndex(predicate) {\n    return function (nea) { return fromReadonlyArray(nea.filter(function (a, i) { return predicate(i, a); })); };\n}\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.5.0\n */\nexport var of = RA.of;\nexport function concat(fx, fy) {\n    return fx.concat(fy);\n}\n/**\n * @since 2.5.0\n */\nexport function fold(S) {\n    return function (fa) { return fa.reduce(S.concat); };\n}\n/**\n * @category combinators\n * @since 2.5.1\n */\nexport var zipWith = RA.zipWith;\n/**\n * @category combinators\n * @since 2.5.1\n */\nexport var zip = RA.zip;\n/**\n * @since 2.5.1\n */\nexport var unzip = RA.unzip;\n/**\n * Prepend an element to every member of an array\n *\n * @example\n * import { cons, prependToAll } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(prependToAll(9)(cons(1, [2, 3, 4])), cons(9, [1, 9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var prependToAll = RA.prependToAll;\n/**\n * Places an element in between members of an array\n *\n * @example\n * import { cons, intersperse } from 'fp-ts/ReadonlyNonEmptyArray'\n *\n * assert.deepStrictEqual(intersperse(9)(cons(1, [2, 3, 4])), cons(1, [9, 2, 9, 3, 9, 4]))\n *\n * @category combinators\n * @since 2.9.0\n */\nexport var intersperse = RA.intersperse;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = RA.Functor.map;\nvar mapWithIndex_ = RA.FunctorWithIndex.mapWithIndex;\nvar ap_ = RA.Applicative.ap;\nvar chain_ = RA.Monad.chain;\nvar extend_ = RA.Extend.extend;\nvar reduce_ = RA.Foldable.reduce;\nvar foldMap_ = RA.Foldable.foldMap;\nvar reduceRight_ = RA.Foldable.reduceRight;\nvar traverse_ = RA.Traversable.traverse;\nvar alt_ = RA.Alt.alt;\nvar reduceWithIndex_ = RA.FoldableWithIndex.reduceWithIndex;\nvar foldMapWithIndex_ = RA.FoldableWithIndex\n    .foldMapWithIndex;\nvar reduceRightWithIndex_ = RA.FoldableWithIndex\n    .reduceRightWithIndex;\nvar traverseWithIndex_ = RA.TraversableWithIndex\n    .traverseWithIndex;\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexport var foldMapWithIndex = function (S) { return function (f) { return function (fa) { return fa.slice(1).reduce(function (s, a, i) { return S.concat(s, f(i + 1, a)); }, f(0, fa[0])); }; }; };\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var foldMap = function (S) { return function (f) { return function (fa) {\n    return fa.slice(1).reduce(function (s, a) { return S.concat(s, f(a)); }, f(fa[0]));\n}; }; };\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = RA.altW;\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * @category Alt\n * @since 2.6.2\n */\nexport var alt = RA.alt;\n/**\n * @category Apply\n * @since 2.5.0\n */\nexport var ap = RA.ap;\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var apFirst = RA.apFirst;\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var apSecond = RA.apSecond;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.5.0\n */\nexport var chain = RA.chain;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var chainFirst = RA.chainFirst;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var duplicate = RA.duplicate;\n/**\n * @category Extend\n * @since 2.5.0\n */\nexport var extend = RA.extend;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var flatten = RA.flatten;\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.5.0\n */\nexport var map = RA.map;\n/**\n * @category FunctorWithIndex\n * @since 2.5.0\n */\nexport var mapWithIndex = RA.mapWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduce = RA.reduce;\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexport var reduceWithIndex = RA.reduceWithIndex;\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduceRight = RA.reduceRight;\n/**\n * @category FoldableWithIndex\n * @since 2.5.0\n */\nexport var reduceRightWithIndex = RA.reduceRightWithIndex;\n/**\n * @since 2.6.3\n */\nexport var traverse = RA.traverse;\n/**\n * @since 2.6.3\n */\nexport var sequence = RA.sequence;\n/**\n * @since 2.6.3\n */\nexport var traverseWithIndex = RA.traverseWithIndex;\n/**\n * @since 2.6.3\n */\nexport var extract = head;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyNonEmptyArray';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    ap: ap_,\n    of: of,\n    chain: chain_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: map_,\n    alt: alt_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Comonad = {\n    URI: URI,\n    map: map_,\n    extend: extend_,\n    extract: extract\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var readonlyNonEmptyArray = {\n    URI: URI,\n    of: of,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    ap: ap_,\n    chain: chain_,\n    extend: extend_,\n    extract: extract,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    alt: alt_\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) { return map(bindTo_(name)); };\n/**\n * @since 2.8.0\n */\nexport var bind = function (name, f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), ap(fb));\n};\n","import { fromEquals } from './Eq';\nimport { identity, pipe } from './function';\nimport { isNone, isSome, none, some as optionSome } from './Option';\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport function fromRecord(r) {\n    return Object.assign({}, r);\n}\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport function toRecord(r) {\n    return Object.assign({}, r);\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getShow(S) {\n    return {\n        show: function (r) {\n            var elements = collect(function (k, a) { return JSON.stringify(k) + \": \" + S.show(a); })(r).join(', ');\n            return elements === '' ? '{}' : \"{ \" + elements + \" }\";\n        }\n    };\n}\n/**\n * Calculate the number of key/value pairs in a record\n *\n * @since 2.5.0\n */\nexport function size(r) {\n    return Object.keys(r).length;\n}\n/**\n * Test whether a record is empty\n *\n * @since 2.5.0\n */\nexport function isEmpty(r) {\n    return Object.keys(r).length === 0;\n}\n/**\n * @since 2.5.0\n */\nexport function keys(r) {\n    return Object.keys(r).sort();\n}\n/**\n * Map a record into an array\n *\n * @example\n * import {collect} from 'fp-ts/ReadonlyRecord'\n *\n * const x: { a: string, b: boolean } = { a: 'foo', b: false }\n * assert.deepStrictEqual(\n *   collect((key, val) => ({key: key, value: val}))(x),\n *   [{key: 'a', value: 'foo'}, {key: 'b', value: false}]\n * )\n *\n * @since 2.5.0\n */\nexport function collect(f) {\n    return function (r) {\n        // tslint:disable-next-line: readonly-array\n        var out = [];\n        for (var _i = 0, _a = keys(r); _i < _a.length; _i++) {\n            var key = _a[_i];\n            out.push(f(key, r[key]));\n        }\n        return out;\n    };\n}\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport var toReadonlyArray = \n/*#__PURE__*/\ncollect(function (k, a) { return [k, a]; });\nexport function toUnfoldable(U) {\n    return function (r) {\n        var arr = toReadonlyArray(r);\n        var len = arr.length;\n        return U.unfold(0, function (b) { return (b < len ? optionSome([arr[b], b + 1]) : none); });\n    };\n}\nexport function insertAt(k, a) {\n    return function (r) {\n        if (r[k] === a) {\n            return r;\n        }\n        var out = Object.assign({}, r);\n        out[k] = a;\n        return out;\n    };\n}\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function hasOwnProperty(k, r) {\n    return _hasOwnProperty.call(r === undefined ? this : r, k);\n}\nexport function deleteAt(k) {\n    return function (r) {\n        if (!_hasOwnProperty.call(r, k)) {\n            return r;\n        }\n        var out = Object.assign({}, r);\n        delete out[k];\n        return out;\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function updateAt(k, a) {\n    return function (r) {\n        if (!hasOwnProperty(k, r)) {\n            return none;\n        }\n        if (r[k] === a) {\n            return optionSome(r);\n        }\n        var out = Object.assign({}, r);\n        out[k] = a;\n        return optionSome(out);\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function modifyAt(k, f) {\n    return function (r) {\n        if (!hasOwnProperty(k, r)) {\n            return none;\n        }\n        var out = Object.assign({}, r);\n        out[k] = f(r[k]);\n        return optionSome(out);\n    };\n}\nexport function pop(k) {\n    var deleteAtk = deleteAt(k);\n    return function (r) {\n        var oa = lookup(k, r);\n        return isNone(oa) ? none : optionSome([oa.value, deleteAtk(r)]);\n    };\n}\nexport function isSubrecord(E) {\n    return function (me, that) {\n        if (that === undefined) {\n            var isSubrecordE_1 = isSubrecord(E);\n            return function (that) { return isSubrecordE_1(that, me); };\n        }\n        for (var k in me) {\n            if (!_hasOwnProperty.call(that, k) || !E.equals(me[k], that[k])) {\n                return false;\n            }\n        }\n        return true;\n    };\n}\nexport function getEq(E) {\n    var isSubrecordE = isSubrecord(E);\n    return fromEquals(function (x, y) { return isSubrecordE(x)(y) && isSubrecordE(y)(x); });\n}\nexport function getMonoid(S) {\n    return {\n        concat: function (x, y) {\n            if (x === empty) {\n                return y;\n            }\n            if (y === empty) {\n                return x;\n            }\n            var keys = Object.keys(y);\n            var len = keys.length;\n            if (len === 0) {\n                return x;\n            }\n            var r = Object.assign({}, x);\n            for (var i = 0; i < len; i++) {\n                var k = keys[i];\n                r[k] = _hasOwnProperty.call(x, k) ? S.concat(x[k], y[k]) : y[k];\n            }\n            return r;\n        },\n        empty: empty\n    };\n}\nexport function lookup(k, r) {\n    if (r === undefined) {\n        return function (r) { return lookup(k, r); };\n    }\n    return _hasOwnProperty.call(r, k) ? optionSome(r[k]) : none;\n}\n/**\n * @since 2.5.0\n */\nexport var empty = {};\nexport function mapWithIndex(f) {\n    return function (fa) {\n        var out = {};\n        var keys = Object.keys(fa);\n        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n            var key = keys_1[_i];\n            out[key] = f(key, fa[key]);\n        }\n        return out;\n    };\n}\nexport function map(f) {\n    return mapWithIndex(function (_, a) { return f(a); });\n}\nexport function reduceWithIndex(b, f) {\n    return function (fa) {\n        var out = b;\n        var ks = keys(fa);\n        var len = ks.length;\n        for (var i = 0; i < len; i++) {\n            var k = ks[i];\n            out = f(k, out, fa[k]);\n        }\n        return out;\n    };\n}\nexport function foldMapWithIndex(M) {\n    return function (f) { return function (fa) {\n        var out = M.empty;\n        var ks = keys(fa);\n        var len = ks.length;\n        for (var i = 0; i < len; i++) {\n            var k = ks[i];\n            out = M.concat(out, f(k, fa[k]));\n        }\n        return out;\n    }; };\n}\nexport function reduceRightWithIndex(b, f) {\n    return function (fa) {\n        var out = b;\n        var ks = keys(fa);\n        var len = ks.length;\n        for (var i = len - 1; i >= 0; i--) {\n            var k = ks[i];\n            out = f(k, fa[k], out);\n        }\n        return out;\n    };\n}\n/**\n * Create a record with one key/value pair\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function singleton(k, a) {\n    var _a;\n    return _a = {}, _a[k] = a, _a;\n}\nexport function traverseWithIndex(F) {\n    return function (f) { return function (ta) {\n        var ks = keys(ta);\n        if (ks.length === 0) {\n            return F.of(empty);\n        }\n        var fr = F.of({});\n        var _loop_1 = function (key) {\n            fr = F.ap(F.map(fr, function (r) { return function (b) {\n                r[key] = b;\n                return r;\n            }; }), f(key, ta[key]));\n        };\n        for (var _i = 0, ks_1 = ks; _i < ks_1.length; _i++) {\n            var key = ks_1[_i];\n            _loop_1(key);\n        }\n        return fr;\n    }; };\n}\nexport function traverse(F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (f) { return traverseWithIndexF(function (_, a) { return f(a); }); };\n}\nexport function sequence(F) {\n    return traverseWithIndex(F)(function (_, a) { return a; });\n}\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wither = function (F) {\n    var traverseF = traverse(F);\n    return function (f) { return function (fa) { return F.map(pipe(fa, traverseF(f)), compact); }; };\n};\n/**\n * @category Witherable\n * @since 2.6.5\n */\nexport var wilt = function (F) {\n    var traverseF = traverse(F);\n    return function (f) { return function (fa) { return F.map(pipe(fa, traverseF(f)), separate); }; };\n};\nexport function partitionMapWithIndex(f) {\n    return function (fa) {\n        var left = {};\n        var right = {};\n        var keys = Object.keys(fa);\n        for (var _i = 0, keys_2 = keys; _i < keys_2.length; _i++) {\n            var key = keys_2[_i];\n            var e = f(key, fa[key]);\n            switch (e._tag) {\n                case 'Left':\n                    left[key] = e.left;\n                    break;\n                case 'Right':\n                    right[key] = e.right;\n                    break;\n            }\n        }\n        return {\n            left: left,\n            right: right\n        };\n    };\n}\nexport function partitionWithIndex(predicateWithIndex) {\n    return function (fa) {\n        var left = {};\n        var right = {};\n        var keys = Object.keys(fa);\n        for (var _i = 0, keys_3 = keys; _i < keys_3.length; _i++) {\n            var key = keys_3[_i];\n            var a = fa[key];\n            if (predicateWithIndex(key, a)) {\n                right[key] = a;\n            }\n            else {\n                left[key] = a;\n            }\n        }\n        return {\n            left: left,\n            right: right\n        };\n    };\n}\nexport function filterMapWithIndex(f) {\n    return function (fa) {\n        var r = {};\n        var keys = Object.keys(fa);\n        for (var _i = 0, keys_4 = keys; _i < keys_4.length; _i++) {\n            var key = keys_4[_i];\n            var optionB = f(key, fa[key]);\n            if (isSome(optionB)) {\n                r[key] = optionB.value;\n            }\n        }\n        return r;\n    };\n}\nexport function filterWithIndex(predicateWithIndex) {\n    return function (fa) {\n        var out = {};\n        var changed = false;\n        for (var key in fa) {\n            if (_hasOwnProperty.call(fa, key)) {\n                var a = fa[key];\n                if (predicateWithIndex(key, a)) {\n                    out[key] = a;\n                }\n                else {\n                    changed = true;\n                }\n            }\n        }\n        return changed ? out : fa;\n    };\n}\nexport function fromFoldable(M, F) {\n    var fromFoldableMapM = fromFoldableMap(M, F);\n    return function (fka) { return fromFoldableMapM(fka, identity); };\n}\nexport function fromFoldableMap(M, F) {\n    return function (ta, f) {\n        return F.reduce(ta, {}, function (r, a) {\n            var _a = f(a), k = _a[0], b = _a[1];\n            r[k] = _hasOwnProperty.call(r, k) ? M.concat(r[k], b) : b;\n            return r;\n        });\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function every(predicate) {\n    return function (r) {\n        for (var k in r) {\n            if (!predicate(r[k])) {\n                return false;\n            }\n        }\n        return true;\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function some(predicate) {\n    return function (r) {\n        for (var k in r) {\n            if (predicate(r[k])) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\nexport function elem(E) {\n    return function (a, fa) {\n        if (fa === undefined) {\n            var elemE_1 = elem(E);\n            return function (fa) { return elemE_1(a, fa); };\n        }\n        for (var k in fa) {\n            if (E.equals(fa[k], a)) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\n/* istanbul ignore next */\nvar mapWithIndex_ = function (fa, f) { return pipe(fa, mapWithIndex(f)); };\n/* istanbul ignore next */\nvar reduce_ = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\n/* istanbul ignore next */\nvar foldMap_ = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\n/* istanbul ignore next */\nvar reduceRight_ = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\n/* istanbul ignore next */\nvar traverse_ = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n/* istanbul ignore next */\nvar filter_ = function (fa, predicate) {\n    return pipe(fa, filter(predicate));\n};\n/* istanbul ignore next */\nvar filterMap_ = function (fa, f) { return pipe(fa, filterMap(f)); };\n/* istanbul ignore next */\nvar partition_ = function (fa, predicate) { return pipe(fa, partition(predicate)); };\n/* istanbul ignore next */\nvar partitionMap_ = function (fa, f) { return pipe(fa, partitionMap(f)); };\n/* istanbul ignore next */\nvar reduceWithIndex_ = function (fa, b, f) {\n    return pipe(fa, reduceWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar foldMapWithIndex_ = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex(M);\n    return function (fa, f) { return pipe(fa, foldMapWithIndexM(f)); };\n};\n/* istanbul ignore next */\nvar reduceRightWithIndex_ = function (fa, b, f) {\n    return pipe(fa, reduceRightWithIndex(b, f));\n};\n/* istanbul ignore next */\nvar partitionMapWithIndex_ = function (fa, f) { return pipe(fa, partitionMapWithIndex(f)); };\n/* istanbul ignore next */\nvar partitionWithIndex_ = function (fa, predicateWithIndex) {\n    return pipe(fa, partitionWithIndex(predicateWithIndex));\n};\n/* istanbul ignore next */\nvar filterMapWithIndex_ = function (fa, f) {\n    return pipe(fa, filterMapWithIndex(f));\n};\n/* istanbul ignore next */\nvar filterWithIndex_ = function (fa, predicateWithIndex) {\n    return pipe(fa, filterWithIndex(predicateWithIndex));\n};\n/* istanbul ignore next */\nvar traverseWithIndex_ = function (F) {\n    var traverseWithIndexF = traverseWithIndex(F);\n    return function (ta, f) { return pipe(ta, traverseWithIndexF(f)); };\n};\n/* istanbul ignore next */\nvar wither_ = function (F) {\n    var witherF = wither(F);\n    return function (fa, f) { return pipe(fa, witherF(f)); };\n};\n/* istanbul ignore next */\nvar wilt_ = function (F) {\n    var wiltF = wilt(F);\n    return function (fa, f) { return pipe(fa, wiltF(f)); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var filter = function (predicate) {\n    return filterWithIndex(function (_, a) { return predicate(a); });\n};\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var filterMap = function (f) { return filterMapWithIndex(function (_, a) { return f(a); }); };\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var partition = function (predicate) {\n    return partitionWithIndex(function (_, a) { return predicate(a); });\n};\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var partitionMap = function (f) {\n    return partitionMapWithIndex(function (_, a) { return f(a); });\n};\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduce = function (b, f) {\n    return reduceWithIndex(b, function (_, b, a) { return f(b, a); });\n};\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var foldMap = function (M) {\n    var foldMapWithIndexM = foldMapWithIndex(M);\n    return function (f) { return foldMapWithIndexM(function (_, a) { return f(a); }); };\n};\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) {\n    return reduceRightWithIndex(b, function (_, a, b) { return f(a, b); });\n};\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexport var compact = function (fa) {\n    var r = {};\n    var keys = Object.keys(fa);\n    for (var _i = 0, keys_5 = keys; _i < keys_5.length; _i++) {\n        var key = keys_5[_i];\n        var optionA = fa[key];\n        if (isSome(optionA)) {\n            r[key] = optionA.value;\n        }\n    }\n    return r;\n};\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexport var separate = function (fa) {\n    var left = {};\n    var right = {};\n    var keys = Object.keys(fa);\n    for (var _i = 0, keys_6 = keys; _i < keys_6.length; _i++) {\n        var key = keys_6[_i];\n        var e = fa[key];\n        switch (e._tag) {\n            case 'Left':\n                left[key] = e.left;\n                break;\n            case 'Right':\n                right[key] = e.right;\n                break;\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyRecord';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FunctorWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FoldableWithIndex = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var FilterableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var TraversableWithIndex = {\n    URI: URI,\n    map: map_,\n    mapWithIndex: mapWithIndex_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    traverse: traverse_,\n    sequence: sequence,\n    traverseWithIndex: traverseWithIndex_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Witherable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    wither: wither_,\n    wilt: wilt_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var readonlyRecord = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_,\n    mapWithIndex: mapWithIndex_,\n    reduceWithIndex: reduceWithIndex_,\n    foldMapWithIndex: foldMapWithIndex_,\n    reduceRightWithIndex: reduceRightWithIndex_,\n    filterMapWithIndex: filterMapWithIndex_,\n    filterWithIndex: filterWithIndex_,\n    partitionMapWithIndex: partitionMapWithIndex_,\n    partitionWithIndex: partitionWithIndex_,\n    traverseWithIndex: traverseWithIndex_,\n    wither: wither_,\n    wilt: wilt_\n};\n","import * as RS from './ReadonlySet';\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getShow = RS.getShow;\n/**\n * @since 2.0.0\n */\nexport var empty = new Set();\n/**\n * @category constructors\n * @since 2.0.0\n */\n// tslint:disable-next-line: readonly-array\nexport var toArray = RS.toReadonlyArray;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getEq = RS.getEq;\n/**\n * @since 2.0.0\n */\nexport var some = RS.some;\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var map = RS.map;\n/**\n * @since 2.0.0\n */\nexport var every = RS.every;\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chain = RS.chain;\n// TODO: remove non-curried overloading in v3\n/**\n * `true` if and only if every element in the first set is an element of the second set\n *\n * @since 2.0.0\n */\nexport var subset = RS.isSubset;\nexport function filter(predicate) {\n    return RS.filter(predicate);\n}\nexport function partition(predicate) {\n    return RS.partition(predicate);\n}\n// TODO: remove non-curried overloading in v3\n/**\n * Test if a value is a member of a set\n *\n * @since 2.0.0\n */\nexport var elem = RS.elem;\n// TODO: remove non-curried overloading in v3\n/**\n * Form the union of two sets\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var union = RS.union;\n// TODO: remove non-curried overloading in v3\n/**\n * The set of elements which are in both the first and second set\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var intersection = RS.intersection;\n/**\n * @since 2.0.0\n */\nexport var partitionMap = RS.partitionMap;\n// TODO: remove non-curried overloading in v3\n/**\n * Form the set difference (`x` - `y`)\n *\n * @example\n * import { difference } from 'fp-ts/Set'\n * import { eqNumber } from 'fp-ts/Eq'\n * import { pipe } from 'fp-ts/function'\n *\n * assert.deepStrictEqual(pipe(new Set([1, 2]), difference(eqNumber)(new Set([1, 3]))), new Set([2]))\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var difference = RS.difference;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getUnionMonoid = RS.getUnionMonoid;\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var getIntersectionSemigroup = RS.getIntersectionSemigroup;\n/**\n * @since 2.0.0\n */\nexport var reduce = RS.reduce;\n/**\n * @since 2.0.0\n */\nexport var foldMap = RS.foldMap;\n/**\n * Create a set with one element\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var singleton = RS.singleton;\n/**\n * Insert a value into a set\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var insert = RS.insert;\n/**\n * Delete a value from a set\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var remove = RS.remove;\n/**\n * Checks an element is a member of a set;\n * If yes, removes the value from the set\n * If no, inserts the value to the set\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function toggle(E) {\n    var elemE = elem(E);\n    var removeE = remove(E);\n    var insertE = insert(E);\n    return function (a) { return function (set) { return (elemE(a, set) ? removeE : insertE)(a)(set); }; };\n}\n/**\n * Create a set from an array\n *\n * @category constructors\n * @since 2.0.0\n */\n// tslint:disable-next-line: readonly-array\nexport var fromArray = RS.fromArray;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var compact = RS.compact;\n/**\n * @since 2.0.0\n */\nexport var separate = RS.separate;\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var filterMap = RS.filterMap;\n","import { isLeft } from './Either';\nimport { fromEquals } from './Eq';\nimport { pipe } from './function';\nimport * as O from './Option';\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport function fromMap(m) {\n    return new Map(m);\n}\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport function toMap(m) {\n    return new Map(m);\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getShow(SK, SA) {\n    return {\n        show: function (m) {\n            var elements = '';\n            m.forEach(function (a, k) {\n                elements += \"[\" + SK.show(k) + \", \" + SA.show(a) + \"], \";\n            });\n            if (elements !== '') {\n                elements = elements.substring(0, elements.length - 2);\n            }\n            return \"new Map([\" + elements + \"])\";\n        }\n    };\n}\n/**\n * Calculate the number of key/value pairs in a map\n *\n * @since 2.5.0\n */\nexport function size(d) {\n    return d.size;\n}\n/**\n * Test whether or not a map is empty\n *\n * @since 2.5.0\n */\nexport function isEmpty(d) {\n    return d.size === 0;\n}\nexport function member(E) {\n    var lookupE = lookup(E);\n    return function (k, m) {\n        if (m === undefined) {\n            var memberE_1 = member(E);\n            return function (m) { return memberE_1(k, m); };\n        }\n        return O.isSome(lookupE(k, m));\n    };\n}\nexport function elem(E) {\n    return function (a, m) {\n        if (m === undefined) {\n            var elemE_1 = elem(E);\n            return function (m) { return elemE_1(a, m); };\n        }\n        var values = m.values();\n        var e;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var v = e.value;\n            if (E.equals(a, v)) {\n                return true;\n            }\n        }\n        return false;\n    };\n}\n/**\n * Get a sorted array of the keys contained in a map\n *\n * @since 2.5.0\n */\nexport function keys(O) {\n    return function (m) { return Array.from(m.keys()).sort(O.compare); };\n}\n/**\n * Get a sorted array of the values contained in a map\n *\n * @since 2.5.0\n */\nexport function values(O) {\n    return function (m) { return Array.from(m.values()).sort(O.compare); };\n}\n/**\n * @since 2.5.0\n */\nexport function collect(O) {\n    var keysO = keys(O);\n    return function (f) { return function (m) {\n        // tslint:disable-next-line: readonly-array\n        var out = [];\n        var ks = keysO(m);\n        for (var _i = 0, ks_1 = ks; _i < ks_1.length; _i++) {\n            var key = ks_1[_i];\n            out.push(f(key, m.get(key)));\n        }\n        return out;\n    }; };\n}\n/**\n * Get a sorted of the key/value pairs contained in a map\n *\n * @category destructors\n * @since 2.5.0\n */\nexport function toReadonlyArray(O) {\n    return collect(O)(function (k, a) { return [k, a]; });\n}\nexport function toUnfoldable(ord, U) {\n    var toArrayO = toReadonlyArray(ord);\n    return function (d) {\n        var arr = toArrayO(d);\n        var len = arr.length;\n        return U.unfold(0, function (b) { return (b < len ? O.some([arr[b], b + 1]) : O.none); });\n    };\n}\n/**\n * Insert or replace a key/value pair in a map\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function insertAt(E) {\n    var lookupWithKeyE = lookupWithKey(E);\n    return function (k, a) { return function (m) {\n        var found = lookupWithKeyE(k, m);\n        if (O.isNone(found)) {\n            var r = new Map(m);\n            r.set(k, a);\n            return r;\n        }\n        else if (found.value[1] !== a) {\n            var r = new Map(m);\n            r.set(found.value[0], a);\n            return r;\n        }\n        return m;\n    }; };\n}\n/**\n * Delete a key and value from a map\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function deleteAt(E) {\n    var lookupWithKeyE = lookupWithKey(E);\n    return function (k) { return function (m) {\n        var found = lookupWithKeyE(k, m);\n        if (O.isSome(found)) {\n            var r = new Map(m);\n            r.delete(found.value[0]);\n            return r;\n        }\n        return m;\n    }; };\n}\n/**\n * @since 2.5.0\n */\nexport function updateAt(E) {\n    var lookupWithKeyE = lookupWithKey(E);\n    return function (k, a) { return function (m) {\n        var found = lookupWithKeyE(k, m);\n        if (O.isNone(found)) {\n            return O.none;\n        }\n        var r = new Map(m);\n        r.set(found.value[0], a);\n        return O.some(r);\n    }; };\n}\n/**\n * @since 2.5.0\n */\nexport function modifyAt(E) {\n    var lookupWithKeyE = lookupWithKey(E);\n    return function (k, f) { return function (m) {\n        var found = lookupWithKeyE(k, m);\n        if (O.isNone(found)) {\n            return O.none;\n        }\n        var r = new Map(m);\n        r.set(found.value[0], f(found.value[1]));\n        return O.some(r);\n    }; };\n}\n/**\n * Delete a key and value from a map, returning the value as well as the subsequent map\n *\n * @since 2.5.0\n */\nexport function pop(E) {\n    var lookupE = lookup(E);\n    var deleteAtE = deleteAt(E);\n    return function (k) {\n        var deleteAtEk = deleteAtE(k);\n        return function (m) {\n            return pipe(lookupE(k, m), O.map(function (a) { return [a, deleteAtEk(m)]; }));\n        };\n    };\n}\nexport function lookupWithKey(E) {\n    return function (k, m) {\n        if (m === undefined) {\n            var lookupWithKeyE_1 = lookupWithKey(E);\n            return function (m) { return lookupWithKeyE_1(k, m); };\n        }\n        var entries = m.entries();\n        var e;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = entries.next()).done) {\n            var _a = e.value, ka = _a[0], a = _a[1];\n            if (E.equals(ka, k)) {\n                return O.some([ka, a]);\n            }\n        }\n        return O.none;\n    };\n}\nexport function lookup(E) {\n    var lookupWithKeyE = lookupWithKey(E);\n    return function (k, m) {\n        if (m === undefined) {\n            var lookupE_1 = lookup(E);\n            return function (m) { return lookupE_1(k, m); };\n        }\n        return pipe(lookupWithKeyE(k, m), O.map(function (_a) {\n            var _ = _a[0], a = _a[1];\n            return a;\n        }));\n    };\n}\nexport function isSubmap(SK, SA) {\n    var lookupWithKeyS = lookupWithKey(SK);\n    return function (me, that) {\n        if (that === undefined) {\n            var isSubmapSKSA_1 = isSubmap(SK, SA);\n            return function (that) { return isSubmapSKSA_1(that, me); };\n        }\n        var entries = me.entries();\n        var e;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = entries.next()).done) {\n            var _a = e.value, k = _a[0], a = _a[1];\n            var d2OptA = lookupWithKeyS(k, that);\n            if (O.isNone(d2OptA) || !SK.equals(k, d2OptA.value[0]) || !SA.equals(a, d2OptA.value[1])) {\n                return false;\n            }\n        }\n        return true;\n    };\n}\n/**\n * @since 2.5.0\n */\nexport var empty = new Map();\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getEq(SK, SA) {\n    var isSubmap_ = isSubmap(SK, SA);\n    return fromEquals(function (x, y) { return isSubmap_(x, y) && isSubmap_(y, x); });\n}\n/**\n * Gets `Monoid` instance for Maps given `Semigroup` instance for their values\n *\n * @category instances\n * @since 2.5.0\n */\nexport function getMonoid(SK, SA) {\n    var lookupWithKeyS = lookupWithKey(SK);\n    return {\n        concat: function (mx, my) {\n            if (mx === empty) {\n                return my;\n            }\n            if (my === empty) {\n                return mx;\n            }\n            var r = new Map(mx);\n            var entries = my.entries();\n            var e;\n            // tslint:disable-next-line: strict-boolean-expressions\n            while (!(e = entries.next()).done) {\n                var _a = e.value, k = _a[0], a = _a[1];\n                var mxOptA = lookupWithKeyS(k, mx);\n                if (O.isSome(mxOptA)) {\n                    r.set(mxOptA.value[0], SA.concat(mxOptA.value[1], a));\n                }\n                else {\n                    r.set(k, a);\n                }\n            }\n            return r;\n        },\n        empty: empty\n    };\n}\n/**\n * Create a map with one key/value pair\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function singleton(k, a) {\n    return new Map([[k, a]]);\n}\nexport function fromFoldable(E, M, F) {\n    return function (fka) {\n        var lookupWithKeyE = lookupWithKey(E);\n        return F.reduce(fka, new Map(), function (b, _a) {\n            var k = _a[0], a = _a[1];\n            var bOpt = lookupWithKeyE(k, b);\n            if (O.isSome(bOpt)) {\n                b.set(bOpt.value[0], M.concat(bOpt.value[1], a));\n            }\n            else {\n                b.set(k, a);\n            }\n            return b;\n        });\n    };\n}\nvar mapWithIndex_ = function (fa, f) {\n    var m = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, key = _a[0], a = _a[1];\n        m.set(key, f(key, a));\n    }\n    return m;\n};\nvar partitionMapWithIndex_ = function (fa, f) {\n    var left = new Map();\n    var right = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, k = _a[0], a = _a[1];\n        var ei = f(k, a);\n        if (isLeft(ei)) {\n            left.set(k, ei.left);\n        }\n        else {\n            right.set(k, ei.right);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n};\nvar partitionWithIndex_ = function (fa, p) {\n    var left = new Map();\n    var right = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, k = _a[0], a = _a[1];\n        if (p(k, a)) {\n            right.set(k, a);\n        }\n        else {\n            left.set(k, a);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n};\nvar filterMapWithIndex_ = function (fa, f) {\n    var m = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, k = _a[0], a = _a[1];\n        var o = f(k, a);\n        if (O.isSome(o)) {\n            m.set(k, o.value);\n        }\n    }\n    return m;\n};\nvar filterWithIndex_ = function (fa, p) {\n    var m = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, k = _a[0], a = _a[1];\n        if (p(k, a)) {\n            m.set(k, a);\n        }\n    }\n    return m;\n};\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return mapWithIndex_(fa, function (_, a) { return f(a); }); };\nvar filter_ = function (fa, p) {\n    return filterWithIndex_(fa, function (_, a) { return p(a); });\n};\nvar filterMap_ = function (fa, f) { return filterMapWithIndex_(fa, function (_, a) { return f(a); }); };\nvar partition_ = function (fa, predicate) { return partitionWithIndex_(fa, function (_, a) { return predicate(a); }); };\nvar partitionMap_ = function (fa, f) { return partitionMapWithIndex_(fa, function (_, a) { return f(a); }); };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexport var compact = function (fa) {\n    var m = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, k = _a[0], oa = _a[1];\n        if (O.isSome(oa)) {\n            m.set(k, oa.value);\n        }\n    }\n    return m;\n};\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var filter = function (predicate) { return function (fa) { return filter_(fa, predicate); }; };\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var filterMap = function (f) { return function (fa) { return filterMap_(fa, f); }; };\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.5.0\n */\nexport var map = function (f) { return function (fa) { return map_(fa, f); }; };\n/**\n * @category FunctorWithIndex\n * @since 2.7.1\n */\nexport var mapWithIndex = function (f) { return function (fa) { return mapWithIndex_(fa, f); }; };\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var partition = function (predicate) { return function (fa) { return partition_(fa, predicate); }; };\n/**\n * @category Filterable\n * @since 2.5.0\n */\nexport var partitionMap = function (f) { return function (fa) { return partitionMap_(fa, f); }; };\n/**\n * @category Compactable\n * @since 2.5.0\n */\nexport var separate = function (fa) {\n    var left = new Map();\n    var right = new Map();\n    var entries = fa.entries();\n    var e;\n    // tslint:disable-next-line: strict-boolean-expressions\n    while (!(e = entries.next()).done) {\n        var _a = e.value, k = _a[0], ei = _a[1];\n        if (isLeft(ei)) {\n            left.set(k, ei.left);\n        }\n        else {\n            right.set(k, ei.right);\n        }\n    }\n    return {\n        left: left,\n        right: right\n    };\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyMap';\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getFilterableWithIndex() {\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        mapWithIndex: mapWithIndex_,\n        compact: compact,\n        separate: separate,\n        filter: filter_,\n        filterMap: filterMap_,\n        partition: partition_,\n        partitionMap: partitionMap_,\n        partitionMapWithIndex: partitionMapWithIndex_,\n        partitionWithIndex: partitionWithIndex_,\n        filterMapWithIndex: filterMapWithIndex_,\n        filterWithIndex: filterWithIndex_\n    };\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getWitherable(O) {\n    var keysO = keys(O);\n    var reduceWithIndex = function (fa, b, f) {\n        var out = b;\n        var ks = keysO(fa);\n        var len = ks.length;\n        for (var i = 0; i < len; i++) {\n            var k = ks[i];\n            out = f(k, out, fa.get(k));\n        }\n        return out;\n    };\n    var foldMapWithIndex = function (M) { return function (fa, f) {\n        var out = M.empty;\n        var ks = keysO(fa);\n        var len = ks.length;\n        for (var i = 0; i < len; i++) {\n            var k = ks[i];\n            out = M.concat(out, f(k, fa.get(k)));\n        }\n        return out;\n    }; };\n    var reduceRightWithIndex = function (fa, b, f) {\n        var out = b;\n        var ks = keysO(fa);\n        var len = ks.length;\n        for (var i = len - 1; i >= 0; i--) {\n            var k = ks[i];\n            out = f(k, fa.get(k), out);\n        }\n        return out;\n    };\n    var traverseWithIndex = function (F) {\n        return function (ta, f) {\n            var fm = F.of(empty);\n            var ks = keysO(ta);\n            var len = ks.length;\n            var _loop_1 = function (i) {\n                var key = ks[i];\n                var a = ta.get(key);\n                fm = F.ap(F.map(fm, function (m) { return function (b) { return new Map(m).set(key, b); }; }), f(key, a));\n            };\n            for (var i = 0; i < len; i++) {\n                _loop_1(i);\n            }\n            return fm;\n        };\n    };\n    var traverse = function (F) {\n        var traverseWithIndexF = traverseWithIndex(F);\n        return function (ta, f) { return traverseWithIndexF(ta, function (_, a) { return f(a); }); };\n    };\n    var sequence = function (F) {\n        var traverseWithIndexF = traverseWithIndex(F);\n        return function (ta) { return traverseWithIndexF(ta, function (_, a) { return a; }); };\n    };\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        compact: compact,\n        separate: separate,\n        filter: filter_,\n        filterMap: filterMap_,\n        partition: partition_,\n        partitionMap: partitionMap_,\n        reduce: function (fa, b, f) { return reduceWithIndex(fa, b, function (_, b, a) { return f(b, a); }); },\n        foldMap: function (M) {\n            var foldMapWithIndexM = foldMapWithIndex(M);\n            return function (fa, f) { return foldMapWithIndexM(fa, function (_, a) { return f(a); }); };\n        },\n        reduceRight: function (fa, b, f) { return reduceRightWithIndex(fa, b, function (_, a, b) { return f(a, b); }); },\n        traverse: traverse,\n        sequence: sequence,\n        mapWithIndex: mapWithIndex_,\n        reduceWithIndex: reduceWithIndex,\n        foldMapWithIndex: foldMapWithIndex,\n        reduceRightWithIndex: reduceRightWithIndex,\n        traverseWithIndex: traverseWithIndex,\n        wilt: function (F) {\n            var traverseF = traverse(F);\n            return function (wa, f) { return F.map(traverseF(wa, f), separate); };\n        },\n        wither: function (F) {\n            var traverseF = traverse(F);\n            return function (wa, f) { return F.map(traverseF(wa, f), compact); };\n        }\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Compactable = {\n    URI: URI,\n    compact: compact,\n    separate: separate\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Filterable = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var readonlyMap = {\n    URI: URI,\n    map: map_,\n    compact: compact,\n    separate: separate,\n    filter: filter_,\n    filterMap: filterMap_,\n    partition: partition_,\n    partitionMap: partitionMap_\n};\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport { identity, pipe, bind_, bindTo_, flow } from './function';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromIO = function (ma) { return function () { return Promise.resolve(ma()); }; };\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Creates a task that will complete after a time delay\n *\n * @example\n * import { sequenceT } from 'fp-ts/Apply'\n * import * as T from 'fp-ts/Task'\n *\n * async function test() {\n *   const log: Array<string> = []\n *   const append = (message: string): T.Task<void> =>\n *     T.fromIO(() => {\n *       log.push(message)\n *     })\n *   const fa = append('a')\n *   const fb = append('b')\n *   const fc = T.delay(10)(append('c'))\n *   const fd = append('d')\n *   await sequenceT(T.task)(fa, fb, fc, fd)()\n *   assert.deepStrictEqual(log, ['a', 'b', 'd', 'c'])\n * }\n *\n * test()\n *\n * @category combinators\n * @since 2.0.0\n */\nexport function delay(millis) {\n    return function (ma) { return function () {\n        return new Promise(function (resolve) {\n            setTimeout(function () {\n                // tslint:disable-next-line: no-floating-promises\n                ma().then(resolve);\n            }, millis);\n        });\n    }; };\n}\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function fromIOK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromIO(f.apply(void 0, a));\n    };\n}\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function chainIOK(f) {\n    return chain(fromIOK(f));\n}\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\nvar apPar_ = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar apSeq_ = function (fab, fa) {\n    return pipe(fab, chain(function (f) { return pipe(fa, map(f)); }));\n};\nvar chain_ = function (ma, f) { return pipe(ma, chain(f)); };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) { return function () { return fa().then(f); }; }; };\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = function (fa) { return function (fab) { return function () {\n    return Promise.all([fab(), fa()]).then(function (_a) {\n        var f = _a[0], a = _a[1];\n        return f(a);\n    });\n}; }; };\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Wrap a value into the type constructor.\n *\n * @category Applicative\n * @since 2.0.0\n */\nexport var of = function (a) { return function () { return Promise.resolve(a); }; };\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = function (f) { return function (ma) { return function () {\n    return ma().then(function (a) { return f(a)(); });\n}; }; };\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = function (f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\n};\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = \n/*#__PURE__*/\nchain(identity);\n/**\n * @category MonadTask\n * @since 2.7.0\n */\nexport var fromTask = identity;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'Task';\n/**\n * Lift a semigroup into 'Task', the inner values are concatenated using the provided `Semigroup`.\n *\n * @example\n * import * as T from 'fp-ts/Task'\n * import { semigroupString } from 'fp-ts/Semigroup'\n *\n * async function test() {\n *   const S = T.getSemigroup(semigroupString)\n *   const fa = T.of('a')\n *   const fb = T.of('b')\n *   assert.deepStrictEqual(await S.concat(fa, fb)(), 'ab')\n * }\n *\n * test()\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getSemigroup(S) {\n    return {\n        concat: function (x, y) { return function () { return x().then(function (rx) { return y().then(function (ry) { return S.concat(rx, ry); }); }); }; }\n    };\n}\n/**\n * Lift a monoid into 'Task', the inner values are concatenated using the provided `Monoid`.\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getMonoid(M) {\n    return {\n        concat: getSemigroup(M).concat,\n        empty: of(M.empty)\n    };\n}\n/**\n * Monoid returning the first completed task.\n *\n * Note: uses `Promise.race` internally.\n *\n * @example\n * import * as T from 'fp-ts/Task'\n *\n * async function test() {\n *   const S = T.getRaceMonoid<string>()\n *   const fa = T.delay(20)(T.of('a'))\n *   const fb = T.delay(10)(T.of('b'))\n *   assert.deepStrictEqual(await S.concat(fa, fb)(), 'b')\n * }\n *\n * test()\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getRaceMonoid() {\n    return {\n        concat: function (x, y) { return function () { return Promise.race([x(), y()]); }; },\n        empty: never\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var ApplicativePar = {\n    URI: URI,\n    map: map_,\n    ap: apPar_,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var ApplicativeSeq = {\n    URI: URI,\n    map: map_,\n    ap: apSeq_,\n    of: of\n};\n/**\n * Used in TaskEither.getTaskValidation\n *\n * @internal\n */\nexport var Monad = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: apPar_,\n    chain: chain_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var task = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: apPar_,\n    chain: chain_,\n    fromIO: fromIO,\n    fromTask: fromTask\n};\n// TODO: remove in v3\n/**\n * Like `task` but `ap` is sequential\n *\n * @category instances\n * @since 2.0.0\n */\nexport var taskSeq = {\n    URI: URI,\n    map: map_,\n    of: of,\n    ap: apSeq_,\n    chain: chain_,\n    fromIO: fromIO,\n    fromTask: fromTask\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * A `Task` that never completes.\n *\n * @since 2.0.0\n */\nexport var never = function () { return new Promise(function (_) { return undefined; }); };\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) { return map(bindTo_(name)); };\n/**\n * @since 2.8.0\n */\nexport var bind = function (name, f) {\n    return chain(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apS = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), ap(fb));\n};\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = function (f) { return function (arr) { return function () { return Promise.all(arr.map(function (x, i) { return f(i, x)(); })); }; }; };\n/**\n * this function map array to task using provided function and transform it to a task of array.\n *\n * this function have the same behavior of `A.traverse(T.task)` but it's stack safe.\n *\n * > **This function run all task in parallel for sequential use `traverseSeqArray` **\n *\n * @example\n * import { range } from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n * import { of, traverseArray } from 'fp-ts/Task'\n * async function test() {\n *   const arr = range(0, 10)\n *   assert.deepStrictEqual(await pipe(arr, traverseArray(of))(), arr)\n * }\n *\n * test()\n *\n * @since 2.9.0\n */\nexport var traverseArray = function (f) {\n    return traverseArrayWithIndex(function (_, a) { return f(a); });\n};\n/**\n * this function works like `Promise.all` it will get an array of tasks and return a task of array.\n *\n * this function have the same behavior of `A.sequence(T.task)` but it's stack safe.\n *\n * > **This function run all task in parallel for sequential use `sequenceSeqArray` **\n *\n * @example\n * import * as RA from 'fp-ts/ReadonlyArray'\n * import { pipe } from 'fp-ts/function'\n * import { of, sequenceArray } from 'fp-ts/Task'\n *\n * async function test() {\n *   const arr = RA.range(1, 10)\n *   assert.deepStrictEqual(await pipe(arr, RA.map(of), sequenceArray)(), arr)\n * }\n *\n * test()\n *\n * @since 2.9.0\n */\nexport var sequenceArray = function (arr) { return function () {\n    return Promise.all(arr.map(function (x) { return x(); }));\n}; };\n/**\n * @since 2.9.0\n */\nexport var traverseSeqArrayWithIndex = function (f) { return function (arr) { return function () { return __awaiter(void 0, void 0, void 0, function () {\n    var result, i, r;\n    return __generator(this, function (_a) {\n        switch (_a.label) {\n            case 0:\n                result = [];\n                i = 0;\n                _a.label = 1;\n            case 1:\n                if (!(i < arr.length)) return [3 /*break*/, 4];\n                return [4 /*yield*/, f(i, arr[i])()];\n            case 2:\n                r = _a.sent();\n                result.push(r);\n                _a.label = 3;\n            case 3:\n                i++;\n                return [3 /*break*/, 1];\n            case 4: return [2 /*return*/, result];\n        }\n    });\n}); }; }; };\n/**\n * runs an action for every element in array then run task sequential, and accumulates the results in the array.\n *\n * this function have the same behavior of `A.traverse(T.taskSeq)` but it's stack safe.\n *\n * > **This function run all task sequentially for parallel use `traverseArray` **\n *\n *\n * @since 2.9.0\n */\nexport var traverseSeqArray = function (f) { return traverseSeqArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * run tasks in array sequential and give a task of array\n *\n * this function have the same behavior of `A.sequence(T.taskSeq)` but it's stack safe.\n *\n * > **This function run all task sequentially for parallel use `sequenceArray` **\n *\n * @since 2.9.0\n */\nexport var sequenceSeqArray = \n/*#__PURE__*/\ntraverseSeqArray(identity);\n","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nimport * as E from './Either';\nimport { getFilterableComposition } from './Filterable';\nimport { bindTo_, bind_, flow, identity, pipe } from './function';\nimport * as T from './Task';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var left = \n/*#__PURE__*/\nflow(E.left, T.of);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var right = \n/*#__PURE__*/\nflow(E.right, T.of);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightTask = \n/*#__PURE__*/\nT.map(E.right);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftTask = \n/*#__PURE__*/\nT.map(E.left);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var rightIO = \n/*#__PURE__*/\nflow(T.fromIO, rightTask);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var leftIO = \n/*#__PURE__*/\nflow(T.fromIO, leftTask);\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport var fromIOEither = T.fromIO;\n/**\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromEither = \n/*#__PURE__*/\nE.fold(left, function (a) { return right(a); });\n/**\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromOption = function (onNone) { return function (ma) {\n    return ma._tag === 'None' ? left(onNone()) : right(ma.value);\n}; };\n/**\n * Derivable from `MonadThrow`.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport var fromPredicate = function (predicate, onFalse) { return function (a) { return (predicate(a) ? right(a) : left(onFalse(a))); }; };\n/**\n * Transforms a `Promise` that may reject to a `Promise` that never rejects and returns an `Either` instead.\n *\n * Note: `f` should never `throw` errors, they are not caught.\n *\n * @example\n * import { left, right } from 'fp-ts/Either'\n * import { tryCatch } from 'fp-ts/TaskEither'\n *\n * tryCatch(() => Promise.resolve(1), String)().then(result => {\n *   assert.deepStrictEqual(result, right(1))\n * })\n * tryCatch(() => Promise.reject('error'), String)().then(result => {\n *   assert.deepStrictEqual(result, left('error'))\n * })\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function tryCatch(f, onRejected) {\n    return function () { return f().then(E.right, function (reason) { return E.left(onRejected(reason)); }); };\n}\n// -------------------------------------------------------------------------------------\n// destructors\n// -------------------------------------------------------------------------------------\n/**\n * @category destructors\n * @since 2.0.0\n */\nexport var fold = \n/*#__PURE__*/\nflow(E.fold, T.chain);\n/**\n * Less strict version of [`getOrElse`](#getOrElse).\n *\n * @category destructors\n * @since 2.6.0\n */\nexport var getOrElseW = function (onLeft) { return function (ma) {\n    return pipe(ma, T.chain(E.fold(onLeft, T.of)));\n}; };\n/**\n * @category destructors\n * @since 2.0.0\n */\nexport var getOrElse = getOrElseW;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Returns `ma` if is a `Right` or the value returned by `onLeft` otherwise.\n *\n * See also [alt](#alt).\n *\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as TE from 'fp-ts/TaskEither'\n *\n * async function test() {\n *   const errorHandler = TE.orElse((error: string) => TE.right(`recovering from ${error}...`))\n *   assert.deepStrictEqual(await pipe(TE.right('ok'), errorHandler)(), E.right('ok'))\n *   assert.deepStrictEqual(await pipe(TE.left('ko'), errorHandler)(), E.right('recovering from ko...'))\n * }\n *\n * test()\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var orElse = function (f) { return T.chain(E.fold(f, right)); };\n/**\n * @category combinators\n * @since 2.0.0\n */\nexport var swap = \n/*#__PURE__*/\nT.map(E.swap);\n/**\n * Less strict version of [`filterOrElse`](#filterOrElse).\n *\n * @since 2.9.0\n */\nexport var filterOrElseW = function (predicate, onFalse) {\n    return chainW(function (a) { return (predicate(a) ? right(a) : left(onFalse(a))); });\n};\n/**\n * Derivable from `MonadThrow`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var filterOrElse = filterOrElseW;\n/**\n * Converts a function returning a `Promise` to one returning a `TaskEither`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function tryCatchK(f, onRejected) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return tryCatch(function () { return f.apply(void 0, a); }, onRejected);\n    };\n}\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function fromEitherK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromEither(f.apply(void 0, a));\n    };\n}\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport function fromIOEitherK(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return fromIOEither(f.apply(void 0, a));\n    };\n}\n/**\n * Less strict version of [`chainEitherK`](#chainEitherK).\n *\n * @category combinators\n * @since 2.6.1\n */\nexport var chainEitherKW = function (f) { return chainW(fromEitherK(f)); };\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport var chainEitherK = chainEitherKW;\n/**\n * Less strict version of [`chainIOEitherK`](#chainIOEitherK).\n *\n * @category combinators\n * @since 2.6.1\n */\nexport var chainIOEitherKW = function (f) { return chainW(fromIOEitherK(f)); };\n/**\n * @category combinators\n * @since 2.4.0\n */\nexport var chainIOEitherK = chainIOEitherKW;\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\n/* istanbul ignore next */\nvar bimap_ = function (fa, f, g) { return pipe(fa, bimap(f, g)); };\n/* istanbul ignore next */\nvar mapLeft_ = function (fa, f) { return pipe(fa, mapLeft(f)); };\nvar apPar_ = function (fab, fa) { return pipe(fab, ap(fa)); };\nvar apSeq_ = function (fab, fa) {\n    return pipe(fab, chain(function (f) { return pipe(fa, map(f)); }));\n};\n/* istanbul ignore next */\nvar chain_ = function (ma, f) { return pipe(ma, chain(f)); };\n/* istanbul ignore next */\nvar alt_ = function (fa, that) { return pipe(fa, alt(that)); };\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.0.0\n */\nexport var map = function (f) { return T.map(E.map(f)); };\n/**\n * Map a pair of functions over the two type arguments of the bifunctor.\n *\n * @category Bifunctor\n * @since 2.0.0\n */\nexport var bimap = \n/*#__PURE__*/\nflow(E.bimap, T.map);\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category Bifunctor\n * @since 2.0.0\n */\nexport var mapLeft = function (f) {\n    return T.map(E.mapLeft(f));\n};\n/**\n * Less strict version of [`ap`](#ap).\n *\n * @category Apply\n * @since 2.8.0\n */\nexport var apW = function (fa) {\n    return flow(T.map(function (gab) { return function (ga) { return E.apW(ga)(gab); }; }), T.ap(fa));\n};\n/**\n * Apply a function to an argument under a type constructor.\n *\n * @category Apply\n * @since 2.0.0\n */\nexport var ap = apW;\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apFirst = function (fb) {\n    return flow(map(function (a) { return function () { return a; }; }), ap(fb));\n};\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * Derivable from `Apply`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var apSecond = function (fb) {\n    return flow(map(function () { return function (b) { return b; }; }), ap(fb));\n};\n/**\n * Less strict version of [`chain`](#chain).\n *\n * @category Monad\n * @since 2.6.0\n */\nexport var chainW = function (f) { return function (ma) {\n    return pipe(ma, T.chain(E.fold(left, f)));\n}; };\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation.\n *\n * @category Monad\n * @since 2.0.0\n */\nexport var chain = chainW;\n/**\n * Less strict version of [`chainFirst`](#chainFirst).\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.8.0\n */\nexport var chainFirstW = function (f) {\n    return chainW(function (a) {\n        return pipe(f(a), map(function () { return a; }));\n    });\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var chainFirst = chainFirstW;\n/**\n * Derivable from `Monad`.\n *\n * @category combinators\n * @since 2.0.0\n */\nexport var flatten = \n/*#__PURE__*/\nchain(identity);\n/**\n * Less strict version of [`alt`](#alt).\n *\n * @category Alt\n * @since 2.9.0\n */\nexport var altW = function (that) { return function (fa) { return pipe(fa, T.chain(E.fold(that, right))); }; };\n/**\n * Identifies an associative operation on a type constructor. It is similar to `Semigroup`, except that it applies to\n * types of kind `* -> *`.\n *\n * In case of `TaskEither` returns `fa` if is a `Right` or the value returned by `that` otherwise.\n *\n * See also [orElse](#orElse).\n *\n * @example\n * import * as E from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n * import * as TE from 'fp-ts/TaskEither'\n *\n * async function test() {\n *   assert.deepStrictEqual(\n *     await pipe(\n *       TE.right(1),\n *       TE.alt(() => TE.right(2))\n *     )(),\n *     E.right(1)\n *   )\n *   assert.deepStrictEqual(\n *     await pipe(\n *       TE.left('a'),\n *       TE.alt(() => TE.right(2))\n *     )(),\n *     E.right(2)\n *   )\n *   assert.deepStrictEqual(\n *     await pipe(\n *       TE.left('a'),\n *       TE.alt(() => TE.left('b'))\n *     )(),\n *     E.left('b')\n *   )\n * }\n *\n * test()\n *\n * @category Alt\n * @since 2.0.0\n */\nexport var alt = altW;\n/**\n * Wrap a value into the type constructor.\n *\n * Equivalent to [`right`](#right).\n *\n * @category Applicative\n * @since 2.0.0\n */\nexport var of = right;\n/**\n * @category MonadIO\n * @since 2.7.0\n */\nexport var fromIO = rightIO;\n/**\n * @category MonadTask\n * @since 2.7.0\n */\nexport var fromTask = rightTask;\n/**\n * @category MonadTask\n * @since 2.7.0\n */\nexport var throwError = left;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var URI = 'TaskEither';\n/**\n * Semigroup returning the left-most non-`Left` value. If both operands are `Right`s then the inner values are\n * concatenated using the provided `Semigroup`\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getSemigroup(S) {\n    return T.getSemigroup(E.getSemigroup(S));\n}\n/**\n * Semigroup returning the left-most `Left` value. If both operands are `Right`s then the inner values\n * are concatenated using the provided `Semigroup`\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getApplySemigroup(S) {\n    return T.getSemigroup(E.getApplySemigroup(S));\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getApplyMonoid(M) {\n    return {\n        concat: getApplySemigroup(M).concat,\n        empty: right(M.empty)\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport function getApplicativeTaskValidation(A, SE) {\n    var AV = E.getApplicativeValidation(SE);\n    var ap = function (fga) { return function (fgab) {\n        return A.ap(A.map(fgab, function (h) { return function (ga) { return AV.ap(h, ga); }; }), fga);\n    }; };\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        ap: function (fab, fa) { return pipe(fab, ap(fa)); },\n        of: of\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport function getAltTaskValidation(SE) {\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        alt: function (me, that) {\n            return pipe(me, T.chain(function (e1) {\n                return E.isRight(e1)\n                    ? T.of(e1)\n                    : pipe(that(), T.map(function (e2) { return (E.isLeft(e2) ? E.left(SE.concat(e1.left, e2.left)) : e2); }));\n            }));\n        }\n    };\n}\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getTaskValidation(SE) {\n    var applicativeTaskValidation = getApplicativeTaskValidation(T.ApplicativePar, SE);\n    var altTaskValidation = getAltTaskValidation(SE);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        ap: applicativeTaskValidation.ap,\n        of: of,\n        chain: chain_,\n        bimap: bimap_,\n        mapLeft: mapLeft_,\n        alt: altTaskValidation.alt,\n        fromIO: fromIO,\n        fromTask: fromTask,\n        throwError: throwError\n    };\n}\n/**\n * @category instances\n * @since 2.1.0\n */\nexport function getFilterable(M) {\n    var W = E.getWitherable(M);\n    var F = getFilterableComposition(T.Monad, W);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        compact: F.compact,\n        separate: F.separate,\n        filter: F.filter,\n        filterMap: F.filterMap,\n        partition: F.partition,\n        partitionMap: F.partitionMap\n    };\n}\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var ApplicativePar = {\n    URI: URI,\n    map: map_,\n    ap: apPar_,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var ApplicativeSeq = {\n    URI: URI,\n    map: map_,\n    ap: apSeq_,\n    of: of\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Bifunctor = {\n    URI: URI,\n    bimap: bimap_,\n    mapLeft: mapLeft_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Alt = {\n    URI: URI,\n    map: map_,\n    alt: alt_\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var taskEither = {\n    URI: URI,\n    bimap: bimap_,\n    mapLeft: mapLeft_,\n    map: map_,\n    of: of,\n    ap: apPar_,\n    chain: chain_,\n    alt: alt_,\n    fromIO: fromIO,\n    fromTask: fromTask,\n    throwError: throwError\n};\n// TODO: remove in v3\n/**\n * Like `TaskEither` but `ap` is sequential\n *\n * @category instances\n * @since 2.0.0\n */\nexport var taskEitherSeq = {\n    URI: URI,\n    bimap: bimap_,\n    mapLeft: mapLeft_,\n    map: map_,\n    of: of,\n    ap: apSeq_,\n    chain: chain_,\n    alt: alt_,\n    fromIO: fromIO,\n    fromTask: fromTask,\n    throwError: throwError\n};\nexport function taskify(f) {\n    return function () {\n        var args = Array.prototype.slice.call(arguments);\n        return function () {\n            return new Promise(function (resolve) {\n                var cbResolver = function (e, r) { return (e != null ? resolve(E.left(e)) : resolve(E.right(r))); };\n                f.apply(null, args.concat(cbResolver));\n            });\n        };\n    };\n}\n/**\n * Make sure that a resource is cleaned up in the event of an exception (\\*). The release action is called regardless of\n * whether the body action throws (\\*) or returns.\n *\n * (\\*) i.e. returns a `Left`\n *\n * Derivable from `MonadThrow`.\n *\n * @since 2.0.0\n */\nexport var bracket = function (acquire, use, release) {\n    return pipe(acquire, chain(function (a) {\n        return pipe(pipe(use(a), T.map(E.right)), chain(function (e) {\n            return pipe(release(a, e), chain(function () { return (E.isLeft(e) ? left(e.left) : of(e.right)); }));\n        }));\n    }));\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var Do = \n/*#__PURE__*/\nof({});\n/**\n * @since 2.8.0\n */\nexport var bindTo = function (name) {\n    return map(bindTo_(name));\n};\n/**\n * @since 2.8.0\n */\nexport var bindW = function (name, f) {\n    return chainW(function (a) {\n        return pipe(f(a), map(function (b) { return bind_(a, name, b); }));\n    });\n};\n/**\n * @since 2.8.0\n */\nexport var bind = bindW;\n// -------------------------------------------------------------------------------------\n// pipeable sequence S\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.8.0\n */\nexport var apSW = function (name, fb) {\n    return flow(map(function (a) { return function (b) { return bind_(a, name, b); }; }), apW(fb));\n};\n/**\n * @since 2.8.0\n */\nexport var apS = apSW;\n// -------------------------------------------------------------------------------------\n// array utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.9.0\n */\nexport var traverseArrayWithIndex = function (f) { return function (arr) {\n    return pipe(arr, T.traverseArrayWithIndex(f), T.map(E.sequenceArray));\n}; };\n/**\n * this function have the same behavior of `A.traverse(TE.taskEither)` but it's stack safe and perform better\n *\n * *this function run all tasks in parallel and does not bail out, for sequential version use `traverseSeqArray`*\n *\n * @example\n *\n * import * as TE from 'fp-ts/TaskEither'\n * import * as A from 'fp-ts/Array'\n * import { right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * const PostRepo = {\n *  findById : (id: number) => TE.of({id, title: ''})\n * }\n *\n * const findAllPosts = (ids:number[]) => pipe(ids, TE.traverseArray(PostRepo.findById))\n *\n * async function test() {\n *   const ids = A.range(0, 10)\n *\n *   assert.deepStrictEqual(\n *     await findAllPosts(ids)(),\n *     right(\n *       pipe(\n *         ids,\n *         A.map((id) => ({ id, title: ''}))\n *       )\n *     )\n *   )\n * }\n *\n * test()\n *\n * @since 2.9.0\n */\nexport var traverseArray = function (f) { return traverseArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * this function have the same behavior of `A.sequence(TE.taskEither)` but it's stack safe and perform better\n *\n * *this function run all tasks in parallel and does not bail out, for sequential version use `sequenceSeqArray`*\n *\n * @example\n *\n * import * as TE from 'fp-ts/TaskEither'\n * import * as A from 'fp-ts/Array'\n * import { right } from 'fp-ts/Either'\n * import { pipe } from 'fp-ts/function'\n *\n * const PostRepo = {\n *  findById : (id: number) => TE.of({id, title: ''})\n * }\n *\n * const findAllPosts = (ids:number[]) => pipe(ids, A.map(PostRepo.findById), TE.sequenceArray)\n *\n * async function test() {\n *   const ids = A.range(0, 10)\n *\n *   assert.deepStrictEqual(\n *     await findAllPosts(ids)(),\n *     right(\n *       pipe(\n *         ids,\n *         A.map((id) => ({ id, title: ''}))\n *       )\n *     )\n *   )\n * }\n *\n * test()\n *\n * @since 2.9.0\n */\nexport var sequenceArray = \n/*#__PURE__*/\ntraverseArray(identity);\n/**\n * @since 2.9.0\n */\nexport var traverseSeqArrayWithIndex = function (f) { return function (arr) { return function () { return __awaiter(void 0, void 0, void 0, function () {\n    var result, i, e;\n    return __generator(this, function (_a) {\n        switch (_a.label) {\n            case 0:\n                result = [];\n                i = 0;\n                _a.label = 1;\n            case 1:\n                if (!(i < arr.length)) return [3 /*break*/, 4];\n                return [4 /*yield*/, f(i, arr[i])()];\n            case 2:\n                e = _a.sent();\n                if (E.isLeft(e)) {\n                    return [2 /*return*/, e];\n                }\n                result.push(e.right);\n                _a.label = 3;\n            case 3:\n                i++;\n                return [3 /*break*/, 1];\n            case 4: return [2 /*return*/, E.right(result)];\n        }\n    });\n}); }; }; };\n/**\n * this function have the same behavior of `A.traverse(TE.taskEitherSeq)` but it's stack safe and perform better\n *\n * *this function run all tasks in sequential order and bails out on left side of either, for parallel version use `traverseArray`*\n *\n * @since 2.9.0\n */\nexport var traverseSeqArray = function (f) { return traverseSeqArrayWithIndex(function (_, a) { return f(a); }); };\n/**\n * this function have the same behavior of `A.sequence(TE.taskEitherSeq)` but it's stack safe and perform better\n *\n * *this function run all tasks in sequential order and bails out on left side of either, for parallel version use `sequenceArray`*\n *\n * @since 2.9.0\n */\nexport var sequenceSeqArray = \n/*#__PURE__*/\ntraverseSeqArray(identity);\n","import { identity, pipe } from './function';\n// -------------------------------------------------------------------------------------\n// model\n// -------------------------------------------------------------------------------------\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport function fst(ea) {\n    return ea[0];\n}\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport function snd(ea) {\n    return ea[1];\n}\n/**\n * @category combinators\n * @since 2.5.0\n */\nexport function swap(ea) {\n    return [snd(ea), fst(ea)];\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getApply(S) {\n    return {\n        URI: URI,\n        _E: undefined,\n        map: map_,\n        ap: function (fab, fa) { return [fst(fab)(fst(fa)), S.concat(snd(fab), snd(fa))]; }\n    };\n}\nvar of = function (M) { return function (a) {\n    return [a, M.empty];\n}; };\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getApplicative(M) {\n    var A = getApply(M);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: A.map,\n        ap: A.ap,\n        of: of(M)\n    };\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getChain(S) {\n    var A = getApply(S);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: A.map,\n        ap: A.ap,\n        chain: function (ma, f) {\n            var _a = f(fst(ma)), b = _a[0], s = _a[1];\n            return [b, S.concat(snd(ma), s)];\n        }\n    };\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getMonad(M) {\n    var C = getChain(M);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: C.map,\n        ap: C.ap,\n        chain: C.chain,\n        of: of(M)\n    };\n}\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getChainRec(M) {\n    var chainRec = function (a, f) {\n        var result = f(a);\n        var acc = M.empty;\n        var s = fst(result);\n        while (s._tag === 'Left') {\n            acc = M.concat(acc, snd(result));\n            result = f(s.left);\n            s = fst(result);\n        }\n        return [s.right, M.concat(acc, snd(result))];\n    };\n    var C = getChain(M);\n    return {\n        URI: URI,\n        _E: undefined,\n        map: C.map,\n        ap: C.ap,\n        chain: C.chain,\n        chainRec: chainRec\n    };\n}\n// -------------------------------------------------------------------------------------\n// non-pipeables\n// -------------------------------------------------------------------------------------\n/* istanbul ignore next */\nvar compose_ = function (bc, ab) { return pipe(bc, compose(ab)); };\n/* istanbul ignore next */\nvar map_ = function (fa, f) { return pipe(fa, map(f)); };\n/* istanbul ignore next */\nvar bimap_ = function (fa, f, g) { return pipe(fa, bimap(f, g)); };\n/* istanbul ignore next */\nvar mapLeft_ = function (fa, f) { return pipe(fa, mapLeft(f)); };\n/* istanbul ignore next */\nvar extend_ = function (wa, f) { return pipe(wa, extend(f)); };\n/* istanbul ignore next */\nvar reduce_ = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\n/* istanbul ignore next */\nvar foldMap_ = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\n/* istanbul ignore next */\nvar reduceRight_ = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\n/* istanbul ignore next */\nvar traverse_ = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n// -------------------------------------------------------------------------------------\n// pipeables\n// -------------------------------------------------------------------------------------\n/**\n * Map a pair of functions over the two type arguments of the bifunctor.\n *\n * @category Bifunctor\n * @since 2.5.0\n */\nexport var bimap = function (f, g) { return function (fa) { return [g(fst(fa)), f(snd(fa))]; }; };\n/**\n * Map a function over the first type argument of a bifunctor.\n *\n * @category Bifunctor\n * @since 2.5.0\n */\nexport var mapLeft = function (f) { return function (fa) { return [\n    fst(fa),\n    f(snd(fa))\n]; }; };\n/**\n * @category Semigroupoid\n * @since 2.5.0\n */\nexport var compose = function (ab) { return function (bc) { return [\n    fst(bc),\n    snd(ab)\n]; }; };\n/**\n * @category Extend\n * @since 2.5.0\n */\nexport var extend = function (f) { return function (wa) { return [f(wa), snd(wa)]; }; };\n/**\n * @category Extract\n * @since 2.6.2\n */\nexport var extract = fst;\n/**\n * Derivable from `Extend`.\n *\n * @category combinators\n * @since 2.5.0\n */\nexport var duplicate = \n/*#__PURE__*/\nextend(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category Functor\n * @since 2.5.0\n */\nexport var map = function (f) { return function (fa) { return [\n    f(fst(fa)),\n    snd(fa)\n]; }; };\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduce = function (b, f) { return function (fa) {\n    return f(b, fst(fa));\n}; };\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var foldMap = function () {\n    return function (f) { return function (fa) { return f(fst(fa)); }; };\n};\n/**\n * @category Foldable\n * @since 2.5.0\n */\nexport var reduceRight = function (b, f) { return function (fa) {\n    return f(fst(fa), b);\n}; };\n/**\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n    return function (f) { return function (ta) { return F.map(f(fst(ta)), function (b) { return [b, snd(ta)]; }); }; };\n};\n/**\n * @since 2.6.3\n */\nexport var sequence = function (F) { return function (fas) {\n    return F.map(fst(fas), function (a) { return [a, snd(fas)]; });\n}; };\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var URI = 'ReadonlyTuple';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: map_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Bifunctor = {\n    URI: URI,\n    bimap: bimap_,\n    mapLeft: mapLeft_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Semigroupoid = {\n    URI: URI,\n    compose: compose_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Comonad = {\n    URI: URI,\n    map: map_,\n    extend: extend_,\n    extract: extract\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: map_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n// TODO: remove in v3\n/**\n * @category instances\n * @since 2.5.0\n */\nexport var readonlyTuple = {\n    URI: URI,\n    compose: compose_,\n    map: map_,\n    bimap: bimap_,\n    mapLeft: mapLeft_,\n    extract: extract,\n    extend: extend_,\n    reduce: reduce_,\n    foldMap: foldMap_,\n    reduceRight: reduceRight_,\n    traverse: traverse_,\n    sequence: sequence\n};\n","import { fromEquals } from './Eq';\nimport { not, identity } from './function';\n/**\n * @category constructors\n * @since 2.5.0\n */\nexport function fromSet(s) {\n    return new Set(s);\n}\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport function toSet(s) {\n    return new Set(s);\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getShow(S) {\n    return {\n        show: function (s) {\n            var elements = '';\n            s.forEach(function (a) {\n                elements += S.show(a) + ', ';\n            });\n            if (elements !== '') {\n                elements = elements.substring(0, elements.length - 2);\n            }\n            return \"new Set([\" + elements + \"])\";\n        }\n    };\n}\n/**\n * @since 2.5.0\n */\nexport var empty = new Set();\n/**\n * @category destructors\n * @since 2.5.0\n */\nexport function toReadonlyArray(O) {\n    return function (x) {\n        // tslint:disable-next-line: readonly-array\n        var r = [];\n        x.forEach(function (e) { return r.push(e); });\n        return r.sort(O.compare);\n    };\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getEq(E) {\n    var subsetE = isSubset(E);\n    return fromEquals(function (x, y) { return subsetE(x, y) && subsetE(y, x); });\n}\n/**\n * @since 2.5.0\n */\nexport function some(predicate) {\n    return function (set) {\n        var values = set.values();\n        var e;\n        var found = false;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!found && !(e = values.next()).done) {\n            found = predicate(e.value);\n        }\n        return found;\n    };\n}\n/**\n * Projects a Set through a function\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function map(E) {\n    var elemE = elem(E);\n    return function (f) { return function (set) {\n        var r = new Set();\n        set.forEach(function (e) {\n            var v = f(e);\n            if (!elemE(v, r)) {\n                r.add(v);\n            }\n        });\n        return r;\n    }; };\n}\n/**\n * @since 2.5.0\n */\nexport function every(predicate) {\n    return not(some(not(predicate)));\n}\n/**\n * @category combinators\n * @since 2.5.0\n */\nexport function chain(E) {\n    var elemE = elem(E);\n    return function (f) { return function (set) {\n        var r = new Set();\n        set.forEach(function (e) {\n            f(e).forEach(function (e) {\n                if (!elemE(e, r)) {\n                    r.add(e);\n                }\n            });\n        });\n        return r;\n    }; };\n}\nexport function isSubset(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var isSubsetE_1 = isSubset(E);\n            return function (that) { return isSubsetE_1(that, me); };\n        }\n        return every(function (a) { return elemE(a, that); })(me);\n    };\n}\nexport function filter(predicate) {\n    return function (set) {\n        var values = set.values();\n        var e;\n        var r = new Set();\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var value = e.value;\n            if (predicate(value)) {\n                r.add(value);\n            }\n        }\n        return r;\n    };\n}\nexport function partition(predicate) {\n    return function (set) {\n        var values = set.values();\n        var e;\n        var right = new Set();\n        var left = new Set();\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var value = e.value;\n            if (predicate(value)) {\n                right.add(value);\n            }\n            else {\n                left.add(value);\n            }\n        }\n        return { left: left, right: right };\n    };\n}\nexport function elem(E) {\n    return function (a, set) {\n        if (set === undefined) {\n            var elemE_1 = elem(E);\n            return function (set) { return elemE_1(a, set); };\n        }\n        var values = set.values();\n        var e;\n        var found = false;\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!found && !(e = values.next()).done) {\n            found = E.equals(a, e.value);\n        }\n        return found;\n    };\n}\nexport function union(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var unionE_1 = union(E);\n            return function (that) { return unionE_1(me, that); };\n        }\n        if (me === empty) {\n            return that;\n        }\n        if (that === empty) {\n            return me;\n        }\n        var r = new Set(me);\n        that.forEach(function (e) {\n            if (!elemE(e, r)) {\n                r.add(e);\n            }\n        });\n        return r;\n    };\n}\nexport function intersection(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var intersectionE_1 = intersection(E);\n            return function (that) { return intersectionE_1(that, me); };\n        }\n        if (me === empty || that === empty) {\n            return empty;\n        }\n        var r = new Set();\n        me.forEach(function (e) {\n            if (elemE(e, that)) {\n                r.add(e);\n            }\n        });\n        return r;\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function partitionMap(EB, EC) {\n    return function (f) { return function (set) {\n        var values = set.values();\n        var e;\n        var left = new Set();\n        var right = new Set();\n        var hasB = elem(EB);\n        var hasC = elem(EC);\n        // tslint:disable-next-line: strict-boolean-expressions\n        while (!(e = values.next()).done) {\n            var v = f(e.value);\n            switch (v._tag) {\n                case 'Left':\n                    if (!hasB(v.left, left)) {\n                        left.add(v.left);\n                    }\n                    break;\n                case 'Right':\n                    if (!hasC(v.right, right)) {\n                        right.add(v.right);\n                    }\n                    break;\n            }\n        }\n        return { left: left, right: right };\n    }; };\n}\nexport function difference(E) {\n    var elemE = elem(E);\n    return function (me, that) {\n        if (that === undefined) {\n            var differenceE_1 = difference(E);\n            return function (that) { return differenceE_1(that, me); };\n        }\n        return filter(function (a) { return !elemE(a, that); })(me);\n    };\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getUnionMonoid(E) {\n    return {\n        concat: union(E),\n        empty: empty\n    };\n}\n/**\n * @category instances\n * @since 2.5.0\n */\nexport function getIntersectionSemigroup(E) {\n    return {\n        concat: intersection(E)\n    };\n}\n/**\n * @since 2.5.0\n */\nexport function reduce(O) {\n    var toArrayO = toReadonlyArray(O);\n    return function (b, f) { return function (fa) { return toArrayO(fa).reduce(f, b); }; };\n}\n/**\n * @since 2.5.0\n */\nexport function foldMap(O, M) {\n    var toArrayO = toReadonlyArray(O);\n    return function (f) { return function (fa) { return toArrayO(fa).reduce(function (b, a) { return M.concat(b, f(a)); }, M.empty); }; };\n}\n/**\n * Create a set with one element\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function singleton(a) {\n    return new Set([a]);\n}\n/**\n * Insert a value into a set\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function insert(E) {\n    var elemE = elem(E);\n    return function (a) { return function (set) {\n        if (!elemE(a)(set)) {\n            var r = new Set(set);\n            r.add(a);\n            return r;\n        }\n        else {\n            return set;\n        }\n    }; };\n}\n/**\n * Delete a value from a set\n *\n * @category combinators\n * @since 2.5.0\n */\nexport function remove(E) {\n    return function (a) { return function (set) { return filter(function (ax) { return !E.equals(a, ax); })(set); }; };\n}\n/**\n * Create a set from an array\n *\n * @category constructors\n * @since 2.5.0\n */\nexport function fromArray(E) {\n    return function (as) {\n        var len = as.length;\n        var r = new Set();\n        var has = elem(E);\n        for (var i = 0; i < len; i++) {\n            var a = as[i];\n            if (!has(a, r)) {\n                r.add(a);\n            }\n        }\n        return r;\n    };\n}\n/**\n * @category combinators\n * @since 2.5.0\n */\nexport function compact(E) {\n    return filterMap(E)(identity);\n}\n/**\n * @since 2.5.0\n */\nexport function separate(EE, EA) {\n    return function (fa) {\n        var elemEE = elem(EE);\n        var elemEA = elem(EA);\n        var left = new Set();\n        var right = new Set();\n        fa.forEach(function (e) {\n            switch (e._tag) {\n                case 'Left':\n                    if (!elemEE(e.left, left)) {\n                        left.add(e.left);\n                    }\n                    break;\n                case 'Right':\n                    if (!elemEA(e.right, right)) {\n                        right.add(e.right);\n                    }\n                    break;\n            }\n        });\n        return { left: left, right: right };\n    };\n}\n/**\n * @category combinators\n * @since 2.5.0\n */\nexport function filterMap(E) {\n    var elemE = elem(E);\n    return function (f) { return function (fa) {\n        var r = new Set();\n        fa.forEach(function (a) {\n            var ob = f(a);\n            if (ob._tag === 'Some' && !elemE(ob.value, r)) {\n                r.add(ob.value);\n            }\n        });\n        return r;\n    }; };\n}\n","/**\n * If a type `A` can form a `Semigroup` it has an **associative** binary operation.\n *\n * ```ts\n * interface Semigroup<A> {\n *   readonly concat: (x: A, y: A) => A\n * }\n * ```\n *\n * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.\n *\n * ```ts\n * concat(x, concat(y, z)) = concat(concat(x, y), z)\n * ```\n *\n * A common example of a semigroup is the type `string` with the operation `+`.\n *\n * ```ts\n * import { Semigroup } from 'fp-ts/Semigroup'\n *\n * const semigroupString: Semigroup<string> = {\n *   concat: (x, y) => x + y\n * }\n *\n * const x = 'x'\n * const y = 'y'\n * const z = 'z'\n *\n * semigroupString.concat(x, y) // 'xy'\n *\n * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'\n *\n * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'\n * ```\n *\n * *Adapted from https://typelevel.org/cats*\n *\n * @since 2.0.0\n */\nimport { identity } from './function';\nimport { max, min } from './Ord';\nexport function fold(S) {\n    return function (startWith, as) {\n        if (as === undefined) {\n            var foldS_1 = fold(S);\n            return function (as) { return foldS_1(startWith, as); };\n        }\n        return as.reduce(S.concat, startWith);\n    };\n}\n/**\n * Always return the first argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.getFirstSemigroup<number>().concat(1, 2), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getFirstSemigroup() {\n    return { concat: identity };\n}\n/**\n * Always return the last argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.getLastSemigroup<number>().concat(1, 2), 2)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getLastSemigroup() {\n    return { concat: function (_, y) { return y; } };\n}\n/**\n * Given a tuple of semigroups returns a semigroup for the tuple.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getTupleSemigroup(S.semigroupString, S.semigroupSum)\n * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const S2 = S.getTupleSemigroup(S.semigroupString, S.semigroupSum, S.semigroupAll)\n * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getTupleSemigroup() {\n    var semigroups = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        semigroups[_i] = arguments[_i];\n    }\n    return {\n        concat: function (x, y) { return semigroups.map(function (s, i) { return s.concat(x[i], y[i]); }); }\n    };\n}\n/**\n * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.getDualSemigroup(S.semigroupString).concat('a', 'b'), 'ba')\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getDualSemigroup(S) {\n    return {\n        concat: function (x, y) { return S.concat(y, x); }\n    };\n}\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/function'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = S.getFunctionSemigroup(S.semigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = S.getFunctionSemigroup(S.semigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getFunctionSemigroup(S) {\n    return function () { return ({\n        concat: function (f, g) { return function (a) { return S.concat(f(a), g(a)); }; }\n    }); };\n}\n/**\n * Given a struct of semigroups returns a semigroup for the struct.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const semigroupPoint = S.getStructSemigroup<Point>({\n *   x: S.semigroupSum,\n *   y: S.semigroupSum\n * })\n *\n * assert.deepStrictEqual(semigroupPoint.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getStructSemigroup(semigroups) {\n    return {\n        concat: function (x, y) {\n            var r = {};\n            for (var _i = 0, _a = Object.keys(semigroups); _i < _a.length; _i++) {\n                var key = _a[_i];\n                r[key] = semigroups[key].concat(x[key], y[key]);\n            }\n            return r;\n        }\n    };\n}\n/**\n * Get a semigroup where `concat` will return the minimum, based on the provided order.\n *\n * @example\n * import * as O from 'fp-ts/Ord'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getMeetSemigroup(O.ordNumber)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 1)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getMeetSemigroup(O) {\n    return {\n        concat: min(O)\n    };\n}\n/**\n * Get a semigroup where `concat` will return the maximum, based on the provided order.\n *\n * @example\n * import * as O from 'fp-ts/Ord'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getJoinSemigroup(O.ordNumber)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 2)\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getJoinSemigroup(O) {\n    return {\n        concat: max(O)\n    };\n}\n/**\n * Return a semigroup for objects, preserving their type.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * interface Person {\n *   name: string\n *   age: number\n * }\n *\n * const S1 = S.getObjectSemigroup<Person>()\n * assert.deepStrictEqual(S1.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })\n *\n * @category instances\n * @since 2.0.0\n */\nexport function getObjectSemigroup() {\n    return {\n        concat: function (x, y) { return Object.assign({}, x, y); }\n    };\n}\n/**\n * `boolean` semigroup under conjunction.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupAll.concat(true, true), true)\n * assert.deepStrictEqual(S.semigroupAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var semigroupAll = {\n    concat: function (x, y) { return x && y; }\n};\n/**\n * `boolean` semigroup under disjunction.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupAny.concat(true, true), true)\n * assert.deepStrictEqual(S.semigroupAny.concat(true, false), true)\n * assert.deepStrictEqual(S.semigroupAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var semigroupAny = {\n    concat: function (x, y) { return x || y; }\n};\n/**\n * `number` semigroup under addition.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupSum.concat(2, 3), 5)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var semigroupSum = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * `number` semigroup under multiplication.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupProduct.concat(2, 3), 6)\n *\n * @category instances\n * @since 2.0.0\n */\nexport var semigroupProduct = {\n    concat: function (x, y) { return x * y; }\n};\n/**\n * `string` semigroup under concatenation.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.semigroupString.concat('a', 'b'), 'ab')\n *\n * @category instances\n * @since 2.0.0\n */\nexport var semigroupString = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * @category instances\n * @since 2.0.0\n */\nexport var semigroupVoid = {\n    concat: function () { return undefined; }\n};\n/**\n * You can glue items between and stay associative.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.getIntercalateSemigroup(' ')(S.semigroupString)\n *\n * assert.strictEqual(S1.concat('a', 'b'), 'a b')\n * assert.strictEqual(S1.concat(S1.concat('a', 'b'), 'c'), S1.concat('a', S1.concat('b', 'c')))\n *\n * @category instances\n * @since 2.5.0\n */\nexport function getIntercalateSemigroup(a) {\n    return function (S) { return ({\n        concat: function (x, y) { return S.concat(x, S.concat(a, y)); }\n    }); };\n}\n"],"sourceRoot":""}