{"version":3,"file":"app.6bb33bee4c31392b0558.js","mappings":"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IAAK,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,IAAK,GAAI,EAAG,IAAK,IAAK,IAAK,IAAK,EAAG,IAAK,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAAK,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,EAAG,IAAK,IAAK,IAAK,EAAG,EAAG,EAAG,IAAK,IAAK,IAAK,GAAI,IAAK,EAAG,EAAG,EAAG,IAAK,IAAK,IAAK,GAAI,IAAK,EAAG,EAAG,EAAG,IAAK,IAAK,IAAK,GAAI,IAAK,EAAG,EAAG,EAAG,IAAK,IAAK,IAAK,GAAI,IAAK,EAAG,EAAG,EAAG,IAAK,IAAK,IAAK,GAAI,IAAK,IAAK,IAAK,IAAK,EAAG,EAAG,GAAI,IAAK,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,GAAI,EAAG,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,EAAG,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,GAAI,EAAG,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,EAAG,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,GAAI,EAAG,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,EAAG,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,GAAI,EAAG,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,EAAG,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,GAAI,EAAG,IAAK,GAAI,GAAI,EAAG,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,IAAK,GAAI,EAAG,IAAK,GAAI,GAAI,IAAK,IAAK,IAAK,GAAI,EAAG,GAAI,GAAI,IAAK,IAAK,GAAI,EAAG,GAAI,EAAG,IAAK,MACznC,CAAC,GAAGC,OAIb,CAFA,MAAOC,GAEP,CAWO,SAASC,GAAKC,EAAKC,EAAM3C,GAK5BzK,KAAKmN,IAAY,EAANA,EAKXnN,KAAKoN,KAAc,EAAPA,EAKZpN,KAAKyK,WAAaA,CACtB,CAmDO,SAAS4C,GAAOrI,GACnB,OAAsC,KAA9BA,GAAOA,EAAgB,WACnC,CApDAkI,GAAKrE,UAAUtJ,YAAc,WACzB,IAAIwD,EAAK/C,KAAKyK,SAAW,EAAI,EAG7B,OAFA1H,GAAOA,GAAM,GAAKA,EAAM/C,KAAKoN,KAC7BrK,GAAOA,GAAM,GAAKA,EAAM/C,KAAKmN,IACtBpK,CACX,EACAmK,GAAKrE,UAAUlF,OAAS,SAAU1E,GAAK,OAAO,GAAOe,KAAMf,EAAI,EAC/DiO,GAAKrE,UAAUrE,UAAY,SAAUvF,GAAK,OAAO,GAAQe,KAAMf,EAAI,EACnEiO,GAAKrE,UAAUtH,SAAW,SAAUO,GAAS,OAAO,GAAS9B,KAAM8B,EAAQ,EAC3EoL,GAAKrE,UAAUtC,OAAS,WAAc,OAAO,GAASvG,KAAO,EAC7DkN,GAAKrE,UAAUqD,IAAU,WACrB,MAAMjN,EAAIe,KACV,MAAO,CACHoM,SAAU1M,GAAK,GAAST,EAAGS,GAC3B6M,YAAaC,GAAMpG,OAAOnH,IAAK,GAAIsN,YAAYC,GAAInD,OAAO,GAC1DoD,cAAeH,GAAMlG,OAAOnH,IAAK,GAAIwN,cAAcH,GAAIjD,OAAO,GAC9DgD,QAASC,GAAMlG,OAAOnH,IAAK,GAAIoN,QAAQC,GAAIjD,OAAO,GAClDqD,MAAO,KAAM,UAASzN,EAAEwL,SAAWxL,EAgtCpC,SAAmBqO,EAAO7C,EAAU8C,GACvC,OAAOA,EASJ,SAAqBD,EAAO7C,GAC/B,OAAO,IAAIyC,GAAKI,EAAM,GAClBA,EAAM,IAAM,EACZA,EAAM,IAAM,GACZA,EAAM,IAAM,GAAIA,EAAM,GACtBA,EAAM,IAAM,EACZA,EAAM,IAAM,GACZA,EAAM,IAAM,GAAI7C,EACxB,CAjBgB+C,CAAYF,EAAO7C,GAyB5B,SAAqB6C,EAAO7C,GAC/B,OAAO,IAAIyC,GAAKI,EAAM,IAAM,GACxBA,EAAM,IAAM,GACZA,EAAM,IAAM,EACZA,EAAM,GAAIA,EAAM,IAAM,GACtBA,EAAM,IAAM,GACZA,EAAM,IAAM,EACZA,EAAM,GAAI7C,EAClB,CAjC+CgD,CAAYH,EAAO7C,EAClE,CAltC+CiD,EA+pCvBC,EA/pCyC1O,EAgqCtDsO,EAQJ,SAAmBI,GACtB,IAAIC,EAAKD,EAAMP,KAAMS,EAAKF,EAAMR,IAChC,MAAO,CACE,IAALU,EACAA,IAAO,EAAI,IACXA,IAAO,GAAK,IACZA,IAAO,GACF,IAALD,EACAA,IAAO,EAAI,IACXA,IAAO,GAAK,IACZA,IAAO,GAEf,CApBgBE,CAAUH,GA2BnB,SAAmBA,GACtB,IAAIC,EAAKD,EAAMP,KAAMS,EAAKF,EAAMR,IAChC,MAAO,CACHS,IAAO,GACPA,IAAO,GAAK,IACZA,IAAO,EAAI,IACN,IAALA,EACAC,IAAO,GACPA,IAAO,GAAK,IACZA,IAAO,EAAI,IACN,IAALA,EAER,CAvCmCE,CAAUJ,KAhqCwB,GAAO,IA+pCrE,IAAiBA,EAAOJ,CA/pCgD,EAE/E,EAuBAL,GAAKrE,UAAUmF,WACfrO,OAAOsO,eAAef,GAAKrE,UAAW,aAAc,CAAEzI,OAAO,IAsB7D,IAAI8N,GAAY,CAAC,EAMbC,GAAa,CAAC,EAOX,SAASC,GAAQhO,EAAOqK,GAC3B,IAAIzF,EAAKqJ,EAAWC,EACpB,OAAI7D,GAEI6D,EAAS,IADblO,KAAW,IACgBA,EAAQ,OAC/BiO,EAAYF,GAAW/N,IAEZiO,GAEfrJ,EAAM,GAAS5E,GAAgB,EAARA,GAAa,GAAK,EAAI,GAAG,GAC5CkO,IACAH,GAAW/N,GAAS4E,GACjBA,IAIHsJ,GAAU,MADdlO,GAAS,IACqBA,EAAQ,OAClCiO,EAAYH,GAAU9N,IAEXiO,GAEfrJ,EAAM,GAAS5E,EAAOA,EAAQ,GAAK,EAAI,GAAG,GACtCkO,IACAJ,GAAU9N,GAAS4E,GAChBA,EAEf,CAeO,SAASuJ,GAAWnO,EAAOqK,GAC9B,GAAImB,MAAMxL,GACN,OAAOqK,EAAW+D,GAAQC,GAC9B,GAAIhE,EAAU,CACV,GAAIrK,EAAQ,EACR,OAAOoO,GACX,GAAIpO,GAASsO,GACT,OAAOC,EACf,KACK,CACD,GAAIvO,IAAUwO,GACV,OAAOC,GACX,GAAIzO,EAAQ,GAAKwO,GACb,OAAOE,EACf,CACA,OAAI1O,EAAQ,EACD2O,GAAOR,IAAYnO,EAAOqK,IAC9B,GAAUrK,EAAQ4O,GAAkB,EAAI5O,EAAQ4O,GAAkB,EAAGvE,EAChF,CAgBO,SAAS,GAASwE,EAASC,EAAUzE,GACxC,OAAO,IAAIyC,GAAK+B,EAASC,EAAUzE,EACvC,CAkBA,IAAI0E,GAAUC,KAAKC,IAQZ,SAASC,GAAWhO,EAAKmJ,EAAU3I,GACtC,GAAmB,IAAfR,EAAID,OACJ,MAAMf,MAAM,gBAChB,GAAY,QAARgB,GAAyB,aAARA,GAA8B,cAARA,GAA+B,cAARA,EAC9D,OAAOmN,GAUX,GATwB,iBAAbhE,GAEP3I,EAAQ2I,EACJA,GAAW,GAGfA,IAAaA,GAEjB3I,EAAQA,GAAS,IACL,GAAK,GAAKA,EAClB,MAAMyN,WAAW,SACrB,IAAIC,EAAIlO,EAAIoF,QAAQ,KACpB,GAAI8I,EAAI,EACJ,MAAMlP,MAAM,mBACX,GAAU,IAANkP,EACL,OAAOT,GAAOO,GAAWhO,EAAImO,UAAU,GAAIhF,EAAU3I,IAMzD,IAFA,IAAI4N,EAAenB,GAAWY,GAAQrN,EAAO,IACzCqF,EAASsH,GACJrN,EAAI,EAAGA,EAAIE,EAAID,OAAQD,GAAK,EAAG,CACpC,IAAIuO,EAAOP,KAAKrD,IAAI,EAAGzK,EAAID,OAASD,GAAIhB,EAAQuL,SAASrK,EAAImO,UAAUrO,EAAGA,EAAIuO,GAAO7N,GAGjFqF,EAASyI,GAFTD,EAAO,EAEM,GAASxI,EADVoH,GAAWY,GAAQrN,EAAO6N,KAItCxI,EAAS,GAASA,EAAQuI,GAHYnB,GAAWnO,GAMzD,CAEA,OADA+G,EAAOsD,SAAWA,EACXtD,CACX,CAiBO,SAAS,GAAU0I,EAAKpF,GAC3B,MAAmB,iBAARoF,EACAtB,GAAWsB,EAAKpF,GACR,iBAARoF,EACAP,GAAWO,EAAKpF,GAEpB,GAASoF,EAAI1C,IAAK0C,EAAIzC,KAA0B,kBAAb3C,EAAyBA,EAAWoF,EAAIpF,SACtF,CAgBA,IAYIuE,GAAiBc,WAMjBpB,GAAiBM,GAAiBA,GAMlCJ,GAAiBF,GAAiB,EAMlCqB,GAAa3B,GAxBI,GAAK,IA6BfK,GAAOL,GAAQ,GAUfI,GAAQJ,GAAQ,GAAG,GAUnB4B,GAAM5B,GAAQ,GAUd6B,GAAO7B,GAAQ,GAAG,GAUlB8B,GAAU9B,IAAS,GAUnBU,GAAY,IAAS,EAAgB,YAAgB,GAUrDH,GAAqB,IAAS,GAAgB,GAAgB,GAU9DE,GAAY,GAAS,GAAG,YAAgB,GAgB5C,SAAS,GAAMlB,GAClB,OAAOA,EAAMlD,SAAWkD,EAAMR,MAAQ,EAAIQ,EAAMR,GACpD,CAOO,SAASgD,GAASxC,GACrB,OAAIA,EAAMlD,UACGkD,EAAMP,OAAS,GAAK4B,IAAmBrB,EAAMR,MAAQ,GAC3DQ,EAAMP,KAAO4B,IAAkBrB,EAAMR,MAAQ,EACxD,CAUO,SAAS,GAASQ,EAAO7L,GAE5B,IADAA,EAAQA,GAAS,IACL,GAAK,GAAKA,EAClB,MAAMyN,WAAW,SACrB,GAAIa,GAAOzC,GACP,MAAO,IACX,GAAI0C,GAAW1C,GAAQ,CACnB,GAAI,GAAOA,EAAOkB,IAAY,CAG1B,IAAIyB,EAAY/B,GAAWzM,GAAQyO,EAAMC,GAAO7C,EAAO2C,GAAYG,EAAOC,GAAS,GAASH,EAAKD,GAAY3C,GAC7G,OAAO,GAAS4C,EAAKzO,GAAS,GAAM2O,GAAMlP,SAASO,EACvD,CAEI,MAAO,IAAM,GAASiN,GAAOpB,GAAQ7L,EAC7C,CAKA,IAFA,IAAI4N,EAAenB,GAAWY,GAAQrN,EAAO,GAAI6L,EAAMlD,UAAWkG,EAAMhD,EACpExG,EAAS,KACA,CACT,IAAIyJ,EAASJ,GAAOG,EAAKjB,GAAoF1E,GAA5D,GAAM0F,GAASC,EAAK,GAASC,EAAQlB,OAAoB,GAAmBnO,SAASO,GAEtI,GAAIsO,GADJO,EAAMC,GAEF,OAAO5F,EAAS7D,EAEhB,KAAO6D,EAAO3J,OAAS,GACnB2J,EAAS,IAAMA,EACnB7D,EAAS,GAAK6D,EAAS7D,CAE/B,CACJ,CA0DO,SAASiJ,GAAOzC,GACnB,OAAsB,IAAfA,EAAMP,MAA4B,IAAdO,EAAMR,GACrC,CAYO,SAASkD,GAAW1C,GACvB,OAAQA,EAAMlD,UAAYkD,EAAMP,KAAO,CAC3C,CAgBO,SAASyD,GAAMlD,GAClB,OAA2B,IAAP,EAAZA,EAAMR,IAClB,CAiBO,SAAS,GAAOQ,EAAO9G,GAG1B,OAFKwG,GAAOxG,KACRA,EAAQ,GAAUA,KAClB8G,EAAMlD,WAAa5D,EAAM4D,UAAakD,EAAMP,OAAS,IAAQ,GAAMvG,EAAMuG,OAAS,IAAQ,IAEvFO,EAAMP,OAASvG,EAAMuG,MAAQO,EAAMR,MAAQtG,EAAMsG,GAC5D,CAuCO,SAAS2D,GAASnD,EAAO9G,GAC5B,OAAO,GAAQ8G,EAAuB9G,GAAS,CACnD,CAuCO,SAASkK,GAAYpD,EAAO9G,GAC/B,OAAO,GAAQ8G,EAAuB9G,GAAS,CACnD,CAeO,SAASmK,GAAmBrD,EAAO9G,GACtC,OAAO,GAAQ8G,EAAuB9G,IAAU,CACpD,CAuBO,SAAS,GAAQ8G,EAAO9G,GAG3B,GAFKwG,GAAOxG,KACRA,EAAQ,GAAUA,IAClB,GAAO8G,EAAO9G,GACd,OAAO,EACX,IAAIoK,EAAUZ,GAAW1C,GAAQuD,EAAWb,GAAWxJ,GACvD,OAAIoK,IAAYC,GACJ,GACPD,GAAWC,EACL,EAENvD,EAAMlD,SAGH5D,EAAMuG,OAAS,EAAMO,EAAMP,OAAS,GAAOvG,EAAMuG,OAASO,EAAMP,MAASvG,EAAMsG,MAAQ,EAAMQ,EAAMR,MAAQ,GAAO,EAAI,EAFnHkD,GAAWK,GAAS/C,EAAO9G,KAAW,EAAI,CAGzD,CAeO,SAASkI,GAAOpB,GACnB,OAAKA,EAAMlD,UAAY,GAAOkD,EAAOkB,IAC1BA,GACJe,GA0RJ,SAAajC,GAChB,OAAO,IAAUA,EAAMR,KAAMQ,EAAMP,KAAMO,EAAMlD,SACnD,CA5Re0G,CAAIxD,GAAQqC,GAC3B,CAcO,SAASJ,GAAIjC,EAAOyD,GAClB/D,GAAO+D,KACRA,EAAS,GAAUA,IAEvB,IAAIC,EAAM1D,EAAMP,OAAS,GACrBkE,EAAmB,MAAb3D,EAAMP,KACZmE,EAAM5D,EAAMR,MAAQ,GACpBqE,EAAkB,MAAZ7D,EAAMR,IACZsE,EAAML,EAAOhE,OAAS,GACtBsE,EAAoB,MAAdN,EAAOhE,KACbuE,EAAMP,EAAOjE,MAAQ,GAErByE,EAAM,EAAGC,EAAM,EAAGC,EAAM,EAAGC,EAAM,EAYrC,OAVAD,IADAC,GAAOP,GAFgB,MAAbJ,EAAOjE,QAGF,GAGf0E,IADAC,GAAOP,EAAMI,KACE,GAGfC,IADAC,GAAOP,EAAMI,KACE,GAEfE,GAAOP,EAAMI,EAEN,IANPK,GAAO,QAMiB,IATxBC,GAAO,QAQPH,GAAO,QACoC,IAH3CC,GAAO,OAG+ClE,EAAMlD,SAChE,CAQO,SAASiG,GAAS/C,EAAOqE,GAG5B,OAFK3E,GAAO2E,KACRA,EAAa,GAAUA,IACpBpC,GAAIjC,EAAOoB,GAAOiD,GAC7B,CAeO,SAAS,GAASrE,EAAOsE,GAC5B,GAAI7B,GAAOzC,GACP,OAAOA,EAAMlD,SAAW+D,GAAQC,GAIpC,GAHKpB,GAAO4E,KACRA,EAAa,GAAUA,IAEvBtF,GAEA,OAAO,GADGA,GAAKuF,IAAIvE,EAAMR,IAAKQ,EAAMP,KAAM6E,EAAW9E,IAAK8E,EAAW7E,MAChDT,GAAKwF,WAAYxE,EAAMlD,UAEhD,GAAI2F,GAAO6B,GACP,OAAOtE,EAAMlD,SAAW+D,GAAQC,GACpC,GAAI,GAAOd,EAAOkB,IACd,OAAOgC,GAAMoB,GAAcpD,GAAYJ,GAC3C,GAAI,GAAOwD,EAAYpD,IACnB,OAAOgC,GAAMlD,GAASkB,GAAYJ,GACtC,GAAI4B,GAAW1C,GACX,OAAI0C,GAAW4B,GACJ,GAASlD,GAAOpB,GAAQoB,GAAOkD,IAE/BlD,GAAO,GAASA,GAAOpB,GAAQsE,IAEzC,GAAI5B,GAAW4B,GAChB,OAAOlD,GAAO,GAASpB,EAAOoB,GAAOkD,KAEzC,GAAInB,GAASnD,EAAOoC,KAAee,GAASmB,EAAYlC,IACpD,OAAOxB,GAAW4B,GAASxC,GAASwC,GAAS8B,GAAatE,EAAMlD,UAGpE,IAAI4G,EAAM1D,EAAMP,OAAS,GACrBkE,EAAmB,MAAb3D,EAAMP,KACZmE,EAAM5D,EAAMR,MAAQ,GACpBqE,EAAkB,MAAZ7D,EAAMR,IACZsE,EAAMQ,EAAW7E,OAAS,GAC1BsE,EAAwB,MAAlBO,EAAW7E,KACjBuE,EAAMM,EAAW9E,MAAQ,GACzBiF,EAAuB,MAAjBH,EAAW9E,IACjByE,EAAM,EAAGC,EAAM,EAAGC,EAAM,EAAGC,EAAM,EAqBrC,OAnBAD,IADAC,GAAOP,EAAMY,KACE,GAGfP,IADAC,GAAOP,EAAMa,KACE,GACfN,GAAO,MAEPD,IADAC,GAAON,EAAMG,KACE,GAGfC,IADAC,GAAOP,EAAMc,KACE,GACfP,GAAO,MAEPD,IADAC,GAAON,EAAMI,KACE,GACfE,GAAO,MAEPD,IADAC,GAAOL,EAAME,KACE,GAEfE,GAAOP,EAAMe,EAAMd,EAAMK,EAAMJ,EAAMG,EAAMF,EAAMC,EAE1C,IAZPK,GAAO,QAYiB,IAlBxBC,GAAO,QAiBPH,GAAO,QACoC,IAH3CC,GAAO,OAG+ClE,EAAMlD,SAChE,CAgBO,SAAS+F,GAAO7C,EAAO0E,GAG1B,GAFKhF,GAAOgF,KACRA,EAAU,GAAUA,IACpBjC,GAAOiC,GACP,MAAM/R,MAAM,oBAYZ,IAKAgS,EAAQ3B,EAAKnL,EAfjB,GAAImH,GAIA,OAAKgB,EAAMlD,WACS,aAAhBkD,EAAMP,OACW,IAAjBiF,EAAQlF,MAAgC,IAAlBkF,EAAQjF,KAK3B,IADIO,EAAMlD,SAAWkC,GAAK4F,MAAQ5F,GAAK6F,OAAO7E,EAAMR,IAAKQ,EAAMP,KAAMiF,EAAQlF,IAAKkF,EAAQjF,MAC5ET,GAAKwF,WAAYxE,EAAMlD,UAHjCkD,EAKf,GAAIyC,GAAOzC,GACP,OAAOA,EAAMlD,SAAW+D,GAAQC,GAEpC,GAAKd,EAAMlD,SAiCN,CAKD,GAFK4H,EAAQ5H,WACT4H,EA0RL,SAAoB1E,GACvB,OAAIA,EAAMlD,SACCkD,EACJ,GAASA,EAAMR,IAAKQ,EAAMP,MAAM,EAC3C,CA9RsBqF,CAAWJ,IACrBtB,GAAYsB,EAAS1E,GACrB,OAAOa,GACX,GAAIuC,GAAYsB,EA4KjB,SAA4B1E,EAAO+E,GAItC,GAHIrF,GAAOqF,KACPA,EAAU,GAAMA,IAEJ,IADhBA,GAAW,IAEP,OAAO/E,EAEP,IAAIP,EAAOO,EAAMP,KACjB,OAAIsF,EAAU,GAEH,GADG/E,EAAMR,MACSuF,EAAYtF,GAAS,GAAKsF,EAAWtF,IAASsF,EAAS/E,EAAMlD,UAG/E,GADU,KAAZiI,EACWtF,EAEAA,IAAUsF,EAAU,GAFd,EAAG/E,EAAMlD,SAI3C,CA7LiCkI,CAAmBhF,EAAO,IAC/C,OAAOsC,GACXzK,EAAMgJ,EACV,KA3CqB,CAGjB,GAAI,GAAOb,EAAOkB,IACd,OAAI,GAAOwD,EAASrC,KAAQ,GAAOqC,EAASnC,IACjCrB,GACF,GAAOwD,EAASxD,IACdmB,GAKH,GADJsC,EAyJT,SAAmB3E,EAAO+E,GAG7B,OAFIrF,GAAOqF,KACPA,EAAU,GAAMA,IACI,IAAnBA,GAAW,IACL/E,EACF+E,EAAU,GACR,GAAS/E,EAAMR,KAAOuF,EAAU/E,EAAMP,MAAQsF,EAAY/E,EAAMR,MAAS,GAAKuF,EAAW/E,EAAMlD,UAE/F,GAAS,EAAGkD,EAAMR,KAAQuF,EAAU,GAAK/E,EAAMlD,SAC9D,CAlKyBmI,CAAUpC,GAiL5B,SAAoB7C,EAAO+E,GAG9B,OAFIrF,GAAOqF,KACPA,EAAU,GAAMA,IACI,IAAnBA,GAAW,IACL/E,EACF+E,EAAU,GACR,GAAU/E,EAAMR,MAAQuF,EAAY/E,EAAMP,MAAS,GAAKsF,EAAW/E,EAAMP,MAAQsF,EAAS/E,EAAMlD,UAEhG,GAASkD,EAAMP,MAASsF,EAAU,GAAK/E,EAAMP,MAAQ,EAAI,GAAK,EAAGO,EAAMlD,SACtF,CA3L+BoI,CAAWlF,EAAO,GACG0E,GAAU,GAC3B5D,IACR4B,GAAWgC,GAAWrC,GAAME,GAInC1K,EAAMoK,GAAI0C,EAAQ9B,GADlBG,EAAMD,GAAS/C,EAAO,GAAS0E,EAASC,IACVD,IAKrC,GAAI,GAAOA,EAASxD,IACrB,OAAOlB,EAAMlD,SAAW+D,GAAQC,GACpC,GAAI4B,GAAW1C,GACX,OAAI0C,GAAWgC,GACJ7B,GAAOzB,GAAOpB,GAAQoB,GAAOsD,IACjCtD,GAAOyB,GAAOzB,GAAOpB,GAAQ0E,IAEnC,GAAIhC,GAAWgC,GAChB,OAAOtD,GAAOyB,GAAO7C,EAAOoB,GAAOsD,KACvC7M,EAAMiJ,EACV,CAkBA,IADAkC,EAAMhD,EACCqD,GAAmBL,EAAK0B,IAAU,CAGrCC,EAASlD,KAAKxK,IAAI,EAAGwK,KAAK0D,MAAM3C,GAASQ,GAAOR,GAASkC,KAOzD,IAJA,IAAIU,EAAO3D,KAAK4D,KAAK5D,KAAK6D,IAAIX,GAAUlD,KAAK8D,KAAMC,EAASJ,GAAQ,GAAM,EAAI5D,GAAQ,EAAG4D,EAAO,IAGhGK,EAAY7E,GAAW+D,GAASe,EAAY,GAASD,EAAWf,GACzDhC,GAAWgD,IAActC,GAAYsC,EAAW1C,IAGnD0C,EAAY,GADZD,EAAY7E,GADZ+D,GAAUa,EACqBxF,EAAMlD,UACL4H,GAIhCjC,GAAOgD,KACPA,EAAYpD,IAChBxK,EAAMoK,GAAIpK,EAAK4N,GACfzC,EAAMD,GAASC,EAAK0C,EACxB,CACA,OAAO7N,CACX,CCv9BA,MAGa,GAAc,GACd,GAAiB,GACjB,GAAc,GACd,GAAc,GAEd8N,GAAmB,GAInB,GDkgCN,SAAa3F,EAAO9G,GAGvB,OAFKwG,GAAOxG,KACRA,EAAQ,GAAUA,IACf,GAAS8G,EAAMR,IAAMtG,EAAMsG,IAAKQ,EAAMP,KAAOvG,EAAMuG,KAAMO,EAAMlD,SAC1E,EC5/Ba,GAAS,GACT,GAAU,GACV,GAAU,GACV,GAAW,GAEX,GAAa,GAGb,GAAQ,GAER,GAAW,GACX,GAAW,GA+BjB,SAAS,GAAYrK,EAAOqK,EAAU9I,GACzC,IAAI1C,EAAImB,EACJmT,EAAK,EACT,OAAQ5R,GACJ,KAAK,EACD1C,EAAImB,GAAS,IAAM,GACnBmT,EAAKtU,EACL,MACJ,KAAK,EACDA,EAAImB,GAAS,KAAO,GACpB,MACJ,KAAK,EACDnB,EAAImB,GAAS,IAAM,GACnBmT,EAAKtU,EACL,MACJ,KAAK,EACDA,EAAImB,GAAS,KAAO,GACpB,MACJ,KAAK,EACDnB,EAAImB,GAAS,EACbmT,EAAKtU,EACL,MACJ,KAAK,EACDA,EAAImB,IAAU,EAGtB,OAAO,GAAiBnB,EAAGsU,GAAM,GAAI9I,EACzC,CACO,SAAS,GAAMnJ,EAAKsJ,EAAOH,EAAU+I,EAAU1R,GAClD,MAAM0D,EAAMmF,GAAQrJ,EAAKsJ,EAAO9I,GAChC,GAAW,MAAP0D,EAAa,CACb,MAAMiO,EAAc,CAACxU,EAAGS,KACpB,MAAM+C,EAAM2M,KAAKxK,IAAI3F,EAAEoC,OAAQ3B,EAAE2B,QACjC,OAAOpC,EAAEyU,SAASjR,EAAK,MAAQ/C,EAAEgU,SAASjR,EAAK,IAAI,EAEjD4N,EAA0B,MAAb7K,EAAI+F,KACjBoI,EA9Dd,SAAqBlJ,EAAU3I,EAAOuO,GAClC,OAAQvO,GACJ,KAAK,EAAG,OAAO2I,EACX,mEACC4F,EAAa,mEACR,kEACV,KAAK,EAAG,OAAO5F,EACX,yBACC4F,EAAa,yBAA2B,wBAC7C,KAAK,GAAI,OAAO5F,EACZ,uBACC4F,EAAa,sBAAwB,sBAC1C,KAAK,GAAI,OAAO5F,EACZ,mBACC4F,EAAa,mBAAqB,mBACvC,QAAS,MAAM,IAAI/P,MAAM,kBAEjC,CA6CyBsT,CAAYnJ,GAA0B,KAAdjF,EAAI1D,MAAc0D,EAAI1D,MAAOuO,GACtE,GAAIoD,EAAYjO,EAAIwF,OAAO6I,cAAeF,GAEtC,OADArS,EAAM+O,EAAa7K,EAAI+F,KAAO/F,EAAIwF,OAASxF,EAAIwF,OACxC,GAAmB1J,EAAKmJ,EAAUjF,EAAI1D,MAErD,CACA,MAAM,IAAIxB,MAAM,4CACpB,CACO,SAAS,GAASgB,EAAKsJ,EAAOH,EAAUC,EAASuB,GACpD,IAEI,OADAA,EAASzE,SAAW,GAAMlG,EAAKsJ,EAAOH,IAC/B,CAIX,CAFA,MAAOnB,GACH,OAAO,CACX,CACJ,CC3GO,SAAS,GAAmB5H,GAC/B,MAAMoS,EAAUpS,EAAS,EAGnBqS,GAFNrS,EAAS0N,KAAK4E,IAAItS,IAEQ,KAAW,IACrC,OAAQoS,EAAU,IAAM,KACpB,KAHapS,EAAS,MAGF,GAAK,IACzB,EAAaqS,EAAS,EAC9B,CACO,SAASE,GAAoBzS,EAAM0S,GACtC,MAAM5S,EAAME,EAAK2S,cACjB,MAAgB,UAATD,EACD5S,EAAImO,UAAU,EAAGnO,EAAIoF,QAAQ,MAC7BpF,EAAImO,UAAUnO,EAAIoF,QAAQ,KAAO,EAAGpF,EAAID,OAAS,EAC3D,CAsBA,SAAS+S,GAA6B5S,EAAM6S,EAAQC,GAChD,OAAOD,EAAOvJ,QAAQ,YAAayJ,IAC/B,IAAIC,EAAM9I,OAAO+I,IACjB,OAAQF,EAAM9E,UAAU,EAAG,IACvB,IAAK,IACD,MAAM/P,EAAI4U,EAAM9S,EAAKkT,iBAAmBlT,EAAKmT,cAC7CH,EAAMD,EAAMlT,OAAS,EAAI3B,EAAI,IAAMA,EACnC,MACJ,IAAK,IACD8U,GAAOF,EAAM9S,EAAKoT,cAAgBpT,EAAKqT,YAAc,EACrD,MACJ,IAAK,IACDL,EAAMF,EAAM9S,EAAKsT,aAAetT,EAAKuT,UACrC,MACJ,IAAK,IACDP,EAAMF,EAAM9S,EAAKwT,cAAgBxT,EAAKyT,WACtC,MACJ,IAAK,IACD,MAAMzS,EAAI8R,EAAM9S,EAAKwT,cAAgBxT,EAAKyT,WAC1CT,EAAMhS,EAAI,GAAKA,EAAI,GAAKA,EACxB,MACJ,IAAK,IACDgS,EAAMF,EAAM9S,EAAK0T,gBAAkB1T,EAAK2T,aACxC,MACJ,IAAK,IACDX,EAAMF,EAAM9S,EAAK4T,gBAAkB5T,EAAK6T,aACxC,MACJ,IAAK,IACDb,EAAMF,EAAM9S,EAAK8T,qBAAuB9T,EAAK+T,kBAGrD,OAAI7J,OAAOE,MAAM4I,GACND,EAGCC,EAAM,IAAMD,EAAMlT,OAAS,EAAK,IAAMmT,EAAM,GAAKA,CAC7D,GAER,CA8CO,SAAS,GAAShT,EAAM6S,EAAQmB,GACnC,OAAsB,MAAfhU,EAAKE,OA9ChB,SAAgCF,EAAM6S,GAClC,IAAI/K,EAAImM,EAAIC,EACZ,MAAMC,EAAI,IAAIzS,KAAK1B,EAAK2B,WAAoC,QAAtBmG,EAAK9H,EAAKE,cAA2B,IAAP4H,EAAgBA,EAAK,IACzF,GAAsB,iBAAX+K,EACP,OAAOsB,EAAExB,cAAcrJ,QAAQ,QAAS,IAAIA,QAAQ,eAAgB,KAAO,GAA2C,QAAtB2K,EAAKjU,EAAKE,cAA2B,IAAP+T,EAAgBA,EAAK,GAElJ,GAAsB,IAAlBpB,EAAOhT,OAYZ,OAAO+S,GAA6BuB,EAAGtB,GAAQ,GAX/C,OAAQA,GACJ,IAAK,IACL,IAAK,IAAK,OAAOJ,GAAoB0B,EAAG,SACxC,IAAK,IACL,IAAK,IAAK,OAAO1B,GAAoB0B,EAAG,UACxC,IAAK,IACL,IAAK,IAAK,OAxDtB,SAAmCC,EAAgBlU,GAC/C,MAAMJ,EAAMsU,EAAezB,cAC3B,OAAO7S,EAAImO,UAAU,EAAGnO,EAAID,OAAS,GAAK,GAAmBK,EACjE,CAqD6BmU,CAA0BF,EAA2B,QAAtBD,EAAKlU,EAAKE,cAA2B,IAAPgU,EAAgBA,EAAK,GACnG,QAAS,MAAM,IAAIpV,MAAM,kCAMrC,CA2BUwV,CAAuBtU,EAAM6S,GA1BvC,SAA8B7S,EAAM6S,GAChC,MAAMC,EAAoB,IAAd9S,EAAKG,KACjB,GAAsB,iBAAX0S,EACP,OAAOC,EAAM9S,EAAKuU,cAAgBvU,EAAKwU,iBAEtC,GAAsB,IAAlB3B,EAAOhT,OAgBZ,OAAO+S,GAA6B5S,EAAM6S,EAAQC,GAflD,OAAQD,GACJ,IAAK,IACL,IAAK,IACD,OAAOC,EAAML,GAAoBzS,EAAM,SAAWA,EAAKyU,qBAC3D,IAAK,IACL,IAAK,IACD,OAAO3B,EAAML,GAAoBzS,EAAM,UAAYA,EAAK0U,qBAC5D,IAAK,IACL,IAAK,IACD,OAhGhB,SAAyBP,EAAGrB,GACxB,GAAIA,EACA,OAAOqB,EAAExB,cAER,CAED,MAAMgC,EAAwB,MAAVR,EAAEhU,MAAiC,IAAXgU,EAAEhU,KAC9C,OAAO,EAAagU,EAAEhB,cAAe,GAAK,IACtC,EAAagB,EAAEd,WAAa,EAAG,GAAK,IACpC,EAAac,EAAEZ,UAAW,GAAK,IAC/B,EAAaY,EAAEV,WAAY,GAAK,IAChC,EAAaU,EAAER,aAAc,GAAK,IAClC,EAAaQ,EAAEN,aAAc,GAAK,IAClC,EAAaM,EAAEJ,kBAAmB,IACjCY,EAAc,IAA4C,IAAzBR,EAAE/T,qBAAgC,GAC5E,CACJ,CAgFuBwU,CAAgB5U,EAAM8S,GACjC,QACI,MAAM,IAAIhU,MAAM,kCAMhC,CAIU+V,CAAqB7U,EAAM6S,EACrC,CACO,SAAS,GAASjU,EAAOuB,GAC5B,MAAMgU,EAAI,IAAIzS,KAAK9C,GAEnB,OADAuV,EAAEhU,KAAqD,GAArC,MAARA,EAAe,EAAsBA,GACxCgU,CACX,CAkCO,SAASW,GAASC,GACrB,SAASC,IACL,MAAM,IAAIlW,MAAM,mCAAmCiW,IACvD,CACa,MAATA,GAAkC,KAAjBA,EAAME,QACvBD,IAGiB,KAAjBD,EAAMlV,QAA8B,MAAbkV,EAAM,IAA2B,MAAbA,EAAM,KACjDA,GAAS,aAEb,IAAI/U,EAAO,IAAI0B,KAAKqT,GAChB7U,EAAS,KACb,GAAIkK,MAAMpK,EAAK2B,WAAY,CAGvB,MAAMuT,EAAI,yHAAyH7L,KAAK0L,GACxI,GAAS,MAALG,EAAW,CACX,IAAIC,EACAC,EAAgB,EACpB,GAAY,MAARF,EAAE,GAAY,CACd,MAAMG,EAAYH,EAAE,GAAGI,MAAM,KAC7BF,EACiC,KAA7BjL,SAASkL,EAAU,GAAI,IACiB,GAApClL,SAASkL,EAAU,IAAM,IAAK,IAC9BE,WAAWF,EAAU,IAAM,KACvB,MAARH,EAAE,IAAqC,OAAvBA,EAAE,GAAG7C,gBACrB+C,GAAiB,IAEzB,CACA,GAAY,MAARF,EAAE,GAAY,CACd,GAAY,MAARA,EAAE,GACFC,EAAW,IAAIzT,KAAKwT,EAAE,GAAK,YAE1B,CACD,MAAMf,EAAI,IAAIzS,KACdyT,EAAW,IAAIzT,KAAKyS,EAAEjB,iBAAmB,KAAOiB,EAAEf,cAAgB,GAAK,IAAMe,EAAEb,aACnF,CACA,GAAa,MAAT4B,EAAE,GACFhV,EAAS,QAER,CACD,IAAIsV,EAAuC,GAArBrL,SAAS+K,EAAE,GAAI,IAAW/K,SAAS+K,EAAE,IAAM,IAAK,IACtD,MAAZA,EAAE,GAAG,KACLM,IAAoB,GAExBtV,EAASsV,EACTJ,GAAmC,GAAlBI,CACrB,CACJ,MAEI,GAAY,MAARN,EAAE,GACFC,EAAW,IAAIzT,KAAKwT,EAAE,QAErB,CACD,MAAMf,EAAI,IAAIzS,KACdyT,EAAW,IAAIzT,KAAKyS,EAAEhB,cAAgB,KAAOgB,EAAEd,WAAa,GAAK,IAAMc,EAAEZ,UAC7E,CAEJvT,EAAO,IAAI0B,KAAKyT,EAASxT,UAA4B,IAAhByT,GAErCpV,EAAO,IAAI0B,KAAK1B,EAAK2B,UAAwE,KAA3D3B,EAAKI,oBAAsB+U,EAAS/U,qBAC1E,MAEI4U,IAGA5K,MAAMpK,EAAK2B,YACXqT,GAER,CACA,MAAO,CAAChV,EAAME,EAClB,CACO,SAAS,GAAMJ,EAAK2V,GAAY,GACnC,MAAOzV,EAAME,GAAU4U,GAAShV,GAG1BK,EAAiB,MAAVD,EACNuV,GAAwB,MAAXvV,EAAiB,EAAc,EAC7C,EACN,OAAO,GAASF,EAAK2B,UAAWxB,EACpC,CC/OO,SAAS,GAAOL,GACnB,OAAOA,EAAIwJ,QAAQ,sCAAuC,OAC9D,CCdA,MAAMoM,GAAiB,gDAEjBC,GAAe,wDACrB,SAASC,GAAWnY,EAAGS,GACnB,OLJG,SAAiBT,EAAGS,GACvB,MAAiB,iBAANT,EACAA,EAAIS,GAAK,EAAKT,EAAIS,EAAI,EAAI,EAG1BT,EAAEuF,UAAU9E,EAE3B,CKHW,CAAeT,EAAGS,GAAK,CAClC,CAgFO,SAAS2X,GAAOd,GACnB,MAAO,CACHA,QACAe,MAiJiBhW,EAjJFiV,EAkJXe,IACJJ,GAAeK,UAAY,EAC3B,MAAMC,EAAW,GACXC,EAAU,GAChB,IAAIC,EAAS,EACTnD,EAAQ2C,GAAerM,KAAKvJ,GAChC,KAAOiT,GAAO,CAGV,MAAMoD,EAAapD,EAAMqD,OAASrD,EAAM,IAAM,IAAIlT,OAClDmW,EAASK,KAAKvW,EAAImO,UAAUiI,EAAQC,GAAY7M,QAAQ,MAAO,MAC/D2M,EAAQI,KAAKtD,GACbmD,EAASR,GAAeK,UAExBL,GAAeK,WAAa,EAC5BhD,EAAQ2C,GAAerM,KAAKvJ,EAChC,CACA,OAAwB,IAApBkW,EAASnW,OACFiW,EAAKhW,EAAIwJ,QAAQ,MAAO,OAG/B0M,EAASK,KAAKvW,EAAImO,UAAUiI,GAAQ5M,QAAQ,MAAO,MAC5CgN,GAAcR,EAAME,EAAUC,GACzC,IAxBD,IAAkBnW,CA/IzB,CAsBA,SAASyW,GAAcT,EAAM5R,GACzB,MAAsB,iBAARA,EAAmB4R,EAAK5R,GAAOA,EAAI4R,KAAKA,EAC1D,CAQO,SAASU,GAAOtS,GACnB,OAAOqS,IAAe9Y,GAAMA,GAAGyG,EACnC,CACO,SAASuS,GAAOvS,GACnB,OAAOqS,IAAe9Y,IAClB,MAAM,IAAIqB,MAAMrB,EAAE,GACnByG,EACP,CACA,SAASwS,GAAkB1D,EAAK2D,EAAOC,EAAWC,EAAWhE,GACzD,IAAI9I,EAAO,GAGX,GAFA4M,EAAQA,GAAS,GACjB9D,EAASA,GAAU,GACflI,GAAUqI,GAgBV,OAf6B,MAAzBH,EAAOiE,gBACHlB,GAAW5C,EAAK,IAChBA,EAAMpI,GAASoI,GAAM,GACrBjJ,EAAO,KAGH4M,EAAMzR,QAAQ,MAAQ,EACtB6E,EAAO,IAEF4M,EAAMzR,QAAQ,MAAQ,IAC3B6E,EAAO,MAInB8M,EAAyB,MAAbA,EAAoB,KAAO1M,SAAS0M,EAAW,IACnDhE,GACJ,IAAK,IACL,IAAK,IAEDG,EAAMnI,GAAQmI,EADd6D,EAAyB,MAAbA,EAAoBA,EAAY,GAE5C,MACJ,IAAK,IACL,IAAK,IACD7D,EAAmB,MAAb6D,EAAoB9L,GAAYiI,EAAK6D,GAAa9L,GAAYiI,GACpE,MACJ,IAAK,IACL,IAAK,IACDA,EAAmB,MAAb6D,EAAoB5L,GAAc+H,EAAK6D,GAAa5L,GAAc+H,GACxE,MACJ,IAAK,IACDA,EAAM9H,GAAM8H,GACZ,MACJ,IAAK,IACDA,EAAM9H,GAAM8H,GAAKX,cACjB,MACJ,QACIW,EAAMpO,OAAOoO,QAKrBA,EADKA,aAAetR,KACd,GAAasR,GAGb,EAASA,GAGnB,GADA4D,EAAiC,iBAAdA,EAAyBA,EAAYzM,SAASyM,EAAW,IACvExM,MAAMwM,GAaP5D,EAAMjJ,EAAOiJ,MAbM,CACnB,MAAM+D,EAAWJ,EAAMzR,QAAQ,MAAQ,EACjC8R,EAAYL,EAAMzR,QAAQ,MAAQ,EAClC+R,EAAKD,IAAcD,EAAW,IAAM,IAGtC/D,EAFO,MAAPiE,EAEMlN,GADNiJ,EAAMkE,GAAQlE,EAAK4D,EAAY7M,EAAKlK,OAAQoX,EAAID,IAI1CE,GAAQnN,EAAOiJ,EAAK4D,EAAWK,EAAID,EAEjD,CAIA,OAAOhE,CACX,CACA,SAASsD,GAAcR,EAAMqB,EAAWC,EAAUC,EAAU,GAAIC,GAAS,GACrE,MAAO,IAAIvT,KAEP,IAAI4B,EAAS0R,EACb,MAAMrB,EAAWmB,EAAUI,QACrBtB,EAAUmB,EAASG,QACzB,IAAK,MAAMrT,KAAOH,EAAM,CACpB,MAAO,CAAE,CAAE4S,EAAOa,EAAYX,EAAWhE,GAAUoD,EAAQ,GAC3D,IAAIW,EAAYY,EAChB,GAAIF,GAAU,EACVV,EAAYU,EACZA,GAAU,OAET,GAAkB,MAAdV,EAAmB,CACxB,GAAI1S,EAAM,EACN,MAAM,IAAIpF,MAAM,gCAEpBwY,EAASpT,EACT,QACJ,CACAyB,GAAUqQ,EAAS,GACnBrQ,GAAU+Q,GAAkBxS,EAAKyS,EAAOC,EAAWC,EAAWhE,GAC9DmD,EAAS5Q,OAAO,EAAG,GACnB6Q,EAAQ7Q,OAAO,EAAG,EACtB,CACA,OAAuB,IAAnB6Q,EAAQpW,QACR8F,GAAUqQ,EAAS,GACZF,EAAKnQ,IAGL2Q,GAAcR,EAAME,EAAUC,EAAStQ,EAAQ2R,EAC1D,CAER,CA4BO,SAASzE,GAAO/S,KAAQiE,GAM3B,MALmB,iBAARjE,GAAoBiE,EAAKlE,OAAS,IAEzCC,EAAMiE,EAAK,GACXA,EAAK0T,SAEF3X,EAAIwJ,QAAQqM,IAAc,CAAC+B,EAAGC,EAAKf,EAAW/D,EAAQgE,EAAWe,KACpE,GAAID,EAAM,GAAKA,GAAO5T,EAAKlE,OACvB,MAAM,IAAIf,MAAM,+EAEpB,IAAIkU,EAAMjP,EAAK4T,GACf,GAAIhN,GAAUqI,GAEV,OADA6D,EAAyB,MAAbA,EAAoB,KAAO1M,SAAS0M,EAAW,IACnDhE,GACJ,IAAK,IACL,IAAK,IAEDG,EAAMnI,GAAQmI,EADd6D,EAAyB,MAAbA,EAAoBA,EAAY,GAE5C,MACJ,IAAK,IACL,IAAK,IACD7D,EAAmB,MAAb6D,EAAoB9L,GAAYiI,EAAK6D,GAAa9L,GAAYiI,GACpE,MACJ,IAAK,IACL,IAAK,IACDA,EAAmB,MAAb6D,EAAoB5L,GAAc+H,EAAK6D,GAAa5L,GAAc+H,GACxE,MACJ,IAAK,IACL,IAAK,IACD6D,EAAyB,MAAbA,EAAoBA,EAAY,EAC5C7D,EAAMnI,GAAQD,GAASoI,EAAK,KAAM6D,GAAa,KAC/C,MACJ,IAAK,IACL,IAAK,IACD7D,EAAmB,MAAb6D,EAAoBK,GAAQtS,OAAOoO,GAAM6D,EAAW,KAAOjS,OAAOoO,GACxE,MACJ,IAAK,IACL,IAAK,IACDA,EAAmB,MAAb6D,EAAoBK,GAAQhM,GAAM8H,GAAM6D,EAAW,KAAO3L,GAAM8H,GACvD,MAAXH,IACAG,EAAMA,EAAIX,eAEd,MACJ,QACI,GAAIuF,EAAS,CACT,IAAI7N,EAAO,GACXiJ,EAAM4E,EAAQtO,QAAQ,sBAAsB,CAACoO,EAAGG,EAASC,KACjDlC,GAAW5C,EAAK,KAChBA,EAAMpI,GAASoI,GAAM,GACrBjJ,EAAO,KAEX,MAAMgO,EAAmC,MAAfD,EAAsBA,EAAYjY,OAAS,EAGrE,GAFAmT,EAAMnI,GAAQmI,EAAKpF,KAAKxK,IAAI2U,EAAoB,EAAG,IAE/CF,EAAQ3S,QAAQ,KAAO,EAAG,CAC1B,MAAO2S,EAASC,GAAe9E,EAAIsC,MAAM,KACnC1V,EAAIiY,EAAQhY,OAAS,EACrBmY,EAAiBpK,KAAK0D,MAAMuG,EAAQhY,OAAS,GACnD,IAAIoY,EAAYrY,EAAI,EAAIiY,EAAQhQ,OAAO,EAAGjI,IAAMoY,EAAiB,EAAI,IAAM,IAAM,GACjF,IAAK,IAAIlV,EAAI,EAAGA,EAAIkV,EAAgBlV,IAChCmV,GAAaJ,EAAQhQ,OAAOjI,EAAQ,EAAJkD,EAAO,IAAMA,EAAIkV,EAAiB,EAAI,IAAM,IAEhFhF,EAAM8E,EAAcG,EAAY,IAAMH,EAAcG,CACxD,CAGA,MAAMC,GADNL,EAAUA,EAAQvO,QAAQ,KAAM,KACFzJ,OAAS,GAAoB,MAAfgY,EAAQ,GAAaA,EAAQhY,OAAS,EAClF,OAAOqX,GAAQlE,EAAKkF,EAAgBnO,EAAKlK,OAASkY,EAAmB,IAAI,IAE7E/E,EAAMjJ,EAAOiJ,CACjB,OAIRA,EADKA,aAAetR,KACd,GAAasR,EAAK4E,GAAW/E,GAG7B,EAASG,GAMnB,OAJA4D,EAAYzM,UAAUyM,GAAa,KAAK3I,UAAU,GAAI,IACjD7D,MAAMwM,KACP5D,EAAMkE,GAAQtS,OAAOoO,GAAMpF,KAAK4E,IAAIoE,GAAY,IAAKA,EAAY,IAE9D5D,CAAG,GAElB,CACO,SAASmF,GAASrY,EAAKsY,GAC1B,MAAMT,EAAM7X,EAAI8H,YAAYwQ,GAC5B,OAAOT,GAAO,GAAKA,IAAQ7X,EAAID,OAASuY,EAAOvY,MACnD,CAiBO,SAASwY,GAAcvY,GAC1B,MAAsB,iBAARA,GAAmC,IAAfA,EAAID,MAC1C,CAOO,SAAS,GAAKyY,EAAWC,GAC5B,OAAI7a,MAAMC,QAAQ4a,GACPA,EAAG7T,KAAK4T,GAGR5a,MAAM8a,KAAKD,GAAI7T,KAAK4T,EAEnC,CAkBO,SAASG,GAAiBC,GAC7B,MAAMC,EAAyB,mBAATC,KAAsBA,KAAKF,GAXrD,SAAsB/T,GAClB,MAAM,IAAI7F,MAAM,oCAAsC6F,EAAO,4BACjE,CASmEkU,CAAa,QACtE/M,EAAQ,IAAIP,WAAWoN,EAAO9Y,QACpC,IAAK,IAAID,EAAI,EAAGA,EAAI+Y,EAAO9Y,OAAQD,IAC/BkM,EAAMlM,GAAK+Y,EAAOzX,WAAWtB,GAEjC,OAAOkM,CACX,CACO,SAASoL,GAAQpX,EAAKmB,EAAKgW,EAAI6B,GAClC7B,EAAKA,GAAM,IACXhW,GAAYnB,EAAID,OAChB,IAAK,IAAID,EAAI,EAAGA,EAAIqB,EAAKrB,IACrBE,EAAMgZ,EAAUhZ,EAAMmX,EAAKA,EAAKnX,EAEpC,OAAOA,CACX,CAaO,SAAS,GAAQA,EAAKsY,EAAQ9O,GACjC,OAAOxJ,EAAIwJ,QAAQ,IAAIyP,OAAO,GAAOX,GAAS,KAAM9O,EACxD,CAUO,SAAS,GAAMxJ,EAAKkZ,EAAWpY,EAAOqY,GAGzC,GADAA,EAA6B,iBAAZA,EAAuBA,EAAU,GADlDrY,EAAyB,iBAAVA,EAAqBA,OAAQvB,IAE/BuB,EAAQ,EACjB,MAAM,IAAI9B,MAAM,kCAEpB,GAAc,IAAV8B,EACA,MAAO,GAEX,MAAMsY,EAAgC,IAAP,EAAVD,GACfhE,EAAyB,IAAP,EAAVgE,GAGdD,GADAA,GADAA,EAAYA,GAAa,IACHG,QAAO1b,GAAKA,IAAGqE,IAAI,KACnBjC,OAAS,EAAImZ,EAAY,CAAC,OAChD,MAAMI,EAAS,GACTC,EAAM,IAAIN,OAAOC,EAAUtU,KAAK,KAAM,KAC5C,IAAI4U,GAAa,EACb1Z,EAAI,EACR,EAAG,CACC,MAAMmT,EAAQsG,EAAIhQ,KAAKvJ,GACvB,GAAc,OAAViT,EAAgB,CAChB,MAAMwG,EAAYtE,EAAOnV,EAAImO,UAAUrO,GAAGqV,OAASnV,EAAImO,UAAUrO,KAC5DsZ,GAAeK,EAAU1Z,OAAS,IACnCuZ,EAAO/C,KAAKkD,GAEhBD,GAAa,CACjB,KACK,CACD,MAAMC,EAAYtE,EAAOnV,EAAImO,UAAUrO,EAAGmT,EAAMqD,OAAOnB,OAASnV,EAAImO,UAAUrO,EAAGmT,EAAMqD,SAClF8C,GAAeK,EAAU1Z,OAAS,KACtB,MAATe,GAAiBwY,EAAOvZ,OAAS,IAAMe,GACvCwY,EAAO/C,KAAKpB,EAAOnV,EAAImO,UAAUrO,GAAGqV,OAASnV,EAAImO,UAAUrO,IAC3D0Z,GAAa,GAGbF,EAAO/C,KAAKkD,IAGpB3Z,EAAIyZ,EAAItD,SACZ,CACJ,OAASuD,GACT,OAAOF,CACX,CCpeO,MAAMI,GACTnb,YAAYO,GACRJ,KAAKI,MAAQA,CACjB,CACAmG,SACI,OAAOvG,KAAKI,KAChB,CAEAmB,WACI,OAAO6E,OAAOpG,KAAKI,MACvB,CACAb,cACI,OAAO,EAAeS,KAAKI,MAC/B,CACAuD,OAAOkD,GACH,OAAa,MAATA,GAIO,EAAO7G,KAAKI,MAAOyG,aAAiBmU,GAAOnU,EAAMzG,MAAQyG,EAExE,CACArC,UAAUqC,GACN,OAAa,MAATA,EACO,EAGA,EAAQ7G,KAAKI,MAAOyG,aAAiBmU,GAAOnU,EAAMzG,MAAQyG,EAEzE,EAEG,SAAS,GAAK5H,GACjB,OAAY,MAALA,GAAaA,aAAa+b,GAAO,IAAIA,GAAK/b,GAAKA,CAC1D,CACO,SAAS,GAAMA,GAClB,GAAS,MAALA,EACA,MAAM,IAAIqB,MAAM,uBAGhB,OAAOrB,aAAa+b,GAAO/b,EAAEmB,MAAQnB,CAE7C,CAeO,SAAS,GAAWgc,EAAKC,GAC5B,OAAe,MAAPD,EAAe,GAAMA,GAAOC,CACxC,CC3DO,MAAM,GAAsB,iEActB,GAAuB,6DCX7B,SAASC,GAA8BpV,EAAMtD,GAChD,MAAsB,mBAAVsD,EACD,IAAIA,EAAKtD,GAGT,IAAIvD,MAAMuD,EAEzB,CAEA,SAAS2Y,KACL,MAAM,IAAK9a,MAAM,qEACrB,CAuBO,SAAS,GAAK+a,EAAQC,EAAalZ,EAAOhC,GAC7C,MAAMmb,EAAsB,EAAdD,EACd,OAAOD,EAAOG,KAAKpb,EAAOmb,EAAQA,EAAQnZ,EAC9C,CAuBO,SAASqZ,GAAWpW,EAAGqW,EAAQ3V,GAClC,MAAMtD,EAAsB,EAAhBiZ,EAAOra,OACbga,EAASF,GAA8BpV,EAAMtD,GACnD,IAAK,IAAIrB,EAAI,EAAGA,GAAMqB,EAAM,EAAIrB,IAC5Bia,EAAOja,GAAKiE,EAAEjE,EAAGsa,EAAOta,IAE5B,OAAOia,CACX,CAEO,SAAS,GAAIhW,EAAGqW,EAAQ3V,GAC3B,MAAMtD,EAAsB,EAAhBiZ,EAAOra,OACbga,EAASF,GAA8BpV,EAAMtD,GACnD,IAAK,IAAIrB,EAAI,EAAGA,GAAMqB,EAAM,EAAIrB,IAC5Bia,EAAOja,GAAKiE,EAAEqW,EAAOta,IAEzB,OAAOia,CACX,CA+FO,SAAS,GAAOM,EAAQ5V,GAC3B,MAAM6V,EAAW1c,MAAMC,QAAQwc,GAAUA,EAAUzc,MAAM8a,KAAK2B,GAE9D,OADqC,EAAlBC,EAASva,QAExB,KAAK,EACD,OAAO8Z,GAA8BpV,EAAM,GAE/C,KAAK,EACD,OAAO6V,EAAS,GAEpB,QAAS,CACL,IAAIC,EAAW,EACXC,EAAc,EAClB,IAAK,IAAI3C,EAAM,EAAGA,GAAQyC,EAASva,OAAS,EAAI8X,IAE5C2C,EAAgBA,EADFF,EAASzC,GACa9X,OAAU,EAElD,MAAM8F,EAASgU,GAA8BpV,EAAM+V,GACnD,IAAK,IAAIC,EAAQ,EAAGA,GAAUH,EAASva,OAAS,EAAI0a,IAAS,CACzD,MAAMC,EAAQJ,EAASG,GACvB,IAAK,IAAIzX,EAAI,EAAGA,GAAM0X,EAAM3a,OAAS,EAAIiD,IACrC6C,EAAO0U,GAAYG,EAAM1X,GACzBuX,EAAaA,EAAW,EAAK,CAErC,CACA,OAAO1U,CACX,EAER,CAmCO,SAAS,GAAU/G,EAAO2F,GAC7B,MAAMkW,EAAKd,GAA8BpV,EAAM,GAE/C,OADAkW,EAAG,GAAK7b,EACD6b,CACX,CAEO,SAAS,GAAW7Z,EAAO8Z,EAAanW,GAC3C,GAAI3D,EAAQ,EACR,MAAM,IAAK9B,MAAM,0DAErB,MAAM6G,EAASgU,GAA8BpV,EAAM3D,GACnD,IAAK,IAAIhB,EAAI,EAAGA,GAAMgB,EAAQ,EAAIhB,IAC9B+F,EAAO/F,GAAK8a,EAAY9a,GAE5B,OAAO+F,CACX,CAiFO,SAASgV,GAAK/Z,EAAOga,EAAOrW,GAC/B,GAAI3D,EAAQ,EACR,MAAM,IAAK9B,MAAM,0DAErB,GAAI8B,EAAQga,EAAM/a,OACd,MAAM,IAAKf,MAAM,8DAErB,GAAc,IAAV8B,EACA,OAAO+Y,GAA8BpV,EAAM,GAE1C,CACD,MAAMwV,EAAQ,EACd,OAAOa,EAAMrD,MAAMwC,EAAQA,EAAQnZ,EACvC,CACJ,CAkIO,SAAS,GAAQia,EAAWD,GAC/B,OAAOA,EAAME,KAAKD,EACtB,CAoMO,SAAS,GAAKE,EAAQC,EAAOJ,GAChC,OAAOA,EAAMtZ,OAAO,EAAU0Z,EAClC,CAiKO,SAASC,GAAIC,EAAQC,GACpBD,EAAOrb,SAAWsb,EAAOtb,QAvzBjC,WACI,MAAM,IAAKf,MAAM,+BACrB,CAszBQsc,GAEJ,MAAMzV,EAAS,IAAIjI,MAAMwd,EAAOrb,QAChC,IAAK,IAAID,EAAI,EAAGA,GAAMsb,EAAOrb,OAAS,EAAID,IACtC+F,EAAO/F,GAAK,CAACsb,EAAOtb,GAAIub,EAAOvb,IAEnC,OAAO+F,CACX,CAyEO,SAAS0V,GAAWC,EAAQJ,EAAQC,GACvC,GAAc,MAAVD,EACA,OAAc,MAAVC,EAOH,GAAc,MAAVA,EACL,OAAO,EAEN,CACD,IAAIvb,EAAI,EACJ+F,GAAS,EACb,MAAM4V,EAA0B,EAAhBL,EAAOrb,OACjB2b,EAA0B,EAAhBL,EAAOtb,OACvB,GAAI0b,EAAUC,EACV,OAAO,EAEN,GAAID,EAAUC,EACf,OAAO,EAGP,KAAQ5b,EAAI2b,GAAY5V,GACpBA,EAAS2V,EAAOJ,EAAOtb,GAAIub,EAAOvb,IAClCA,EAAMA,EAAI,EAAK,EAEnB,OAAO+F,CAEf,CACJ,CAuBO,SAAS,GAAKiV,GACjB,GAAqB,IAAjBA,EAAM/a,OACN,MAAM,IAAKf,MAAM,qDAGjB,OAAO8b,EAAM,EAErB,CAsEO,SAAS,GAAOa,EAAWb,GAC9B,GAAqB,IAAjBA,EAAM/a,OACN,MAAM,IAAKf,MAAM,6BAErB,MAAM4c,EAAcD,EACpB,OAAOb,EAAMtZ,OAAOoa,EACxB,CAsFO,SAAS,GAAInD,EAAIlV,GACpB,OAAO,IAAO,CAAC5F,EAAGS,IAAQmF,EAASsY,QAAQzd,EAAGT,GAAK,EAAKS,EAAIT,GAAI8a,EACpE,CAMO,SAAS,GAAIA,EAAIlV,GACpB,OAAO,IAAO,CAAC5F,EAAGS,IAAQmF,EAASsY,QAAQzd,EAAGT,GAAK,EAAKA,EAAIS,GAAIqa,EACpE,CC1nCO,MAAM,WAAmB,EAC5Bla,YAAYud,EAAMC,GACdC,QACAtd,KAAKod,KAAOA,EACZpd,KAAKqd,KAAOA,CAChB,CACA9b,WAEI,MAAQ,IAAM,GAAK,KADRvB,MACqB,GACpC,CACA2D,OAAOkD,GAEH,OADW7G,OACA6G,GAIM,EAAC0W,EAAUC,KACpBC,EACA,OAAa,CACT,MAAMC,EAAOH,EAAUI,EAAOH,EACxBI,EAAa,CAACF,EAAKL,KAAMM,EAAKN,MACpC,GAAqB,MAAjBO,EAAW,GAAY,CACvB,GAAqB,MAAjBA,EAAW,GAAY,CACvB,MAAMC,EAAKD,EAAW,GAChBE,EAAKF,EAAW,GACtB,GAAI,EAAOF,EAAKN,KAAMO,EAAKP,MAAO,CAC9BG,EAAWM,EACXL,EAAWM,EACX,SAASL,CACb,CAEI,OAAO,CAEf,CAEI,OAAO,CAEf,CACK,OAAqB,MAAjBG,EAAW,EAOxB,GAEGH,CApCAzd,KAoCS6G,EAExB,CACAtH,cAyBI,OAAwB,EAvBX,EAACwe,EAAOC,EAAOT,KAExB,OAAa,CACT,MAAMnc,EAAI2c,EAAOvb,EAAIwb,EAAON,EAAOH,EAC7BK,EAAaF,EAAKL,KACxB,GAAkB,MAAdO,EAaA,OAAW,EAAJpb,EAbX,CACI,MAAM4F,EAAIwV,EACV,GAAIxc,EAAI,GACJ,OAAW,EAAJoB,EAGPub,EAAS3c,EAAI,EACb4c,GAAWxb,GAAK,GAAK,EAAekb,EAAKN,MAAU,IAAMhc,EACzDmc,EAAWnV,CAMnB,CAEJ,GAEGqV,CAAK,EAAG,EAxBJzd,KAyBf,CACAuG,OAAO0X,GAEH,OAAO/e,MAAM8a,KADCha,KAElB,CACAwE,UAAUqC,GAkCN,OAAyB,EAhCZ,EAAC0W,EAAUC,KACpBC,EACA,OAAa,CACT,MAAMC,EAAOH,EAAUI,EAAOH,EACxBI,EAAa,CAACF,EAAKL,KAAMM,EAAKN,MACpC,GAAqB,MAAjBO,EAAW,GAAY,CACvB,GAAqB,MAAjBA,EAAW,GAAY,CACvB,MAAMC,EAAKD,EAAW,GAChBE,EAAKF,EAAW,GAChBM,EAAoC,EAAhC,EAAQR,EAAKN,KAAMO,EAAKP,MAClC,GAAU,IAANc,EAAS,CACTX,EAAWM,EACXL,EAAWM,EACX,SAASL,CACb,CAEI,OAAW,EAAJS,CAEf,CAEI,OAAO,CAEf,CACK,OAAqB,MAAjBN,EAAW,IACR,EAGD,CAGf,GAEGH,CAjCIzd,KAiCK6G,EACpB,CACArG,gBAEI,OAwDG,IAAI2d,GAzDIne,KAEf,CACA,CAACS,OAAOC,YACJ,OAAO,EAAWV,KAAKQ,gBAC3B,CACA,iDAEI,OAAO,EADIR,KAEf,EAOG,MAAMme,GACTte,YAAYka,GACR/Z,KAAK+Z,GAAKA,EACV/Z,KAAKoe,GAAKpe,KAAK+Z,GACf/Z,KAAKC,QAAU,IACnB,CACA,yDAEI,OADWD,KACDC,OACd,CACA,+CAEI,OADWD,KACDC,OACd,CACA,4CACI,MAAMoe,EAAKre,KACL4d,EAAaS,EAAGD,GAAGf,KACzB,GAAkB,MAAdO,EAAoB,CACpB,MAAMxV,EAAIwV,EAGV,OAFAS,EAAGpe,QAAUoe,EAAGD,GAAGhB,KACnBiB,EAAGD,GAAKhW,GACD,CACX,CAEI,OAAO,CAEf,CACA,yCACI,MAAMiW,EAAKre,KACXqe,EAAGD,GAAKC,EAAGtE,GACXsE,EAAGpe,QAAU,IACjB,CACAT,UACA,EAWG,SAAS8e,KACZ,OAAO,IAAI,GAAW,UAAM,EAChC,CAEO,SAASC,GAAyBtf,EAAG8a,GACxC,OAAO,IAAI,GAAW9a,EAAG8a,EAC7B,CAEO,SAASyE,GAAwBzE,GACpC,OAAkB,MAAXA,EAAGsD,IACd,CAEO,SAASoB,GAAuB1E,GAiBnC,OAAqB,EAhBR,EAACgE,EAAOR,KAEjB,OAAa,CACT,MAAMnc,EAAI2c,EACJH,EADkBL,EACAF,KACxB,GAAkB,MAAdO,EAMA,OAAW,EAAJxc,EALP2c,EAAS3c,EAAI,EACbmc,EAAWK,CAOnB,GAEGH,CAAK,EAAG1D,EACnB,CAEO,SAAS2E,GAAqB3E,GAEjC,GAAkB,MADCA,EAAGsD,KAElB,OAAOtD,EAAGqD,KAGV,MAAM,IAAK9c,MAAM,+CAEzB,CAEO,SAASqe,GAAqB5E,GACjC,MAAM6D,EAAa7D,EAAGsD,KACtB,GAAkB,MAAdO,EACA,OAAOA,EAGP,MAAM,IAAKtd,MAAM,+CAEzB,CA2BO,SAAS,KACZ,OAAOge,IACX,CAEO,SAAS,GAAKrf,EAAG8a,GACpB,OAAOwE,GAAyBtf,EAAG8a,EACvC,CAEO,SAAS,GAAU9a,GACtB,OAAOsf,GAAyBtf,EAAGqf,KACvC,CAEO,SAAS,GAAQvE,GACpB,OAAOyE,GAAwBzE,EACnC,CAEO,SAAS,GAAOA,GACnB,OAAO0E,GAAuB1E,EAClC,CAEO,SAAS,GAAKA,GACjB,OAAO2E,GAAqB3E,EAChC,CAWO,SAAS,GAAKA,GACjB,OAAO4E,GAAqB5E,EAChC,CAmEO,SAAS,GAAQA,GACpB,MAAMtX,EAAmC,EAA7Bgc,GAAuB1E,GAC7BvU,EAAM,GAAK,IAAItG,MAAMuD,GAAM,EAAGA,EAAK,MAezC,MAda,EAACsb,EAAOR,KAEjB,OAAa,CACT,MAAMnc,EAAI2c,EAAOL,EAAOH,EACxB,GAAKiB,GAAwBd,GAM7B,MALIlY,EAAIpE,GAAKsd,GAAqBhB,GAC9BK,EAAS3c,EAAI,EACbmc,EAAWoB,GAAqBjB,EAIxC,GAEJD,CAAK,EAAG1D,GACDvU,CACX,CAEO,SAAS,GAAK+W,EAAQC,EAAOzC,GAChC,IAAI6E,EAAMpC,EACNkB,EAAO3D,EACX,MAAQyE,GAAwBd,IAC5BkB,EAAMrC,EAAOqC,EAAKF,GAAqBhB,IACvCA,EAAOiB,GAAqBjB,GAEhC,OAAOkB,CACX,CAEO,SAAS,GAAQ7E,GACpB,OAAO,IAAK,CAAC6E,EAAK3f,IAAMsf,GAAyBtf,EAAG2f,IAAMN,KAAwBvE,EACtF,CAmEO,SAAS,GAAQ8E,EAAQ9E,GAC5B,IAAK,CAAC+E,EAAU7f,KACZ4f,EAAO5f,EAAE,QACV,EAAQ8a,EACf,CA0BO,SAAS,GAAgBA,EAAIgF,GAChC,IAAIvZ,EAAMuZ,EACV,IAAK,IAAI3d,EAAI2Y,EAAG1Y,OAAS,EAAGD,GAAK,EAAGA,IAChCoE,EAAM+Y,GAAyBxE,EAAG3Y,GAAIoE,GAE1C,OAAOA,CACX,CAEO,SAAS,GAAQuU,GACpB,OAAO,GAAgBA,EAAIuE,KAC/B,CAoFO,SAAS,GAAOvE,EAAIiF,GACvB,OAAO,IAAK,CAACJ,EAAK3f,IAAMsf,GAAyBtf,EAAG2f,IAAMI,EAAI,GAAQjF,GAC1E,CAgCO,SAAS,GAAIkF,EAASlF,GACzB,MAAMmF,EAAOZ,KACPa,EAAO,IAAK,CAACP,EAAK3f,KACpB,IAAImJ,EACJ,OAAQA,EAAI,IAAK,GAAW6W,EAAQhgB,QAAI,GAAW2f,EAAIvB,KAAOjV,EAAGA,CAAG,GACrE8W,EAAMnF,GACHqF,EAAMd,KAEZ,OADAa,EAAK9B,KAAO+B,EACLT,GAAqBO,EAChC,CAuHO,SAAS,GAAQ7Z,EAAG0U,GACvB,OAnCG,SAAiB1U,EAAG0U,GAqBvB,MApBa,CAACwD,IACVE,EACA,OAAa,CACT,MAAMC,EAAOH,EACb,GAAIiB,GAAwBd,GACxB,OAEC,CACD,MAAME,EAAavY,EAAEqZ,GAAqBhB,IAC1C,GAAkB,MAAdE,EAAoB,CACpBL,EAAWoB,GAAqBjB,GAChC,SAASD,CACb,CAEI,OAAOG,CAEf,CAEJ,GAEGH,CAAK1D,EAChB,CAaW,EAAS9a,GAAOoG,EAAEpG,GAAK,GAAKA,QAAK,GAAW8a,EACvD,CAsIO,SAAS,GAAO1U,EAAG0U,GACtB,MAAMmF,EAAOZ,KACPa,EAAO,IAAK,CAACP,EAAK3f,KACpB,MAAM2e,EAAavY,EAAEpG,GACrB,GAAkB,MAAd2e,EACA,OAAOgB,EAEN,CACD,MAAMxW,EAAI,IAAI,GAAW,GAAQwV,QAAa,GAE9C,OADAgB,EAAIvB,KAAOjV,EACJA,CACX,IACD8W,EAAMnF,GACHqF,EAAMd,KAEZ,OADAa,EAAK9B,KAAO+B,EACLT,GAAqBO,EAChC,CAEO,SAAS,GAAS9e,EAAO2Z,EAAIrW,GAChC,OAAuD,MA/HpD,SAAsB2B,EAAG0U,GAmB5B,MAlBa,EAACgE,EAAOR,KAEjB,OAAa,CACT,MAAMnc,EAAI2c,EAAOL,EAAOH,EACxB,GAAIiB,GAAwBd,GACxB,OAEC,GAAIrY,EAAEqZ,GAAqBhB,IAC5B,OAAOtc,EAGP2c,EAAS3c,EAAI,EACbmc,EAAWoB,GAAqBjB,EAIxC,GAEGD,CAAK,EAAG1D,EACnB,CA2GW,EAAcxW,GAAMG,EAAGC,OAAOvD,EAAOmD,IAAIwW,EACpD,C,qsTCh4BqBsF,G,OZmajB/U,GADwBrL,EYhacogB,GZka/BpgB,EAAEoH,QAAQpH,EAAEqH,KAFhB,IAAqBrH,C,wKYnYAqgB,G,OACdA,EAAAA,K,gDAOM,IAAM,GAAuBA,G,cANhC,G,4XAoCDC,G,OACFA,EAAAA,K,cAEmB,MAAQ,EAAR,U,qJAmBT,GAAuBA,G,cApB1B,G,0IA4CWtgB,G,kBAtGZogB,G,OZkZhB/U,GADuBrL,EY/YcogB,GZiZ9BpgB,EAAEqH,IAFN,IAAoBrH,C,CY1Sf,CAAsBA,GAAI,E,2OA0hBVwb,EAAS+E,EAASC,EAAYC,G,MAC1CvY,EAAoB,GAAAqY,EAHxB,OAAU,KAAc,KAAqB,MAGhC/E,GAETtT,EACM,MAAAsY,EAEItY,EADU,GAAAA,EAAAsY,GAGlB,aAAAC,EAEIvY,EADU,GAAAA,EAAAuY,E,aAGjB1f,EAAa2f,G,OAChB,OAAoB,GAAAA,EAAM,SAA1B,2B,aAEG3f,EAAc4f,G,OACjB,OAAoB,GAAAA,EAAM,SAA1B,2B,aAEG5f,EAAc6f,G,OACjB,eAAsB,GAAAA,EAAI,WAA1B,iB,aAKG7f,EAAiBqf,G,OACW,GAAArf,EAA/B,GAAuBqf,G,aAEpBrf,EAAkB8f,G,OACrB,eAAsB,IAjHXrF,EAiHYqF,EA7ChB,KAnEM3Y,EAAO4Y,K,IAjcZT,EAOmBU,EAsBnBV,EAOmBU,E,OA8ZrBD,EAAAA,K,cAEiC,G,SAzG3BR,G,OACVA,EAAAA,K,cAEmB,YAAc,EAAd,U,oJAmBT,YAAc,GAAwBA,GAAO,MAAC,EAA/B,GAAuBA,GAAO,Q,cApBhD,G,CAuG+B,CAAD,aAAgBpY,G,6CA8DnD,GAhTJ,GAgTI,aAAkCA,G,cA5DC,GAxc3C,WAAa,GAwc8B,aAxcP,GAwcO,aAAgCA,G,cAChC,IAvc/BmY,EAuc+B,YAtcrC,gCAIF,WAAa,GAkc0B,aAlcH,GAAgBA,GAAS,SAE7D,aAA2B,IAAAU,EAA4D,EAAvFV,GAA2B,GAAQ,uDAAR,CAAAU,MAC3B,KA+boE7Y,G,cAC7B,GA7a3C,GA6a2C,aA7af,GA6ae,aAAqCA,G,cACrC,IA5a/BmY,EA4a+B,YA3arC,gCAIF,GAuauC,aAvaX,GAAgBA,GAAS,SAErD,aAA2B,IAAAU,EAA4D,EAAvFV,GAA2B,GAAQ,uDAAR,CAAAU,MAC3B,KAoayE7Y,G,cAElC,IArMnBmY,EAqMmB,YAjM3C,MANI,GAuMuC,aAnM9B,GAAgBA,IAmMuDnY,G,cACzC,G,SAhMfmY,EAAOW,G,IAUJD,E,OATzBV,EAAAA,K,2BAMF,MAfA,GAa6BW,GAChB,GAAgBX,GACF,Q,eAG3B,aAA2B,IAAAU,EAAsD,EAAjFV,GAA2B,GAAQ,iDAAR,CAAAU,MAC3B,G,CAqLwC,CAAD,yBAA6C7Y,G,QAC7C,mBAAU,G,SA1FhCmY,G,MACrB,eAAiB,GAAgBA,E,CAyFqB,CAAX,aAAgCnY,GAAYA,E,QAC5C,mBAAU,G,SArF5BmY,G,IAOMU,E,OANzBV,EAAAA,K,2BAIF,eAAiB,GAAgBA,GAAS,Q,eAE1C,aAA2B,IAAAU,EAAiE,EAA5FV,GAA2B,GAAQ,4DAAR,CAAAU,MAC3B,G,CA6EkD,CAAX,aAAoC7Y,GAAYA,E,QAChD,mBAAU,G,SAzFnCmY,G,MAClB,YAAc,GAAgBA,E,CAwFwB,CAAX,aAA6BnY,GAAYA,E,QACzC,mBAAU,G,SA7E/BmY,G,IAOSU,E,OANzBV,EAAAA,K,2BAIF,YAAc,GAAgBA,GAAS,Q,eAEvC,aAA2B,IAAAU,EAA8D,EAAzFV,GAA2B,GAAQ,yDAAR,CAAAU,MAC3B,G,CAqEkD,CAAX,aAAiC7Y,GAAYA,E,uBAE5D,gBAAcA,G,+GAatB,GAAC,GAAuB4Y,GAAS5Y,G,eACtB,IArKP+Y,EAqKO,YArKHC,EAqKG,YAjK/B,GAHmCD,GAG7B,IANF,GAIwBC,IAmKwChZ,G,eAChDiZ,EACZ,mBAAQ,GAAc,UAAUjZ,EAAAA,C,oCAG5B,GAhbR,GAgbsCiZ,GAAYjZ,GAF1C,cA9aR,GA8aiDiZ,IAAYjZ,E,gBAGlD4Y,EACP,mBAAQ,GAAc,UAAU5Y,EAAAA,C,oCAG5B,GAvaR,GAuaiC4Y,GAAS5Y,GAFlC,cAraR,GAqa4C4Y,IAAS5Y,E,gBAGhC4Y,EACjB,mBAAQ,GAAc,UAAU5Y,EAAAA,C,oCAG5B,GAhZR,GAgZ2C4Y,GAAS5Y,GAF5C,cA9YR,GA8YsD4Y,IAAS5Y,E,gBAG5C4Y,EACf,mBAAQ,GAAc,UAAU5Y,EAAAA,C,oCAG5B,GAzXR,GAyXyC4Y,GAAS5Y,GAF1C,cAvXR,GAuXoD4Y,IAAS5Y,E,gBAG5C4Y,EACb,mBAAQ,GAAc,UAAU5Y,EAAAA,C,oCAG5B,GAnWR,GAmWuC4Y,GAAS5Y,GAFxC,cAjWR,GAiWkD4Y,IAAS5Y,E,gBApDpB,G,SAhIrBoY,G,OAChBA,EAAAA,K,cAEmB,kBAAoB,EAApB,U,oJAmBT,kBAAoB,GAAwBA,GAAO,MAAC,EAA/B,GAAuBA,GAAO,Q,cApBtD,G,CA8H+B,CAAD,aAAsBpY,G,IAxIzC+Y,EAAIC,EArDJb,C,GA8PU,KAAlC7E,IA6CmE,WAA/D,kB,IAjHWA,C,aAmHRza,G,MACG4d,ED2JX,SAAgBvY,EAAG0U,GACtB,MAAMmF,EAAOZ,KACPa,EAAO,IAAK,CAACP,EAAK3f,KACpB,GAAIoG,EAAEpG,GAAI,CACN,MAAMmJ,EAAI,IAAI,GAAWnJ,OAAG,GAE5B,OADA2f,EAAIvB,KAAOjV,EACJA,CACX,CAEI,OAAOwW,CACX,GACDM,EAAMnF,GACHqF,EAAMd,KAEZ,OADAa,EAAK9B,KAAO+B,EACLT,GAAqBO,EAChC,CC1KkC,EAAiBmB,IAAY,GAA4BA,KAAa,GAAcA,EAAI,kB,qCAAxG,qBAAAzC,GACE,QACK,GAAiC,UAArB,GAAc,IAA1BA,IAAoD,Q,aAG9D5d,EAAoBsgB,EAA2DC,G,MAC9EA,EAAW,GAAWA,EAAS,M,OACnCD,EAAI,GAAAtgB,GAAsBugB,E,aAGvBvgB,EAAoBsgB,G,OACvBA,EAAI,GAAAtgB,G,aAEMmH,EAAyB4Y,G,OACjCA,EAAAA,K,cAEuB,GAAA5Y,EAAA,a,cACJ,GAAAA,EAAA,a,eAFR,GAAAA,EAAA,a,CC7rBzB,SAASqZ,GAAQlf,EAAKmf,GAClB,OAAOnf,EAAIwJ,QAAQ,gBAAiB4L,GAAmB,IAAbA,EAAErV,OACtCqV,EAAE4B,cACF5B,EAAEgK,OAAO,GAAKD,EAAY/J,EAAEgK,OAAO,GAAGpI,eAChD,CAgBO,SAAS,GAAavT,EAAQ4b,EA1B3B,GA2BN,MAAM3b,EAAM,CAAC,EACP4b,EAAkBD,EACxB,SAASnK,EAAKqK,GACV,MAAM,IAAIvgB,MAAM,iCAAmC8F,OAAOya,GAC9D,CACA,SAASC,EAAOpc,EAAKic,EAAUvgB,GAC3BsE,EAtBR,SAAoBpD,EAAKqf,GACrB,OAAQA,GACJ,KAZQ,EAaJ,OAAOrf,EAAIof,OAAO,GAAGpI,cAAgBhX,EAAIyX,MAAM,GACnD,KAbO,EAcH,OAAOyH,GAAQlf,EAAK,KACxB,KAdc,EAeV,OAAOkf,GAAQlf,EAAK,KAAKuS,cAC7B,KAfO,EAgBH,OAAO2M,GAAQlf,EAAK,KAExB,QACI,OAAOA,EAEnB,CAQcyf,CAAWrc,EAAKic,GACtB3b,EAAIN,GAAOtE,CACf,CACA,IAAK,IAAIygB,KAAU9b,EAAQ,CACvB,IAAI4b,EArCF,EA0CF,GAJc,MAAVE,GACArK,EAAKqK,GAGLA,aAAkB,EAAO,CACzB,MAAM1a,EAAO0a,EAAOxa,QAAQwa,EAAOva,KACnCua,EAAkC,IAAzBA,EAAO9b,OAAO1D,OAAe8E,EAAO,CAACA,GAAMR,OAAOkb,EAAO9b,QAClE4b,EAAWC,CACf,CACA,GAAI1hB,MAAMC,QAAQ0hB,GACd,OAAQA,EAAOxf,QACX,KAAK,EACDmV,EAAKqK,GACL,MACJ,KAAK,EACDC,EAAOD,EAAO,GAAIF,GAAU,GAC5B,MACJ,KAAK,EACD,MAAMvgB,EAAQygB,EAAO,GACrBC,EAAOD,EAAO,GAAIF,EAAUvgB,GAC5B,MACJ,QACI0gB,EAAOD,EAAO,GAAIF,EAAUE,EAAO9H,MAAM,QAG1B,iBAAX8H,EACZC,EAAOD,EAAQF,GAAU,GAGzBnK,EAAKqK,EAEb,CACA,OAAO7b,CACX,CAUO,SAAS,GAAY1B,EAAKoB,EAAKwW,GAClC,QAAI5X,EAAIpB,IAAIwC,KACRwW,EAAa1T,SAAWlE,EAAIjB,IAAIqC,IACzB,EAGf,CACO,SAAS,GAASnB,EAAGpB,GACxB,OAAIA,EAAID,IAAIqB,KAGZpB,EAAIyN,IAAIrM,IACD,EACX,CACO,SAAS,GAAUyd,EAAM/a,EAAG1C,GAC/B,GAAIyd,EAAK9e,IAAI+D,GACT,MAAM,IAAI3F,MAAM,0DAA4D2F,GAEhF+a,EAAK7e,IAAI8D,EAAG1C,EAChB,CACO,SAAS,GAAgBD,EAAKoB,GACjC,GAAIpB,EAAIpB,IAAIwC,GACR,OAAOpB,EAAIjB,IAAIqC,GAGf,MAAM,IAAIpE,MAAM,kBAAkBoE,wCAE1C,C,srBC7BczF,EAAES,G,OAjBUuhB,EAiBN,CAAKrB,EAAAW,IA4OjB,gBAzT4B,OA6EXX,EAAAA,MAAAW,GAjBiBA,EAiBb7gB,EALjB,MAKeT,GALe,CAXZkI,EAAyB4Y,K,OACjCA,EAAAA,K,mCAKW,GAAA5Y,EAAmB4Y,G,cACnB,GAAA5Y,EAAA,a,cACY,GAAAA,EAAA,a,cACJ,GAAAA,EAAA,a,QAPL,mBAAc,GAAAA,EAAmB4Y,GAAY5Y,E,GASzB,eAA8B8Z,EAASV,G,IAZrEU,EAAgBV,C,aA6EfU,EAASxG,EAA6B8F,G,OACrD,MAAqB9F,EAASA,GAAc,gBAA+BwG,EAASV,E,aAYhFthB,EAAES,G,OAJSuhB,EAIL,CAAMrB,EAAAW,IAmKpB,gBAhS8B,SA6HVX,EAAAA,MAAAW,GAJqCA,EAI/B7gB,EAHtB,MAGoBT,EAHUwb,GAAc,gBAA+BwG,EAASV,G,IADrEU,EAAsCV,C,aAajDthB,EAAES,G,OAJWuhB,EAIP,CAAQrB,EAAAW,IA0JtB,gBAhS8B,SAsIRX,EAAAA,MAAAW,GAJqCA,EAI/B7gB,EAHxB,MAGsBT,EAHQwb,GAAc,cAA6BwG,EAASV,G,IADjEU,EAAsCV,C,aAyBtD9F,EAAQ8F,G,OAQb,MAAqB9F,GAAS,CAPZtT,EAAyB4Y,K,OACjCA,EAAAA,K,cAEgB,GAAA5Y,EAAA,a,cACY,GAAAA,EAAA,a,cACJ,GAAAA,EAAA,a,QAHL,mBAAc,GAAAA,EAAmB4Y,GAAY5Y,E,GAK9B,iBAA8ByY,EAAAW,IA6H1E,gBAhS8B,SAmK4CX,EAAAA,MAAAW,IAAKA,E,aAGxE9F,EAAQ8F,G,OASf,MAAqB9F,GAAS,CARZtT,EAAyB4Y,K,OACjCA,EAAAA,K,cAEuC,GAAA5Y,EAAtB,IAAA+Z,GAAO,GAAP,c,cACC,GAAA/Z,EAAA,a,cACY,GAAAA,EAAA,a,cACJ,GAAAA,EAAA,a,QAJL,mBAAc,GAAAA,EAAmB4Y,GAAY5Y,E,GAMhC,mBAAgCyY,EAAAW,IAiH5E,gBAhS8B,SA+K8CX,EAAAA,MAAAW,IAAKA,E,gGCnLvDY,EAAqBC,G,OAC/C,cAAkBC,EAAQC,KACtB,I,MACQC,EAAS,eACbA,EAAA,OAAsBC,IAAK,EAAAD,EAAA,O,EAC3BA,EAAQJ,GAAmBC,E,OAE7BnU,GAAK,EAAAA,E,iBAWC5H,EAAEoc,G,MACFC,EAAAA,EAAAA,K,gBAAKC,EAAY,EAAAH,EAAAA,EAAA,MAAAA,G,YAKb,EAAO,GAASG,I,OAJnBvZ,EACK,GAAAoZ,GADRhf,EACQ,GAAAgf,GAAA5D,EAAAvY,EAAE7C,GAAF,W,OACO,MAAAob,IAAS,GAAC,GAAS+D,GAAWvZ,I,EAC9B,GAAA5F,EAAGmf,G,EAAWvZ,EAApB,SAAAsZ,C,IAEfA,CAAK,KAAGD,E,iKAuChB,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,W,2yBhB2EG,MACH5hB,YAAY+hB,GACR5hB,KAAK4hB,QAAUA,CACnB,G,YiB/IuBC,EAAwBC,EAAUC,G,MAChCD,GADF,KAAAD,SAAAA,EAAkC,KAAAE,YAAAA,C,cAAlCF,EAAwBC,EAAUC,G,spBCbtD,SAAS,KACZ,OCF4Cld,EASL,EARhC,CACHsY,QAAO,CAACle,EAAGS,IACAmF,EAAS5F,EAAGS,IAKxB,IARyCmF,CDGhD,CEfO,MAUM,GAAuB,6DAQ7B,SAASmd,KACZ,MAAM,IAAK1hB,MAjByB,8CAkBxC,CAEO,SAAS2hB,KACZ,MAAM,IAAK3hB,MAvB8B,gCAwB7C,CAEO,MAAM4hB,GACTriB,YAAYwF,GACRrF,KAAKqF,EAAIA,CACb,CACA9D,WAGI,IAAIH,EAAI,EACJE,EAAM,QACV,MAAM2L,EAAI,EAJCjN,MAKX,IACI,KAAQoB,EALK,GAKY6L,EAAE,8CACnB7L,EAAI,IACJE,GAAa,MAEjBA,GAAa,EAAS2L,EAAE,2DACxB7L,EAAMA,EAAI,EAAK,EAKnB,OAfa,IAYTA,IACAE,GAAa,SAEVA,EAAM,GAIjB,CAFA,QACI,EAAY2L,EAChB,CACJ,CACAzM,gBAEI,OADUR,KACDqF,GACb,CACA,CAAC5E,OAAOC,YACJ,OAAO,EAAWV,KAAKQ,gBAC3B,CACA,iDAEI,OADUR,KACDqF,GACb,EAWG,MAAM8c,GACTtiB,YAAYI,EAASE,EAAMiiB,GACvBpiB,KAAKC,QAAUA,EACfD,KAAKG,KAAOA,EACZH,KAAKoiB,QAAUA,CACnB,CACA,yDAEI,OADWpiB,KACDC,SACd,CACA,+CAEI,OADWD,KACDC,SACd,CACA,4CAEI,OADWD,KACDG,MACd,CACA,0CA9EG,WACH,MAAM,IAAKG,MAHqB,6CAIpC,CA6EQ+hB,EACJ,CACA7iB,UACeQ,KACRoiB,SACP,EAOG,SAASE,GAA0CriB,EAASE,EAAMiiB,GACrE,OAAO,IAAID,GAA2BliB,EAASE,EAAMiiB,EACzD,CAkHO,SAASG,GAA6BC,EAAOC,EAASC,GACzD,IACIC,EADAC,GAAU,EAEVpG,EAAQ,GAAKgG,KACjB,MAAMJ,EAAU,KACZ,GAAa,MAAT5F,EAAe,CACf,MAAMqG,EAAM,GAAQrG,GACpB,IACIkG,EAAOG,EAIX,CAFA,QACIrG,OAAQ,CACZ,CACJ,GAEEsG,EAAS,KACX,IACIV,GAIJ,CAFA,QACIO,OAAO,CACX,GAEJ,OAAOL,IAA0C,KACxCM,GACDZ,KAEQ,MAARW,EACO,GAAQA,GAGRV,QAEZ,KAIC,GAHKW,IACDA,GAAU,GAED,MAATpG,EAAe,CACf,MAAMja,EAAI,GAAQia,GAClB,IAAIuG,EACJ,IACIA,EAAeN,EAAQlgB,EAK3B,CAHA,MAAOqb,GAEH,MADAkF,IACMlF,CACV,CACA,OAAoB,MAAhBmF,GACAJ,EAAOI,GACA,IAGPD,KACO,EAEf,CAEI,OAAO,CACX,GACDV,EACP,CAuCO,SAASY,GAAM3d,GAClB,OA3PG,SAAuCA,GAC1C,OAAO,IAAI6c,GAAe7c,EAC9B,CAyPW4d,CAA8B5d,EACzC,CAEO,SAAS,GAAM0U,GAElB,OAZyBmJ,EAWZ,SAVF,MAUYnJ,GFhSpB,SAA2B9a,GAC9B,MAAM,IAAKqB,MAAMrB,EACrB,CEqRQkkB,CAAkBD,GAUf,EAAcnJ,GAZlB,IAAsBmJ,CAa7B,CAEO,SAAS,GAAME,GAClB,OAAOJ,IAAM,IAAM,EAAcI,MACrC,CAEO,SAAS,GAAOC,GACnB,OAAOL,IAAM,IAzNV,SAA2BK,GAC9B,IAAIC,EACAC,EAGAZ,EAFAC,GAAU,EACVY,GAAW,EAEf,MAAMV,EAAS,KAEX,GADAU,GAAW,EACK,MAAZD,EAAkB,CAClB,MAAME,EAAQF,EACd,IACI,EAAYE,EAIhB,CAFA,QACIF,OAAW,CACf,CACJ,CACA,GAAgB,MAAZD,EAAkB,CAClB,MAAMI,EAAQJ,EACd,IACI,EAAYI,EAIhB,CAFA,QACIJ,OAAW,CACf,CACJ,GAEJ,OAAOhB,IAA0C,KACxCM,EAGIY,GACLvB,KAHAD,KAKQ,MAARW,EACO,GAAQA,GAGRV,QAEZ,KACC,IAAI0B,EAIJ,GAHKf,IACDA,GAAU,GAEVY,EACA,OAAO,EAEN,CACD,IAAIhe,EACJ,KAAc,MAAPA,GAAa,CAChB,MAAMoY,EAAa,CAAC0F,EAAUC,GAC9B,GAAqB,MAAjB3F,EAAW,GACX,GAAqB,MAAjBA,EAAW,GAAY,CACvB,MAAMgG,EAAUhG,EAAW,GAC3B,GAAIgG,EAAQ,6CACRjB,EAAO,GAAKiB,EAAQ,2DACpBpe,GAAM,OAGN,IACI,EAAYoe,EAIhB,CAFA,QACIL,OAAW,CACf,CAER,KACK,CACD,MAAMM,EAAUjG,EAAW,GACvBiG,EAAQ,8CAEKF,EADFE,EAAQ,0DACnBN,EAAgC,EAAcI,KAG9Cb,IACAtd,GAAM,EAEd,MAGA8d,EAAW,EAAcD,EAEjC,CACA,OAAO,GAAQ7d,EACnB,KACD,KACMge,GACDV,GACJ,GAER,CA8HuBgB,CAAkBT,IACzC,CAMO,SAAS,KACZ,OAAO,IAAM,IAAM,IAAKnkB,MAAM,IAClC,CAEO,SAAS,GAAUD,GACtB,OAAO,IAAM,IAAM,GAAYA,IACnC,CAMO,SAAS,GAAQ8a,GACpB,OAAIA,aAAc,GACP,GAAUA,GAGV7a,MAAM8a,KAAKD,EAE1B,CAMO,SAAS,GAAOA,GACnB,OAAI,EAAYA,GACL,GAAUA,GAEZA,aAAc,GACZA,ER8HR,SAAeA,GAClB,IAAIgK,EAAM3b,EACV,GAAI,EAAY2R,GACZ,OAAO,GAAQA,GAEd,GAAIA,aAAc,GACnB,OAAOA,EAEN,CACD,MAAMmF,EAAOZ,KACb,IAAIa,EAAOD,EACX,MAAM8E,EAAa,EAAcjK,GACjC,IACI,KAAOiK,EAAW,8CAA8C,CAC5D,MAAM/kB,EAAI+kB,EAAW,0DACZD,EAAO5E,EAAO/W,EAAI,IAAK,GAAWnJ,OAAG,GAAW8kB,EAAK1G,KAAOjV,EAArE+W,EAAwE/W,CAC5E,CAIJ,CAFA,QACI,EAAY4b,EAChB,CACA,MAAMC,EAAO9E,EACPC,EAAMd,KAEZ,OADA2F,EAAK5G,KAAO+B,EACLT,GAAqBO,EAChC,CACJ,CQrJegF,CAAQnK,EAEvB,CAEO,SAASoK,GAASC,EAAQ3B,EAASL,GACtC,OAAOY,IAAM,IAAMT,GAA6B6B,EAAQ3B,EAASL,IACrE,CAYO,SAAS,GAAOrI,EAAIiF,GACvB,OAAO,GAAO,CAACjF,EAAIiF,GACvB,CA6LO,SAAS,GAAQ3C,EAAWtC,GAC/B,MAAM9M,EAAI,GAAM8M,GAChB,IACI,IAAIvU,EACJ,KAAe,MAAPA,GAAgByH,EAAE,8CAA8C,CACpE,MAAMiR,EAAIjR,EAAE,0DACRoP,EAAU6B,KACV1Y,EAAM,GAAK0Y,GAEnB,CACA,OAAO1Y,CAIX,CAFA,QACI,EAAYyH,EAChB,CACJ,CA+EO,SAAS,GAAKsP,EAAQC,EAAOzC,GAChC,MAAM9M,EAAI,GAAM8M,GAChB,IACI,IAAI6E,EAAMpC,EACV,KAAOvP,EAAE,8CACL2R,EAAMrC,EAAOqC,EAAK3R,EAAE,2DAExB,OAAO2R,CAIX,CAFA,QACI,EAAY3R,EAChB,CACJ,CAyIO,SAAS,GAAQ4R,EAAQ9E,GAC5B,IAAK,CAAC+E,EAAU7f,KACZ4f,EAAO5f,EAAE,QACV,EAAQ8a,EACf,CAQO,SAAS,GAAe8E,EAAQ9E,GACnC,IAAK,CAAC3Y,EAAGnC,KACL4f,EAAOzd,EAAGnC,GACFmC,EAAI,EAAK,IAClB,EAAG2Y,EACV,CAiEO,SAAS,GAAIkF,EAASlF,GACzB,OAAOoK,IAAS,IAAM,GAAMpK,KAAM9M,GAAOA,EAAE,6CAA+C,GAAKgS,EAAQhS,EAAE,iEAA8D,IAAYoX,IAC/K,EAAYA,EAAI,GAExB,CAuQO,SAAS,GAAKjiB,EAAOsZ,GACxB,OAAOsH,IAAM,KACT,MAAM/V,EAAI,GAAMyO,GAChB,IACI,IAAK,IAAIxC,EAAI,EAAGA,GAAK9W,EAAO8W,IACxB,IAAKjM,EAAE,6CACH,MAAM,IAAK3M,MAAO,GAAD,6BAGzB,OA98BL,SAAyC+E,EAAG4H,GAC/C,OAAOqV,IAA0C,IAAMrV,EAAE,4DAA2D,IAAMA,EAAE,+CAA8C,KACtK,IACI,EAAYA,EAIhB,CAFA,QACI5H,GACJ,IAER,CAq8BmBif,EAAgC,QACpCrX,EAKP,CAHA,MAAO2Q,GAEH,MADA,EAAY3Q,GACN2Q,CACV,IAER,CAwDO,SAAS,GAAQqB,EAASlF,GAC7B,OAAO,IAAM,IAAM,GAAO,GAAIkF,EAASlF,KAC3C,CAjQKtZ,OAAOC,SCn+BL,MAAM,GACTb,YAAY0kB,EAAO1f,GACf,MAAM2f,EAAQ,IAAI,EAAU,MAC5BxkB,KAAK6E,SAAWA,EAChB2f,EAAMhd,SAAWxH,KACjBA,KAAKykB,QAAU,IAAKC,IAAI,IACxB1kB,KAAK,YAAc,EACnB,MAAMgkB,EAAa,EAAcO,GACjC,IACI,KAAOP,EAAW,8CAA8C,CAC5D,MAAMW,EAAOX,EAAW,0DACxBY,GAAuBJ,EAAMhd,SAAUmd,EAAK,GAAIA,EAAK,GACzD,CAIJ,CAFA,QACI,EAAYX,EAChB,CACJ,CACYa,IAAPpkB,OAAOokB,eACR,MAAO,YACX,CACAte,OAAO0X,GAEH,OAAO/e,MAAM8a,KADCha,KAElB,CACA,iDAEI,OAAO,EADOA,KAElB,CACAQ,gBAEI,OAAO,EAAc,GADPR,KACoBykB,QAAQphB,UAC9C,CACA,CAAC5C,OAAOC,YACJ,OAAO,EAAWV,KAAKQ,gBAC3B,CACA,oDAAsDskB,GAElDF,GADc5kB,KACgB8kB,EAAK,GAAIA,EAAK,GAChD,CACA,mDAEIC,GADc/kB,KAElB,CACA,yDAA2D8kB,GACvD,MACMlH,EAAaoH,GADLhlB,KACsC8kB,EAAK,IACzD,IAAIG,EAYJ,OATQA,EAFU,MAAdrH,GACI,EAAOA,EAAW,GAAIkH,EAAK,IACD,EAOJ,EAEtBG,GACJ,KAAK,EACD,OAAO,EAEX,KAAK,EACD,OAAO,EAGnB,CACA,2DAA6D7I,EAAO8I,GAEhE,IAAe,CAAC9jB,EAAG6L,KACfmP,EAAM8I,EAAa9jB,GAAK6L,CAAC,GAFfjN,KAIlB,CACA,uDAEI,OAAsC,EAA/BmlB,GADOnlB,KAElB,CACA,4DACI,OAAO,CACX,CACA,uDAAyD8kB,GACrD,MACMlH,EAAaoH,GADLhlB,KACsC8kB,EAAK,IACzD,OAAkB,MAAdlH,IACI,EAAOA,EAAW,GAAIkH,EAAK,KAC3BM,GAJMplB,KAI0B8kB,EAAK,KAElC,EAKf,CACA,qDAAuDpgB,EAAKtE,GAExDwkB,GADc5kB,KACgB0E,EAAKtE,EACvC,CACA,4DAA8DsE,GAE1D,OAAO2gB,GADOrlB,KAC8B0E,EAChD,CACA,yDAA2DA,GAEvD,OAAO4gB,GADOtlB,KAC2B0E,EAC7C,CACA,0DAA4DA,EAAKnB,GAE7DgiB,GADcvlB,KACqB0E,EAAKnB,EAC5C,CACA,sDACI,MAAMihB,EAAQxkB,KACd,OAAO,GAAQ,IAAM,IAAM,IAAK2kB,GAASA,EAAK,IAAIH,KACtD,CACA,uDAAyD9f,GAErD,OAAO0gB,GADOplB,KACyB0E,EAC3C,CACA,+DAAiEA,EAAKtE,GAClE,MACMwd,EAAaoH,GADLhlB,KACsC0E,GACpD,GAAkB,MAAdkZ,EAAoB,CACpB,MAAM+G,EAAO/G,EAEb,OADAxd,EAAMoH,SAAWmd,EAAK,IACf,CACX,CAEI,OAAO,CAEf,CACA,wDACI,MAAMH,EAAQxkB,KACd,OAAO,GAAQ,IAAM,IAAM,IAAK2kB,GAASA,EAAK,IAAIH,KACtD,CACI7U,WAEA,OAAsC,EAA/BwV,GADOnlB,KAElB,CACAwlB,QAEIT,GADc/kB,KAElB,CACAylB,OAAOxf,GAEH,OAAOmf,GADOplB,KACyBiG,EAC3C,CACAD,UAEI,OAAO,IAAKwJ,GAAM,CAACA,EAAE,GAAIA,EAAE,KADbxP,KAElB,CACAqC,IAAI4D,GAEA,OAAOqf,GADOtlB,KAC2BiG,EAC7C,CACA/D,IAAI+D,GAEA,OAAOof,GADOrlB,KAC8BiG,EAChD,CACAnC,OAEI,OAAO,IAAK0L,GAAMA,EAAE,IADNxP,KAElB,CACAmC,IAAI8D,EAAG1C,GAGH,OADAgiB,GADcvlB,KACqBiG,EAAG1C,GADxBvD,IAGlB,CACAqD,SAEI,OAAO,IAAKmM,GAAMA,EAAE,IADNxP,KAElB,CACA0lB,QAAQrgB,EAAGsgB,GACP,MAAMnB,EAAQxkB,KACd,IAASwP,IACLnK,EAAEmK,EAAE,GAAIA,EAAE,GAAIgV,EAAM,GACrBA,EACP,EAWJ,SAASoB,GAA+BpB,EAAOve,GAC3C,MAAMzD,EAAoC,EAAhCgiB,EAAM3f,SAAStF,YAAY0G,GACrC,IAAI2X,EACAiI,EAAS,KAIb,OAHAjI,EAAa,CAAC,GAAY4G,EAAMC,QAASjiB,EAAG,IAAI,GAAU,IAAMqjB,IAAStiB,IACrEsiB,EAAStiB,CAAC,KACTsiB,GACDjI,EAAW,GACJ,EAAC,EAAMpb,EAAGob,EAAW,GAAGkI,WAAWnB,GAASH,EAAM3f,SAASlB,OAAOsC,EAAG0e,EAAK,OAG1E,EAAC,EAAOniB,GAAI,EAE3B,CAEO,SAASwiB,GAA0BR,EAAOve,GAC7C,MAAM2X,EAAagI,GAA+BpB,EAAOve,GACzD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EACD,OAAO,GAAgBT,EAAMC,QAAS7G,EAAW,IAAIA,EAAW,IAEpE,KAAK,EACD,OAGZ,CAMO,SAASmH,GAAkBP,GAC9BA,EAAMC,QAAQe,OAClB,CAEO,SAASL,GAAsBX,GAClC,IAAIpiB,EAAQ,EACR4hB,EAAa,EAAcQ,EAAMC,QAAQphB,UAC7C,IACI,KAAO2gB,EAAW,8CAEd5hB,EAAUA,EADI4hB,EAAW,0DACD3iB,OAAU,CAK1C,CAFA,QACI,EAAY2iB,EAChB,CACA,OAAe,EAAR5hB,CACX,CAEO,SAASkjB,GAA2Bd,EAAOve,GAC9C,MAAM2X,EAAaoH,GAA0BR,EAAOve,GACpD,GAAkB,MAAd2X,EACA,OAAOA,EAAW,GAGlB,MAAM,IAAKtd,MAAM,uCAEzB,CAEO,SAASilB,GAA4Bf,EAAOve,EAAG1C,GAClD,MAAMqa,EAAagI,GAA+BpB,EAAOve,GACzD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EACD,GAAgBT,EAAMC,QAAS7G,EAAW,IAAIA,EAAW,IAAM,CAAC3X,EAAG1C,GACnE,MAEJ,KAAK,EACGqa,EAAW,GACS,GAAgB4G,EAAMC,QAAS7G,EAAW,IAAI/F,KAAK,CAAC5R,EAAG1C,IAG3EihB,EAAMC,QAAQtiB,IAAIyb,EAAW,GAAI,CAAC,CAAC3X,EAAG1C,KAKtD,CAEO,SAASqhB,GAAuBJ,EAAOve,EAAG1C,GAC7C,MAAMqa,EAAagI,GAA+BpB,EAAOve,GACzD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EAAG,CACJ,MAAMc,EAAM1R,GAAO,6DAA8DpO,GACjF,MAAM,IAAK3F,MAAMylB,EAErB,CACA,KAAK,EACGnI,EAAW,GACS,GAAgB4G,EAAMC,QAAS7G,EAAW,IAAI/F,KAAK,CAAC5R,EAAG1C,IAG3EihB,EAAMC,QAAQtiB,IAAIyb,EAAW,GAAI,CAAC,CAAC3X,EAAG1C,KAKtD,CAEO,SAAS8hB,GAA8Bb,EAAOve,GACjD,MAAM2X,EAAagI,GAA+BpB,EAAOve,GACzD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EACD,OAAO,EAEX,KAAK,EACD,OAAO,EAGnB,CAEO,SAASG,GAAyBZ,EAAOve,GAC5C,MAAM2X,EAAagI,GAA+BpB,EAAOve,GACzD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EAED,OADA,GAAgBT,EAAMC,QAAS7G,EAAW,IAAIhX,OAAOgX,EAAW,GAAI,IAC7D,EAEX,KAAK,EACD,OAAO,EAGnB,C,YCvS8BoI,G,OACtB,GAAG,YAAG,GAAsBA,GAAAA,C,MAChBC,EAAkB,GAA+BD,G,OACrD,GAAOE,GADH,MAEJ,QAAOA,GAFH,Q,QAGJ,GAAMF,E,iBAEE5d,GAChB,OAAG,GAAsBA,GACpB8d,GAAiB9d,Q,cAmDC+d,EAAiBrH,G,OAAMqH,EAAEllB,K,aAOnBmlB,G,IAGUD,EAmBDA,EACAA,EACcA,EACRA,EACJA,EAEHA,EACKA,EACFA,EACJA,EACYA,EACcA,EAC1BA,EACIA,EACIA,EACvBA,E,MAnCnBE,E,SA5ImBC,G,OACf,GAAAA,I,IAAA,gB,OACoB,OAAQ,G,IAD5B,c,OAEkB,OAAQ,G,IAF1B,e,OAGmB,OAAQ,I,IAH3B,e,OAImB,OAAQ,G,IAJ3B,gC,IAAA,e,OAMmB,OAAQ,I,IAN3B,gB,OAOoB,OAAQ,G,IAP5B,gB,OAQoB,OAAQ,G,IAR5B,gB,OASoB,OAAQ,G,IAT5B,kB,OAUsB,OAAQ,I,IAV9B,kB,OAWsB,OAAQ,I,IAX9B,kB,OAYsB,OAAQ,I,IAZ9B,kB,OAasB,OAAQ,I,IAb9B,wB,OAc4B,OAAQ,I,IAdpC,iB,OAesB,OAAQ,G,IAf9B,gB,OAgBoB,OAAQ,G,IAhB5B,gB,OAiBoB,OAAQ,G,IAjB5B,kC,IAAA,iB,OAmBqB,OAAQ,I,IAnB7B,6B,OAoBiC,OAAQ,I,IApBzC,6B,OAqBiC,OAAQ,G,IArBzC,c,OAsBkB,OAAQ,I,IAtB1B,c,OAuBkB,OAAQ,I,IAvB1B,e,OAwBmB,OAAQ,I,IAxB3B,gB,OAyBoB,OAAQ,I,IAzB5B,a,OA0BiB,OAAQ,I,gBAiH7B,CADIF,GACJ,GADI,Q,OAAAC,E,OAEJE,EAAA,GAFIH,GAEJ,GAFI,S,MAEMI,EAFND,E,OAEgB,OAAQ,IAASJ,EAAAA,IAAe,OAAM,GAAUM,GAAeD,KAAAA,IAA9CE,GAAAP,I,QACrCQ,E,SAhHgBve,GAClB,OrBwRD,SAAkBA,GACrB,OAAOA,aAAaT,EAAuB,MAAZS,EAAErD,OAAiBqD,aAAa,CACnE,CqB1RW,CAAoBA,GAGhB,IAAe4B,GAAAA,CAASA,EAAO,EAAAA,GAAYA,EAAA,KAD9C,GAA2B5B,S,EA6G7B,CAHIge,GAGJ,GAHI,S,MAGOrhB,EAHP4hB,EAIER,EAAI,YAEA,GAAG,YAAqCvI,GAAO,GAC3C,OADoC,KAGtB6I,GAHsB,cAAA1hB,MAIpCqhB,K,OACZ,OAAQ,QAASM,GAAAP,I,QAEnBS,E,SAxGexe,GACjB,OrBmQD,SAAiBA,GACpB,OAAOA,aAAaT,EAAsB,MAAXS,EAAE/B,MAAgB+B,aAAa,CAClE,CqBrQW,CAAmBA,GAGf,IAAea,IAAAA,OACC,EAAAA,GAELA,EAD0B,IAAe0W,GAAQA,EAAA,KrBoRxCzV,EqBpRHjB,ErBqRP,MAAdiB,EAAInF,OAAiB,GAAKmF,EAAInF,UADlC,IAA4BmF,CqBpRHjB,GAHpB,GAAyBb,S,EAqG3B,CAbIge,GAaJ,GAbI,S,MAaM/f,EAbNugB,EAcET,EAAI,YACJ,GAAG,YAAuCvI,GAAM,GAC5C,OADsC,KAGxB,GAAU6I,GAHc,cAAApgB,MAGiB+f,K,OAC/D,OAAQ,QAAQM,GAAAP,I,QAElBU,ErBEH,SAAgBze,GACnB,OAAsB,MAAfA,EAAEJ,WAAqBI,EAAEJ,UAAU3G,OAAS,CACvD,CqB9BW,CADa+G,EAMVge,GrBgEP,SAA+Bhe,GAClC,IAAIkB,EACJ,OAA6B,QAArBA,EAAKlB,EAAEP,gBAA6B,IAAPyB,OAAgB,EAASA,EAAG,EACrE,CqBvEa,CAAuBlB,Q,EAyB1B,GArBI,S,MAqBKc,EArBL2d,E,OAqBiB,OAAQ,IAAOV,EAAAA,IAAiB,QAAMM,GAAevd,GAAUkd,KAAAA,IAAhDM,GAAAP,I,QACpCW,E,SA/Fc1e,GAChB,OAA0B,IAAtB,GAAAA,GAAAA,QAAsB,6CACrB,EAAAA,GAAyB,Q,EA6F5B,CAtBIge,GAsBJ,GAtBI,S,MAsBKld,EAtBL4d,E,OAsBiB,OAAQ,IAAOX,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QACpCY,E,SAnDqB3e,GACvB,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,mCACpB,EAAAA,GAAyB,Q,EAiD5B,CAvBIge,GAuBJ,GAvBI,S,MAuBYld,EAvBZ6d,E,OAuBwB,OAAQ,IAAcZ,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QAClDa,E,SA/CiB5e,GACnB,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,sCACpB,EAAAA,GAAyB,Q,EA6C5B,CAxBIge,GAwBJ,GAxBI,S,MAwBQld,EAxBR8d,E,OAwBoB,OAAQ,IAAUb,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QAC1Cc,E,SAjFe7e,GACjB,OrBiED,SAAiBA,GACpB,OAA4B,MAArBe,GAAef,EAC1B,CqBnEW,CAAAA,GACE,GAAAA,Q,EA+EH,CAzBIge,GAyBJ,GAzBI,S,MAyBMld,EAzBN+d,E,OAyBkB,OAAQ,IAAQd,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QAEtCe,E,SAzEe9e,GACjB,OAAG,GAAmBA,GrBqMvB,SAA0BA,GAC7B,GAAIuB,GAAQvB,IAAoB,MAAdA,EAAEP,SAChB,OAAOO,EAAEP,SAGT,MAAM,IAAIvH,MAAM,GAAG8H,EAAER,+BAE7B,CqB3Ma,CAA4BQ,Q,EAuE/B,CA3BIge,GA2BJ,GA3BI,S,MA2BMI,EA3BNU,E,OA2Be,OAAQ,IAAQf,EAAAA,IAAiB,OAAM,GAAUM,GAAeD,KAAAA,IAAhDE,GAAAP,I,QACnCgB,E,SA/EgB/e,GAClB,OAA0B,IAAtB,GAAAA,GAAAA,QAAsB,wCACrB,EAAAA,GAAyB,Q,EA6E5B,CA5BIge,GA4BJ,GA5BI,S,MA4BOld,EA5BPie,E,OA4BmB,OAAQ,IAAShB,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QACxCiB,E,SA7Hchf,GAChB,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,qBACpB,EAAAA,GAAyB,Q,EA2H5B,CA7BIge,GA6BJ,GA7BI,S,MA6BKld,EA7BLke,E,OA6BiB,OAAQ,IAASjB,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QACtCkB,E,SAnIajf,GACf,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,4CACpB,EAAAA,GAAyB,Q,EAiI5B,CA9BIge,GA8BJ,GA9BI,S,MA8BIld,EA9BJme,E,OA8BgB,OAAQ,IAAMlB,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QAClCmB,E,SA/Galf,GACf,GAA0B,IAAtB,GAAAA,GAAAA,QAAsB,6C,MAElBmf,EAAU,EAAAnf,G,OACRmf,EAAS,GAAIA,EAAS,G,EA2G9B,CA/BInB,GA+BJ,GA/BI,S,MA+BKoB,EA/BL,KA+BcC,EA/Bd,K,OA+B4B,OAAQ,IAAMtB,EAAAA,IAAiB,QAAMM,GAAee,GAASf,GAAegB,MAAAA,IAA9Df,GAAAP,I,QAC9CuB,E,SApEoBtf,GACtB,GAAyB,IAAtB,GAAAA,GAAAA,QAAsB,0C,MAEnBmf,EAAU,EAAAnf,G,OACRmf,EAAS,GAAIA,EAAS,G,EAgE5B,CAhCInB,GAgCJ,GAhCI,S,MAgCYoB,EAhCZ,KAgCqBC,EAhCrB,K,OAgCmC,OAAQ,IAAatB,EAAAA,IAAiB,QAAMM,GAAee,GAASf,GAAegB,GAAWA,KAAAA,IAAzEf,GAAAP,I,QAC5DwB,E,SA1Eavf,GACf,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,4CACnB,EAAAA,GAAyB,Q,EAwE7B,CAjCIge,GAiCJ,GAjCI,S,MAiCIld,EAjCJye,E,OAiCgB,OAAQ,IAAMxB,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QAClCyB,E,SApDexf,GACjB,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,0CACnB,EAAAA,GAAyB,Q,EAkD7B,CAlCIge,GAkCJ,GAlCI,S,MAkCMld,EAlCN0e,E,OAkCkB,OAAQ,IAAQzB,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QACtC0B,E,SAhDiBzf,GACnB,OAAyB,IAAtB,GAAAA,GAAAA,QAAsB,2BACpB,EAAAA,GAAyB,Q,EA8C5B,CAnCIge,GAmCJ,GAnCI,S,MAmCQld,EAnCR2e,E,OAmCoB,OAAQ,IAAU1B,EAAAA,IAAiB,OAAMM,GAAevd,KAAAA,IAAtCwd,GAAAP,I,QACrC,OAAQ,IAAMA,EAAAA,IAAiB,OAAMC,IAAAA,IAAvBM,GAAAP,I,qBA1CL/d,C,UA4CQ,OAAU,I,qCAElBge,G,IACVxI,EAAAiI,EAAAA,KAAA,GAAAjI,EAAAA,CAAA,GAAAkK,GAA0B1B,EAAAA,IAAAA,GAAAA,IAA1BP,IAAAA,IAAAA,EAAAA,CAAAA,KAAAA,GAAA,K,OACQ,K,OAENkC,EAAKC,GAAgB5B,GASzB,OAJS,GAAqB,GAAAA,KAClB,MAAAA,GAA+B,SAC/B,MAAAA,GAA+B,SAGvC0B,GAAA,IAAe1B,EAAiB2B,GAGhCA,C,cAOMvG,G,OAAAA,EAAAA,K,8JAoBS,E,eACR,E,aAGHA,GAAA,mBAGL,iBACA,OAAkBnC,GAAQ,wB,CClNlC,MAAM,WAA+B/e,MACxCT,cACIyd,MAAM,8BACN3d,OAAOsoB,eAAejoB,KAAM,GAAuB6I,UACvD,EAEG,MAAMqf,GACTroB,cACIG,KAAKmoB,UAAY,CACrB,CACWC,oCACP,OAAO,GACX,CACAC,oBACI,OAAOroB,KAAKmoB,YAAcD,GAAWE,sBACzC,CACAE,OAAOjjB,GACHrF,KAAKmoB,UAAY,EACjBI,WAAWljB,EAAG,EAClB,EAEG,SAAS,GAAcA,GAC1B,OAAQmjB,IACJ,GAAIA,EAAIC,YAAYC,YAChBF,EAAIG,SAAS,IAAI,SAEhB,GAAIH,EAAII,WAAWP,oBACpBG,EAAII,WAAWN,QAAO,KAClB,IACIjjB,EAAEmjB,EAIN,CAFA,MAAOK,GACHL,EAAIM,QAAQD,EAChB,UAIJ,IACIxjB,EAAEmjB,EAIN,CAFA,MAAOK,GACHL,EAAIM,QAAQD,EAChB,CACJ,CAER,CAoGO,MAAM,GAAY,IA9ElB,MACHE,KAAKC,EAAaC,GACd,OAvBD,SAAuBD,EAAaC,GACvC,OAAO,IAAeT,IAClBQ,EAAY,CACRE,UAAYjqB,IACR,IACIgqB,EAAOhqB,EAAPgqB,CAAUT,EAId,CAFA,MAAOW,GACHX,EAAIM,QAAQK,EAChB,GAEJL,QAASN,EAAIM,QACbH,SAAUH,EAAIG,SACdF,YAAaD,EAAIC,YACjBG,WAAYJ,EAAII,YAClB,GAEV,CAMe,CAAcI,EAAaC,EACtC,CACAG,QAAQC,EAAcC,GAClB,OAAOtpB,KAAK+oB,KAAKM,GAAc,IAAMC,GACzC,CACAC,MAAMnG,GACF,OAAO,IAAeoF,GAAQpF,IAAYoF,IAC9C,CACAgB,IAAIC,EAAUC,GACV,MAAM3pB,EAAO0pB,EAAShpB,OAAOC,YAC7B,IAAIR,EAAMH,EAAKI,OACf,OAAOH,KAAK2pB,OAAM,KAAOzpB,EAAIG,MAAML,KAAKupB,OAAM,KAC1C,MAAM/jB,EAAMkkB,EAAKxpB,EAAIE,OAErB,OADAF,EAAMH,EAAKI,OACJqF,CAAG,IAElB,CACAokB,OAAOxpB,GACH,OAvBD,SAAyBA,GAC5B,OAAO,IAAeooB,GAAQA,EAAIU,UAAU9oB,IAChD,CAqBe,CAAgBA,EAC3B,CACAypB,WAAWb,GACP,OAAOA,CACX,CACAc,WAAWd,EAAae,GACpB,OAAO,IAAevB,IAClBQ,EAAY,CACRE,UAAYjqB,IACR8qB,IACAvB,EAAIU,UAAUjqB,EAAE,EAEpB6pB,QAAU7pB,IACN8qB,IACAvB,EAAIM,QAAQ7pB,EAAE,EAElB0pB,SAAW1pB,IACP8qB,IACAvB,EAAIG,SAAS1pB,EAAE,EAEnBwpB,YAAaD,EAAIC,YACjBG,WAAYJ,EAAII,YAClB,GAEV,CACAoB,QAAQhB,EAAaiB,GACjB,OAAO,IAAezB,IAClBQ,EAAY,CACRE,UAAWV,EAAIU,UACfP,SAAUH,EAAIG,SACdF,YAAaD,EAAIC,YACjBG,WAAYJ,EAAII,WAChBE,QAAUK,IACN,IACIc,EAAad,EAAbc,CAAiBzB,EAIrB,CAFA,MAAO0B,GACH1B,EAAIM,QAAQoB,EAChB,IAEN,GAEV,CACAC,MAAMC,EAAUnB,GACZ,OAAOjpB,KAAK8pB,WAAWb,EAAOmB,IAAW,IAAMA,EAAS5qB,WAC5D,CACAmqB,MAAMU,EAAOrB,GACT,OAAIqB,IACOrqB,KAAK+oB,KAAKC,GAAa,IAAMhpB,KAAK2pB,MAAMU,EAAOrB,KAG/ChpB,KAAK4pB,YAAO,EAE3B,CACAU,OACI,OAAO,IAAe9B,GAAQA,EAAIU,eAAU,IAChD,GC1KG,MAAM,WAAuB,EAChCrpB,YAAYyG,KAAQvB,GAChBuY,QACAtd,KAAKsG,IAAa,EAANA,EACZtG,KAAK+E,OAASA,CAClB,CACAsB,QACI,MAAO,CAAC,KAAM,QAClB,EAkCG,MAAMkkB,WAAuB,EAChC1qB,YAAYyG,KAAQvB,GAChBuY,QACAtd,KAAKsG,IAAa,EAANA,EACZtG,KAAK+E,OAASA,CAClB,CACAsB,QACI,MAAO,CAAC,aAAc,aAC1B,EC5CJ,SAASmkB,GAAkBC,GAE3B,CAwEO,MAAMC,GAA2B,IFpFjC,MACH7qB,YAAY8qB,GAAY,GACpB3qB,KAAK4qB,IAAM,EACX5qB,KAAK6qB,WAAaF,EAClB3qB,KAAK8qB,WAAa,IAAIpG,GAC1B,CACIgE,kBACA,OAAO1oB,KAAK6qB,UAChB,CACAE,SACI,IAAK/qB,KAAK6qB,WAAY,CAClB7qB,KAAK6qB,YAAa,EAClB,IAAK,MAAO,CAAEG,KAAahrB,KAAK8qB,WAC5BE,GAER,CACJ,CACAC,YAAY5lB,GACR,MAAM7B,EAAKxD,KAAK4qB,IAEhB,OADA5qB,KAAK8qB,WAAW3oB,IAAInC,KAAK4qB,MAAOvlB,GACzB7B,CACX,CACA0nB,eAAe1nB,GACX,OAAOxD,KAAK8qB,WAAWrF,OAAOjiB,EAClC,CACA2nB,SAAS9lB,EAAGmX,GACR,MAAM4O,EAAIprB,KACJwD,EAAKxD,KAAKirB,YAAqB,MAATzO,EAAgBnX,EAAI,IAAMA,EAAEmX,IACxD,MAAO,CAAEhd,UAAY4rB,EAAEF,eAAe1nB,EAAK,EAC/C,GEmEG,SAAS,GAAkB6B,GAC9B,OAAO,IAAemjB,GAAQnjB,EAAE,CAACmjB,EAAIU,UAAWV,EAAIM,QAASN,EAAIG,YACrE,CAuCO,SAAS0C,GAAerC,EAAasC,GACxC,OAJG,SAAetC,EAAasC,GAC/B,OAKG,SAAgCtC,EAAauC,EAAcC,EAAuBC,EAA0BhD,GACnF,mBAAjB8C,IACP9C,EAAc8C,EACdA,OAAe1qB,GAEnB,MAAM+nB,EAAa,IAAIV,GACvBc,EAAY,CACRE,UAAWqC,GAA8Bf,GACzC1B,QAAS0C,GAAgDhB,GACzD7B,SAAU8C,GAAsDjB,GAChE/B,YAAaA,GAA4BiC,GACzC9B,cAER,CAlBW8C,CAAuB1C,EAAasC,EAC/C,CAEW/P,CAAMyN,EAAasC,EAC9B,C,SClIqD,OAChC,UACP,IACI,KAEI,WADI,G,YAKbK,G,OACL,OAEsB,UADPA,EADf,6C,aAKMA,G,OACN,OAEsB,UADPA,EADf,6C,aAWYC,EAASC,G,OAAoB,0BAAqBD,EAArB,gC,aAOhClC,EAAMmC,G,OAAoB,oCAAyBnC,EAAzB,kB,aAEdoC,EAA6CC,EAAcF,G,OAAoB,cACpG,QDoCG,IAAerD,GAAQA,EAAIU,UAAUV,EAAIC,gBCpCvCjH,I,MAAAwK,EAAAxK,EACDyK,EAAU,IAAgCC,I,MACtCC,EAAM,IAAAC,eAEJ,IAAAP,EAAA,eAEIM,EAAA,KAAa,OAAQN,EAAIQ,KAD1BF,EAAA,KAAa,MAAON,EAAIQ,KAG3B,MAAAP,GACO,EAAEK,GAGfH,EAAA,eACIG,EAAA,QACA,KAAO,UAAkCH,GAAO,I,MAIhChI,EAAA,EAAA6H,EAAA,SAApB,SAAoB,iD,MAAfS,EAAe,4DAChBH,EAAA,iBADgB,U,UAApB,EAAoBnI,E,CAGpBmI,EAAA,gBAAuBN,EAAIU,gBAE3BJ,EAAA,wB,QACU,MAAAA,EAAIK,YDxBnB,SAAiCR,GACpC,OAAgB,MAATA,GAAiBA,EAAMtD,WAClC,CCuB2C,CAAAsD,G,aACvB,OAAAG,G,QAGFvO,EAAAiO,EAAIY,Y,OAAJ7O,EAAAA,K,OAEwBuO,EAAA,KAAS,GAAT,c,aACVA,EAAA,KAAS,IClDpBO,EDkDW,uBCjDrB,WACEA,EACA,eAAiBA,K,cD6CPP,EAAA,O,IChDFO,C,WDoDb,cAAQT,EAAAA,K,CE9ET,SAASU,GAAU9N,GACxB,KAAM7e,gBAAgB2sB,IACpB,OAAO,IAAIA,GAAU9N,GAEvB7e,KAAKkZ,EAAI2F,CACX,CAEA,IAAI3F,GAAIyT,GAAU9jB,UAeX,SAAS,GAAOxD,EAAGunB,EAAMC,GAI9B,OAVK,SAAiBxnB,EAAGwnB,IAPpB,SAAeC,EAAGznB,GAEvB,IADA,IAAIjE,EAAI,EACAA,EAAI0rB,EAAG1rB,IACbiE,EAAEjE,EAEN,CAGE2rB,CAAMF,EAAIxrB,QAAQ,SAASD,GACzBiE,EAAEwnB,EAAIzrB,GAAIA,EAAGyrB,EACf,GACF,CAGEnH,EAAQ,SAASsH,EAAM5rB,EAAGyrB,GACxBD,EAAOvnB,EAAEunB,EAAMI,EAAM5rB,EAAGyrB,EAC1B,GAAGA,GACID,CACT,CAEO,SAAS,GAAIvnB,EAAGwnB,GACrB,OAAO,IACL,SAASjO,EAAKoO,EAAM5rB,EAAG6rB,GACrB,OAAOrO,EAAIjZ,OAAO,CAACN,EAAE2nB,EAAM5rB,EAAG6rB,IAChC,GACA,GACAJ,EAEJ,CAsQA,SAASK,GAASloB,GAChB,OAAOA,aAAe2nB,EACxB,CAEA,SAAS,GAAQ1tB,GACf,MAA+B,mBAAxB,CAAC,EAAEsC,SAAS4rB,KAAKluB,EAC1B,CAEA,SAASmuB,GAASnuB,GAEhB,MAvNyB,oBAAXouB,QAuNWA,OAAOD,SAASnuB,EAC3C,CAEO,SAASquB,GAAY1V,EAAOxX,GACjC,MAAO,CACLmtB,QAAQ,EACR3V,MAAOA,EACPxX,MAAOA,EACPotB,UAAW,EACXC,SAAU,GAEd,CAEO,SAASC,GAAY9V,EAAO6V,GAIjC,OAHK,GAAQA,KACXA,EAAW,CAACA,IAEP,CACLF,QAAQ,EACR3V,OAAQ,EACRxX,MAAO,KACPotB,SAAU5V,EACV6V,SAAUA,EAEd,CAEA,SAASE,GAAaxmB,EAAQymB,GAC5B,IAAKA,EACH,OAAOzmB,EAET,GAAIA,EAAOqmB,SAAWI,EAAKJ,SACzB,OAAOrmB,EAET,IAAIsmB,EACFtmB,EAAOqmB,WAAaI,EAAKJ,SAiC7B,SAAezT,EAAIiF,GAEjB,IADA,IAAIha,EAAM,CAAC,EACF5D,EAAI,EAAGA,EAAI2Y,EAAG1Y,OAAQD,IAC7B4D,EAAI+U,EAAG3Y,KAAM,EAEf,IAAK,IAAIkD,EAAI,EAAGA,EAAI0a,EAAG3d,OAAQiD,IAC7BU,EAAIga,EAAG1a,KAAM,EAEf,IAAIR,EAAO,GACX,IAAK,IAAImC,KAAKjB,GACR,CAAC,GAAE6oB,eAAeV,KAAKnoB,EAAKiB,IAC9BnC,EAAK+T,KAAK5R,GAId,OADAnC,EAAKE,OACEF,CACT,CAhDQgqB,CAAM3mB,EAAOsmB,SAAUG,EAAKH,UAC5BG,EAAKH,SACX,MAAO,CACLF,OAAQpmB,EAAOomB,OACf3V,MAAOzQ,EAAOyQ,MACdxX,MAAO+G,EAAO/G,MACdotB,SAAUI,EAAKJ,SACfC,SAAUA,EAEd,CAEA,SAASM,GAAoBxX,EAAOnV,GAClC,GAAIgsB,GAAS7W,GACX,MAAO,CACL7U,OAAQN,EACR4sB,MAAO,EACPC,QAAS,GAGb,IAAIC,EAAQ3X,EAAMwC,MAAM,EAAG3X,GAAG0V,MAAM,MAKpC,MAAO,CACLpV,OAAQN,EACR4sB,KAJkBE,EAAM7sB,OAKxB4sB,OAJoBC,EAAMA,EAAM7sB,OAAS,GAAGA,OAAS,EAMzD,CAqBA,SAAS8sB,GAAa3e,GACpB,IAAK0d,GAAS1d,GACZ,MAAM,IAAIlP,MAAM,iBAAmBkP,EAEvC,CAEA,SAASnN,GAAIkU,EAAOnV,GAClB,MAAqB,iBAAVmV,EACFA,EAAMmK,OAAOtf,GAEfmV,EAAMnV,EACf,CASA,SAASgtB,GAAanvB,GACpB,GAAiB,iBAANA,EACT,MAAM,IAAIqB,MAAM,iBAAmBrB,EAEvC,CAEA,SAASovB,GAAapvB,GACpB,KAAMA,aAAasb,QACjB,MAAM,IAAIja,MAAM,iBAAmBrB,GAGrC,IADA,IAAIoG,EAAI8S,GAAMlZ,GACLmC,EAAI,EAAGA,EAAIiE,EAAEhE,OAAQD,IAAK,CACjC,IAAI8c,EAAI7Y,EAAEqb,OAAOtf,GAIjB,GAAU,MAAN8c,GAAmB,MAANA,GAAmB,MAANA,EAC5B,MAAM,IAAI5d,MAAM,4BAA8B4d,EAAI,MAAQjf,EAE9D,CACF,CAEA,SAASqvB,GAAervB,GACtB,GAAiB,mBAANA,EACT,MAAM,IAAIqB,MAAM,mBAAqBrB,EAEzC,CAEA,SAASsvB,GAAatvB,GACpB,GAAiB,iBAANA,EACT,MAAM,IAAIqB,MAAM,iBAAmBrB,EAEvC,CAWO,SAASuvB,GAAOC,EAAQtO,GAC7B,OAAO,IAAIjhB,MAAMihB,EAAS,GAAGja,KAAKuoB,EACpC,CASO,SAASC,GAAQptB,EAAKqtB,EAAKC,GAChC,IAAIhf,EAAM+e,EAAMrtB,EAAID,OACpB,OAAIuO,GAAO,EACFtO,EAEFktB,GAAOI,EAAMhf,GAAOtO,CAC7B,CA2BO,SAASutB,GAAyBztB,EAAG0tB,EAAQC,EAAO1tB,GACzD,MAAO,CAEL2Y,KAAM5Y,EAAI0tB,EAAS,EAAI1tB,EAAI0tB,EAAS,EACpCE,GAAI5tB,EAAI2tB,EAAQ1tB,EAASA,EAASD,EAAI2tB,EAE1C,CAkBO,SAASE,GAAU1Y,EAAO2Y,GAC/B,IAIIjB,EACAkB,EACAjB,EACAkB,EACAC,EARAzX,EAAQsX,EAAMtX,MACdxW,EAAIwW,EAAMlW,OAEV4tB,EAAuB,EAO3B,GAAIluB,IAAMmV,EAAMlV,OACd,MAAO,2BAGT,GAAI+rB,GAAS7W,GAAQ,CACnB,IAAIgZ,EAAyBnuB,EAAKA,EAzFnB,EA0FXouB,EAAkBpuB,EAAImuB,EACtBE,EAAYZ,GACdU,EA3FYG,GA6FZC,GACApZ,EAAMlV,QAGJuuB,EA1ER,SAAkB/C,EAAKgD,GACrB,IAAIxuB,EAASwrB,EAAIxrB,OACbyuB,EAAS,GACTC,EAAa,EAEjB,GAAI1uB,GA7Ba,EA8Bf,MAAO,CAACwrB,EAAI9T,SAGd,IAAK,IAAI3X,EAAI,EAAGA,EAAIC,EAAQD,IACrB0uB,EAAOC,IACVD,EAAOjY,KAAK,IAGdiY,EAAOC,GAAYlY,KAAKgV,EAAIzrB,KAEvBA,EAAI,GAxCM,GAwCa,GAC1B2uB,IAIJ,OAAOD,CACT,CAoDwBE,CADRzZ,EAAMwC,MAAM0W,EAAUzV,KAAMyV,EAAUT,IACfzoB,SAASmmB,MAExCuD,EAAY,IAAI,SAASC,GAC3B,OAAO,IAAI,SAASC,GAElB,OAAOzB,GAAQyB,EAAU5uB,SAAS,IAAK,EAAG,IAC5C,GAAG2uB,EACL,GAAGN,GAEHR,EAlDG,SAA0BK,GAE/B,OAAuB,IAAnBA,EAAUzV,MAA+B,IAAjByV,EAAUT,GAC7B,CACLhV,KAAMyV,EAAUzV,KAChBgV,GAAIS,EAAUT,IAIX,CACLhV,KAAMyV,EAAUzV,KAnED,EAqEfgV,GAAI5f,KAAK0D,MAAM2c,EAAUT,GArEV,GAuEnB,CAoCgBoB,CAAiBX,GAC7BN,EAAqBI,EA5GN,EA6GftB,EAA2B,EAAlBuB,EAGLA,GAAmB,IACrBvB,GAAU,GAGZqB,EAAuB,EACvBpB,EAAQ,IAAI,SAASmC,GACnB,OAAOA,EAAShvB,QAAU,EACtBgvB,EAASnqB,KAAK,KACdmqB,EAAStX,MAAM,EAAG,GAAG7S,KAAK,KAAO,KAAOmqB,EAAStX,MAAM,GAAG7S,KAAK,IACrE,GAAG+pB,IACHZ,GACyD,GAAtDD,EAAUJ,GAAK,EAAII,EAAUJ,GAAK,EAAII,EAAUJ,KACjDztB,SAAS,IAAIF,QAEiB,IAC9BguB,EAA4B,EAEhC,KAAO,CACL,IAAIiB,EAAa/Z,EAAMO,MAAM,2BAC7BmX,EAASrW,EAAMqW,OAAS,EACxBkB,EAAqBvX,EAAMoW,KAAO,EAClCoB,EAAYP,GACVM,EAxIuB,EACD,EA0ItBmB,EAAWjvB,QAGb6sB,EAAQoC,EAAWvX,MAAMqW,EAAUpV,KAAMoV,EAAUJ,IACnDK,EAA4BD,EAAUJ,GAAGztB,WAAWF,MACtD,CAEA,IAAIkvB,EAA4BpB,EAAqBC,EAAUpV,KAE3DoT,GAAS7W,KACX8Y,GACyD,GAAtDD,EAAUJ,GAAK,EAAII,EAAUJ,GAAK,EAAII,EAAUJ,KACjDztB,SAAS,IAAIF,QAEiB,IAC9BguB,EAA4B,GAIhC,IAAImB,EAAuB,IACzB,SAAS5R,EAAK6R,EAAY7Y,GACxB,IAEI8Y,EAFAC,EAAkB/Y,IAAU2Y,EAC5BxlB,EAAS4lB,EAAkB,KA5Jb,KA6KlB,OAbED,EADEtD,GAAS7W,GACOmY,IACY,GAA1BU,EAAUpV,KAAOpC,IAAYrW,SAAS,IACxC8tB,EACA,KAGgBX,IACfU,EAAUpV,KAAOpC,EAAQ,GAAGrW,WAC7B8tB,EACA,KAIG,GAAG1pB,OACRiZ,EACA,CAAC7T,EAAS2lB,EAAkB,MAAQD,GACpCE,EACI,CAjLY,KAmLRnC,GAAO,IAAKa,GACZ,MACAX,GAAQ,GAAIT,EAAQ,KACpBO,GAAO,IAAKc,IAEhB,GAER,GACA,GACApB,GAGF,OAAOsC,EAAqBtqB,KAAK,KACnC,CAcO,SAASiS,GAAMyY,GACpB,IAAIruB,EAAI,GAAKquB,EACb,OAAOruB,EAAEwW,MAAMxW,EAAE6G,YAAY,KAAO,EACtC,CAEO,SAASynB,GAAeD,GAC7B,OAAOrW,OAAO,OAASqW,EAAGlV,OAAS,IAAKvD,GAAMyY,GAChD,CAIO,SAAS,KAGd,IAFA,IAAIE,EAAU,GAAG/X,MAAMoU,KAAK4D,WACxBC,EAAaF,EAAQzvB,OAChBiD,EAAI,EAAGA,EAAI0sB,EAAY1sB,GAAK,EACnC6pB,GAAa2C,EAAQxsB,IAEvB,OAAOqoB,IAAU,SAASpW,EAAOnV,GAG/B,IAFA,IAAI+F,EACA8pB,EAAQ,IAAI/xB,MAAM8xB,GACb1sB,EAAI,EAAGA,EAAI0sB,EAAY1sB,GAAK,EAAG,CAEtC,KADA6C,EAASwmB,GAAamD,EAAQxsB,GAAG4U,EAAE3C,EAAOnV,GAAI+F,IAClComB,OACV,OAAOpmB,EAET8pB,EAAM3sB,GAAK6C,EAAO/G,MAClBgB,EAAI+F,EAAOyQ,KACb,CACA,OAAO+V,GAAaL,GAAYlsB,EAAG6vB,GAAQ9pB,EAC7C,GACF,CA0DO,SAAS+pB,KACd,IAAI3rB,EAAO,GAAGwT,MAAMoU,KAAK4D,WACzB,GAAoB,IAAhBxrB,EAAKlE,OACP,MAAM,IAAIf,MAAM,sCAElB,IAAI6wB,EAAS5rB,EAAK6rB,MAElB,OADA9C,GAAe6C,GACR,GAAIE,MAAM,KAAM9rB,GAAMjC,KAAI,SAASguB,GACxC,OAAOH,EAAOE,MAAM,KAAMC,EAC5B,GACF,CAkBO,SAASC,KACd,IAAIT,EAAU,GAAG/X,MAAMoU,KAAK4D,WACxBC,EAAaF,EAAQzvB,OACzB,GAAmB,IAAf2vB,EACF,OAAO,GAAK,mBAEd,IAAK,IAAI1sB,EAAI,EAAGA,EAAI0sB,EAAY1sB,GAAK,EACnC6pB,GAAa2C,EAAQxsB,IAEvB,OAAOqoB,IAAU,SAASpW,EAAOnV,GAE/B,IADA,IAAI+F,EACK7C,EAAI,EAAGA,EAAIwsB,EAAQzvB,OAAQiD,GAAK,EAEvC,IADA6C,EAASwmB,GAAamD,EAAQxsB,GAAG4U,EAAE3C,EAAOnV,GAAI+F,IACnComB,OACT,OAAOpmB,EAGX,OAAOA,CACT,GACF,CAOO,SAASqqB,GAAOhS,EAAQiB,GAI7B,OAHA0N,GAAa3O,GACb2O,GAAa1N,GAENyQ,GAAO1R,EADFiB,EAAUgR,KAAKjS,GAAQkS,QACN,SAASC,EAAGC,GACvC,MAAO,CAACD,GAAGhsB,OAAOisB,EACpB,GACF,CAiRO,SAASnD,GAAOntB,GACrBitB,GAAajtB,GACb,IAAImsB,EAAW,IAAMnsB,EAAM,IAC3B,OAAOqrB,IAAU,SAASpW,EAAOnV,GAC/B,IAAIkD,EAAIlD,EAAIE,EAAID,OACZ+b,EAAO7G,EAAMwC,MAAM3X,EAAGkD,GAC1B,OAAI8Y,IAAS9b,EACJgsB,GAAYhpB,EAAG8Y,GAEfsQ,GAAYtsB,EAAGqsB,EAE1B,GACF,CAyBO,SAASoE,GAAOjB,EAAIkB,GACzBzD,GAAauC,GACTG,UAAU1vB,QAAU,EACtB+sB,GAAa0D,GAEbA,EAAQ,EAEV,IAAIC,EAAWlB,GAAeD,GAC1BnD,EAAW,GAAKmD,EACpB,OAAOjE,IAAU,SAASpW,EAAOnV,GAC/B,IAAImT,EAAQwd,EAASlnB,KAAK0L,EAAMwC,MAAM3X,IACtC,GAAImT,EAAO,CACT,GAAI,GAAKud,GAASA,GAASvd,EAAMlT,OAAQ,CACvC,IAAI2wB,EAAYzd,EAAM,GAClB0d,EAAa1d,EAAMud,GACvB,OAAOxE,GAAYlsB,EAAI4wB,EAAU3wB,OAAQ4wB,EAC3C,CAGA,OAAOvE,GAAYtsB,EADjB,2BAA6BmT,EAAMlT,OAAS,QAAUosB,EAE1D,CACA,OAAOC,GAAYtsB,EAAGqsB,EACxB,GACF,CAEO,SAAS,GAAQrtB,GACtB,OAAOusB,IAAU,SAASpW,EAAOnV,GAC/B,OAAOksB,GAAYlsB,EAAGhB,EACxB,GACF,CAEO,SAAS,GAAKqtB,GACnB,OAAOd,IAAU,SAASpW,EAAOnV,GAC/B,OAAOssB,GAAYtsB,EAAGqsB,EACxB,GACF,CAEO,SAAS,GAAUxuB,GACxB,GAAIiuB,GAASjuB,GACX,OAAO0tB,IAAU,SAASpW,EAAOnV,GAC/B,IAAI+F,EAASlI,EAAEia,EAAE3C,EAAOnV,GAGxB,OAFA+F,EAAOyQ,MAAQxW,EACf+F,EAAO/G,MAAQ,GACR+G,CACT,IACK,GAAiB,iBAANlI,EAChB,OAAO,GAAUwvB,GAAOxvB,IACnB,GAAIA,aAAasb,OACtB,OAAO,GAAUsX,GAAO5yB,IAE1B,MAAM,IAAIqB,MAAM,oCAAsCrB,EACxD,CAaO,SAASoM,GAAKgR,GAEnB,OADAiS,GAAejS,GACRsQ,IAAU,SAASpW,EAAOnV,GAC/B,IAAIwtB,EAAOvsB,GAAIkU,EAAOnV,GACtB,OAAIA,EAAImV,EAAMlV,QAAUgb,EAAUuS,GACzBtB,GAAYlsB,EAAI,EAAGwtB,GAEnBlB,GAAYtsB,EAAG,6BAA+Bib,EAEzD,GACF,CA5XAnD,GAAEzN,MAAQ,SAAS8K,GACjB,GAAqB,iBAAVA,IAAuB6W,GAAS7W,GACzC,MAAM,IAAIjW,MACR,iEAGJ,IAAI6G,EAASnH,KAAKkyB,KAAK,IAAKhZ,EAAE3C,EAAO,GACrC,OAAIpP,EAAOomB,OACF,CACLA,QAAQ,EACRntB,MAAO+G,EAAO/G,OAGX,CACLmtB,QAAQ,EACR3V,MAAOmW,GAAoBxX,EAAOpP,EAAOqmB,UACzCC,SAAUtmB,EAAOsmB,SAErB,EAIAvU,GAAElN,SAAW,SAAS1K,GACpB,IAAI6F,EAASnH,KAAKyL,MAAMnK,GACxB,GAAI6F,EAAOomB,OACT,OAAOpmB,EAAO/G,MAEd,IAAI2lB,EAhMD,SAAqBxP,EAAO2Y,GACjC,MAAO,CACL,KACA,qBAAuBV,GAAO,IAAK,IACnC,OACAS,GAAU1Y,EAAO2Y,GACjB,QAlM2BzB,EAmMZyB,EAAMzB,SAlMC,IAApBA,EAASpsB,OACJ,gBAAkBosB,EAAS,GAE7B,sCAAwCA,EAASvnB,KAAK,OAgM3D,MACAA,KAAK,IArMF,IAAwBunB,CAsM/B,CAsLc0E,CAAY7wB,EAAK6F,GACvB0hB,EAAM,IAAIvoB,MAAMylB,GAGpB,MAFA8C,EAAIuJ,KAAO,iBACXvJ,EAAI1hB,OAASA,EACP0hB,CAEV,EAEA3P,GAAEmZ,GAAK,SAASC,GACd,OAAOf,GAAIvxB,KAAMsyB,EACnB,EAEApZ,GAAEzC,KAAO,SAAS+I,GAChB,OAAOxf,KAAKuyB,KAAK/S,EAAQA,EAC3B,EAEAtG,GAAEqZ,KAAO,SAASC,EAAYC,GAC5B,OAAOvB,GAAOsB,EAAYxyB,KAAMyyB,GAAa,SAASC,EAAMC,GAC1D,OAAOA,CACT,GACF,EAEAzZ,GAAE0Z,KAAO,SAASC,GAChB,OAAOA,EAAQ7yB,KACjB,EAEAkZ,GAAEuY,KAAO,SAAStxB,GAEhB,OADAguB,GAAahuB,GACN,GAAIH,KAAMG,GAAMmD,KAAI,SAASguB,GAClC,OAAOA,EAAQ,EACjB,GACF,EAEApY,GAAEwY,KAAO,WACP,IAAI7rB,EAAO7F,KAEX,OAAO2sB,IAAU,SAASpW,EAAOnV,GAI/B,IAHA,IAAI6vB,EAAQ,GACR9pB,OAAStG,IAEJ,CAEP,KADAsG,EAASwmB,GAAa9nB,EAAKqT,EAAE3C,EAAOnV,GAAI+F,IAC7BomB,OAUT,OAAOI,GAAaL,GAAYlsB,EAAG6vB,GAAQ9pB,GAT3C,GAAI/F,IAAM+F,EAAOyQ,MACf,MAAM,IAAItX,MACR,kIAIJc,EAAI+F,EAAOyQ,MACXqZ,EAAMpZ,KAAK1Q,EAAO/G,MAItB,CACF,GACF,EAEA8Y,GAAE4Z,QAAU,SAASrS,GAEnB,OADA8N,GAAa9N,GACNzgB,KAAKsD,KAAI,SAASiC,GAEvB,GA/eJ,SAAqBtG,GACnB,IAAK,GAAQA,GACX,MAAM,IAAIqB,MAAM,iBAAmBrB,EAEvC,CA0eI8zB,CAAYxtB,GACRA,EAAKlE,OAAQ,CACfktB,GAAahpB,EAAK,IAElB,IADA,IAAIhD,EAAIgD,EAAK,GACJnE,EAAI,EAAGA,EAAImE,EAAKlE,OAAQD,IAC/BmtB,GAAahpB,EAAKnE,IAClBmB,GAAKke,EAAYlb,EAAKnE,GAExB,OAAOmB,CACT,CACE,MAAO,EAEX,GACF,EAEA2W,GAAE8Z,IAAM,WACN,OAAOhzB,KAAK8yB,QAAQ,GACtB,EAEA5Z,GAAE6T,MAAQ,SAAShhB,EAAKnH,GACtB,IAAIiB,EAAO7F,KAMX,OALI+wB,UAAU1vB,OAAS,IACrBuD,EAAMmH,GAERqiB,GAAariB,GACbqiB,GAAaxpB,GACN+nB,IAAU,SAASpW,EAAOnV,GAI/B,IAHA,IAAI6vB,EAAQ,GACR9pB,OAAStG,EACToyB,OAAapyB,EACRksB,EAAQ,EAAGA,EAAQhhB,EAAKghB,GAAS,EAAG,CAG3C,GADAkG,EAAatF,GADbxmB,EAAStB,EAAKqT,EAAE3C,EAAOnV,GACW6xB,IAC9B9rB,EAAOomB,OAIT,OAAO0F,EAHP7xB,EAAI+F,EAAOyQ,MACXqZ,EAAMpZ,KAAK1Q,EAAO/G,MAItB,CACA,KAAO2sB,EAAQnoB,IAEbquB,EAAatF,GADbxmB,EAAStB,EAAKqT,EAAE3C,EAAOnV,GACW6xB,GAC9B9rB,EAAOomB,QAHOR,GAAS,EAIzB3rB,EAAI+F,EAAOyQ,MACXqZ,EAAMpZ,KAAK1Q,EAAO/G,OAKtB,OAAOutB,GAAaL,GAAYlsB,EAAG6vB,GAAQgC,EAC7C,GACF,EAEA/Z,GAAE/R,OAAS,SAAS3B,GAClB,OAAOxF,KAAKsD,KAAI,WACd,OAAOkC,CACT,GACF,EAEA0T,GAAEga,OAAS,SAASpG,GAClB,OAAO9sB,KAAK+sB,MAAM,EAAGD,EACvB,EAEA5T,GAAEia,QAAU,SAASrG,GACnB,OAAOoE,GAAOlxB,KAAK+sB,MAAMD,GAAI9sB,KAAK0xB,QAAQ,SAAS0B,EAAMC,GACvD,OAAOD,EAAKztB,OAAO0tB,EACrB,GACF,EAEAna,GAAE5V,IAAM,SAASgwB,GACfhF,GAAegF,GACf,IAAIztB,EAAO7F,KACX,OAAO2sB,IAAU,SAASpW,EAAOnV,GAC/B,IAAI+F,EAAStB,EAAKqT,EAAE3C,EAAOnV,GAC3B,OAAK+F,EAAOomB,OAGLI,GAAaL,GAAYnmB,EAAOyQ,MAAO0b,EAAGnsB,EAAO/G,QAAS+G,GAFxDA,CAGX,GACF,EAEA+R,GAAEqa,UAAY,SAASD,GACrBhF,GAAegF,GACf,IAAIztB,EAAO7F,KACX,OAAO2sB,IAAU,SAASpW,EAAOnV,GAC/B,IAAI+F,EAAStB,EAAK4F,MAAM6nB,EAAG/c,EAAMwC,MAAM3X,KACvC,OAAK+F,EAAOomB,OAGLD,GAAYlsB,EAAImV,EAAMlV,OAAQ8F,EAAO/G,OAFnC+G,CAGX,GACF,EAEA+R,GAAEsa,OAAS,SAASnuB,EAAGouB,GAGrB,OAFAnF,GAAejpB,GACfipB,GAAemF,GACRzzB,KAAKuzB,UAAUluB,GAAG/B,IAAImwB,EAC/B,EAEAva,GAAEgZ,KAAO,SAAS/xB,GAChB,OAAO,GAAIH,KAAMG,GAAMmD,KAAI,SAASguB,GAClC,OAAOA,EAAQ,EACjB,GACF,EAEApY,GAAEwa,KAAO,WACP,OAAOxC,GAAO,GAAOlxB,KAAM,IAAO,SAASub,EAAOnb,EAAOuzB,GACvD,MAAO,CACLpY,MAAOA,EACPnb,MAAOA,EACPuzB,IAAKA,EAET,GACF,EAEAza,GAAEiG,KAAO,SAAShZ,GAChB,OAAO+qB,GAAO,GAAOlxB,KAAM,IAAO,SAASub,EAAOnb,EAAOuzB,GACvD,MAAO,CACLxtB,KAAMA,EACN/F,MAAOA,EACPmb,MAAOA,EACPoY,IAAKA,EAET,GACF,EAEAza,GAAE0a,MAAQ,SAASnT,GACjB,OAxOK,SAAejB,EAAQiB,GAE5B,OAAO+Q,GAAOhS,EAAQiB,GAAW4R,GAAG,GAAQ,IAC9C,CAqOSuB,CAAM5zB,KAAMygB,EACrB,EAEAvH,GAAEsY,OAAS,SAAS/Q,GAClB,OAAO+Q,GAAOxxB,KAAMygB,EACtB,EAEAvH,GAAE2a,UAAY,SAAS50B,GACrB,OAAOe,KAAKkyB,KAAK,GAAUjzB,GAC7B,EAEAia,GAAE4a,cAAgB,SAAS70B,GACzB,OAAOe,KAAKkyB,MAoIZ/D,GAD4B3O,EAnIGvgB,GAqIxB0tB,IAAU,SAASpW,EAAOnV,GAC/B,IAAI+F,EAASqY,EAAOtG,EAAE3C,EAAOnV,GACzB2yB,EAAOxd,EAAMwC,MAAM3X,EAAG+F,EAAOyQ,OACjC,OAAOzQ,EAAOomB,OACVG,GAAYtsB,EAAG,QAAU2yB,EAAO,KAChCzG,GAAYlsB,EAAG,KACrB,MARK,IAAuBoe,CAlI9B,EAEAtG,GAAE8a,KAAO,SAASvG,GACX,GAAQA,KACXA,EAAW,CAACA,IAEd,IAAI5nB,EAAO7F,KACX,OAAO2sB,IAAU,SAASpW,EAAOnV,GAC/B,IAAI6yB,EAAQpuB,EAAKqT,EAAE3C,EAAOnV,GAI1B,OAHK6yB,EAAM1G,SACT0G,EAAMxG,SAAWA,GAEZwG,CACT,GACF,EAEA/a,GAAEgb,SAAW,SAAS/sB,GACpB,OAAOnH,KAAKqyB,GAAG,GAAQlrB,GACzB,EAEA+R,GAAEib,GAAK,SAASttB,GACd,OAAOqqB,GAAOrqB,EAAO7G,MAAM,SAASqF,EAAGpG,GACrC,OAAOoG,EAAEpG,EACX,GACF,EAEAia,GAAEkb,MAAQ,SAAS/uB,GACjB,IAAIQ,EAAO7F,KACX,OAAO2sB,IAAU,SAASpW,EAAOnV,GAC/B,IAAI+F,EAAStB,EAAKqT,EAAE3C,EAAOnV,GAC3B,OAAK+F,EAAOomB,OAILI,GADUtoB,EAAE8B,EAAO/G,OACK8Y,EAAE3C,EAAOpP,EAAOyQ,OAAQzQ,GAH9CA,CAIX,GACF,EAoLA+R,GAAEvT,OAASuT,GAAEmZ,GACbnZ,GAAEmb,MALF,WACE,OAAO,GAAK,qBACd,EAIAnb,GAAEob,GAAK,GACPpb,GAAE,mBAAqBA,GAAEib,GACzBjb,GAAE,sBAAwBA,GAAEkb,MAC5Blb,GAAE,uBAAyBA,GAAEvT,OAC7BuT,GAAE,sBAAwBA,GAAEmb,MAC5Bnb,GAAE,mBAAqBA,GAAEob,GACzBpb,GAAE,oBAAsBA,GAAE5V,IAInB,MAAM,GAAQqpB,IAAU,SAASpW,EAAOnV,GAC7C,OAAOksB,GAAYlsB,EAAG2sB,GAAoBxX,EAAOnV,GACnD,IAaa,IAXMurB,IAAU,SAASpW,EAAOnV,GAC3C,OAAIA,GAAKmV,EAAMlV,OACNqsB,GAAYtsB,EAAG,sBAEjBksB,GAAYlsB,EAAI,EAAGiB,GAAIkU,EAAOnV,GACvC,IAEmBurB,IAAU,SAASpW,EAAOnV,GAC3C,OAAOksB,GAAY/W,EAAMlV,OAAQkV,EAAMwC,MAAM3X,GAC/C,IAEmBurB,IAAU,SAASpW,EAAOnV,GAC3C,OAAIA,EAAImV,EAAMlV,OACLqsB,GAAYtsB,EAAG,OAEjBksB,GAAYlsB,EAAG,KACxB,KAEamzB,GAAQ1C,GAAO,SAASmC,KAAK,WAI7BQ,IAHS3C,GAAO,UAAUmC,KAAK,mBACtBnC,GAAO,UAAUmC,KAAK,YACrBnC,GAAO,WAAWmC,KAAK,oBACjBnC,GAAO,OAAOmC,KAAK,wBAEnCS,IADa5C,GAAO,OAAOmC,KAAK,cAC3BvF,GAAO,OACZiG,GAAKjG,GAAO,MAEZkG,GAAUpD,GADH9C,GAAO,QACMiG,GAAID,IAAIT,KAAK,W,YCrsChCxU,G,OACNA,EAAOkS,M,CDqsCIH,GAAIoD,GAAS,I,SApEzB,SAAcX,EAAM3uB,GACrB0rB,UAAU1vB,OAAS,IACrBgE,EAAI2uB,EACJA,OAAOnzB,GAGT,IAAI2e,EAASmN,IAAU,SAASpW,EAAOnV,GAErC,OADAoe,EAAOtG,EAAI7T,IAAI6T,EACRsG,EAAOtG,EAAE3C,EAAOnV,EACzB,IAEA,OAAI4yB,EACKxU,EAAOwU,KAAKA,GAEZxU,CAEX,E,kBCjlCoBoV,EAAuBC,G,OACnCA,EAAOjB,MAAMgB,E,aAEJlC,EAAoBoC,EAAqBnC,G,OAvE5CoC,EA0EHD,EAtDK/F,EAqDL4D,EADHD,EAnDO,KAAM3D,GApBRmD,KAAK6C,G,IADJA,EAoBEhG,C,aAyDH1pB,EAAcma,G,OAAuBA,EAAOlc,IAAI+B,E,aAW7C2vB,G,OjBqvBT,SAAgB3vB,EAAG0U,GACtB,GAAIyE,GAAwBzE,GACxB,MAAM,IAAKzZ,MF55Ba,yBE+5BxB,OAAO,GAAK+E,EAAG,GAAK0U,GAAK,GAAKA,GAEtC,CiB3vBQ,GAAiB6E,EAAIY,IAAUZ,EAAIyT,GAAM7S,IAASwV,E,CA3B/C,GADHT,I,oCAgEche,EAAgBnW,G,OAE3B,IAASohB,GAAKphB,GADjB,GAAImW,G,yBAcIiJ,G,OACRA,EAAOlc,KAAK2xB,GAAA,GAAc,GAAdA,I,aCjNb,SAAS,GAAM3zB,GAClB,MAAM2K,EAAW,IAAI,EAAU,GAC/B,GAbG,SAAkB3K,EAAK2K,GAE1B,GAAW,MAAP3K,GAAe,KAAK+J,KAAK/J,GAAM,CAC/B,MAAMiC,GAAKjC,EAAIwJ,QAAQ,IAAK,IAC5B,IAAKY,OAAOE,MAAMrI,GAEd,OADA0I,EAASzE,SAAWjE,GACb,CAEf,CACA,OAAO,CACX,CAGQ,CAASjC,EAAK2K,GACd,OAAOA,EAASzE,SAGhB,MAAM,IAAIlH,MAAM,4CAExB,C,kJCVO,MAAM40B,GACTr1B,YAAYoG,EAAG1C,GACXvD,KAAKiG,EAAIA,EACTjG,KAAKuD,EAAIA,CACb,EAOG,SAAS4xB,GAA2BlvB,EAAG1C,GAC1C,OAAO,IAAI2xB,GAAcjvB,EAAG1C,EAChC,CAEO,SAAS6xB,GAAuBlc,GACnC,OAAOA,EAAEjT,CACb,CAEO,SAASovB,GAAyBnc,GACrC,OAAOA,EAAE3V,CACb,CAEO,MAAM+xB,WAAsBJ,GAC/Br1B,YAAYoG,EAAG1C,EAAGmvB,EAAMoC,EAAOtyB,GAC3B8a,MAAMrX,EAAG1C,GACTvD,KAAK0yB,KAAOA,EACZ1yB,KAAK80B,MAAQA,EACb90B,KAAKwC,EAAS,EAAJA,CACd,EAOG,SAAS+yB,GAA6BtvB,EAAG1C,EAAGmvB,EAAMoC,EAAOtyB,GAC5D,OAAO,IAAI8yB,GAAcrvB,EAAG1C,EAAGmvB,EAAMoC,EAAOtyB,EAChD,CAEO,SAASgzB,GAAwBtc,GACpC,OAAOA,EAAEwZ,IACb,CAEO,SAAS+C,GAAyBvc,GACrC,OAAOA,EAAE4b,KACb,CAEO,SAASY,GAA0Bxc,GACtC,OAAOA,EAAE1W,CACb,CAMO,SAASmzB,GAAsBC,EAASC,GAC3CF,EACA,OAAa,CACT,MAAM/W,EAAMgX,EAASlf,EAAImf,EACzB,GAAS,MAALnf,EAAW,CACX,MAAMof,EAAKpf,EACX,GAAIof,aAAcR,GAAe,CAC7BM,EAAUD,GAAsB/W,EAAM,EAAG4W,GAAwBM,IACjED,EAAQJ,GAAyBK,GACjC,SAASH,CACb,CAEI,OAAQ/W,EAAM,EAAK,CAE3B,CAEI,OAAa,EAANA,CAGf,CACJ,CAEO,SAASmX,GAAmB92B,GAC/B,OAAO02B,GAAsB,EAAG12B,EACpC,CAEO,SAAS+2B,GAAiB7P,EAAGlgB,EAAG1C,EAAGouB,GACtC,IAAIsE,EASAC,EAPJ,GAAS,MADC/P,EACK,CACX,MAAM2P,EAFA3P,EAGN8P,EAAOH,aAAcR,GAAiBI,GAA0BI,GAAM,CAC1E,MAEIG,EAAK,EAIT,GAAW,MADCtE,EACK,CACb,MAAMwE,EAFExE,EAGRuE,EAAOC,aAAgBb,GAAiBI,GAA0BS,GAAQ,CAC9E,MAEID,EAAK,EAET,MAAME,EAA8B,GAAtBH,EAAKC,EAAMA,EAAKD,GAC9B,OAAY,IAARG,EACOjB,GAA2BlvB,EAAG1C,GAG9BgyB,GAA6BtvB,EAAG1C,EAAG4iB,EAAGwL,EAAGyE,EAAM,EAE9D,CAEO,SAASC,GAAwBhuB,EAAIpC,EAAG1C,EAAG+E,GAC9C,IAAI8tB,EAAKE,EAAMC,EAAKC,EAChBC,EASAC,EAPJ,GAAS,MADCruB,EACK,CACX,MAAMytB,EAFAztB,EAGNouB,EAAQX,aAAcR,GAAiBI,GAA0BI,GAAM,CAC3E,MAEIW,EAAM,EAIV,GAAW,MADCnuB,EACK,CACb,MAAM6tB,EAFE7tB,EAGRouB,EAAQP,aAAgBb,GAAiBI,GAA0BS,GAAQ,CAC/E,MAEIO,EAAM,EAEV,GAAIA,EAAOD,EAAM,EAAI,CACjB,MAAM7Y,EAAa,GAAQtV,GAC3B,GAAIsV,aAAsB0X,GAAe,CACrC,GAAMc,EAAMZ,GAAwB5X,IAAqB,MAAPwY,GAAiBE,EAAOF,EAAME,aAAgBhB,GAAiBI,GAA0BY,GAAQ,GAAM,GAAOG,EAAM,EAAI,CACtK,MAAM1T,EAAe,GAAQyS,GAAwB5X,IACrD,GAAImF,aAAwBuS,GACxB,OAAOU,GAAiBA,GAAiB3tB,EAAIpC,EAAG1C,EAAGiyB,GAAwBzS,IAAgBqS,GAAuBrS,GAAesS,GAAyBtS,GAAeiT,GAAiBP,GAAyB1S,GAAeqS,GAAuBxX,GAAayX,GAAyBzX,GAAa6X,GAAyB7X,KAGrU,MAAM,IAAKtd,MAAM,gCAEzB,CAEI,OAAO01B,GAAiBA,GAAiB3tB,EAAIpC,EAAG1C,EAAGiyB,GAAwB5X,IAAcwX,GAAuBxX,GAAayX,GAAyBzX,GAAa6X,GAAyB7X,GAEpM,CAEI,MAAM,IAAKtd,MAAM,gCAEzB,CACK,GAAIm2B,EAAOC,EAAM,EAAI,CACtB,MAAMC,EAAe,GAAQtuB,GAC7B,GAAIsuB,aAAwBrB,GAAe,CACvC,GAAMiB,EAAMd,GAAyBkB,IAAuB,MAAPJ,GAAiBC,EAAOD,EAAMC,aAAgBlB,GAAiBI,GAA0Bc,GAAQ,GAAM,GAAOE,EAAM,EAAI,CACzK,MAAME,EAAe,GAAQnB,GAAyBkB,IACtD,GAAIC,aAAwBtB,GACxB,OAAOU,GAAiBA,GAAiBR,GAAwBmB,GAAevB,GAAuBuB,GAAetB,GAAyBsB,GAAenB,GAAwBoB,IAAgBxB,GAAuBwB,GAAevB,GAAyBuB,GAAeZ,GAAiBP,GAAyBmB,GAAe3wB,EAAG1C,EAAG+E,IAGnV,MAAM,IAAKhI,MAAM,gCAEzB,CAEI,OAAO01B,GAAiBR,GAAwBmB,GAAevB,GAAuBuB,GAAetB,GAAyBsB,GAAeX,GAAiBP,GAAyBkB,GAAe1wB,EAAG1C,EAAG+E,GAEpN,CAEI,MAAM,IAAKhI,MAAM,gCAEzB,CAEI,OAAO01B,GAAiB3tB,EAAIpC,EAAG1C,EAAG+E,EAE1C,CAEO,SAASuuB,GAAkBhyB,EAAUoB,EAAG1C,EAAGmT,GAC9C,GAAS,MAALA,EAAW,CACX,MAAMof,EAAKpf,EACLwH,EAAsD,EAAlDrZ,EAASsY,QAAQlX,EAAGmvB,GAAuBU,IACrD,OAAIA,aAAcR,GACVpX,EAAI,EACGmY,GAAwBQ,GAAkBhyB,EAAUoB,EAAG1C,EAAGiyB,GAAwBM,IAAMV,GAAuBU,GAAKT,GAAyBS,GAAKL,GAAyBK,IAEvK,IAAN5X,EACEqX,GAA6BtvB,EAAG1C,EAAGiyB,GAAwBM,GAAKL,GAAyBK,GAAKJ,GAA0BI,IAGxHO,GAAwBb,GAAwBM,GAAKV,GAAuBU,GAAKT,GAAyBS,GAAKe,GAAkBhyB,EAAUoB,EAAG1C,EAAGkyB,GAAyBK,KAGhL5X,EAAI,EACFqX,GAA6BtvB,EAAG1C,OAAGuzB,EAAuBpgB,EAAG,GAEzD,IAANwH,EACEiX,GAA2BlvB,EAAG1C,GAG9BgyB,GAA6BtvB,EAAG1C,EAAGmT,OAAGogB,EAAuB,EAE5E,CAEI,OAAO3B,GAA2BlvB,EAAG1C,EAE7C,CAEO,SAASwzB,GAAsBC,EAAcC,EAAOpB,GACvDkB,EACA,OAAa,CACT,MAAMlyB,EAAWmyB,EAAc/wB,EAAIgxB,EAAOvgB,EAAImf,EAC9C,GAAS,MAALnf,EAAW,CACX,MAAMof,EAAKpf,EACLwH,EAAsD,EAAlDrZ,EAASsY,QAAQlX,EAAGmvB,GAAuBU,IACrD,GAAU,IAAN5X,EACA,OAAO,GAAKmX,GAAyBS,IAEpC,GAAIA,aAAcR,GAAe,CAClC0B,EAAenyB,EACfoyB,EAAQhxB,EACR4vB,EAAU3X,EAAI,EAAKsX,GAAwBM,GAAML,GAAyBK,GAC1E,SAASiB,CACb,CAEI,MAER,CAEI,MAGR,CACJ,CA8PO,SAASG,GAAsBC,EAAOtB,GACzCqB,EACA,OAAa,CACT,MAAM7xB,EAAI8xB,EAAOzgB,EAAImf,EACrB,GAAS,MAALnf,EAAW,CACX,MAAMof,EAAKpf,EACX,GAAIof,aAAcR,GAAe,CAC7B4B,GAAsB7xB,EAAGmwB,GAAwBM,IACjDzwB,EAAE+vB,GAAuBU,GAAKT,GAAyBS,IACvDqB,EAAQ9xB,EACRwwB,EAAQJ,GAAyBK,GACjC,SAASoB,CACb,CAEI7xB,EAAE+vB,GAAuBU,GAAKT,GAAyBS,GAE/D,CACA,KACJ,CACJ,CAEO,SAASsB,GAAmB/xB,EAAGqR,GAClCwgB,GAAsB7xB,EAAGqR,EAC7B,CA8QO,SAAS2gB,GAA0B3gB,EAAGmW,EAAKzrB,GAC9C,IAAIkD,EAAIlD,EACRg2B,IAAmB,CAACn4B,EAAGS,KACnBmtB,EAAIvoB,GAAK,CAACrF,EAAGS,GACb4E,EAAMA,EAAI,EAAK,CAAE,GAClBoS,EACP,CAwCO,SAAS4gB,GAAoBzyB,EAAUqZ,GAC1C,GAAI,EAAYA,GACZ,OAXD,SAA+BrZ,EAAUgoB,GAC5C,IAAIrnB,EACJ,IAAK,IAAI2T,EAAM,EAAGA,GAAQ0T,EAAIxrB,OAAS,EAAI8X,IAAO,CAC9C,MAAMmT,EAAaO,EAAI1T,GACvB3T,EAAMqxB,GAAkBhyB,EAAUynB,EAAW,GAAIA,EAAW,GAAI9mB,EACpE,CACA,OAAOA,CACX,CAIe+xB,CAAsB1yB,EAAUqZ,GAEtC,GAAIA,aAAa,GAClB,OApCD,SAA8BrZ,EAAUshB,GAC3C,OAAO,IAAO,CAACvH,EAAKsN,IAAc2K,GAAkBhyB,EAAUqnB,EAAU,GAAIA,EAAU,GAAItN,SAAMkY,EAAuB3Q,EAC3H,CAkCeqR,CAAqB3yB,EAAUqZ,GAErC,CACD,MAAMuZ,EAAK,EAAcvZ,GACzB,IACI,OArCL,SAAwC8Y,EAAcpB,EAAS8B,GAElE,OAAa,CACT,MAAM7yB,EAAWmyB,EAAcpY,EAAMgX,EAAS3oB,EAAIyqB,EAClD,IAAIzqB,EAAE,6CAQF,OAAO2R,EARX,CACI,MAAMqH,EAAehZ,EAAE,0DACvB+pB,EAAenyB,EACf+wB,EAAUiB,GAAkBhyB,EAAUohB,EAAa,GAAIA,EAAa,GAAIrH,GACxE8Y,EAAQzqB,CAKZ,CAEJ,CACJ,CAqBmB0qB,CAA+B9yB,OAAUiyB,EAAuBW,EAI3E,CAFA,QACI,EAAYA,EAChB,CACJ,CACJ,CAEO,MAAMG,WAAoC,EAC7C/3B,YAAYg4B,EAAOjV,GACftF,QACAtd,KAAK63B,MAAQA,EACb73B,KAAK4iB,QAAUA,CACnB,EAOG,SAASkV,GAA0BC,GACtCD,EACA,OAAa,CACT,MAAMD,EAAQE,EACd,GAAK,GAAUF,GAmBX,OAAO,KAnBY,CACnB,MAAMxE,EAAO,GAAKwE,GACZnhB,EAAI,GAAKmhB,GACf,GAAS,MAALnhB,EAAW,CACX,MAAMof,EAAKpf,EACX,GAAIof,aAAcR,GAAe,CAC7ByC,EAAY,GAAgB,CAACvC,GAAwBM,GAAKX,GAA2BC,GAAuBU,GAAKT,GAAyBS,IAAML,GAAyBK,IAAMzC,GAC/K,SAASyE,CACb,CAEI,OAAOD,CAEf,CAEIE,EAAY1E,EACZ,SAASyE,CAEjB,CAKJ,CACJ,CAEO,SAASE,GAAyBthB,GACrC,OAAO,IAAIkhB,GAA4BE,GAA0B,GAAUphB,KAAK,EACpF,CAUO,SAASuhB,GAAsB72B,GAClC,GAAIA,EAAEwhB,QAAS,CACX,MAAMhF,EAAaxc,EAAEy2B,MACrB,GAAK,GAAUja,GAeX,OAtBL,WACH,MAAM,IAAKtd,MAAM,+BACrB,CAoBmB43B,GAdP,GAAwB,MAApB,GAAKta,GAAqB,CAC1B,MAAMlH,EAAI,GAAKkH,GACf,GAAIlH,aAAa4e,GACb,MAAM,IAAKh1B,MAAM,mEAGjB,MAAO,CAAC80B,GAAuB1e,GAAI2e,GAAyB3e,GAEpE,CAEI,MAAM,IAAKpW,MAAM,kEAM7B,CAEI,OA9BD,WACH,MAAM,IAAKA,MAAM,0BACrB,CA4Be63B,EAEf,CA8BO,SAASC,GAA4B1hB,GACxC,IAAItV,EAAI42B,GAAyBthB,GACjC,MAAO,CACH,uDAAwD,IAC7CuhB,GAAsB72B,GAEjC,6CAA8C,IACnC62B,GAAsB72B,GAEjC,0CAA2C,IArC5C,SAAgCA,GACnC,GAAIA,EAAEwhB,QAAS,CACX,MAAMhF,EAAaxc,EAAEy2B,MACrB,GAAK,GAAUja,GAgBX,OAAO,EAfP,GAAwB,MAApB,GAAKA,GAAqB,CAE1B,GADU,GAAKA,aACE0X,GACb,MAAM,IAAKh1B,MAAM,oEAIjB,OADAc,EAAEy2B,MAAQC,GAA0B,GAAKla,KACjC,GAAUxc,EAAEy2B,MAE5B,CAEI,MAAM,IAAKv3B,MAAM,mEAM7B,CAGI,OADAc,EAAEwhB,SAAU,GACJ,GAAUxhB,EAAEy2B,MAE5B,CAYmBQ,CAAuBj3B,GAElC,yCACIA,EAAI42B,GAAyBthB,EACjC,EACAlX,UACA,EAER,CAaO,MAAM84B,GACTz4B,YAAYgF,EAAU0zB,GAClBv4B,KAAK6E,SAAWA,EAChB7E,KAAKu4B,KAAOA,CAChB,CACAh5B,cAEI,OAA2C,EAwR5C,SAAoCilB,GACvC,MAAMgU,EAAc,CAACv5B,EAAGS,KAAST,GAAK,GAAKS,EAAK,IAChD,IAAI8F,EAAM,EACV,MAAMwe,EAAa,EAAcQ,GACjC,IACI,KAAOR,EAAW,8CAA8C,CAC5D,MAAMyU,EAA0BzU,EAAW,0DAC3Cxe,EAAsE,EAA/DgzB,EAAYhzB,EAAK,EAAeizB,EAAwB,KAC/DjzB,EAAsE,EAA/DgzB,EAAYhzB,EAAK,EAAeizB,EAAwB,IACnE,CAIJ,CAFA,QACI,EAAYzU,EAChB,CACA,OAAa,EAANxe,CACX,CAvSekzB,CADO14B,KAElB,CACA2D,OAAOg1B,GAEH,KAAIA,aAAgBL,IAqChB,OAAO,EArCoB,CAC3B,MAAMM,EAAK,EAFD54B,MAGV,IACI,MAAM64B,EAAK,EAAcF,GACzB,IACI,MAAMlb,EAAO,KACT,MAAMqb,EAAKF,EAAG,6CACd,GAAIE,IAAOD,EAAG,6CAA8C,CACxD,GAAKC,EAGA,CACD,MAAMC,EAAMH,EAAG,0DACTI,EAAMH,EAAG,0DACf,SAAI,EAAOE,EAAI,GAAIC,EAAI,MAAO,EAAOD,EAAI,GAAIC,EAAI,MACtCvb,GAKf,CAXI,OAAO,CAYf,CAEI,OAAO,CACX,EAEJ,OAAOA,GAIX,CAFA,QACI,EAAYob,EAChB,CAIJ,CAFA,QACI,EAAYD,EAChB,CACJ,CAIJ,CACAr3B,WAEI,MAAQ,QAAU,GAAK,KAAM,IAAO0D,GAAOoP,GAAO,aAAcpP,EAAG,GAAIA,EAAG,KAD5DjF,OAC4E,GAC9F,CACY6kB,IAAPpkB,OAAOokB,eACR,MAAO,WACX,CACAte,OAAO0X,GAEH,OAAO/e,MAAM8a,KADCha,KAElB,CACAQ,gBAEI,OAAO43B,GADIp4B,KAC2Bu4B,KAC1C,CACA,CAAC93B,OAAOC,YACJ,OAAO,EAAWV,KAAKQ,gBAC3B,CACA,iDAEI,OAAO43B,GADIp4B,KAC2Bu4B,KAC1C,CACA/zB,UAAUQ,GACN,MAAM0R,EAAI1W,KACV,GAAIgF,aAAeszB,GACf,OAGa,EXpoBlB,SAAqBzzB,EAAUkV,EAAIiF,GACtC,MAAM4Z,EAAK,GAAM7e,GACjB,IACI,MAAM8e,EAAK,GAAM7Z,GACjB,IACI,IAAId,EAAI,EACJ+a,EAAKL,EAAG,6CACRM,EAAKL,EAAG,6CACZ,KAAe,IAAN3a,GAAY+a,GAAOC,GACxBhb,EAA4I,EAAvIrZ,EAAS+zB,EAAG,0DAA2DC,EAAG,2DACrE,IAAN3a,IACA+a,EAAKL,EAAG,6CACRM,EAAKL,EAAG,8CAGhB,OAAoD,GAArC,IAAN3a,EAAWA,EAAK+a,EAAK,EAAKC,GAAM,EAAI,EAIjD,CAFA,QACI,EAAYL,EAChB,CAIJ,CAFA,QACI,EAAYD,EAChB,CACJ,CWymBmB,EAAY,CAACO,EAAMC,KACtB,MAAMlb,EAA2C,EAAvCxH,EAAE7R,SAASsY,QAAQgc,EAAK,GAAIC,EAAK,IAC3C,OAAqD,GAAtC,IAANlb,EAAWA,EAAI,EAAQib,EAAK,GAAIC,EAAK,IAAQ,GACvD1iB,EAAG1R,GAGN,MAAM,IAAK1E,MAAM,uCAEzB,CACA,oDAAsDrB,GAClD,MAAM,IAAKqB,MAAM,wBACrB,CACA,mDACI,MAAM,IAAKA,MAAM,wBACrB,CACA,uDAAyDrB,GACrD,MAAM,IAAKqB,MAAM,wBACrB,CACA,yDAA2DrB,GAEvD,OAAOo6B,GADGr5B,KACuBf,EAAE,KAAO,EAAOq6B,GADvCt5B,KAC8Df,EAAE,IAAKA,EAAE,GACrF,CACA,2DAA6D4tB,EAAKzrB,GAE9Di2B,GADUr3B,KACkBu4B,KAAM1L,EAAKzrB,EAC3C,CACA,4DACI,OAAO,CACX,CACA,uDAEI,OAAiC,EAA1Bm4B,GADGv5B,KAEd,CACA,+DAEI,OAAiC,EAA1Bu5B,GADGv5B,KAEd,CACI2P,WAEA,OAAiC,EAA1B4pB,GADGv5B,KAEd,CACAwlB,QACI,MAAM,IAAKllB,MAAM,wBACrB,CACAmlB,OAAOjE,GACH,MAAM,IAAKlhB,MAAM,wBAErB,CACA0F,UAEI,OAAO,IAAOwJ,GAAM,CAACA,EAAE,GAAIA,EAAE,KADnBxP,KAEd,CACAqC,IAAI4D,GAEA,OAAOqzB,GADGt5B,KACoBiG,EAClC,CACA/D,IAAI+D,GAEA,OAAOozB,GADGr5B,KACuBiG,EACrC,CACAnC,OAEI,OAAO,IAAO0L,GAAMA,EAAE,IADZxP,KAEd,CACAmC,IAAI8D,EAAG1C,GAEH,MAAM,IAAKjD,MAAM,wBAErB,CACA+C,SAEI,OAAO,IAAOmM,GAAMA,EAAE,IADZxP,KAEd,CACA0lB,QAAQrgB,EAAGsgB,GACP,MAAMjP,EAAI1W,KACV,IAAWwP,IACPnK,EAAEmK,EAAE,GAAIA,EAAE,GAAIkH,EAAE,GACjBA,EACP,EAOG,SAAS8iB,GAAgB30B,EAAU0zB,GACtC,OAAO,IAAID,GAAUzzB,EAAU0zB,EACnC,CAmCO,SAASe,GAAoB5iB,EAAGhS,GACnC,OAl7BG,SAA4BG,EAAUoB,EAAGyQ,GAC5C,MAAMkH,EAAamZ,GAAsBlyB,EAAUoB,EAAGyQ,GACtD,GAAkB,MAAdkH,EACA,MAAM,IAAKtd,MAGX,OAAO,GAAQsd,EAEvB,CA06BW6b,CAAmB/iB,EAAE7R,SAAUH,EAAKgS,EAAE6hB,KACjD,CA2CO,SAASgB,GAAqB7iB,GACjC,OAAOqf,GAAmBrf,EAAE6hB,KAChC,CAEO,SAASc,GAAuB3iB,EAAGhS,GACtC,OA1wBG,SAA2BsyB,EAAcC,EAAOpB,GACnD6D,EACA,OAAa,CACT,MAAM70B,EAAWmyB,EAAc/wB,EAAIgxB,EAAOvgB,EAAImf,EAC9C,GAAS,MAALnf,EAAW,CACX,MAAMof,EAAKpf,EACLwH,EAAsD,EAAlDrZ,EAASsY,QAAQlX,EAAGmvB,GAAuBU,IACrD,GAAIA,aAAcR,GAAe,CAC7B,GAAIpX,EAAI,EAAG,CACP8Y,EAAenyB,EACfoyB,EAAQhxB,EACR4vB,EAAQL,GAAwBM,GAChC,SAAS4D,CACb,CACK,GAAU,IAANxb,EACL,OAAO,EAGP8Y,EAAenyB,EACfoyB,EAAQhxB,EACR4vB,EAAQJ,GAAyBK,GACjC,SAAS4D,CAEjB,CAEI,OAAa,IAANxb,CAEf,CAEI,OAAO,CAGf,CACJ,CAyuBWwb,CAAkBhjB,EAAE7R,SAAUH,EAAKgS,EAAE6hB,KAChD,CAuDO,SAAS,GAAQoB,GACpB,OA9GiB,MA8GaA,EA9GrBpB,IA+Gb,CAcO,SAAS,GAAQ7zB,EAAKi1B,GACzB,OA9CG,SAA4BjjB,EAAGhS,GAClC,OAAOqyB,GAAsBrgB,EAAE7R,SAAUH,EAAKgS,EAAE6hB,KACpD,CA4CWqB,CAAmBD,EAAOj1B,EACrC,CAMO,SAASm1B,GAAYn1B,EAAKi1B,GAC7B,OAAON,GAAuBM,EAAOj1B,EACzC,CA4EO,SAAS,GAAOo1B,GACnB,OA1OG,SAA0BrC,GAC7B,MAAM5yB,EAAW,KACjB,OAAO20B,GAAgB30B,EAAUyyB,GAAoBzyB,EAAU4yB,GACnE,CAuOWsC,CAAiBD,EAC5B,CAWO,SAAS,GAAOH,GACnB,OAvoBG,SAA8BjjB,GACjC,MAAM+G,EAAO,CAACuc,EAASpE,KACnBnY,EACA,OAAa,CACT,MAAMwc,EAAMD,EAASpb,EAAMgX,EAC3B,GAAW,MAAPqE,EAAa,CACb,MAAMnE,EAAKmE,EACX,GAAInE,aAAcR,GAAe,CAC7B0E,EAAUxE,GAAwBM,GAClCF,EAAU,GAAK,CAACR,GAAuBU,GAAKT,GAAyBS,IAAMrY,EAAKgY,GAAyBK,GAAKlX,IAC9G,SAASnB,CACb,CAEI,OAAO,GAAK,CAAC2X,GAAuBU,GAAKT,GAAyBS,IAAMlX,EAEhF,CAEI,OAAOA,CAGf,GAEJ,OAAOnB,EAAK/G,EAAG,KACnB,CAoeWwjB,CA4IkBP,EA5IKpB,KA6IlC,CAEO,SAAS,GAAQoB,GACpB,OA1mBG,SAA+BjjB,GAClC,MAAMoW,EAA4B,EAAxBiJ,GAAmBrf,GACvBlR,EAAM,GAAK,IAAItG,MAAM4tB,GAAI,EAAGA,EAAG,CAAC,KAAM,OAE5C,OADAuK,GAA0B3gB,EAAGlR,EAAK,GAC3BA,CACX,CAydW20B,CA4ImBR,EA5IKpB,KA6InC,CAnQID,GAAUjE,MAAQmF,GAAgB,UAA0C1C,G,SCtnCvD,MAFd,GADA,GH+DI3D,QAkIC,K,GG1LL,IAAoBjH,IAAA,MADvB,GAAgB,GAAc,KAAKkO,K,GAWhC,MADA,GADH,IAJI,cAAgB,kDAEhB,cAAgB,qC,GASjB,IAAcC,GAAAA,IAAA,KAAAA,IADd,GADH,IAACC,GAAQF,GAAMG,O,GAOZ,GAFH,IAAE,GAAuB,OAAQ,UAAM,IACrC,GAAuB,QAAS,UAAM,O,GAGhC,GAAuB,OAAO,W,eAGlCC,EAEG,IAAchZ,I,OAAAA,G,IAAA,I,MACJ,K,IADI,I,MAEJ,K,IAFI,I,MAGJ,K,IAHI,I,MAIJ,K,IAJI,I,MAKJ,K,eACAA,E,GJ4nClB,SAAelgB,GAEpB,IADA,IAAImsB,EAAWnsB,EAAIwV,MAAM,IAChBqC,EAAM,EAAGA,EAAMsU,EAASpsB,OAAQ8X,IACvCsU,EAAStU,GAAO,IAAMsU,EAAStU,GAAO,IAExC,OAAO9N,IAAK,SAASoN,GACnB,OAAOnX,EAAIoF,QAAQ+R,IAAO,CAC5B,IAAGub,KAAKvG,EACV,CI3oCY,CAAgB,cAehBgN,EAIG,GADA,G,SHGAC,EAA2Blb,G,OAClCA,EAAO6S,GAAMqI,E,CGLN,CANA,IAAcC,GAAA,MADjB,GAAgB,GAAc,MAAMH,IAGhB,IAAuBtc,GAAU,MAAL,GAAkB,OAAL,O,OAS9D,GAAmB,GAAc,KAAO,GAAc,KADzDuc,E,iBAKejrB,G,OACf,SAAgFA,E,UAK7E,GADA,GAASorB,GADZ,IAAEC,GAAOC,GAAOC,GANNC,GAAc13B,KAAI+2B,GAAAA,IAAA,KAAAA,S,GAUpBO,GAAgB,GAAc,M,GAElC,O,kBAAO,QA6BR,GADH,IAACK,GAlBM,WAA+B,KAAhB,QADf,GAPWL,GAAgB,GAAc,MAC7BA,GAAgB,GAAc,MAEhC,GAAqBM,GAAM,YAqBrC,WAA6C,KAAd,GAAhB,SADf,GAbSN,GAAgB,GAAc,MAC7BA,GAAgB,GAAc,MAQxC,GAAAM,GADA,IAAoBhP,GAAAA,CAAA,YAJvB,GACK0O,GAAeI,IACfJ,GAAgB,GAAc,MAC9BA,GAAe,mB,OAYXA,GA/BT,UC1EZ,IAAIO,GAAI,CACJ57B,cAAgB,OAAOqD,EAAiB,CAAC5C,KAAKuC,EAAGvC,KAAKiN,GAAGtH,OAAO3F,KAAKke,GAAK,EAC1Eva,OAAO1E,GAAK,OAAQe,KAAKo7B,IAAIn8B,EAAI,EACjCuF,UAAUvF,GAAK,OAAOe,KAAKo7B,IAAIn8B,EAAI,EACnC,CAACiN,MACG,MAAMmvB,EAAQr7B,KACd,MAAO,CACHoM,SAAU1M,GAAK27B,EAAMnpB,IAAIxS,GACzB6M,YAAaC,GAAM6uB,EAAM9uB,YAAYC,GACrCC,cAAeH,GAAM+uB,EAAM5uB,cAAcH,GACzCD,QAASC,GAAM+uB,EAAMhvB,QAAQC,GAC7BI,MAAO,KAAOhB,OAAO2vB,KAAW,GAAG95B,SAAS,IAEpD,GAyBJ+5B,GAAS,IAuBTC,GAAO,YAAaC,GAAUD,GAAO,WAAYE,GAAaD,GAAU,iBAA0DE,GAAcH,GAAO,mBAAoBI,QAAY,EAAQC,GAAU,uCA2DzM,SAAS,GAAM38B,EAAG6tB,GACd,IAAI7f,EAAG7L,EAAGy6B,EACV,IAAKD,GAAQvwB,KAAKyhB,GACd,MAAMxsB,MAAMk7B,GAAU,UAqB1B,IAlBAv8B,EAAEsD,EAAmB,KAAfuqB,EAAEpM,OAAO,IAAaoM,EAAIA,EAAE/T,MAAM,IAAK,GAAK,GAE7C9L,EAAI6f,EAAEpmB,QAAQ,OAAS,IACxBomB,EAAIA,EAAEhiB,QAAQ,IAAK,MAElB1J,EAAI0rB,EAAElT,OAAO,OAAS,GAEnB3M,EAAI,IACJA,EAAI7L,GACR6L,IAAM6f,EAAE/T,MAAM3X,EAAI,GAClB0rB,EAAIA,EAAErd,UAAU,EAAGrO,IAEd6L,EAAI,IAETA,EAAI6f,EAAEzrB,QAEVw6B,EAAK/O,EAAEzrB,OAEFD,EAAI,EAAGA,EAAI6L,GAAK7L,EAAIy6B,GAAqB,KAAf/O,EAAEpM,OAAOtf,MAClCA,EAIN,GAAIA,GAAKy6B,EAEL58B,EAAEif,EAAI,CAACjf,EAAEgO,EAAI,QAMb,IAHAhO,EAAEgO,EAAIA,EAAI7L,EAAI,EACdnC,EAAEif,EAAI,GAEDjR,EAAI,EAAG7L,EAAIy6B,GACZ58B,EAAEif,EAAEjR,MAAQ6f,EAAEpM,OAAOtf,KAQ7B,OADI,GAAMnC,EAAG68B,GAAIC,GAAK,EAAGD,GAAIE,GAEjC,CASA,SAAS,GAAM/8B,EAAGuN,EAAIyvB,EAAIC,GACtB,IAAIC,EAAKl9B,EAAEif,EAGX,GAFI+d,IAAON,KACPM,EAAKH,GAAIE,IACF,IAAPC,GAAmB,IAAPA,GAAmB,IAAPA,GAAmB,IAAPA,EACpC,MAAM37B,MAxHyFk7B,kCA0HnG,GAAIhvB,EAAK,EACL0vB,EACW,IAAPD,IAAaC,KAAUC,EAAG,KAAc,IAAP3vB,IAAoB,IAAPyvB,GAAYE,EAAG,IAAM,GACxD,IAAPF,IAAaE,EAAG,GAAK,GAAe,IAAVA,EAAG,KAAaD,GAAQC,EAAG,KAAOR,MACpEQ,EAAG96B,OAAS,EACR66B,GAEAj9B,EAAEgO,EAAIhO,EAAEgO,EAAIT,EAAK,EACjB2vB,EAAG,GAAK,GAIRA,EAAG,GAAKl9B,EAAEgO,EAAI,OAGjB,GAAIT,EAAK2vB,EAAG96B,OAAQ,CAErB,MAAM+O,EAAS+rB,EAAGrW,WAAU,CAACsW,EAAKjjB,IAAQA,GAAO3M,GAAM4vB,EAAM,IAAK,EASlE,GARAF,EACW,IAAPD,GAAYE,EAAG3vB,IAAO,GACX,IAAPyvB,IAAaE,EAAG3vB,GAAM,GAAgB,IAAX2vB,EAAG3vB,KACzB0vB,GAAQC,EAAG3vB,EAAK,KAAOmvB,IAA0B,EAAbQ,EAAG3vB,EAAK,MAC1C,IAAPyvB,IAAaC,IAAS9rB,GAE9B+rB,EAAG96B,OAASmL,IAER0vB,EAEA,OAASC,EAAG3vB,GAAM,GACd2vB,EAAG3vB,GAAM,EACJA,QACCvN,EAAEgO,EACJkvB,EAAGE,QAAQ,IAKvB,IAAK7vB,EAAK2vB,EAAG96B,QAAS86B,IAAK3vB,IACvB2vB,EAAG/K,KACX,CACA,OAAOnyB,CACX,CAKA,SAASq9B,GAAUr9B,EAAGs9B,EAAeC,GACjC,IAAIvvB,EAAIhO,EAAEgO,EAAG1K,EAAItD,EAAEif,EAAEhY,KAAK,IAAK4mB,EAAIvqB,EAAElB,OAErC,GAAIk7B,EACAh6B,EAAIA,EAAEme,OAAO,IAAMoM,EAAI,EAAI,IAAMvqB,EAAEwW,MAAM,GAAK,KAAO9L,EAAI,EAAI,IAAM,MAAQA,OAG1E,GAAIA,EAAI,EAAG,CACZ,OAASA,GACL1K,EAAI,IAAMA,EACdA,EAAI,KAAOA,CACf,MACK,GAAI0K,EAAI,EACT,KAAMA,EAAI6f,EACN,IAAK7f,GAAK6f,EAAG7f,KACT1K,GAAK,SAEJ0K,EAAI6f,IACTvqB,EAAIA,EAAEwW,MAAM,EAAG9L,GAAK,IAAM1K,EAAEwW,MAAM9L,SAGjC6f,EAAI,IACTvqB,EAAIA,EAAEme,OAAO,GAAK,IAAMne,EAAEwW,MAAM,IAEpC,OAAO9Z,EAAEsD,EAAI,GAAKi6B,EAAY,IAAMj6B,EAAIA,CAC5C,CAKA44B,GAAEnnB,IAAM,WACJ,IAAI/U,EAAI,IAAIe,KAAKH,YAAYG,MAE7B,OADAf,EAAEsD,EAAI,EACCtD,CACX,EAMAk8B,GAAEC,IAAM,SAAU17B,GACd,IAAI+8B,EAAOX,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAuBm8B,GAAhBz8B,EAAI,IAAIo8B,EAAIp8B,GAAST,EAAEif,GAAGwe,EAAKh9B,EAAEwe,EAAG9c,EAAInC,EAAEsD,EAAG+B,EAAI5E,EAAE6C,EAAG0D,EAAIhH,EAAEgO,EAAGkZ,EAAIzmB,EAAEuN,EAE3H,IAAKkvB,EAAG,KAAOO,EAAG,GACd,OAAQP,EAAG,GAAuB/6B,EAAjBs7B,EAAG,IAAUp4B,EAAL,EAE7B,GAAIlD,GAAKkD,EACL,OAAOlD,EAGX,GAFAq7B,EAAQr7B,EAAI,EAER6E,GAAKkgB,EACL,OAAOlgB,EAAIkgB,EAAIsW,EAAQ,GAAK,EAGhC,IADAn4B,EAAI8K,KAAKxK,IAAIu3B,EAAG96B,OAAQq7B,EAAGr7B,QACtBD,EAAI,EAAGA,EAAIkD,EAAGlD,IAGf,IAFA6E,EAAI7E,EAAI+6B,EAAG96B,OAAS86B,EAAG/6B,GAAK,KAC5B+kB,EAAI/kB,EAAIs7B,EAAGr7B,OAASq7B,EAAGt7B,GAAK,GAExB,OAAO6E,EAAIkgB,EAAIsW,EAAQ,GAAK,EAEpC,OAAO,CASX,EAKAtB,GAAE5qB,IAAM,SAAU7Q,GACd,IAAIo8B,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAuBitB,GAAhBvtB,EAAI,IAAIo8B,EAAIp8B,GAAQT,EAAEif,GACrEye,EAAIj9B,EAAEwe,EACNjY,EAAIhH,EAAEsD,GAAK7C,EAAE6C,EAAI,GAAK,EAAG+J,EAAKwvB,EAAIC,GAClC,GAAIzvB,MAASA,GAAMA,EAAK,GAAKA,EAAKgvB,GAC9B,MAAMh7B,MAAMm7B,IAGhB,IAAKkB,EAAE,GACH,MAAMr8B,MAAMo7B,IAGhB,IAAKzO,EAAE,GAGH,OAFAvtB,EAAE6C,EAAI0D,EACNvG,EAAEwe,EAAI,CAACxe,EAAEuN,EAAI,GACNvN,EAEX,IAAIk9B,EAAIC,EAAI/P,EAAGsO,EAAK0B,EAAIC,EAAKJ,EAAE5jB,QAASikB,EAAKJ,EAAKD,EAAEt7B,OAAQ47B,EAAKhQ,EAAE5rB,OAAQswB,EAAI1E,EAAElU,MAAM,EAAG6jB,GAC1FM,EAAKvL,EAAEtwB,OAAQ87B,EAAIz9B,EACnB09B,EAAKD,EAAEjf,EAAI,GAAImf,EAAK,EAAG7tB,EAAIlD,GAAM6wB,EAAElwB,EAAIhO,EAAEgO,EAAIvN,EAAEuN,GAAK,EAMpD,IALAkwB,EAAE56B,EAAI0D,EACNA,EAAIuJ,EAAI,EAAI,EAAIA,EAEhButB,EAAGV,QAAQ,GAEJa,IAAON,GACVjL,EAAE9Z,KAAK,GACX,EAAG,CAEC,IAAKiV,EAAI,EAAGA,EAAI,GAAIA,IAAK,CAErB,GAAI8P,IAAOM,EAAKvL,EAAEtwB,QACd+5B,EAAMwB,EAAKM,EAAK,GAAK,OAGrB,IAAKJ,GAAM,EAAG1B,EAAM,IAAK0B,EAAKF,GAC1B,GAAID,EAAEG,IAAOnL,EAAEmL,GAAK,CAChB1B,EAAMuB,EAAEG,GAAMnL,EAAEmL,GAAM,GAAK,EAC3B,KACJ,CAIR,KAAI1B,EAAM,GAiBN,MAdA,IAAKyB,EAAKK,GAAMN,EAAKD,EAAII,EAAIG,GAAK,CAC9B,GAAIvL,IAAIuL,GAAML,EAAGK,GAAK,CAElB,IADAJ,EAAKI,EACEJ,IAAOnL,IAAImL,IACdnL,EAAEmL,GAAM,IACVnL,EAAEmL,GACJnL,EAAEuL,IAAO,EACb,CACAvL,EAAEuL,IAAOL,EAAGK,EAChB,CACA,MAAQvL,EAAE,IACNA,EAAE1Y,OAKd,CAEAmkB,EAAGC,KAAQjC,EAAMtO,IAAMA,EAEnB6E,EAAE,IAAMyJ,EACRzJ,EAAEuL,GAAMjQ,EAAE+P,IAAO,EAEjBrL,EAAI,CAAC1E,EAAE+P,GACf,QAAUA,IAAOC,GAAMtL,EAAE,KAAOgK,KAAc11B,KAW9C,OATKm3B,EAAG,IAAY,GAANC,IAEVD,EAAGnkB,QACHkkB,EAAElwB,IACFuC,KAGA6tB,EAAK7tB,GACL,GAAM2tB,EAAG3tB,EAAGssB,EAAIE,GAAIrK,EAAE,KAAOgK,IAC1BwB,CACX,EAIAhC,GAAEz3B,GAAK,SAAUhE,GACb,OAAuB,IAAhBM,KAAKo7B,IAAI17B,EACpB,EAKAy7B,GAAEmC,GAAK,SAAU59B,GACb,OAAOM,KAAKo7B,IAAI17B,GAAK,CACzB,EAKAy7B,GAAEoC,IAAM,SAAU79B,GACd,OAAOM,KAAKo7B,IAAI17B,IAAM,CAC1B,EAIAy7B,GAAEqC,GAAK,SAAU99B,GACb,OAAOM,KAAKo7B,IAAI17B,GAAK,CACzB,EAKAy7B,GAAEsC,IAAM,SAAU/9B,GACd,OAAOM,KAAKo7B,IAAI17B,GAAK,CACzB,EAIAy7B,GAAEuC,MAAQvC,GAAEwC,IAAM,SAAUj+B,GACxB,IAAI0B,EAAGkD,EAAG8D,EAAGw1B,EAAM9B,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAuBitB,GAAhBvtB,EAAI,IAAIo8B,EAAIp8B,GAAQT,EAAEsD,GAAGo6B,EAAIj9B,EAAE6C,EAE7F,GAAI0qB,GAAK0P,EAEL,OADAj9B,EAAE6C,GAAKo6B,EACA19B,EAAE4+B,KAAKn+B,GAElB,IAAIy8B,EAAKl9B,EAAEif,EAAEnF,QAAS+kB,EAAK7+B,EAAEgO,EAAGyvB,EAAKh9B,EAAEwe,EAAG6f,EAAKr+B,EAAEuN,EAEjD,IAAKkvB,EAAG,KAAOO,EAAG,GAUd,OATIA,EAAG,GACHh9B,EAAE6C,GAAKo6B,EAEFR,EAAG,GACRz8B,EAAI,IAAIo8B,EAAI78B,GAGZS,EAAE6C,EAAI,EAEH7C,EAGX,GAAIutB,EAAI6Q,EAAKC,EAAI,CAUb,KATIH,EAAO3Q,EAAI,IACXA,GAAKA,EACL7kB,EAAI+zB,IAGJ4B,EAAKD,EACL11B,EAAIs0B,GAERt0B,EAAE41B,UACGrB,EAAI1P,EAAG0P,KACRv0B,EAAEyP,KAAK,GACXzP,EAAE41B,SACN,MAII,IADA15B,IAAMs5B,EAAOzB,EAAG96B,OAASq7B,EAAGr7B,QAAU86B,EAAKO,GAAIr7B,OAC1C4rB,EAAI0P,EAAI,EAAGA,EAAIr4B,EAAGq4B,IACnB,GAAIR,EAAGQ,IAAMD,EAAGC,GAAI,CAChBiB,EAAOzB,EAAGQ,GAAKD,EAAGC,GAClB,KACJ,CAcR,GAVIiB,IACAx1B,EAAI+zB,EACJA,EAAKO,EACLA,EAAKt0B,EACL1I,EAAE6C,GAAK7C,EAAE6C,IAMRo6B,GAAKr4B,EAAIo4B,EAAGr7B,SAAWD,EAAI+6B,EAAG96B,SAAW,EAC1C,KAAOs7B,KACHR,EAAG/6B,KAAO,EAElB,IAAKu7B,EAAIv7B,EAAGkD,EAAI2oB,GAAI,CAChB,GAAIkP,IAAK73B,GAAKo4B,EAAGp4B,GAAI,CACjB,IAAKlD,EAAIkD,EAAGlD,IAAM+6B,IAAK/6B,IACnB+6B,EAAG/6B,GAAK,IACV+6B,EAAG/6B,GACL+6B,EAAG73B,IAAM,EACb,CACA63B,EAAG73B,IAAMo4B,EAAGp4B,EAChB,CAEA,KAAmB,IAAZ63B,IAAKQ,IACRR,EAAG/K,MAEP,KAAiB,IAAV+K,EAAG,IACNA,EAAGljB,UACD8kB,EAUN,OARK5B,EAAG,KAEJz8B,EAAE6C,EAAI,EAEN45B,EAAK,CAAC4B,EAAK,IAEfr+B,EAAEwe,EAAIie,EACNz8B,EAAEuN,EAAI8wB,EACCr+B,CACX,EAIAy7B,GAAE8C,IAAM,SAAUv+B,GACd,IAAIw+B,EAAMpC,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAuBitB,GAAhBvtB,EAAI,IAAIo8B,EAAIp8B,GAAQT,EAAEsD,GAAGo6B,EAAIj9B,EAAE6C,EACpF,IAAK7C,EAAEwe,EAAE,GACL,MAAM5d,MAAMo7B,IAMhB,OAJAz8B,EAAEsD,EAAI7C,EAAE6C,EAAI,EACZ27B,EAAmB,GAAZx+B,EAAE07B,IAAIn8B,GACbA,EAAEsD,EAAI0qB,EACNvtB,EAAE6C,EAAIo6B,EACFuB,EACO,IAAIpC,EAAI78B,IACnBguB,EAAI6O,EAAIC,GACRY,EAAIb,EAAIE,GACRF,EAAIC,GAAKD,EAAIE,GAAK,EAClB/8B,EAAIA,EAAEsR,IAAI7Q,GACVo8B,EAAIC,GAAK9O,EACT6O,EAAIE,GAAKW,EACF38B,KAAK09B,MAAMz+B,EAAE8tB,MAAMrtB,IAC9B,EAIAy7B,GAAE0C,KAAO1C,GAAEvrB,IAAM,SAAUlQ,GACvB,IAAIuN,EAAGhH,EAAGmC,EAAG0zB,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAEjD,GAFwDN,EAAI,IAAIo8B,EAAIp8B,GAEhET,EAAEsD,GAAK7C,EAAE6C,EAET,OADA7C,EAAE6C,GAAK7C,EAAE6C,EACFtD,EAAEy+B,MAAMh+B,GAEnB,IAAIo+B,EAAK7+B,EAAEgO,EAAGkvB,EAAKl9B,EAAEif,EAAG6f,EAAKr+B,EAAEuN,EAAGyvB,EAAKh9B,EAAEwe,EAEzC,IAAKie,EAAG,KAAOO,EAAG,GASd,OARKA,EAAG,KACAP,EAAG,GACHz8B,EAAI,IAAIo8B,EAAI78B,GAGZS,EAAE6C,EAAItD,EAAEsD,GAGT7C,EAKX,GAHAy8B,EAAKA,EAAGpjB,QAGJ9L,EAAI6wB,EAAKC,EAAI,CAUb,IATI9wB,EAAI,GACJ8wB,EAAKD,EACL11B,EAAIs0B,IAGJzvB,GAAKA,EACL7E,EAAI+zB,GAER/zB,EAAE41B,UACK/wB,KACH7E,EAAEyP,KAAK,GACXzP,EAAE41B,SACN,CASA,IAPI7B,EAAG96B,OAASq7B,EAAGr7B,OAAS,IACxB+G,EAAIs0B,EACJA,EAAKP,EACLA,EAAK/zB,GAET6E,EAAIyvB,EAAGr7B,OAEF4E,EAAI,EAAGgH,EAAGkvB,EAAGlvB,IAAM,GACpBhH,GAAKk2B,IAAKlvB,GAAKkvB,EAAGlvB,GAAKyvB,EAAGzvB,GAAKhH,GAAK,GAAK,EAO7C,IALIA,IACAk2B,EAAGE,QAAQp2B,KACT83B,GAGD9wB,EAAIkvB,EAAG96B,OAAoB,IAAZ86B,IAAKlvB,IACrBkvB,EAAG/K,MAGP,OAFA1xB,EAAEwe,EAAIie,EACNz8B,EAAEuN,EAAI8wB,EACCr+B,CACX,EAQAy7B,GAAE9rB,IAAM,SAAUyd,GACd,IAAIgP,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAON,EAAI,IAAIo8B,EAAI,KAAMqC,EAAM,IAAIrC,EAAI,KAAMW,EAAQ3P,EAAI,EACjG,GAAIA,MAAQA,GAAKA,GAAI,KAAcA,EAnjB3B,IAojBJ,MAAMxsB,MAAMk7B,GAAU,YAI1B,IAFIiB,IACA3P,GAAKA,GAEG,EAAJA,IACAptB,EAAIA,EAAEqtB,MAAM9tB,IAChB6tB,IAAM,GAGN7tB,EAAIA,EAAE8tB,MAAM9tB,GAEhB,OAAOw9B,EAAQ0B,EAAI5tB,IAAI7Q,GAAKA,CAChC,EAQAy7B,GAAEiD,KAAO,SAAU5xB,EAAIyvB,GACnB,GAAIzvB,MAASA,GAAMA,EAAK,GAAKA,EAAK8uB,GAC9B,MAAMh7B,MAAMk7B,GAAU,aAE1B,OAAO,GAAM,IAAIx7B,KAAKH,YAAYG,MAAOwM,EAAIyvB,EACjD,EAUAd,GAAEkD,MAAQ,SAAU/xB,EAAI2vB,GACpB,GAAI3vB,IAAOqvB,GACPrvB,EAAK,OACJ,GAAIA,MAASA,GAAMA,GAAMgvB,IAAUhvB,EAAKgvB,GACzC,MAAMh7B,MAAMm7B,IAEhB,OAAO,GAAM,IAAIz7B,KAAKH,YAAYG,MAAOsM,EAAKtM,KAAKiN,EAAI,EAAGgvB,EAC9D,EAKAd,GAAEmD,KAAO,WACL,IAAI3M,EAAGzT,EAAG9V,EAAG0zB,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAOuC,EAAItD,EAAEsD,EAAG0K,EAAIhO,EAAEgO,EAAGiH,EAAO,IAAI4nB,EAAI,OAEzF,IAAK78B,EAAEif,EAAE,GACL,OAAO,IAAI4d,EAAI78B,GAEnB,GAAIsD,EAAI,EACJ,MAAMjC,MAAMi7B,GAAO,kBAMb,KAHVh5B,EAAI6M,KAAKkvB,KAAKr/B,EAAI,MAGHsD,IAAM,MACjB2b,EAAIjf,EAAEif,EAAEhY,KAAK,KACL7E,OAAS4L,EAAI,IACjBiR,GAAK,KAETjR,IAAMA,EAAI,GAAK,EAAI,IAAMA,EAAI,GAAS,EAAJA,GAClC0kB,EAAI,IAAImK,IAFRv5B,EAAI6M,KAAKkvB,KAAKpgB,KAEI,IAAQ,MAAQ3b,EAAIA,EAAEkK,iBAAiBsM,MAAM,EAAGxW,EAAEmE,QAAQ,KAAO,IAAMuG,IAGzF0kB,EAAI,IAAImK,EAAIv5B,EAAI,IAEpB0K,EAAI0kB,EAAE1kB,GAAK6uB,EAAIC,IAAM,GAErB,GACI3zB,EAAIupB,EACJA,EAAIzd,EAAK6Y,MAAM3kB,EAAEy1B,KAAK5+B,EAAEsR,IAAInI,WACvBA,EAAE8V,EAAEnF,MAAM,EAAG9L,GAAG/G,KAAK,MAAQyrB,EAAEzT,EAAEnF,MAAM,EAAG9L,GAAG/G,KAAK,KAC3D,OAAO,GAAMyrB,GAAImK,EAAIC,IAAM,GAAKpK,EAAE1kB,EAAI,EAAG6uB,EAAIE,GACjD,EAIAb,GAAEpO,MAAQoO,GAAEjpB,IAAM,SAAUxS,GACxB,IAAIwe,EAAG4d,EAAM97B,KAAKH,YAAaZ,EAAI,IAAI68B,EAAI97B,MAAuBm8B,GAAhBz8B,EAAI,IAAIo8B,EAAIp8B,GAAST,EAAEif,GAAGwe,EAAKh9B,EAAEwe,EAAG+O,EAAIkP,EAAG96B,OAAQs7B,EAAID,EAAGr7B,OAAQD,EAAInC,EAAEgO,EAAG3I,EAAI5E,EAAEuN,EAInI,GAFAvN,EAAE6C,EAAItD,EAAEsD,GAAK7C,EAAE6C,EAAI,GAAK,GAEnB45B,EAAG,KAAOO,EAAG,GAEd,OADAh9B,EAAEwe,EAAI,CAACxe,EAAEuN,EAAI,GACNvN,EAcX,IAXAA,EAAEuN,EAAI7L,EAAIkD,EAEN2oB,EAAI0P,IACJze,EAAIie,EACJA,EAAKO,EACLA,EAAKxe,EACL5Z,EAAI2oB,EACJA,EAAI0P,EACJA,EAAIr4B,GAGH4Z,EAAI,IAAIhf,MAAMoF,EAAI2oB,EAAI0P,GAAIr4B,KAC3B4Z,EAAE5Z,GAAK,EAGX,IAAKlD,EAAIu7B,EAAGv7B,KAAM,CAGd,IAFAu7B,EAAI,EAECr4B,EAAI2oB,EAAI7rB,EAAGkD,EAAIlD,GAEhBu7B,EAAIze,EAAE5Z,GAAKo4B,EAAGt7B,GAAK+6B,EAAG73B,EAAIlD,EAAI,GAAKu7B,EACnCze,EAAE5Z,KAAOq4B,EAAI,GAEbA,EAAIA,EAAI,GAAK,EAEjBze,EAAE5Z,GAAKq4B,CACX,CAOA,IALIA,IACEj9B,EAAEuN,EAEJiR,EAAEjF,QAED7X,EAAI8c,EAAE7c,QAAS6c,IAAI9c,IACpB8c,EAAEkT,MAEN,OADA1xB,EAAEwe,EAAIA,EACCxe,CACX,EAQAy7B,GAAE1uB,cAAgB,SAAUH,EAAI2vB,GAC5B,IAAIh9B,EAAIe,KAAM8sB,EAAI7tB,EAAEif,EAAE,GACtB,GAAI5R,IAAOqvB,GAAW,CAClB,GAAIrvB,MAASA,GAAMA,EAAK,GAAKA,EAAKgvB,GAC9B,MAAMh7B,MAAMm7B,IAGhB,IADAx8B,EAAI,GAAM,IAAIA,EAAEY,YAAYZ,KAAMqN,EAAI2vB,GAC/Bh9B,EAAEif,EAAE7c,OAASiL,GAChBrN,EAAEif,EAAErG,KAAK,EACjB,CACA,OAAOykB,GAAUr9B,GAAG,IAAQ6tB,EAChC,EAWAqO,GAAE9uB,QAAU,SAAUC,EAAI2vB,GACtB,IAAIh9B,EAAIe,KAAM8sB,EAAI7tB,EAAEif,EAAE,GACtB,GAAI5R,IAAOqvB,GAAW,CAClB,GAAIrvB,MAASA,GAAMA,EAAK,GAAKA,EAAKgvB,GAC9B,MAAMh7B,MAAMm7B,IAIhB,IAAKnvB,EAAKA,GAFVrN,EAAI,GAAM,IAAIA,EAAEY,YAAYZ,GAAIqN,EAAKrN,EAAEgO,EAAI,EAAGgvB,IAE7BhvB,EAAI,EAAGhO,EAAEif,EAAE7c,OAASiL,GACjCrN,EAAEif,EAAErG,KAAK,EACjB,CACA,OAAOykB,GAAUr9B,GAAG,IAAS6tB,EACjC,EAOAqO,GAAE50B,OAAS40B,GAAE55B,SAAW,WACpB,IAAItC,EAAIe,KAAM87B,EAAM78B,EAAEY,YACtB,OAAOy8B,GAAUr9B,EAAGA,EAAEgO,GAAK6uB,EAAIyC,IAAMt/B,EAAEgO,GAAK6uB,EAAI0C,KAAMv/B,EAAEif,EAAE,GAC9D,EAIAid,GAAEhrB,SAAW,WACT,IAAI2c,EAAIphB,OAAO4wB,GAAUt8B,MAAM,GAAM,IACrC,IAAgC,IAA5BA,KAAKH,YAAY4+B,SAAoBz+B,KAAK0D,GAAGopB,EAAEvrB,YAC/C,MAAMjB,MAAMi7B,GAAO,wBAEvB,OAAOzO,CACX,EAUAqO,GAAE5uB,YAAc,SAAUC,EAAIyvB,GAC1B,IAAIh9B,EAAIe,KAAM87B,EAAM78B,EAAEY,YAAaitB,EAAI7tB,EAAEif,EAAE,GAC3C,GAAI1R,IAAOmvB,GAAW,CAClB,GAAInvB,MAASA,GAAMA,EAAK,GAAKA,EAAK8uB,GAC9B,MAAMh7B,MAAMk7B,GAAU,aAG1B,IADAv8B,EAAI,GAAM,IAAI68B,EAAI78B,GAAIuN,EAAIyvB,GACnBh9B,EAAEif,EAAE7c,OAASmL,GAChBvN,EAAEif,EAAErG,KAAK,EACjB,CACA,OAAOykB,GAAUr9B,EAAGuN,GAAMvN,EAAEgO,GAAKhO,EAAEgO,GAAK6uB,EAAIyC,IAAMt/B,EAAEgO,GAAK6uB,EAAI0C,KAAM1R,EACvE,EAOAqO,GAAEuD,QAAU,WACR,IAAIz/B,EAAIe,KAAM87B,EAAM78B,EAAEY,YACtB,IAAmB,IAAfi8B,EAAI2C,OACJ,MAAMn+B,MAAMi7B,GAAO,sBAEvB,OAAOe,GAAUr9B,EAAGA,EAAEgO,GAAK6uB,EAAIyC,IAAMt/B,EAAEgO,GAAK6uB,EAAI0C,IAAI,EACxD,EAEO,IAAI1C,GA/vBX,SAAS6C,IAOL,SAAS7C,EAAIhP,GACT,IAAI7tB,EAAIe,KAER,KAAMf,aAAa68B,GACf,OAAOhP,IAAM6O,GAAYgD,IAAU,IAAI7C,EAAIhP,GAE/C,GAAIA,aAAagP,EACb78B,EAAEsD,EAAIuqB,EAAEvqB,EACRtD,EAAEgO,EAAI6f,EAAE7f,EACRhO,EAAEif,EAAI4O,EAAE5O,EAAEnF,QAyBtB,SAAmB9Z,GAEf,GAAIA,EAAEif,EAAE7c,OAAS,IAAMpC,EAAEif,EAAE,GAAI,CAC3B,IAAI9c,EAAInC,EAAEif,EAAE4H,WAAU7mB,GAAKA,IAC3BA,EAAEif,EAAIjf,EAAEif,EAAEnF,MAAM3X,GAChBnC,EAAEgO,EAAIhO,EAAEgO,EAAI7L,CAChB,CACJ,CA/BYw9B,CAAU3/B,OAET,CACD,GAAiB,iBAAN6tB,EAAgB,CACvB,IAAmB,IAAfgP,EAAI2C,OACJ,MAAMI,UAAUrD,GAAU,UAG9B1O,EAAU,IAANA,GAAW,EAAIA,EAAI,EAAI,KAAO1mB,OAAO0mB,EAC7C,CACA,GAAM7tB,EAAG6tB,EACb,CAGA7tB,EAAEY,YAAci8B,CACpB,CAOA,OANAA,EAAIjzB,UAAYsyB,GAChBW,EAAIC,GAxEC,GAyELD,EAAIE,GAhEH,EAiEDF,EAAIyC,IAvDH,GAwDDzC,EAAI0C,GAlDH,GAmDD1C,EAAI2C,QA7CC,EA8CE3C,CACX,CAutBiB6C,GAEjB,YCr0BA,MA2DO,SAAS,GAAS1/B,GACrB,OAAOA,EAAEsC,UACb,CA5DwB,IAAI,GAAQ,GACb,IAAI,GAAQ,GACP,IAAI,IAAS,GACb,IAAI,GAAQ,iCACZ,IAAI,GAAQ,kCCCjC,MAAMu9B,WAAe,EACxBj/B,YAAYk/B,EAAO/zB,GACfsS,QACAtd,KAAK++B,MAAiB,EAARA,EACd/+B,KAAKgL,OAASA,CAClB,EAOG,SAASg0B,GAAuBC,EAAOC,GAE1C,OAAa,CACT,MAAMjgC,EAAIggC,EAAOnS,EAAIoS,EACrB,GAAU,IAANpS,EACA,OAAO,EAEN,GAAKA,EAAI,GAAO,EAMjB,OAAQ7tB,EAAI+/B,GAAuB//B,EAAIA,KAAO6tB,EAAI,IAAQ,EAL1DmS,EAAShgC,EAAIA,EACbigC,KAAapS,EAAI,EAOzB,CACJ,CAoLO,SAASqS,GAAmBrS,GAC/B,OAAOA,EAAEiS,KACb,CAMO,SAASK,GAAmBtS,EAAG1rB,GAClC,OAAO0rB,EAAE9hB,OAAO5J,EACpB,CAEO,SAASi+B,GAAqBvS,EAAG1rB,GACpC,OAAO,GAAYg+B,GAAmBtS,EAAG1rB,IAAI,EAAO,EACxD,CAEO,SAASk+B,GAAsBxS,EAAG1rB,EAAGmC,GACxCupB,EAAE9hB,OAAO5J,GAAU,EAAJmC,CACnB,CAEO,SAASg8B,GAAmBN,EAAOC,GAEtC,OAAa,CACT,MAAMjgC,EAAIggC,EAAOnS,EAAIoS,EACrB,GAAU,IAANpS,EACA,OAAO,GAAS,EAAG,GAAG,GAErB,GAAKA,EAAI,GAAO,EAMjB,OAAO,GAAY7tB,EAAGsgC,GAAmB,GAAYtgC,EAAGA,MAAQ6tB,EAAI,KALpEmS,EAAQ,GAAYhgC,EAAGA,GACvBigC,KAAapS,EAAI,EAOzB,CACJ,CAEO,SAAS0S,GAAmBP,EAAOC,GAEtC,OAAa,CACT,MAAMjgC,EAAIggC,EAAOnS,EAAIoS,EACrB,GAAU,IAANpS,EACA,OAAO,EAEN,GAAKA,EAAI,GAAO,EAMjB,OAAQ7tB,EAAIugC,GAAmBvgC,EAAIA,KAAO6tB,EAAI,IAAQ,EALtDmS,EAAShgC,EAAIA,EACbigC,KAAapS,EAAI,EAOzB,CACJ,CAtNkC,GAAS,WAAY,GAAG,GAkBnB,GAAS,WAAY,GAAG,GAmGjB,GAAW2S,IAAmCr+B,GAAM49B,GAAuB,EAAG59B,IAAIs+B,YA6HzH,MAAMC,GAAwB,GAExBC,GAAqB,SAIrBC,GAAwB,GAAS,SAAU,GAAG,GAE9CC,GAA2B,GAAS,SAAU,GAAG,GAoBvD,SAASC,GAAqB9gC,GACjC,SAAYA,IAAM,IAAO0gC,GAC7B,CAEO,SAASK,GAAqB/gC,GACjC,OA7BiC,SA6B1BA,CACX,CAEO,SAASghC,GAAqBtD,GACjC,OAAO,IAAImC,GAAOnC,EAAG,IAAI+C,WAAW/C,GACxC,CAMO,SAASuD,GAAmBpT,GAC/B,MAeMiS,EAAgD,EAf/B,EAACoB,EAAQpiB,KAE5B,OAAa,CACT,MAAMqiB,EAAKD,EAAQ/+B,EAAI2c,EACvB,IAAY,IAAP3c,GAA8B,IAAVg/B,EAAGh/B,GACxB,OAAQA,EAAI,EAAK,EAGjB++B,EAASC,EACTriB,EAAS3c,EAAI,CAIrB,GAEUi/B,CAAevT,EAAE9hB,OAAQ8hB,EAAEiS,MAAQ,GAEjD,OADAjS,EAAEiS,MAAiB,EAARA,EACJjS,CACX,CAQO,SAASwT,GAAmBrhC,GAC/B,MAAM4jB,EAA0B,GAAlB5jB,EAAI,EAAK,EAAIA,GAC3B,GAAI4jB,EAAM+c,GAAoB,CAC1B,MAAMjO,EAAIsO,GAAqB,GAE/B,OADAtO,EAAE3mB,OAAO,GAAY,EAAN6X,EACRqd,GAAmBvO,EAC9B,CACK,CACD,MAAM4O,EAAMN,GAdiB,GAe7B,IAAK,IAAI7+B,EAAI,EAAGA,GAAK,EAA6BA,IAC9Cm/B,EAAIv1B,OAAO5J,MAAYyhB,EAAM2c,GAAmBI,GAAoBx+B,IAAQw+B,GAAsB,EAEtG,OAAOM,GAAmBK,EAC9B,CACJ,CAWO,SAASC,GAAoB1T,GAChC,GAAgB,IAAZA,EAAEiS,MACF,OAAqB,EAAdjS,EAAE9hB,OAAO,GAEf,CACD,IAAI4T,EAAM,EACV,IAAK,IAAIxd,EAAI0rB,EAAEiS,MAAQ,EAAG39B,GAAK,EAAGA,IAC9Bwd,EAAQkO,EAAE9hB,OAAO5J,GAAMw+B,GAAqBhhB,EAAQ,EAExD,OAAa,EAANA,CACX,CACJ,CAjGsC,GAAS,SAAU,GAAG,GAgHrD,MAAM6hB,GAAmBH,GAAmB,GAEtCI,GAAoBJ,GAAmB,GA2B7C,SAASK,GAAoB7T,GAChC,OAAOA,EAAEiS,MAAQ,CACrB,CAsBO,SAAS,GAAiBvvB,EAAG2tB,GAChC,MAAMyD,EAAU,GAlMgB3T,EAkMQzd,EAAEuvB,MAlMPpC,EAkMcQ,EAAE4B,MAjM/C9R,EAAI0P,EACO,EAAJA,EAGI,EAAJ1P,GA6LkD,EACvD0E,EAAIsO,GAAqBW,GAnM5B,IAA6B3T,EAAG0P,EAqMnC,OAxBG,SAA2B5e,EAAOmhB,EAAO2B,EAAOC,EAAOC,EAAOC,GACjE,IAAIC,EAAGC,EAAKC,EAAKC,EAEjB,OAAa,CACT,MAAMhgC,EAAI2c,EAAO+O,EAAIoS,EAAOhhB,EAAI2iB,EAAOrxB,EAAIsxB,EAAO3D,EAAI4D,EAAOpP,EAAIqP,EACjE,KAAI5/B,EAAI0rB,GAWR,MAXA,CACI,MAAM7tB,EAAsJ,GAA9IgiC,EAAIzxB,EAAI0xB,EAAW,EAAJ9/B,GAAS8/B,EAAMD,EAAElC,MAASkC,EAAEj2B,OAAOk2B,GAAO,IAASC,EAAMhE,EAAIiE,EAAW,EAAJhgC,EAASggC,EAAMD,EAAIpC,MAASoC,EAAIn2B,OAAOo2B,GAAO,GAAQljB,GACvJyT,EAAE3mB,OAAO5J,GAAgC,EAA1B4+B,GAAqB/gC,GACpC8e,EAAS3c,EAAI,EACb89B,EAAQpS,EACR+T,EAAQd,GAAqB9gC,GAC7B6hC,EAAQtxB,EACRuxB,EAAQ5D,EACR6D,EAAQrP,CAEZ,CAEJ,CACJ,CAKI0P,CAAkB,EAAGT,EAAQ,EAAGpxB,EAAG2tB,EAAGxL,GAC/BuO,GAAmBvO,EAC9B,CAiDO,SAAS,GAAoBniB,GAChC,OAAmB,IAAZA,EAAEuvB,KACb,CAmHO,SAASuC,GAAgB9xB,EAAG2tB,GAC/B,OAAuC,IAnCpC,SAA8B3tB,EAAG2tB,GACpC,OAAI3tB,EAAEuvB,MAAQ5B,EAAE4B,OACJ,EAEHvvB,EAAEuvB,MAAQ5B,EAAE4B,MACV,EAyByC,EAtBlC,EAACwC,EAAQC,EAAQzjB,KAE3B,OAAa,CACT,MAAM0jB,EAAKF,EAAQG,EAAKF,EAAQpgC,EAAI2c,EACpC,IAAW,IAAP3c,EACA,OAAO,EAEN,GAAIqgC,EAAGrgC,KAAOsgC,EAAGtgC,GAMjB,OAAIqgC,EAAGrgC,GAAKsgC,EAAGtgC,IACR,EAGD,EATPmgC,EAASE,EACTD,EAASE,EACT3jB,EAAS3c,EAAI,CAUrB,GAEGugC,CAAMnyB,EAAExE,OAAQmyB,EAAEnyB,OAAQwE,EAAEuvB,MAAQ,EAEnD,CAGW6C,CAAqBpyB,EAAG2tB,EACnC,CAmEO,SAAS0E,GAAgCb,EAAOH,EAAO5J,GAE1D,OAAa,CACT,MAAMtF,EAAIqP,EAAO9iB,EAAI2iB,EAAO56B,EAAIgxB,EAChC,KAAI,GAAQ/Y,EAAG,GAAS,EAAG,GAAG,IAAU,GAQxC,MARA,CACI,MAAM4jB,EAAM,GAAYzC,GAAqB1N,EAAG1rB,GAAIiY,GACpDohB,GAAsB3N,EAAG1rB,IAAM,GAAM,GAAc67B,EAAKhC,MACxDkB,EAAQrP,EACRkP,EAAQ,GAAYiB,EAAKjC,IACzB5I,EAAShxB,EAAI,CAEjB,CAEJ,CACJ,CAEO,SAAS87B,GAAmCvyB,EAAG2tB,GAClD,MAAM6E,EAA6B,EAAxB7C,GAAmB3vB,GACxBmiB,EAAIsO,GAAqB+B,EAAK,GAC9BC,EAAM,GAAY9E,GAAG,EAAO,GAClC,IAAIjf,EAAI,GAAS,EAAG,GAAG,GACvB,IAAK,IAAI9c,EAAI,EAAGA,GAAM4gC,EAAK,EAAI5gC,IAAK,CAChC,MAAM0gC,EAAM,GAAY,GAAY5jB,EAAGmhB,GAAqB1N,EAAGvwB,IAAK,GAAYi+B,GAAqB7vB,EAAGpO,GAAI6gC,IAC5G3C,GAAsB3N,EAAGvwB,IAAM,GAAM,GAAc0gC,EAAKhC,MACxD5hB,EAAI,GAAY4jB,EAAKjC,GACzB,CAEA,OADAgC,GAAgClQ,EAAGzT,EAAG8jB,GAC/B9B,GAAmBvO,EAC9B,CAsCO,MAAMuQ,WAA8B,EACvCriC,YAAYsiC,EAAMC,EAAWn8B,EAAGo8B,EAAMC,EAAMxrB,EAAO8D,GAC/C0C,QACAtd,KAAKmiC,KAAe,EAAPA,EACbniC,KAAKoiC,UAAyB,EAAZA,EAClBpiC,KAAKiG,EAAS,EAAJA,EACVjG,KAAKqiC,KAAe,EAAPA,EACbriC,KAAKsiC,KAAe,EAAPA,EACbtiC,KAAK8W,MAAiB,EAARA,EACd9W,KAAK4a,OAASA,CAClB,EAOG,SAAS2nB,GAAwBJ,EAAMl8B,EAAGo8B,EAAMC,GACnD,OAAO,IAAIJ,GAAsBC,EAAM3C,GAAmB,EAAG2C,GAAOl8B,EAAGo8B,EAAMC,KAAU3C,GAAwBwC,GAAQ,MAAexC,GAAwBwC,IAAS/gC,GAAMo+B,GAAmB,EAAG2C,EAAO/gC,IAAIs+B,YAClN,CAEO,MAAM8C,GAAqB,CAACD,GAAwB,EAAG,GAAI,UAAW,WAAYA,GAAwB,EAAG,GAAI,SAAU,WAAYA,GAAwB,EAAG,GAAI,SAAU,UAAWA,GAAwB,EAAG,GAAI,QAAS,UAAWA,GAAwB,EAAG,GAAI,QAAS,SAAUA,GAAwB,EAAG,GAAI,OAAQ,SAAUA,GAAwB,EAAG,GAAI,MAAO,QAASA,GAAwB,EAAG,GAAI,MAAO,QAASA,GAAwB,EAAG,GAAI,KAAM,OAAQA,GAAwB,GAAI,GAAI,KAAM,OAAQA,GAAwB,GAAI,EAAG,IAAK,MAAOA,GAAwB,GAAI,EAAG,GAAI,KAAMA,GAAwB,GAAI,EAAG,GAAI,MAiLjoB,SAAS,GAAiB/yB,EAAG2tB,GAChC,OAxNG,SAAoC3tB,EAAG2tB,GAC1C,MAAMsF,EAAmC,IAA1BtD,GAAmB3vB,GAC5BkzB,EAAmC,IAA1BvD,GAAmBhC,GAClC,OAAIsF,GAAUC,EA5DX,SAA6ClzB,EAAG2tB,GACnD,MAAMxL,EAAIsO,GAAqB,GACzB6B,EAAM,GAAY,GAAYtyB,GAAG,EAAO,GAAI,GAAY2tB,GAAG,EAAO,IAGxE,OAFAmC,GAAsB3N,EAAG,IAAM,GAAM,GAAcmQ,EAAKhC,MACxDR,GAAsB3N,EAAG,IAAM,GAAM,GAAYmQ,EAAKjC,MAC/CK,GAAmBvO,EAC9B,CAuDegR,CAAoCvD,GAAmB5vB,EAAG,GAAI4vB,GAAmBjC,EAAG,IAEtFsF,EACEV,GAAmC5E,EAAGiC,GAAmB5vB,EAAG,IAE9DkzB,EACEX,GAAmCvyB,EAAG4vB,GAAmBjC,EAAG,IA7BpE,SAAgD3tB,EAAG2tB,GACtD,MAAMxL,EAAIsO,GAAqBzwB,EAAEuvB,MAAQ5B,EAAE4B,OACrC6D,EAAKjR,EAAE3mB,OACb,IAAK,IAAI5J,EAAI,EAAGA,GAAMoO,EAAEuvB,MAAQ,EAAI39B,IAAK,CACrC,MAAMyhC,EAAM,GAAYrzB,EAAExE,OAAO5J,IAAI,EAAO,GAC5C,IAAI8c,EAAI,GAAS,EAAG,GAAG,GACnBjY,EAAI7E,EACR,IAAK,IAAIkD,EAAI,EAAGA,GAAM64B,EAAE4B,MAAQ,EAAIz6B,IAAK,CACrC,MAAMw+B,EAAM,GAAY3F,EAAEnyB,OAAO1G,IAAI,EAAO,GACtCw9B,EAAM,GAAY,GAAY,GAAYc,EAAG38B,IAAI,EAAO,GAAIiY,GAAI,GAAY2kB,EAAKC,IACvFF,EAAG38B,GAAkE,IAAxD,GAAM,GAAc67B,EAAKhC,KACtC5hB,EAAI,GAAY4jB,EAAKjC,IACrB55B,EAAMA,EAAI,EAAK,CACnB,CACA47B,GAAgClQ,EAAGzT,EAAGjY,EAC1C,CACA,OAAOi6B,GAAmBvO,EAC9B,CAeeoR,CAAuCvzB,EAAG2tB,EAEzD,CAyMW6F,CAA2BxzB,EAAG2tB,EACzC,CAEO,SAAS8F,GAA6BhkC,EAAGoG,EAAG4nB,EAAGH,GAClD,MAAM7G,EAAe,CAAChnB,EAAE+L,OAAQ21B,GAAoB1hC,IAC9C4jB,EAAMoD,EAAa,GACnBid,EAAiB,CAACjW,EAAEjiB,OAAQ21B,GAAoB1T,IAChDkW,EAAyB,EAApBD,EAAe,GACpBE,EAAMF,EAAe,GACrBG,EAAM,GAAYh+B,GAAG,EAAO,GAClC,IAAIf,EAAI,EACJ28B,EAAI,GAAYoC,EAAK,GAAYD,EAAI,IAAI,EAAO,IACpD,KAAQ,GAAQnC,EAAG,GAAS,EAAG,GAAG,IAAU,GAAa38B,EAAI6+B,GAAK,CAC9D,GAAI7+B,EAAI2hB,EAAa,GACjB,MAAM,IAAK3lB,MAAM,qEAErB,IAAIgjC,IAAS,GAAM,GAAcrC,EAAGnB,KAChCyD,EAAM,GAAYtC,EAAGpB,IACrByD,GAAOzgB,EAAIve,EAAIwoB,GACfjK,EAAIve,EAAIwoB,GAAOjK,EAAIve,EAAIwoB,GAAKwW,EAAO,GAGnCzgB,EAAIve,EAAIwoB,GAAOjK,EAAIve,EAAIwoB,IAAM8S,GAAqB0D,GAAQ,EAC1DC,EAAM,GAAYA,EAAK,GAAS,EAAG,GAAG,KAGtCtC,EADA38B,EAAI6+B,EACA,GAAYI,EAAK,GAAYF,EAAK,GAAYD,EAAI9+B,EAAI,IAAI,EAAO,KAGjEi/B,EAERj/B,EAAMA,EAAI,EAAK,CACnB,CACA47B,GAAmBjhC,EACvB,CAQO,SAASukC,GAA6BvkC,EAAGoG,EAAG4nB,EAAGH,GAClD,MAAM7G,EAAe,CAAChnB,EAAE+L,OAAQ21B,GAAoB1hC,IAC9C4jB,EAAMoD,EAAa,GACnBid,EAAiB,CAACjW,EAAEjiB,OAAQ21B,GAAoB1T,IAChDkW,EAAyB,EAApBD,EAAe,GACpBE,EAAMF,EAAe,GACrBG,EAAM,GAAYh+B,GAAG,EAAO,GAClC,IAAIf,EAAI,EACJ28B,EAAI,GAAYoC,EAAK,GAAYD,EAAI,IAAI,EAAO,IACpD,KAAQ,GAAQnC,EAAG,GAAS,EAAG,GAAG,IAAU,GAAa38B,EAAI6+B,GAAK,CAC9D,GAAI7+B,EAAI2hB,EAAa,GACjB,MAAM,IAAK3lB,MAAM,qEAErB,IAAIgjC,IAAS,GAAM,GAAcrC,EAAGnB,KAChCyD,EAAM,GAAYtC,EAAGpB,IACrByD,EAAO1D,GAAqB/c,EAAIve,EAAIwoB,GACpCjK,EAAIve,EAAIwoB,GAAOjK,EAAIve,EAAIwoB,GAAKwW,EAAO,GAGnCzgB,EAAIve,EAAIwoB,GAAOwW,GAAO1D,GAAqB/c,EAAIve,EAAIwoB,IAAO,EAC1DyW,EAAM,GAAYA,EAAK,GAAS,EAAG,GAAG,KAGtCtC,EADA38B,EAAI6+B,EACA,GAAYI,EAAK,GAAYF,EAAK,GAAYD,EAAI9+B,EAAI,IAAI,EAAO,KAGjEi/B,EAERj/B,EAAMA,EAAI,EAAK,CACnB,CACA47B,GAAmBjhC,EACvB,CAQO,SAASwkC,GAA0BxkC,EAAGguB,EAAGH,GAC5C,MAAM7G,EAAe,CAAC0a,GAAoB1T,GAAI0T,GAAoB1hC,IAC5DykC,EAAyB,EAAlBzd,EAAa,GACpB0d,EAAyB,EAAlB1d,EAAa,GAC1B,GAAIyd,EAAQC,EAAO7W,EACf,OAAO,EAEN,CACD,MAAMoW,EAAiB,CAACjW,EAAEjiB,OAAQ/L,EAAE+L,QAC9B44B,EAAKV,EAAe,GACpBW,EAAKX,EAAe,GACpB79B,EAAmgB,GAApf,IAATs+B,EAAgBD,IAAS5W,KAAU8W,EAAG9W,GAAK+W,EAAG,MAAY,GAAM,GAAY,GAAY,GAAY,GAAYD,EAAGF,IAAO,EAAO,GAAI7D,IAAwB,GAAY+D,EAAGF,EAAO,IAAI,EAAO,IAAK,GAAYG,EAAG,IAAI,EAAO,KAAYH,IAAUC,EAAO7W,KAAW8W,EAAGF,IAASG,EAAGF,GAAQ,MAAY,GAAM,GAAY,GAAY,GAAY,GAAYC,EAAGF,IAAO,EAAO,GAAI7D,IAAwB,GAAY+D,EAAGF,EAAO,IAAI,EAAO,IAAK,GAAY,GAAYG,EAAGF,IAAO,EAAO,GAAI,GAAS,EAAG,GAAG,OACzf,OAAU,IAANt+B,EAC8C,IApfby+B,EAofAhX,EApfIqQ,EAofDl+B,GApfNuQ,EAofAyd,GAnf/B8R,MAAQ+E,EAAO3G,EAAE4B,MAmfuB,GAlfnC,EAEFvvB,EAAEuvB,MAAQ+E,EAAO3G,EAAE4B,MAAQ+E,EAC1B,EA6BgD,EA1BzC,EAACvC,EAAQC,EAAQzjB,KAC3B4jB,EACA,OAAa,CACT,MAAMF,EAAKF,EAAQG,EAAKF,EAAQpgC,EAAI2c,EACpC,IAAW,IAAP3c,EACA,OAAO,EAEN,CACD,MAAMyhC,EAAoC,GAA5BzhC,EAAI0iC,EAAM,EAAIrC,EAAGrgC,EAAI0iC,IAC7BC,EAAoC,GAA5B3iC,EAmeiB,EAneP,EAAIsgC,EAAGtgC,EAmeA,IAle/B,GAAIyhC,IAAQkB,EAAK,CACbxC,EAASE,EACTD,EAASE,EACT3jB,EAAS3c,EAAI,EACb,SAASugC,CACb,CACK,OAAIkB,EAAMkB,GACH,EAGD,CAEf,CAEJ,GAEGpC,CAAMnyB,EAAExE,OAAQmyB,EAAEnyB,OAASwE,EAAEuvB,MAAQ+E,EAAM,IAmdnC,EAGA,EAIA,EAAJz+B,CAEf,CA9fG,IAAmCmK,EAAGs0B,EAAI3G,CA+fjD,CAEO,SAAS,GAAoBR,EAAG1P,GACnC,GAAI,GAAoBA,GACpB,MAAM,IAAK3sB,MAEV,GAAIqgC,GAAoBhE,GAAKgE,GAAoB1T,GAClD,MAAO,CAACyT,GAAmB/D,GAE1B,CACD,MAAM19B,EAnvBP,SAA4BA,GAC/B,OAAO,IAAI6/B,GAAO7/B,EAAE8/B,MAAY9/B,EAAE+L,OxB7DrB+N,QwB8DjB,CAivBkBirB,CAAmBrH,GACvBhnB,EAAIsqB,GAAuBU,GAAoBhE,GAAKgE,GAAoB1T,GAAM,EAAK,GACzF,IAAIzd,EAAImxB,GAAoBhE,GAC5B,MAAMjmB,EAA6B,EAAzBiqB,GAAoB1T,GAC9B,IAAIH,EAAItd,EAAIkH,EACZ,MAAMutB,EAAa/X,IAAD,EAElB,IAAI1I,GAAW,EACf,MAAQA,GAAU,CACdygB,EAAU,CAACtuB,EAAG1W,EAAG6tB,EAAGtd,IACpB,MAAMnK,EAAyC,EAArCo+B,GAA0BxkC,EAAGguB,EAAGH,GACtCznB,EAAI,GACJ49B,GAA6BhkC,EAAGoG,EAAG4nB,EAAGH,GACtC0W,GAA6B7tB,EAAGtQ,EAAGo7B,GAAkB3T,GACrDmX,EAAU,CAACtuB,EAAG1W,EAAG6tB,EAAGtd,MAGpBgU,EAAmB,IAANne,GAAmB,IAANynB,EACrBtJ,IACGhU,IAAOkH,EAAIoW,GACXmX,EAAU,CAACtuB,EAAG1W,EAAG6tB,EAAI,EAAGtd,IACxBsd,EAAMA,EAAI,EAAK,IAGfmX,EAAU,CAACtuB,EAAG1W,EAAG6tB,EAAI,EAAGtd,EAAI,IAC5Bsd,EAAMA,EAAI,EAAK,EACftd,EAAMA,EAAI,EAAK,IAI/B,CACA,MAAO,CAAC0wB,GAAmBvqB,GAAIuqB,GAAmBjhC,GACtD,CACJ,CA0HO,SAASilC,GAAqBpX,GAiBjC,MAhBkB,EAAC8I,EAASqB,EAAOlZ,KAE/B,OAAa,CACT,MAAMa,EAAMgX,EAAS3vB,EAAIgxB,EAAO71B,EAAI2c,EACpC,GAAI3c,IAAM0rB,EAAEiS,MACR,OAAOngB,EAGPgX,EAAWhX,EAAO3Y,EAAI6mB,EAAE9hB,OAAO5J,GAC/B61B,EAAShxB,EAAI25B,GACb7hB,EAAS3c,EAAI,CAIrB,GAEG+iC,CAAU,EAAG,EAAG,EAC3B,CAEO,SAASC,GAAqBtX,GACjC,OAAOwT,GAAmBxT,EAC9B,CAEO,SAASuX,GAAqBvX,GACjC,OAx3BG,SAA8B7tB,GACjC,MAAM4jB,EAAO,GAAQ5jB,EAAG,GAAS,EAAG,GAAG,IAAU,EAAK,GAAS,EAAG,GAAG,GAASA,EACxE0yB,EAAIsO,GAtByB,GAuBnC,IAAK,IAAI7+B,EAAI,EAAGA,GAAK,EAA+BA,IAChDuwB,EAAE3mB,OAAO5J,GAAuH,IAA7G,I/BgmBJuM,E+BhmBqB,GAAYkV,EAAK0c,GAAmBM,GAAuBz+B,I/BgmBzEiR,E+BhmB8EwtB,G/BimBnGxyB,GAAOgF,KACRA,EAAU,GAAUA,IAEpB1F,GAEO,IADIgB,EAAMlD,SAAWkC,GAAK23B,MAAQ33B,GAAK43B,OAAO52B,EAAMR,IAAKQ,EAAMP,KAAMiF,EAAQlF,IAAKkF,EAAQjF,MAC5ET,GAAKwF,WAAYxE,EAAMlD,UAEzCiG,GAAS/C,EAAO,GAAS6C,GAAO7C,EAAO0E,GAAUA,MARrD,IAAgB1E,EAAO0E,E+B9lB1B,OAAO6tB,GAAmBvO,EAC9B,CAi3BW6S,CAAqB1X,EAChC,CAqDO,SAAS2X,GAAsB3X,GAClC,MAAM4X,EAAgC,EAAzB/D,GAAoB7T,GAiB3B6X,EAAU,CAACC,EAAeC,EAAYC,EAASC,KACjDJ,EACA,OAAa,CACT,MAAMK,EAAYJ,EAAe55B,EAAS65B,EAAYI,EAAMH,EAAStjB,EAAQujB,EAC7E,GAAK,GAAQvjB,GAoBR,CACD,MAAM0jB,EAAiC,EAA3B1E,GAAoByE,GAChC,OAAID,GAAsB,IAARE,EACPl6B,EAGA,GAAKnJ,EAAcqjC,GAAMl6B,EAExC,CA5BqB,CACjB,MAAMm6B,EAAU,GAAK3jB,GACfyE,EAAe,GAAoBgf,EAAK,GAAKzjB,GAAO,IACpD4jB,EAAKnf,EAAa,GAClBof,EAAKpf,EAAa,GACxB,GAAI+e,GAAa,GAAoBK,GAAK,CACtCT,EAAgBI,EAChBH,EAAa75B,EACb85B,EAAUM,EACVL,EAAYI,EACZ,SAASR,CACb,CAEIC,EAAgBI,EAChBH,EAAaF,GAAQ,EAAO35B,EAAQo6B,EAAID,GACxCL,EAAUO,EACVN,EAAYI,EACZ,SAASR,CAEjB,CAWJ,GAEEW,EAAWX,GAAQ,EAAM,KAAS7X,EApD1B,EAACyY,EAAWtO,EAAOuO,KAE7B,OAAa,CACT,MAAMC,EAAQF,EAAWt/B,EAAIgxB,EAAOyO,EAAQF,EAC5C,GAAI7E,GAAoB+E,GAAShB,EAC7B,OAAO,GAAK,CAACz+B,EAAGy/B,GAAQD,GAGxBF,EAAY,GAAK,CAACt/B,EAAGy/B,GAAQD,GAC7BxO,EAAShxB,EAAI,EACbu/B,EAAY,GAAiBE,EAAOA,EAI5C,GAsCuCC,CAAM,KAAS,EAAGrF,GAAmB,MAChF,OAAI,GAAQgF,GACD,IAGA,GAAK,GAAI,GAAQA,GAEhC,CAEO,SAASM,GAAsBtkC,GAClC,MAAMmB,EAAmB,EAAbnB,EAAID,OAChB,GAAIwY,GAAcvY,GACd,MAAM,IAAKhB,MAAM,sCAErB,MAAMulC,EAAMvF,GAAmB,IAuB/B,MAtBc,EAAC1K,EAAS7X,KACpB+nB,EACA,OAAa,CACT,MAAMlnB,EAAMgX,EAASx0B,EAAI2c,EACzB,GAAI3c,IAAMqB,EACN,OAAOmc,EAEN,CACD,MACMjJ,EADIrU,EAAIF,GACDsB,WAAW,GAAK,GAAM,EACnC,GAAK,GAAKiT,GAAOA,GAAK,EAAI,CACtBigB,EAAU,GAAiB,GAAiBiQ,EAAKjnB,GAAM0hB,GAAmB3qB,IAC1EoI,EAAS3c,EAAI,EACb,SAAS0kC,CACb,CAEI,MAAM,IAAKxlC,KAEnB,CAEJ,GAEGwlC,CAAMxF,GAAmB,GAAI,EACxC,CAMO,SAASyF,GAAsBjZ,GAClC,MAAMmU,EAAInU,EAEV,OADU,EACFmU,EAAElC,MACe,EAAdkC,EAAEj2B,OAFH,GAKC,CAEf,CA3lBoC,GAAW20B,IAAwBv+B,GAAOo+B,GAAmB,EAAGp+B,GAAK,GAAIs+B,YAEvE,GAAWC,IAAwBv+B,GAAMo+B,GAAmB,EAAGp+B,IAAIs+B,YAEhE,GAAWC,IAAwBv+B,GAAMm+B,GAAmB,GAAS,EAAG,GAAG,GAAQn+B,KA4ItEohC,GAAmB,GAAGF,KAuN5ChC,GAAmB,GCjqC5C,MAAM,WAAmB,EAC5BzgC,YAAYmmC,EAASziC,GACjB+Z,QACAtd,KAAKgmC,QAAqB,EAAVA,EAChBhmC,KAAKuD,EAAIA,CACb,CACAhC,WACI,MAAMtC,EAAIe,KAEV,OADgD,EAA7BimC,GAAwBhnC,IAEvC,KAAM,EACF,OAAO,GAAoBinC,GAAkBjnC,IAAM,IAAO,IAAMwlC,GAAsByB,GAAkBjnC,IAE5G,KAAK,EACD,MAAO,IAEX,KAAK,EACD,OAAOwlC,GAAsByB,GAAkBjnC,IAEnD,QACI,MAAM,IAAKqB,MAAM,8BAG7B,CACAqD,OAAOqB,GAEH,OAAQA,aAAe,IAAe,GADxBhF,KAC+DgF,EACjF,CACAzF,cAEI,OAAsC,GAkWP,IAA/B0mC,GAnWUjmC,MAoWH,EAGCimC,GAvWEjmC,MD8OX,SAA2B8sB,GAC9B,IAAItnB,EAAM,EACV,IAAK,IAAIpE,EAAI,EAAGA,GAAM0rB,EAAEiS,MAAQ,EAAI39B,IAChCoE,EAAQsnB,EAAE9hB,OAAO5J,IAAMoE,GAAO,GAAM,EAExC,OAAa,EAANA,CACX,CCmH6C2gC,CAAkBD,GAvW7ClmC,OAuWsE,EArWpF,CACAuG,OAAO0X,GAEH,OAAO,EADOje,KAElB,CACAwE,UAAUQ,GAEN,GAAIA,aAAe,GACf,OAAiD,GA8JtD,SAAyC/F,EAAGS,GAC/C,MAAMke,EAAa,CAACqoB,GAAwBhnC,GAAIgnC,GAAwBvmC,IACxE,IAAIulB,EA8CJ,OA3CQA,GAFe,IAAnBrH,EAAW,IACY,IAAnBA,EAAW,GACe,EAEH,IAAlBA,EAAW,GACU,EAEH,IAAlBA,EAAW,GACU,EAGA,EAGP,IAAlBA,EAAW,IACO,IAAnBA,EAAW,GACe,EAEH,IAAlBA,EAAW,GACU,EAEH,IAAlBA,EAAW,GACU,EAGA,EAGP,IAAlBA,EAAW,IACO,IAAnBA,EAAW,GACe,EAEH,IAAlBA,EAAW,GACU,EAEH,IAAlBA,EAAW,GACU,EAGA,EAIJ,EAEtBqH,GACJ,KAAK,EACD,OAAOqc,GAAgB4E,GAAkBjnC,GAAIinC,GAAkBxmC,IAEnE,KAAK,EACD,OAAO4hC,GAAgB4E,GAAkBxmC,GAAIwmC,GAAkBjnC,IAEnE,KAAK,EAWL,KAAK,EAML,KAAK,EAGL,KAAK,EACD,OAAO,EAlBX,KAAK,EACD,OAAK,GAAoBinC,GAAkBjnC,MAI/B,GAAoBinC,GAAkBxmC,IAMtD,KAAK,EACD,OAAQ,GAAoBwmC,GAAkBxmC,IAQlD,KAAK,EACD,OAAQ,GAAoBwmC,GAAkBjnC,IAElD,KAAK,EACD,MAAM,IAAKqB,MAAM,kDAG7B,CA0FQ,CA/UcN,KA8UyBomC,EA5UOphC,IA8UtC,EAEH,GAlVShF,KAkV0BomC,GACjC,EAGA,GAjVH,MAAM,IAAK9lC,MAAM,wDAyUtB,IAAwC8lC,CAvU3C,EAOG,SAASC,GAA0BL,EAASziC,GAC/C,OAAO,IAAI,GAAWyiC,EAASziC,EACnC,CAUO,SAAS+iC,GAAyBxZ,GACrC,ODw0CG,SAA8BA,GACjC,OAAOA,EAAEiS,OAAS,CACtB,CC10CQ,CAAqBjS,IAAOiZ,GAAsBjZ,GAAK,GAAWyZ,SAC3D,GAAWC,YAAYT,GAAsBjZ,IAG7CA,CAEf,CAMO,SAAS2Z,GAA0B3Z,GACtC,OAAOuZ,GAA0B,EAAGC,GAAyBxZ,GACjE,CAeO,SAASmZ,GAAwBhnC,GACpC,OAAOA,EAAE+mC,OACb,CAEO,SAASE,GAAkBjnC,GAC9B,OAAOA,EAAEsE,CACb,CAEO,SAAS,GAAgCtE,EAAGS,GAC/C,MAAMke,EAAa,CAACqoB,GAAwBhnC,GAAIgnC,GAAwBvmC,IACxE,IAAIulB,EA8CJ,OA3CQA,GAFe,IAAnBrH,EAAW,IACY,IAAnBA,EAAW,GACe,EAEH,IAAlBA,EAAW,GACU,EAEH,IAAlBA,EAAW,GACU,EAGA,EAGP,IAAlBA,EAAW,IACO,IAAnBA,EAAW,GACe,EAEH,IAAlBA,EAAW,GACU,EAEH,IAAlBA,EAAW,GACU,EAGA,EAGP,IAAlBA,EAAW,IACO,IAAnBA,EAAW,GACe,EAEH,IAAlBA,EAAW,GACU,EAEH,IAAlBA,EAAW,GACU,EAGA,EAIJ,EAEtBqH,GACJ,KAAK,EAGL,KAAK,EACD,ODiYuBzV,ECjYG02B,GAAkBjnC,GDiYlBk+B,ECjYsB+I,GAAkBxmC,GDkYtE8P,EAAEuvB,QAAU5B,EAAE4B,OACA,EAACwC,EAAQC,EAAQzjB,KAE3B,OAAa,CACT,MAAM0jB,EAAKF,EAAQG,EAAKF,EAAQpgC,EAAI2c,EACpC,IAAW,IAAP3c,EACA,OAAO,EAEN,GAAIqgC,EAAGrgC,KAAOsgC,EAAGtgC,GAOlB,OAAO,EANPmgC,EAASE,EACTD,EAASE,EACT3jB,EAAS3c,EAAI,CAOrB,GAEGugC,CAAMnyB,EAAExE,OAAQmyB,EAAEnyB,OAAQwE,EAAEuvB,MAAQ,GCpZ3C,KAAK,EAQL,KAAK,EACD,QAAI,GAAoBmH,GAAkBjnC,KAC/B,GAAoBinC,GAAkBxmC,IAMrD,KAAK,EACD,OAAO,EAEX,KAAK,EAGL,KAAK,EACD,OAAO,GAAoBwmC,GAAkBxmC,IAEjD,KAAK,EAGL,KAAK,EACD,OAAO,GAAoBwmC,GAAkBjnC,IAEjD,KAAK,EACD,MAAM,IAAKqB,MAAM,kDD+VtB,IAA4BkP,EAAG2tB,CC5VtC,CA6MO,SAAS,GAA2BrQ,GACvC,OAAIA,GAAK,EACEuZ,GAA0B,EAAGC,GAAyBlC,GAAqBtX,KAG3EuZ,IAA2B,EAAGC,IADzB,aAAPxZ,EACyDuX,GAAqB/wB,GAAiB,GAAYwZ,GAAG,EAAO,KAG5DsX,IlC1SpD,cADqBnlC,EkC2S2E6tB,GlC1SnF7tB,GAAKA,KAD7B,IAAgCA,CkC6SvC,CAcO,SAAS,KACZ,OAAO,GAAWk/B,GACtB,CAMO,SAAS,KACZ,OAAO,GAAWuI,IACtB,CC3ZO,SAAS,GAAMC,GAClB,ODs/BG,SAAoC5S,GACvC,GAAY,MAARA,EACA,MAAM,IAAKzzB,MAAM,QAErB,MAAMsmC,EAAS7S,EAAKtd,OACdhU,EAAsB,EAAhBmkC,EAAOvlC,OACnB,GAAY,IAARoB,EACA,MAAM,IAAKnC,MAEf,MAAMsd,EAAa,CAACgpB,EAAO,GAAInkC,GAC/B,GAAsB,MAAlBmb,EAAW,GAAY,CACvB,GAAsB,IAAlBA,EAAW,GACX,MAAM,IAAKtd,MAGX,OAAOmmC,GAA0Bb,GAAsBgB,EAAO7tB,MAAM,EAAItW,EAAM,EAAK,IAE3F,CACK,GAAsB,MAAlBmb,EAAW,GAAY,CAC5B,GAAsB,IAAlBA,EAAW,GACX,MAAM,IAAKtd,MAGX,OAh9BD+lC,IAA2B,EAAGC,GAg9BIV,GAAsBgB,EAAO7tB,MAAM,EAAItW,EAAM,EAAK,KAE3F,CAEI,OAAOgkC,GAA0Bb,GAAsBgB,GAE/D,CCnhCW,CAA2BD,EACtC,CAqFO,SAASE,GAAU5nC,GACtB,OD25BG,SAAmCA,GACtC,OAAO,IAAI,GAvCR,SAAkCA,GAErC,OADgD,EAA7BgnC,GAAwBhnC,IAEvC,KAAM,EACF,OAAQilC,GAAqBgC,GAAkBjnC,IAEnD,KAAK,EACD,OAAO,EAEX,KAAK,EACD,OAAOilC,GAAqBgC,GAAkBjnC,IAElD,QACI,MAAM,IAAKqB,MAAM,kDAG7B,CAuBuB,CAAyBrB,GAChD,CC75BW6nC,CAA0B7nC,EACrC,C,YC7FkBA,GACV,SAAK,S,SAFYA,G,MAAwB,iBAAJA,C,CAGlC,CAAgBA,IAChB,YAAiBA,GACjB,MAAWA,GACX,WAAiB,EAAI,IACrB,UAAgB,EAAI,C,aAchBsX,G,MACDqH,E,SALIrH,G,gBTaHA,EAAgBiJ,G,MAEhBrY,EADPqY,EAAO/T,MAAM8K,GAEH,OAAApP,EAAA,OACI,GAAKA,EAAO/G,Y,EShB1B,CAAgBmW,EAAAA,G,CAIV,CAASA,GAAT,eAEI,GAAU,yCAAV,CAA+CA,GADxCqH,C,aAIF4D,GAAA,gCAEC,OACC,QAHF,a,OAIYulB,EAAAA,OAAAA,GAAAA,WAJZ,a,OAKG,GAAQ,WAAR,CALH,2B,MAUR/mB,EADA,GAAc,IADd,GAASze,GARD,c,OAUR,GAAQ,WAAR,CAAAye,E,CAVQ,c,MAgBRA,EADA,GAAc,IADd,IAAekM,I,MAAc8a,EAAyB,GAAvC,M,OAAc,GAAQ,cAAR,CAAd,KAAc,CAAAA,EAAAA,GAD7B,GAbQ,e,OAgBR,GAAQ,WAAR,CAAAhnB,E,OAfI,M,aAmBQzJ,G,OACbA,EAAAA,K,4BAIa,Y,cAEX6F,EAAQ,GACC4H,EAAA,EADT,aACJ,SAAa,iD,MAAT5jB,EAAS,4DAAUgc,EAAM,KAAI,GAAchc,G,UAA/C,EAAa4jB,E,QACP5H,C,eAEF6qB,EAAW,GACKjjB,EAAA,KADhB,cACJ,SAAoB,iD,MAAfsI,EAAe,4DAChB,EADgB,MACF,GADE,K,UAApB,EAAoBtI,E,QAEdijB,C,kCAEC7mC,GACX,OAAG,QACE,qBACA,eAAkBA,GAAO,CAAKsE,EAAIwiC,K,IAcKvjB,E,OAbxC,GAAYujB,GAAAA,GAAAA,GACoBA,IAE3B,kBAEI,GADmCA,EACf,KAEvBA,iBAAAA,EACSA,EvC/FX,OADWjoC,EuC+FTioC,IvC9FmB,iBAANjoC,GAAkBwB,OAAOC,YAAYzB,EuCiGpD,cAAiCioC,GAAgBA,EAC5C,WAAUA,GAJb,GAKYA,GAAAA,GAAAA,GAAiDA,I,SAlFzDjoC,GAAU,0BAAY,WAAgBA,C,CA6E1C,CAMgBioC,IAAkBvjB,EAAuBujB,EAAvB,GAAAvjB,EAA2C,MAC5EujB,EvCtGZ,IAAoBjoC,CuCsGRioC,GACR,M,aAEwBjoC,G,MAEzBkoC,E,SC1FkBloC,GACpB,MAAgBA,iBAAb,EACsBA,O,EDwFvB,CADIA,GACJ,GADI,Q,OAC0B,SAD1BkoC,G,OAEJC,E,SCjFkBnoC,GACpB,MAAgBA,iBAAb,EACqBA,O,ED+EtB,CAFIA,GAEJ,GAFI,Q,OAE6B,SAF7BmoC,G,OAGJC,E,SCvFgBpoC,GAClB,MAAcA,kBAAX,EACoBA,O,EDqFrB,CAHIA,GAGJ,GAHI,Q,OAG0B,SAH1BooC,GAIJ,GAJIpoC,M,SCrEMA,GACZ,OAAG,QACE,GAAKA,Q,EDmEJ,CAAAA,G,OAIgB,U,OACpBqoC,E,SCrEiBroC,GACnB,OAAI,cAA8BA,GACVA,O,EDmEtB,CALIA,GAKJ,GALI,Q,OAKyB,SAAQ,GAAc,GAAUsoC,GALzDD,K,OAMJE,E,SChFkBvoC,GACpB,MAAgBA,iBAAb,EACE,GAAKA,Q,ED8ER,CANIA,GAMJ,GANI,S,MAMmBwoC,EAAAA,GANnBD,G,OASC,SADA,GADH,GAAE,YAAI9iC,GAAAA,CAA6CA,EAAK,GAAc,EAASA,MAAlE,YAA4B+iC,Q,QAGtC,S,iBAGMlxB,G,OAEb,GADa,WAAcA,G,CFzD/B,GAAWgwB,SAAW,KACtB,GAAWC,YAAc,GAAW,GAAWD,SAAUnC,IACzD,GAAWjG,IAAM,GAA2B,GAC5C,GAAWuJ,IAAM,GAA2B,GAC5C,GAAWhB,KAAO,GAA2B,GCzB7B,KAED,KDoYR,GAAWgB,IC/RE,KAED,KGpJvB,MAAMC,GAAMvnC,IAAU,CAClBkG,IAAK,KACLlG,UAEE8uB,GAASA,IAAU,CAAG5oB,IAAK,QAAS4oB,UACnC,MAAM0Y,GACT/nC,YAAY2c,GACRxc,KAAK6nC,IAAMrrB,CACf,CACAxa,qBAAqB6lC,GACjB,IAGI,OADA,IAAIC,IAAID,IACD,CAIX,CAFA,MAAOv+B,GACH,OAAO,CACX,CACJ,CACAtH,yBAAyB6lC,EAAKlmC,GAC1B,OAAQA,GACJ,KAAK,EACD,OAAOimC,GAAIG,cAAcF,GACnBF,GAAG,IAAIC,GAAI,CAAEI,SAAUH,EAAKznC,MAAO,IAAI0nC,IAAID,GAAMlmC,UACjDutB,GAAM,+DAChB,KAAK,EACD,OAAO0Y,GAAIG,cAAcF,GACnB3Y,GAAM,+BACNyY,GAAG,IAAIC,GAAI,CAAEI,SAAUH,EAAKznC,MAAOynC,EAAKlmC,UAClD,KAAK,EACD,OAAOimC,GAAIG,cAAcF,GACnBF,GAAG,IAAIC,GAAI,CAAEI,SAAUH,EAAKznC,MAAO,IAAI0nC,IAAID,GAAMlmC,KAAM,KACvDgmC,GAAG,IAAIC,GAAI,CAAEI,SAAUH,EAAKznC,MAAOynC,EAAKlmC,KAAM,KACxD,QAEI,OADcA,EAG1B,CACAK,yBAAyBimC,EAASC,GAC9B,OAA4B,IAArBD,EAAQJ,IAAIlmC,KACbutB,GAAM,sCACiB,iBAAhBgZ,EACHP,GAAG,IAAIC,GAAI,CACTI,SAAU,IAAIF,IAAII,EAAaD,EAAQJ,IAAIznC,OAAOmB,WAClDnB,MAAO,IAAI0nC,IAAII,EAAaD,EAAQJ,IAAIznC,OACxCuB,KAAM,KAEiB,IAAzBumC,EAAYL,IAAIlmC,KACZgmC,GAAG,IAAIC,GAAI,CACTI,SAAU,IAAIF,IAAII,EAAYL,IAAIznC,MAAO6nC,EAAQJ,IAAIznC,OAAOmB,WAC5DnB,MAAO,IAAI0nC,IAAII,EAAYL,IAAIznC,MAAO6nC,EAAQJ,IAAIznC,OAClDuB,KAAM,KAERgmC,GAAGM,EACrB,CACAjmC,qBAAqB5B,EAAO+nC,EAAY,GACpC,MAAwB,iBAAV/nC,EACa,iBAAd+nC,EACHjZ,GAAM,wDACN0Y,GAAIQ,kBAAkBhoC,EAAO+nC,GACZ,iBAAdA,EACHjZ,GAAM,qEACN0Y,GAAIS,kBAAkBjoC,EAAO+nC,EAC3C,CACAnmC,cAAc5B,EAAO+nC,EAAY,GAC7B,MAAMhhC,EAASygC,GAAIU,cAAcloC,EAAO+nC,GACxC,OAAQhhC,EAAOb,KACX,IAAK,KACD,OAAOa,EAAO/G,MAClB,IAAK,QACD,MAAM,IAAIE,MAAM6G,EAAO+nB,OAC3B,QAEI,OADc/nB,EAG1B,CACAnF,iBAAiB5B,EAAO+nC,EAAY,EAAkBI,GAClD,MAAMphC,EAASygC,GAAIU,cAAcloC,EAAO+nC,GACxC,OAAQhhC,EAAOb,KACX,IAAK,KAED,OADAiiC,EAAI/gC,SAAWL,EAAO/G,OACf,EACX,IAAK,QACD,OAAO,EACX,QAEI,OADc+G,EAG1B,CACA5F,WACI,OAAQvB,KAAK6nC,IAAIlmC,MACb,KAAK,EACD,OAAO6mC,mBAAmBxoC,KAAKyoC,QAAQlnC,YAC3C,KAAK,EACD,OAAOvB,KAAK6nC,IAAIznC,MACpB,QAEI,OADcJ,KAAK6nC,IAG/B,CACAY,QACI,OAAQzoC,KAAK6nC,IAAIlmC,MACb,KAAK,EACD,OAAO3B,KAAK6nC,IAAIznC,MACpB,KAAK,EACD,MAAM,IAAIE,MAAM,uDACpB,QAEI,OADcN,KAAK6nC,IAG/B,CACIE,oBACA,OAAyB,IAAlB/nC,KAAK6nC,IAAIlmC,IACpB,CACI+mC,kBACA,OAAO1oC,KAAKyoC,QAAQE,IACxB,CACIC,aACA,MAAMC,EAAW7oC,KAAKyoC,QAAQI,SAC9B,OAAOA,EAAS9vB,MAAM,EAAG8vB,EAASxnC,OAAS,EAC/C,CACIynC,WACA,OAAO9oC,KAAKyoC,QAAQK,IACxB,CACIC,mBACA,OAAO/oC,KAAKyoC,QAAQO,QACxB,CACIC,YACA,OAAOjpC,KAAKyoC,QAAQ7uB,MACxB,CACIsvB,mBACA,MAAMvd,EAAM3rB,KAAKyoC,QACjB,OAAO9c,EAAIqd,SAAWrd,EAAI/R,MAC9B,CACIuvB,eACA,OAAOnpC,KAAKyoC,QAAQW,IACxB,CACIC,qBACA,OAAOrpC,KAAK6nC,IAAIG,QACpB,EC1HW,SAASsB,GAAelpC,EAAOsB,IAM9C,SAA4BA,GACxB,GAAc,MAAVA,GAA6B,IAAXA,EAAc,CAChC,GAAIA,EAAS,KAAU,EACnB,MAAM,IAAIpB,MAAM,8CAEpB,GAAI8O,KAAK4E,IAAItS,EAAS,MAAW,GAC7B,MAAM,IAAIpB,MAAM,gDAExB,CACJ,CAdIipC,CAAmB7nC,GACnB,MAAMiU,EAAI,IAAIzS,KAAK9C,GAEnB,OADAuV,EAAEjU,OAAmB,MAAVA,EAAiBA,GAA2C,KAAlC,IAAIwB,MAAOtB,oBACzC+T,CACX,CAsDO,SAAS,GAAMrU,GAClB,MAAOE,EAAMgoC,GAAelzB,GAAShV,GAC/BI,EAAwB,MAAf8nC,GACmB,IAA5BhoC,EAAKI,oBACY,MAAhB4nC,EAAsB,EAAkB,IAAdA,EACjC,OAAOF,GAAe9nC,EAAK2B,UAAWzB,EAC1C,CC1DO,SAAS+nC,GAAcC,GAE1B,OrCgGyCC,EqCjG3BC,GAAiB,GAAW,OAAeF,GArBlD,GrCuHA,GAAiB,GAAe,GAAYC,EAAO,KAAQ,cqCvH3C,GADpB,IrCuHsCA,CqC/F7C,CCvBO,SAAS,GAAOnnC,EAAI,EAAGkU,EAAI,EAAGnU,EAAI,EAAGsnC,EAAK,GAC7C,GAAIrnC,EAAI,GAAKkU,EAAI,GAAKnU,EAAI,GAAKsnC,EAAK,EAChC,MAAM,IAAIvpC,MAAM,wDACpB,OAAyB,IAArBywB,UAAU1vB,OAEH,GAAU0vB,UAAU,IAEhB,KAAJvuB,EAAkB,IAAJkU,EAAgB,IAAJnU,EAAWsnC,CACpD,CACO,SAAS,GAAUF,GACtB,OAAO,GAAc,GAAiBA,EAAO,KACjD,CCXA,MAAMG,GAAY,uFACZC,GAAoB,uEACpBC,GAAe,8EAwBd,SAAS,GAAM1oC,GAClB,SAAS2oC,EAAc3oC,GACnB,OAAOA,EAAIwJ,QAAQi/B,GAAmB,iBAC1C,CACA,MAAMG,EAAmB5oC,EAAImV,OAAO6B,cACpC,GAAIwxB,GAAUz+B,KAAK6+B,GACf,OpCmcD,SAAc5oC,KAAQ6oC,GACzB,GAAqB,IAAjBA,EAAM9oC,OACN,OAAOC,EAAImV,OAEf,MAAM2C,EAAU,IAAM,GAAO+wB,EAAMjkC,KAAK,KAAO,KAC/C,OAAO5E,EAAIwJ,QAAQ,IAAIyP,OAAO,IAAMnB,GAAU,IAAItO,QAAQ,IAAIyP,OAAOnB,EAAU,KAAM,GACzF,CoCzce3C,CAAKyzB,EAAkB,IAAK,IAAK,IAAK,KAE5C,GAAIH,GAAkB1+B,KAAK6+B,GAC5B,OAAOD,EAAcC,GAEpB,GAAIF,GAAa3+B,KAAK6+B,GACvB,OAAOD,EAAcC,EAAiBp/B,QAAQ,cAAe,KAG7D,MAAM,IAAIxK,MAAM,oFAExB,CC9CA,MAAM8pC,IAAe,EAsBd,SAASC,GAAcjqC,GAC1B,MAAMkN,EAAQ,IAAIP,WAAW,GAG7B,OAFa,IAAIu9B,SAASh9B,EAAMi9B,OAAQj9B,EAAMk9B,WAAYl9B,EAAMm9B,YAC3DC,SAAS,EAAGtqC,EAAOgqC,IACjB98B,CACX,CA2EO,SAAS,GAAQA,EAAO5L,GAC3B,MAAM0a,EAAQhd,YAAYC,OAAOiO,GAASA,EAAQP,WAAWiN,KAAK1M,GAC5Dq9B,EAAO,IAAIL,SAASluB,EAAMmuB,OAAQnuB,EAAMouB,WAAYpuB,EAAMquB,YAC1Dx7B,EAAU07B,EAAKC,SAASlpC,EAAyB,EAAQ0oC,IACzDl7B,EAAWy7B,EAAKC,SAASlpC,EAAyB,EAAQ0oC,IAChE,OAAO,GAASn7B,EAASC,GAAU,EACvC,CCnGO,MAAM27B,GACThrC,YAAYoG,GACRjG,KAAKiG,EAAIA,CACb,EAOG,SAAS6kC,GAA0B7kC,GACtC,OAAO,IAAI4kC,GAAc5kC,EAC7B,CAEO,SAAS8kC,GAAuB7xB,GACnC,OAAOA,EAAEjT,CACb,CAEO,MAAM+kC,WAAsBH,GAC/BhrC,YAAY0D,EAAGmvB,EAAMoC,EAAOtyB,GACxB8a,MAAM/Z,GACNvD,KAAK0yB,KAAOA,EACZ1yB,KAAK80B,MAAQA,EACb90B,KAAKwC,EAAS,EAAJA,CACd,EAOG,SAASyoC,GAA8B1nC,EAAGmvB,EAAMoC,EAAOtyB,GAC1D,OAAO,IAAIwoC,GAAcznC,EAAGmvB,EAAMoC,EAAOtyB,EAC7C,CAEO,SAAS0oC,GAAwBhyB,GACpC,OAAOA,EAAEwZ,IACb,CAEO,SAASyY,GAAyBjyB,GACrC,OAAOA,EAAE4b,KACb,CAEO,SAASsW,GAA0BlyB,GACtC,OAAOA,EAAE1W,CACb,CAMO,SAAS6oC,GAAuBC,EAAO1V,GAC1CyV,EACA,OAAa,CACT,MAAMjjC,EAAIkjC,EAAO1sB,EAAMgX,EACvB,GAAS,MAALxtB,EAAW,CACX,MAAME,EAAKF,EACX,GAAIE,aAAc0iC,GAAe,CAC7BM,EAAQJ,GAAwB5iC,GAChCstB,EAAUyV,GAAuBF,GAAyB7iC,GAAKsW,EAAM,GACrE,SAASysB,CACb,CAEI,OAAQzsB,EAAM,EAAK,CAE3B,CAEI,OAAa,EAANA,CAGf,CACJ,CAEO,SAAS2sB,GAAoBhpC,GAChC,OAAO8oC,GAAuB9oC,EAAG,EACrC,CAEO,SAASipC,GAAiBrlB,EAAGlgB,EAAG0rB,GACnC,IAAIsE,EASAC,EAPJ,GAAS,MADC/P,EACK,CACX,MAAM7d,EAFA6d,EAGN8P,EAAO3tB,aAAc0iC,GAAiBI,GAA0B9iC,GAAM,CAC1E,MAEI2tB,EAAK,EAIT,GAAW,MADCtE,EACK,CACb,MAAM8Z,EAFE9Z,EAGRuE,EAAOuV,aAAgBT,GAAiBI,GAA0BK,GAAQ,CAC9E,MAEIvV,EAAK,EAET,MAAMxf,EAA4B,GAAtBuf,EAAKC,EAAMA,EAAKD,GAC5B,OAAU,IAANvf,EACOo0B,GAA0B7kC,GAG1BglC,GAA8BhlC,EAAGkgB,EAAGwL,EAAGjb,EAAI,EAE1D,CAEO,SAASg1B,GAAwBrjC,EAAI9E,EAAG+E,GAC3C,IAAI8W,EAAKusB,EAAMC,EAAKC,EAChBpV,EASAC,EAPJ,GAAS,MADCruB,EACK,CACX,MAAMojC,EAFApjC,EAGNouB,EAAQgV,aAAgBT,GAAiBI,GAA0BK,GAAQ,CAC/E,MAEIhV,EAAM,EAIV,GAAW,MADCnuB,EACK,CACb,MAAMwjC,EAFExjC,EAGRouB,EAAQoV,aAAgBd,GAAiBI,GAA0BU,GAAQ,CAC/E,MAEIpV,EAAM,EAEV,GAAIA,EAAOD,EAAM,EAAI,CACjB,MAAM7Y,EAAa,GAAQtV,GAC3B,GAAIsV,aAAsBotB,GAAe,CACrC,GAAM5rB,EAAM8rB,GAAwBttB,IAAqB,MAAPwB,GAAiBusB,EAAOvsB,EAAMusB,aAAgBX,GAAiBI,GAA0BO,GAAQ,GAAM,GAAOlV,EAAM,EAAI,CACtK,MAAM1T,EAAe,GAAQmoB,GAAwBttB,IACrD,GAAImF,aAAwBioB,GACxB,OAAOQ,GAAiBA,GAAiBnjC,EAAI9E,EAAG2nC,GAAwBnoB,IAAgBgoB,GAAuBhoB,GAAeyoB,GAAiBL,GAAyBpoB,GAAegoB,GAAuBntB,GAAautB,GAAyBvtB,KAGpP,MAAM,IAAKtd,MAAM,gCAEzB,CAEI,OAAOkrC,GAAiBA,GAAiBnjC,EAAI9E,EAAG2nC,GAAwBttB,IAAcmtB,GAAuBntB,GAAautB,GAAyBvtB,GAE3J,CAEI,MAAM,IAAKtd,MAAM,gCAEzB,CACK,GAAIm2B,EAAOC,EAAM,EAAI,CACtB,MAAMC,EAAe,GAAQtuB,GAC7B,GAAIsuB,aAAwBqU,GAAe,CACvC,GAAMY,EAAMT,GAAyBxU,IAAuB,MAAPiV,GAAiBC,EAAOD,EAAMC,aAAgBb,GAAiBI,GAA0BS,GAAQ,GAAM,GAAOnV,EAAM,EAAI,CACzK,MAAME,EAAe,GAAQuU,GAAyBxU,IACtD,GAAIC,aAAwBoU,GACxB,OAAOQ,GAAiBA,GAAiBN,GAAwBvU,GAAeoU,GAAuBpU,GAAeuU,GAAwBtU,IAAgBmU,GAAuBnU,GAAe4U,GAAiBL,GAAyBvU,GAAerzB,EAAG+E,IAGhQ,MAAM,IAAKhI,MAAM,gCAEzB,CAEI,OAAOkrC,GAAiBN,GAAwBvU,GAAeoU,GAAuBpU,GAAe6U,GAAiBL,GAAyBxU,GAAepzB,EAAG+E,GAEzK,CAEI,MAAM,IAAKhI,MAAM,gCAEzB,CAEI,OAAOkrC,GAAiBnjC,EAAI9E,EAAG+E,EAEvC,CAEO,SAASyjC,GAAkBlnC,EAAUoB,EAAGmC,GAC3C,GAAS,MAALA,EAAW,CACX,MAAME,EAAKF,EACL8V,EAAsD,EAAlDrZ,EAASsY,QAAQlX,EAAG8kC,GAAuBziC,IACrD,GAAIA,aAAc0iC,GACd,OAAI9sB,EAAI,EACGwtB,GAAwBK,GAAkBlnC,EAAUoB,EAAGilC,GAAwB5iC,IAAMyiC,GAAuBziC,GAAK6iC,GAAyB7iC,IAEtI,IAAN4V,EACE9V,EAGAsjC,GAAwBR,GAAwB5iC,GAAKyiC,GAAuBziC,GAAKyjC,GAAkBlnC,EAAUoB,EAAGklC,GAAyB7iC,KAGnJ,CACD,MAAM0jC,EAAwD,EAAlDnnC,EAASsY,QAAQlX,EAAG8kC,GAAuBziC,IACvD,OAAI0jC,EAAM,EACCf,GAA8BhlC,OAAGgmC,EAAuB7jC,EAAG,GAErD,IAAR4jC,EACE5jC,EAGA6iC,GAA8BhlC,EAAGmC,OAAG6jC,EAAuB,EAE1E,CACJ,CAEI,OAAOnB,GAA0B7kC,EAEzC,CAgIO,SAASimC,GAAkBlV,EAAcC,EAAOqU,GACnDY,EACA,OAAa,CACT,MAAMrnC,EAAWmyB,EAAc/wB,EAAIgxB,EAAO7uB,EAAIkjC,EAC9C,GAAS,MAALljC,EAAW,CACX,MAAME,EAAKF,EACL8V,EAAsD,EAAlDrZ,EAASsY,QAAQlX,EAAG8kC,GAAuBziC,IACrD,GAAIA,aAAc0iC,GAAe,CAC7B,GAAI9sB,EAAI,EAAG,CACP8Y,EAAenyB,EACfoyB,EAAQhxB,EACRqlC,EAAQJ,GAAwB5iC,GAChC,SAAS4jC,CACb,CACK,GAAU,IAANhuB,EACL,OAAO,EAGP8Y,EAAenyB,EACfoyB,EAAQhxB,EACRqlC,EAAQH,GAAyB7iC,GACjC,SAAS4jC,CAEjB,CAEI,OAAa,IAANhuB,CAEf,CAEI,OAAO,CAGf,CACJ,CAEO,SAASiuB,GAAmBhV,EAAOmU,GACtCa,EACA,OAAa,CACT,MAAM9mC,EAAI8xB,EAAO/uB,EAAIkjC,EACrB,GAAS,MAALljC,EAAW,CACX,MAAME,EAAKF,EACX,GAAIE,aAAc0iC,GAAe,CAC7BmB,GAAmB9mC,EAAG6lC,GAAwB5iC,IAC9CjD,EAAE0lC,GAAuBziC,IACzB6uB,EAAQ9xB,EACRimC,EAAQH,GAAyB7iC,GACjC,SAAS6jC,CACb,CAEI9mC,EAAE0lC,GAAuBziC,GAEjC,CACA,KACJ,CACJ,CAkYO,MAAM8jC,WAAoC,EAC7CvsC,YAAYg4B,EAAOjV,GACftF,QACAtd,KAAK63B,MAAQA,EACb73B,KAAK4iB,QAAUA,CACnB,EAOG,SAASypB,GAA0BtU,GACtCsU,EACA,OAAa,CACT,MAAMxU,EAAQE,EACd,GAAK,GAAUF,GAmBX,OAAO,KAnBY,CACnB,MAAM54B,EAAI,GAAK44B,GACTxE,EAAO,GAAKwE,GAClB,GAAS,MAAL54B,EAAW,CACX,MAAMqtC,EAAKrtC,EACX,GAAIqtC,aAActB,GAAe,CAC7BjT,EAAY,GAAgB,CAACmT,GAAwBoB,GAAKxB,GAA0BC,GAAuBuB,IAAMnB,GAAyBmB,IAAMjZ,GAChJ,SAASgZ,CACb,CAEI,OAAOxU,CAEf,CAEIE,EAAY1E,EACZ,SAASgZ,CAEjB,CAKJ,CACJ,CAEO,SAASE,GAAyBhqC,GACrC,OAAO,IAAI6pC,GAA4BC,GAA0B,GAAY9pC,KAAK,EACtF,CAUO,SAASiqC,GAAsBprC,GAClC,GAAIA,EAAEwhB,QAAS,CACX,MAAMhF,EAAaxc,EAAEy2B,MACrB,GAAI,GAAUja,GACV,OARL,WACH,MAAM,IAAKtd,MAAM,8BACrB,CAMmBmsC,GAEN,GAAwB,MAApB,GAAK7uB,GAEV,OAAOmtB,GADG,GAAKntB,IAIf,MAAM,IAAKtd,MAAM,kEAEzB,CAEI,OAvBD,WACH,MAAM,IAAKA,MAAM,0BACrB,CAqBeosC,EAEf,CA8BO,SAASC,GAA4BpqC,GACxC,IAAInB,EAAImrC,GAAyBhqC,GACjC,MAAO,CACH,uDAAwD,IAC7CiqC,GAAsBprC,GAEjC,6CAA8C,IACnCorC,GAAsBprC,GAEjC,0CAA2C,IArC5C,SAAgCA,GACnC,GAAIA,EAAEwhB,QAAS,CACX,MAAMhF,EAAaxc,EAAEy2B,MACrB,GAAK,GAAUja,GAgBX,OAAO,EAfP,GAAwB,MAApB,GAAKA,GAAqB,CAE1B,GADU,GAAKA,aACEotB,GACb,MAAM,IAAK1qC,MAAM,oEAIjB,OADAc,EAAEy2B,MAAQwU,GAA0B,GAAKzuB,KACjC,GAAUxc,EAAEy2B,MAE5B,CAEI,MAAM,IAAKv3B,MAAM,mEAM7B,CAGI,OADAc,EAAEwhB,SAAU,GACJ,GAAUxhB,EAAEy2B,MAE5B,CAYmB+U,CAAuBxrC,GAElC,yCACIA,EAAImrC,GAAyBhqC,EACjC,EACA/C,UACA,EAER,CA4bO,SAASqtC,GAAsBhoC,EAAUwD,EAAIC,GAChD,OAAU,MAAND,EACU,MAANC,EACO,GAGC,EAGD,MAANA,EACE,EAG0E,EAvclF,SAAqC0uB,EAAc8V,EAAQC,GAC9DC,EACA,OAAa,CACT,MAAMnoC,EAAWmyB,EAAciW,EAAKH,EAAQI,EAAKH,EAC3CnvB,EAAa,CAACqvB,EAAIC,GACxB,GAAK,GAAUtvB,EAAW,IA2arB,OAAI,GAAUA,EAAW,IACnB,GAGC,EA9aR,GAAK,GAAUA,EAAW,IAuatB,OAAO,EAtaP,GAA2B,MAAvB,GAAKA,EAAW,IAChB,GAA2B,MAAvB,GAAKA,EAAW,IAAa,CAC7B,MAAMuvB,EAAO,GAAKvvB,EAAW,IACvBwvB,EAAO,GAAKxvB,EAAW,IAC7B,GAAIuvB,aAAgBnC,GAChB,GAAqC,MAAjCE,GAAwBiC,GAAe,CACvC,KAAIC,aAAgBpC,IAoFf,CACD,MAAMgB,EAAqF,EAA/EnnC,EAASsY,QAAQ4tB,GAAuBoC,GAAOpC,GAAuBqC,IAClF,GAAY,IAARpB,EACA,OAAa,EAANA,EAGPhV,EAAenyB,EACfioC,EAAS,GAAK3B,GAAyBgC,GAAO,GAAKvvB,EAAW,KAC9DmvB,EAAS,QAAKd,EAAuB,GAAKruB,EAAW,KACrD,SAASovB,CAEjB,CA9FI,GAAqC,MAAjC9B,GAAwBkC,GAAe,CACvC,MAAMlvB,EAAmF,EAA/ErZ,EAASsY,QAAQ4tB,GAAuBoC,GAAOpC,GAAuBqC,IAChF,GAAU,IAANlvB,EACA,OAAW,EAAJA,EAGP8Y,EAAenyB,EACfioC,EAAS,GAAK3B,GAAyBgC,GAAO,GAAKvvB,EAAW,KAC9DmvB,EAAS,GAAK5B,GAAyBiC,GAAO,GAAKxvB,EAAW,KAC9D,SAASovB,CAEjB,CACK,CACD,MAAMpW,EAAe,CAACqW,EAAIC,GAC1B,IAAIjoB,EAAyBooB,EAAMC,EAAMC,EAAMC,EAkC/C,OAjCK,GAAU5W,EAAa,IAoBlB,GAAUA,EAAa,IAW7B3R,EAA0B,EAVG,MAAzB,GAAK2R,EAAa,KAClB3R,EAA0B,EAC1BsoB,EAAO,GAAK3W,EAAa,IACzB4W,EAAO,GAAK5W,EAAa,KAGzB3R,EAA0B,EA1BD,MAAzB,GAAK2R,EAAa,KAClB3R,EAA0B,EAC1BooB,EAAO,GAAKzW,EAAa,IACzB0W,EAAO,GAAK1W,EAAa,KAEnB,GAAUA,EAAa,IAW7B3R,EAA0B,EAVG,MAAzB,GAAK2R,EAAa,KAClB3R,EAA0B,EAC1BsoB,EAAO,GAAK3W,EAAa,IACzB4W,EAAO,GAAK5W,EAAa,KAGzB3R,EAA0B,EAoB9BA,GACJ,KAAK,EACD,GAAIqoB,aAAgBtC,GAAe,CAC/BhU,EAAenyB,EACfioC,EAAS,GAAgB,CAAC5B,GAAwBoC,GAAOrC,GAA8BF,GAAuBuC,QAAOrB,EAAuBd,GAAyBmC,GAAO,IAAKD,GACjLN,EAASG,EACT,SAASF,CACb,CAEIhW,EAAenyB,EACfioC,EAAS,GAAgB,MAACb,EAAuBnB,GAA0BC,GAAuBuC,KAASD,GAC3GN,EAASG,EACT,SAASF,EAGjB,KAAK,EACD,GAAIQ,aAAgBxC,GAAe,CAC/BhU,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,CAAC7B,GAAwBsC,GAAOvC,GAA8BF,GAAuByC,QAAOvB,EAAuBd,GAAyBqC,GAAO,IAAKD,GACjL,SAASP,CACb,CAEIhW,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,MAACd,EAAuBnB,GAA0BC,GAAuByC,KAASD,GAC3G,SAASP,EAGjB,KAAK,EACD,MAAM,IAAK1sC,MAAM,6CAG7B,CAcR,KACK,CACD,MAAMmtC,EAAe,CAACR,EAAIC,GAC1B,IAAIQ,EAA2BC,EAAMC,EAAMC,EAAMC,EAkCjD,OAjCK,GAAUL,EAAa,IAoBlB,GAAUA,EAAa,IAW7BC,EAA4B,EAVC,MAAzB,GAAKD,EAAa,KAClBC,EAA4B,EAC5BG,EAAO,GAAKJ,EAAa,IACzBK,EAAO,GAAKL,EAAa,KAGzBC,EAA4B,EA1BH,MAAzB,GAAKD,EAAa,KAClBC,EAA4B,EAC5BC,EAAO,GAAKF,EAAa,IACzBG,EAAO,GAAKH,EAAa,KAEnB,GAAUA,EAAa,IAW7BC,EAA4B,EAVC,MAAzB,GAAKD,EAAa,KAClBC,EAA4B,EAC5BG,EAAO,GAAKJ,EAAa,IACzBK,EAAO,GAAKL,EAAa,KAGzBC,EAA4B,EAoBhCA,GACJ,KAAK,EACD,GAAIE,aAAgB5C,GAAe,CAC/BhU,EAAenyB,EACfioC,EAAS,GAAgB,CAAC5B,GAAwB0C,GAAO3C,GAA8BF,GAAuB6C,QAAO3B,EAAuBd,GAAyByC,GAAO,IAAKD,GACjLZ,EAASG,EACT,SAASF,CACb,CAEIhW,EAAenyB,EACfioC,EAAS,GAAgB,MAACb,EAAuBnB,GAA0BC,GAAuB6C,KAASD,GAC3GZ,EAASG,EACT,SAASF,EAGjB,KAAK,EACD,GAAIc,aAAgB9C,GAAe,CAC/BhU,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,CAAC7B,GAAwB4C,GAAO7C,GAA8BF,GAAuB+C,QAAO7B,EAAuBd,GAAyB2C,GAAO,IAAKD,GACjL,SAASb,CACb,CAEIhW,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,MAACd,EAAuBnB,GAA0BC,GAAuB+C,KAASD,GAC3G,SAASb,EAGjB,KAAK,EACD,MAAM,IAAK1sC,MAAM,6CAG7B,KAEC,MAAI8sC,aAAgBpC,IAoFpB,CACD,MAAM+C,EAAqF,EAA/ElpC,EAASsY,QAAQ4tB,GAAuBoC,GAAOpC,GAAuBqC,IAClF,GAAY,IAARW,EACA,OAAa,EAANA,EAGP/W,EAAenyB,EACfioC,EAAS,GAAKlvB,EAAW,IACzBmvB,EAAS,GAAKnvB,EAAW,IACzB,SAASovB,CAEjB,CA9FI,GAAqC,MAAjC9B,GAAwBkC,GAAe,CACvC,MAAMY,EAAqF,EAA/EnpC,EAASsY,QAAQ4tB,GAAuBoC,GAAOpC,GAAuBqC,IAClF,GAAY,IAARY,EACA,OAAa,EAANA,EAGPhX,EAAenyB,EACfioC,EAAS,QAAKb,EAAuB,GAAKruB,EAAW,KACrDmvB,EAAS,GAAK5B,GAAyBiC,GAAO,GAAKxvB,EAAW,KAC9D,SAASovB,CAEjB,CACK,CACD,MAAMiB,EAAe,CAAChB,EAAIC,GAC1B,IAAIgB,EAA2BC,EAAMC,EAAMC,EAAMC,EAkCjD,OAjCK,GAAUL,EAAa,IAoBlB,GAAUA,EAAa,IAW7BC,EAA4B,EAVC,MAAzB,GAAKD,EAAa,KAClBC,EAA4B,EAC5BG,EAAO,GAAKJ,EAAa,IACzBK,EAAO,GAAKL,EAAa,KAGzBC,EAA4B,EA1BH,MAAzB,GAAKD,EAAa,KAClBC,EAA4B,EAC5BC,EAAO,GAAKF,EAAa,IACzBG,EAAO,GAAKH,EAAa,KAEnB,GAAUA,EAAa,IAW7BC,EAA4B,EAVC,MAAzB,GAAKD,EAAa,KAClBC,EAA4B,EAC5BG,EAAO,GAAKJ,EAAa,IACzBK,EAAO,GAAKL,EAAa,KAGzBC,EAA4B,EAoBhCA,GACJ,KAAK,EACD,GAAIE,aAAgBpD,GAAe,CAC/BhU,EAAenyB,EACfioC,EAAS,GAAgB,CAAC5B,GAAwBkD,GAAOnD,GAA8BF,GAAuBqD,QAAOnC,EAAuBd,GAAyBiD,GAAO,IAAKD,GACjLpB,EAASG,EACT,SAASF,CACb,CAEIhW,EAAenyB,EACfioC,EAAS,GAAgB,MAACb,EAAuBnB,GAA0BC,GAAuBqD,KAASD,GAC3GpB,EAASG,EACT,SAASF,EAGjB,KAAK,EACD,GAAIsB,aAAgBtD,GAAe,CAC/BhU,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,CAAC7B,GAAwBoD,GAAOrD,GAA8BF,GAAuBuD,QAAOrC,EAAuBd,GAAyBmD,GAAO,IAAKD,GACjL,SAASrB,CACb,CAEIhW,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,MAACd,EAAuBnB,GAA0BC,GAAuBuD,KAASD,GAC3G,SAASrB,EAGjB,KAAK,EACD,MAAM,IAAK1sC,MAAM,6CAG7B,CAaJ,CACJ,KACK,CACU,GAAKsd,EAAW,IAA3B,MACMmF,EAAe,CAACkqB,EAAIC,GAC1B,IAAIqB,EAA2BC,EAAMC,EAAI3C,EAAM4C,EAkC/C,OAjCK,GAAU3rB,EAAa,IAoBlB,GAAUA,EAAa,IAW7BwrB,EAA4B,EAVC,MAAzB,GAAKxrB,EAAa,KAClBwrB,EAA4B,EAC5BzC,EAAO,GAAK/oB,EAAa,IACzB2rB,EAAO,GAAK3rB,EAAa,KAGzBwrB,EAA4B,EA1BH,MAAzB,GAAKxrB,EAAa,KAClBwrB,EAA4B,EAC5BC,EAAO,GAAKzrB,EAAa,IACzB0rB,EAAK,GAAK1rB,EAAa,KAEjB,GAAUA,EAAa,IAW7BwrB,EAA4B,EAVC,MAAzB,GAAKxrB,EAAa,KAClBwrB,EAA4B,EAC5BzC,EAAO,GAAK/oB,EAAa,IACzB2rB,EAAO,GAAK3rB,EAAa,KAGzBwrB,EAA4B,EAoBhCA,GACJ,KAAK,EACD,GAAIE,aAAczD,GAAe,CAC7BhU,EAAenyB,EACfioC,EAAS,GAAgB,CAAC5B,GAAwBuD,GAAKxD,GAA8BF,GAAuB0D,QAAKxC,EAAuBd,GAAyBsD,GAAK,IAAKD,GAC3KzB,EAASG,EACT,SAASF,CACb,CAEIhW,EAAenyB,EACfioC,EAAS,GAAgB,MAACb,EAAuBnB,GAA0BC,GAAuB0D,KAAOD,GACzGzB,EAASG,EACT,SAASF,EAGjB,KAAK,EACD,GAAI0B,aAAgB1D,GAAe,CAC/BhU,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,CAAC7B,GAAwBwD,GAAOzD,GAA8BF,GAAuB2D,QAAOzC,EAAuBd,GAAyBuD,GAAO,IAAK5C,GACjL,SAASkB,CACb,CAEIhW,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,MAACd,EAAuBnB,GAA0BC,GAAuB2D,KAAS5C,GAC3G,SAASkB,EAGjB,KAAK,EACD,MAAM,IAAK1sC,MAAM,6CAG7B,KAEC,IAA2B,MAAvB,GAAKsd,EAAW,IAuEpB,CACDoZ,EAAenyB,EACfioC,EAAS,GAAKlvB,EAAW,IACzBmvB,EAAS,GAAKnvB,EAAW,IACzB,SAASovB,CACb,CA5EsC,CACrB,GAAKpvB,EAAW,IAA7B,MACM+Y,EAAe,CAACsW,EAAIC,GAC1B,IAAIyB,EAA2BC,EAAMC,EAAMhD,EAAMiD,EAkCjD,OAjCK,GAAUnY,EAAa,IAoBlB,GAAUA,EAAa,IAW7BgY,EAA4B,EAVC,MAAzB,GAAKhY,EAAa,KAClBgY,EAA4B,EAC5B9C,EAAO,GAAKlV,EAAa,IACzBmY,EAAO,GAAKnY,EAAa,KAGzBgY,EAA4B,EA1BH,MAAzB,GAAKhY,EAAa,KAClBgY,EAA4B,EAC5BC,EAAO,GAAKjY,EAAa,IACzBkY,EAAO,GAAKlY,EAAa,KAEnB,GAAUA,EAAa,IAW7BgY,EAA4B,EAVC,MAAzB,GAAKhY,EAAa,KAClBgY,EAA4B,EAC5B9C,EAAO,GAAKlV,EAAa,IACzBmY,EAAO,GAAKnY,EAAa,KAGzBgY,EAA4B,EAoBhCA,GACJ,KAAK,EACD,GAAIE,aAAgB7D,GAAe,CAC/BhU,EAAenyB,EACfioC,EAAS,GAAgB,CAAC5B,GAAwB2D,GAAO5D,GAA8BF,GAAuB8D,QAAO5C,EAAuBd,GAAyB0D,GAAO,IAAKD,GACjL7B,EAASG,EACT,SAASF,CACb,CAEIhW,EAAenyB,EACfioC,EAAS,GAAgB,MAACb,EAAuBnB,GAA0BC,GAAuB8D,KAASD,GAC3G7B,EAASG,EACT,SAASF,EAGjB,KAAK,EACD,GAAI8B,aAAgB9D,GAAe,CAC/BhU,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,CAAC7B,GAAwB4D,GAAO7D,GAA8BF,GAAuB+D,QAAO7C,EAAuBd,GAAyB2D,GAAO,IAAKjD,GACjL,SAASmB,CACb,CAEIhW,EAAenyB,EACfioC,EAASG,EACTF,EAAS,GAAgB,MAACd,EAAuBnB,GAA0BC,GAAuB+D,KAASjD,GAC3G,SAASmB,EAGjB,KAAK,EACD,MAAM,IAAK1sC,MAAM,6CAG7B,CAMA,CAYR,KACJ,CACJ,CAee0sC,CAA4BnoC,EAAU,GAAYwD,GAAK,GAAYC,GAElF,CA+BO,SAASymC,GAA0BxsC,EAAGsqB,EAAKzrB,GAC9C,IAAIkD,EAAIlD,EACR+qC,IAAoBltC,IAChB4tB,EAAIvoB,GAAKrF,EACTqF,EAAMA,EAAI,EAAK,CAAE,GAClB/B,EACP,CAkCO,SAASysC,GAAoBnqC,EAAUqZ,GAC1C,GAAI,EAAYA,GACZ,OAVD,SAA+BrZ,EAAUshB,GAC5C,OAAO,IAAO,CAACvH,EAAK3Y,IAAM8lC,GAAkBlnC,EAAUoB,EAAG2Y,SAAMqtB,EAAuB9lB,EAC1F,CAQe8oB,CAAsBpqC,EAAUqZ,GAEtC,GAAIA,aAAa,GAClB,OATD,SAA8BrZ,EAAUshB,GAC3C,OAAO,IAAO,CAACvH,EAAK3Y,IAAM8lC,GAAkBlnC,EAAUoB,EAAG2Y,SAAMqtB,EAAuB9lB,EAC1F,CAOe+oB,CAAqBrqC,EAAUqZ,GAErC,CACD,MAAMuZ,EAAK,EAAcvZ,GACzB,IACI,OAnCL,SAAwC8Y,EAAcpB,EAAS8B,GAElE,OAAa,CACT,MAAM7yB,EAAWmyB,EAAcpY,EAAMgX,EAAS3oB,EAAIyqB,EAClD,IAAIzqB,EAAE,6CAOF,OAAO2R,EANPoY,EAAenyB,EACf+wB,EAAUmW,GAAkBlnC,EAAUoI,EAAE,0DAA2D2R,GACnG8Y,EAAQzqB,CAOhB,CACJ,CAoBmBkiC,CAA+BtqC,OAAUonC,EAAuBxU,EAI3E,CAFA,QACI,EAAYA,EAChB,CACJ,CACJ,CAEO,MAAM2X,GACTvvC,YAAYgF,EAAU0zB,GAClBv4B,KAAK6E,SAAWA,EAChB7E,KAAKu4B,KAAOA,CAChB,CACAh5B,cAEI,OAA2C,EA2Q5C,SAAoCilB,GACvC,IAAI9kB,EACA8F,EAAM,EACV,MAAMwe,EAAa,EAAcQ,GACjC,IACI,KAAOR,EAAW,8CAEdxe,EAAmE,GAA1D9F,EAA2B,EAAtB,EADFskB,EAAW,4DACmBxe,GAAO,GAAK9F,EAAK,IAKnE,CAFA,QACI,EAAYskB,EAChB,CACA,OAAuB,EAAhB5U,KAAK4E,IAAIxO,EACpB,CAzRe6pC,CADOrvC,KAElB,CACA2D,OAAOg1B,GAEH,OAAQA,aAAgByW,IAAgI,IAAjHvC,GAAsByC,GAD/CtvC,MAC+EuvC,GAD/EvvC,MAC2GuvC,GAAoB5W,GACjJ,CACAp3B,WAEI,MAAQ,QAAU,GAAK,KAAM,IAAOtC,GAEzB,EADYA,IAFTe,OAIA,GAClB,CACY6kB,IAAPpkB,OAAOokB,eACR,MAAO,WACX,CACAte,OAAO0X,GAEH,OAAO/e,MAAM8a,KADCha,KAElB,CACAwE,UAAUm0B,GAEN,OAA8G,EAAvGkU,GAAsByC,GADnBtvC,MAC+CuvC,GAD/CvvC,MACuEuvC,GAAoB5W,GACzG,CACA,oDAAsD15B,GAClD,MAAM,IAAKqB,MAAM,qBACrB,CACA,mDACI,MAAM,IAAKA,MAAM,qBACrB,CACA,uDAAyDrB,GACrD,MAAM,IAAKqB,MAAM,qBACrB,CACA,yDAA2DrB,GAEvD,OAAOitC,GAAkBoD,GADftvC,MAC2Cf,EAAGswC,GAD9CvvC,MAEd,CACA,2DAA6D6sB,EAAKzrB,GAE9D2tC,GAA0BQ,GADhBvvC,MACwC6sB,EAAKzrB,EAC3D,CACA,4DACI,OAAO,CACX,CACA,uDAEI,OAAiC,EAA1BouC,GADGxvC,KAEd,CACA,+DAEI,OAAiC,EAA1BwvC,GADGxvC,KAEd,CACAQ,gBAEI,OAAOmsC,GAA4B4C,GADzBvvC,MAEd,CACA,CAACS,OAAOC,YACJ,OAAO,EAAWV,KAAKQ,gBAC3B,CACA,iDAEI,OAAOmsC,GAA4B4C,GADzBvvC,MAEd,CACI2P,WAEA,OAAiC,EAA1B6/B,GADGxvC,KAEd,CACA4P,IAAI3J,GAEA,MAAM,IAAK3F,MAAM,wBAErB,CACAklB,QACI,MAAM,IAAKllB,MAAM,wBACrB,CACAmlB,OAAOxf,GACH,MAAM,IAAK3F,MAAM,wBAErB,CACA4B,IAAI+D,GAEA,OAAOwpC,GADGzvC,KACoBiG,EAClC,CACAnC,OAEI,OAAO,IAAO7E,GAAMA,GADVe,KAEd,CACAqD,SAEI,OAAO,IAAOpE,GAAMA,GADVe,KAEd,CACAgG,UAEI,OAAO,IAAOzC,GAAM,CAACA,EAAGA,IADdvD,KAEd,CACA0lB,QAAQrgB,EAAGsgB,GACP,MAAMpjB,EAAIvC,KACV,IAAWf,IACPoG,EAAEpG,EAAGA,EAAGsD,EAAE,GACXA,EACP,EAOG,SAASmtC,GAAgB7qC,EAAU0zB,GACtC,OAAO,IAAI6W,GAAUvqC,EAAU0zB,EACnC,CAEO,SAAS+W,GAAwBK,GACpC,OAAOA,EAAK9qC,QAChB,CAEO,SAAS0qC,GAAoBI,GAChC,OAAOA,EAAKpX,IAChB,CAcO,SAASiX,GAAqBjtC,GACjC,OAAOgpC,GAAoBgE,GAAoBhtC,GACnD,CAEO,SAASktC,GAAoBltC,EAAGnC,GACnC,OAAO8rC,GAAkBoD,GAAwB/sC,GAAInC,EAAOmvC,GAAoBhtC,GACpF,CC9iDO,MAAM,GACT1C,YAAY+vC,EAAO/qC,GACf,MAAM2f,EAAQ,IAAI,EAAU,MAC5BxkB,KAAK6E,SAAWA,EAChB2f,EAAMhd,SAAWxH,KACjBA,KAAKykB,QAAU,IAAKC,IAAI,IACxB1kB,KAAK,YAAc,EACnB,MAAMgkB,EAAa,EAAc4rB,GACjC,IACI,KAAO5rB,EAAW,8CAA8C,CAC5D,MAAMc,EAAOd,EAAW,0DACxB6rB,GAAmBrrB,EAAMhd,SAAUsd,EACvC,CAIJ,CAFA,QACI,EAAYd,EAChB,CACJ,CACYa,IAAPpkB,OAAOokB,eACR,MAAO,SACX,CACAte,OAAO0X,GAEH,OAAO/e,MAAM8a,KADCha,KAElB,CACA,iDAEI,OAAO,EADOA,KAElB,CACAQ,gBAEI,OAAO,EAAc,GADPR,KACoBykB,QAAQphB,UAC9C,CACA,CAAC5C,OAAOC,YACJ,OAAO,EAAWV,KAAKQ,gBAC3B,CACA,oDAAsDskB,GAElD+qB,GADc7vC,KACY8kB,EAC9B,CACA,mDAEIgrB,GADc9vC,KAElB,CACA,yDAA2D8kB,GAEvD,OAAOirB,GADO/vC,KACwB8kB,EAC1C,CACA,2DAA6D1I,EAAO8I,GAEhE,IAAe,CAAC9jB,EAAG6L,KACfmP,EAAM8I,EAAa9jB,GAAK6L,CAAC,GAFfjN,KAIlB,CACA,uDAEI,OAAmC,EAA5BgwC,GADOhwC,KAElB,CACA,4DACI,OAAO,CACX,CACA,uDAAyD8kB,GAErD,OAAOmrB,GADOjwC,KACsB8kB,EACxC,CACInV,WAEA,OAAmC,EAA5BqgC,GADOhwC,KAElB,CACA4P,IAAI3J,GAGA,OADA4pC,GADc7vC,KACYiG,GADZjG,IAGlB,CACAwlB,QAEIsqB,GADc9vC,KAElB,CACAylB,OAAOxf,GAEH,OAAOgqC,GADOjwC,KACsBiG,EACxC,CACA/D,IAAI+D,GAEA,OAAO8pC,GADO/vC,KACwBiG,EAC1C,CACAnC,OAEI,OAAO,IAAK7E,GAAMA,GADJe,KAElB,CACAqD,SAEI,OAAO,IAAKpE,GAAMA,GADJe,KAElB,CACAgG,UAEI,OAAO,IAAKzC,GAAM,CAACA,EAAGA,IADRvD,KAElB,CACA0lB,QAAQrgB,EAAGsgB,GACP,MAAMnB,EAAQxkB,KACd,IAASf,IACLoG,EAAEpG,EAAGA,EAAGulB,EAAM,GACfA,EACP,EAWJ,SAAS0rB,GAA4B1rB,EAAOve,GACxC,MAAMzD,EAAoC,EAAhCgiB,EAAM3f,SAAStF,YAAY0G,GACrC,IAAI2X,EACAiI,EAAS,KAIb,OAHAjI,EAAa,CAAC,GAAY4G,EAAMC,QAASjiB,EAAG,IAAI,GAAU,IAAMqjB,IAAStiB,IACrEsiB,EAAStiB,CAAC,KACTsiB,GACDjI,EAAW,GACJ,EAAC,EAAMpb,EAAGob,EAAW,GAAGkI,WAAWqqB,GAAQ3rB,EAAM3f,SAASlB,OAAOsC,EAAGkqC,MAGpE,EAAC,EAAO3tC,GAAI,EAE3B,CA8BO,SAASstC,GAAetrB,GAC3BA,EAAMC,QAAQe,OAClB,CAEO,SAASwqB,GAAmBxrB,GAC/B,IAAIpiB,EAAQ,EACR4hB,EAAa,EAAcQ,EAAMC,QAAQphB,UAC7C,IACI,KAAO2gB,EAAW,8CAEd5hB,EAAUA,EADI4hB,EAAW,0DACD3iB,OAAU,CAK1C,CAFA,QACI,EAAY2iB,EAChB,CACA,OAAe,EAAR5hB,CACX,CAEO,SAASytC,GAAmBrrB,EAAOve,GACtC,MAAM2X,EAAasyB,GAA4B1rB,EAAOve,GACtD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EACD,OAAO,EAEX,KAAK,EACD,OAAIrH,EAAW,IACS,GAAgB4G,EAAMC,QAAS7G,EAAW,IAAI/F,KAAK5R,IAChE,IAGPue,EAAMC,QAAQtiB,IAAIyb,EAAW,GAAI,CAAC3X,KAC3B,GAIvB,CAEO,SAAS8pC,GAAwBvrB,EAAOve,GAC3C,MAAM2X,EAAasyB,GAA4B1rB,EAAOve,GACtD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EACD,OAAO,EAEX,KAAK,EACD,OAAO,EAGnB,CAEO,SAASgrB,GAAsBzrB,EAAOve,GACzC,MAAM2X,EAAasyB,GAA4B1rB,EAAOve,GACtD,IAAIgf,EAYJ,OATQA,EAFJrH,EAAW,IACPA,EAAW,IAAM,EACS,EAOJ,EAEtBqH,GACJ,KAAK,EAED,OADA,GAAgBT,EAAMC,QAAS7G,EAAW,IAAIhX,OAAOgX,EAAW,GAAI,IAC7D,EAEX,KAAK,EACD,OAAO,EAGnB,C,SCjPwB,IAAS,+DAAT,G,qIA6BC4D,G,OAAAA,EAAAA,K,cAEQ,8B,cAErB,GAAE,WAAO,GAAT,aACE,WAAO,GADT,aAEE,YAFF,mC,eAHU,K,aAqBCA,G,OAAAA,EAAAA,K,cACkBulB,EAAAA,OAAAA,GAAAA,W,cAChB,Y,4BAYDqJ,GAEd,GADIA,M,SApBSA,G,eACT,IAAAA,EAAA,kBAAAA,EAAA,U,qBACuBA,E,eAkBvB,CAAAA,G,OACe,U,OACnBC,E,SAZa7uB,G,MACqB9c,EAAKtE,EAD1B,gC,SAAA,GACN,IADM,GACN,iBADM,iBACN,uBADM,SACN,c,QAAA,C,MAAoBkwC,EAAA,GADd,GACN,kBADM,cACN,kB,IADM,MACN,uB,IAA2B5rC,EADrB4rC,EAC0BlwC,EAD1B,GACN,sB,2DAAiDsE,EAAKtE,G,eAW7D,CAFIgwC,GAEJ,GAFI,S,MAEI1rC,EAFJ,KAEStE,EAFT,K,OAEyB,SAAoBsE,EAAKtE,E,QACtDmwC,E,SATc/uB,G,MACqB9c,EAAYguB,EAAMoC,EAAb10B,EAD1B,gC,SAAA,GACP,IADO,GACP,iBADO,kBACP,uBADO,SACP,c,QAAA,C,MAAqBowC,EAAA,GADd,GACP,kBADO,cACP,mBADO,MACP,uBADO,MACP,2BADO,MACP,8B,IAAA,IADO,GACP,sCADO,MACP,mC,IAA4B9rC,EADrB8rC,EACiC9d,EADjC,GACP,yBAA8CoC,EADvC,GACP,6BAAiC10B,EAD1B,GACP,sB,2DACCsE,EAAKtE,EAAOsyB,EAAMoC,G,eAO1B,CAHIsb,GAGJ,GAHI,Q,OAAA,C,MAGK1rC,EAHL,KAGiBguB,EAHjB,KAGuBoC,EAHvB,KAGU10B,EAHV,KAIIwd,EAAAA,CAAA,GAAY8U,GAAM,GAAYoC,I,MAC7B2b,EAAcC,E,OADf,wB,IACCD,EAAL,KAAmBC,EAAL,M,qBACN,SAAoBhsC,EAAKtE,EAAOqwC,EAASC,G,8BAIlCnY,G,OACrB,GACI,S,IAAM3a,EACUlZ,EAAWtE,E,OAD3B,IAAMwd,EAAAA,CAAA,GAAY,IAAI2a,GAAM,GAAY,IAAIA,IAAtC,sCACU7zB,EADV,eACqBtE,EAAL,KAF1B,IAEyCsE,EAAKtE,KACnC,MAEP,S,IAAMwd,EACU8U,E,OADhB,IAAM9U,EAAA,GAAY,OAAO2a,GAAnB,oBACU7F,EADV,YAC0B,GAAgBA,IACzC,MAED,S,MAAA9U,EAAA,GAAY,QAAQ2a,G,MACVzD,E,OADV,oB,IACUA,EADV,a,qBAC2B,GAAgBA,G,cAC1C,K,yBAGa6b,G,OACxB,GACI,S,IAAM/yB,E,OAAN,IAAMA,EAAA,GAAY,OAAO+yB,GAAnB,QAEI,KAHd,GAAA/yB,IAKU,S,MAAAA,EAAA,GAAY,OAAO+yB,G,MACTtzB,E,OADV,oB,IACUA,EADV,a,qBAC0B,GAAmBA,G,cAC5C,K,qBAICmE,G,OAAAA,EAAAA,K,+DAOY,E,eACjB,E,aAMUA,GAAA,oB5B+kBFnF,E4B3kBQgD,GAAgC,IAAxB,oB,SARpBmC,GAAA,iB,CAQiD,CAAS,YAAgB,K5B4XtF,SAAgBnF,EAAWtC,GAC9B,MAAM9M,EAAI,GAAM8M,GAChB,IACI,IAAI62B,GAAQ,EACZ,MAASA,GAAU3jC,EAAE,8CACjB2jC,EAAQv0B,EAAUpP,EAAE,2DAExB,OAAO2jC,CAIX,CAFA,QACI,EAAY3jC,EAChB,CACJ,CAoMY,EAAQhO,IAAQod,EAAUpd,I4B9kBtB,mB5B6kBT,IAAgBod,C,a4BvkBJmF,GAAA,iB,aAIDjL,GACV,OAAiB,IAAjBA,EAAA,QAAiB,MAAQ,GAAAA,EAAe,I,aAEzBA,G,MAAiB,IAAOA,EAAQ,G,aAEjCA,G,OxCiWf,SAAmBjV,EAAKuvC,EAAYxvC,GACvC,GwCjWoB,GxCiWDA,GAAU,GAAKC,EAAID,OAClC,MAAM,IAAIf,MAAM,oCAEpB,OAAiB,MAAVe,EAAiBC,EAAI+H,OwCpWR,ExCoW2BhI,GAAUC,EAAI+H,OwCpWzC,ExCqWxB,CwCrWQ,CAAAkN,EAAgB,EAAGA,EAAM,OAAS,E,sBA0Gfu6B,EAIAA,EAkBRC,EA4LC1tC,EAoIiCk1B,EA/BDA,E,gBA/Z5BhiB,EAAAA,EAAcy6B,EAAAA,EACxBpzB,EAAAA,CAAArH,EAAOy6B,G,MACH5wC,E,OADJ,2B,IACIA,EADJ,gB,MAAA,4BAEiD,QAAlB,mC,qBADIA,E,cAC8B,I,cAC7DA,EACAA,E,OAJJ,2B,IAGIA,EAHJ,gB,EAAA,cAKmD,QAAlB,mC,IALjC,4B,IAIIA,EAJJ,gB,wBAG0CA,G,cACIA,E,cACqB,I,cAC/DA,EAEAA,EACFA,EAEEA,EACAA,EACAA,EAEAA,EACAA,EAEAA,EAEAA,EACAA,EACAA,EACAA,EAEAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACAA,EACqB6wC,EAArB7wC,EAiBqB8wC,EAArB9wC,EAKsB8wC,EAAtB9wC,EAYR+wC,EAEQ/wC,EACAA,EACAA,EACAA,GACAA,GAEAA,GACAA,GAEAA,GAEAA,GACAA,GAKAA,GACAA,GACAA,GAKwBgxC,GAAxB/tC,GA0FR6jC,GAA2BmK,G,OAtLvB,2B,IAMIjxC,EANJ,8B,IAWIA,EAXJ,8B,IAYIA,EAZJ,8B,IAeIA,EAfJ,+B,IAkBIA,EAlBJ,+B,IAoBIA,EApBJ,+B,KAsBIA,EAtBJ,8B,KA0BIA,EA1BJ,8B,KA4BIA,EA5BJ,8B,KA8BIA,EA9BJ,+B,KAgCyB6wC,EAhCzB,eAgCI7wC,EAhCJ,+B,KAsD0B8wC,EAtD1B,eAsDI9wC,EAtDJ,+B,KAkEJ+wC,EAlEI,qB,KAoEI/wC,EApEJ,+B,KAqEIA,EArEJ,+B,KAwEIA,GAxEJ,+B,KA0EIA,GA1EJ,+B,KA6EIA,GA7EJ,+B,KA+EIA,GA/EJ,+B,KAsFIA,GAtFJ,+B,KAuFIA,GAvFJ,8BAsLgD,EAtLhD,KAsL6D,W,WAAjE8mC,GAtLI,KAsLuBmK,GAtLvB,gB,KAAA,2B,IAQIjxC,EARJ,8B,IAaIA,EAbJ,8B,IAgBIA,EAhBJ,+B,KAqBIA,EArBJ,+B,KAuBIA,EAvBJ,8B,KAyBIA,EAzBJ,8B,KA2BIA,EA3BJ,8B,KA6BIA,EA7BJ,+B,KA+BIA,EA/BJ,+B,KAiDyB8wC,EAjDzB,eAiDI9wC,EAjDJ,+B,KAkEJ+wC,EAlEI,qB,KAsEI/wC,EAtEJ,+B,KAuEIA,GAvEJ,+B,KA2EIA,GA3EJ,+B,KAgFIA,GAhFJ,+B,KAqFIA,GArFJ,8BAsLgD,EAtLhD,KAsL6D,W,WAAjE8mC,GAtLI,KAsLuBmK,GAtLvB,gB,KAAA,2B,IASEjxC,EATF,+B,KAkEJ+wC,EAlEI,oBAsLgD,EAtLhD,KAsL6D,W,WAAjEjK,GAtLI,KAsLuBmK,GAtLvB,gB,KAAA,0B,KAAA,a,KAAA,e,KAkEJF,EAlEI,M,EAAA,c,MAAA,4B,KAkEJA,EAlEI,qB,KA4F4BC,GA5F5B,eA4FI/tC,GA5FJ,8BAsLgD,EAtLhD,KAsL6D,W,WAAjE6jC,GAtLI,KAsLuBmK,GAtLvB,gB,KAAA,e,KAkEJF,EAlEI,oBAsLgD,EAtLhD,KAsL6D,W,WAAjEjK,GAtLI,KAsLuBmK,GAtLvB,gB,yBAM8CjxC,G,cAEV,WAAcA,G,cAClBA,E,cAEI,GAAIA,EAAAA,KAAAA,EAAAA,I,cACAA,E,kCACYA,G,cAEhBA,E,cACQA,EAAAA,W,cAEXwnC,GAAA,OAAIxnC,G,cAEC,OAAQA,G,eACR,OAAQA,G,eACV,GAAMA,EAAAA,KAAAA,EAAAA,I,eACAA,EAAAA,MAAAA,OAAAA,M,eAEEA,MAAAA,E,eACP,GAAOA,EAAAA,KAAAA,EAAAA,I,eACAA,IAAAA,E,eACP,GAAOA,EAAAA,KAAAA,EAAAA,I,kBACAA,GAAAA,G,eACP,GAAOA,EAAAA,KAAAA,G,eACL,WAAcA,G,eAEnD6lB,EAAiCgrB,IAAhCK,EAAD,KAAiBC,EAAjB,K,OACED,EAAAA,K,YAEI1zB,EAAAiI,EAAAA,EAAA,GAAAjI,EAAAA,CAAA,GAAexd,EAAAA,KAAAA,EAAAA,GAAAA,IAAAA,GAAAA,IAAfylB,IAAAA,IAAAA,EAAAA,EAAAA,CAAAA,KAAAA,GAAA,K,OAEF,K,OAEAmhB,EAAoE,EAAAuK,G,OAApE,GAAU,wDAAV,CAA8DnxC,EAA9D,CAAA4mC,E,eAEEppB,EAAAiI,EAAAA,GAAAA,GAAA,GAAAjI,EAAAA,CAAA,GAAexd,EAAAA,KAAAA,EAAAA,EAAAA,IAAAA,GAAAA,IAAfylB,IAAAA,IAAAA,EAAAA,CAAAA,KAAAA,GAAA,K,OAEF,K,OAEAmhB,EAAoE,EAAAuK,G,OAApE,GAAU,wDAAV,CAA8DnxC,EAA9D,CAAA4mC,E,iBAEJA,EAA0E,EAAAuK,G,OAA1E,GAAU,8DAAV,CAAoEnxC,EAApE,CAAA4mC,E,kBAEoBkK,IAClB9wC,E,eAIF8I,EAAW,IACT,YAAAA,EAAA,IAEC,0EAAgBsoC,GACP,GAAyBpxC,GACzB,uCAAqBA,EAAAA,WACtB,GAAU,iDAAV,CAAuDA,EAAvD,CAAA8I,E,mDAKsB,GAAyBioC,G,eAEzB,GAAM/wC,EAAAA,KAAAA,G,eACN,GAAKA,EAAAA,KAAAA,EAAAA,G,eACAA,IAAAA,E,eACEA,GAAAA,IAAAA,KAAAA,I,eACN,GAAMA,GAAAA,KAAAA,EAAAA,G,eAEL,GAAiBA,I,eXvK1CgB,EWwKiC,WAAchB,KXvK7D,YD8V+B0sB,EC7VD,GAAY1rB,GAAG,EAAO,GD8VxD,GAAQ0rB,EAAG,GAAS,EAAG,GAAG,KAAW,EAC9BuZ,GAA0B,EAAGC,GAAyBjC,GAAqBvX,KAE7E,GAAOA,EAAG,GAAS,EAAG,YAAY,IAChCuZ,IAA2B,EAAGC,GAAyB,GAAiBjC,GAAqB,GAAS,WAAY,YAAY,IAAS5D,MAGvI4F,IAA2B,EAAGC,GAAyBjC,GAAqB/wB,GAAiBwZ,OClW7F,GAA2B1rB,G,eWqKW,GAAehB,I,eAET,GAAqBA,I,eAG7DkpC,GAD4BlpC,IAC5B,MADc,WAAcA,KAAAA,IAAAA,G,eAIM,KAA4BA,I,eAC5B,GAAwB,GAAIA,GAAAA,KAAAA,EAAAA,K,eAC5B,GAAU,GAAMA,GAAAA,KAAAA,I,eAMrD6lB,EAAqBmrB,KAAbK,EAAR,KAACprC,EAAD,KACEuX,EAAA,GAAWva,I,MACbquC,EAAiBruC,EA2BjBquC,EAAmBtB,EA5BjB,MAAAxyB,G,SAAA,GACJA,IADI,GACJA,GAAAA,GAAAA,IADI,MACJA,K,IAAE8zB,EADE,GACJ9zB,GAAAA,GAAmBva,EADf,GACJua,GAAAA,GAAAA,OAAAA,I,eA2BY+zB,EA1ND,KAAAnwB,EA8LP,GACJ5D,GAAAA,IA/LW,S,EAEP4D,EA4LA,eACJ5D,K,IA2BE8zB,EA5BE,GACJ9zB,GAAAA,GA2BqBwyB,EA5BjBuB,G,4BAICnwB,EADA,IAAmBnC,GAAQ,aAAgBqyB,GAD9CrrC,GAEG,W,OAGSurC,EAAgB,GAAc,KADlB,IAAevyB,GAAQ,GAAQ,aAAR,CAAiB,aAAehZ,IAEvE2gC,EAAyF,EAAAyK,G,OAAzF,GAAU,0EAAV,CAAgFC,EAAhF,CAAA1K,EAAA,CAAwG4K,E,CAJ7G,GAKQd,EAALtvB,EAAuD,IAAnC,oBAAwC,GAAUsvB,EAAUe,UAAW,K,MAAtFf,EAALtvB,E,OAEE,GAAsB,QADH,GAAY,SAAOne,GAAQ,YAAqB,K,QAGhEytC,E,OATR,SASQA,EAALtvB,EAAuD,IAAnC,oBAAwC,GAAS,YAAqB,K,IAArFsvB,EAALtvB,G,0BAEE,GAAsB,QADM,GAAY,SAAOne,GAAQ,YAAqB,M,OAVjF,Y,MAaQytC,EACHtvB,EAAA,GAAsC,IAAnC,qBACS,GAAU,YAAqB,KACpC,qBAAoC,GAAYne,GAAAA,C,MAClDyuC,EAAuKzuC,EAAZ,GAAYA,GAAvK2jC,EAAwH,qBAAxH,GAAU,8FAAV,CAAoG,WAApG,CAAAA,EAAA,CAAA8K,E,QAKL,GAAsB,OADf,IAAgB5lB,GAAqB,GAArB,YADhB,GAAU,YADb,GAAa7oB,K,CAnBtB,iC,gBA2BA0uC,EADA,IAAmB1yB,GAAQ,aAAgBqyB,GAD9CrrC,G,MAG0C2rC,EAAjBN,EAA0CO,E,OADhE,SAAAlB,EAAA,iBAAAA,EAAAA,OAAA,a,SACuCiB,EADvC,OACsBN,EADtB,WACgEO,EADhE,iB,qBAEK,GAAsBD,EAAU,CAAG,CAAMz7B,GAAAy6B,GAAA,GAAAz6B,EAAAy6B,GAAN,CAAiBZ,EAAjB,CAAsB6B,K,cAIrDL,EAAgB,GAAc,KADlB,IAAevyB,GAAQ,GAAQ,aAAR,CAAiB,aAAehZ,IAEvE2gC,EAAyF,EAAAyK,G,OAAzF,GAAU,0EAAV,CAAgFC,EAAhF,CAAA1K,EAAA,CAAwG4K,E,UAtC9G,IAyCW,GAAgB,MAAMvuC,MAAU,GAAgB,SAASA,KAA6B,IjBgnCxGk2B,GiBhnC+Fl2B,IAzCxF,IAsDW,GAAe2tC,GAAAA,C,MAExBkB,EAEG,IAAkBC,GAAW,GAAgBA,EAAQ9uC,KAHvC,IAAC,aAAc,YAAa,WAK3C,SAAA6uC,EAAA,C,MAIEE,EjB89Bb9Y,GiB99BgEj2B,GAAnD6uC,GACE,OAAAE,EAAA,K,MACIC,EACF,YAAAC,EAEG,IAAiBjzB,GAAQ,2BAAmCgzB,EAAmB,eADlFhsC,GAGE,SAAAisC,EAAA,C,MAGCjzB,EAICizB,E,OACJ,GAAsB,QADF,GAAY,SAAQjvC,IAAS,YAAgB,K,QALjE2c,EAA6E,EAAAyxB,G,OAA7E,GAAU,uEAAV,CAAAzxB,EAAA,CAA4FqyB,E,SAQhGryB,EAAgK,EAAAyxB,G,OAAhK,GAAU,0JAAV,CAAAzxB,E,SAnBJA,EAA2L,EAAAyxB,G,OAA3L,GAAU,qLAAV,CAAAzxB,E,SAsBAuyB,EAAiB,eApFnB30B,GAqFE40B,EAAe,eAAkBnsC,G,OACrC,GAAU,gDAAV,CAAsDksC,EAAtD,CAAqEC,E,EA7C8B,C,MAC7F50B,EAAAA,CAAA,GAAY,MAAMva,IAAQ,GAAY,SAASA,K,MACrCovC,EAAyBC,E,OADnC,oD,IACUD,EADV,eACmCC,EADnC,gB,qBAEE5B,EAAYzqC,IAAWosC,G,OAM3B,GAAsB,OAFf,KAAgB76B,EAAMxX,IAAS,GAAWA,EAAO,YAAqBwX,KADtE,GADH86B,I,eAMJ1L,EAA+F,GAAAyK,GAA/FzxB,EAAyD,GAAqB,SAAQ3c,K,OAAtF,GAAU,kDAAV,CAAA2c,EAAA,CAAAgnB,E,mCAuCR,GAD4B,GAAWE,GADpB,O,eAGb9mC,EAEAA,EAGA4gB,EAcA0wB,EAAyBN,E,OA7M7B,4B,IA0LIhxC,EA1LJ,+BA6M2C,GA7M3C,iB,IA6MIsxC,EA7MJ,eA6M6BN,EA7M7B,gB,IAAA,4B,IA4LIhxC,EA5LJ,gB,IAAA,6B,IA+LI4gB,EA/LJ,gB,wBA0LuD5gB,G,cAElBA,KAAWA,GAAXA,EAAAA,G,cAInCiC,EAAIqC,GAAM,GAAYA,EAAIsc,GAG3B2xB,EADA,IAAY1zC,GAAAA,GADf,IAAE,EAAI,OAAO,EAAI,QAAQ,EAAI,e,MAGAmO,EAAbD,E,OADb,GAAAwlC,G,IACGA,IADH,GACGA,GAAAA,IADH,MACGA,I,IAAAA,IADH,GACG,GAAAA,IAAAA,IADH,MACG,GAAAA,K,IAAAA,IADH,GACG,MAAAA,KAAAA,KADH,MACG,MAAAA,O,IAAuBvlC,EAD1B,GACG,GAAAulC,IAAAA,OAAAA,GAAUxlC,EADb,GACGwlC,GAAAA,OAAAA,I,6BAIE,GADoB,IAFL,KAA0BxlC,GACzB,KAA0BC,IAAAA,YAEN,G,cAEjC,GAAU,6F,eAIjB6Y,EAAyB,IAAxB2sB,EAAD,KAGDC,EADA,IAAmBxzB,GAAQ,aAAgB,GAAaqyB,IAD3DkB,GAEG,Y,MAIShB,EAAgB,GAAc,KADlB,IAAevyB,GAAQ,GAAQ,aAAR,CAAiB,aAAeuzB,IAEvE5L,EAAyF,EAR7F,M,OAQI,GAAU,0EAAV,CAAgF0K,EAAhF,CAAA1K,EAAA,CAAwG4K,E,QAJrE,GAAP,U,eAO9BF,EAAyBN,EAUS0B,EAAlCC,EAIDC,EAA0B5B,EAqCH6B,EAAvB5vC,EAOsB4vC,EAAtB5vC,EAO2B4vC,EAA1BtC,EAOoBsC,EAArB5vC,EAOqB4vC,EAArB5vC,EAKA+Y,EAAsB82B,EAQrBlyB,EAAsBowB,EAkCFA,EAArB+B,EAoB4B/B,EAA5B+B,EAgBCnyB,EAA0BowB,EAgBHgC,EAAxBxD,EAcmBwB,EAAlB9tC,EA4EQ8vC,E,OAreZ,4B,IAyNI1B,EAzNJ,eAyN6BN,EAzN7B,+B,IAmOsC0B,EAnOtC,eAmOIC,EAnOJ,+B,KAqeYK,EAreZ,gB,KAAA,4B,IAuOGJ,EAvOH,eAuO6B5B,EAvO7B,+B,IA4Q0B6B,EA5Q1B,eA4QG5vC,EA5QH,+B,IAmRyB4vC,EAnRzB,eAmRG5vC,EAnRH,+B,IAiSwB4vC,EAjSxB,eAiSG5vC,EAjSH,+B,IAwSwB4vC,EAxSxB,eAwSG5vC,EAxSH,+B,IA6SG+Y,EA7SH,eA6SyB82B,EA7SzB,+B,KAuVwB9B,EAvVxB,eAuVG+B,EAvVH,+B,KA2W+B/B,EA3W/B,eA2WG+B,EA3WH,+B,KA2Y2BC,EA3Y3B,eA2YGxD,EA3YH,+B,KAqeYwD,EAreZ,gB,KAAA,4B,IA0R8BH,EA1R9B,eA0RItC,EA1RJ,+B,IAqTI3vB,EArTJ,eAqT0BowB,EArT1B,+B,KA2XIpwB,EA3XJ,eA2X8BowB,EA3X9B,+B,KAyZsBA,EAzZtB,eAyZI9tC,EAzZJ,+B,KAqeY8vC,EAreZ,gB,KAAA,e,KAqeYA,EAreZ,gB,sBA0NEntB,EAAyB,IAAxB2sB,EAAD,KAGDS,EADA,IAAmBh0B,GAAQ,aAAgBqyB,GAD9CkB,GAEG,Y,MAIShB,EAAgB,GAAc,KADlB,IAAevyB,GAAQ,GAAQ,aAAR,CAAiB,aAAeuzB,IAEvE5L,EAAyF,EAR7F,M,OAQI,GAAU,0EAAV,CAAgF0K,EAAhF,CAAA1K,EAAA,CAAwG4K,E,QAJrE,GAAP,U,UAMxB,GAAiBmB,G,EAAkB/B,EAA/C,W,cAII/qB,EAAqB,IAApB5f,EAAD,K,MAGQqrC,EAWFA,EAAYruC,EAiBpBiwC,E,OA9BI,GAAAN,I,IA8BJM,EA9BIN,GAEJA,IAFI,GAEJA,GAAAA,IAFI,MAEJA,K,IAAUtB,EAFN,GAEJsB,GAAAA,OAAAA,K,IAWQtB,EAbJ,GAEJsB,GAAAA,OAAAA,GAWoB3vC,EAbhB,GAEJ2vC,K,IA4BAM,EA9BIN,G,iBAKCO,EADA,IAAmBl0B,GAAQ,aAAgBqyB,GAD9CrrC,GAEG,Y,MAMSurC,EAAgB,GAAc,KADlB,IAAevyB,GAAQ,GAAQ,aAAR,CAAiB,aAAehZ,IAEvE2gC,EAA2F,EAbnG,M,OAaQ,GAAU,4EAAV,CAAkF0K,EAAlF,CAAA1K,EAAA,CAA0G4K,E,QAJ1G,uBAAO,GAAP,U,eAQL4B,EADA,IAAmBn0B,GAAQ,aAAgBqyB,GAD9CrrC,GAEG,Y,MAKkEmgB,EAC7D,YADiBitB,EACjB,WADuCzB,EACvC,O,OAAG,WAAsB,GAAY3uC,IAChC,GAAU,gEAAV,CAAsEowC,GAK3E,GAAsBzB,EADf,IAAgB9lB,GAAqB,GAArB,YADhB,GAAA1F,EADH,GAAanjB,K,QANbuuC,EAAgB,GAAc,KADlB,IAAgBpwB,GAAA,YAA8Bnb,I,OAE9D,GAAU,kDAAV,CAAwDqrC,EAAxD,CAAiEE,E,gBAWrEW,EAAiB,eAAkBe,GACnCd,EAAe,eAAkBnsC,G,OACrC,GAAU,gDAAV,CAAsDksC,EAAtD,CAAqEC,E,iBAGrEkB,EAAcT,I,OAGf,GADA,IAAc7yC,GAAgB,GAAWA,EAAMszC,IADlDrwC,G,eAMIqwC,EAAc,I,OAEf,IAActzC,GAAgB,GAAWA,EAAMszC,IADlDrwC,E,eAMIqwC,EAAc,I,OAGf,IAActzC,GAAgB,GAAWA,EAAMszC,IAF9B,GAAmB/C,G,eAMnC+C,EAAc,I,OFo1CnBhE,GADsB7qC,EEl1CrBxB,C,WFm1CyB2rC,GAAoBnqC,EEl1C1C,IAAczE,GAAgB,GAAWA,EAAMszC,IADlDrwC,I,eAMIqwC,EAAc,I,OACF,IAActzC,GAAgB,GAAWA,EAAMszC,IAAcrwC,E,eAQ1E,IAAgB6oB,GAAuB,GAAvB,YADhB,GAHcgnB,IAEd,GADH92B,K,cAOI6J,EAAqB,IAAb0tB,EAAR,KAAA5uC,EAAA,K,OA+BG,GAAuB4uC,GA5BtBtwC,EAAS,GAAW2d,GAErB,IAAgB2xB,I,MAAqCiB,EAArC,YAAcC,EAAd,YAGZC,EADA,IAAmB5nB,GAAe2nB,IAAf,MADtBxwC,GAEG,YAGW,QAAAuwC,EAAA,I,YAMAG,E,MAIG/zB,EADA,GAAc,KADd,OAAiB,GAAQ,WAAR,CAAP,OADb,GAAWgB,K,IAIXgzB,EALAD,EAIG,GAAQ,aAAR,CAAA/zB,G,MAQAA,EADA,GAAc,KAJd,IAAgB+xB,I,MAAc5rC,EAAd,YACT,4BACiB,GAAQ,qBAAR,CAAyBA,GACzC,GAAQ,qBAAR,CAAyBA,E,GAJpCpB,IADAivC,EAOG,GAAQ,aAAR,CAAAh0B,G,MACP8xB,EAA8J,EAAA6B,G,OAA9J,GAAU,qIAAV,CAA2IE,EAA3I,CAAqJE,EAArJ,CAAAjC,EAAA,CAA8KkC,E,SArB7J,KAAO,GAAP,KAAwBJ,E,GALvD7uC,I,gBA8BAkhB,EAAuB,IAAtBuB,EAAD,KACAjD,EACA,GAAE,YAAI0vB,I,IACuDhnB,E,OACzD,GADY,GAAWgnB,EAAc,OAAQ,IAAYhnB,EAAI,CAAGzF,EAHpE,UAGuGyF,KAAAA,GADjFkmB,M,OAGpB3rB,EAAAA,IAWC,GAFHjD,E,gBAMA0B,EAAqC,IAApCuB,EAAD,KACAjD,EACA,GAAE,YAAI0vB,GAEF,GADY,GAAWA,EAAc,OAAQ,SAAqBzsB,EAHtE,WAEsB2rB,MAItBe,EACM,eACiB,GAAU,I,0BAD3B,UAEiB,GAAU,I,0BAGjBlwB,EAAA,EAA2CO,GAA/D,SAAoB,iD,MAAf+H,EAAe,4DAAqD,GAAA4nB,EAArD,U,UAApB,EAAoBlwB,E,QACdkwB,C,gBAGFjuB,EAAqC,IAApCuB,EAAD,KAIGjD,EADJ,IAAe2H,GAAAA,CAAe,GAAY,SAA3B,MAAwC1E,GAAS,GAAjD,KAHd,QAED,GADHxG,IAIQkzB,EACM,eACgB,GAAU,I,0BAD1B,UAEiB,GAAU,I,0BAGjBlwB,EAAA,EAAAO,GAApB,SAAoB,iD,MAAf+H,EAAe,4DAAS,GAAA4nB,EAAT,U,UAApB,EAAoBlwB,E,QAEdkwB,C,gBAGNhrC,EAAWkqC,IACXe,EACM,eACgB,GAAO,I,0BADvB,UAEiB,GAAO,I,0BAGtBnwB,EAAA,EAAA4rB,GAAZ,SAAY,gDAER,GADmB,GADX,4DAC2B1mC,GACnCirC,E,SAFJ,EAAYnwB,E,QAINmwB,C,gBAGFluB,EAAuB,IAAbwB,EAAV,KAACD,EAAD,KAGE5J,EAAAA,CAAA,GAAY,WAAWta,GAAK,GAAY,OAAOA,I,MACrCuB,EAAwB0zB,E,OADlC,oDACkCA,EADlC,eAC6C,GAD7C,iB,IACU1zB,EADV,eACkC0zB,EADlC,gB,0BAEI3a,EAAA,GAAa,SAAO2a,IAApB,Y,MA0BE6b,EAAY,GAAqB,SAAO7b,I,OAC5C,GAAU,4CAAV,CAAkD6b,E,QAzB9C7vB,EAEG,IAAe2H,I,MAAAxnB,EAAA,K,OAEF,GAASA,GAEL,GAAY,GAAuBA,GAAK8iB,GADxC,GAAY,SAAQ9iB,GAAK8iB,GAElB,GALT,KAK0BC,GAAAA,GAN5C,GADA7J,I,OASE4J,EAAAA,IAWC,GAFHjD,E,gBAUI1f,EAAyB0zB,E,OAhCnC,oDAgCmCA,EAhCnC,eAgC8C,GAhC9C,iB,IAgCU1zB,EAhCV,eAgCmC0zB,EAhCnC,gB,yBAkCU,KADO,GAAY,GAAgBA,K,EACbyY,EAAlC,W,cAKIzsB,EAGG,IAAe2H,I,MAAAxnB,EAAA,K,OAEF,GAASA,GAWN,GAAY,GAAuBA,GAAK8iB,GAT5C,GAAsBA,IAAW,GAAoBA,GAG7C,GAAY,SAAQ9iB,GAAK8iB,GAIzB,GAAY,GAAuB9iB,GAAK8iB,GAGpC,GAdT,KAc0BC,GAAAA,GAfzC,GADHnkB,I,OAmBEkkB,EAAAA,IAWC,GAFHjD,E,oBAMRyiB,EAAgE,GAD9C,KAClBhnB,EAAqC,GAAoBzJ,G,OAAzD,GAAU,8BAAV,CAAAyJ,EAAA,CAAAgnB,E,gBAEAA,EAAiE,eAAkBgK,GAAnFhxB,EAAqC,GAAoBzJ,G,OAAzD,GAAU,8BAAV,CAAAyJ,EAAA,CAAAgnB,E,gBjBkpBL,IKz3BoCla,EUm3CVjoB,EErtDR2c,EXGCpgB,C,UYjEX,SAAeizC,GAC1B,IAAIC,EAAY,2HACZC,EAAO,CACP,KAAM,MACN,KAAM,MACN,KAAM,MACN,KAAM,MACN,KAAM,MACN,IAAK,MACL,KAAM,QAIV,OADAD,EAAU/8B,UAAY,EACf+8B,EAAUjpC,KAAKgpC,GAClB,IAAMA,EAAUvpC,QAAQwpC,GAAW,SAAUrnB,GACzC,IAAI/O,EAAIq2B,EAAKtnB,GACb,MAAoB,iBAAN/O,EAAiBA,EAC3B,OAAS,OAAS+O,EAAEvqB,WAAW,GAAGnB,SAAS,KAAKwX,OAAO,EAC/D,IAAK,IACL,IAAMs7B,EAAY,GAC1B,E,qBDqpB0C1wB,EAEIA,EACMA,EAEdA,EACeA,E,gBAjC/BvjB,EAAAA,EAAO4wC,EAAAA,E,OACfA,EAAAA,K,cAEEpc,EAAwBx0B,EAC5B,OAAG,QACE,OACA,GAAUw0B,E,sBAmMf,O,cA/LA,OAAG,aAAmBx0B,GACjB,GAAU,OACYA,EAAAA,W,cACZ,GAA+BA,G,sEAQXA,G,sBAEpB,MAAoCA,I,uBAKrC,GAAe,EAAYA,I,eAHvB,MAAsCA,I,OACzC,OAAeA,EAAW,OAAY,Q,eACtC,IAAeujB,EAAavjB,EAAbujB,I,eAEX,IAAeA,EAAiBvjB,EAAjB,GAAAujB,EAAiC,O,eAC1C,IAAeA,EAAuBvjB,EAAvB,GAAAujB,EAAuC,O,kBAErDA,EAAiBvjB,ENxpB5C,GAAM,IrCiG4BypC,SAAInoC,SAAJmoC,GC4CpBroC,E0C2gBamiB,G1C1gBOxgB,UD7CIzB,EC6CO,EAAWF,GD5CxD,GAAY,GAAY,GAAY,GAAmBqoC,GAAK,aAAiBnoC,GAAS,MqClGlD,U,eMypBhB,OAAsBiiB,EAAiBvjB,EEpnB3DwpC,GAAiB4K,GFonByB7wB,GEpnBJ,Q,cF+nBrC,IAAM,GAAc,KALb,IAAe3Z,I,MAEdg9B,EAAsC,GADrB,GAA2B5mC,EAAO4J,EAAMyqC,cACEzqC,EAAM0qC,W,OAAjE,GAAQ,eAAR,CAAqB1qC,EAAM2qC,UAA3B,CAAA3N,EAAAA,GALJ,mBAQwC,I,eAGxC0M,EAAc,c,MAOlB,IAFO,GAAc,KADd,IAAazyB,GAAW,GAAUA,EAAQyyB,IAF7CtzC,IAKW,G,gBAGXszC,EAAc,c,MAOlB,IAFO,GAAc,KADd,IAAazyB,GAAW,GAAUA,EAAQyyB,IAF7CtzC,IAKW,G,gBAGXszC,EAAc,c,MAOlB,IAFO,GAAc,KADd,IAAazyB,GAAW,GAAUA,EAAQyyB,IAF7CtzC,IAKW,G,gBAGXszC,EAAc,c,MAOlB,IAFO,GAAc,KADd,IAAezyB,GAAW,GAAUA,EAAQyyB,IAF/CtzC,IAKW,G,gBAGXszC,EAAc,c,MAOlB,IAFO,GAAc,KADd,IAAczyB,GAAW,GAAUA,EAAQyyB,IAF9CtzC,IAKW,G,gBAGXszC,EAAc,c,MAQlB,IAFO,GAAc,KADd,IAAezyB,GAAW,GAAUA,EAAQyyB,IAD5C,GAFHtzC,KAMW,G,gBAGTwd,EAAkBxd,EAAlB,Y,KAEkBwd,G,EAAyB,cAAzB,U,OADd,M,gBAINqI,EAA0B,cAC1BA,EAAqB,GAA2B7lB,EADhD,MACCw0C,EAAD,KAAW7vC,EAAX,KACA6tC,EAGe,WADIvzB,GAAQ,aAAgB,EAAAu1B,KAAAA,UAG/C,GAAGC,GAAU7D,IAAY,a,OACrB,GAAc,EAAA4D,IAClB,GAAwB,IAAnBhC,EAAU,O,MACX,IAAM,GAAc,EAAAgC,IAAgB,KAAO,GAAU7vC,EAAQ,GAAG6tC,EAAW,IAAK,I,OAE5EkC,EAGG,GAAc,KADd,KAAgBl9B,EAAMq6B,IAAY,GAAUltC,EAAQ6S,GAAOq6B,IAD9DW,I,MAIJ,IAAM,GAAc,EAAAgC,IAApB,MAAiDE,EAAmB,K,iBAGpE7uB,EAAuB,cAAtBuB,EAAD,KAEAutB,EAeG,GAAc,KAXd,IAAgB7oB,I,MACX8oB,EAAgB,GADL,KACmBxtB,GAC9BytB,EAAkB,GAFP,KANnB,MAUI,OAAGC,GAAY1tB,IAAWqtB,GAAUrtB,GACxB,GAASwtB,GAEZA,EAAgB,KAAOC,EADtB,GAAUD,GAAiB,KAAOC,EAGxC,IAAMD,EAAgB,KAAOC,EAAkB,G,GAVpD,GAFH70C,KAgBJ,OAAG80C,GAAY1tB,IAAWqtB,GAAUrtB,GAC/B,IAAMutB,EAAmB,IACzB,IAAMA,EAAmB,G,gBAG1B9uB,EAAqC,cAApCuB,EAAD,KACAutB,EAeG,GAAc,KAZd,IAAapwB,I,MACRsB,EAAAA,CAAetB,EAAA,GAAUA,EAAA,IACzBqwB,EAAgB,GADhB,KAC8BxtB,GAC9BytB,EAAkB,GAFlB,KALR,MASI,OAAGC,GAAY1tB,IAAWqtB,GAAUrtB,GACxB,GAASwtB,GAEZ,EAAgB,KAAOC,EADtB,GAAcD,GAAiB,KAAOC,EAG5C,IAAMD,EAAgB,KAAOC,EAAkB,G,GAZvD70C,IAgBJ,OAAG80C,GAAY1tB,IAAWqtB,GAAUrtB,GAC/B,IAAMutB,EAAmB,IACzB,IAAMA,EAAmB,G,gBAG1BI,EAAa,cAEjB,OAAuB,IAApBA,EAAW,OACV,IAAM,GAAU/0C,EAAM+0C,EAAY,IAAK,IAQvC,IAFO,GAAc,KADd,KAAgBv9B,EAAMqJ,IAAW,GAAUA,EAAQk0B,EAAYv9B,KAFlExX,IAKqB,G,wBAO7B,GAAqBA,G,M1CjrB1B,IAAkBoB,ED5CoBqoC,EAAInoC,C,a8CjE9B+Y,EAAQ26B,EAAUC,EAAmBzB,G,IAC5C0B,E,MACM13B,EAAAy3B,EAAKX,U,OAAL92B,EAAAA,K,gBADN03B,EAAAA,CAG+BD,EAAKX,W,cAHpCY,EAI2B,c,cAJ3BA,EAKO,GAAU,+CAAV,CAAqDD,EAAKV,W,MAEjEY,EAAgB,SAA0B,IAC1CC,ExCfL,SAAcp5B,GACjB,GAAqB,IAAjBA,EAAM/a,OACN,MAAM,IAAKf,MAAM,qDAErB,OAAO8b,EAAMA,EAAM/a,OAAS,EAChC,CwCU8B,CAAWi0C,G,IAE7BG,E,MACM73B,EAAAy3B,EAAKX,UAAL,e,MAEI92B,EAAA,mBAAAA,EAAAA,OAAA,aAHV63B,GAKmB,GADU,KAzCnBj0B,EAyCmB,KAJ7Bi0B,EArCU,YAEJ,uB,MAmCNA,GAMe,E,IA3CLj0B,E,MA8CVmK,E,SAnDoBga,EAAO+P,GACzB,SAAAA,EAAA,C,MAEQ11B,E3Cydf,SAAiB1e,KAAQ6oC,GAC5B,OAAwB,IAAjBA,EAAM9oC,OACPC,EAAIq0C,UACJr0C,EAAIwJ,QAAQ,IAAIyP,OAAO,IAAM,GAAO4vB,EAAMjkC,KAAK,KAAO,OAAQ,GACxE,C2C7dsC,CAAhBwvC,EAA4B,K,OAA5B,GAAQ,WAAR,CAAA11B,EAAA,CAAkC2lB,E,QADtCA,C,CAiDA,CADElrB,EAAQm7B,aAAaR,EAASC,EAAKV,WACPl6B,EAAQo7B,SAC5CC,EACM,KAAAR,EAAAA,OAAA,IAAAA,EAAA,eAAAA,EAAAA,OAAA,IAAAA,EAAA,YAAAA,EAAA,aAAAA,EAAA,aAAAA,EAAA,eAAAA,EAAA,QAMNS,EACA,EACK,2BACA,kCAELC,EAAqB,GAAWT,EAAcD,GAE9C1pB,EAAU,GACV,eAAM,eAAgBmqB,IACtB,eAAM,mBAAoB,SAC1B,WAAOt7B,EAAQw7B,cACT,S,MAAAr4B,EAAAnD,EAAQy7B,cAAR,eAEI,KADU,IAAM,gBAANt4B,G,kBAGpBu4B,EACA,GAAG,UAAA17B,EAAA,8B,SA/Dc+G,GAAA,e,MAEX5D,EAAA,iCAEI,sB,QAIC,C,CAuDsC,CAAmB43B,GAAAA,C,IAC5DY,E,MACMx4B,EAAAnD,EAAQ47B,4BAAR,GAAAz4B,MAAA,IAAAA,GAAAA,C,MACC04B,EAAAA,EAAAA,EACC14B,GAAA7U,E,0BAzDFmX,EAAAA,EAClB,IAAG,GAAiCA,GAGpC,OlDsHiB,OADK9X,EkDrHjB8X,GlDsHArY,UAAoBO,EAAEP,SAASxG,OAAS,EkDrHX,GAA9B,EAAA6e,IAEAA,E,EALI,GAAmDA,GAAAA,E,ClDuH5D,IAAuB9X,C,CkDhEW,CAAcwrC,GAHnCwC,EAIQv0B,GAAYy0B,EAAWz0B,EAAXy0B,CAAoBvtC,E,MAJxCqtC,EAKOh2C,GAAAA,EAPf+1C,EASQI,GAAe,cAEf,QzBpBZC,IACerqB,IAAOA,EAAA,aAAoB,aAAa,IAC9CA,GAAAA,CACW,eAAmC,YACvC,WyBoBO,GAAAP,EAHP,EAEO,GAAA2qB,EADH,GAAU5qB,IAKV,GAASA,MAPZnK,I,MAAWi1B,EAWhB,OAXM50B,EAWN,KAAM,SAAA40B,E,OAEF,UAAOL,EAAKv0B,I,OACdiL,EACM2pB,EAAAA,EAAAC,EAAiB,IAAAC,KAAA,CAA2B90B,EAAAA,QAAAA,CAAAA,KAAAA,e,OAChD,SA/GAT,EA+GwCs1B,EA9GxD,IAAgCxqB,I,MACxB3K,EAAS,eACbA,EAAA,OAAqBC,IACd,IAAAD,EAAOiL,YACL,KAAejL,EAAOpa,O,EAE/Boa,EAAA,WAAkBH,EAAK,MAwGN2wB,I,MACDlwB,EAAW,OAAe40B,EADzB1E,GAEDjwB,EAAkB,MAAJgL,EAAa,GAAQ,6DAAR,CAAiEnB,GAAS,GAAQ,iDAAR,CAAqDmB,EAArD,CAAuDnB,G,OAChK,oBAAQ,MAAO,GAAsB9J,EAAUC,EAAU,e,EAAzD,G,QAlHAV,C,iBAqHJrY,EACM,KAAAysC,EAAA,UAAAA,EAAA,IACmC,cAElC,GAAU,2DAAV,CAAiEH,EAAKV,WArCrFwB,EAuCQI,GAAe,cAEf,QzBtDLC,QAAY,GAAUrqB,GAAAA,IAAQ,GAAqBA,EAAIoB,OAAuBpB,EAAIyqB,eyB0DlE,GAAAhrB,EAHP,EAEO,GAAA2qB,EADH,GAAU5qB,IAKV,GAASA,MAPZgnB,I,MAAA9wB,EAAA8wB,EAWC/0B,EAAA,e,OAAAA,G,KAAA,K,MAEEi5B,EAAa,GAAuB,gB,OACxC,UAAO,GAAmBA,EAAW9tC,G,MAHnC,I,OAIG,oBAAQ,MAAO,GAAsB8Y,EAAU,GAAQ,6DAAR,CAAiE8J,GAAK,e,EAArH,I,eACA,oBAAQ,MAAO,GAAsB9J,EAAU,GAAQ,qEAAR,CAA/CjE,EAA+C,CAA2E+N,GAAK,e,EAA/H,I,aAGjB0O,GAAKyc,GAAKC,GAAKC,GAAKC,GAAKC,GAAKC,GAAKC,I,IAUrBx5B,E,MATVy5B,EACD,EACK,GAAW9B,EAAAA,CAAqBlb,EAASyc,EAASC,EAASC,EAAUC,EAAUC,EAAUC,EAAUC,IAAAA,G,OAqB3GjB,EAjBI,MACI1pB,GAAW,EAAe4N,IAEpBzc,EAAA,EAAAo4B,EAAmB,OAAnB,MACQ,GAAkBA,EAAoB,IAD9C,IAQFvpB,GAAW,EART,MAOoB,IAAqB4qB,EAAgB,IAAO,OAAQ,QAAiBrB,EAAoB,MAIzF,GAAkBqB,EADzB,OAAQ,QAAgBrB,MATS,IAGhDvpB,GAAW,EADW,GAAkB4qB,EAAgB,GADzC,OAAQ,QAAgBrB,MAFrC,IAQFvpB,GAAW,EART,MAOoB,IAAqB4qB,EAAgB,IAAO,OAAQ,QAAiBrB,EAAoB,MAIzF,GAAkBqB,EADzB,OAAQ,QAAgBrB,O,ylECpI9Bv7B,EAA2C68B,G,MAChElxB,EAAe,GAAAkxB,GAAAA,cACfC,EAAa9wB,GAAeL,GAC1B,QAAAmxB,EAAA,K,MAEEtxB,EAAuB,cAAd0tB,EAAT,KACA6D,EAAiE,IAAe73B,GAAAA,CAAQ,EAAAA,GAAWA,EAAA,KAAtF,GAAsCg0B,I,OA4C3C,GAAuBA,EA3ChB,GACf,YAAI3pC,I,IACc8iB,EAgCJlP,EA/BFg2B,EACAtgB,E,OAJG,IAEGxG,EAoCH,GAJDlP,EAAA5T,EAAM0qC,UAAN,uBACiB,EADjB,WAGqB,qBAA2B,EAC/C,GzC4ZV+C,EyC/bkDvrB,GAAiB,OAAOliB,EAAM2qC,UAA9B,U,EzC+bzCv4B,EyC/bUo7B,EAAZ5D,EzCgcX,CAAC71B,IACVN,EACA,OAAa,CACT,MAAMrc,EAAI2c,EACV,GAAI3c,GAAKgb,EAAM/a,OACX,OAAO+Z,KAEN,CACD,MAAMwC,EAAa65B,EAAQr7B,EAAMhb,IACjC,GAAkB,MAAdwc,EACA,OAAO,GAAQA,GAGfG,EAAS3c,EAAI,EACb,SAASqc,CAEjB,CAEJ,GAEGA,CAAK,GyCndY6V,EAAK,GAAiB7Y,EAAQ,EAAAk5B,GAAgB3pC,EAAM4pC,GAClD,IAAA9mB,EACMwG,EAAA,KAAAA,CAAA,KAAAA,CAAA,KAAAA,CAAA,KAAAA,CAAA,KAAAA,CAAA,KAAAA,CAAA,KAAAA,CAAA,MADN,IAAAxG,EAEUG,GACZqG,EAAGrG,EAAHqG,CAAGrG,KAAHqG,CAAGrG,KAAHqG,CAAGrG,KAAHqG,CAAGrG,KAAHqG,CAAGrG,KAAHqG,CAAGrG,KAAHqG,CAAGrG,MAHD,IAAAH,EAAA,CAMwB4qB,EAAAC,IADTrkB,EACSokB,EADTpkB,CACSqkB,EADTrkB,CACSqkB,KADTrkB,CACSqkB,KADTrkB,CACSqkB,KADTrkB,CACSqkB,KADTrkB,CACSqkB,KADTrkB,CACSqkB,MANxB,IAAA7qB,EAAA,CAS0B4qB,EAAAC,EAAAC,IADTtkB,EACSokB,EADTpkB,CACSqkB,EADTrkB,CACSskB,EADTtkB,CACSskB,KADTtkB,CACSskB,KADTtkB,CACSskB,KADTtkB,CACSskB,KADTtkB,CACSskB,MAT1B,IAAA9qB,EAAA,CAY4B4qB,EAAAC,EAAAC,EAAAC,IADTvkB,EACSokB,EADTpkB,CACSqkB,EADTrkB,CACSskB,EADTtkB,CACSukB,EADTvkB,CACSukB,KADTvkB,CACSukB,KADTvkB,CACSukB,KADTvkB,CACSukB,MAZ5B,IAAA/qB,EAAA,CAe8B4qB,EAAAC,EAAAC,EAAAC,EAAAC,IADTxkB,EACSokB,EADTpkB,CACSqkB,EADTrkB,CACSskB,EADTtkB,CACSukB,EADTvkB,CACSwkB,EADTxkB,CACSwkB,KADTxkB,CACSwkB,KADTxkB,CACSwkB,MAf9B,IAAAhrB,EAAA,CAkBgC4qB,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,IADTzkB,EACSokB,EADTpkB,CACSqkB,EADTrkB,CACSskB,EADTtkB,CACSukB,EADTvkB,CACSwkB,EADTxkB,CACSykB,EADTzkB,CACSykB,KADTzkB,CACSykB,MAlBhC,IAAAjrB,EAAA,CAqBkC4qB,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,IADT1kB,EACSokB,EADTpkB,CACSqkB,EADTrkB,CACSskB,EADTtkB,CACSukB,EADTvkB,CACSwkB,EADTxkB,CACSykB,EADTzkB,CACS0kB,EADT1kB,CACS0kB,MArBlC,IAAAlrB,EAAA,CAwBoC4qB,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC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","sources":["webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Util.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Types.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Reflection.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Int32.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Numeric.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/lib/long.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Long.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Date.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/RegExp.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/String.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Option.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Global.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Array.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/List.js","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Common.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/MapUtil.js","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Components/Navbar.fs","webpack:///./src/Client/JSInterop.fs","webpack:///./src/Client/output/fable_modules/Fable.Remoting.Client.7.19.0/Types.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/FSharp.Core.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/FSharp.Collections.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Seq.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/MutableMap.js","webpack:///./src/Client/output/fable_modules/Fable.SimpleJson.3.23.0/TypeInfo.Converter.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/AsyncBuilder.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Choice.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Async.js","webpack:///./src/Client/output/fable_modules/Fable.Remoting.Client.7.19.0/Http.fs","webpack:///./src/Client/output/fable_modules/Fable.Remoting.Client.7.19.0/Extensions.fs","webpack:///./src/Client/output/fable_modules/Fable.Parsimmon.4.1.0/Parsimmon.js","webpack:///./src/Client/output/fable_modules/Fable.Parsimmon.4.1.0/Parsimmon.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Double.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Map.js","webpack:///./src/Client/output/fable_modules/Fable.SimpleJson.3.23.0/Parser.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/lib/big.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Decimal.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/BigInt/n.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/BigInt/z.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/BigInt.js","webpack:///./src/Client/output/fable_modules/Fable.SimpleJson.3.23.0/SimpleJson.fs","webpack:///./src/Client/output/fable_modules/Fable.SimpleJson.3.23.0/TypeCheck.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Uri.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/DateOffset.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/DateOnly.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/TimeOnly.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Guid.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/BitConverter.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Set.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/MutableSet.js","webpack:///./src/Client/output/fable_modules/Fable.SimpleJson.3.23.0/Json.Converter.fs","webpack:///./src/Client/output/fable_modules/Fable.SimpleJson.3.23.0/quote.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/TimeSpan.js","webpack:///./src/Client/output/fable_modules/Fable.Remoting.Client.7.19.0/Proxy.fs","webpack:///./src/Client/output/fable_modules/Fable.Remoting.Client.7.19.0/Remoting.fs","webpack:///./src/Client/AppModel.fs","webpack:///./src/Shared/Shared.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Components/Modal.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Heading.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Button.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Icon.fs","webpack:///./src/Client/output/fable_modules/Fable.FontAwesome.2.0.0/FontAwesome.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Container.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Content.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Columns.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Column.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/Input.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/File.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/Label.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/Field.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/Control.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/Checkbox.fs","webpack:///./src/Client/GenericViewComponents.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Form/Textarea.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Hero.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Range.js","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Level.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Seq2.js","webpack:///./src/Client/output/fable_modules/Feliz.Plotly.2.1.0/Bindings.fs","webpack:///./src/Client/PlotComponent.fs","webpack:///./src/Client/ResultViews.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Elements/Notification.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Section.fs","webpack:///./src/Client/output/fable_modules/Fulma.2.16.0/Layouts/Footer.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Event.js","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Observable.js","webpack:///./src/Client/output/fable_modules/Fable.Elmish.3.1.0/prelude.fs","webpack:///./src/Client/output/fable_modules/fable-library.3.7.5/Timer.js","webpack:///./src/Client/output/fable_modules/Fable.Elmish.3.1.0/cmd.fs","webpack:///./src/Client/output/fable_modules/Fable.Elmish.3.1.0/ring.fs","webpack:///./src/Client/output/fable_modules/Fable.Elmish.3.1.0/program.fs","webpack:///./src/Client/output/fable_modules/Fable.Elmish.React.3.0.1/react.fs","webpack:///./src/Client/output/fable_modules/Fable.Elmish.React.3.0.1/common.fs","webpack:///./src/Client/StateHandling.fs","webpack:///./src/Client/Client.fs"],"sourcesContent":["// tslint:disable:ban-types\nexport function isIterable(x) {\n    return x != null && typeof x === \"object\" && Symbol.iterator in x;\n}\nexport function isArrayLike(x) {\n    return Array.isArray(x) || ArrayBuffer.isView(x);\n}\nfunction isComparer(x) {\n    return typeof x.Compare === \"function\";\n}\nfunction isComparable(x) {\n    return typeof x.CompareTo === \"function\";\n}\nfunction isEquatable(x) {\n    return typeof x.Equals === \"function\";\n}\nfunction isHashable(x) {\n    return typeof x.GetHashCode === \"function\";\n}\nexport function isDisposable(x) {\n    return x != null && typeof x.Dispose === \"function\";\n}\nexport function disposeSafe(x) {\n    if (isDisposable(x)) {\n        x.Dispose();\n    }\n}\nexport function sameConstructor(x, y) {\n    return Object.getPrototypeOf(x).constructor === Object.getPrototypeOf(y).constructor;\n}\nexport class Enumerator {\n    constructor(iter) {\n        this.iter = iter;\n    }\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\n        const cur = this.iter.next();\n        this.current = cur.value;\n        return !cur.done;\n    }\n    [\"System.Collections.IEnumerator.Reset\"]() {\n        throw new Error(\"JS iterators cannot be reset\");\n    }\n    Dispose() {\n        return;\n    }\n}\nexport function getEnumerator(o) {\n    return typeof o.GetEnumerator === \"function\"\n        ? o.GetEnumerator()\n        : new Enumerator(o[Symbol.iterator]());\n}\nexport function toIterator(en) {\n    return {\n        [Symbol.iterator]() { return this; },\n        next() {\n            const hasNext = en[\"System.Collections.IEnumerator.MoveNext\"]();\n            const current = hasNext ? en[\"System.Collections.IEnumerator.get_Current\"]() : undefined;\n            return { done: !hasNext, value: current };\n        },\n    };\n}\nexport class Comparer {\n    constructor(f) {\n        this.Compare = f || compare;\n    }\n}\nexport function comparerFromEqualityComparer(comparer) {\n    // Sometimes IEqualityComparer also implements IComparer\n    if (isComparer(comparer)) {\n        return new Comparer(comparer.Compare);\n    }\n    else {\n        return new Comparer((x, y) => {\n            const xhash = comparer.GetHashCode(x);\n            const yhash = comparer.GetHashCode(y);\n            if (xhash === yhash) {\n                return comparer.Equals(x, y) ? 0 : -1;\n            }\n            else {\n                return xhash < yhash ? -1 : 1;\n            }\n        });\n    }\n}\nexport function assertEqual(actual, expected, msg) {\n    if (!equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport function assertNotEqual(actual, expected, msg) {\n    if (equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport class Lazy {\n    constructor(factory) {\n        this.factory = factory;\n        this.isValueCreated = false;\n    }\n    get Value() {\n        if (!this.isValueCreated) {\n            this.createdValue = this.factory();\n            this.isValueCreated = true;\n        }\n        return this.createdValue;\n    }\n    get IsValueCreated() {\n        return this.isValueCreated;\n    }\n}\nexport function lazyFromValue(v) {\n    return new Lazy(() => v);\n}\nexport function padWithZeros(i, length) {\n    let str = i.toString(10);\n    while (str.length < length) {\n        str = \"0\" + str;\n    }\n    return str;\n}\nexport function padLeftAndRightWithZeros(i, lengthLeft, lengthRight) {\n    let str = i.toString(10);\n    while (str.length < lengthLeft) {\n        str = \"0\" + str;\n    }\n    while (str.length < lengthRight) {\n        str = str + \"0\";\n    }\n    return str;\n}\nexport function dateOffset(date) {\n    const date1 = date;\n    return typeof date1.offset === \"number\"\n        ? date1.offset\n        : (date.kind === 1 /* UTC */\n            ? 0 : date.getTimezoneOffset() * -60000);\n}\nexport function int16ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport function int32ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFFFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport class ObjectRef {\n    static id(o) {\n        if (!ObjectRef.idMap.has(o)) {\n            ObjectRef.idMap.set(o, ++ObjectRef.count);\n        }\n        return ObjectRef.idMap.get(o);\n    }\n}\nObjectRef.idMap = new WeakMap();\nObjectRef.count = 0;\nexport function stringHash(s) {\n    let i = 0;\n    let h = 5381;\n    const len = s.length;\n    while (i < len) {\n        h = (h * 33) ^ s.charCodeAt(i++);\n    }\n    return h;\n}\nexport function numberHash(x) {\n    return x * 2654435761 | 0;\n}\n// From https://stackoverflow.com/a/37449594\nexport function combineHashCodes(hashes) {\n    if (hashes.length === 0) {\n        return 0;\n    }\n    return hashes.reduce((h1, h2) => {\n        return ((h1 << 5) + h1) ^ h2;\n    });\n}\nexport function physicalHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default:\n            return numberHash(ObjectRef.id(x));\n    }\n}\nexport function identityHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    else if (isHashable(x)) {\n        return x.GetHashCode();\n    }\n    else {\n        return physicalHash(x);\n    }\n}\nexport function dateHash(x) {\n    return x.getTime();\n}\nexport function arrayHash(x) {\n    const len = x.length;\n    const hashes = new Array(len);\n    for (let i = 0; i < len; i++) {\n        hashes[i] = structuralHash(x[i]);\n    }\n    return combineHashCodes(hashes);\n}\nexport function structuralHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default: {\n            if (isHashable(x)) {\n                return x.GetHashCode();\n            }\n            else if (isArrayLike(x)) {\n                return arrayHash(x);\n            }\n            else if (x instanceof Date) {\n                return dateHash(x);\n            }\n            else if (Object.getPrototypeOf(x).constructor === Object) {\n                // TODO: check call-stack to prevent cyclic objects?\n                const hashes = Object.values(x).map((v) => structuralHash(v));\n                return combineHashCodes(hashes);\n            }\n            else {\n                // Classes don't implement GetHashCode by default, but must use identity hashing\n                return numberHash(ObjectRef.id(x));\n                // return stringHash(String(x));\n            }\n        }\n    }\n}\n// Intended for custom numeric types, like long or decimal\nexport function fastStructuralHash(x) {\n    return stringHash(String(x));\n}\n// Intended for declared types that may or may not implement GetHashCode\nexport function safeHash(x) {\n    return x == null ? 0 : isHashable(x) ? x.GetHashCode() : numberHash(ObjectRef.id(x));\n}\nexport function equalArraysWith(x, y, eq) {\n    if (x == null) {\n        return y == null;\n    }\n    if (y == null) {\n        return false;\n    }\n    if (x.length !== y.length) {\n        return false;\n    }\n    for (let i = 0; i < x.length; i++) {\n        if (!eq(x[i], y[i])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equalArrays(x, y) {\n    return equalArraysWith(x, y, equals);\n}\nfunction equalObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return false;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0; i < xKeys.length; i++) {\n        if (xKeys[i] !== yKeys[i] || !equals(x[xKeys[i]], y[yKeys[i]])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equals(x, y) {\n    if (x === y) {\n        return true;\n    }\n    else if (x == null) {\n        return y == null;\n    }\n    else if (y == null) {\n        return false;\n    }\n    else if (typeof x !== \"object\") {\n        return false;\n    }\n    else if (isEquatable(x)) {\n        return x.Equals(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) && equalArrays(x, y);\n    }\n    else if (x instanceof Date) {\n        return (y instanceof Date) && compareDates(x, y) === 0;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object && equalObjects(x, y);\n    }\n}\nexport function compareDates(x, y) {\n    let xtime;\n    let ytime;\n    // DateTimeOffset and DateTime deals with equality differently.\n    if (\"offset\" in x && \"offset\" in y) {\n        xtime = x.getTime();\n        ytime = y.getTime();\n    }\n    else {\n        xtime = x.getTime() + dateOffset(x);\n        ytime = y.getTime() + dateOffset(y);\n    }\n    return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);\n}\nexport function comparePrimitives(x, y) {\n    return x === y ? 0 : (x < y ? -1 : 1);\n}\nexport function compareArraysWith(x, y, comp) {\n    if (x == null) {\n        return y == null ? 0 : 1;\n    }\n    if (y == null) {\n        return -1;\n    }\n    if (x.length !== y.length) {\n        return x.length < y.length ? -1 : 1;\n    }\n    for (let i = 0, j = 0; i < x.length; i++) {\n        j = comp(x[i], y[i]);\n        if (j !== 0) {\n            return j;\n        }\n    }\n    return 0;\n}\nexport function compareArrays(x, y) {\n    return compareArraysWith(x, y, compare);\n}\nfunction compareObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return xKeys.length < yKeys.length ? -1 : 1;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0, j = 0; i < xKeys.length; i++) {\n        const key = xKeys[i];\n        if (key !== yKeys[i]) {\n            return key < yKeys[i] ? -1 : 1;\n        }\n        else {\n            j = compare(x[key], y[key]);\n            if (j !== 0) {\n                return j;\n            }\n        }\n    }\n    return 0;\n}\nexport function compare(x, y) {\n    if (x === y) {\n        return 0;\n    }\n    else if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    else if (y == null) {\n        return 1;\n    }\n    else if (typeof x !== \"object\") {\n        return x < y ? -1 : 1;\n    }\n    else if (isComparable(x)) {\n        return x.CompareTo(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) ? compareArrays(x, y) : -1;\n    }\n    else if (x instanceof Date) {\n        return y instanceof Date ? compareDates(x, y) : -1;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object ? compareObjects(x, y) : -1;\n    }\n}\nexport function min(comparer, x, y) {\n    return comparer(x, y) < 0 ? x : y;\n}\nexport function max(comparer, x, y) {\n    return comparer(x, y) > 0 ? x : y;\n}\nexport function clamp(comparer, value, min, max) {\n    return (comparer(value, min) < 0) ? min : (comparer(value, max) > 0) ? max : value;\n}\nexport function createAtom(value) {\n    let atom = value;\n    return (value, isSetter) => {\n        if (!isSetter) {\n            return atom;\n        }\n        else {\n            atom = value;\n            return void 0;\n        }\n    };\n}\nexport function createObj(fields) {\n    const obj = {};\n    for (const kv of fields) {\n        obj[kv[0]] = kv[1];\n    }\n    return obj;\n}\nexport function jsOptions(mutator) {\n    const opts = {};\n    mutator(opts);\n    return opts;\n}\nexport function round(value, digits = 0) {\n    const m = Math.pow(10, digits);\n    const n = +(digits ? value * m : value).toFixed(8);\n    const i = Math.floor(n);\n    const f = n - i;\n    const e = 1e-8;\n    const r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 === 0) ? i : i + 1) : Math.round(n);\n    return digits ? r / m : r;\n}\nexport function sign(x) {\n    return x > 0 ? 1 : x < 0 ? -1 : 0;\n}\nexport function unescapeDataString(s) {\n    // https://stackoverflow.com/a/4458580/524236\n    return decodeURIComponent((s).replace(/\\+/g, \"%20\"));\n}\nexport function escapeDataString(s) {\n    return encodeURIComponent(s).replace(/!/g, \"%21\")\n        .replace(/'/g, \"%27\")\n        .replace(/\\(/g, \"%28\")\n        .replace(/\\)/g, \"%29\")\n        .replace(/\\*/g, \"%2A\");\n}\nexport function escapeUriString(s) {\n    return encodeURI(s);\n}\n// ICollection.Clear and Count members can be called on Arrays\n// or Dictionaries so we need a runtime check (see #1120)\nexport function count(col) {\n    if (isArrayLike(col)) {\n        return col.length;\n    }\n    else {\n        let count = 0;\n        for (const _ of col) {\n            count++;\n        }\n        return count;\n    }\n}\nexport function clear(col) {\n    if (isArrayLike(col)) {\n        col.splice(0);\n    }\n    else {\n        col.clear();\n    }\n}\nconst CURRIED = Symbol(\"curried\");\nexport function uncurry(arity, f) {\n    // f may be a function option with None value\n    if (f == null || f.length > 1) {\n        return f;\n    }\n    const uncurried = (...args) => {\n        let res = f;\n        for (let i = 0; i < arity; i++) {\n            res = res(args[i]);\n        }\n        return res;\n    };\n    uncurried[CURRIED] = f;\n    return uncurried;\n}\nfunction _curry(args, arity, f) {\n    return (arg) => arity === 1\n        ? f(...args.concat([arg]))\n        // Note it's important to generate a new args array every time\n        // because a partially applied function can be run multiple times\n        : _curry(args.concat([arg]), arity - 1, f);\n}\nexport function curry(arity, f) {\n    if (f == null || f.length === 1) {\n        return f;\n    }\n    else if (CURRIED in f) {\n        return f[CURRIED];\n    }\n    else {\n        return _curry([], arity, f);\n    }\n}\nexport function checkArity(arity, f) {\n    return f.length > arity\n        ? (...args1) => (...args2) => f.apply(undefined, args1.concat(args2))\n        : f;\n}\nexport function partialApply(arity, f, args) {\n    if (f == null) {\n        return undefined;\n    }\n    else if (CURRIED in f) {\n        f = f[CURRIED];\n        for (let i = 0; i < args.length; i++) {\n            f = f(args[i]);\n        }\n        return f;\n    }\n    else {\n        return _curry(args, arity, f);\n    }\n}\nexport function mapCurriedArgs(fn, mappings) {\n    function mapArg(fn, arg, mappings, idx) {\n        const mapping = mappings[idx];\n        if (mapping !== 0) {\n            const expectedArity = mapping[0];\n            const actualArity = mapping[1];\n            if (expectedArity > 1) {\n                arg = curry(expectedArity, arg);\n            }\n            if (actualArity > 1) {\n                arg = uncurry(actualArity, arg);\n            }\n        }\n        const res = fn(arg);\n        if (idx + 1 === mappings.length) {\n            return res;\n        }\n        else {\n            return (arg) => mapArg(res, arg, mappings, idx + 1);\n        }\n    }\n    return (arg) => mapArg(fn, arg, mappings, 0);\n}\n","import { combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from \"./Util.js\";\nexport function seqToString(self) {\n    let count = 0;\n    let str = \"[\";\n    for (const x of self) {\n        if (count === 0) {\n            str += toString(x);\n        }\n        else if (count === 100) {\n            str += \"; ...\";\n            break;\n        }\n        else {\n            str += \"; \" + toString(x);\n        }\n        count++;\n    }\n    return str + \"]\";\n}\nexport function toString(x, callStack = 0) {\n    if (x != null && typeof x === \"object\") {\n        if (typeof x.toString === \"function\") {\n            return x.toString();\n        }\n        else if (Symbol.iterator in x) {\n            return seqToString(x);\n        }\n        else { // TODO: Date?\n            const cons = Object.getPrototypeOf(x).constructor;\n            return cons === Object && callStack < 10\n                // Same format as recordToString\n                ? \"{ \" + Object.entries(x).map(([k, v]) => k + \" = \" + toString(v, callStack + 1)).join(\"\\n  \") + \" }\"\n                : cons.name;\n        }\n    }\n    return String(x);\n}\nexport function unionToString(name, fields) {\n    if (fields.length === 0) {\n        return name;\n    }\n    else {\n        let fieldStr = \"\";\n        let withParens = true;\n        if (fields.length === 1) {\n            fieldStr = toString(fields[0]);\n            withParens = fieldStr.indexOf(\" \") >= 0;\n        }\n        else {\n            fieldStr = fields.map((x) => toString(x)).join(\", \");\n        }\n        return name + (withParens ? \" (\" : \" \") + fieldStr + (withParens ? \")\" : \"\");\n    }\n}\nexport class Union {\n    get name() {\n        return this.cases()[this.tag];\n    }\n    toJSON() {\n        return this.fields.length === 0 ? this.name : [this.name].concat(this.fields);\n    }\n    toString() {\n        return unionToString(this.name, this.fields);\n    }\n    GetHashCode() {\n        const hashes = this.fields.map((x) => structuralHash(x));\n        hashes.splice(0, 0, numberHash(this.tag));\n        return combineHashCodes(hashes);\n    }\n    Equals(other) {\n        if (this === other) {\n            return true;\n        }\n        else if (!sameConstructor(this, other)) {\n            return false;\n        }\n        else if (this.tag === other.tag) {\n            return equalArrays(this.fields, other.fields);\n        }\n        else {\n            return false;\n        }\n    }\n    CompareTo(other) {\n        if (this === other) {\n            return 0;\n        }\n        else if (!sameConstructor(this, other)) {\n            return -1;\n        }\n        else if (this.tag === other.tag) {\n            return compareArrays(this.fields, other.fields);\n        }\n        else {\n            return this.tag < other.tag ? -1 : 1;\n        }\n    }\n}\nfunction recordToJSON(self) {\n    const o = {};\n    const keys = Object.keys(self);\n    for (let i = 0; i < keys.length; i++) {\n        o[keys[i]] = self[keys[i]];\n    }\n    return o;\n}\nfunction recordToString(self) {\n    return \"{ \" + Object.entries(self).map(([k, v]) => k + \" = \" + toString(v)).join(\"\\n  \") + \" }\";\n}\nfunction recordGetHashCode(self) {\n    const hashes = Object.values(self).map((v) => structuralHash(v));\n    return combineHashCodes(hashes);\n}\nfunction recordEquals(self, other) {\n    if (self === other) {\n        return true;\n    }\n    else if (!sameConstructor(self, other)) {\n        return false;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            if (!equals(self[thisNames[i]], other[thisNames[i]])) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\nfunction recordCompareTo(self, other) {\n    if (self === other) {\n        return 0;\n    }\n    else if (!sameConstructor(self, other)) {\n        return -1;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            const result = compare(self[thisNames[i]], other[thisNames[i]]);\n            if (result !== 0) {\n                return result;\n            }\n        }\n        return 0;\n    }\n}\nexport class Record {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class FSharpRef {\n    constructor(contentsOrGetter, setter) {\n        if (typeof setter === \"function\") {\n            this.getter = contentsOrGetter;\n            this.setter = setter;\n        }\n        else {\n            this.getter = () => contentsOrGetter;\n            this.setter = (v) => { contentsOrGetter = v; };\n        }\n    }\n    get contents() {\n        return this.getter();\n    }\n    set contents(v) {\n        this.setter(v);\n    }\n}\n// EXCEPTIONS\n// Exception is intentionally not derived from Error, for performance reasons (see #2160)\nexport class Exception {\n    constructor(message) {\n        this.message = message;\n    }\n}\nexport function isException(x) {\n    return x instanceof Exception || x instanceof Error;\n}\nexport class FSharpException extends Exception {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class MatchFailureException extends FSharpException {\n    constructor(arg1, arg2, arg3) {\n        super();\n        this.arg1 = arg1;\n        this.arg2 = arg2 | 0;\n        this.arg3 = arg3 | 0;\n        this.message = \"The match cases were incomplete\";\n    }\n}\nexport class Attribute {\n}\n","import { Record, Union } from \"./Types.js\";\nimport { combineHashCodes, equalArraysWith, stringHash } from \"./Util.js\";\nimport Decimal from \"./Decimal.js\";\nimport { fromInt as int64FromInt } from \"./Long.js\";\nexport class CaseInfo {\n    constructor(declaringType, tag, name, fields) {\n        this.declaringType = declaringType;\n        this.tag = tag;\n        this.name = name;\n        this.fields = fields;\n    }\n}\nexport class MethodInfo {\n    constructor(name, parameters, returnType) {\n        this.name = name;\n        this.parameters = parameters;\n        this.returnType = returnType;\n    }\n}\nexport class TypeInfo {\n    constructor(fullname, generics, construct, parent, fields, cases, enumCases) {\n        this.fullname = fullname;\n        this.generics = generics;\n        this.construct = construct;\n        this.parent = parent;\n        this.fields = fields;\n        this.cases = cases;\n        this.enumCases = enumCases;\n    }\n    toString() {\n        return fullName(this);\n    }\n    GetHashCode() {\n        return getHashCode(this);\n    }\n    Equals(other) {\n        return equals(this, other);\n    }\n}\nexport class GenericParameter extends TypeInfo {\n    constructor(name) {\n        super(name);\n    }\n}\nexport function getGenerics(t) {\n    return t.generics != null ? t.generics : [];\n}\nexport function getHashCode(t) {\n    const fullnameHash = stringHash(t.fullname);\n    const genHashes = getGenerics(t).map(getHashCode);\n    return combineHashCodes([fullnameHash, ...genHashes]);\n}\nexport function equals(t1, t2) {\n    if (t1.fullname === \"\") { // Anonymous records\n        return t2.fullname === \"\"\n            && equalArraysWith(getRecordElements(t1), getRecordElements(t2), ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2));\n    }\n    else {\n        return t1.fullname === t2.fullname\n            && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);\n    }\n}\nexport function class_type(fullname, generics, construct, parent) {\n    return new TypeInfo(fullname, generics, construct, parent);\n}\nexport function record_type(fullname, generics, construct, fields) {\n    return new TypeInfo(fullname, generics, construct, undefined, fields);\n}\nexport function anonRecord_type(...fields) {\n    return new TypeInfo(\"\", undefined, undefined, undefined, () => fields);\n}\nexport function union_type(fullname, generics, construct, cases) {\n    const t = new TypeInfo(fullname, generics, construct, undefined, undefined, () => {\n        const caseNames = construct.prototype.cases();\n        return cases().map((fields, i) => new CaseInfo(t, i, caseNames[i], fields));\n    });\n    return t;\n}\nexport function tuple_type(...generics) {\n    return new TypeInfo(\"System.Tuple`\" + generics.length, generics);\n}\nexport function delegate_type(...generics) {\n    return new TypeInfo(\"System.Func`\" + generics.length, generics);\n}\nexport function lambda_type(argType, returnType) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpFunc`2\", [argType, returnType]);\n}\nexport function option_type(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpOption`1\", [generic]);\n}\nexport function list_type(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Collections.FSharpList`1\", [generic]);\n}\nexport function array_type(generic) {\n    return new TypeInfo(\"[]\", [generic]);\n}\nexport function enum_type(fullname, underlyingType, enumCases) {\n    return new TypeInfo(fullname, [underlyingType], undefined, undefined, undefined, undefined, enumCases);\n}\nexport function measure_type(fullname) {\n    return new TypeInfo(fullname);\n}\nexport function generic_type(name) {\n    return new GenericParameter(name);\n}\nexport const obj_type = new TypeInfo(\"System.Object\");\nexport const unit_type = new TypeInfo(\"Microsoft.FSharp.Core.Unit\");\nexport const char_type = new TypeInfo(\"System.Char\");\nexport const string_type = new TypeInfo(\"System.String\");\nexport const bool_type = new TypeInfo(\"System.Boolean\");\nexport const int8_type = new TypeInfo(\"System.SByte\");\nexport const uint8_type = new TypeInfo(\"System.Byte\");\nexport const int16_type = new TypeInfo(\"System.Int16\");\nexport const uint16_type = new TypeInfo(\"System.UInt16\");\nexport const int32_type = new TypeInfo(\"System.Int32\");\nexport const uint32_type = new TypeInfo(\"System.UInt32\");\nexport const float32_type = new TypeInfo(\"System.Single\");\nexport const float64_type = new TypeInfo(\"System.Double\");\nexport const decimal_type = new TypeInfo(\"System.Decimal\");\nexport function name(info) {\n    if (Array.isArray(info)) {\n        return info[0];\n    }\n    else if (info instanceof TypeInfo) {\n        const elemType = getElementType(info);\n        if (elemType != null) {\n            return name(elemType) + \"[]\";\n        }\n        else {\n            const i = info.fullname.lastIndexOf(\".\");\n            return i === -1 ? info.fullname : info.fullname.substr(i + 1);\n        }\n    }\n    else {\n        return info.name;\n    }\n}\nexport function fullName(t) {\n    const elemType = getElementType(t);\n    if (elemType != null) {\n        return fullName(elemType) + \"[]\";\n    }\n    else if (t.generics == null || t.generics.length === 0) {\n        return t.fullname;\n    }\n    else {\n        return t.fullname + \"[\" + t.generics.map((x) => fullName(x)).join(\",\") + \"]\";\n    }\n}\nexport function namespace(t) {\n    const elemType = getElementType(t);\n    if (elemType != null) {\n        return namespace(elemType);\n    }\n    else {\n        const i = t.fullname.lastIndexOf(\".\");\n        return i === -1 ? \"\" : t.fullname.substr(0, i);\n    }\n}\nexport function isArray(t) {\n    return getElementType(t) != null;\n}\nexport function getElementType(t) {\n    var _a;\n    return t.fullname === \"[]\" && ((_a = t.generics) === null || _a === void 0 ? void 0 : _a.length) === 1 ? t.generics[0] : undefined;\n}\nexport function isGenericType(t) {\n    return t.generics != null && t.generics.length > 0;\n}\nexport function isGenericParameter(t) {\n    return t instanceof GenericParameter;\n}\nexport function isEnum(t) {\n    return t.enumCases != null && t.enumCases.length > 0;\n}\nexport function isSubclassOf(t1, t2) {\n    return (t2.fullname === obj_type.fullname) || (t1.parent != null && (t1.parent.Equals(t2) || isSubclassOf(t1.parent, t2)));\n}\nfunction isErasedToNumber(t) {\n    return isEnum(t) || [\n        int8_type.fullname,\n        uint8_type.fullname,\n        int16_type.fullname,\n        uint16_type.fullname,\n        int32_type.fullname,\n        uint32_type.fullname,\n        float32_type.fullname,\n        float64_type.fullname,\n    ].includes(t.fullname);\n}\nexport function isInstanceOfType(t, o) {\n    if (t.fullname === obj_type.fullname)\n        return true;\n    switch (typeof o) {\n        case \"boolean\":\n            return t.fullname === bool_type.fullname;\n        case \"string\":\n            return t.fullname === string_type.fullname;\n        case \"function\":\n            return isFunction(t);\n        case \"number\":\n            return isErasedToNumber(t);\n        default:\n            return t.construct != null && o instanceof t.construct;\n    }\n}\n/**\n * This doesn't replace types for fields (records) or cases (unions)\n * but it should be enough for type comparison purposes\n */\nexport function getGenericTypeDefinition(t) {\n    return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));\n}\nexport function getEnumUnderlyingType(t) {\n    var _a;\n    return (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0];\n}\nexport function getEnumValues(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[1]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function getEnumNames(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[0]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nfunction getEnumCase(t, v) {\n    if (t.enumCases != null) {\n        if (typeof v === \"string\") {\n            for (const kv of t.enumCases) {\n                if (kv[0] === v) {\n                    return kv;\n                }\n            }\n            throw new Error(`'${v}' was not found in ${t.fullname}`);\n        }\n        else {\n            for (const kv of t.enumCases) {\n                if (kv[1] === v) {\n                    return kv;\n                }\n            }\n            // .NET returns the number even if it doesn't match any of the cases\n            return [\"\", v];\n        }\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function parseEnum(t, str) {\n    // TODO: better int parsing here, parseInt ceils floats: \"4.8\" -> 4\n    const value = parseInt(str, 10);\n    return getEnumCase(t, isNaN(value) ? str : value)[1];\n}\nexport function tryParseEnum(t, str, defValue) {\n    try {\n        defValue.contents = parseEnum(t, str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getEnumName(t, v) {\n    return getEnumCase(t, v)[0];\n}\nexport function isEnumDefined(t, v) {\n    try {\n        const kv = getEnumCase(t, v);\n        return kv[0] != null && kv[0] !== \"\";\n    }\n    catch (_a) {\n        // supress error\n    }\n    return false;\n}\n// FSharpType\nexport function getUnionCases(t) {\n    if (t.cases != null) {\n        return t.cases();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# union type`);\n    }\n}\nexport function getRecordElements(t) {\n    if (t.fields != null) {\n        return t.fields();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# record type`);\n    }\n}\nexport function getTupleElements(t) {\n    if (isTuple(t) && t.generics != null) {\n        return t.generics;\n    }\n    else {\n        throw new Error(`${t.fullname} is not a tuple type`);\n    }\n}\nexport function getFunctionElements(t) {\n    if (isFunction(t) && t.generics != null) {\n        const gen = t.generics;\n        return [gen[0], gen[1]];\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# function type`);\n    }\n}\nexport function isUnion(t) {\n    return t instanceof TypeInfo ? t.cases != null : t instanceof Union;\n}\nexport function isRecord(t) {\n    return t instanceof TypeInfo ? t.fields != null : t instanceof Record;\n}\nexport function isTuple(t) {\n    return t.fullname.startsWith(\"System.Tuple\");\n}\n// In .NET this is false for delegates\nexport function isFunction(t) {\n    return t.fullname === \"Microsoft.FSharp.Core.FSharpFunc`2\";\n}\n// FSharpValue\nexport function getUnionFields(v, t) {\n    const cases = getUnionCases(t);\n    const case_ = cases[v.tag];\n    if (case_ == null) {\n        throw new Error(`Cannot find case ${v.name} in union type`);\n    }\n    return [case_, v.fields];\n}\nexport function getUnionCaseFields(uci) {\n    return uci.fields == null ? [] : uci.fields;\n}\n// This is used as replacement of `FSharpValue.GetRecordFields`\n// For `FSharpTypes.GetRecordFields` see `getRecordElements`\n// Object.keys returns keys in the order they were added to the object\nexport function getRecordFields(v) {\n    return Object.keys(v).map((k) => v[k]);\n}\nexport function getRecordField(v, field) {\n    return v[field[0]];\n}\nexport function getTupleFields(v) {\n    return v;\n}\nexport function getTupleField(v, i) {\n    return v[i];\n}\nexport function makeUnion(uci, values) {\n    const expectedLength = (uci.fields || []).length;\n    if (values.length !== expectedLength) {\n        throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);\n    }\n    return uci.declaringType.construct != null\n        ? new uci.declaringType.construct(uci.tag, ...values)\n        : {};\n}\nexport function makeRecord(t, values) {\n    const fields = getRecordElements(t);\n    if (fields.length !== values.length) {\n        throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);\n    }\n    return t.construct != null\n        ? new t.construct(...values)\n        : fields.reduce((obj, [key, _t], i) => {\n            obj[key] = values[i];\n            return obj;\n        }, {});\n}\nexport function makeTuple(values, _t) {\n    return values;\n}\nexport function makeGenericType(t, generics) {\n    return new TypeInfo(t.fullname, generics, t.construct, t.parent, t.fields, t.cases);\n}\nexport function createInstance(t, consArgs) {\n    // TODO: Check if consArgs length is same as t.construct?\n    // (Arg types can still be different)\n    if (typeof t.construct === \"function\") {\n        return new t.construct(...(consArgs !== null && consArgs !== void 0 ? consArgs : []));\n    }\n    else if (isErasedToNumber(t)) {\n        return 0;\n    }\n    else {\n        switch (t.fullname) {\n            case obj_type.fullname:\n                return {};\n            case bool_type.fullname:\n                return false;\n            case \"System.Int64\":\n            case \"System.UInt64\":\n                // typeof<int64> and typeof<uint64> get transformed to class_type(\"System.Int64\")\n                // and class_type(\"System.UInt64\") respectively. Test for the name of the primitive type.\n                return int64FromInt(0);\n            case decimal_type.fullname:\n                return new Decimal(0);\n            case char_type.fullname:\n                // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null\n                return null;\n            default:\n                throw new Error(`Cannot access constructor of ${t.fullname}`);\n        }\n    }\n}\nexport function getValue(propertyInfo, v) {\n    return v[propertyInfo[0]];\n}\n// Fable.Core.Reflection\nfunction assertUnion(x) {\n    if (!(x instanceof Union)) {\n        throw new Error(`Value is not an F# union type`);\n    }\n}\nexport function getCaseTag(x) {\n    assertUnion(x);\n    return x.tag;\n}\nexport function getCaseName(x) {\n    assertUnion(x);\n    return x.cases()[x.tag];\n}\nexport function getCaseFields(x) {\n    assertUnion(x);\n    return x.fields;\n}\n","// export type decimal = Decimal;\nexport var NumberStyles;\n(function (NumberStyles) {\n    // None = 0x00000000,\n    // AllowLeadingWhite = 0x00000001,\n    // AllowTrailingWhite = 0x00000002,\n    // AllowLeadingSign = 0x00000004,\n    // AllowTrailingSign = 0x00000008,\n    // AllowParentheses = 0x00000010,\n    // AllowDecimalPoint = 0x00000020,\n    // AllowThousands = 0x00000040,\n    // AllowExponent = 0x00000080,\n    // AllowCurrencySymbol = 0x00000100,\n    NumberStyles[NumberStyles[\"AllowHexSpecifier\"] = 512] = \"AllowHexSpecifier\";\n    // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,\n    // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,\n    // Number = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //          AllowTrailingSign | AllowDecimalPoint | AllowThousands,\n    // Float = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //         AllowDecimalPoint | AllowExponent,\n    // Currency = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,\n    // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,\n})(NumberStyles || (NumberStyles = {}));\nfunction validResponse(regexMatch, radix) {\n    const [/*all*/ , sign, prefix, digits] = regexMatch;\n    return {\n        sign: sign || \"\",\n        prefix: prefix || \"\",\n        digits,\n        radix,\n    };\n}\nfunction getRange(unsigned, bitsize) {\n    switch (bitsize) {\n        case 8: return unsigned ? [0, 255] : [-128, 127];\n        case 16: return unsigned ? [0, 65535] : [-32768, 32767];\n        case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];\n        default: throw new Error(\"Invalid bit size.\");\n    }\n}\nfunction getInvalidDigits(radix) {\n    switch (radix) {\n        case 2: return /[^0-1]/;\n        case 8: return /[^0-7]/;\n        case 10: return /[^0-9]/;\n        case 16: return /[^0-9a-fA-F]/;\n        default:\n            throw new Error(\"Invalid Base.\");\n    }\n}\nfunction getRadix(prefix, style) {\n    if (style & NumberStyles.AllowHexSpecifier) {\n        return 16;\n    }\n    else {\n        switch (prefix) {\n            case \"0b\":\n            case \"0B\": return 2;\n            case \"0o\":\n            case \"0O\": return 8;\n            case \"0x\":\n            case \"0X\": return 16;\n            default: return 10;\n        }\n    }\n}\nexport function isValid(str, style, radix) {\n    const integerRegex = /^\\s*([\\+\\-])?(0[xXoObB])?([0-9a-fA-F]+)\\s*$/;\n    const res = integerRegex.exec(str.replace(/_/g, \"\"));\n    if (res != null) {\n        const [/*all*/ , /*sign*/ , prefix, digits] = res;\n        radix = radix || getRadix(prefix, style);\n        const invalidDigits = getInvalidDigits(radix);\n        if (!invalidDigits.test(digits)) {\n            return validResponse(res, radix);\n        }\n    }\n    return null;\n}\nexport function parse(str, style, unsigned, bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        let v = Number.parseInt(res.sign + res.digits, res.radix);\n        if (!Number.isNaN(v)) {\n            const [umin, umax] = getRange(true, bitsize);\n            if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {\n                v = v << (32 - bitsize) >> (32 - bitsize);\n            }\n            const [min, max] = getRange(unsigned, bitsize);\n            if (v >= min && v <= max) {\n                return v;\n            }\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_UnaryNegation_Int8(x) {\n    return x === -128 ? x : -x;\n}\nexport function op_UnaryNegation_Int16(x) {\n    return x === -32768 ? x : -x;\n}\nexport function op_UnaryNegation_Int32(x) {\n    return x === -2147483648 ? x : -x;\n}\nexport function divRem(x, y, out) {\n    const div = ~~(x / y);\n    const rem = x % y;\n    if (out != null) {\n        out.contents = rem;\n        return div;\n    }\n    else {\n        return [div, rem];\n    }\n}\n","export const symbol = Symbol(\"numeric\");\nexport function isNumeric(x) {\n    return typeof x === \"number\" || (x === null || x === void 0 ? void 0 : x[symbol]);\n}\nexport function compare(x, y) {\n    if (typeof x === \"number\") {\n        return x < y ? -1 : (x > y ? 1 : 0);\n    }\n    else {\n        return x.CompareTo(y);\n    }\n}\nexport function multiply(x, y) {\n    if (typeof x === \"number\") {\n        return x * y;\n    }\n    else {\n        return x[symbol]().multiply(y);\n    }\n}\nexport function toFixed(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toFixed(dp);\n    }\n    else {\n        return x[symbol]().toFixed(dp);\n    }\n}\nexport function toPrecision(x, sd) {\n    if (typeof x === \"number\") {\n        return x.toPrecision(sd);\n    }\n    else {\n        return x[symbol]().toPrecision(sd);\n    }\n}\nexport function toExponential(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toExponential(dp);\n    }\n    else {\n        return x[symbol]().toExponential(dp);\n    }\n}\nexport function toHex(x) {\n    if (typeof x === \"number\") {\n        return (Number(x) >>> 0).toString(16);\n    }\n    else {\n        return x[symbol]().toHex();\n    }\n}\n","// Adapted from: https://github.com/dcodeIO/long.js/blob/master/src/long.js\n// Apache License 2.0: https://github.com/dcodeIO/long.js/blob/master/LICENSE\n/* tslint:disable */\nimport { symbol } from \"../Numeric.js\";\n/**\n * wasm optimizations, to do native i64 multiplication and divide\n */\nvar wasm = null;\ntry {\n    wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11\n    ])), {}).exports;\n}\ncatch (e) {\n    // no wasm support :(\n}\n/**\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n *  See the from* functions below for more convenient ways of constructing Longs.\n * @exports Long\n * @class A Long class for representing a 64 bit two's-complement integer value.\n * @param {number} low The low (signed) 32 bits of the long\n * @param {number} high The high (signed) 32 bits of the long\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @constructor\n */\nexport function Long(low, high, unsigned) {\n    /**\n     * The low 32 bits as a signed value.\n     * @type {number}\n     */\n    this.low = low | 0;\n    /**\n     * The high 32 bits as a signed value.\n     * @type {number}\n     */\n    this.high = high | 0;\n    /**\n     * Whether unsigned or not.\n     * @type {boolean}\n     */\n    this.unsigned = !!unsigned;\n}\nLong.prototype.GetHashCode = function () {\n    let h1 = this.unsigned ? 1 : 0;\n    h1 = ((h1 << 5) + h1) ^ this.high;\n    h1 = ((h1 << 5) + h1) ^ this.low;\n    return h1;\n};\nLong.prototype.Equals = function (x) { return equals(this, x); };\nLong.prototype.CompareTo = function (x) { return compare(this, x); };\nLong.prototype.toString = function (radix) { return toString(this, radix); };\nLong.prototype.toJSON = function () { return toString(this); };\nLong.prototype[symbol] = function () {\n    const x = this;\n    return {\n        multiply: y => multiply(x, y),\n        toPrecision: sd => String(x) + (0).toPrecision(sd).substr(1),\n        toExponential: dp => String(x) + (0).toExponential(dp).substr(1),\n        toFixed: dp => String(x) + (0).toFixed(dp).substr(1),\n        toHex: () => toString(x.unsigned ? x : fromBytes(toBytes(x), true), 16),\n    };\n};\n// The internal representation of a long is the two given signed, 32-bit values.\n// We use 32-bit pieces because these are the size of integers on which\n// Javascript performs bit-operations.  For operations like addition and\n// multiplication, we split each number into 16 bit pieces, which can easily be\n// multiplied within Javascript's floating-point representation without overflow\n// or change in sign.\n//\n// In the algorithms below, we frequently reduce the negative case to the\n// positive case by negating the input(s) and then post-processing the result.\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n// a positive number, it overflows back into a negative).  Not handling this\n// case would often result in infinite recursion.\n//\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\n// methods on which they depend.\n/**\n * An indicator used to reliably determine if an object is a Long or not.\n * @type {boolean}\n * @const\n * @private\n */\nLong.prototype.__isLong__;\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\n/**\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n * @inner\n */\nexport function isLong(obj) {\n    return (obj && obj[\"__isLong__\"]) === true;\n}\n/**\n * Tests if the specified object is a Long.\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n */\n// Long.isLong = isLong;\n/**\n * A cache of the Long representations of small integer values.\n * @type {!Object}\n * @inner\n */\nvar INT_CACHE = {};\n/**\n * A cache of the Long representations of small unsigned integer values.\n * @type {!Object}\n * @inner\n */\nvar UINT_CACHE = {};\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromInt(value, unsigned) {\n    var obj, cachedObj, cache;\n    if (unsigned) {\n        value >>>= 0;\n        if (cache = (0 <= value && value < 256)) {\n            cachedObj = UINT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\n        if (cache)\n            UINT_CACHE[value] = obj;\n        return obj;\n    }\n    else {\n        value |= 0;\n        if (cache = (-128 <= value && value < 128)) {\n            cachedObj = INT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\n        if (cache)\n            INT_CACHE[value] = obj;\n        return obj;\n    }\n}\n/**\n * Returns a Long representing the given 32 bit integer value.\n * @function\n * @param {number} value The 32 bit integer in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromInt = fromInt;\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromNumber(value, unsigned) {\n    if (isNaN(value))\n        return unsigned ? UZERO : ZERO;\n    if (unsigned) {\n        if (value < 0)\n            return UZERO;\n        if (value >= TWO_PWR_64_DBL)\n            return MAX_UNSIGNED_VALUE;\n    }\n    else {\n        if (value <= -TWO_PWR_63_DBL)\n            return MIN_VALUE;\n        if (value + 1 >= TWO_PWR_63_DBL)\n            return MAX_VALUE;\n    }\n    if (value < 0)\n        return negate(fromNumber(-value, unsigned));\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\n}\n/**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @function\n * @param {number} value The number in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromNumber = fromNumber;\n/**\n * @param {number} lowBits\n * @param {number} highBits\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromBits(lowBits, highBits, unsigned) {\n    return new Long(lowBits, highBits, unsigned);\n}\n/**\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\n *  assumed to use 32 bits.\n * @function\n * @param {number} lowBits The low 32 bits\n * @param {number} highBits The high 32 bits\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromBits = fromBits;\n/**\n * @function\n * @param {number} base\n * @param {number} exponent\n * @returns {number}\n * @inner\n */\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\n/**\n * @param {string} str\n * @param {(boolean|number)=} unsigned\n * @param {number=} radix\n * @returns {!Long}\n * @inner\n */\nexport function fromString(str, unsigned, radix) {\n    if (str.length === 0)\n        throw Error('empty string');\n    if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\n        return ZERO;\n    if (typeof unsigned === 'number') {\n        // For goog.math.long compatibility\n        radix = unsigned,\n            unsigned = false;\n    }\n    else {\n        unsigned = !!unsigned;\n    }\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    var p = str.indexOf('-');\n    if (p > 0)\n        throw Error('interior hyphen');\n    else if (p === 0) {\n        return negate(fromString(str.substring(1), unsigned, radix));\n    }\n    // Do several (8) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 8));\n    var result = ZERO;\n    for (var i = 0; i < str.length; i += 8) {\n        var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);\n        if (size < 8) {\n            var power = fromNumber(pow_dbl(radix, size));\n            result = add(multiply(result, power), fromNumber(value));\n        }\n        else {\n            result = multiply(result, radixToPower);\n            result = add(result, fromNumber(value));\n        }\n    }\n    result.unsigned = unsigned;\n    return result;\n}\n/**\n * Returns a Long representation of the given string, written using the specified radix.\n * @function\n * @param {string} str The textual representation of the Long\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromString = fromString;\n/**\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromValue(val, unsigned) {\n    if (typeof val === 'number')\n        return fromNumber(val, unsigned);\n    if (typeof val === 'string')\n        return fromString(val, unsigned);\n    // Throws for non-objects, converts non-instanceof Long:\n    return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);\n}\n/**\n * Converts the specified value to a Long using the appropriate from* function for its type.\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long}\n */\n// Long.fromValue = fromValue;\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\n// no runtime penalty for these.\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_16_DBL = 1 << 16;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_24_DBL = 1 << 24;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n/**\n * @type {!Long}\n * @const\n * @inner\n */\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\n/**\n * @type {!Long}\n * @inner\n */\nexport var ZERO = fromInt(0);\n/**\n * Signed zero.\n * @type {!Long}\n */\n// Long.ZERO = ZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UZERO = fromInt(0, true);\n/**\n * Unsigned zero.\n * @type {!Long}\n */\n// Long.UZERO = UZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var ONE = fromInt(1);\n/**\n * Signed one.\n * @type {!Long}\n */\n// Long.ONE = ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UONE = fromInt(1, true);\n/**\n * Unsigned one.\n * @type {!Long}\n */\n// Long.UONE = UONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var NEG_ONE = fromInt(-1);\n/**\n * Signed negative one.\n * @type {!Long}\n */\n// Long.NEG_ONE = NEG_ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false);\n/**\n * Maximum signed value.\n * @type {!Long}\n */\n// Long.MAX_VALUE = MAX_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true);\n/**\n * Maximum unsigned value.\n * @type {!Long}\n */\n// Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n/**\n * Minimum signed value.\n * @type {!Long}\n */\n// Long.MIN_VALUE = MIN_VALUE;\n/**\n * @alias Long.prototype\n * @inner\n */\n// var LongPrototype = Long.prototype;\n/**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @this {!Long}\n * @returns {number}\n */\nexport function toInt($this) {\n    return $this.unsigned ? $this.low >>> 0 : $this.low;\n}\n;\n/**\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\n * @this {!Long}\n * @returns {number}\n */\nexport function toNumber($this) {\n    if ($this.unsigned)\n        return (($this.high >>> 0) * TWO_PWR_32_DBL) + ($this.low >>> 0);\n    return $this.high * TWO_PWR_32_DBL + ($this.low >>> 0);\n}\n;\n/**\n * Converts the Long to a string written in the specified radix.\n * @this {!Long}\n * @param {number=} radix Radix (2-36), defaults to 10\n * @returns {string}\n * @override\n * @throws {RangeError} If `radix` is out of range\n */\nexport function toString($this, radix) {\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    if (isZero($this))\n        return '0';\n    if (isNegative($this)) { // Unsigned Longs are never negative\n        if (equals($this, MIN_VALUE)) {\n            // We need to change the Long value before it can be negated, so we remove\n            // the bottom-most digit in this base and then recurse to do the rest.\n            var radixLong = fromNumber(radix), div = divide($this, radixLong), rem1 = subtract(multiply(div, radixLong), $this);\n            return toString(div, radix) + toInt(rem1).toString(radix);\n        }\n        else\n            return '-' + toString(negate($this), radix);\n    }\n    // Do several (6) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 6), $this.unsigned), rem = $this;\n    var result = '';\n    while (true) {\n        var remDiv = divide(rem, radixToPower), intval = toInt(subtract(rem, multiply(remDiv, radixToPower))) >>> 0, digits = intval.toString(radix);\n        rem = remDiv;\n        if (isZero(rem))\n            return digits + result;\n        else {\n            while (digits.length < 6)\n                digits = '0' + digits;\n            result = '' + digits + result;\n        }\n    }\n}\n;\n/**\n * Gets the high 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed high bits\n */\nexport function getHighBits($this) {\n    return $this.high;\n}\n;\n/**\n * Gets the high 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned high bits\n */\nexport function getHighBitsUnsigned($this) {\n    return $this.high >>> 0;\n}\n;\n/**\n * Gets the low 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed low bits\n */\nexport function getLowBits($this) {\n    return $this.low;\n}\n;\n/**\n * Gets the low 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned low bits\n */\nexport function getLowBitsUnsigned($this) {\n    return $this.low >>> 0;\n}\n;\n/**\n * Gets the number of bits needed to represent the absolute value of this Long.\n * @this {!Long}\n * @returns {number}\n */\nexport function getNumBitsAbs($this) {\n    if (isNegative($this)) // Unsigned Longs are never negative\n        return equals($this, MIN_VALUE) ? 64 : getNumBitsAbs(negate($this));\n    var val = $this.high != 0 ? $this.high : $this.low;\n    for (var bit = 31; bit > 0; bit--)\n        if ((val & (1 << bit)) != 0)\n            break;\n    return $this.high != 0 ? bit + 33 : bit + 1;\n}\n;\n/**\n * Tests if this Long's value equals zero.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isZero($this) {\n    return $this.high === 0 && $this.low === 0;\n}\n;\n/**\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\n * @returns {boolean}\n */\n// LongPrototype.eqz = LongPrototype.isZero;\n/**\n * Tests if this Long's value is negative.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isNegative($this) {\n    return !$this.unsigned && $this.high < 0;\n}\n;\n/**\n * Tests if this Long's value is positive.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isPositive($this) {\n    return $this.unsigned || $this.high >= 0;\n}\n;\n/**\n * Tests if this Long's value is odd.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isOdd($this) {\n    return ($this.low & 1) === 1;\n}\n;\n/**\n * Tests if this Long's value is even.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isEven($this) {\n    return ($this.low & 1) === 0;\n}\n;\n/**\n * Tests if this Long's value equals the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function equals($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if ($this.unsigned !== other.unsigned && ($this.high >>> 31) === 1 && (other.high >>> 31) === 1)\n        return false;\n    return $this.high === other.high && $this.low === other.low;\n}\n;\n/**\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.eq = LongPrototype.equals;\n/**\n * Tests if this Long's value differs from the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function notEquals($this, other) {\n    return !equals($this, /* validates */ other);\n}\n;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.neq = LongPrototype.notEquals;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ne = LongPrototype.notEquals;\n/**\n * Tests if this Long's value is less than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThan($this, other) {\n    return compare($this, /* validates */ other) < 0;\n}\n;\n/**\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lt = LongPrototype.lessThan;\n/**\n * Tests if this Long's value is less than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) <= 0;\n}\n;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lte = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.le = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is greater than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThan($this, other) {\n    return compare($this, /* validates */ other) > 0;\n}\n;\n/**\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gt = LongPrototype.greaterThan;\n/**\n * Tests if this Long's value is greater than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) >= 0;\n}\n;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gte = LongPrototype.greaterThanOrEqual;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ge = LongPrototype.greaterThanOrEqual;\n/**\n * Compares this Long's value with the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\nexport function compare($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if (equals($this, other))\n        return 0;\n    var thisNeg = isNegative($this), otherNeg = isNegative(other);\n    if (thisNeg && !otherNeg)\n        return -1;\n    if (!thisNeg && otherNeg)\n        return 1;\n    // At this point the sign bits are the same\n    if (!$this.unsigned)\n        return isNegative(subtract($this, other)) ? -1 : 1;\n    // Both are positive if at least one is unsigned\n    return (other.high >>> 0) > ($this.high >>> 0) || (other.high === $this.high && (other.low >>> 0) > ($this.low >>> 0)) ? -1 : 1;\n}\n;\n/**\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\n// LongPrototype.comp = LongPrototype.compare;\n/**\n * Negates this Long's value.\n * @this {!Long}\n * @returns {!Long} Negated Long\n */\nexport function negate($this) {\n    if (!$this.unsigned && equals($this, MIN_VALUE))\n        return MIN_VALUE;\n    return add(not($this), ONE);\n}\n;\n/**\n * Negates this Long's value. This is an alias of {@link Long#negate}.\n * @function\n * @returns {!Long} Negated Long\n */\n// LongPrototype.neg = LongPrototype.negate;\n/**\n * Returns the sum of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} addend Addend\n * @returns {!Long} Sum\n */\nexport function add($this, addend) {\n    if (!isLong(addend))\n        addend = fromValue(addend);\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = addend.high >>> 16;\n    var b32 = addend.high & 0xFFFF;\n    var b16 = addend.low >>> 16;\n    var b00 = addend.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 + b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 + b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 + b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 + b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the difference of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nexport function subtract($this, subtrahend) {\n    if (!isLong(subtrahend))\n        subtrahend = fromValue(subtrahend);\n    return add($this, negate(subtrahend));\n}\n;\n/**\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\n * @function\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\n// LongPrototype.sub = LongPrototype.subtract;\n/**\n * Returns the product of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nexport function multiply($this, multiplier) {\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    if (!isLong(multiplier))\n        multiplier = fromValue(multiplier);\n    // use wasm support if present\n    if (wasm) {\n        var low = wasm.mul($this.low, $this.high, multiplier.low, multiplier.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero(multiplier))\n        return $this.unsigned ? UZERO : ZERO;\n    if (equals($this, MIN_VALUE))\n        return isOdd(multiplier) ? MIN_VALUE : ZERO;\n    if (equals(multiplier, MIN_VALUE))\n        return isOdd($this) ? MIN_VALUE : ZERO;\n    if (isNegative($this)) {\n        if (isNegative(multiplier))\n            return multiply(negate($this), negate(multiplier));\n        else\n            return negate(multiply(negate($this), multiplier));\n    }\n    else if (isNegative(multiplier))\n        return negate(multiply($this, negate(multiplier)));\n    // If both longs are small, use float multiplication\n    if (lessThan($this, TWO_PWR_24) && lessThan(multiplier, TWO_PWR_24))\n        return fromNumber(toNumber($this) * toNumber(multiplier), $this.unsigned);\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n    // We can skip products that would overflow.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = multiplier.high >>> 16;\n    var b32 = multiplier.high & 0xFFFF;\n    var b16 = multiplier.low >>> 16;\n    var b00 = multiplier.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 * b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 * b00;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c16 += a00 * b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 * b00;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a16 * b16;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a00 * b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\n * @function\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\n// LongPrototype.mul = LongPrototype.multiply;\n/**\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\n *  unsigned if this Long is unsigned.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nexport function divide($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    if (isZero(divisor))\n        throw Error('division by zero');\n    // use wasm support if present\n    if (wasm) {\n        // guard against signed division overflow: the largest\n        // negative number / -1 would be 1 larger than the largest\n        // positive number, due to two's complement.\n        if (!$this.unsigned &&\n            $this.high === -0x80000000 &&\n            divisor.low === -1 && divisor.high === -1) {\n            // be consistent with non-wasm code path\n            return $this;\n        }\n        var low = ($this.unsigned ? wasm.div_u : wasm.div_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    var approx, rem, res;\n    if (!$this.unsigned) {\n        // This section is only relevant for signed longs and is derived from the\n        // closure library as a whole.\n        if (equals($this, MIN_VALUE)) {\n            if (equals(divisor, ONE) || equals(divisor, NEG_ONE))\n                return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE\n            else if (equals(divisor, MIN_VALUE))\n                return ONE;\n            else {\n                // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n                var halfThis = shiftRight($this, 1);\n                approx = shiftLeft(divide(halfThis, divisor), 1);\n                if (equals(approx, ZERO)) {\n                    return isNegative(divisor) ? ONE : NEG_ONE;\n                }\n                else {\n                    rem = subtract($this, multiply(divisor, approx));\n                    res = add(approx, divide(rem, divisor));\n                    return res;\n                }\n            }\n        }\n        else if (equals(divisor, MIN_VALUE))\n            return $this.unsigned ? UZERO : ZERO;\n        if (isNegative($this)) {\n            if (isNegative(divisor))\n                return divide(negate($this), negate(divisor));\n            return negate(divide(negate($this), divisor));\n        }\n        else if (isNegative(divisor))\n            return negate(divide($this, negate(divisor)));\n        res = ZERO;\n    }\n    else {\n        // The algorithm below has not been made for unsigned longs. It's therefore\n        // required to take special care of the MSB prior to running it.\n        if (!divisor.unsigned)\n            divisor = toUnsigned(divisor);\n        if (greaterThan(divisor, $this))\n            return UZERO;\n        if (greaterThan(divisor, shiftRightUnsigned($this, 1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\n            return UONE;\n        res = UZERO;\n    }\n    // Repeat the following until the remainder is less than other:  find a\n    // floating-point that approximates remainder / other *from below*, add this\n    // into the result, and subtract it from the remainder.  It is critical that\n    // the approximate value is less than or equal to the real value so that the\n    // remainder never becomes negative.\n    rem = $this;\n    while (greaterThanOrEqual(rem, divisor)) {\n        // Approximate the result of division. This may be a little greater or\n        // smaller than the actual value.\n        approx = Math.max(1, Math.floor(toNumber(rem) / toNumber(divisor)));\n        // We will tweak the approximate result by changing it in the 48-th digit or\n        // the smallest non-fractional digit, whichever is larger.\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), \n        // Decrease the approximation until it is smaller than the remainder.  Note\n        // that if it is too large, the product overflows and is negative.\n        approxRes = fromNumber(approx), approxRem = multiply(approxRes, divisor);\n        while (isNegative(approxRem) || greaterThan(approxRem, rem)) {\n            approx -= delta;\n            approxRes = fromNumber(approx, $this.unsigned);\n            approxRem = multiply(approxRes, divisor);\n        }\n        // We know the answer can't be zero... and actually, zero would cause\n        // infinite recursion since we would make no progress.\n        if (isZero(approxRes))\n            approxRes = ONE;\n        res = add(res, approxRes);\n        rem = subtract(rem, approxRem);\n    }\n    return res;\n}\n;\n/**\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\n// LongPrototype.div = LongPrototype.divide;\n/**\n * Returns this Long modulo the specified.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nexport function modulo($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    // use wasm support if present\n    if (wasm) {\n        var low = ($this.unsigned ? wasm.rem_u : wasm.rem_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    return subtract($this, multiply(divide($this, divisor), divisor));\n}\n;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.mod = LongPrototype.modulo;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.rem = LongPrototype.modulo;\n/**\n * Returns the bitwise NOT of this Long.\n * @this {!Long}\n * @returns {!Long}\n */\nexport function not($this) {\n    return fromBits(~$this.low, ~$this.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise AND of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function and($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low & other.low, $this.high & other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise OR of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function or($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low | other.low, $this.high | other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise XOR of this Long and the given one.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function xor($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low ^ other.low, $this.high ^ other.high, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftLeft($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits($this.low << numBits, ($this.high << numBits) | ($this.low >>> (32 - numBits)), $this.unsigned);\n    else\n        return fromBits(0, $this.low << (numBits - 32), $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shl = LongPrototype.shiftLeft;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRight($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits(($this.low >>> numBits) | ($this.high << (32 - numBits)), $this.high >> numBits, $this.unsigned);\n    else\n        return fromBits($this.high >> (numBits - 32), $this.high >= 0 ? 0 : -1, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr = LongPrototype.shiftRight;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRightUnsigned($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    numBits &= 63;\n    if (numBits === 0)\n        return $this;\n    else {\n        var high = $this.high;\n        if (numBits < 32) {\n            var low = $this.low;\n            return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, $this.unsigned);\n        }\n        else if (numBits === 32)\n            return fromBits(high, 0, $this.unsigned);\n        else\n            return fromBits(high >>> (numBits - 32), 0, $this.unsigned);\n    }\n}\n;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shru = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits rotated to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateLeft = function rotateLeft(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.low << numBits) | (this.high >>> b)), ((this.high << numBits) | (this.low >>> b)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.high << numBits) | (this.low >>> b)), ((this.low << numBits) | (this.high >>> b)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotl = LongPrototype.rotateLeft;\n/**\n * Returns this Long with bits rotated to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateRight = function rotateRight(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.high << b) | (this.low >>> numBits)), ((this.low << b) | (this.high >>> numBits)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.low << b) | (this.high >>> numBits)), ((this.high << b) | (this.low >>> numBits)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotr = LongPrototype.rotateRight;\n/**\n * Converts this Long to signed.\n * @this {!Long}\n * @returns {!Long} Signed long\n */\nexport function toSigned($this) {\n    if (!$this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, false);\n}\n;\n/**\n * Converts this Long to unsigned.\n * @this {!Long}\n * @returns {!Long} Unsigned long\n */\nexport function toUnsigned($this) {\n    if ($this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, true);\n}\n;\n/**\n * Converts this Long to its byte representation.\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @this {!Long}\n * @returns {!Array.<number>} Byte representation\n */\nexport function toBytes($this, le) {\n    return le ? toBytesLE($this) : toBytesBE($this);\n}\n;\n/**\n * Converts this Long to its little endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Little endian byte representation\n */\nexport function toBytesLE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        lo & 0xff,\n        lo >>> 8 & 0xff,\n        lo >>> 16 & 0xff,\n        lo >>> 24,\n        hi & 0xff,\n        hi >>> 8 & 0xff,\n        hi >>> 16 & 0xff,\n        hi >>> 24\n    ];\n}\n;\n/**\n * Converts this Long to its big endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Big endian byte representation\n */\nexport function toBytesBE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        hi >>> 24,\n        hi >>> 16 & 0xff,\n        hi >>> 8 & 0xff,\n        hi & 0xff,\n        lo >>> 24,\n        lo >>> 16 & 0xff,\n        lo >>> 8 & 0xff,\n        lo & 0xff\n    ];\n}\n;\n/**\n * Creates a Long from its byte representation.\n * @param {!Array.<number>} bytes Byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytes(bytes, unsigned, le) {\n    return le ? fromBytesLE(bytes, unsigned) : fromBytesBE(bytes, unsigned);\n}\n;\n/**\n * Creates a Long from its little endian byte representation.\n * @param {!Array.<number>} bytes Little endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesLE(bytes, unsigned) {\n    return new Long(bytes[0] |\n        bytes[1] << 8 |\n        bytes[2] << 16 |\n        bytes[3] << 24, bytes[4] |\n        bytes[5] << 8 |\n        bytes[6] << 16 |\n        bytes[7] << 24, unsigned);\n}\n;\n/**\n * Creates a Long from its big endian byte representation.\n * @param {!Array.<number>} bytes Big endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesBE(bytes, unsigned) {\n    return new Long(bytes[4] << 24 |\n        bytes[5] << 16 |\n        bytes[6] << 8 |\n        bytes[7], bytes[0] << 24 |\n        bytes[1] << 16 |\n        bytes[2] << 8 |\n        bytes[3], unsigned);\n}\n;\n","import { isValid } from \"./Int32.js\";\nimport * as LongLib from \"./lib/long.js\";\nexport default LongLib.Long;\nexport const get_Zero = LongLib.ZERO;\nexport const get_One = LongLib.ONE;\nexport const op_Addition = LongLib.add;\nexport const op_Subtraction = LongLib.subtract;\nexport const op_Multiply = LongLib.multiply;\nexport const op_Division = LongLib.divide;\nexport const op_Modulus = LongLib.modulo;\nexport const op_UnaryNegation = LongLib.negate;\nexport const op_LeftShift = LongLib.shiftLeft;\nexport const op_RightShift = LongLib.shiftRight;\nexport const op_RightShiftUnsigned = LongLib.shiftRightUnsigned;\nexport const op_BitwiseAnd = LongLib.and;\nexport const op_BitwiseOr = LongLib.or;\nexport const op_ExclusiveOr = LongLib.xor;\nexport const op_LogicalNot = LongLib.not;\nexport const op_LessThan = LongLib.lessThan;\nexport const op_LessThanOrEqual = LongLib.lessThanOrEqual;\nexport const op_GreaterThan = LongLib.greaterThan;\nexport const op_GreaterThanOrEqual = LongLib.greaterThanOrEqual;\nexport const op_Equality = LongLib.equals;\nexport const op_Inequality = LongLib.notEquals;\nexport const equals = LongLib.equals;\nexport const compare = LongLib.compare;\nexport const fromInt = LongLib.fromInt;\nexport const fromBits = LongLib.fromBits;\nexport const fromBytes = LongLib.fromBytes;\nexport const fromNumber = LongLib.fromNumber;\nexport const fromString = LongLib.fromString;\nexport const fromValue = LongLib.fromValue;\nexport const toInt = LongLib.toInt;\nexport const toBytes = LongLib.toBytes;\nexport const toNumber = LongLib.toNumber;\nexport const toString = LongLib.toString;\nexport const getLowBits = LongLib.getLowBits;\nexport const getHighBits = LongLib.getHighBits;\nexport const getLowBitsUnsigned = LongLib.getLowBitsUnsigned;\nexport const getHighBitsUnsigned = LongLib.getHighBitsUnsigned;\nfunction getMaxValue(unsigned, radix, isNegative) {\n    switch (radix) {\n        case 2: return unsigned ?\n            \"1111111111111111111111111111111111111111111111111111111111111111\" :\n            (isNegative ? \"1000000000000000000000000000000000000000000000000000000000000000\"\n                : \"111111111111111111111111111111111111111111111111111111111111111\");\n        case 8: return unsigned ?\n            \"1777777777777777777777\" :\n            (isNegative ? \"1000000000000000000000\" : \"777777777777777777777\");\n        case 10: return unsigned ?\n            \"18446744073709551615\" :\n            (isNegative ? \"9223372036854775808\" : \"9223372036854775807\");\n        case 16: return unsigned ?\n            \"FFFFFFFFFFFFFFFF\" :\n            (isNegative ? \"8000000000000000\" : \"7FFFFFFFFFFFFFFF\");\n        default: throw new Error(\"Invalid radix.\");\n    }\n}\nexport function abs(x) {\n    if (!x.unsigned && LongLib.isNegative(x)) {\n        return op_UnaryNegation(x);\n    }\n    else {\n        return x;\n    }\n}\nexport function fromInteger(value, unsigned, kind) {\n    let x = value;\n    let xh = 0;\n    switch (kind) {\n        case 0:\n            x = value << 24 >> 24;\n            xh = x;\n            break;\n        case 4:\n            x = value << 24 >>> 24;\n            break;\n        case 1:\n            x = value << 16 >> 16;\n            xh = x;\n            break;\n        case 5:\n            x = value << 16 >>> 16;\n            break;\n        case 2:\n            x = value >> 0;\n            xh = x;\n            break;\n        case 6:\n            x = value >>> 0;\n            break;\n    }\n    return LongLib.fromBits(x, xh >> 31, unsigned);\n}\nexport function parse(str, style, unsigned, _bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        const lessOrEqual = (x, y) => {\n            const len = Math.max(x.length, y.length);\n            return x.padStart(len, \"0\") <= y.padStart(len, \"0\");\n        };\n        const isNegative = res.sign === \"-\";\n        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);\n        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {\n            str = isNegative ? res.sign + res.digits : res.digits;\n            return LongLib.fromString(str, unsigned, res.radix);\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function unixEpochMillisecondsToTicks(ms, offset) {\n    return op_Multiply(op_Addition(op_Addition(LongLib.fromNumber(ms), 62135596800000), offset), 10000);\n}\nexport function ticksToUnixEpochMilliseconds(ticks) {\n    return LongLib.toNumber(op_Subtraction(op_Division(ticks, 10000), 62135596800000));\n}\n// export function makeRangeStepFunction(step: Long, last: Long, unsigned: boolean) {\n//   const stepComparedWithZero = LongLib.compare(step, unsigned ? LongLib.UZERO : LongLib.ZERO);\n//   if (stepComparedWithZero === 0) {\n//     throw new Error(\"The step of a range cannot be zero\");\n//   }\n//   const stepGreaterThanZero = stepComparedWithZero > 0;\n//   return (x: Long) => {\n//     const comparedWithLast = LongLib.compare(x, last);\n//     if ((stepGreaterThanZero && comparedWithLast <= 0)\n//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n//       return [x, op_Addition(x, step)];\n//     } else {\n//       return undefined;\n//     }\n//   };\n// }\nexport function divRem(x, y, out) {\n    const div = op_Division(x, y);\n    const rem = op_Modulus(x, y);\n    if (out != null) {\n        out.contents = rem;\n        return div;\n    }\n    else {\n        return [div, rem];\n    }\n}\n","/**\n * DateTimeOffset functions.\n *\n * Note: Date instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, dateOffset, padWithZeros } from \"./Util.js\";\nexport function dateOffsetToString(offset) {\n    const isMinus = offset < 0;\n    offset = Math.abs(offset);\n    const hours = ~~(offset / 3600000);\n    const minutes = (offset % 3600000) / 60000;\n    return (isMinus ? \"-\" : \"+\") +\n        padWithZeros(hours, 2) + \":\" +\n        padWithZeros(minutes, 2);\n}\nexport function dateToHalfUTCString(date, half) {\n    const str = date.toISOString();\n    return half === \"first\"\n        ? str.substring(0, str.indexOf(\"T\"))\n        : str.substring(str.indexOf(\"T\") + 1, str.length - 1);\n}\nfunction dateToISOString(d, utc) {\n    if (utc) {\n        return d.toISOString();\n    }\n    else {\n        // JS Date is always local\n        const printOffset = d.kind == null ? true : d.kind === 2 /* Local */;\n        return padWithZeros(d.getFullYear(), 4) + \"-\" +\n            padWithZeros(d.getMonth() + 1, 2) + \"-\" +\n            padWithZeros(d.getDate(), 2) + \"T\" +\n            padWithZeros(d.getHours(), 2) + \":\" +\n            padWithZeros(d.getMinutes(), 2) + \":\" +\n            padWithZeros(d.getSeconds(), 2) + \".\" +\n            padWithZeros(d.getMilliseconds(), 3) +\n            (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -60000) : \"\");\n    }\n}\nfunction dateToISOStringWithOffset(dateWithOffset, offset) {\n    const str = dateWithOffset.toISOString();\n    return str.substring(0, str.length - 1) + dateOffsetToString(offset);\n}\nfunction dateToStringWithCustomFormat(date, format, utc) {\n    return format.replace(/(\\w)\\1*/g, (match) => {\n        let rep = Number.NaN;\n        switch (match.substring(0, 1)) {\n            case \"y\":\n                const y = utc ? date.getUTCFullYear() : date.getFullYear();\n                rep = match.length < 4 ? y % 100 : y;\n                break;\n            case \"M\":\n                rep = (utc ? date.getUTCMonth() : date.getMonth()) + 1;\n                break;\n            case \"d\":\n                rep = utc ? date.getUTCDate() : date.getDate();\n                break;\n            case \"H\":\n                rep = utc ? date.getUTCHours() : date.getHours();\n                break;\n            case \"h\":\n                const h = utc ? date.getUTCHours() : date.getHours();\n                rep = h > 12 ? h % 12 : h;\n                break;\n            case \"m\":\n                rep = utc ? date.getUTCMinutes() : date.getMinutes();\n                break;\n            case \"s\":\n                rep = utc ? date.getUTCSeconds() : date.getSeconds();\n                break;\n            case \"f\":\n                rep = utc ? date.getUTCMilliseconds() : date.getMilliseconds();\n                break;\n        }\n        if (Number.isNaN(rep)) {\n            return match;\n        }\n        else {\n            return (rep < 10 && match.length > 1) ? \"0\" + rep : \"\" + rep;\n        }\n    });\n}\nfunction dateToStringWithOffset(date, format) {\n    var _a, _b, _c;\n    const d = new Date(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0));\n    if (typeof format !== \"string\") {\n        return d.toISOString().replace(/\\.\\d+/, \"\").replace(/[A-Z]|\\.\\d+/g, \" \") + dateOffsetToString(((_b = date.offset) !== null && _b !== void 0 ? _b : 0));\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\": return dateToHalfUTCString(d, \"first\");\n            case \"T\":\n            case \"t\": return dateToHalfUTCString(d, \"second\");\n            case \"O\":\n            case \"o\": return dateToISOStringWithOffset(d, ((_c = date.offset) !== null && _c !== void 0 ? _c : 0));\n            default: throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(d, format, true);\n    }\n}\nfunction dateToStringWithKind(date, format) {\n    const utc = date.kind === 1 /* UTC */;\n    if (typeof format !== \"string\") {\n        return utc ? date.toUTCString() : date.toLocaleString();\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\":\n                return utc ? dateToHalfUTCString(date, \"first\") : date.toLocaleDateString();\n            case \"T\":\n            case \"t\":\n                return utc ? dateToHalfUTCString(date, \"second\") : date.toLocaleTimeString();\n            case \"O\":\n            case \"o\":\n                return dateToISOString(date, utc);\n            default:\n                throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(date, format, utc);\n    }\n}\nexport function toString(date, format, _provider) {\n    return date.offset != null\n        ? dateToStringWithOffset(date, format)\n        : dateToStringWithKind(date, format);\n}\nexport function DateTime(value, kind) {\n    const d = new Date(value);\n    d.kind = (kind == null ? 0 /* Unspecified */ : kind) | 0;\n    return d;\n}\nexport function fromTicks(ticks, kind) {\n    ticks = fromValue(ticks);\n    kind = kind != null ? kind : 2 /* Local */; // better default than Unspecified\n    let date = DateTime(ticksToUnixEpochMilliseconds(ticks), kind);\n    // Ticks are local to offset (in this case, either UTC or Local/Unknown).\n    // If kind is anything but UTC, that means that the tick number was not\n    // in utc, thus getTime() cannot return UTC, and needs to be shifted.\n    if (kind !== 1 /* UTC */) {\n        date = DateTime(date.getTime() - dateOffset(date), kind);\n    }\n    return date;\n}\nexport function fromDateTimeOffset(date, kind) {\n    var _a;\n    switch (kind) {\n        case 1 /* UTC */: return DateTime(date.getTime(), 1 /* UTC */);\n        case 2 /* Local */: return DateTime(date.getTime(), 2 /* Local */);\n        default:\n            const d = DateTime(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0), kind);\n            return DateTime(d.getTime() - dateOffset(d), kind);\n    }\n}\nexport function getTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), dateOffset(date));\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTime(-62135596800000, 0 /* Unspecified */);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTime(253402300799999, 0 /* Unspecified */);\n}\nexport function parseRaw(input) {\n    function fail() {\n        throw new Error(`The string is not a valid Date: ${input}`);\n    }\n    if (input == null || input.trim() === \"\") {\n        fail();\n    }\n    // ISO dates without TZ are parsed as UTC. Adding time without TZ keeps them local.\n    if (input.length === 10 && input[4] === \"-\" && input[7] === \"-\") {\n        input += \"T00:00:00\";\n    }\n    let date = new Date(input);\n    let offset = null;\n    if (isNaN(date.getTime())) {\n        // Try to check strings JS Date cannot parse (see #1045, #1422)\n        // tslint:disable-next-line:max-line-length\n        const m = /^\\s*(\\d+[^\\w\\s:]\\d+[^\\w\\s:]\\d+)?\\s*(\\d+:\\d+(?::\\d+(?:\\.\\d+)?)?)?\\s*([AaPp][Mm])?\\s*(Z|[+-]([01]?\\d):?([0-5]?\\d)?)?\\s*$/.exec(input);\n        if (m != null) {\n            let baseDate;\n            let timeInSeconds = 0;\n            if (m[2] != null) {\n                const timeParts = m[2].split(\":\");\n                timeInSeconds =\n                    parseInt(timeParts[0], 10) * 3600 +\n                        parseInt(timeParts[1] || \"0\", 10) * 60 +\n                        parseFloat(timeParts[2] || \"0\");\n                if (m[3] != null && m[3].toUpperCase() === \"PM\") {\n                    timeInSeconds += 720;\n                }\n            }\n            if (m[4] != null) { // There's an offset, parse as UTC\n                if (m[1] != null) {\n                    baseDate = new Date(m[1] + \" UTC\");\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getUTCFullYear() + \"/\" + (d.getUTCMonth() + 1) + \"/\" + d.getUTCDate());\n                }\n                if (m[4] === \"Z\") {\n                    offset = \"Z\";\n                }\n                else {\n                    let offsetInMinutes = parseInt(m[5], 10) * 60 + parseInt(m[6] || \"0\", 10);\n                    if (m[4][0] === \"-\") {\n                        offsetInMinutes *= -1;\n                    }\n                    offset = offsetInMinutes;\n                    timeInSeconds -= offsetInMinutes * 60;\n                }\n            }\n            else {\n                if (m[1] != null) {\n                    baseDate = new Date(m[1]);\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getFullYear() + \"/\" + (d.getMonth() + 1) + \"/\" + d.getDate());\n                }\n            }\n            date = new Date(baseDate.getTime() + timeInSeconds * 1000);\n            // correct for daylight savings time\n            date = new Date(date.getTime() + (date.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 60000);\n        }\n        else {\n            fail();\n        }\n        // Check again the date is valid after transformations, see #2229\n        if (isNaN(date.getTime())) {\n            fail();\n        }\n    }\n    return [date, offset];\n}\nexport function parse(str, detectUTC = false) {\n    const [date, offset] = parseRaw(str);\n    // .NET always parses DateTime as Local if there's offset info (even \"Z\")\n    // Newtonsoft.Json uses UTC if the offset is \"Z\"\n    const kind = offset != null\n        ? (detectUTC && offset === \"Z\" ? 1 /* UTC */ : 2 /* Local */)\n        : 0 /* Unspecified */;\n    return DateTime(date.getTime(), kind);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {\n    const dateValue = kind === 1 /* UTC */\n        ? Date.UTC(year, month - 1, day, h, m, s, ms)\n        : new Date(year, month - 1, day, h, m, s, ms).getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date.\");\n    }\n    const date = DateTime(dateValue, kind);\n    if (year <= 99) {\n        date.setFullYear(year, month - 1, day);\n    }\n    return date;\n}\nexport function now() {\n    return DateTime(Date.now(), 2 /* Local */);\n}\nexport function utcNow() {\n    return DateTime(Date.now(), 1 /* UTC */);\n}\nexport function today() {\n    return date(now());\n}\nexport function isLeapYear(year) {\n    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n}\nexport function daysInMonth(year, month) {\n    return month === 2\n        ? (isLeapYear(year) ? 29 : 28)\n        : (month >= 8 ? (month % 2 === 0 ? 31 : 30) : (month % 2 === 0 ? 30 : 31));\n}\nexport function toUniversalTime(date) {\n    return date.kind === 1 /* UTC */ ? date : DateTime(date.getTime(), 1 /* UTC */);\n}\nexport function toLocalTime(date) {\n    return date.kind === 2 /* Local */ ? date : DateTime(date.getTime(), 2 /* Local */);\n}\nexport function specifyKind(d, kind) {\n    return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), kind);\n}\nexport function timeOfDay(d) {\n    return hour(d) * 3600000\n        + minute(d) * 60000\n        + second(d) * 1000\n        + millisecond(d);\n}\nexport function date(d) {\n    return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);\n}\nexport function day(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDate() : d.getDate();\n}\nexport function hour(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCHours() : d.getHours();\n}\nexport function millisecond(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMilliseconds() : d.getMilliseconds();\n}\nexport function minute(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMinutes() : d.getMinutes();\n}\nexport function month(d) {\n    return (d.kind === 1 /* UTC */ ? d.getUTCMonth() : d.getMonth()) + 1;\n}\nexport function second(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCSeconds() : d.getSeconds();\n}\nexport function year(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCFullYear() : d.getFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDay() : d.getDay();\n}\nexport function dayOfYear(d) {\n    const _year = year(d);\n    const _month = month(d);\n    let _day = day(d);\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    const newDate = DateTime(d.getTime() + ts, d.kind);\n    if (d.kind === 2 /* Local */) {\n        const oldTzOffset = d.getTimezoneOffset();\n        const newTzOffset = newDate.getTimezoneOffset();\n        return oldTzOffset !== newTzOffset\n            ? DateTime(newDate.getTime() + (newTzOffset - oldTzOffset) * 60000, d.kind)\n            : newDate;\n    }\n    else {\n        return newDate;\n    }\n}\nexport function addDays(d, v) {\n    return add(d, v * 86400000);\n}\nexport function addHours(d, v) {\n    return add(d, v * 3600000);\n}\nexport function addMinutes(d, v) {\n    return add(d, v * 60000);\n}\nexport function addSeconds(d, v) {\n    return add(d, v * 1000);\n}\nexport function addMilliseconds(d, v) {\n    return add(d, v);\n}\nexport function addYears(d, v) {\n    const newMonth = month(d);\n    const newYear = year(d) + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function addMonths(d, v) {\n    let newMonth = month(d) + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = year(d) + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function subtract(d, that) {\n    return typeof that === \"number\"\n        ? add(d, -that)\n        : d.getTime() - that.getTime();\n}\nexport function toLongDateString(d) {\n    return d.toDateString();\n}\nexport function toShortDateString(d) {\n    return d.toLocaleDateString();\n}\nexport function toLongTimeString(d) {\n    return d.toLocaleTimeString();\n}\nexport function toShortTimeString(d) {\n    return d.toLocaleTimeString().replace(/:\\d\\d(?!:)/, \"\");\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport const compare = compareDates;\nexport const compareTo = compareDates;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function isDaylightSavingTime(x) {\n    const jan = new Date(x.getFullYear(), 0, 1);\n    const jul = new Date(x.getFullYear(), 6, 1);\n    return isDST(jan.getTimezoneOffset(), jul.getTimezoneOffset(), x.getTimezoneOffset());\n}\nfunction isDST(janOffset, julOffset, tOffset) {\n    return Math.min(janOffset, julOffset) === tOffset;\n}\nexport default DateTime;\n","export function create(pattern, options = 0) {\n    // Supported RegexOptions\n    // * IgnoreCase:  0x0001\n    // * Multiline:   0x0002\n    // * Singleline:  0x0010\n    // * ECMAScript:  0x0100 (ignored)\n    if ((options & ~(1 ^ 2 ^ 16 ^ 256)) !== 0) {\n        throw new Error(\"RegexOptions only supports: IgnoreCase, Multiline, Singleline and ECMAScript\");\n    }\n    let flags = \"g\";\n    flags += options & 1 ? \"i\" : \"\"; // 0x0001 RegexOptions.IgnoreCase\n    flags += options & 2 ? \"m\" : \"\";\n    flags += options & 16 ? \"s\" : \"\";\n    return new RegExp(pattern, flags);\n}\n// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex\nexport function escape(str) {\n    return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n}\nexport function unescape(str) {\n    return str.replace(/\\\\([\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|])/g, \"$1\");\n}\nexport function isMatch(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    return reg.test(input);\n}\nexport function match(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    return reg.exec(input);\n}\nexport function matches(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    if (!reg.global) {\n        throw new Error(\"Non-global RegExp\"); // Prevent infinite loop\n    }\n    let m = reg.exec(input);\n    const matches = [];\n    while (m !== null) {\n        matches.push(m);\n        m = reg.exec(input);\n    }\n    return matches;\n}\nexport function options(reg) {\n    let options = 256; // ECMAScript\n    options |= reg.ignoreCase ? 1 : 0;\n    options |= reg.multiline ? 2 : 0;\n    return options;\n}\nexport function replace(reg, input, replacement, limit, offset = 0) {\n    function replacer() {\n        let res = arguments[0];\n        if (limit) {\n            limit--;\n            const match = [];\n            const len = arguments.length;\n            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter\n            // * match: matched substring\n            // * p1, p2, ...: nth capture group string\n            // * offset: offset of matched substring\n            // * string: whole string examined\n            // * groups: named capturing groups\n            //           ONLY if regex contains a named capture group AND browser supports named groups\n            // -> last element can be groups OR input string\n            // -> check if last element is string\n            const withGroups = typeof arguments[len - 1] !== \"string\";\n            let pLast = withGroups ? len - 3 : len - 2;\n            for (let i = 0; i < pLast; i++) {\n                match.push(arguments[i]);\n            }\n            match.index = arguments[pLast++];\n            match.input = arguments[pLast++];\n            if (withGroups) {\n                match.groups = arguments[pLast];\n            }\n            res = replacement(match);\n        }\n        return res;\n    }\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    if (typeof replacement === \"function\") {\n        limit = limit == null ? -1 : limit;\n        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);\n    }\n    else {\n        replacement =\n            replacement\n                // $0 doesn't work with JS regex, see #1155\n                .replace(/\\$0/g, (_s) => \"$&\")\n                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)\n                .replace(/\\${([^}]+)}/g, \"\\$<$1>\");\n        if (limit != null) {\n            let m;\n            const sub1 = input.substring(offset);\n            const _matches = matches(reg, sub1);\n            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;\n            return input.substring(0, offset) + sub2.replace(reg, replacement)\n                + input.substring(offset + sub2.length);\n        }\n        else {\n            return input.replace(reg, replacement);\n        }\n    }\n}\nexport function split(reg, input, limit, offset = 0) {\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    input = input.substring(offset);\n    return input.split(reg, limit);\n}\n","import { toString as dateToString } from \"./Date.js\";\nimport { compare as numericCompare, isNumeric, multiply, toExponential, toFixed, toHex, toPrecision } from \"./Numeric.js\";\nimport { escape } from \"./RegExp.js\";\nimport { toString } from \"./Types.js\";\nconst fsFormatRegExp = /(^|[^%])%([0+\\- ]*)(\\*|\\d+)?(?:\\.(\\d+))?(\\w)/g;\nconst interpolateRegExp = /(?:(^|[^%])%([0+\\- ]*)(\\d+)?(?:\\.(\\d+))?(\\w))?%P\\(\\)/g;\nconst formatRegExp = /\\{(\\d+)(,-?\\d+)?(?:\\:([a-zA-Z])(\\d{0,2})|\\:(.+?))?\\}/g;\nfunction isLessThan(x, y) {\n    return numericCompare(x, y) < 0;\n}\nfunction cmp(x, y, ic) {\n    function isIgnoreCase(i) {\n        return i === true ||\n            i === 1 /* CurrentCultureIgnoreCase */ ||\n            i === 3 /* InvariantCultureIgnoreCase */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    function isOrdinal(i) {\n        return i === 4 /* Ordinal */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    if (y == null) {\n        return 1;\n    } // everything is bigger than null\n    if (isOrdinal(ic)) {\n        if (isIgnoreCase(ic)) {\n            x = x.toLowerCase();\n            y = y.toLowerCase();\n        }\n        return (x === y) ? 0 : (x < y ? -1 : 1);\n    }\n    else {\n        if (isIgnoreCase(ic)) {\n            x = x.toLocaleLowerCase();\n            y = y.toLocaleLowerCase();\n        }\n        return x.localeCompare(y);\n    }\n}\nexport function compare(...args) {\n    switch (args.length) {\n        case 2: return cmp(args[0], args[1], false);\n        case 3: return cmp(args[0], args[1], args[2]);\n        case 4: return cmp(args[0], args[1], args[2] === true);\n        case 5: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), false);\n        case 6: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5]);\n        case 7: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5] === true);\n        default: throw new Error(\"String.compare: Unsupported number of parameters\");\n    }\n}\nexport function compareOrdinal(x, y) {\n    return cmp(x, y, 4 /* Ordinal */);\n}\nexport function compareTo(x, y) {\n    return cmp(x, y, 0 /* CurrentCulture */);\n}\nexport function startsWith(str, pattern, ic) {\n    if (str.length >= pattern.length) {\n        return cmp(str.substr(0, pattern.length), pattern, ic) === 0;\n    }\n    return false;\n}\nexport function indexOfAny(str, anyOf, ...args) {\n    if (str == null || str === \"\") {\n        return -1;\n    }\n    const startIndex = (args.length > 0) ? args[0] : 0;\n    if (startIndex < 0) {\n        throw new Error(\"Start index cannot be negative\");\n    }\n    const length = (args.length > 1) ? args[1] : str.length - startIndex;\n    if (length < 0) {\n        throw new Error(\"Length cannot be negative\");\n    }\n    if (length > str.length - startIndex) {\n        throw new Error(\"Invalid startIndex and length\");\n    }\n    str = str.substr(startIndex, length);\n    for (const c of anyOf) {\n        const index = str.indexOf(c);\n        if (index > -1) {\n            return index + startIndex;\n        }\n    }\n    return -1;\n}\nexport function printf(input) {\n    return {\n        input,\n        cont: fsFormat(input),\n    };\n}\nexport function interpolate(str, values) {\n    let valIdx = 0;\n    let strIdx = 0;\n    let result = \"\";\n    interpolateRegExp.lastIndex = 0;\n    let match = interpolateRegExp.exec(str);\n    while (match) {\n        // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char\n        // Note: we don't use negative lookbehind because some browsers don't support it yet\n        const matchIndex = match.index + (match[1] || \"\").length;\n        result += str.substring(strIdx, matchIndex).replace(/%%/g, \"%\");\n        const [, , flags, padLength, precision, format] = match;\n        result += formatReplacement(values[valIdx++], flags, padLength, precision, format);\n        strIdx = interpolateRegExp.lastIndex;\n        // Likewise we need to move interpolateRegExp.lastIndex one char behind to make sure we match the no-escape char next time\n        interpolateRegExp.lastIndex -= 1;\n        match = interpolateRegExp.exec(str);\n    }\n    result += str.substring(strIdx).replace(/%%/g, \"%\");\n    return result;\n}\nfunction continuePrint(cont, arg) {\n    return typeof arg === \"string\" ? cont(arg) : arg.cont(cont);\n}\nexport function toConsole(arg) {\n    // Don't remove the lambda here, see #1357\n    return continuePrint((x) => console.log(x), arg);\n}\nexport function toConsoleError(arg) {\n    return continuePrint((x) => console.error(x), arg);\n}\nexport function toText(arg) {\n    return continuePrint((x) => x, arg);\n}\nexport function toFail(arg) {\n    return continuePrint((x) => {\n        throw new Error(x);\n    }, arg);\n}\nfunction formatReplacement(rep, flags, padLength, precision, format) {\n    let sign = \"\";\n    flags = flags || \"\";\n    format = format || \"\";\n    if (isNumeric(rep)) {\n        if (format.toLowerCase() !== \"x\") {\n            if (isLessThan(rep, 0)) {\n                rep = multiply(rep, -1);\n                sign = \"-\";\n            }\n            else {\n                if (flags.indexOf(\" \") >= 0) {\n                    sign = \" \";\n                }\n                else if (flags.indexOf(\"+\") >= 0) {\n                    sign = \"+\";\n                }\n            }\n        }\n        precision = precision == null ? null : parseInt(precision, 10);\n        switch (format) {\n            case \"f\":\n            case \"F\":\n                precision = precision != null ? precision : 6;\n                rep = toFixed(rep, precision);\n                break;\n            case \"g\":\n            case \"G\":\n                rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                break;\n            case \"e\":\n            case \"E\":\n                rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                break;\n            case \"x\":\n                rep = toHex(rep);\n                break;\n            case \"X\":\n                rep = toHex(rep).toUpperCase();\n                break;\n            default: // AOid\n                rep = String(rep);\n                break;\n        }\n    }\n    else if (rep instanceof Date) {\n        rep = dateToString(rep);\n    }\n    else {\n        rep = toString(rep);\n    }\n    padLength = typeof padLength === \"number\" ? padLength : parseInt(padLength, 10);\n    if (!isNaN(padLength)) {\n        const zeroFlag = flags.indexOf(\"0\") >= 0; // Use '0' for left padding\n        const minusFlag = flags.indexOf(\"-\") >= 0; // Right padding\n        const ch = minusFlag || !zeroFlag ? \" \" : \"0\";\n        if (ch === \"0\") {\n            rep = padLeft(rep, padLength - sign.length, ch, minusFlag);\n            rep = sign + rep;\n        }\n        else {\n            rep = padLeft(sign + rep, padLength, ch, minusFlag);\n        }\n    }\n    else {\n        rep = sign + rep;\n    }\n    return rep;\n}\nfunction createPrinter(cont, _strParts, _matches, _result = \"\", padArg = -1) {\n    return (...args) => {\n        // Make copies of the values passed by reference because the function can be used multiple times\n        let result = _result;\n        const strParts = _strParts.slice();\n        const matches = _matches.slice();\n        for (const arg of args) {\n            const [, , flags, _padLength, precision, format] = matches[0];\n            let padLength = _padLength;\n            if (padArg >= 0) {\n                padLength = padArg;\n                padArg = -1;\n            }\n            else if (padLength === \"*\") {\n                if (arg < 0) {\n                    throw new Error(\"Non-negative number required\");\n                }\n                padArg = arg;\n                continue;\n            }\n            result += strParts[0];\n            result += formatReplacement(arg, flags, padLength, precision, format);\n            strParts.splice(0, 1);\n            matches.splice(0, 1);\n        }\n        if (matches.length === 0) {\n            result += strParts[0];\n            return cont(result);\n        }\n        else {\n            return createPrinter(cont, strParts, matches, result, padArg);\n        }\n    };\n}\nexport function fsFormat(str) {\n    return (cont) => {\n        fsFormatRegExp.lastIndex = 0;\n        const strParts = [];\n        const matches = [];\n        let strIdx = 0;\n        let match = fsFormatRegExp.exec(str);\n        while (match) {\n            // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char\n            // Note: we don't use negative lookbehind because some browsers don't support it yet\n            const matchIndex = match.index + (match[1] || \"\").length;\n            strParts.push(str.substring(strIdx, matchIndex).replace(/%%/g, \"%\"));\n            matches.push(match);\n            strIdx = fsFormatRegExp.lastIndex;\n            // Likewise we need to move fsFormatRegExp.lastIndex one char behind to make sure we match the no-escape char next time\n            fsFormatRegExp.lastIndex -= 1;\n            match = fsFormatRegExp.exec(str);\n        }\n        if (strParts.length === 0) {\n            return cont(str.replace(/%%/g, \"%\"));\n        }\n        else {\n            strParts.push(str.substring(strIdx).replace(/%%/g, \"%\"));\n            return createPrinter(cont, strParts, matches);\n        }\n    };\n}\nexport function format(str, ...args) {\n    if (typeof str === \"object\" && args.length > 0) {\n        // Called with culture info\n        str = args[0];\n        args.shift();\n    }\n    return str.replace(formatRegExp, (_, idx, padLength, format, precision, pattern) => {\n        if (idx < 0 || idx >= args.length) {\n            throw new Error(\"Index must be greater or equal to zero and less than the arguments' length.\");\n        }\n        let rep = args[idx];\n        if (isNumeric(rep)) {\n            precision = precision == null ? null : parseInt(precision, 10);\n            switch (format) {\n                case \"f\":\n                case \"F\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(rep, precision);\n                    break;\n                case \"g\":\n                case \"G\":\n                    rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                    break;\n                case \"e\":\n                case \"E\":\n                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                    break;\n                case \"p\":\n                case \"P\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(multiply(rep, 100), precision) + \" %\";\n                    break;\n                case \"d\":\n                case \"D\":\n                    rep = precision != null ? padLeft(String(rep), precision, \"0\") : String(rep);\n                    break;\n                case \"x\":\n                case \"X\":\n                    rep = precision != null ? padLeft(toHex(rep), precision, \"0\") : toHex(rep);\n                    if (format === \"X\") {\n                        rep = rep.toUpperCase();\n                    }\n                    break;\n                default:\n                    if (pattern) {\n                        let sign = \"\";\n                        rep = pattern.replace(/([0#,]+)(\\.[0#]+)?/, (_, intPart, decimalPart) => {\n                            if (isLessThan(rep, 0)) {\n                                rep = multiply(rep, -1);\n                                sign = \"-\";\n                            }\n                            const decimalPartLength = decimalPart != null ? decimalPart.length : 0;\n                            rep = toFixed(rep, Math.max(decimalPartLength - 1, 0));\n                            // Thousands separator\n                            if (intPart.indexOf(\",\") > 0) {\n                                const [intPart, decimalPart] = rep.split(\".\");\n                                const i = intPart.length % 3;\n                                const thousandGroups = Math.floor(intPart.length / 3);\n                                let thousands = i > 0 ? intPart.substr(0, i) + (thousandGroups > 0 ? \",\" : \"\") : \"\";\n                                for (let j = 0; j < thousandGroups; j++) {\n                                    thousands += intPart.substr(i + j * 3, 3) + (j < thousandGroups - 1 ? \",\" : \"\");\n                                }\n                                rep = decimalPart ? thousands + \".\" + decimalPart : thousands;\n                            }\n                            // In .NET you can mix 0/# placeholders but for simplicity we only check the left most character\n                            intPart = intPart.replace(/,/g, \"\");\n                            const intPartLength = intPart.length > 0 && intPart[0] === \"0\" ? intPart.length : 0;\n                            return padLeft(rep, intPartLength - sign.length + decimalPartLength, \"0\");\n                        });\n                        rep = sign + rep;\n                    }\n            }\n        }\n        else if (rep instanceof Date) {\n            rep = dateToString(rep, pattern || format);\n        }\n        else {\n            rep = toString(rep);\n        }\n        padLength = parseInt((padLength || \" \").substring(1), 10);\n        if (!isNaN(padLength)) {\n            rep = padLeft(String(rep), Math.abs(padLength), \" \", padLength < 0);\n        }\n        return rep;\n    });\n}\nexport function endsWith(str, search) {\n    const idx = str.lastIndexOf(search);\n    return idx >= 0 && idx === str.length - search.length;\n}\nexport function initialize(n, f) {\n    if (n < 0) {\n        throw new Error(\"String length must be non-negative\");\n    }\n    const xs = new Array(n);\n    for (let i = 0; i < n; i++) {\n        xs[i] = f(i);\n    }\n    return xs.join(\"\");\n}\nexport function insert(str, startIndex, value) {\n    if (startIndex < 0 || startIndex > str.length) {\n        throw new Error(\"startIndex is negative or greater than the length of this instance.\");\n    }\n    return str.substring(0, startIndex) + value + str.substring(startIndex);\n}\nexport function isNullOrEmpty(str) {\n    return typeof str !== \"string\" || str.length === 0;\n}\nexport function isNullOrWhiteSpace(str) {\n    return typeof str !== \"string\" || /^\\s*$/.test(str);\n}\nexport function concat(...xs) {\n    return xs.map((x) => String(x)).join(\"\");\n}\nexport function join(delimiter, xs) {\n    if (Array.isArray(xs)) {\n        return xs.join(delimiter);\n    }\n    else {\n        return Array.from(xs).join(delimiter);\n    }\n}\nexport function joinWithIndices(delimiter, xs, startIndex, count) {\n    const endIndexPlusOne = startIndex + count;\n    if (endIndexPlusOne > xs.length) {\n        throw new Error(\"Index and count must refer to a location within the buffer.\");\n    }\n    return xs.slice(startIndex, endIndexPlusOne).join(delimiter);\n}\nfunction notSupported(name) {\n    throw new Error(\"The environment doesn't support '\" + name + \"', please use a polyfill.\");\n}\nexport function toBase64String(inArray) {\n    let str = \"\";\n    for (let i = 0; i < inArray.length; i++) {\n        str += String.fromCharCode(inArray[i]);\n    }\n    return typeof btoa === \"function\" ? btoa(str) : notSupported(\"btoa\");\n}\nexport function fromBase64String(b64Encoded) {\n    const binary = typeof atob === \"function\" ? atob(b64Encoded) : notSupported(\"atob\");\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n        bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n}\nexport function padLeft(str, len, ch, isRight) {\n    ch = ch || \" \";\n    len = len - str.length;\n    for (let i = 0; i < len; i++) {\n        str = isRight ? str + ch : ch + str;\n    }\n    return str;\n}\nexport function padRight(str, len, ch) {\n    return padLeft(str, len, ch, true);\n}\nexport function remove(str, startIndex, count) {\n    if (startIndex >= str.length) {\n        throw new Error(\"startIndex must be less than length of string\");\n    }\n    if (typeof count === \"number\" && (startIndex + count) > str.length) {\n        throw new Error(\"Index and count must refer to a location within the string.\");\n    }\n    return str.slice(0, startIndex) + (typeof count === \"number\" ? str.substr(startIndex + count) : \"\");\n}\nexport function replace(str, search, replace) {\n    return str.replace(new RegExp(escape(search), \"g\"), replace);\n}\nexport function replicate(n, x) {\n    return initialize(n, () => x);\n}\nexport function getCharAtIndex(input, index) {\n    if (index < 0 || index >= input.length) {\n        throw new Error(\"Index was outside the bounds of the array.\");\n    }\n    return input[index];\n}\nexport function split(str, splitters, count, options) {\n    count = typeof count === \"number\" ? count : undefined;\n    options = typeof options === \"number\" ? options : 0;\n    if (count && count < 0) {\n        throw new Error(\"Count cannot be less than zero\");\n    }\n    if (count === 0) {\n        return [];\n    }\n    const removeEmpty = (options & 1) === 1;\n    const trim = (options & 2) === 2;\n    splitters = splitters || [];\n    splitters = splitters.filter(x => x).map(escape);\n    splitters = splitters.length > 0 ? splitters : [\"\\\\s\"];\n    const splits = [];\n    const reg = new RegExp(splitters.join(\"|\"), \"g\");\n    let findSplits = true;\n    let i = 0;\n    do {\n        const match = reg.exec(str);\n        if (match === null) {\n            const candidate = trim ? str.substring(i).trim() : str.substring(i);\n            if (!removeEmpty || candidate.length > 0) {\n                splits.push(candidate);\n            }\n            findSplits = false;\n        }\n        else {\n            const candidate = trim ? str.substring(i, match.index).trim() : str.substring(i, match.index);\n            if (!removeEmpty || candidate.length > 0) {\n                if (count != null && splits.length + 1 === count) {\n                    splits.push(trim ? str.substring(i).trim() : str.substring(i));\n                    findSplits = false;\n                }\n                else {\n                    splits.push(candidate);\n                }\n            }\n            i = reg.lastIndex;\n        }\n    } while (findSplits);\n    return splits;\n}\nexport function trim(str, ...chars) {\n    if (chars.length === 0) {\n        return str.trim();\n    }\n    const pattern = \"[\" + escape(chars.join(\"\")) + \"]+\";\n    return str.replace(new RegExp(\"^\" + pattern), \"\").replace(new RegExp(pattern + \"$\"), \"\");\n}\nexport function trimStart(str, ...chars) {\n    return chars.length === 0\n        ? str.trimStart()\n        : str.replace(new RegExp(\"^[\" + escape(chars.join(\"\")) + \"]+\"), \"\");\n}\nexport function trimEnd(str, ...chars) {\n    return chars.length === 0\n        ? str.trimEnd()\n        : str.replace(new RegExp(\"[\" + escape(chars.join(\"\")) + \"]+$\"), \"\");\n}\nexport function filter(pred, x) {\n    return x.split(\"\").filter((c) => pred(c)).join(\"\");\n}\nexport function substring(str, startIndex, length) {\n    if ((startIndex + (length || 0) > str.length)) {\n        throw new Error(\"Invalid startIndex and/or length\");\n    }\n    return length != null ? str.substr(startIndex, length) : str.substr(startIndex);\n}\nexport function fmt(strs, ...args) {\n    return ({ strs, args });\n}\nexport function fmtWith(fmts) {\n    return (strs, ...args) => ({ strs, args, fmts });\n}\nexport function getFormat(s) {\n    return s.fmts\n        ? s.strs.reduce((acc, newPart, index) => acc + `{${String(index - 1) + s.fmts[index - 1]}}` + newPart)\n        : s.strs.reduce((acc, newPart, index) => acc + `{${index - 1}}` + newPart);\n}\n","import { compare, equals, structuralHash } from \"./Util.js\";\n// Using a class here for better compatibility with TS files importing Some\nexport class Some {\n    constructor(value) {\n        this.value = value;\n    }\n    toJSON() {\n        return this.value;\n    }\n    // Don't add \"Some\" for consistency with erased options\n    toString() {\n        return String(this.value);\n    }\n    GetHashCode() {\n        return structuralHash(this.value);\n    }\n    Equals(other) {\n        if (other == null) {\n            return false;\n        }\n        else {\n            return equals(this.value, other instanceof Some ? other.value : other);\n        }\n    }\n    CompareTo(other) {\n        if (other == null) {\n            return 1;\n        }\n        else {\n            return compare(this.value, other instanceof Some ? other.value : other);\n        }\n    }\n}\nexport function some(x) {\n    return x == null || x instanceof Some ? new Some(x) : x;\n}\nexport function value(x) {\n    if (x == null) {\n        throw new Error(\"Option has no value\");\n    }\n    else {\n        return x instanceof Some ? x.value : x;\n    }\n}\nexport function ofNullable(x) {\n    // This will fail with unit probably, an alternative would be:\n    // return x === null ? undefined : (x === undefined ? new Some(x) : x);\n    return x == null ? undefined : x;\n}\nexport function toNullable(x) {\n    return x == null ? null : value(x);\n}\nexport function flatten(x) {\n    return x == null ? undefined : value(x);\n}\nexport function toArray(opt) {\n    return (opt == null) ? [] : [value(opt)];\n}\nexport function defaultArg(opt, defaultValue) {\n    return (opt != null) ? value(opt) : defaultValue;\n}\nexport function defaultArgWith(opt, defThunk) {\n    return (opt != null) ? value(opt) : defThunk();\n}\nexport function filter(predicate, opt) {\n    return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;\n}\nexport function map(mapping, opt) {\n    return (opt != null) ? some(mapping(value(opt))) : undefined;\n}\nexport function map2(mapping, opt1, opt2) {\n    return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;\n}\nexport function map3(mapping, opt1, opt2, opt3) {\n    return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;\n}\nexport function bind(binder, opt) {\n    return opt != null ? binder(value(opt)) : undefined;\n}\nexport function tryOp(op, arg) {\n    try {\n        return some(op(arg));\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\n","\r\nexport const SR_indexOutOfBounds = \"The index was outside the range of elements in the collection.\";\r\n\r\nexport const SR_inputWasEmpty = \"Collection was empty.\";\r\n\r\nexport const SR_inputMustBeNonNegative = \"The input must be non-negative.\";\r\n\r\nexport const SR_inputSequenceEmpty = \"The input sequence was empty.\";\r\n\r\nexport const SR_inputSequenceTooLong = \"The input sequence contains more than one element.\";\r\n\r\nexport const SR_keyNotFoundAlt = \"An index satisfying the predicate was not found in the collection.\";\r\n\r\nexport const SR_differentLengths = \"The collections had different lengths.\";\r\n\r\nexport const SR_notEnoughElements = \"The input sequence has an insufficient number of elements.\";\r\n\r\n","import { value as value_2, defaultArg, some } from \"./Option.js\";\r\nimport { min as min_1, disposeSafe, getEnumerator, comparePrimitives, max as max_1 } from \"./Util.js\";\r\nimport { SR_indexOutOfBounds } from \"./Global.js\";\r\n\r\nexport function Helpers_allocateArrayFromCons(cons, len) {\r\n    if ((typeof cons) === \"function\") {\r\n        return new cons(len);\r\n    }\r\n    else {\r\n        return new Array(len);\r\n    }\r\n}\r\n\r\nfunction indexNotFound() {\r\n    throw (new Error(\"An index satisfying the predicate was not found in the collection.\"));\r\n}\r\n\r\nfunction differentLengths() {\r\n    throw (new Error(\"Arrays had different lengths\"));\r\n}\r\n\r\nexport function append(array1, array2, cons) {\r\n    const len1 = array1.length | 0;\r\n    const len2 = array2.length | 0;\r\n    const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);\r\n    for (let i = 0; i <= (len1 - 1); i++) {\r\n        newArray[i] = array1[i];\r\n    }\r\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\r\n        newArray[i_1 + len1] = array2[i_1];\r\n    }\r\n    return newArray;\r\n}\r\n\r\nexport function filter(predicate, array) {\r\n    return array.filter(predicate);\r\n}\r\n\r\nexport function fill(target, targetIndex, count, value) {\r\n    const start = targetIndex | 0;\r\n    return target.fill(value, start, (start + count));\r\n}\r\n\r\nexport function getSubArray(array, start, count) {\r\n    const start_1 = start | 0;\r\n    return array.slice(start_1, (start_1 + count));\r\n}\r\n\r\nexport function last(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    return array[array.length - 1];\r\n}\r\n\r\nexport function tryLast(array) {\r\n    if (array.length === 0) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[array.length - 1]);\r\n    }\r\n}\r\n\r\nexport function mapIndexed(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const target = Helpers_allocateArrayFromCons(cons, len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = f(i, source[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function map(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const target = Helpers_allocateArrayFromCons(cons, len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = f(source[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function mapIndexed2(f, source1, source2, cons) {\r\n    if (source1.length !== source2.length) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(i, source1[i], source2[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function map2(f, source1, source2, cons) {\r\n    if (source1.length !== source2.length) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(source1[i], source2[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function mapIndexed3(f, source1, source2, source3, cons) {\r\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(i, source1[i], source2[i], source3[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function map3(f, source1, source2, source3, cons) {\r\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(source1[i], source2[i], source3[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function mapFold(mapping, state, array, cons) {\r\n    const matchValue = array.length | 0;\r\n    if (matchValue === 0) {\r\n        return [[], state];\r\n    }\r\n    else {\r\n        let acc = state;\r\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\r\n        for (let i = 0; i <= (array.length - 1); i++) {\r\n            const patternInput = mapping(acc, array[i]);\r\n            res[i] = patternInput[0];\r\n            acc = patternInput[1];\r\n        }\r\n        return [res, acc];\r\n    }\r\n}\r\n\r\nexport function mapFoldBack(mapping, array, state, cons) {\r\n    const matchValue = array.length | 0;\r\n    if (matchValue === 0) {\r\n        return [[], state];\r\n    }\r\n    else {\r\n        let acc = state;\r\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\r\n        for (let i = array.length - 1; i >= 0; i--) {\r\n            const patternInput = mapping(array[i], acc);\r\n            res[i] = patternInput[0];\r\n            acc = patternInput[1];\r\n        }\r\n        return [res, acc];\r\n    }\r\n}\r\n\r\nexport function indexed(source) {\r\n    const len = source.length | 0;\r\n    const target = new Array(len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = [i, source[i]];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function truncate(count, array) {\r\n    const count_1 = max_1(comparePrimitives, 0, count) | 0;\r\n    const start = 0;\r\n    return array.slice(start, (start + count_1));\r\n}\r\n\r\nexport function concat(arrays, cons) {\r\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\r\n    const matchValue = arrays_1.length | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return Helpers_allocateArrayFromCons(cons, 0);\r\n        }\r\n        case 1: {\r\n            return arrays_1[0];\r\n        }\r\n        default: {\r\n            let totalIdx = 0;\r\n            let totalLength = 0;\r\n            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {\r\n                const arr_1 = arrays_1[idx];\r\n                totalLength = ((totalLength + arr_1.length) | 0);\r\n            }\r\n            const result = Helpers_allocateArrayFromCons(cons, totalLength);\r\n            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {\r\n                const arr_2 = arrays_1[idx_1];\r\n                for (let j = 0; j <= (arr_2.length - 1); j++) {\r\n                    result[totalIdx] = arr_2[j];\r\n                    totalIdx = ((totalIdx + 1) | 0);\r\n                }\r\n            }\r\n            return result;\r\n        }\r\n    }\r\n}\r\n\r\nexport function collect(mapping, array, cons) {\r\n    return concat(map(mapping, array, null), cons);\r\n}\r\n\r\nexport function where(predicate, array) {\r\n    return array.filter(predicate);\r\n}\r\n\r\nexport function contains(value, array, eq) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return false;\r\n            }\r\n            else if (eq.Equals(value, array[i])) {\r\n                return true;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function empty(cons) {\r\n    return Helpers_allocateArrayFromCons(cons, 0);\r\n}\r\n\r\nexport function singleton(value, cons) {\r\n    const ar = Helpers_allocateArrayFromCons(cons, 1);\r\n    ar[0] = value;\r\n    return ar;\r\n}\r\n\r\nexport function initialize(count, initializer, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, count);\r\n    for (let i = 0; i <= (count - 1); i++) {\r\n        result[i] = initializer(i);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function pairwise(array) {\r\n    if (array.length < 2) {\r\n        return [];\r\n    }\r\n    else {\r\n        const count = (array.length - 1) | 0;\r\n        const result = new Array(count);\r\n        for (let i = 0; i <= (count - 1); i++) {\r\n            result[i] = [array[i], array[i + 1]];\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function replicate(count, initial, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, count);\r\n    for (let i = 0; i <= (result.length - 1); i++) {\r\n        result[i] = initial;\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function copy(array) {\r\n    return array.slice();\r\n}\r\n\r\nexport function reverse(array) {\r\n    const array_2 = array.slice();\r\n    return array_2.reverse();\r\n}\r\n\r\nexport function scan(folder, state, array, cons) {\r\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\r\n    res[0] = state;\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        res[i + 1] = folder(res[i], array[i]);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function scanBack(folder, array, state, cons) {\r\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\r\n    res[array.length] = state;\r\n    for (let i = array.length - 1; i >= 0; i--) {\r\n        res[i] = folder(array[i], res[i + 1]);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function skip(count, array, cons) {\r\n    if (count > array.length) {\r\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\r\n    }\r\n    if (count === array.length) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const count_1 = ((count < 0) ? 0 : count) | 0;\r\n        return array.slice(count_1);\r\n    }\r\n}\r\n\r\nexport function skipWhile(predicate, array, cons) {\r\n    let count = 0;\r\n    while ((count < array.length) && predicate(array[count])) {\r\n        count = ((count + 1) | 0);\r\n    }\r\n    if (count === array.length) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const count_1 = count | 0;\r\n        return array.slice(count_1);\r\n    }\r\n}\r\n\r\nexport function take(count, array, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    if (count > array.length) {\r\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\r\n    }\r\n    if (count === 0) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const start = 0;\r\n        return array.slice(start, (start + count));\r\n    }\r\n}\r\n\r\nexport function takeWhile(predicate, array, cons) {\r\n    let count = 0;\r\n    while ((count < array.length) && predicate(array[count])) {\r\n        count = ((count + 1) | 0);\r\n    }\r\n    if (count === 0) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const start = 0;\r\n        const count_1 = count | 0;\r\n        return array.slice(start, (start + count_1));\r\n    }\r\n}\r\n\r\nexport function addInPlace(x, array) {\r\n    array.push(x);\r\n}\r\n\r\nexport function addRangeInPlace(range, array) {\r\n    const enumerator = getEnumerator(range);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            addInPlace(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), array);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n}\r\n\r\nexport function insertRangeInPlace(index, range, array) {\r\n    let index_1;\r\n    let i = index;\r\n    const enumerator = getEnumerator(range);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            (index_1 = (i | 0), array.splice(index_1, 0, x));\r\n            i = ((i + 1) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n}\r\n\r\nexport function removeInPlace(item_1, array) {\r\n    const i = (array.indexOf(item_1, 0)) | 0;\r\n    if (i > -1) {\r\n        array.splice(i, 1);\r\n        return true;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function removeAllInPlace(predicate, array) {\r\n    const countRemoveAll = (count) => {\r\n        const i = (array.findIndex(predicate)) | 0;\r\n        if (i > -1) {\r\n            array.splice(i, 1);\r\n            return (countRemoveAll(count) + 1) | 0;\r\n        }\r\n        else {\r\n            return count | 0;\r\n        }\r\n    };\r\n    return countRemoveAll(0) | 0;\r\n}\r\n\r\nexport function copyTo(source, sourceIndex, target, targetIndex, count) {\r\n    const diff = (targetIndex - sourceIndex) | 0;\r\n    for (let i = sourceIndex; i <= ((sourceIndex + count) - 1); i++) {\r\n        target[i + diff] = source[i];\r\n    }\r\n}\r\n\r\nexport function copyToTypedArray(source, sourceIndex, target, targetIndex, count) {\r\n    try {\r\n        target.set(source.subarray(sourceIndex, sourceIndex + count), targetIndex);\r\n    }\r\n    catch (matchValue) {\r\n        copyTo(source, sourceIndex, target, targetIndex, count);\r\n    }\r\n}\r\n\r\nexport function indexOf(array, item_1, start, count) {\r\n    const start_1 = defaultArg(start, 0) | 0;\r\n    const i = (array.indexOf(item_1, start_1)) | 0;\r\n    if ((count != null) && (i >= (start_1 + value_2(count)))) {\r\n        return -1;\r\n    }\r\n    else {\r\n        return i | 0;\r\n    }\r\n}\r\n\r\nexport function partition(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const res1 = Helpers_allocateArrayFromCons(cons, len);\r\n    const res2 = Helpers_allocateArrayFromCons(cons, len);\r\n    let iTrue = 0;\r\n    let iFalse = 0;\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        if (f(source[i])) {\r\n            res1[iTrue] = source[i];\r\n            iTrue = ((iTrue + 1) | 0);\r\n        }\r\n        else {\r\n            res2[iFalse] = source[i];\r\n            iFalse = ((iFalse + 1) | 0);\r\n        }\r\n    }\r\n    return [truncate(iTrue, res1), truncate(iFalse, res2)];\r\n}\r\n\r\nexport function find(predicate, array) {\r\n    const matchValue = array.find(predicate);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_2(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFind(predicate, array) {\r\n    return array.find(predicate);\r\n}\r\n\r\nexport function findIndex(predicate, array) {\r\n    const matchValue = (array.findIndex(predicate)) | 0;\r\n    if (matchValue > -1) {\r\n        return matchValue | 0;\r\n    }\r\n    else {\r\n        return indexNotFound() | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(predicate, array) {\r\n    const matchValue = (array.findIndex(predicate)) | 0;\r\n    if (matchValue > -1) {\r\n        return matchValue;\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function pick(chooser, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return indexNotFound();\r\n            }\r\n            else {\r\n                const matchValue = chooser(array[i]);\r\n                if (matchValue != null) {\r\n                    return value_2(matchValue);\r\n                }\r\n                else {\r\n                    i_mut = (i + 1);\r\n                    continue loop;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function tryPick(chooser, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return void 0;\r\n            }\r\n            else {\r\n                const matchValue = chooser(array[i]);\r\n                if (matchValue == null) {\r\n                    i_mut = (i + 1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function findBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return indexNotFound();\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return array[i];\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function tryFindBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return void 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return some(array[i]);\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function findLastIndex(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return -1;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i | 0;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1) | 0;\r\n}\r\n\r\nexport function findIndexBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return indexNotFound() | 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i | 0;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1) | 0;\r\n}\r\n\r\nexport function tryFindIndexBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return void 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function choose(chooser, array, cons) {\r\n    const res = [];\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        const matchValue = chooser(array[i]);\r\n        if (matchValue != null) {\r\n            const y = value_2(matchValue);\r\n            res.push(y);\r\n        }\r\n    }\r\n    if ((typeof cons) === \"function\") {\r\n        return map((x) => x, res, cons);\r\n    }\r\n    else {\r\n        return res;\r\n    }\r\n}\r\n\r\nexport function foldIndexed(folder, state, array) {\r\n    return array.reduce(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg0, delegateArg1)), state);\r\n}\r\n\r\nexport function fold(folder, state, array) {\r\n    return array.reduce((folder), state);\r\n}\r\n\r\nexport function iterate(action, array) {\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        action(array[i]);\r\n    }\r\n}\r\n\r\nexport function iterateIndexed(action, array) {\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        action(i, array[i]);\r\n    }\r\n}\r\n\r\nexport function iterate2(action, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        action(array1[i], array2[i]);\r\n    }\r\n}\r\n\r\nexport function iterateIndexed2(action, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        action(i, array1[i], array2[i]);\r\n    }\r\n}\r\n\r\nexport function isEmpty(array) {\r\n    return array.length === 0;\r\n}\r\n\r\nexport function forAll(predicate, array) {\r\n    return array.every(predicate);\r\n}\r\n\r\nexport function permute(f, array) {\r\n    const size = array.length | 0;\r\n    const res = array.slice();\r\n    const checkFlags = new Array(size);\r\n    iterateIndexed((i, x) => {\r\n        const j = f(i) | 0;\r\n        if ((j < 0) ? true : (j >= size)) {\r\n            throw (new Error(\"Not a valid permutation\"));\r\n        }\r\n        res[j] = x;\r\n        checkFlags[j] = 1;\r\n    }, array);\r\n    if (!(checkFlags.every((y) => (1 === y)))) {\r\n        throw (new Error(\"Not a valid permutation\"));\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function setSlice(target, lower, upper, source) {\r\n    const lower_1 = defaultArg(lower, 0) | 0;\r\n    const upper_1 = defaultArg(upper, 0) | 0;\r\n    const length = (((upper_1 > 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;\r\n    for (let i = 0; i <= length; i++) {\r\n        target[i + lower_1] = source[i];\r\n    }\r\n}\r\n\r\nexport function sortInPlaceBy(projection, xs, comparer) {\r\n    xs.sort((x, y) => comparer.Compare(projection(x), projection(y)));\r\n}\r\n\r\nexport function sortInPlace(xs, comparer) {\r\n    xs.sort((x, y) => comparer.Compare(x, y));\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => comparer.Compare(x, y));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    return (xs_1.sort((x, y) => comparer.Compare(projection(x), projection(y))), xs_1);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => (comparer.Compare(x, y) * -1));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    return (xs_1.sort((x, y) => (comparer.Compare(projection(x), projection(y)) * -1)), xs_1);\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    const comparer_1 = comparer;\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort(comparer_1);\r\n    return xs_1;\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const len1 = xs.length | 0;\r\n    const len2 = ys.length | 0;\r\n    const res = new Array(len1 * len2);\r\n    for (let i = 0; i <= (xs.length - 1); i++) {\r\n        for (let j = 0; j <= (ys.length - 1); j++) {\r\n            res[(i * len2) + j] = [xs[i], ys[j]];\r\n        }\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function unfold(generator, state) {\r\n    const res = [];\r\n    const loop = (state_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const state_1 = state_1_mut;\r\n            const matchValue = generator(state_1);\r\n            if (matchValue != null) {\r\n                const x = matchValue[0];\r\n                const s = matchValue[1];\r\n                res.push(x);\r\n                state_1_mut = s;\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    loop(state);\r\n    return res;\r\n}\r\n\r\nexport function unzip(array) {\r\n    const len = array.length | 0;\r\n    const res1 = new Array(len);\r\n    const res2 = new Array(len);\r\n    iterateIndexed((i, tupledArg) => {\r\n        res1[i] = tupledArg[0];\r\n        res2[i] = tupledArg[1];\r\n    }, array);\r\n    return [res1, res2];\r\n}\r\n\r\nexport function unzip3(array) {\r\n    const len = array.length | 0;\r\n    const res1 = new Array(len);\r\n    const res2 = new Array(len);\r\n    const res3 = new Array(len);\r\n    iterateIndexed((i, tupledArg) => {\r\n        res1[i] = tupledArg[0];\r\n        res2[i] = tupledArg[1];\r\n        res3[i] = tupledArg[2];\r\n    }, array);\r\n    return [res1, res2, res3];\r\n}\r\n\r\nexport function zip(array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    const result = new Array(array1.length);\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        result[i] = [array1[i], array2[i]];\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function zip3(array1, array2, array3) {\r\n    if ((array1.length !== array2.length) ? true : (array2.length !== array3.length)) {\r\n        differentLengths();\r\n    }\r\n    const result = new Array(array1.length);\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        result[i] = [array1[i], array2[i], array3[i]];\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function chunkBySize(chunkSize, array) {\r\n    if (chunkSize < 1) {\r\n        throw (new Error(\"The input must be positive.\\\\nParameter name: size\"));\r\n    }\r\n    if (array.length === 0) {\r\n        return [[]];\r\n    }\r\n    else {\r\n        const result = [];\r\n        for (let x = 0; x <= ((~(~Math.ceil(array.length / chunkSize))) - 1); x++) {\r\n            let slice;\r\n            const start_1 = (x * chunkSize) | 0;\r\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\r\n            result.push(slice);\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function splitAt(index, array) {\r\n    let start;\r\n    if ((index < 0) ? true : (index > array.length)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return [(start = 0, array.slice(start, (start + index))), array.slice(index)];\r\n}\r\n\r\nexport function compareWith(comparer, array1, array2) {\r\n    if (array1 == null) {\r\n        if (array2 == null) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n    else if (array2 == null) {\r\n        return 1;\r\n    }\r\n    else {\r\n        let i = 0;\r\n        let result = 0;\r\n        const length1 = array1.length | 0;\r\n        const length2 = array2.length | 0;\r\n        if (length1 > length2) {\r\n            return 1;\r\n        }\r\n        else if (length1 < length2) {\r\n            return -1;\r\n        }\r\n        else {\r\n            while ((i < length1) && (result === 0)) {\r\n                result = (comparer(array1[i], array2[i]) | 0);\r\n                i = ((i + 1) | 0);\r\n            }\r\n            return result | 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function equalsWith(equals, array1, array2) {\r\n    if (array1 == null) {\r\n        if (array2 == null) {\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else if (array2 == null) {\r\n        return false;\r\n    }\r\n    else {\r\n        let i = 0;\r\n        let result = true;\r\n        const length1 = array1.length | 0;\r\n        const length2 = array2.length | 0;\r\n        if (length1 > length2) {\r\n            return false;\r\n        }\r\n        else if (length1 < length2) {\r\n            return false;\r\n        }\r\n        else {\r\n            while ((i < length1) && result) {\r\n                result = equals(array1[i], array2[i]);\r\n                i = ((i + 1) | 0);\r\n            }\r\n            return result;\r\n        }\r\n    }\r\n}\r\n\r\nexport function exactlyOne(array) {\r\n    if (array.length === 1) {\r\n        return array[0];\r\n    }\r\n    else if (array.length === 0) {\r\n        throw (new Error(\"The input sequence was empty\\\\nParameter name: array\"));\r\n    }\r\n    else {\r\n        throw (new Error(\"Input array too long\\\\nParameter name: array\"));\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(array) {\r\n    if (array.length === 1) {\r\n        return some(array[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function head(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    else {\r\n        return array[0];\r\n    }\r\n}\r\n\r\nexport function tryHead(array) {\r\n    if (array.length === 0) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[0]);\r\n    }\r\n}\r\n\r\nexport function tail(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"Not enough elements\\\\nParameter name: array\"));\r\n    }\r\n    return array.slice(1);\r\n}\r\n\r\nexport function item(index, array) {\r\n    return array[index];\r\n}\r\n\r\nexport function tryItem(index, array) {\r\n    if ((index < 0) ? true : (index >= array.length)) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[index]);\r\n    }\r\n}\r\n\r\nexport function foldBackIndexed(folder, array, state) {\r\n    return array.reduceRight(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg1, delegateArg0)), state);\r\n}\r\n\r\nexport function foldBack(folder, array, state) {\r\n    return array.reduceRight(((delegateArg0, delegateArg1) => folder(delegateArg1, delegateArg0)), state);\r\n}\r\n\r\nexport function foldIndexed2(folder, state, array1, array2) {\r\n    let acc = state;\r\n    if (array1.length !== array2.length) {\r\n        throw (new Error(\"Arrays have different lengths\"));\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        acc = folder(i, acc, array1[i], array2[i]);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function fold2(folder, state, array1, array2) {\r\n    return foldIndexed2((_arg1, acc, x, y) => folder(acc, x, y), state, array1, array2);\r\n}\r\n\r\nexport function foldBackIndexed2(folder, array1, array2, state) {\r\n    let acc = state;\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    const size = array1.length | 0;\r\n    for (let i = 1; i <= size; i++) {\r\n        acc = folder(i - 1, array1[size - i], array2[size - i], acc);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function foldBack2(f, array1, array2, state) {\r\n    return foldBackIndexed2((_arg1, x, y, acc) => f(x, y, acc), array1, array2, state);\r\n}\r\n\r\nexport function reduce(reduction, array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\"));\r\n    }\r\n    const reduction_1 = reduction;\r\n    return array.reduce(reduction_1);\r\n}\r\n\r\nexport function reduceBack(reduction, array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\"));\r\n    }\r\n    const reduction_1 = reduction;\r\n    return array.reduceRight(reduction_1);\r\n}\r\n\r\nexport function forAll2(predicate, array1, array2) {\r\n    return fold2((acc, x, y) => (acc && predicate(x, y)), true, array1, array2);\r\n}\r\n\r\nexport function existsOffset(predicate_mut, array_mut, index_mut) {\r\n    existsOffset:\r\n    while (true) {\r\n        const predicate = predicate_mut, array = array_mut, index = index_mut;\r\n        if (index === array.length) {\r\n            return false;\r\n        }\r\n        else if (predicate(array[index])) {\r\n            return true;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            array_mut = array;\r\n            index_mut = (index + 1);\r\n            continue existsOffset;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function exists(predicate, array) {\r\n    return existsOffset(predicate, array, 0);\r\n}\r\n\r\nexport function existsOffset2(predicate_mut, array1_mut, array2_mut, index_mut) {\r\n    existsOffset2:\r\n    while (true) {\r\n        const predicate = predicate_mut, array1 = array1_mut, array2 = array2_mut, index = index_mut;\r\n        if (index === array1.length) {\r\n            return false;\r\n        }\r\n        else if (predicate(array1[index], array2[index])) {\r\n            return true;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            array1_mut = array1;\r\n            array2_mut = array2;\r\n            index_mut = (index + 1);\r\n            continue existsOffset2;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function exists2(predicate, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    return existsOffset2(predicate, array1, array2, 0);\r\n}\r\n\r\nexport function sum(array, adder) {\r\n    let acc = adder.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        acc = adder.Add(acc, array[i]);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function sumBy(projection, array, adder) {\r\n    let acc = adder.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        acc = adder.Add(acc, projection(array[i]));\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(array, averager) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    let total = averager.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        total = averager.Add(total, array[i]);\r\n    }\r\n    return averager.DivideByInt(total, array.length);\r\n}\r\n\r\nexport function averageBy(projection, array, averager) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    let total = averager.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        total = averager.Add(total, projection(array[i]));\r\n    }\r\n    return averager.DivideByInt(total, array.length);\r\n}\r\n\r\nexport function windowed(windowSize, source) {\r\n    if (windowSize <= 0) {\r\n        throw (new Error(\"windowSize must be positive\"));\r\n    }\r\n    let res;\r\n    const len = max_1(comparePrimitives, 0, (source.length - windowSize) + 1) | 0;\r\n    res = (new Array(len));\r\n    for (let i = windowSize; i <= source.length; i++) {\r\n        res[i - windowSize] = source.slice(i - windowSize, (i - 1) + 1);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function splitInto(chunks, array) {\r\n    if (chunks < 1) {\r\n        throw (new Error(\"The input must be positive.\\\\nParameter name: chunks\"));\r\n    }\r\n    if (array.length === 0) {\r\n        return [[]];\r\n    }\r\n    else {\r\n        const result = [];\r\n        const chunks_1 = min_1(comparePrimitives, chunks, array.length) | 0;\r\n        const minChunkSize = (~(~(array.length / chunks_1))) | 0;\r\n        const chunksWithExtraItem = (array.length % chunks_1) | 0;\r\n        for (let i = 0; i <= (chunks_1 - 1); i++) {\r\n            const chunkSize = ((i < chunksWithExtraItem) ? (minChunkSize + 1) : minChunkSize) | 0;\r\n            let slice;\r\n            const start_1 = ((i * minChunkSize) + min_1(comparePrimitives, chunksWithExtraItem, i)) | 0;\r\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\r\n            result.push(slice);\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function transpose(arrays, cons) {\r\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\r\n    const len = arrays_1.length | 0;\r\n    if (len === 0) {\r\n        return new Array(0);\r\n    }\r\n    else {\r\n        const firstArray = arrays_1[0];\r\n        const lenInner = firstArray.length | 0;\r\n        if (!forAll((a) => (a.length === lenInner), arrays_1)) {\r\n            differentLengths();\r\n        }\r\n        const result = new Array(lenInner);\r\n        for (let i = 0; i <= (lenInner - 1); i++) {\r\n            result[i] = Helpers_allocateArrayFromCons(cons, len);\r\n            for (let j = 0; j <= (len - 1); j++) {\r\n                result[i][j] = arrays_1[j][i];\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index > len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const target = new xs.constructor(len + 1);\r\n    for (let i = 0; i <= (index - 1); i++) {\r\n        target[i] = xs[i];\r\n    }\r\n    target[index] = y;\r\n    for (let i_1 = index; i_1 <= (len - 1); i_1++) {\r\n        target[i_1 + 1] = xs[i_1];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index > len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const ys_1 = Array.from(ys);\r\n    const len2 = ys_1.length | 0;\r\n    const target = new xs.constructor(len + len2);\r\n    for (let i = 0; i <= (index - 1); i++) {\r\n        target[i] = xs[i];\r\n    }\r\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\r\n        target[index + i_1] = ys_1[i_1];\r\n    }\r\n    for (let i_2 = index; i_2 <= (len - 1); i_2++) {\r\n        target[i_2 + len2] = xs[i_2];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    if ((index < 0) ? true : (index >= xs.length)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    let i = -1;\r\n    return filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        return i !== index;\r\n    }, xs);\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    let i = -1;\r\n    let status = -1;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            status = 0;\r\n            return false;\r\n        }\r\n        else if (i > index) {\r\n            if (i < (index + count)) {\r\n                return false;\r\n            }\r\n            else {\r\n                status = 1;\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;\r\n    if (status_1 < 1) {\r\n        const arg = (status_1 < 0) ? \"index\" : \"count\";\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + arg));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index >= len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const target = new xs.constructor(len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = ((i === index) ? y : xs[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\n","import { join } from \"./String.js\";\r\nimport { uncurry, disposeSafe, isArrayLike, getEnumerator, toIterator, compare, structuralHash, equals } from \"./Util.js\";\r\nimport { Record } from \"./Types.js\";\r\nimport { class_type, record_type, option_type } from \"./Reflection.js\";\r\nimport { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from \"./Global.js\";\r\nimport { defaultArg, value as value_1, some } from \"./Option.js\";\r\nimport { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, fill } from \"./Array.js\";\r\n\r\nexport class FSharpList extends Record {\r\n    constructor(head, tail) {\r\n        super();\r\n        this.head = head;\r\n        this.tail = tail;\r\n    }\r\n    toString() {\r\n        const xs = this;\r\n        return (\"[\" + join(\"; \", xs)) + \"]\";\r\n    }\r\n    Equals(other) {\r\n        const xs = this;\r\n        if (xs === other) {\r\n            return true;\r\n        }\r\n        else {\r\n            const loop = (xs_1_mut, ys_1_mut) => {\r\n                loop:\r\n                while (true) {\r\n                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n                    const matchValue = [xs_1.tail, ys_1.tail];\r\n                    if (matchValue[0] != null) {\r\n                        if (matchValue[1] != null) {\r\n                            const xt = matchValue[0];\r\n                            const yt = matchValue[1];\r\n                            if (equals(xs_1.head, ys_1.head)) {\r\n                                xs_1_mut = xt;\r\n                                ys_1_mut = yt;\r\n                                continue loop;\r\n                            }\r\n                            else {\r\n                                return false;\r\n                            }\r\n                        }\r\n                        else {\r\n                            return false;\r\n                        }\r\n                    }\r\n                    else if (matchValue[1] != null) {\r\n                        return false;\r\n                    }\r\n                    else {\r\n                        return true;\r\n                    }\r\n                    break;\r\n                }\r\n            };\r\n            return loop(xs, other);\r\n        }\r\n    }\r\n    GetHashCode() {\r\n        const xs = this;\r\n        const loop = (i_mut, h_mut, xs_1_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const i = i_mut, h = h_mut, xs_1 = xs_1_mut;\r\n                const matchValue = xs_1.tail;\r\n                if (matchValue != null) {\r\n                    const t = matchValue;\r\n                    if (i > 18) {\r\n                        return h | 0;\r\n                    }\r\n                    else {\r\n                        i_mut = (i + 1);\r\n                        h_mut = (((h << 1) + structuralHash(xs_1.head)) + (631 * i));\r\n                        xs_1_mut = t;\r\n                        continue loop;\r\n                    }\r\n                }\r\n                else {\r\n                    return h | 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(0, 0, xs) | 0;\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    CompareTo(other) {\r\n        const xs = this;\r\n        const loop = (xs_1_mut, ys_1_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n                const matchValue = [xs_1.tail, ys_1.tail];\r\n                if (matchValue[0] != null) {\r\n                    if (matchValue[1] != null) {\r\n                        const xt = matchValue[0];\r\n                        const yt = matchValue[1];\r\n                        const c = compare(xs_1.head, ys_1.head) | 0;\r\n                        if (c === 0) {\r\n                            xs_1_mut = xt;\r\n                            ys_1_mut = yt;\r\n                            continue loop;\r\n                        }\r\n                        else {\r\n                            return c | 0;\r\n                        }\r\n                    }\r\n                    else {\r\n                        return 1;\r\n                    }\r\n                }\r\n                else if (matchValue[1] != null) {\r\n                    return -1;\r\n                }\r\n                else {\r\n                    return 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(xs, other) | 0;\r\n    }\r\n    GetEnumerator() {\r\n        const xs = this;\r\n        return ListEnumerator$1_$ctor_3002E699(xs);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const xs = this;\r\n        return getEnumerator(xs);\r\n    }\r\n}\r\n\r\nexport function FSharpList$reflection(gen0) {\r\n    return record_type(\"ListModule.FSharpList\", [gen0], FSharpList, () => [[\"head\", gen0], [\"tail\", option_type(FSharpList$reflection(gen0))]]);\r\n}\r\n\r\nexport class ListEnumerator$1 {\r\n    constructor(xs) {\r\n        this.xs = xs;\r\n        this.it = this.xs;\r\n        this.current = null;\r\n    }\r\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current;\r\n    }\r\n    [\"System.Collections.IEnumerator.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current;\r\n    }\r\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n        const __ = this;\r\n        const matchValue = __.it.tail;\r\n        if (matchValue != null) {\r\n            const t = matchValue;\r\n            __.current = __.it.head;\r\n            __.it = t;\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.IEnumerator.Reset\"]() {\r\n        const __ = this;\r\n        __.it = __.xs;\r\n        __.current = null;\r\n    }\r\n    Dispose() {\r\n    }\r\n}\r\n\r\nexport function ListEnumerator$1$reflection(gen0) {\r\n    return class_type(\"ListModule.ListEnumerator`1\", [gen0], ListEnumerator$1);\r\n}\r\n\r\nexport function ListEnumerator$1_$ctor_3002E699(xs) {\r\n    return new ListEnumerator$1(xs);\r\n}\r\n\r\nexport function FSharpList_get_Empty() {\r\n    return new FSharpList(null, void 0);\r\n}\r\n\r\nexport function FSharpList_Cons_305B8EAC(x, xs) {\r\n    return new FSharpList(x, xs);\r\n}\r\n\r\nexport function FSharpList__get_IsEmpty(xs) {\r\n    return xs.tail == null;\r\n}\r\n\r\nexport function FSharpList__get_Length(xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            const matchValue = xs_1.tail;\r\n            if (matchValue != null) {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = matchValue;\r\n                continue loop;\r\n            }\r\n            else {\r\n                return i | 0;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs) | 0;\r\n}\r\n\r\nexport function FSharpList__get_Head(xs) {\r\n    const matchValue = xs.tail;\r\n    if (matchValue != null) {\r\n        return xs.head;\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputWasEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function FSharpList__get_Tail(xs) {\r\n    const matchValue = xs.tail;\r\n    if (matchValue != null) {\r\n        return matchValue;\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputWasEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function FSharpList__get_Item_Z524259A4(xs, index) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            const matchValue = xs_1.tail;\r\n            if (matchValue != null) {\r\n                if (i === index) {\r\n                    return xs_1.head;\r\n                }\r\n                else {\r\n                    i_mut = (i + 1);\r\n                    xs_1_mut = matchValue;\r\n                    continue loop;\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function empty() {\r\n    return FSharpList_get_Empty();\r\n}\r\n\r\nexport function cons(x, xs) {\r\n    return FSharpList_Cons_305B8EAC(x, xs);\r\n}\r\n\r\nexport function singleton(x) {\r\n    return FSharpList_Cons_305B8EAC(x, FSharpList_get_Empty());\r\n}\r\n\r\nexport function isEmpty(xs) {\r\n    return FSharpList__get_IsEmpty(xs);\r\n}\r\n\r\nexport function length(xs) {\r\n    return FSharpList__get_Length(xs);\r\n}\r\n\r\nexport function head(xs) {\r\n    return FSharpList__get_Head(xs);\r\n}\r\n\r\nexport function tryHead(xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(FSharpList__get_Head(xs));\r\n    }\r\n}\r\n\r\nexport function tail(xs) {\r\n    return FSharpList__get_Tail(xs);\r\n}\r\n\r\nexport function tryLast(xs_mut) {\r\n    tryLast:\r\n    while (true) {\r\n        const xs = xs_mut;\r\n        if (FSharpList__get_IsEmpty(xs)) {\r\n            return void 0;\r\n        }\r\n        else {\r\n            const t = FSharpList__get_Tail(xs);\r\n            if (FSharpList__get_IsEmpty(t)) {\r\n                return some(FSharpList__get_Head(xs));\r\n            }\r\n            else {\r\n                xs_mut = t;\r\n                continue tryLast;\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function last(xs) {\r\n    const matchValue = tryLast(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function compareWith(comparer, xs, ys) {\r\n    const loop = (xs_1_mut, ys_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n            const matchValue = [FSharpList__get_IsEmpty(xs_1), FSharpList__get_IsEmpty(ys_1)];\r\n            if (matchValue[0]) {\r\n                if (matchValue[1]) {\r\n                    return 0;\r\n                }\r\n                else {\r\n                    return -1;\r\n                }\r\n            }\r\n            else if (matchValue[1]) {\r\n                return 1;\r\n            }\r\n            else {\r\n                const c = comparer(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)) | 0;\r\n                if (c === 0) {\r\n                    xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                    ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return c | 0;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(xs, ys) | 0;\r\n}\r\n\r\nexport function toArray(xs) {\r\n    const len = FSharpList__get_Length(xs) | 0;\r\n    const res = fill(new Array(len), 0, len, null);\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (!FSharpList__get_IsEmpty(xs_1)) {\r\n                res[i] = FSharpList__get_Head(xs_1);\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    loop(0, xs);\r\n    return res;\r\n}\r\n\r\nexport function fold(folder, state, xs) {\r\n    let acc = state;\r\n    let xs_1 = xs;\r\n    while (!FSharpList__get_IsEmpty(xs_1)) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_1));\r\n        xs_1 = FSharpList__get_Tail(xs_1);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function reverse(xs) {\r\n    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), FSharpList_get_Empty(), xs);\r\n}\r\n\r\nexport function foldBack(folder, xs, state) {\r\n    return foldBack_1(folder, toArray(xs), state);\r\n}\r\n\r\nexport function foldIndexed(folder, state, xs) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                acc_mut = folder(i, acc, FSharpList__get_Head(xs_1));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, state, xs);\r\n}\r\n\r\nexport function fold2(folder, state, xs, ys) {\r\n    let acc = state;\r\n    let xs_1 = xs;\r\n    let ys_1 = ys;\r\n    while ((!FSharpList__get_IsEmpty(xs_1)) && (!FSharpList__get_IsEmpty(ys_1))) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1));\r\n        xs_1 = FSharpList__get_Tail(xs_1);\r\n        ys_1 = FSharpList__get_Tail(ys_1);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function foldBack2(folder, xs, ys, state) {\r\n    return foldBack2_1(folder, toArray(xs), toArray(ys), state);\r\n}\r\n\r\nexport function unfold(gen, state) {\r\n    const loop = (acc_mut, node_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, node = node_mut;\r\n            const matchValue = gen(acc);\r\n            if (matchValue != null) {\r\n                acc_mut = matchValue[1];\r\n                node_mut = ((t = (new FSharpList(matchValue[0], void 0)), (node.tail = t, t)));\r\n                continue loop;\r\n            }\r\n            else {\r\n                return node;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(state, root);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function iterate(action, xs) {\r\n    fold((unitVar0, x) => {\r\n        action(x);\r\n    }, void 0, xs);\r\n}\r\n\r\nexport function iterate2(action, xs, ys) {\r\n    fold2((unitVar0, x, y) => {\r\n        action(x, y);\r\n    }, void 0, xs, ys);\r\n}\r\n\r\nexport function iterateIndexed(action, xs) {\r\n    fold((i, x) => {\r\n        action(i, x);\r\n        return (i + 1) | 0;\r\n    }, 0, xs);\r\n}\r\n\r\nexport function iterateIndexed2(action, xs, ys) {\r\n    fold2((i, x, y) => {\r\n        action(i, x, y);\r\n        return (i + 1) | 0;\r\n    }, 0, xs, ys);\r\n}\r\n\r\nexport function toSeq(xs) {\r\n    return xs;\r\n}\r\n\r\nexport function ofArrayWithTail(xs, tail_1) {\r\n    let res = tail_1;\r\n    for (let i = xs.length - 1; i >= 0; i--) {\r\n        res = FSharpList_Cons_305B8EAC(xs[i], res);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function ofArray(xs) {\r\n    return ofArrayWithTail(xs, FSharpList_get_Empty());\r\n}\r\n\r\nexport function ofSeq(xs) {\r\n    let xs_3, t;\r\n    if (isArrayLike(xs)) {\r\n        return ofArray(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return xs;\r\n    }\r\n    else {\r\n        const root = FSharpList_get_Empty();\r\n        let node = root;\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                node = ((xs_3 = node, (t = (new FSharpList(x, void 0)), (xs_3.tail = t, t))));\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n        const xs_5 = node;\r\n        const t_2 = FSharpList_get_Empty();\r\n        xs_5.tail = t_2;\r\n        return FSharpList__get_Tail(root);\r\n    }\r\n}\r\n\r\nexport function concat(lists) {\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    const action = (xs) => {\r\n        node = fold((acc, x) => {\r\n            const t = new FSharpList(x, void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }, node, xs);\r\n    };\r\n    if (isArrayLike(lists)) {\r\n        lists.forEach(action);\r\n    }\r\n    else if (lists instanceof FSharpList) {\r\n        iterate(action, lists);\r\n    }\r\n    else {\r\n        const enumerator = getEnumerator(lists);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                action(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n    }\r\n    const xs_6 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_6.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function scan(folder, state, xs) {\r\n    let t, xs_4, t_2;\r\n    const root = FSharpList_get_Empty();\r\n    let node = (t = (new FSharpList(state, void 0)), (root.tail = t, t));\r\n    let acc = state;\r\n    let xs_3 = xs;\r\n    while (!FSharpList__get_IsEmpty(xs_3)) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_3));\r\n        node = ((xs_4 = node, (t_2 = (new FSharpList(acc, void 0)), (xs_4.tail = t_2, t_2))));\r\n        xs_3 = FSharpList__get_Tail(xs_3);\r\n    }\r\n    const xs_6 = node;\r\n    const t_4 = FSharpList_get_Empty();\r\n    xs_6.tail = t_4;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function scanBack(folder, xs, state) {\r\n    return ofArray(scanBack_1(folder, toArray(xs), state));\r\n}\r\n\r\nexport function append(xs, ys) {\r\n    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));\r\n}\r\n\r\nexport function collect(mapping, xs) {\r\n    let xs_1, t;\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    let ys = xs;\r\n    while (!FSharpList__get_IsEmpty(ys)) {\r\n        let zs = mapping(FSharpList__get_Head(ys));\r\n        while (!FSharpList__get_IsEmpty(zs)) {\r\n            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head(zs), void 0)), (xs_1.tail = t, t))));\r\n            zs = FSharpList__get_Tail(zs);\r\n        }\r\n        ys = FSharpList__get_Tail(ys);\r\n    }\r\n    const xs_3 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_3.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapIndexed(mapping, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = foldIndexed((i, acc, x) => {\r\n        let t;\r\n        return (t = (new FSharpList(mapping(i, x), void 0)), (acc.tail = t, t));\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function map(mapping, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        let t;\r\n        return (t = (new FSharpList(mapping(x), void 0)), (acc.tail = t, t));\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function indexed(xs) {\r\n    return mapIndexed((i, x) => [i, x], xs);\r\n}\r\n\r\nexport function map2(mapping, xs, ys) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold2((acc, x, y) => {\r\n        let t;\r\n        return (t = (new FSharpList(mapping(x, y), void 0)), (acc.tail = t, t));\r\n    }, root, xs, ys);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapIndexed2(mapping, xs, ys) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut, ys_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                acc_mut = ((t = (new FSharpList(mapping(i, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(0, root, xs, ys);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function map3(mapping, xs, ys, zs) {\r\n    const loop = (acc_mut, xs_1_mut, ys_1_mut, zs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut, zs_1 = zs_1_mut;\r\n            if ((FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) ? true : FSharpList__get_IsEmpty(zs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = ((t = (new FSharpList(mapping(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1), FSharpList__get_Head(zs_1)), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                zs_1_mut = FSharpList__get_Tail(zs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(root, xs, ys, zs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapFold(mapping, state, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const patternInput_1 = fold((tupledArg, x) => {\r\n        let t;\r\n        const patternInput = mapping(tupledArg[1], x);\r\n        return [(t = (new FSharpList(patternInput[0], void 0)), (tupledArg[0].tail = t, t)), patternInput[1]];\r\n    }, [root, state], xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    patternInput_1[0].tail = t_2;\r\n    return [FSharpList__get_Tail(root), patternInput_1[1]];\r\n}\r\n\r\nexport function mapFoldBack(mapping, xs, state) {\r\n    return mapFold((acc, x) => mapping(x, acc), state, reverse(xs));\r\n}\r\n\r\nexport function tryPick(f, xs) {\r\n    const loop = (xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else {\r\n                const matchValue = f(FSharpList__get_Head(xs_1));\r\n                if (matchValue == null) {\r\n                    xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(xs);\r\n}\r\n\r\nexport function pick(f, xs) {\r\n    const matchValue = tryPick(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFind(f, xs) {\r\n    return tryPick((x) => (f(x) ? some(x) : (void 0)), xs);\r\n}\r\n\r\nexport function find(f, xs) {\r\n    const matchValue = tryFind(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindBack(f, xs) {\r\n    return tryFindBack_1(f, toArray(xs));\r\n}\r\n\r\nexport function findBack(f, xs) {\r\n    const matchValue = tryFindBack(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(f, xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else if (f(FSharpList__get_Head(xs_1))) {\r\n                return i;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function findIndex(f, xs) {\r\n    const matchValue = tryFindIndex(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndexBack(f, xs) {\r\n    return tryFindIndexBack_1(f, toArray(xs));\r\n}\r\n\r\nexport function findIndexBack(f, xs) {\r\n    const matchValue = tryFindIndexBack(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryItem(n, xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else if (i === n) {\r\n                return some(FSharpList__get_Head(xs_1));\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function item(n, xs) {\r\n    return FSharpList__get_Item_Z524259A4(xs, n);\r\n}\r\n\r\nexport function filter(f, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        if (f(x)) {\r\n            const t = new FSharpList(x, void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function partition(f, xs) {\r\n    const patternInput = [FSharpList_get_Empty(), FSharpList_get_Empty()];\r\n    const root2 = patternInput[1];\r\n    const root1 = patternInput[0];\r\n    const patternInput_1 = fold(uncurry(2, (tupledArg) => {\r\n        const lacc = tupledArg[0];\r\n        const racc = tupledArg[1];\r\n        return (x) => {\r\n            let t, t_2;\r\n            return f(x) ? [(t = (new FSharpList(x, void 0)), (lacc.tail = t, t)), racc] : [lacc, (t_2 = (new FSharpList(x, void 0)), (racc.tail = t_2, t_2))];\r\n        };\r\n    }), [root1, root2], xs);\r\n    const t_4 = FSharpList_get_Empty();\r\n    patternInput_1[0].tail = t_4;\r\n    const t_5 = FSharpList_get_Empty();\r\n    patternInput_1[1].tail = t_5;\r\n    return [FSharpList__get_Tail(root1), FSharpList__get_Tail(root2)];\r\n}\r\n\r\nexport function choose(f, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        const matchValue = f(x);\r\n        if (matchValue == null) {\r\n            return acc;\r\n        }\r\n        else {\r\n            const t = new FSharpList(value_1(matchValue), void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function contains(value, xs, eq) {\r\n    return tryFindIndex((v) => eq.Equals(value, v), xs) != null;\r\n}\r\n\r\nexport function initialize(n, f) {\r\n    let xs, t;\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    for (let i = 0; i <= (n - 1); i++) {\r\n        node = ((xs = node, (t = (new FSharpList(f(i), void 0)), (xs.tail = t, t))));\r\n    }\r\n    const xs_2 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_2.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function replicate(n, x) {\r\n    return initialize(n, (_arg1) => x);\r\n}\r\n\r\nexport function reduce(f, xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return fold(f, head(xs), tail(xs));\r\n    }\r\n}\r\n\r\nexport function reduceBack(f, xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return foldBack(f, tail(xs), head(xs));\r\n    }\r\n}\r\n\r\nexport function forAll(f, xs) {\r\n    return fold((acc, x) => (acc && f(x)), true, xs);\r\n}\r\n\r\nexport function forAll2(f, xs, ys) {\r\n    return fold2((acc, x, y) => (acc && f(x, y)), true, xs, ys);\r\n}\r\n\r\nexport function exists(f, xs) {\r\n    return tryFindIndex(f, xs) != null;\r\n}\r\n\r\nexport function exists2(f_mut, xs_mut, ys_mut) {\r\n    exists2:\r\n    while (true) {\r\n        const f = f_mut, xs = xs_mut, ys = ys_mut;\r\n        const matchValue = [FSharpList__get_IsEmpty(xs), FSharpList__get_IsEmpty(ys)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0]) {\r\n            if (matchValue[1]) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 2;\r\n            }\r\n        }\r\n        else if (matchValue[1]) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return false;\r\n            }\r\n            case 1: {\r\n                if (f(FSharpList__get_Head(xs), FSharpList__get_Head(ys))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    xs_mut = FSharpList__get_Tail(xs);\r\n                    ys_mut = FSharpList__get_Tail(ys);\r\n                    continue exists2;\r\n                }\r\n            }\r\n            case 2: {\r\n                throw (new Error((SR_differentLengths + \"\\\\nParameter name: \") + \"list2\"));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function unzip(xs) {\r\n    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty()]);\r\n}\r\n\r\nexport function unzip3(xs) {\r\n    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1]), FSharpList_Cons_305B8EAC(tupledArg[2], tupledArg_1[2])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty(), FSharpList_get_Empty()]);\r\n}\r\n\r\nexport function zip(xs, ys) {\r\n    return map2((x, y) => [x, y], xs, ys);\r\n}\r\n\r\nexport function zip3(xs, ys, zs) {\r\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    const arr = toArray(xs);\r\n    arr.sort(comparer);\r\n    return ofArray(arr);\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(x, y), xs);\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);\r\n}\r\n\r\nexport function sum(xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\r\n}\r\n\r\nexport function sumBy(f, xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, x);\r\n    }, averager.GetZero(), xs);\r\n    return averager.DivideByInt(total, count);\r\n}\r\n\r\nexport function averageBy(f, xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, f(x));\r\n    }, averager.GetZero(), xs);\r\n    return averager.DivideByInt(total, count);\r\n}\r\n\r\nexport function permute(f, xs) {\r\n    return ofArray(permute_1(f, toArray(xs)));\r\n}\r\n\r\nexport function chunkBySize(chunkSize, xs) {\r\n    return ofArray(map_1(ofArray, chunkBySize_1(chunkSize, toArray(xs))));\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    iterate((x) => {\r\n        iterate((y) => {\r\n            let xs_1, t;\r\n            node = ((xs_1 = node, (t = (new FSharpList([x, y], void 0)), (xs_1.tail = t, t))));\r\n        }, ys);\r\n    }, xs);\r\n    const xs_3 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_3.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function skip(count_mut, xs_mut) {\r\n    skip:\r\n    while (true) {\r\n        const count = count_mut, xs = xs_mut;\r\n        if (count <= 0) {\r\n            return xs;\r\n        }\r\n        else if (FSharpList__get_IsEmpty(xs)) {\r\n            throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"list\"));\r\n        }\r\n        else {\r\n            count_mut = (count - 1);\r\n            xs_mut = FSharpList__get_Tail(xs);\r\n            continue skip;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function skipWhile(predicate_mut, xs_mut) {\r\n    skipWhile:\r\n    while (true) {\r\n        const predicate = predicate_mut, xs = xs_mut;\r\n        if (FSharpList__get_IsEmpty(xs)) {\r\n            return xs;\r\n        }\r\n        else if (!predicate(FSharpList__get_Head(xs))) {\r\n            return xs;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            xs_mut = FSharpList__get_Tail(xs);\r\n            continue skipWhile;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function take(count, xs) {\r\n    if (count < 0) {\r\n        throw (new Error((SR_inputMustBeNonNegative + \"\\\\nParameter name: \") + \"count\"));\r\n    }\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (i <= 0) {\r\n                return acc;\r\n            }\r\n            else if (FSharpList__get_IsEmpty(xs_1)) {\r\n                throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"list\"));\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(count, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function takeWhile(predicate, xs) {\r\n    const loop = (acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else if (!predicate(FSharpList__get_Head(xs_1))) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function truncate(count, xs) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (i <= 0) {\r\n                return acc;\r\n            }\r\n            else if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(count, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function getSlice(startIndex, endIndex, xs) {\r\n    const len = length(xs) | 0;\r\n    const startIndex_1 = defaultArg(startIndex, 0) | 0;\r\n    const endIndex_1 = defaultArg(endIndex, len - 1) | 0;\r\n    if (startIndex_1 < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"startIndex\"));\r\n    }\r\n    else if (endIndex_1 >= len) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"endIndex\"));\r\n    }\r\n    else if (endIndex_1 < startIndex_1) {\r\n        return FSharpList_get_Empty();\r\n    }\r\n    else {\r\n        return take((endIndex_1 - startIndex_1) + 1, skip(startIndex_1, xs));\r\n    }\r\n}\r\n\r\nexport function splitAt(index, xs) {\r\n    if (index < 0) {\r\n        throw (new Error((SR_inputMustBeNonNegative + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    if (index > FSharpList__get_Length(xs)) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return [take(index, xs), skip(index, xs)];\r\n}\r\n\r\nexport function exactlyOne(xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n    else if (FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {\r\n        return FSharpList__get_Head(xs);\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputSequenceTooLong + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(xs) {\r\n    if ((!FSharpList__get_IsEmpty(xs)) && FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {\r\n        return some(FSharpList__get_Head(xs));\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function where(predicate, xs) {\r\n    return filter(predicate, xs);\r\n}\r\n\r\nexport function pairwise(xs) {\r\n    return ofArray(pairwise_1(toArray(xs)));\r\n}\r\n\r\nexport function windowed(windowSize, xs) {\r\n    return ofArray(map_1(ofArray, windowed_1(windowSize, toArray(xs))));\r\n}\r\n\r\nexport function splitInto(chunks, xs) {\r\n    return ofArray(map_1(ofArray, splitInto_1(chunks, toArray(xs))));\r\n}\r\n\r\nexport function transpose(lists) {\r\n    return ofArray(map_1(ofArray, transpose_1(map_1(toArray, Array.from(lists)))));\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const result = fold((acc, x) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return FSharpList_Cons_305B8EAC(x, FSharpList_Cons_305B8EAC(y, acc));\r\n        }\r\n        else {\r\n            return FSharpList_Cons_305B8EAC(x, acc);\r\n        }\r\n    }, FSharpList_get_Empty(), xs);\r\n    return reverse(isDone ? result : (((i + 1) === index) ? FSharpList_Cons_305B8EAC(y, result) : (() => {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    })()));\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const ys_1 = ofSeq(ys);\r\n    const result = fold((acc, x) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return FSharpList_Cons_305B8EAC(x, append(ys_1, acc));\r\n        }\r\n        else {\r\n            return FSharpList_Cons_305B8EAC(x, acc);\r\n        }\r\n    }, FSharpList_get_Empty(), xs);\r\n    return reverse(isDone ? result : (((i + 1) === index) ? append(ys_1, result) : (() => {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    })()));\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return false;\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    if (!isDone) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    let i = -1;\r\n    let status = -1;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            status = 0;\r\n            return false;\r\n        }\r\n        else if (i > index) {\r\n            if (i < (index + count)) {\r\n                return false;\r\n            }\r\n            else {\r\n                status = 1;\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;\r\n    if (status_1 < 1) {\r\n        const arg = (status_1 < 0) ? \"index\" : \"count\";\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + arg));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    let isDone = false;\r\n    const ys = mapIndexed((i, x) => {\r\n        if (i === index) {\r\n            isDone = true;\r\n            return y;\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n    }, xs);\r\n    if (!isDone) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return ys;\r\n}\r\n\r\n","namespace Fulma\r\n\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\nmodule Reflection =\r\n\r\n    open Microsoft.FSharp.Reflection\r\n    open System\r\n\r\n    let getCaseName (case : 'T) =\r\n#if FABLE_COMPILER\r\n        Fable.Core.Reflection.getCaseName case\r\n#else\r\n        // Get UnionCaseInfo value from the F# reflection tools\r\n        let (caseInfo, _args) = FSharpValue.GetUnionFields(case, typeof<'T>)\r\n        caseInfo.GetCustomAttributes()\r\n        |> Seq.tryPick (function\r\n                        | :? CompiledNameAttribute as att -> Some att.CompiledName\r\n                        | _ -> None)\r\n        |> Option.defaultWith (fun () -> caseInfo.Name)\r\n#endif\r\n\r\n    let getCaseTag (case : 'T) =\r\n#if FABLE_COMPILER\r\n        Fable.Core.Reflection.getCaseTag case\r\n#else\r\n        let (caseInfo, _args) = FSharpValue.GetUnionFields(case, typeof<'T>)\r\n        caseInfo.Tag\r\n#endif\r\n\r\n[<RequireQualifiedAccess>]\r\ntype Screen =\r\n    | All\r\n    | [<CompiledName(\"desktop\")>] Desktop\r\n    | [<CompiledName(\"tablet\")>] Tablet\r\n    | [<CompiledName(\"mobile\")>] Mobile\r\n    | [<CompiledName(\"widescreen\")>] WideScreen\r\n    | [<CompiledName(\"touch\")>] Touch\r\n    | [<CompiledName(\"fullhd\")>] FullHD\r\n\r\n    static member ToString (screen : Screen) =\r\n        match screen with\r\n        | All -> \"\"\r\n        | Desktop\r\n        | Tablet\r\n        | Mobile\r\n        | WideScreen\r\n        | Touch\r\n        | FullHD -> \"-\" + Reflection.getCaseName screen\r\n\r\n[<AutoOpen>]\r\nmodule Color =\r\n\r\n    type IColor =\r\n        | [<CompiledName(\"is-black\")>] IsBlack\r\n        | [<CompiledName(\"is-dark\")>] IsDark\r\n        | [<CompiledName(\"is-light\")>] IsLight\r\n        | [<CompiledName(\"is-white\")>] IsWhite\r\n        | [<CompiledName(\"is-primary\")>] IsPrimary\r\n        | [<CompiledName(\"is-info\")>] IsInfo\r\n        | [<CompiledName(\"is-success\")>] IsSuccess\r\n        | [<CompiledName(\"is-warning\")>] IsWarning\r\n        | [<CompiledName(\"is-danger\")>] IsDanger\r\n        | [<CompiledName(\"is-link\")>] IsLink\r\n        | [<CompiledName(\"is-black-bis\")>] IsBlackBis\r\n        | [<CompiledName(\"is-black-ter\")>] IsBlackTer\r\n        | [<CompiledName(\"is-grey-darker\")>] IsGreyDarker\r\n        | [<CompiledName(\"is-grey-dark\")>] IsGreyDark\r\n        | [<CompiledName(\"is-grey\")>] IsGrey\r\n        | [<CompiledName(\"is-grey-light\")>] IsGreyLight\r\n        | [<CompiledName(\"is-grey-lighter\")>] IsGreyLighter\r\n        | [<CompiledName(\"is-white-ter\")>] IsWhiteTer\r\n        | [<CompiledName(\"is-white-bis\")>] IsWhiteBis\r\n        /// Allow you to specify a custom color. The color will be prefixed by \"is-\"\r\n        | IsCustomColor of string\r\n        /// Allow you to specify a NoColor case.\r\n        | NoColor\r\n\r\n    let ofColor level =\r\n        match level with\r\n        | NoColor -> \"\"\r\n        | IsCustomColor color -> \"is-\" + color\r\n        | IsBlack\r\n        | IsDark\r\n        | IsLight\r\n        | IsWhite\r\n        | IsPrimary\r\n        | IsInfo\r\n        | IsSuccess\r\n        | IsWarning\r\n        | IsDanger\r\n        | IsLink\r\n        | IsBlackBis\r\n        | IsBlackTer\r\n        | IsGreyDarker\r\n        | IsGreyDark\r\n        | IsGrey\r\n        | IsGreyLight\r\n        | IsGreyLighter\r\n        | IsWhiteTer\r\n        | IsWhiteBis -> Reflection.getCaseName level\r\n\r\n[<AutoOpen>]\r\nmodule Size =\r\n\r\n    type ISize =\r\n        | [<CompiledName(\"is-small\")>] IsSmall\r\n        | [<CompiledName(\"is-medium\")>] IsMedium\r\n        | [<CompiledName(\"is-large\")>] IsLarge\r\n\r\n    let inline ofSize size =\r\n        Reflection.getCaseName size\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule TextSize =\r\n    type Option =\r\n        | Is1\r\n        | Is2\r\n        | Is3\r\n        | Is4\r\n        | Is5\r\n        | Is6\r\n        | Is7\r\n\r\n        static member ToString (x: Option) =\r\n            Reflection.getCaseTag x + 1 |> string\r\n\r\n    let inline generic screen size =\r\n        \"is-size-\" + Option.ToString size + Screen.ToString screen\r\n\r\n    let inline only screen size =\r\n        match screen with\r\n        | Screen.Tablet\r\n        | Screen.Desktop\r\n        | Screen.WideScreen ->\r\n            \"is-size-\" + Option.ToString size + Screen.ToString screen + \"-only\"\r\n        | x ->\r\n            Fable.Core.JS.console.warn(sprintf \"Screen `%s` does not support `is-size-xxx-only`.\" (string x))\r\n            \"\"\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule TextAlignment =\r\n\r\n    type Option =\r\n        /// Add `has-text-centered`\r\n        | [<CompiledName(\"has-text-centered\")>] Centered\r\n        /// Add `has-text-justified`\r\n        | [<CompiledName(\"has-text-justified\")>] Justified\r\n        /// Add `has-text-left`\r\n        | [<CompiledName(\"has-text-left\")>] Left\r\n        /// Add `has-text-right`\r\n        | [<CompiledName(\"has-text-right\")>] Right\r\n\r\n        static member inline ToString opt =\r\n            Reflection.getCaseName opt\r\n\r\n    let inline generic screen alignment =\r\n        Option.ToString alignment + Screen.ToString screen\r\n\r\n    let inline only screen alignment =\r\n        match screen with\r\n        | Screen.Tablet\r\n        | Screen.Desktop\r\n        | Screen.WideScreen ->\r\n            Option.ToString alignment + Screen.ToString screen + \"-only\"\r\n        | x ->\r\n            Fable.Core.JS.console.warn(sprintf \"Screen `%s` does not support `is-size-xxx-only`.\" (string x))\r\n            \"\"\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexDirection =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-flex-direction-row</c></summary>\r\n        | [<CompiledName(\"is-flex-direction-row\")>] Row\r\n        /// <summary>Add <c>is-flex-direction-row-reverse</c></summary>\r\n        | [<CompiledName(\"is-flex-direction-row-reverse\")>] RowReverse\r\n        /// <summary>Add <c>is-flex-direction-column</c></summary>\r\n        | [<CompiledName(\"is-flex-direction-column\")>] Column\r\n        /// <summary>Add <c>is-flex-direction-column-reverse</c></summary>\r\n        | [<CompiledName(\"is-flex-direction-column-reverse\")>] ColumnReverse\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexWrap =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-flex-wrap-nowrap</c></summary>\r\n        | [<CompiledName(\"is-flex-wrap-nowrap\")>] NoWrap\r\n        /// <summary>Add <c>is-flex-wrap-wrap</c></summary>\r\n        | [<CompiledName(\"is-flex-wrap-wrap\")>] Wrap\r\n        /// <summary>Add <c>is-flex-wrap-wrap-reverse</c></summary>\r\n        | [<CompiledName(\"is-flex-wrap-wrap-reverse\")>] WrapReverse\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexJustifyContent =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-justify-content-flex-start</c></summary>\r\n        | [<CompiledName(\"is-justify-content-flex-start\")>] FlexStart\r\n        /// <summary>Add <c>is-justify-content-flex-end</c></summary>\r\n        | [<CompiledName(\"is-justify-content-flex-end\")>] FlexEnd\r\n        /// <summary>Add <c>is-justify-content-center</c></summary>\r\n        | [<CompiledName(\"is-justify-content-center\")>] Center\r\n        /// <summary>Add <c>is-justify-content-space-between</c></summary>\r\n        | [<CompiledName(\"is-justify-content-space-between\")>] SpaceBetween\r\n        /// <summary>Add <c>is-justify-content-space-around</c></summary>\r\n        | [<CompiledName(\"is-justify-content-space-around\")>] SpaceAround\r\n        /// <summary>Add <c>is-justify-content-space-evenly</c></summary>\r\n        | [<CompiledName(\"is-justify-content-space-evenly\")>] SpaceEvenly\r\n        /// <summary>Add <c>is-justify-content-start</c></summary>\r\n        | [<CompiledName(\"is-justify-content-start\")>] Start\r\n        /// <summary>Add <c>is-justify-content-end</c></summary>\r\n        | [<CompiledName(\"is-justify-content-end\")>] End\r\n        /// <summary>Add <c>is-justify-content-left</c></summary>\r\n        | [<CompiledName(\"is-justify-content-left\")>] Left\r\n        /// <summary>Add <c>is-justify-content-right</c></summary>\r\n        | [<CompiledName(\"is-justify-content-right\")>] Right\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexAlignContent =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-align-content-flex-start</c></summary>\r\n        | [<CompiledName(\"is-align-content-flex-start\")>] FlexStart\r\n        /// <summary>Add <c>is-align-content-flex-end</c></summary>\r\n        | [<CompiledName(\"is-align-content-flex-end\")>] FlexEnd\r\n        /// <summary>Add <c>is-align-content-center</c></summary>\r\n        | [<CompiledName(\"is-align-content-center\")>] Center\r\n        /// <summary>Add <c>is-align-content-space-between</c></summary>\r\n        | [<CompiledName(\"is-align-content-space-between\")>] SpaceBetween\r\n        /// <summary>Add <c>is-align-content-space-around</c></summary>\r\n        | [<CompiledName(\"is-align-content-space-around\")>] SpaceAround\r\n        /// <summary>Add <c>is-align-content-space-evenly</c></summary>\r\n        | [<CompiledName(\"is-align-content-space-evenly\")>] SpaceEvenly\r\n        /// <summary>Add <c>is-align-content-stretch</c></summary>\r\n        | [<CompiledName(\"is-align-content-stretch\")>] Stretch\r\n        /// <summary>Add <c>is-align-content-start</c></summary>\r\n        | [<CompiledName(\"is-align-content-start\")>] Start\r\n        /// <summary>Add <c>is-align-content-end</c></summary>\r\n        | [<CompiledName(\"is-align-content-end\")>] End\r\n        /// <summary>Add <c>is-align-content-baseline</c></summary>\r\n        | [<CompiledName(\"is-align-content-baseline\")>] Baseline\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexAlignItems =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-align-items-stretch</c></summary>\r\n        | [<CompiledName(\"is-align-items-stretch\")>] Stretch\r\n        /// <summary>Add <c>is-align-items-flex-start</c></summary>\r\n        | [<CompiledName(\"is-align-items-flex-start\")>] FlexStart\r\n        /// <summary>Add <c>is-align-items-flex-end</c></summary>\r\n        | [<CompiledName(\"is-align-items-flex-end\")>] FlexEnd\r\n        /// <summary>Add <c>is-align-items-center</c></summary>\r\n        | [<CompiledName(\"is-align-items-center\")>] Center\r\n        /// <summary>Add <c>is-align-items-baseline</c></summary>\r\n        | [<CompiledName(\"is-align-items-baseline\")>] Baseline\r\n        /// <summary>Add <c>is-align-items-start</c></summary>\r\n        | [<CompiledName(\"is-align-items-start\")>] Start\r\n        /// <summary>Add <c>is-align-items-end</c></summary>\r\n        | [<CompiledName(\"is-align-items-end\")>] End\r\n        /// <summary>Add <c>is-align-items-self-start</c></summary>\r\n        | [<CompiledName(\"is-align-items-self-start\")>] SelfStart\r\n        /// <summary>Add <c>is-align-items-self-end</c></summary>\r\n        | [<CompiledName(\"is-align-items-self-end\")>] SelfEnd\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexAlignSelf =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-align-self-auto</c></summary>\r\n        | [<CompiledName(\"is-align-self-auto\")>] Auto\r\n        /// <summary>Add <c>is-align-self-flex-start</c></summary>\r\n        | [<CompiledName(\"is-align-self-flex-start\")>] FlexStart\r\n        /// <summary>Add <c>is-align-self-flex-end</c></summary>\r\n        | [<CompiledName(\"is-align-self-flex-end\")>] FlexEnd\r\n        /// <summary>Add <c>is-align-self-center</c></summary>\r\n        | [<CompiledName(\"is-align-self-center\")>] Center\r\n        /// <summary>Add <c>is-align-self-baseline</c></summary>\r\n        | [<CompiledName(\"is-align-self-baseline\")>] Baseline\r\n        /// <summary>Add <c>is-align-self-stretch</c></summary>\r\n        | [<CompiledName(\"is-align-self-stretch\")>] Stretch\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexGrow =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-flex-grow-0</c></summary>\r\n        | [<CompiledName(\"is-flex-grow-0\")>] Is0\r\n        /// <summary>Add <c>is-flex-grow-1</c></summary>\r\n        | [<CompiledName(\"is-flex-grow-1\")>] Is1\r\n        /// <summary>Add <c>is-flex-grow-2</c></summary>\r\n        | [<CompiledName(\"is-flex-grow-2\")>] Is2\r\n        /// <summary>Add <c>is-flex-grow-3</c></summary>\r\n        | [<CompiledName(\"is-flex-grow-3\")>] Is3\r\n        /// <summary>Add <c>is-flex-grow-4</c></summary>\r\n        | [<CompiledName(\"is-flex-grow-4\")>] Is4\r\n        /// <summary>Add <c>is-flex-grow-5</c></summary>\r\n        | [<CompiledName(\"is-flex-grow-5\")>] Is5\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule FlexShrink =\r\n\r\n    type Option =\r\n        /// <summary>Add <c>is-flex-shrink-0</c></summary>\r\n        | [<CompiledName(\"is-flex-shrink-0\")>] Is0\r\n        /// <summary>Add <c>is-flex-shrink-1</c></summary>\r\n        | [<CompiledName(\"is-flex-shrink-1\")>] Is1\r\n        /// <summary>Add <c>is-flex-shrink-2</c></summary>\r\n        | [<CompiledName(\"is-flex-shrink-2\")>] Is2\r\n        /// <summary>Add <c>is-flex-shrink-3</c></summary>\r\n        | [<CompiledName(\"is-flex-shrink-3\")>] Is3\r\n        /// <summary>Add <c>is-flex-shrink-4</c></summary>\r\n        | [<CompiledName(\"is-flex-shrink-4\")>] Is4\r\n        /// <summary>Add <c>is-flex-shrink-5</c></summary>\r\n        | [<CompiledName(\"is-flex-shrink-5\")>] Is5\r\n\r\n        static member inline toClass (opt : Option) =\r\n            Reflection.getCaseName opt\r\n\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule TextWeight =\r\n\r\n    type Option =\r\n        /// Add `has-text-weight-light`\r\n        | [<CompiledName(\"has-text-weight-light\")>] Light\r\n        /// Add `has-text-weight-normal`\r\n        | [<CompiledName(\"has-text-weight-normal\")>] Normal\r\n        /// Add `has-text-weight-semibold`\r\n        | [<CompiledName(\"has-text-weight-semibold\")>] SemiBold\r\n        /// Add `has-text-weight-bold`\r\n        | [<CompiledName(\"has-text-weight-bold\")>] Bold\r\n        /// Add `has-text-weight-medium`\r\n        | [<CompiledName(\"has-text-weight-medium\")>] Medium\r\n\r\n    let inline internal ofOption opt =\r\n        Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule TextTransform =\r\n\r\n    type Option =\r\n        /// Add `is-capitalized`\r\n        | [<CompiledName(\"is-capitalized\")>] Capitalized\r\n        /// Add `is-lowercase`\r\n        | [<CompiledName(\"is-lowercase\")>] LowerCase\r\n        /// Add `is-uppercase`\r\n        | [<CompiledName(\"is-uppercase\")>] UpperCase\r\n        /// Add `is-italic`\r\n        | [<CompiledName(\"is-italic\")>] Italic\r\n        /// Add `is-underlined`\r\n        | [<CompiledName(\"is-underlined\")>] Underlined\r\n\r\n        static member inline toClass opt =\r\n            Reflection.getCaseName opt\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Display =\r\n\r\n    type Option =\r\n        | [<CompiledName(\"block\")>] Block\r\n        | [<CompiledName(\"flex\")>] Flex\r\n        | [<CompiledName(\"inline\")>] Inline\r\n        | [<CompiledName(\"inline-block\")>] InlineBlock\r\n        | [<CompiledName(\"inline-flex\")>] InlineFlex\r\n\r\n        static member inline toClass opt =\r\n            Reflection.getCaseName opt\r\n\r\n    let internal toDisplayClass screen display =\r\n        let display = Option.toClass display\r\n        let screen = Screen.ToString screen\r\n\r\n        \"is-\" + display + screen\r\n\r\n    let internal toDisplayOnlyClass screen display =\r\n        match screen with\r\n        | Screen.Tablet\r\n        | Screen.Desktop\r\n        | Screen.WideScreen ->\r\n            let display = Option.toClass display\r\n            let screen = Screen.ToString screen\r\n            \"is-\" + display + screen + \"-only\"\r\n\r\n        | x ->\r\n            Fable.Core.JS.console.warn(sprintf \"Screen `%s` does not support display only.\" (string x))\r\n            \"\"\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Spacing =\r\n    type TypeAndDirection =\r\n        | [<CompiledName(\"m\")>] Margin\r\n        | [<CompiledName(\"mt\")>] MarginTop\r\n        | [<CompiledName(\"mr\")>] MarginRight\r\n        | [<CompiledName(\"mb\")>] MarginBottom\r\n        | [<CompiledName(\"ml\")>] MarginLeft\r\n        | [<CompiledName(\"my\")>] MarginTopAndBottom\r\n        | [<CompiledName(\"mx\")>] MarginLeftAndRight\r\n        | [<CompiledName(\"p\")>] Padding\r\n        | [<CompiledName(\"pt\")>] PaddingTop\r\n        | [<CompiledName(\"pr\")>] PaddingRight\r\n        | [<CompiledName(\"pb\")>] PaddingBottom\r\n        | [<CompiledName(\"pl\")>] PaddingLeft\r\n        | [<CompiledName(\"py\")>] PaddingTopAndBottom\r\n        | [<CompiledName(\"px\")>] PaddingLeftAndRight\r\n\r\n        static member inline toClass opt =\r\n            Reflection.getCaseName opt\r\n\r\n    type Amount =\r\n        | [<CompiledName(\"auto\")>] IsAuto\r\n        | [<CompiledName(\"0\")>] Is0\r\n        | [<CompiledName(\"1\")>] Is1\r\n        | [<CompiledName(\"2\")>] Is2\r\n        | [<CompiledName(\"3\")>] Is3\r\n        | [<CompiledName(\"4\")>] Is4\r\n        | [<CompiledName(\"5\")>] Is5\r\n        | [<CompiledName(\"6\")>] Is6\r\n\r\n        static member inline toClass opt =\r\n            Reflection.getCaseName opt\r\n\r\n    let internal toSpacingClass typ amount =\r\n        let typ = TypeAndDirection.toClass typ\r\n        let amount = Amount.toClass amount\r\n\r\n        typ + \"-\" + amount\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Modifier =\r\n    let internal ofBackground level =\r\n        match level with\r\n        | NoColor -> \"\"\r\n        | IsCustomColor color -> \"has-background-\" + color\r\n        | IsBlack\r\n        | IsDark\r\n        | IsLight\r\n        | IsWhite\r\n        | IsPrimary\r\n        | IsInfo\r\n        | IsSuccess\r\n        | IsWarning\r\n        | IsDanger\r\n        | IsLink\r\n        | IsBlackBis\r\n        | IsBlackTer\r\n        | IsGreyDarker\r\n        | IsGreyDark\r\n        | IsGrey\r\n        | IsGreyLight\r\n        | IsGreyLighter\r\n        | IsWhiteTer\r\n        | IsWhiteBis -> \"has-background-\" + (Reflection.getCaseName level).[3..]\r\n\r\n    let internal ofText level =\r\n        match level with\r\n        | NoColor -> \"\"\r\n        | IsCustomColor color -> \"has-text-\" + color\r\n        | IsBlack\r\n        | IsDark\r\n        | IsLight\r\n        | IsWhite\r\n        | IsPrimary\r\n        | IsInfo\r\n        | IsSuccess\r\n        | IsWarning\r\n        | IsDanger\r\n        | IsLink\r\n        | IsBlackBis\r\n        | IsBlackTer\r\n        | IsGreyDarker\r\n        | IsGreyDark\r\n        | IsGrey\r\n        | IsGreyLight\r\n        | IsGreyLighter\r\n        | IsWhiteTer\r\n        | IsWhiteBis -> \"has-text-\" + (Reflection.getCaseName level).[3..]\r\n\r\n    let internal ofInvisible screen =\r\n        \"is-invisible\" + Screen.ToString screen\r\n\r\n    let internal ofHidden screen =\r\n        \"is-hidden\" + Screen.ToString screen\r\n\r\n    let internal ofInvisibleOnly screen =\r\n        match screen with\r\n        | Screen.Tablet\r\n        | Screen.Desktop\r\n        | Screen.WideScreen ->\r\n            \"is-invisible\" + Screen.ToString screen + \"-only\"\r\n        | x ->\r\n            Fable.Core.JS.console.warn(sprintf \"Screen `%s` does not support `is-invisible-xxx-only`.\" (string x))\r\n            \"\"\r\n\r\n    let internal ofHiddenOnly screen =\r\n        match screen with\r\n        | Screen.Tablet\r\n        | Screen.Desktop\r\n        | Screen.WideScreen ->\r\n            \"is-hidden\" + Screen.ToString screen + \"-only\"\r\n        | x ->\r\n            Fable.Core.JS.console.warn(sprintf \"Screen `%s` does not support `is-hidden-xxx-only`.\" (string x))\r\n            \"\"\r\n\r\n    type IModifier =\r\n        | BackgroundColor of IColor\r\n        | TextColor of IColor\r\n        | TextWeight of TextWeight.Option\r\n        | TextSize of Screen * TextSize.Option\r\n        | TextSizeOnly of Screen * TextSize.Option\r\n        | TextAlignment of Screen * TextAlignment.Option\r\n        | TextAlignmentOnly of Screen * TextAlignment.Option\r\n        | TextTransform of TextTransform.Option\r\n        | Display of Screen * Display.Option\r\n        | DisplayOnly of Screen * Display.Option\r\n        | [<CompiledName(\"is-clearfix\")>] IsClearfix\r\n        | [<CompiledName(\"is-pulled-left\")>] IsPulledLeft\r\n        | [<CompiledName(\"is-pulled-right\")>] IsPulledRight\r\n        | [<CompiledName(\"is-marginless\")>] IsMarginless\r\n        | [<CompiledName(\"is-paddingless\")>] IsPaddingless\r\n        | [<CompiledName(\"is-overlay\")>] IsOverlay\r\n        | [<CompiledName(\"is-clipped\")>] IsClipped\r\n        | [<CompiledName(\"is-radiusless\")>] IsRadiusless\r\n        | [<CompiledName(\"is-shadowless\")>] IsShadowless\r\n        | [<CompiledName(\"is-unselectable\")>] IsUnselectable\r\n        | [<CompiledName(\"is-clickable\")>] IsClickable\r\n        | [<CompiledName(\"is-relative\")>] IsRelative\r\n        | [<CompiledName(\"is-flex\")>] IsFlex\r\n        | IsInvisible of Screen * bool\r\n        | IsHidden of Screen * bool\r\n        | IsInvisibleOnly of Screen * bool\r\n        | IsHiddenOnly of Screen * bool\r\n        | IsSrOnly\r\n        | IsScreenReaderOnly\r\n        | Spacing of Spacing.TypeAndDirection * Spacing.Amount\r\n        // Flexbox helpers\r\n        | FlexDirection of FlexDirection.Option\r\n        | FlexWrap of FlexWrap.Option\r\n        | FlexJustifyContent of FlexJustifyContent.Option\r\n        | FlexAlignContent of FlexAlignContent.Option\r\n        | FlexAlignItems of FlexAlignItems.Option\r\n        | FlexAlignSelf of FlexAlignSelf.Option\r\n        | FlexGrow of FlexGrow.Option\r\n        | FlexShrink of FlexShrink.Option\r\n\r\n\r\n\r\n                //     | IsGap (screen, size) ->\r\n                // if not (List.contains \"is-variable\" result.Classes) then\r\n                //     result.AddClass(\"is-variable\").AddClass(gapSizeGeneric screen size)\r\n                // else\r\n                //     result.AddClass(gapSizeGeneric screen size)\r\n\r\n\r\n\r\n    let parseModifiers options =\r\n        let parseOptions result option =\r\n            match option with\r\n            | BackgroundColor color             -> (ofBackground color)::result\r\n            | TextColor color                   -> (ofText color)::result\r\n            | TextWeight textWeight             -> (TextWeight.ofOption textWeight)::result\r\n            | TextSize (screen, size)           -> (TextSize.generic screen size)::result\r\n            | TextSizeOnly (screen, size)       -> (TextSize.only screen size)::result\r\n            | TextAlignment (screen, size)      -> (TextAlignment.generic screen size)::result\r\n            | TextAlignmentOnly (screen, size)  -> (TextAlignment.only screen size)::result\r\n            | TextTransform transform           -> (TextTransform.Option.toClass transform)::result\r\n            | Display (screen, display)         -> (Display.toDisplayClass screen display)::result\r\n            | DisplayOnly (screen, display)     -> (Display.toDisplayOnlyClass screen display)::result\r\n            | IsInvisible (screen, b)           -> if b then (ofInvisible screen)::result else result\r\n            | IsInvisibleOnly (screen, b)       -> if b then (ofInvisibleOnly screen)::result else result\r\n            | IsHidden (screen, b)              -> if b then (ofHidden screen)::result else result\r\n            | IsHiddenOnly (screen, b)          -> if b then (ofHiddenOnly screen)::result else result\r\n            | IsSrOnly\r\n            | IsScreenReaderOnly -> \"is-sr-only\"::result\r\n            | IsClearfix\r\n            | IsPulledLeft\r\n            | IsPulledRight\r\n            | IsMarginless\r\n            | IsPaddingless\r\n            | IsOverlay\r\n            | IsClipped\r\n            | IsRadiusless\r\n            | IsShadowless\r\n            | IsClickable\r\n            | IsUnselectable\r\n            | IsFlex\r\n            | IsRelative -> (Reflection.getCaseName option)::result\r\n            | Spacing (typ, amount) -> (Spacing.toSpacingClass typ amount)::result\r\n            | FlexDirection direction ->\r\n                if not (List.contains \"is-flex\" result) then\r\n                    \"is-flex\"::(FlexDirection.Option.toClass direction)::result\r\n                else\r\n                    (FlexDirection.Option.toClass direction)::result\r\n            | FlexWrap option ->\r\n                if not (List.contains \"is-flex\" result) then\r\n                    \"is-flex\"::(FlexWrap.Option.toClass option)::result\r\n                else\r\n                    (FlexWrap.Option.toClass option)::result\r\n            | FlexJustifyContent option ->\r\n                if not (List.contains \"is-flex\" result) then\r\n                    \"is-flex\"::(FlexJustifyContent.Option.toClass option)::result\r\n                else\r\n                    (FlexJustifyContent.Option.toClass option)::result\r\n            | FlexAlignContent option ->\r\n                if not (List.contains \"is-flex\" result) then\r\n                    \"is-flex\"::(FlexAlignContent.Option.toClass option)::result\r\n                else\r\n                    (FlexAlignContent.Option.toClass option)::result\r\n            | FlexAlignItems option ->\r\n                if not (List.contains \"is-flex\" result) then\r\n                    \"is-flex\"::(FlexAlignItems.Option.toClass option)::result\r\n                else\r\n                    (FlexAlignItems.Option.toClass option)::result\r\n\r\n            | FlexAlignSelf option ->\r\n                (FlexAlignSelf.Option.toClass option)::result\r\n\r\n            | FlexGrow size ->\r\n                (FlexGrow.Option.toClass size)::result\r\n\r\n            | FlexShrink size ->\r\n                (FlexShrink.Option.toClass size)::result\r\n\r\n        options |> List.fold parseOptions []\r\n\r\n[<AutoOpen>]\r\nmodule Common =\r\n    type GenericOption =\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    type GenericOptions =\r\n        { Props : IHTMLProp list\r\n          Classes : string list\r\n          RemovedClasses : string list }\r\n\r\n        static member Empty =\r\n            { Props = []; Classes = []; RemovedClasses = [] }\r\n\r\n        static member Parse(options, parser, ?baseClass, ?baseProps) =\r\n            let result = options |> List.fold parser GenericOptions.Empty\r\n\r\n            let result =\r\n                match baseClass with\r\n                | Some baseClass -> result.AddClass(baseClass)\r\n                | None -> result\r\n\r\n            match baseProps with\r\n            | Some baseProps -> result.AddProps(baseProps)\r\n            | None -> result\r\n\r\n        member this.AddProp(prop : IHTMLProp) =\r\n            { this with Props = prop::this.Props }\r\n\r\n        member this.AddProps(props : IHTMLProp list) =\r\n            { this with Props = props@this.Props }\r\n\r\n        member this.AddClass(cl: string) =\r\n            { this with Classes = cl::this.Classes }\r\n\r\n        member this.RemoveClass(cl: string) =\r\n            { this with RemovedClasses = cl::this.RemovedClasses }\r\n\r\n        member this.AddCaseName(case: 'T) =\r\n            Reflection.getCaseName case |> this.AddClass\r\n\r\n        member this.AddModifiers(modifiers) =\r\n            { this with Classes = (modifiers |> Modifier.parseModifiers) @ this.Classes }\r\n\r\n        member this.ToAttributes() =\r\n            match this.Classes |> List.filter (fun cls -> not (System.String.IsNullOrEmpty cls) && not (List.contains cls this.RemovedClasses)) with\r\n            | [] -> this.Props\r\n            | classes -> (classes |> String.concat \" \" |> ClassName :> _) :: this.Props\r\n\r\n        /// Convert to standard element\r\n        member this.ToReactElement(el : IHTMLProp list -> ReactElement list -> ReactElement, ?children): ReactElement =\r\n            let children = defaultArg children []\r\n            el (this.ToAttributes ()) children\r\n\r\n        /// Convert to self closing element\r\n        member this.ToReactElement(el : IHTMLProp list -> ReactElement): ReactElement =\r\n            el (this.ToAttributes ())\r\n\r\n    let parseOptions (result : GenericOptions) option =\r\n        match option with\r\n        | Props props -> result.AddProps props\r\n        | CustomClass customClass -> result.AddClass customClass\r\n        | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n    module Helpers =\r\n\r\n        [<System.Obsolete(\"Use GenericOptions.Parse. This build an abstraction layer usable by all the components and helps reduce the bundle size\")>]\r\n        let classes std (options : string option list) (booleans: (string * bool) list) =\r\n            let std = (std, options) ||> List.fold (fun complete option ->\r\n                match option with\r\n                | Some name -> complete + \" \" + name\r\n                | None -> complete )\r\n            (std, booleans) ||> List.fold (fun complete (name, flag) ->\r\n                if flag then complete + \" \" + name else complete)\r\n            |> ClassName :> IHTMLProp\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Text =\r\n    open Fable.React\r\n\r\n    let p (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions).ToReactElement(p, children)\r\n\r\n    let div (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions).ToReactElement(div, children)\r\n\r\n    let span (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions).ToReactElement(span, children)\r\n","import { equals } from \"./Util.js\";\nimport { Union } from \"./Types.js\";\nconst CaseRules = {\n    None: 0,\n    LowerFirst: 1,\n    SnakeCase: 2,\n    SnakeCaseAllCaps: 3,\n    KebabCase: 4,\n};\nfunction dashify(str, separator) {\n    return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1\n        ? m.toLowerCase()\n        : m.charAt(0) + separator + m.charAt(1).toLowerCase());\n}\nfunction changeCase(str, caseRule) {\n    switch (caseRule) {\n        case CaseRules.LowerFirst:\n            return str.charAt(0).toLowerCase() + str.slice(1);\n        case CaseRules.SnakeCase:\n            return dashify(str, \"_\");\n        case CaseRules.SnakeCaseAllCaps:\n            return dashify(str, \"_\").toUpperCase();\n        case CaseRules.KebabCase:\n            return dashify(str, \"-\");\n        case CaseRules.None:\n        default:\n            return str;\n    }\n}\nexport function keyValueList(fields, caseRule = CaseRules.None) {\n    const obj = {};\n    const definedCaseRule = caseRule;\n    function fail(kvPair) {\n        throw new Error(\"Cannot infer key and value of \" + String(kvPair));\n    }\n    function assign(key, caseRule, value) {\n        key = changeCase(key, caseRule);\n        obj[key] = value;\n    }\n    for (let kvPair of fields) {\n        let caseRule = CaseRules.None;\n        if (kvPair == null) {\n            fail(kvPair);\n        }\n        // Deflate unions and use the defined case rule\n        if (kvPair instanceof Union) {\n            const name = kvPair.cases()[kvPair.tag];\n            kvPair = kvPair.fields.length === 0 ? name : [name].concat(kvPair.fields);\n            caseRule = definedCaseRule;\n        }\n        if (Array.isArray(kvPair)) {\n            switch (kvPair.length) {\n                case 0:\n                    fail(kvPair);\n                    break;\n                case 1:\n                    assign(kvPair[0], caseRule, true);\n                    break;\n                case 2:\n                    const value = kvPair[1];\n                    assign(kvPair[0], caseRule, value);\n                    break;\n                default:\n                    assign(kvPair[0], caseRule, kvPair.slice(1));\n            }\n        }\n        else if (typeof kvPair === \"string\") {\n            assign(kvPair, caseRule, true);\n        }\n        else {\n            fail(kvPair);\n        }\n    }\n    return obj;\n}\n// TODO: Move these methods to Map and Set modules\nexport function containsValue(v, map) {\n    for (const kv of map) {\n        if (equals(v, kv[1])) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function tryGetValue(map, key, defaultValue) {\n    if (map.has(key)) {\n        defaultValue.contents = map.get(key);\n        return true;\n    }\n    return false;\n}\nexport function addToSet(v, set) {\n    if (set.has(v)) {\n        return false;\n    }\n    set.add(v);\n    return true;\n}\nexport function addToDict(dict, k, v) {\n    if (dict.has(k)) {\n        throw new Error(\"An item with the same key has already been added. Key: \" + k);\n    }\n    dict.set(k, v);\n}\nexport function getItemFromDict(map, key) {\n    if (map.has(key)) {\n        return map.get(key);\n    }\n    else {\n        throw new Error(`The given key '${key}' was not present in the dictionary.`);\n    }\n}\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\nopen Browser.Types\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Navbar =\r\n\r\n    type Option =\r\n        | Color of IColor\r\n        /// Add `has-shadow` class\r\n        | [<CompiledName(\"has-shadow\")>] HasShadow\r\n        /// Add `is-transparent` class\r\n        | [<CompiledName(\"is-transparent\")>] IsTransparent\r\n        /// Add `is-fixed-top` class\r\n        /// You also need to add `has-navbar-fixed-top` to your html tag\r\n        | [<CompiledName(\"is-fixed-top\")>] IsFixedTop\r\n        /// Add `is-fixed-bottom` class\r\n        /// You also need to add `has-navbar-fixed-bottom` to your html tag\r\n        | [<CompiledName(\"is-fixed-bottom\")>] IsFixedBottom\r\n        /// Add `is-spaced` class\r\n        /// Increases horizontal and vertical padding of the navbar\r\n        | [<CompiledName(\"is-spaced\")>] IsSpaced\r\n        | Props of IHTMLProp list\r\n        | CustomClass of string\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    module Menu =\r\n\r\n        type Option =\r\n            /// Add `is-active` class if true\r\n            | [<CompiledName(\"is-active\")>] IsActive of bool\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    module Burger =\r\n\r\n        type Option =\r\n            /// Add `is-active` class if true\r\n            | [<CompiledName(\"is-active\")>] IsActive of bool\r\n            | OnClick of (MouseEvent -> unit)\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    module Item =\r\n\r\n        type Option =\r\n            /// Add `is-tab` class\r\n            | [<CompiledName(\"is-tab\")>] IsTab\r\n            /// Add `is-active` class if true\r\n            | [<CompiledName(\"is-active\")>] IsActive of bool\r\n            /// Add `is-hoverable` class\r\n            | [<CompiledName(\"is-hoverable\")>] IsHoverable\r\n            /// Add `has-dropdown` class\r\n            | [<CompiledName(\"has-dropdown\")>] HasDropdown\r\n            /// Add `is-expanded` class\r\n            | [<CompiledName(\"is-expanded\")>] IsExpanded\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n        let internal item element options children =\r\n            let parseOptions (result : GenericOptions) option =\r\n                match option with\r\n                | IsActive state -> if state then result.AddCaseName option else result\r\n                | IsExpanded\r\n                | IsTab\r\n                | IsHoverable\r\n                | HasDropdown -> result.AddCaseName option\r\n                | Props props -> result.AddProps props\r\n                | CustomClass customClass -> result.AddClass customClass\r\n                | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n            GenericOptions.Parse(options, parseOptions, \"navbar-item\").ToReactElement(element, children)\r\n\r\n        /// Generate <div class=\"navbar-item\"></div>\r\n        let div x y = item div x y\r\n        /// Generate <a class=\"navbar-item\"></a>\r\n        let a x y = item a x y\r\n\r\n    module Link =\r\n\r\n        type Option =\r\n            /// Add `is-active` class if true\r\n            | [<CompiledName(\"is-active\")>] IsActive of bool\r\n            /// Add `is-arrowless`\r\n            | [<CompiledName(\"is-arrowless\")>] IsArrowless\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n        let internal link element (options : Option list) children =\r\n            let parseOptions (result : GenericOptions) option =\r\n                match option with\r\n                | IsActive state -> if state then result.AddCaseName option else result\r\n                | IsArrowless -> result.AddCaseName option\r\n                | Props props -> result.AddProps props\r\n                | CustomClass customClass -> result.AddClass customClass\r\n                | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n            GenericOptions.Parse(options, parseOptions, \"navbar-link\").ToReactElement(element, children)\r\n\r\n        /// Generate <div class=\"navbar-link\"></div>\r\n        let div x y = link div x y\r\n        /// Generate <a class=\"navbar-link\"></a>\r\n        let a x y = link a x y\r\n\r\n    module Dropdown =\r\n\r\n        type Option =\r\n            /// Add `is-active` class if true\r\n            | [<CompiledName(\"is-active\")>] IsActive of bool\r\n            /// Add `is-boxed` class\r\n            | [<CompiledName(\"is-boxed\")>] IsBoxed\r\n            /// Add `is-right` class\r\n            | [<CompiledName(\"is-right\")>] IsRight\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n        let internal dropdown element (options : Option list) children =\r\n            let parseOptions (result : GenericOptions) option =\r\n                match option with\r\n                | IsActive state -> if state then result.AddCaseName option else result\r\n                | IsBoxed\r\n                | IsRight -> result.AddCaseName option\r\n                | Props props -> result.AddProps props\r\n                | CustomClass customClass -> result.AddClass customClass\r\n                | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n            GenericOptions.Parse(options, parseOptions, \"navbar-dropdown\").ToReactElement(element, children)\r\n\r\n        /// Generate <div class=\"navbar-dropdown\"></div>\r\n        let div x y = dropdown div x y\r\n        /// Generate <a class=\"navbar-dropdown\"></a>\r\n        let a x y = dropdown a x y\r\n\r\n    module Brand =\r\n        let internal brand element (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"navbar-brand\").ToReactElement(element, children)\r\n\r\n        /// Generate <div class=\"navbar-brand\"></div>\r\n        let div x y = brand div x y\r\n        /// Generate <a class=\"navbar-brand\"></a>\r\n        let a x y = brand a x y\r\n\r\n    module Start =\r\n        let internal start element (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"navbar-start\").ToReactElement(element, children)\r\n\r\n        /// Generate <div class=\"navbar-start\"></div>\r\n        let div x y = start div x y\r\n        /// Generate <a class=\"navbar-start\"></a>\r\n        let a x y = start a x y\r\n\r\n    module End =\r\n        let internal ``end`` element (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"navbar-end\").ToReactElement(element, children)\r\n\r\n        /// Generate <div class=\"navbar-end\"></div>\r\n        let div x y = ``end`` div x y\r\n        /// Generate <a class=\"navbar-end\"></a>\r\n        let a x y = ``end`` a x y\r\n\r\n    /// Generate <nav class=\"navbar\"></nav>\r\n    let navbar (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | HasShadow\r\n            | IsFixedTop\r\n            | IsFixedBottom\r\n            | IsTransparent\r\n            | IsSpaced -> result.AddCaseName option\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"navbar\").ToReactElement(nav, children)\r\n\r\n    /// Generate <div class=\"navbar-menu\"></div>\r\n    let menu options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Menu.IsActive state -> if state then result.AddCaseName option else result\r\n            | Menu.Props props -> result.AddProps props\r\n            | Menu.CustomClass customClass -> result.AddClass customClass\r\n            | Menu.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"navbar-menu\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"navbar-burger\"></div>\r\n    let burger options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Burger.IsActive state -> if state then result.AddCaseName option else result\r\n            | Burger.OnClick cb -> DOMAttr.OnClick cb |> result.AddProp\r\n            | Burger.Props props -> result.AddProps props\r\n            | Burger.CustomClass customClass -> result.AddClass customClass\r\n            | Burger.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"navbar-burger\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"navbar-content\"></div>\r\n    let content (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"navbar-content\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"navbar-divider\"></div>\r\n    let divider (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"navbar-divider\").ToReactElement(div, children)\r\n","module JSInterop\r\n\r\nopen Fable.Core.JsInterop\r\nopen Fable.Core.DynamicExtensions\r\nopen Fable.Core\r\nopen Browser.Dom\r\nopen Fable.React\r\nopen Fable.React.Props\r\nopen Browser.Types\r\n\r\n//open Fulma.FontAwesome\r\n\r\nmodule FileInputHelper =\r\n\r\n    //!!===================================================!!\r\n    //Credit goes to https://github.com/GuuD/fable-file-input\r\n    //!!===================================================!!\r\n\r\n    type FileInfo<'t> = \r\n        { Name: string; MIME: string; Data: 't }\r\n\r\n    [<Emit(\"new Promise($0)\")>]\r\n    let createPromise (executor: ('t -> unit) -> (exn -> unit) -> unit): JS.Promise<'t> = jsNative\r\n\r\n    [<Emit(\"$1.then($0)\")>]\r\n    let consumePromise (callback: 't->unit) (_promise: JS.Promise<'t>): unit = jsNative\r\n    let private readInternal<'t> (readMethod: string) (blob: Browser.Types.Blob) = \r\n        createPromise(fun resolve reject -> \r\n            try\r\n                let reader = Browser.Dom.FileReader.Create()\r\n                reader.onload <- (fun _ -> reader.result |> unbox<'t> |> resolve)\r\n                reader.[readMethod].Invoke(blob) |> ignore\r\n            with \r\n            | e -> e |> reject\r\n        )\r\n    let readAsText blob: JS.Promise<string> = \r\n        readInternal \"readAsText\" blob\r\n    let readAsDataURL blob: JS.Promise<string> = \r\n        readInternal \"readAsDataURL\" blob\r\n    let readAsArrayBuffer blob: JS.Promise<JS.ArrayBuffer> = \r\n        readInternal \"readAsArrayBuffer\" blob\r\n    module React = \r\n        open Fable.React\r\n        open Props\r\n        let extract f list = \r\n            let rec seek traversed = function\r\n                | h::t ->\r\n                    match f h with\r\n                    | Some h' -> Some h', (List.rev traversed)@t\r\n                    | _ -> seek (h::traversed) t\r\n                | [] -> None, (List.rev traversed)\r\n            seek [] list\r\n\r\n        type FileCallback = \r\n            | OnFileBytesReceived of (FileInfo<JS.ArrayBuffer> -> unit)\r\n            | OnDataUrlReceived of (FileInfo<string> -> unit)\r\n            | OnTextReceived of (FileInfo<string> -> unit)\r\n            interface Props.IHTMLProp\r\n\r\n        let inline singleFileInput (props: Props.IHTMLProp list) = \r\n            let existingChangeHandler, otherProps = \r\n                props |> extract (function \r\n                    | :? DOMAttr as prop -> \r\n                        match prop with\r\n                        | OnChange callback -> Some callback\r\n                        | _ -> None\r\n                    | _ -> None)\r\n            let loadCallback, withoutCallbacks = otherProps |> extract (function | :? FileCallback as fc -> Some fc | _ -> None)   \r\n            let changeHandler (e : Event) = \r\n                let files: FileList = !!e.target.[\"files\"]\r\n                if files.length > 0 then\r\n                    let file = files.[0]\r\n                    match loadCallback with\r\n                    | Some(OnFileBytesReceived r) -> \r\n                        readAsArrayBuffer file\r\n                        |> consumePromise (fun bytes -> r { Name = file.name; MIME = file.``type``; Data = bytes })\r\n                    | Some(OnDataUrlReceived r) ->\r\n                        readAsDataURL file\r\n                        |> consumePromise (fun data -> r { Name = file.name; MIME = file.``type``; Data = data } )\r\n                    | Some(OnTextReceived r) ->\r\n                        readAsText file\r\n                        |> consumePromise (fun data -> r { Name = file.name; MIME = file.``type``; Data = data } )\r\n                    | _ -> console.warn(\"You probably need to attach callback to the file input field\")                \r\n                match existingChangeHandler with\r\n                | Some h -> h e\r\n                | _ -> ()\r\n            input ([OnChange changeHandler; Type \"file\" ]@withoutCallbacks)\r\n\r\n\r\nlet gradientColorTable = [|\r\n    \"#FAEE05\"\r\n    \"#FAEE05\"\r\n    \"#F8E109\"\r\n    \"#F7D40E\"\r\n    \"#F5C813\"\r\n    \"#F4BB18\"\r\n    \"#F2AF1D\"\r\n    \"#F1A222\"\r\n    \"#EF9627\"\r\n    \"#EE892C\"\r\n    \"#ED7D31\"\r\n|]\r\n\r\ntype CustomHTMLAttr = \r\n    | [<CompiledName(\"data-dismiss\")>]  DataDismiss     of string\r\n    | [<CompiledName(\"aria-label\")>]    AriaLabel       of string\r\n    | [<CompiledName(\"aria-hidden\")>]   AriaHidden      of bool\r\n    | [<CompiledName(\"aria-controls\")>] AriaControls    of string\r\n    | [<CompiledName(\"aria-haspopup\")>] AriaHasPopup    of bool\r\n    interface IHTMLProp ","namespace Fable.Remoting.Client \r\n\r\nopen System\r\n\r\ntype HttpMethod = GET | POST \r\n\r\ntype RequestBody = \r\n    | Empty\r\n    | Json of string \r\n    | Binary of byte[] \r\n\r\ntype CustomResponseSerializer = byte[] -> Type -> obj\r\n\r\ntype HttpRequest = {\r\n    HttpMethod: HttpMethod\r\n    Url: string \r\n    Headers: (string * string) list  \r\n    RequestBody : RequestBody\r\n    WithCredentials : bool\r\n}\r\n \r\ntype HttpResponse = {\r\n    StatusCode: int \r\n    ResponseBody: string\r\n}\r\n\r\ntype RemoteBuilderOptions = {\r\n    CustomHeaders : (string * string) list\r\n    BaseUrl  : string option\r\n    Authorization : string option\r\n    WithCredentials : bool\r\n    RouteBuilder : (string -> string -> string)\r\n    CustomResponseSerialization : CustomResponseSerializer option\r\n}\r\n\r\ntype ProxyRequestException(response: HttpResponse, errorMsg, reponseText: string) = \r\n    inherit System.Exception(errorMsg)\r\n    member this.Response = response \r\n    member this.StatusCode = response.StatusCode\r\n    member this.ResponseText = reponseText ","import { disposeSafe, structuralHash, equals } from \"./Util.js\";\r\nimport { HashIdentity_Structural, ComparisonIdentity_Structural } from \"./FSharp.Collections.js\";\r\nimport { StringBuilder__Append_Z721C83C5 } from \"./System.Text.js\";\r\n\r\nexport const LanguagePrimitives_GenericEqualityComparer = {\r\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\r\n        return equals(x, y);\r\n    },\r\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\r\n        return structuralHash(x_1);\r\n    },\r\n};\r\n\r\nexport const LanguagePrimitives_GenericEqualityERComparer = {\r\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\r\n        return equals(x, y);\r\n    },\r\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\r\n        return structuralHash(x_1);\r\n    },\r\n};\r\n\r\nexport function LanguagePrimitives_FastGenericComparer() {\r\n    return ComparisonIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericComparerFromTable() {\r\n    return ComparisonIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericEqualityComparer() {\r\n    return HashIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericEqualityComparerFromTable() {\r\n    return HashIdentity_Structural();\r\n}\r\n\r\nexport function Operators_Failure(message) {\r\n    return new Error(message);\r\n}\r\n\r\nexport function Operators_FailurePattern(exn) {\r\n    return exn.message;\r\n}\r\n\r\nexport function Operators_NullArg(x) {\r\n    throw (new Error(x));\r\n}\r\n\r\nexport function Operators_Using(resource, action) {\r\n    try {\r\n        return action(resource);\r\n    }\r\n    finally {\r\n        if (equals(resource, null)) {\r\n        }\r\n        else {\r\n            disposeSafe(resource);\r\n        }\r\n    }\r\n}\r\n\r\nexport function Operators_Lock(_lockObj, action) {\r\n    return action();\r\n}\r\n\r\nexport function ExtraTopLevelOperators_LazyPattern(input) {\r\n    return input.Value;\r\n}\r\n\r\nexport function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {\r\n    return format.cont((s) => {\r\n        StringBuilder__Append_Z721C83C5(builder, s);\r\n        return continuation();\r\n    });\r\n}\r\n\r\nexport function PrintfModule_PrintFormatToStringBuilder(builder, format) {\r\n    return PrintfModule_PrintFormatToStringBuilderThen(() => {\r\n    }, builder, format);\r\n}\r\n\r\n","import { compare, physicalHash, equals, structuralHash } from \"./Util.js\";\r\n\r\nexport function HashIdentity_FromFunctions(hash, eq) {\r\n    return {\r\n        Equals(x, y) {\r\n            return eq(x, y);\r\n        },\r\n        GetHashCode(x_1) {\r\n            return hash(x_1);\r\n        },\r\n    };\r\n}\r\n\r\nexport function HashIdentity_Structural() {\r\n    return HashIdentity_FromFunctions(structuralHash, equals);\r\n}\r\n\r\nexport function HashIdentity_Reference() {\r\n    return HashIdentity_FromFunctions(physicalHash, (e1, e2) => (e1 === e2));\r\n}\r\n\r\nexport function ComparisonIdentity_FromFunction(comparer) {\r\n    return {\r\n        Compare(x, y) {\r\n            return comparer(x, y);\r\n        },\r\n    };\r\n}\r\n\r\nexport function ComparisonIdentity_Structural() {\r\n    return ComparisonIdentity_FromFunction(compare);\r\n}\r\n\r\n","import { clear, equals, isArrayLike, isDisposable, toIterator, disposeSafe, getEnumerator } from \"./Util.js\";\r\nimport { toString } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { Operators_Lock, Operators_NullArg } from \"./FSharp.Core.js\";\r\nimport { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, windowed as windowed_1, splitInto as splitInto_1, map as map_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from \"./Array.js\";\r\nimport { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from \"./List.js\";\r\nimport { SR_indexOutOfBounds } from \"./Global.js\";\r\n\r\nexport const SR_enumerationAlreadyFinished = \"Enumeration already finished.\";\r\n\r\nexport const SR_enumerationNotStarted = \"Enumeration has not started. Call MoveNext.\";\r\n\r\nexport const SR_inputSequenceEmpty = \"The input sequence was empty.\";\r\n\r\nexport const SR_inputSequenceTooLong = \"The input sequence contains more than one element.\";\r\n\r\nexport const SR_keyNotFoundAlt = \"An index satisfying the predicate was not found in the collection.\";\r\n\r\nexport const SR_notEnoughElements = \"The input sequence has an insufficient number of elements.\";\r\n\r\nexport const SR_resetNotSupported = \"Reset is not supported on this enumerator.\";\r\n\r\nexport function Enumerator_noReset() {\r\n    throw (new Error(SR_resetNotSupported));\r\n}\r\n\r\nexport function Enumerator_notStarted() {\r\n    throw (new Error(SR_enumerationNotStarted));\r\n}\r\n\r\nexport function Enumerator_alreadyFinished() {\r\n    throw (new Error(SR_enumerationAlreadyFinished));\r\n}\r\n\r\nexport class Enumerator_Seq {\r\n    constructor(f) {\r\n        this.f = f;\r\n    }\r\n    toString() {\r\n        const xs = this;\r\n        const maxCount = 4;\r\n        let i = 0;\r\n        let str = \"seq [\";\r\n        const e = getEnumerator(xs);\r\n        try {\r\n            while ((i < maxCount) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                if (i > 0) {\r\n                    str = (str + \"; \");\r\n                }\r\n                str = (str + toString(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()));\r\n                i = ((i + 1) | 0);\r\n            }\r\n            if (i === maxCount) {\r\n                str = (str + \"; ...\");\r\n            }\r\n            return str + \"]\";\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n    GetEnumerator() {\r\n        const x = this;\r\n        return x.f();\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const x = this;\r\n        return x.f();\r\n    }\r\n}\r\n\r\nexport function Enumerator_Seq$reflection(gen0) {\r\n    return class_type(\"SeqModule.Enumerator.Seq\", [gen0], Enumerator_Seq);\r\n}\r\n\r\nexport function Enumerator_Seq_$ctor_673A07F2(f) {\r\n    return new Enumerator_Seq(f);\r\n}\r\n\r\nexport class Enumerator_FromFunctions$1 {\r\n    constructor(current, next, dispose) {\r\n        this.current = current;\r\n        this.next = next;\r\n        this.dispose = dispose;\r\n    }\r\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current();\r\n    }\r\n    [\"System.Collections.IEnumerator.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current();\r\n    }\r\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n        const __ = this;\r\n        return __.next();\r\n    }\r\n    [\"System.Collections.IEnumerator.Reset\"]() {\r\n        Enumerator_noReset();\r\n    }\r\n    Dispose() {\r\n        const __ = this;\r\n        __.dispose();\r\n    }\r\n}\r\n\r\nexport function Enumerator_FromFunctions$1$reflection(gen0) {\r\n    return class_type(\"SeqModule.Enumerator.FromFunctions`1\", [gen0], Enumerator_FromFunctions$1);\r\n}\r\n\r\nexport function Enumerator_FromFunctions$1_$ctor_58C54629(current, next, dispose) {\r\n    return new Enumerator_FromFunctions$1(current, next, dispose);\r\n}\r\n\r\nexport function Enumerator_cast(e) {\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e[\"System.Collections.IEnumerator.get_Current\"](), () => e[\"System.Collections.IEnumerator.MoveNext\"](), () => {\r\n        if (isDisposable(e)) {\r\n            disposeSafe(e);\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_concat(sources) {\r\n    let outerOpt = void 0;\r\n    let innerOpt = void 0;\r\n    let started = false;\r\n    let finished = false;\r\n    let curr = void 0;\r\n    const finish = () => {\r\n        finished = true;\r\n        if (innerOpt != null) {\r\n            const inner = innerOpt;\r\n            try {\r\n                disposeSafe(inner);\r\n            }\r\n            finally {\r\n                innerOpt = (void 0);\r\n            }\r\n        }\r\n        if (outerOpt != null) {\r\n            const outer = outerOpt;\r\n            try {\r\n                disposeSafe(outer);\r\n            }\r\n            finally {\r\n                outerOpt = (void 0);\r\n            }\r\n        }\r\n    };\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (!started) {\r\n            Enumerator_notStarted();\r\n        }\r\n        else if (finished) {\r\n            Enumerator_alreadyFinished();\r\n        }\r\n        if (curr != null) {\r\n            return value_1(curr);\r\n        }\r\n        else {\r\n            return Enumerator_alreadyFinished();\r\n        }\r\n    }, () => {\r\n        let copyOfStruct;\r\n        if (!started) {\r\n            started = true;\r\n        }\r\n        if (finished) {\r\n            return false;\r\n        }\r\n        else {\r\n            let res = void 0;\r\n            while (res == null) {\r\n                const matchValue = [outerOpt, innerOpt];\r\n                if (matchValue[0] != null) {\r\n                    if (matchValue[1] != null) {\r\n                        const inner_1 = matchValue[1];\r\n                        if (inner_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            curr = some(inner_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                            res = true;\r\n                        }\r\n                        else {\r\n                            try {\r\n                                disposeSafe(inner_1);\r\n                            }\r\n                            finally {\r\n                                innerOpt = (void 0);\r\n                            }\r\n                        }\r\n                    }\r\n                    else {\r\n                        const outer_1 = matchValue[0];\r\n                        if (outer_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            const ie = outer_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                            innerOpt = ((copyOfStruct = ie, getEnumerator(copyOfStruct)));\r\n                        }\r\n                        else {\r\n                            finish();\r\n                            res = false;\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    outerOpt = getEnumerator(sources);\r\n                }\r\n            }\r\n            return value_1(res);\r\n        }\r\n    }, () => {\r\n        if (!finished) {\r\n            finish();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_enumerateThenFinally(f, e) {\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), () => e[\"System.Collections.IEnumerator.MoveNext\"](), () => {\r\n        try {\r\n            disposeSafe(e);\r\n        }\r\n        finally {\r\n            f();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_generateWhileSome(openf, compute, closef) {\r\n    let started = false;\r\n    let curr = void 0;\r\n    let state = some(openf());\r\n    const dispose = () => {\r\n        if (state != null) {\r\n            const x_1 = value_1(state);\r\n            try {\r\n                closef(x_1);\r\n            }\r\n            finally {\r\n                state = (void 0);\r\n            }\r\n        }\r\n    };\r\n    const finish = () => {\r\n        try {\r\n            dispose();\r\n        }\r\n        finally {\r\n            curr = (void 0);\r\n        }\r\n    };\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (!started) {\r\n            Enumerator_notStarted();\r\n        }\r\n        if (curr != null) {\r\n            return value_1(curr);\r\n        }\r\n        else {\r\n            return Enumerator_alreadyFinished();\r\n        }\r\n    }, () => {\r\n        if (!started) {\r\n            started = true;\r\n        }\r\n        if (state != null) {\r\n            const s = value_1(state);\r\n            let matchValue_1;\r\n            try {\r\n                matchValue_1 = compute(s);\r\n            }\r\n            catch (matchValue) {\r\n                finish();\r\n                throw matchValue;\r\n            }\r\n            if (matchValue_1 != null) {\r\n                curr = matchValue_1;\r\n                return true;\r\n            }\r\n            else {\r\n                finish();\r\n                return false;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, dispose);\r\n}\r\n\r\nexport function Enumerator_unfold(f, state) {\r\n    let curr = void 0;\r\n    let acc = state;\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (curr != null) {\r\n            const x = curr[0];\r\n            const st = curr[1];\r\n            return x;\r\n        }\r\n        else {\r\n            return Enumerator_notStarted();\r\n        }\r\n    }, () => {\r\n        curr = f(acc);\r\n        if (curr != null) {\r\n            const x_1 = curr[0];\r\n            const st_1 = curr[1];\r\n            acc = st_1;\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, () => {\r\n    });\r\n}\r\n\r\nexport function indexNotFound() {\r\n    throw (new Error(SR_keyNotFoundAlt));\r\n}\r\n\r\nexport function checkNonNull(argName, arg) {\r\n    if (arg == null) {\r\n        Operators_NullArg(argName);\r\n    }\r\n}\r\n\r\nexport function mkSeq(f) {\r\n    return Enumerator_Seq_$ctor_673A07F2(f);\r\n}\r\n\r\nexport function ofSeq(xs) {\r\n    checkNonNull(\"source\", xs);\r\n    return getEnumerator(xs);\r\n}\r\n\r\nexport function delay(generator) {\r\n    return mkSeq(() => getEnumerator(generator()));\r\n}\r\n\r\nexport function concat(sources) {\r\n    return mkSeq(() => Enumerator_concat(sources));\r\n}\r\n\r\nexport function unfold(generator, state) {\r\n    return mkSeq(() => Enumerator_unfold(generator, state));\r\n}\r\n\r\nexport function empty() {\r\n    return delay(() => (new Array(0)));\r\n}\r\n\r\nexport function singleton(x) {\r\n    return delay(() => singleton_1(x));\r\n}\r\n\r\nexport function ofArray(arr) {\r\n    return arr;\r\n}\r\n\r\nexport function toArray(xs) {\r\n    if (xs instanceof FSharpList) {\r\n        return toArray_1(xs);\r\n    }\r\n    else {\r\n        return Array.from(xs);\r\n    }\r\n}\r\n\r\nexport function ofList(xs) {\r\n    return xs;\r\n}\r\n\r\nexport function toList(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return ofArray_1(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return xs;\r\n    }\r\n    else {\r\n        return ofSeq_1(xs);\r\n    }\r\n}\r\n\r\nexport function generate(create, compute, dispose) {\r\n    return mkSeq(() => Enumerator_generateWhileSome(create, compute, dispose));\r\n}\r\n\r\nexport function generateIndexed(create, compute, dispose) {\r\n    return mkSeq(() => {\r\n        let i = -1;\r\n        return Enumerator_generateWhileSome(create, (x) => {\r\n            i = ((i + 1) | 0);\r\n            return compute(i, x);\r\n        }, dispose);\r\n    });\r\n}\r\n\r\nexport function append(xs, ys) {\r\n    return concat([xs, ys]);\r\n}\r\n\r\nexport function cast(xs) {\r\n    return mkSeq(() => {\r\n        checkNonNull(\"source\", xs);\r\n        return Enumerator_cast(getEnumerator(xs));\r\n    });\r\n}\r\n\r\nexport function choose(chooser, xs) {\r\n    return generate(() => ofSeq(xs), (e) => {\r\n        let curr = void 0;\r\n        while ((curr == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            curr = chooser(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return curr;\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function compareWith(comparer, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let c = 0;\r\n            let b1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n            let b2 = e2[\"System.Collections.IEnumerator.MoveNext\"]();\r\n            while (((c === 0) && b1) && b2) {\r\n                c = (comparer(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) | 0);\r\n                if (c === 0) {\r\n                    b1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                    b2 = e2[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                }\r\n            }\r\n            return ((c !== 0) ? c : (b1 ? 1 : (b2 ? -1 : 0))) | 0;\r\n        }\r\n        finally {\r\n            disposeSafe(e2);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e1);\r\n    }\r\n}\r\n\r\nexport function contains(value, xs, comparer) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let found = false;\r\n        while ((!found) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            found = comparer.Equals(value, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return found;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function enumerateFromFunctions(create, moveNext, current) {\r\n    return generate(create, (x) => (moveNext(x) ? some(current(x)) : (void 0)), (x_1) => {\r\n        const matchValue = x_1;\r\n        if (isDisposable(matchValue)) {\r\n            disposeSafe(matchValue);\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateThenFinally(source, compensation) {\r\n    const compensation_1 = compensation;\r\n    return mkSeq(() => {\r\n        try {\r\n            return Enumerator_enumerateThenFinally(compensation_1, ofSeq(source));\r\n        }\r\n        catch (matchValue) {\r\n            compensation_1();\r\n            throw matchValue;\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateUsing(resource, source) {\r\n    const compensation = () => {\r\n        if (equals(resource, null)) {\r\n        }\r\n        else {\r\n            let copyOfStruct = resource;\r\n            disposeSafe(copyOfStruct);\r\n        }\r\n    };\r\n    return mkSeq(() => {\r\n        try {\r\n            return Enumerator_enumerateThenFinally(compensation, (ofSeq)(source(resource)));\r\n        }\r\n        catch (matchValue_1) {\r\n            compensation();\r\n            throw matchValue_1;\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateWhile(guard, xs) {\r\n    return concat(unfold((i) => (guard() ? [xs, i + 1] : (void 0)), 0));\r\n}\r\n\r\nexport function filter(f, xs) {\r\n    return choose((x) => {\r\n        if (f(x)) {\r\n            return some(x);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, xs);\r\n}\r\n\r\nexport function exists(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let found = false;\r\n        while ((!found) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            found = predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return found;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function exists2(predicate, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let found = false;\r\n            while (((!found) && e1[\"System.Collections.IEnumerator.MoveNext\"]()) && e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                found = predicate(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            return found;\r\n        }\r\n        finally {\r\n            disposeSafe(e2);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e1);\r\n    }\r\n}\r\n\r\nexport function exactlyOne(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const v = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                throw (new Error((SR_inputSequenceTooLong + \"\\\\nParameter name: \") + \"source\"));\r\n            }\r\n            else {\r\n                return v;\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const v = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? (void 0) : some(v);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function tryFind(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let res = void 0;\r\n        while ((res == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const c = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            if (predicate(c)) {\r\n                res = some(c);\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function find(predicate, xs) {\r\n    const matchValue = tryFind(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindBack(predicate, xs) {\r\n    return tryFindBack_1(predicate, toArray(xs));\r\n}\r\n\r\nexport function findBack(predicate, xs) {\r\n    const matchValue = tryFindBack(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (i_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const i = i_mut;\r\n                if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    if (predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) {\r\n                        return i;\r\n                    }\r\n                    else {\r\n                        i_mut = (i + 1);\r\n                        continue loop;\r\n                    }\r\n                }\r\n                else {\r\n                    return void 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(0);\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function findIndex(predicate, xs) {\r\n    const matchValue = tryFindIndex(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound() | 0;\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndexBack(predicate, xs) {\r\n    return tryFindIndexBack_1(predicate, toArray(xs));\r\n}\r\n\r\nexport function findIndexBack(predicate, xs) {\r\n    const matchValue = tryFindIndexBack(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound() | 0;\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function fold(folder, state, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let acc = state;\r\n        while (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            acc = folder(acc, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return acc;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function foldBack(folder, xs, state) {\r\n    return foldBack_1(folder, toArray(xs), state);\r\n}\r\n\r\nexport function fold2(folder, state, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let acc = state;\r\n            while (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                acc = folder(acc, e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            return acc;\r\n        }\r\n        finally {\r\n            disposeSafe(e2);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e1);\r\n    }\r\n}\r\n\r\nexport function foldBack2(folder, xs, ys, state) {\r\n    return foldBack2_1(folder, toArray(xs), toArray(ys), state);\r\n}\r\n\r\nexport function forAll(predicate, xs) {\r\n    return !exists((x) => (!predicate(x)), xs);\r\n}\r\n\r\nexport function forAll2(predicate, xs, ys) {\r\n    return !exists2((x, y) => (!predicate(x, y)), xs, ys);\r\n}\r\n\r\nexport function tryHead(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return tryHead_1(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return tryHead_2(xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function head(xs) {\r\n    const matchValue = tryHead(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function initialize(count, f) {\r\n    return unfold((i) => ((i < count) ? [f(i), i + 1] : (void 0)), 0);\r\n}\r\n\r\nexport function initializeInfinite(f) {\r\n    return initialize(2147483647, f);\r\n}\r\n\r\nexport function isEmpty(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return xs.length === 0;\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return isEmpty_1(xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            return !e[\"System.Collections.IEnumerator.MoveNext\"]();\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function tryItem(index, xs) {\r\n    if (isArrayLike(xs)) {\r\n        return tryItem_1(index, xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return tryItem_2(index, xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            const loop = (index_1_mut) => {\r\n                loop:\r\n                while (true) {\r\n                    const index_1 = index_1_mut;\r\n                    if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        return void 0;\r\n                    }\r\n                    else if (index_1 === 0) {\r\n                        return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                    }\r\n                    else {\r\n                        index_1_mut = (index_1 - 1);\r\n                        continue loop;\r\n                    }\r\n                    break;\r\n                }\r\n            };\r\n            return loop(index);\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function item(index, xs) {\r\n    const matchValue = tryItem(index, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function iterate(action, xs) {\r\n    fold((unitVar0, x) => {\r\n        action(x);\r\n    }, void 0, xs);\r\n}\r\n\r\nexport function iterate2(action, xs, ys) {\r\n    fold2((unitVar0, x, y) => {\r\n        action(x, y);\r\n    }, void 0, xs, ys);\r\n}\r\n\r\nexport function iterateIndexed(action, xs) {\r\n    fold((i, x) => {\r\n        action(i, x);\r\n        return (i + 1) | 0;\r\n    }, 0, xs);\r\n}\r\n\r\nexport function iterateIndexed2(action, xs, ys) {\r\n    fold2((i, x, y) => {\r\n        action(i, x, y);\r\n        return (i + 1) | 0;\r\n    }, 0, xs, ys);\r\n}\r\n\r\nexport function tryLast(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (acc_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const acc = acc_mut;\r\n                if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    return acc;\r\n                }\r\n                else {\r\n                    acc_mut = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                    continue loop;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(loop(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function last(xs) {\r\n    const matchValue = tryLast(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function length(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return xs.length | 0;\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return length_1(xs) | 0;\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            let count = 0;\r\n            while (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                count = ((count + 1) | 0);\r\n            }\r\n            return count | 0;\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function map(mapping, xs) {\r\n    return generate(() => ofSeq(xs), (e) => (e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(mapping(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function mapIndexed(mapping, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => (e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(mapping(i, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function indexed(xs) {\r\n    return mapIndexed((i, x) => [i, x], xs);\r\n}\r\n\r\nexport function map2(mapping, xs, ys) {\r\n    return generate(() => [ofSeq(xs), ofSeq(ys)], (tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        return (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            disposeSafe(tupledArg_1[0]);\r\n        }\r\n        finally {\r\n            disposeSafe(tupledArg_1[1]);\r\n        }\r\n    });\r\n}\r\n\r\nexport function mapIndexed2(mapping, xs, ys) {\r\n    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        return (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(i, e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            disposeSafe(tupledArg_1[0]);\r\n        }\r\n        finally {\r\n            disposeSafe(tupledArg_1[1]);\r\n        }\r\n    });\r\n}\r\n\r\nexport function map3(mapping, xs, ys, zs) {\r\n    return generate(() => [ofSeq(xs), ofSeq(ys), ofSeq(zs)], (tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        const e3 = tupledArg[2];\r\n        return ((e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) && e3[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e3[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            disposeSafe(tupledArg_1[0]);\r\n        }\r\n        finally {\r\n            try {\r\n                disposeSafe(tupledArg_1[1]);\r\n            }\r\n            finally {\r\n                disposeSafe(tupledArg_1[2]);\r\n            }\r\n        }\r\n    });\r\n}\r\n\r\nexport function readOnly(xs) {\r\n    checkNonNull(\"source\", xs);\r\n    return map((x) => x, xs);\r\n}\r\n\r\nexport class CachedSeq$1 {\r\n    constructor(cleanup, res) {\r\n        this.cleanup = cleanup;\r\n        this.res = res;\r\n    }\r\n    Dispose() {\r\n        const _ = this;\r\n        _.cleanup();\r\n    }\r\n    GetEnumerator() {\r\n        const _ = this;\r\n        return getEnumerator(_.res);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const _ = this;\r\n        return getEnumerator(_.res);\r\n    }\r\n}\r\n\r\nexport function CachedSeq$1$reflection(gen0) {\r\n    return class_type(\"SeqModule.CachedSeq`1\", [gen0], CachedSeq$1);\r\n}\r\n\r\nexport function CachedSeq$1_$ctor_Z7A8347D4(cleanup, res) {\r\n    return new CachedSeq$1(cleanup, res);\r\n}\r\n\r\nexport function CachedSeq$1__Clear(_) {\r\n    _.cleanup();\r\n}\r\n\r\nexport function cache(source) {\r\n    checkNonNull(\"source\", source);\r\n    const prefix = [];\r\n    let enumeratorR = void 0;\r\n    return CachedSeq$1_$ctor_Z7A8347D4(() => {\r\n        Operators_Lock(prefix, () => {\r\n            clear(prefix);\r\n            let pattern_matching_result, e;\r\n            if (enumeratorR != null) {\r\n                if (value_1(enumeratorR) != null) {\r\n                    pattern_matching_result = 0;\r\n                    e = value_1(enumeratorR);\r\n                }\r\n                else {\r\n                    pattern_matching_result = 1;\r\n                }\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n            switch (pattern_matching_result) {\r\n                case 0: {\r\n                    disposeSafe(e);\r\n                    break;\r\n                }\r\n            }\r\n            enumeratorR = (void 0);\r\n        });\r\n    }, unfold((i_1) => Operators_Lock(prefix, () => {\r\n        if (i_1 < prefix.length) {\r\n            return [prefix[i_1], i_1 + 1];\r\n        }\r\n        else {\r\n            if (i_1 >= prefix.length) {\r\n                let optEnumerator_2;\r\n                if (enumeratorR != null) {\r\n                    optEnumerator_2 = value_1(enumeratorR);\r\n                }\r\n                else {\r\n                    const optEnumerator = getEnumerator(source);\r\n                    enumeratorR = some(optEnumerator);\r\n                    optEnumerator_2 = optEnumerator;\r\n                }\r\n                if (optEnumerator_2 == null) {\r\n                }\r\n                else {\r\n                    const enumerator = optEnumerator_2;\r\n                    if (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        void (prefix.push(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()));\r\n                    }\r\n                    else {\r\n                        disposeSafe(enumerator);\r\n                        enumeratorR = some(void 0);\r\n                    }\r\n                }\r\n            }\r\n            return (i_1 < prefix.length) ? [prefix[i_1], i_1 + 1] : (void 0);\r\n        }\r\n    }), 0));\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const ysCache = cache(ys);\r\n    return delay(() => concat(map((x) => map((y) => [x, y], ysCache), xs)));\r\n}\r\n\r\nexport function mapFold(mapping, state, xs) {\r\n    const patternInput = mapFold_1(mapping, state, toArray(xs));\r\n    return [readOnly(patternInput[0]), patternInput[1]];\r\n}\r\n\r\nexport function mapFoldBack(mapping, xs, state) {\r\n    const patternInput = mapFoldBack_1(mapping, toArray(xs), state);\r\n    return [readOnly(patternInput[0]), patternInput[1]];\r\n}\r\n\r\nexport function tryPick(chooser, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let res = void 0;\r\n        while ((res == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            res = chooser(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return res;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function pick(chooser, xs) {\r\n    const matchValue = tryPick(chooser, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function reduce(folder, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (acc_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const acc = acc_mut;\r\n                if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    acc_mut = folder(acc, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return acc;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return loop(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else {\r\n            throw (new Error(SR_inputSequenceEmpty));\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function reduceBack(folder, xs) {\r\n    const arr = toArray(xs);\r\n    if (arr.length > 0) {\r\n        return arr.reduceRight(folder);\r\n    }\r\n    else {\r\n        throw (new Error(SR_inputSequenceEmpty));\r\n    }\r\n}\r\n\r\nexport function replicate(n, x) {\r\n    return initialize(n, (_arg1) => x);\r\n}\r\n\r\nexport function reverse(xs) {\r\n    return delay(() => ofArray(reverse_1(toArray(xs))));\r\n}\r\n\r\nexport function scan(folder, state, xs) {\r\n    return delay(() => {\r\n        let acc = state;\r\n        return concat([singleton(state), map((x) => {\r\n            acc = folder(acc, x);\r\n            return acc;\r\n        }, xs)]);\r\n    });\r\n}\r\n\r\nexport function scanBack(folder, xs, state) {\r\n    return delay(() => ofArray(scanBack_1(folder, toArray(xs), state)));\r\n}\r\n\r\nexport function skip(count, source) {\r\n    return mkSeq(() => {\r\n        const e = ofSeq(source);\r\n        try {\r\n            for (let _ = 1; _ <= count; _++) {\r\n                if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n                }\r\n            }\r\n            return Enumerator_enumerateThenFinally(() => {\r\n            }, e);\r\n        }\r\n        catch (matchValue) {\r\n            disposeSafe(e);\r\n            throw matchValue;\r\n        }\r\n    });\r\n}\r\n\r\nexport function skipWhile(predicate, xs) {\r\n    return delay(() => {\r\n        let skipped = true;\r\n        return filter((x) => {\r\n            if (skipped) {\r\n                skipped = predicate(x);\r\n            }\r\n            return !skipped;\r\n        }, xs);\r\n    });\r\n}\r\n\r\nexport function tail(xs) {\r\n    return skip(1, xs);\r\n}\r\n\r\nexport function take(count, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if (i < count) {\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function takeWhile(predicate, xs) {\r\n    return generate(() => ofSeq(xs), (e) => ((e[\"System.Collections.IEnumerator.MoveNext\"]() && predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function truncate(count, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => (((i < count) && e[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function zip(xs, ys) {\r\n    return map2((x, y) => [x, y], xs, ys);\r\n}\r\n\r\nexport function zip3(xs, ys, zs) {\r\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\r\n}\r\n\r\nexport function collect(mapping, xs) {\r\n    return delay(() => concat(map(mapping, xs)));\r\n}\r\n\r\nexport function where(predicate, xs) {\r\n    return filter(predicate, xs);\r\n}\r\n\r\nexport function pairwise(xs) {\r\n    return delay(() => ofArray(pairwise_1(toArray(xs))));\r\n}\r\n\r\nexport function splitInto(chunks, xs) {\r\n    return delay(() => ofArray(map_1(ofArray, splitInto_1(chunks, toArray(xs)))));\r\n}\r\n\r\nexport function windowed(windowSize, xs) {\r\n    return delay(() => ofArray(map_1(ofArray, windowed_1(windowSize, toArray(xs)))));\r\n}\r\n\r\nexport function transpose(xss) {\r\n    return delay(() => ofArray(map_1(ofArray, transpose_1(map_1(toArray, toArray(xss))))));\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    return delay(() => {\r\n        const arr = toArray(xs);\r\n        arr.sort(comparer);\r\n        return ofArray(arr);\r\n    });\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(x, y), xs);\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);\r\n}\r\n\r\nexport function sum(xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\r\n}\r\n\r\nexport function sumBy(f, xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, x);\r\n    }, averager.GetZero(), xs);\r\n    if (count === 0) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return averager.DivideByInt(total, count);\r\n    }\r\n}\r\n\r\nexport function averageBy(f, xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, f(x));\r\n    }, averager.GetZero(), xs);\r\n    if (count === 0) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return averager.DivideByInt(total, count);\r\n    }\r\n}\r\n\r\nexport function permute(f, xs) {\r\n    return delay(() => ofArray(permute_1(f, toArray(xs))));\r\n}\r\n\r\nexport function chunkBySize(chunkSize, xs) {\r\n    return delay(() => ofArray(map_1(ofArray, chunkBySize_1(chunkSize, toArray(xs)))));\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if (i === index) {\r\n            isDone = true;\r\n            return some(y);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    let status = -1;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        if (i === index) {\r\n            status = 0;\r\n        }\r\n        let inserted;\r\n        if (status === 0) {\r\n            if (e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                inserted = some(e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                status = 1;\r\n                inserted = (void 0);\r\n            }\r\n        }\r\n        else {\r\n            inserted = (void 0);\r\n        }\r\n        if (inserted == null) {\r\n            if (e1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                if (status < 1) {\r\n                    throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n                }\r\n                return void 0;\r\n            }\r\n        }\r\n        else {\r\n            return some(value_1(inserted));\r\n        }\r\n    }, (tupledArg_1) => {\r\n        disposeSafe(tupledArg_1[0]);\r\n        disposeSafe(tupledArg_1[1]);\r\n    });\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if ((i === index) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            isDone = true;\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if (i < index) {\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n        }\r\n        else {\r\n            if (i === index) {\r\n                for (let _ = 1; _ <= count; _++) {\r\n                    if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"count\"));\r\n                    }\r\n                }\r\n            }\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if ((i === index) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            isDone = true;\r\n            return some(y);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\n","import { disposeSafe, equals, toIterator, getEnumerator } from \"./Util.js\";\r\nimport { iterate, map, delay, toArray, iterateIndexed, concat } from \"./Seq.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\r\nimport { format } from \"./String.js\";\r\n\r\nexport class Dictionary {\r\n    constructor(pairs, comparer) {\r\n        const this$ = new FSharpRef(null);\r\n        this.comparer = comparer;\r\n        this$.contents = this;\r\n        this.hashMap = (new Map([]));\r\n        this[\"init@8-1\"] = 1;\r\n        const enumerator = getEnumerator(pairs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const pair = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                Dictionary__Add_5BDDA1(this$.contents, pair[0], pair[1]);\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"Dictionary\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const this$ = this;\r\n        return getEnumerator(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const this$ = this;\r\n        return getEnumerator(concat(this$.hashMap.values()));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\r\n        const this$ = this;\r\n        Dictionary__Add_5BDDA1(this$, item[0], item[1]);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        const this$ = this;\r\n        Dictionary__Clear(this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\r\n        let pattern_matching_result;\r\n        if (matchValue != null) {\r\n            if (equals(matchValue[1], item[1])) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return true;\r\n            }\r\n            case 1: {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\r\n        const this$ = this;\r\n        iterateIndexed((i, e) => {\r\n            array[arrayIndex + i] = e;\r\n        }, this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const this$ = this;\r\n        return Dictionary__get_Count(this$) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return false;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\r\n        if (matchValue != null) {\r\n            if (equals(matchValue[1], item[1])) {\r\n                Dictionary__Remove_2B595(this$, item[0]);\r\n            }\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.Add5BDDA1\"](key, value) {\r\n        const this$ = this;\r\n        Dictionary__Add_5BDDA1(this$, key, value);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.ContainsKey2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__ContainsKey_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Item2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__get_Item_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.set_Item5BDDA1\"](key, v) {\r\n        const this$ = this;\r\n        Dictionary__set_Item_5BDDA1(this$, key, v);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Keys\"]() {\r\n        const this$ = this;\r\n        return toArray(delay(() => map((pair) => pair[0], this$)));\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.Remove2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__Remove_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.TryGetValue23A0B95A\"](key, value) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, key);\r\n        if (matchValue != null) {\r\n            const pair = matchValue;\r\n            value.contents = pair[1];\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Values\"]() {\r\n        const this$ = this;\r\n        return toArray(delay(() => map((pair) => pair[1], this$)));\r\n    }\r\n    get size() {\r\n        const this$ = this;\r\n        return Dictionary__get_Count(this$) | 0;\r\n    }\r\n    clear() {\r\n        const this$ = this;\r\n        Dictionary__Clear(this$);\r\n    }\r\n    delete(k) {\r\n        const this$ = this;\r\n        return Dictionary__Remove_2B595(this$, k);\r\n    }\r\n    entries() {\r\n        const this$ = this;\r\n        return map((p) => [p[0], p[1]], this$);\r\n    }\r\n    get(k) {\r\n        const this$ = this;\r\n        return Dictionary__get_Item_2B595(this$, k);\r\n    }\r\n    has(k) {\r\n        const this$ = this;\r\n        return Dictionary__ContainsKey_2B595(this$, k);\r\n    }\r\n    keys() {\r\n        const this$ = this;\r\n        return map((p) => p[0], this$);\r\n    }\r\n    set(k, v) {\r\n        const this$ = this;\r\n        Dictionary__set_Item_5BDDA1(this$, k, v);\r\n        return this$;\r\n    }\r\n    values() {\r\n        const this$ = this;\r\n        return map((p) => p[1], this$);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const this$ = this;\r\n        iterate((p) => {\r\n            f(p[1], p[0], this$);\r\n        }, this$);\r\n    }\r\n}\r\n\r\nexport function Dictionary$reflection(gen0, gen1) {\r\n    return class_type(\"Fable.Collections.Dictionary\", [gen0, gen1], Dictionary);\r\n}\r\n\r\nexport function Dictionary_$ctor_6623D9B3(pairs, comparer) {\r\n    return new Dictionary(pairs, comparer);\r\n}\r\n\r\nfunction Dictionary__TryFindIndex_2B595(this$, k) {\r\n    const h = this$.comparer.GetHashCode(k) | 0;\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return [true, h, matchValue[1].findIndex((pair) => this$.comparer.Equals(k, pair[0]))];\r\n    }\r\n    else {\r\n        return [false, h, -1];\r\n    }\r\n}\r\n\r\nexport function Dictionary__TryFind_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__get_Comparer(this$) {\r\n    return this$.comparer;\r\n}\r\n\r\nexport function Dictionary__Clear(this$) {\r\n    this$.hashMap.clear();\r\n}\r\n\r\nexport function Dictionary__get_Count(this$) {\r\n    let count = 0;\r\n    let enumerator = getEnumerator(this$.hashMap.values());\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const pairs = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            count = ((count + pairs.length) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return count | 0;\r\n}\r\n\r\nexport function Dictionary__get_Item_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFind_2B595(this$, k);\r\n    if (matchValue != null) {\r\n        return matchValue[1];\r\n    }\r\n    else {\r\n        throw (new Error(\"The item was not found in collection\"));\r\n    }\r\n}\r\n\r\nexport function Dictionary__set_Item_5BDDA1(this$, k, v) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];\r\n            break;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [[k, v]]);\r\n            }\r\n            break;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__Add_5BDDA1(this$, k, v) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            const msg = format(\"An item with the same key has already been added. Key: {0}\", k);\r\n            throw (new Error(msg));\r\n            break;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [[k, v]]);\r\n            }\r\n            break;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__ContainsKey_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__Remove_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\n","namespace Fable.SimpleJson\r\n\r\nopen System\r\nopen FSharp.Reflection\r\nopen Fable.Core\r\nopen System.Reflection\r\nopen System.Collections.Generic\r\n\r\n[<AutoOpen>]\r\nmodule Converter =\r\n    let (|PrimitiveType|_|) (primType: Type) =\r\n        match primType.FullName with\r\n        | \"System.String\" -> Some TypeInfo.String\r\n        | \"System.Char\" -> Some TypeInfo.Char\r\n        | \"System.Int16\" -> Some TypeInfo.Short\r\n        | \"System.Int32\" -> Some TypeInfo.Int32\r\n        | \"Microsoft.FSharp.Core.int64`1\"\r\n        | \"System.Int64\" -> Some TypeInfo.Long\r\n        | \"System.UInt16\" -> Some TypeInfo.UInt16\r\n        | \"System.UInt32\" -> Some TypeInfo.UInt32\r\n        | \"System.UInt64\" -> Some TypeInfo.UInt64\r\n        | \"System.DateTime\" -> Some TypeInfo.DateTime\r\n        | \"System.DateOnly\" -> Some TypeInfo.DateOnly\r\n        | \"System.TimeOnly\" -> Some TypeInfo.TimeOnly\r\n        | \"System.TimeSpan\" -> Some TypeInfo.TimeSpan\r\n        | \"System.DateTimeOffset\" -> Some TypeInfo.DateTimeOffset\r\n        | \"System.Boolean\" -> Some  TypeInfo.Bool\r\n        | \"System.Single\" -> Some TypeInfo.Float32\r\n        | \"System.Double\" -> Some TypeInfo.Float\r\n        | \"Microsoft.FSharp.Core.decimal`1\"\r\n        | \"System.Decimal\" -> Some TypeInfo.Decimal\r\n        | \"System.Numerics.BigInteger\" -> Some TypeInfo.BigInt\r\n        | \"Microsoft.FSharp.Core.Unit\" -> Some TypeInfo.Unit\r\n        | \"System.Guid\" -> Some TypeInfo.Guid\r\n        | \"System.Byte\" -> Some TypeInfo.Byte\r\n        | \"System.SByte\" -> Some TypeInfo.SByte\r\n        | \"System.Object\" -> Some TypeInfo.Object\r\n        | \"System.Uri\" -> Some TypeInfo.Uri\r\n        | _ -> None\r\n\r\n    let (|RecordType|_|) (t: Type) =\r\n        if FSharpType.IsRecord t\r\n        then\r\n            FSharpType.GetRecordFields t\r\n            |> Array.map (fun field -> field, field.Name, field.PropertyType)\r\n            |> Some\r\n        else None\r\n\r\n    let (|SetType|_|) (t: Type) =\r\n        if t.FullName.StartsWith \"Microsoft.FSharp.Collections.FSharpSet`1\"\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|Nullable|_|) (t: Type) =\r\n        if t.FullName.StartsWith \"System.Nullable`1\"\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|UnionType|_|) (t: Type) =\r\n        if FSharpType.IsUnion t\r\n        then\r\n            FSharpType.GetUnionCases t\r\n            |> Array.map (fun info ->\r\n                let caseName = info.Name\r\n                let caseTypes = info.GetFields() |> Array.map (fun prop -> prop.PropertyType)\r\n                caseName, info, caseTypes)\r\n            |> Some\r\n        else None\r\n\r\n    let (|MapType|_|) (t: Type) =\r\n        if (t.FullName.StartsWith \"Microsoft.FSharp.Collections.FSharpMap`2\")\r\n        then\r\n            let genArgs = t.GetGenericArguments()\r\n            Some (genArgs.[0], genArgs.[1])\r\n        else None\r\n\r\n    let (|ListType|_|) (t: Type) =\r\n        if (t.FullName.StartsWith \"Microsoft.FSharp.Collections.FSharpList`1\")\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let rec flattenFuncTypes (typeDef: Type) =\r\n        [| if FSharpType.IsFunction typeDef\r\n           then let (domain, range) = FSharpType.GetFunctionElements typeDef\r\n                yield! flattenFuncTypes domain\r\n                yield! flattenFuncTypes range\r\n           else yield typeDef |]\r\n\r\n    let (|FuncType|_|) (t: Type) =\r\n        if FSharpType.IsFunction t\r\n        then flattenFuncTypes t |> Some\r\n        else None\r\n\r\n    let (|ArrayType|_|) (t:Type) =\r\n        if t.IsArray\r\n        then t.GetElementType() |> Some\r\n        else None\r\n\r\n    let (|OptionType|_|) (t:Type) =\r\n        if (t.FullName.StartsWith \"Microsoft.FSharp.Core.FSharpOption`1\")\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|TupleType|_|) (t: Type) =\r\n        if FSharpType.IsTuple t\r\n        then FSharpType.GetTupleElements(t) |> Some\r\n        else None\r\n\r\n    let (|SeqType|_|) (t: Type) =\r\n        if t.FullName.StartsWith \"System.Collections.Generic.IEnumerable`1\"\r\n        then  t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|DictionaryType|_|) (t: Type) =\r\n        if t.FullName.StartsWith \"System.Collections.Generic.Dictionary\"\r\n        then\r\n          let genArgs = t.GetGenericArguments()\r\n          Some (genArgs.[0], genArgs.[1])\r\n        else\r\n          None\r\n\r\n    let (|ResizeArrayType|_|) (t: Type) =\r\n        if t.FullName.StartsWith \"System.Collections.Generic.List\"\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|HashSetType|_|) (t: Type) =\r\n        if t.FullName.StartsWith \"System.Collections.Generic.HashSet\"\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|AsyncType|_|) (t:Type) =\r\n        if t.FullName.StartsWith \"Microsoft.FSharp.Control.FSharpAsync`1\"\r\n        then  t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let (|PromiseType|_|) (t:Type) =\r\n        if t.FullName.StartsWith \"Fable.Core.JS.Promise`1\"\r\n        then t.GetGenericArguments().[0] |> Some\r\n        else None\r\n\r\n    let private lazyToDelayed (l:Lazy<_>) = fun () -> l.Value\r\n\r\n    let (|EnumType|_|) (t: Type) =\r\n        if t.IsEnum\r\n        then Enum.GetUnderlyingType(t) |> Some\r\n        else None\r\n\r\n    let rec private _createTypeInfo (resolvedType: Type) : Fable.SimpleJson.TypeInfo =\r\n        match resolvedType with\r\n        | PrimitiveType typeInfo -> typeInfo\r\n        | FuncType (types) -> TypeInfo.Func <| lazyToDelayed (lazy (Array.map createTypeInfo types))\r\n        | RecordType fields ->\r\n            let l = lazy (\r\n                let fields =\r\n                    [| for (field, fieldName, fieldType) in fields ->\r\n                        { PropertyInfo = field\r\n                          FieldName = fieldName;\r\n                          FieldType = createTypeInfo fieldType } |]\r\n                fields, resolvedType)\r\n            TypeInfo.Record (lazyToDelayed l)\r\n\r\n        | UnionType cases ->\r\n            let l = lazy (\r\n                [| for (caseName, caseInfo, caseTypes) in cases ->\r\n                    { CaseName = caseName;\r\n                      Info = caseInfo;\r\n                      CaseTypes = Array.map createTypeInfo caseTypes } |], resolvedType)\r\n            TypeInfo.Union (lazyToDelayed l)\r\n\r\n        | EnumType elemType -> TypeInfo.Enum (lazyToDelayed <| lazy (createTypeInfo elemType, resolvedType))\r\n        | ListType elemType -> TypeInfo.List (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | ResizeArrayType elemType -> TypeInfo.ResizeArray (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | HashSetType elemType -> TypeInfo.HashSet (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | ArrayType elemType -> TypeInfo.Array (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        // Checking for tuples has to happen after checking for arrays\r\n        | TupleType types -> TypeInfo.Tuple (lazyToDelayed <| lazy (Array.map createTypeInfo types))\r\n        | OptionType elemType -> TypeInfo.Option (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | Nullable elemType -> TypeInfo.Option (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | SetType elemType -> TypeInfo.Set (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | MapType (keyType, valueType) -> TypeInfo.Map (lazyToDelayed <| lazy (createTypeInfo keyType, createTypeInfo valueType))\r\n        | DictionaryType (keyType, valueType) -> TypeInfo.Dictionary (lazyToDelayed <| lazy (createTypeInfo keyType, createTypeInfo valueType, valueType))\r\n        | SeqType elemType -> TypeInfo.Seq (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | AsyncType elemType -> TypeInfo.Async (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | PromiseType elemType -> TypeInfo.Promise (lazyToDelayed <| lazy (createTypeInfo elemType))\r\n        | _ -> TypeInfo.Any (lazyToDelayed <| lazy (resolvedType))\r\n\r\n    and private typeInfoCache = Dictionary<Type,Fable.SimpleJson.TypeInfo>()\r\n\r\n    and createTypeInfo (resolvedType: Type) : Fable.SimpleJson.TypeInfo =\r\n        match typeInfoCache.TryGetValue resolvedType with\r\n        | true, ti -> ti\r\n        | false, _ ->\r\n            let ti = _createTypeInfo resolvedType\r\n            // see https://github.com/fable-compiler/Fable/issues/1871\r\n            // Type equality doesn't work for anonymous records - all anon records are considered equal.\r\n            // For anonymous records, the name is the empty string.\r\n            let notAnonymousRecord =\r\n                not (String.IsNullOrEmpty resolvedType.FullName)\r\n                && not (resolvedType.FullName.EndsWith(\"`1[]\"))\r\n                && not (resolvedType.FullName.EndsWith(\"`2[]\"))\r\n\r\n            if notAnonymousRecord then\r\n                typeInfoCache.[resolvedType] <- ti\r\n                ti\r\n            else\r\n                ti\r\n\r\n    type Fable.SimpleJson.TypeInfo with\r\n        static member inline createFrom<'t> () : Fable.SimpleJson.TypeInfo =\r\n            createTypeInfo typeof<'t>\r\n\r\n    /// returns whether a type is primitive\r\n    let isPrimitive = function\r\n        | TypeInfo.Unit\r\n        | TypeInfo.String\r\n        | TypeInfo.UInt16\r\n        | TypeInfo.UInt32\r\n        | TypeInfo.UInt64\r\n        | TypeInfo.Int32\r\n        | TypeInfo.Bool\r\n        | TypeInfo.Float32\r\n        | TypeInfo.Float\r\n        | TypeInfo.Decimal\r\n        | TypeInfo.Short\r\n        | TypeInfo.Long\r\n        | TypeInfo.Byte\r\n        | TypeInfo.DateTime\r\n        | TypeInfo.DateTimeOffset\r\n        | TypeInfo.DateOnly\r\n        | TypeInfo.TimeOnly\r\n        | TypeInfo.BigInt\r\n        | TypeInfo.Guid\r\n        | TypeInfo.Option _ -> true\r\n        | otherwise -> false\r\n\r\n    /// returns whether the discrimiated union type is like a enum\r\n    let enumUnion = function\r\n        | TypeInfo.Union getCases ->\r\n            getCases()\r\n            |> fst\r\n            |> Array.forall (fun case -> Array.isEmpty case.CaseTypes)\r\n        | otherwise -> false\r\n","export class CancellationToken {\n    constructor(cancelled = false) {\n        this._id = 0;\n        this._cancelled = cancelled;\n        this._listeners = new Map();\n    }\n    get isCancelled() {\n        return this._cancelled;\n    }\n    cancel() {\n        if (!this._cancelled) {\n            this._cancelled = true;\n            for (const [, listener] of this._listeners) {\n                listener();\n            }\n        }\n    }\n    addListener(f) {\n        const id = this._id;\n        this._listeners.set(this._id++, f);\n        return id;\n    }\n    removeListener(id) {\n        return this._listeners.delete(id);\n    }\n    register(f, state) {\n        const $ = this;\n        const id = this.addListener(state == null ? f : () => f(state));\n        return { Dispose() { $.removeListener(id); } };\n    }\n}\nexport class OperationCanceledError extends Error {\n    constructor() {\n        super(\"The operation was canceled\");\n        Object.setPrototypeOf(this, OperationCanceledError.prototype);\n    }\n}\nexport class Trampoline {\n    constructor() {\n        this.callCount = 0;\n    }\n    static get maxTrampolineCallCount() {\n        return 2000;\n    }\n    incrementAndCheck() {\n        return this.callCount++ > Trampoline.maxTrampolineCallCount;\n    }\n    hijack(f) {\n        this.callCount = 0;\n        setTimeout(f, 0);\n    }\n}\nexport function protectedCont(f) {\n    return (ctx) => {\n        if (ctx.cancelToken.isCancelled) {\n            ctx.onCancel(new OperationCanceledError());\n        }\n        else if (ctx.trampoline.incrementAndCheck()) {\n            ctx.trampoline.hijack(() => {\n                try {\n                    f(ctx);\n                }\n                catch (err) {\n                    ctx.onError(err);\n                }\n            });\n        }\n        else {\n            try {\n                f(ctx);\n            }\n            catch (err) {\n                ctx.onError(err);\n            }\n        }\n    };\n}\nexport function protectedBind(computation, binder) {\n    return protectedCont((ctx) => {\n        computation({\n            onSuccess: (x) => {\n                try {\n                    binder(x)(ctx);\n                }\n                catch (ex) {\n                    ctx.onError(ex);\n                }\n            },\n            onError: ctx.onError,\n            onCancel: ctx.onCancel,\n            cancelToken: ctx.cancelToken,\n            trampoline: ctx.trampoline,\n        });\n    });\n}\nexport function protectedReturn(value) {\n    return protectedCont((ctx) => ctx.onSuccess(value));\n}\nexport class AsyncBuilder {\n    Bind(computation, binder) {\n        return protectedBind(computation, binder);\n    }\n    Combine(computation1, computation2) {\n        return this.Bind(computation1, () => computation2);\n    }\n    Delay(generator) {\n        return protectedCont((ctx) => generator()(ctx));\n    }\n    For(sequence, body) {\n        const iter = sequence[Symbol.iterator]();\n        let cur = iter.next();\n        return this.While(() => !cur.done, this.Delay(() => {\n            const res = body(cur.value);\n            cur = iter.next();\n            return res;\n        }));\n    }\n    Return(value) {\n        return protectedReturn(value);\n    }\n    ReturnFrom(computation) {\n        return computation;\n    }\n    TryFinally(computation, compensation) {\n        return protectedCont((ctx) => {\n            computation({\n                onSuccess: (x) => {\n                    compensation();\n                    ctx.onSuccess(x);\n                },\n                onError: (x) => {\n                    compensation();\n                    ctx.onError(x);\n                },\n                onCancel: (x) => {\n                    compensation();\n                    ctx.onCancel(x);\n                },\n                cancelToken: ctx.cancelToken,\n                trampoline: ctx.trampoline,\n            });\n        });\n    }\n    TryWith(computation, catchHandler) {\n        return protectedCont((ctx) => {\n            computation({\n                onSuccess: ctx.onSuccess,\n                onCancel: ctx.onCancel,\n                cancelToken: ctx.cancelToken,\n                trampoline: ctx.trampoline,\n                onError: (ex) => {\n                    try {\n                        catchHandler(ex)(ctx);\n                    }\n                    catch (ex2) {\n                        ctx.onError(ex2);\n                    }\n                },\n            });\n        });\n    }\n    Using(resource, binder) {\n        return this.TryFinally(binder(resource), () => resource.Dispose());\n    }\n    While(guard, computation) {\n        if (guard()) {\n            return this.Bind(computation, () => this.While(guard, computation));\n        }\n        else {\n            return this.Return(void 0);\n        }\n    }\n    Zero() {\n        return protectedCont((ctx) => ctx.onSuccess(void 0));\n    }\n}\nexport const singleton = new AsyncBuilder();\n","import { Union } from \"./Types.js\";\r\nimport { union_type } from \"./Reflection.js\";\r\nimport { some } from \"./Option.js\";\r\n\r\nexport class FSharpResult$2 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Ok\", \"Error\"];\r\n    }\r\n}\r\n\r\nexport function FSharpResult$2$reflection(gen0, gen1) {\r\n    return union_type(\"FSharp.Core.FSharpResult`2\", [gen0, gen1], FSharpResult$2, () => [[[\"ResultValue\", gen0]], [[\"ErrorValue\", gen1]]]);\r\n}\r\n\r\nexport function Result_Map(mapping, result) {\r\n    if (result.tag === 0) {\r\n        return new FSharpResult$2(0, mapping(result.fields[0]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, result.fields[0]);\r\n    }\r\n}\r\n\r\nexport function Result_MapError(mapping, result) {\r\n    if (result.tag === 0) {\r\n        return new FSharpResult$2(0, result.fields[0]);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, mapping(result.fields[0]));\r\n    }\r\n}\r\n\r\nexport function Result_Bind(binder, result) {\r\n    if (result.tag === 0) {\r\n        return binder(result.fields[0]);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, result.fields[0]);\r\n    }\r\n}\r\n\r\nexport class FSharpChoice$2 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of2\", \"Choice2Of2\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$2$reflection(gen0, gen1) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`2\", [gen0, gen1], FSharpChoice$2, () => [[[\"Item\", gen0]], [[\"Item\", gen1]]]);\r\n}\r\n\r\nexport class FSharpChoice$3 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of3\", \"Choice2Of3\", \"Choice3Of3\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$3$reflection(gen0, gen1, gen2) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`3\", [gen0, gen1, gen2], FSharpChoice$3, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]]]);\r\n}\r\n\r\nexport class FSharpChoice$4 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of4\", \"Choice2Of4\", \"Choice3Of4\", \"Choice4Of4\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$4$reflection(gen0, gen1, gen2, gen3) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`4\", [gen0, gen1, gen2, gen3], FSharpChoice$4, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]]]);\r\n}\r\n\r\nexport class FSharpChoice$5 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of5\", \"Choice2Of5\", \"Choice3Of5\", \"Choice4Of5\", \"Choice5Of5\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$5$reflection(gen0, gen1, gen2, gen3, gen4) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`5\", [gen0, gen1, gen2, gen3, gen4], FSharpChoice$5, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]]]);\r\n}\r\n\r\nexport class FSharpChoice$6 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of6\", \"Choice2Of6\", \"Choice3Of6\", \"Choice4Of6\", \"Choice5Of6\", \"Choice6Of6\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$6$reflection(gen0, gen1, gen2, gen3, gen4, gen5) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`6\", [gen0, gen1, gen2, gen3, gen4, gen5], FSharpChoice$6, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]], [[\"Item\", gen5]]]);\r\n}\r\n\r\nexport class FSharpChoice$7 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of7\", \"Choice2Of7\", \"Choice3Of7\", \"Choice4Of7\", \"Choice5Of7\", \"Choice6Of7\", \"Choice7Of7\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$7$reflection(gen0, gen1, gen2, gen3, gen4, gen5, gen6) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`7\", [gen0, gen1, gen2, gen3, gen4, gen5, gen6], FSharpChoice$7, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]], [[\"Item\", gen5]], [[\"Item\", gen6]]]);\r\n}\r\n\r\nexport function Choice_makeChoice1Of2(x) {\r\n    return new FSharpChoice$2(0, x);\r\n}\r\n\r\nexport function Choice_makeChoice2Of2(x) {\r\n    return new FSharpChoice$2(1, x);\r\n}\r\n\r\nexport function Choice_tryValueIfChoice1Of2(x) {\r\n    if (x.tag === 0) {\r\n        return some(x.fields[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function Choice_tryValueIfChoice2Of2(x) {\r\n    if (x.tag === 1) {\r\n        return some(x.fields[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\n","import { OperationCanceledError, Trampoline } from \"./AsyncBuilder.js\";\nimport { CancellationToken } from \"./AsyncBuilder.js\";\nimport { protectedCont } from \"./AsyncBuilder.js\";\nimport { protectedBind } from \"./AsyncBuilder.js\";\nimport { protectedReturn } from \"./AsyncBuilder.js\";\nimport { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from \"./Choice.js\";\nimport { TimeoutException } from \"./SystemException.js\";\n// Implemented just for type references\nexport class Async {\n}\nfunction emptyContinuation(_x) {\n    // NOP\n}\n// see AsyncBuilder.Delay\nfunction delay(generator) {\n    return protectedCont((ctx) => generator()(ctx));\n}\n// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>\nexport function makeAsync(body) {\n    return body;\n}\n// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn\nexport function invoke(computation, ctx) {\n    return computation(ctx);\n}\n// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn\nexport function callThenInvoke(ctx, result1, part2) {\n    return part2(result1)(ctx);\n}\n// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn\nexport function bind(ctx, part1, part2) {\n    return protectedBind(part1, part2)(ctx);\n}\nexport function createCancellationToken(arg) {\n    const token = new CancellationToken(typeof arg === \"boolean\" ? arg : false);\n    if (typeof arg === \"number\") {\n        setTimeout(() => { token.cancel(); }, arg);\n    }\n    return token;\n}\nexport function cancel(token) {\n    token.cancel();\n}\nexport function cancelAfter(token, ms) {\n    setTimeout(() => { token.cancel(); }, ms);\n}\nexport function isCancellationRequested(token) {\n    return token != null && token.isCancelled;\n}\nexport function throwIfCancellationRequested(token) {\n    if (token != null && token.isCancelled) {\n        throw new Error(\"Operation is cancelled\");\n    }\n}\nfunction throwAfter(millisecondsDueTime) {\n    return protectedCont((ctx) => {\n        let tokenId;\n        const timeoutId = setTimeout(() => {\n            ctx.cancelToken.removeListener(tokenId);\n            ctx.onError(new TimeoutException());\n        }, millisecondsDueTime);\n        tokenId = ctx.cancelToken.addListener(() => {\n            clearTimeout(timeoutId);\n            ctx.onCancel(new OperationCanceledError());\n        });\n    });\n}\nexport function startChild(computation, ms) {\n    if (ms) {\n        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));\n        return startChild(computationWithTimeout);\n    }\n    const promise = startAsPromise(computation);\n    // JS Promises are hot, computation has already started\n    // but we delay returning the result\n    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));\n}\nexport function awaitPromise(p) {\n    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError\n        ? conts[2] : conts[1])(err)));\n}\nexport function cancellationToken() {\n    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));\n}\nexport const defaultCancellationToken = new CancellationToken();\nexport function catchAsync(work) {\n    return protectedCont((ctx) => {\n        work({\n            onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),\n            onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),\n            onCancel: ctx.onCancel,\n            cancelToken: ctx.cancelToken,\n            trampoline: ctx.trampoline,\n        });\n    });\n}\nexport function fromContinuations(f) {\n    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));\n}\nexport function ignore(computation) {\n    return protectedBind(computation, (_x) => protectedReturn(void 0));\n}\nexport function parallel(computations) {\n    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));\n}\nfunction parallel2(a, b) {\n    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));\n}\nexport function sequential(computations) {\n    function _sequential(computations) {\n        let pr = Promise.resolve([]);\n        for (const c of computations) {\n            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));\n        }\n        return pr;\n    }\n    return delay(() => awaitPromise(_sequential(computations)));\n}\nexport function sleep(millisecondsDueTime) {\n    return protectedCont((ctx) => {\n        let tokenId;\n        const timeoutId = setTimeout(() => {\n            ctx.cancelToken.removeListener(tokenId);\n            ctx.onSuccess(void 0);\n        }, millisecondsDueTime);\n        tokenId = ctx.cancelToken.addListener(() => {\n            clearTimeout(timeoutId);\n            ctx.onCancel(new OperationCanceledError());\n        });\n    });\n}\nexport function runSynchronously() {\n    throw new Error(\"Asynchronous code cannot be run synchronously in JS\");\n}\nexport function start(computation, cancellationToken) {\n    return startWithContinuations(computation, cancellationToken);\n}\nexport function startImmediate(computation, cancellationToken) {\n    return start(computation, cancellationToken);\n}\nexport function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {\n    if (typeof continuation !== \"function\") {\n        cancelToken = continuation;\n        continuation = undefined;\n    }\n    const trampoline = new Trampoline();\n    computation({\n        onSuccess: continuation ? continuation : emptyContinuation,\n        onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,\n        onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,\n        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,\n        trampoline,\n    });\n}\nexport function startAsPromise(computation, cancellationToken) {\n    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));\n}\nexport default Async;\n","namespace Fable.Remoting.Client\r\n\r\nopen System.Threading\r\nopen Browser\r\nopen Browser.Types\r\n\r\nmodule Http =\r\n\r\n    /// Constructs default values for HttpRequest\r\n    let private defaultRequestConfig : HttpRequest = {\r\n        HttpMethod = GET\r\n        Url = \"/\"\r\n        Headers = [ ]\r\n        WithCredentials = false\r\n        RequestBody = Empty\r\n    }\r\n\r\n    /// Creates a GET request to the specified url\r\n    let get (url: string) : HttpRequest =\r\n        { defaultRequestConfig\r\n            with Url = url\r\n                 HttpMethod = GET }\r\n\r\n    /// Creates a POST request to the specified url\r\n    let post (url: string) : HttpRequest =\r\n        { defaultRequestConfig\r\n            with Url = url\r\n                 HttpMethod = POST }\r\n\r\n    /// Creates a request using the given method and url\r\n    let request method url =\r\n        { defaultRequestConfig\r\n            with Url = url\r\n                 HttpMethod = method }\r\n\r\n    /// Appends a request with headers as key-value pairs\r\n    let withHeaders headers (req: HttpRequest) = { req with Headers = headers  }\r\n\r\n    /// Sets the withCredentials option on the XHR request, useful for CORS requests\r\n    let withCredentials withCredentials (req: HttpRequest) =\r\n        { req with WithCredentials = withCredentials }\r\n\r\n    /// Appends a request with string body content\r\n    let withBody body (req: HttpRequest) = { req with RequestBody = body }\r\n\r\n    let private sendAndRead (preparation:(XMLHttpRequest -> unit) option) resultMapper (req: HttpRequest) = async {\r\n        let! token = Async.CancellationToken\r\n        let request = Async.FromContinuations <| fun (resolve, _, cancel) ->\r\n            let xhr = XMLHttpRequest.Create()\r\n\r\n            match req.HttpMethod with\r\n            | GET -> xhr.``open``(\"GET\", req.Url)\r\n            | POST -> xhr.``open``(\"POST\", req.Url)\r\n\r\n            match preparation with\r\n            | Some f ->  f xhr\r\n            | _ -> ignore()\r\n\r\n            token.Register(fun _ ->\r\n                xhr.abort()\r\n                cancel(System.OperationCanceledException(token))\r\n            ) |> ignore\r\n\r\n            // set the headers, must be after opening the request\r\n            for (key, value) in req.Headers do\r\n                xhr.setRequestHeader(key, value)\r\n\r\n            xhr.withCredentials <- req.WithCredentials\r\n\r\n            xhr.onreadystatechange <- fun _ ->\r\n                match xhr.readyState with\r\n                | ReadyState.Done when not token.IsCancellationRequested ->\r\n                    xhr |> resultMapper |> resolve\r\n                | _ -> ignore()\r\n\r\n            match req.RequestBody with\r\n            | Empty -> xhr.send()\r\n            | RequestBody.Json content -> xhr.send(content)\r\n            | Binary content -> xhr.send(InternalUtilities.toUInt8Array content)\r\n\r\n        return! request\r\n    }\r\n\r\n    /// Sends the request to the server and asynchronously returns a response\r\n    let send = sendAndRead None (fun xhr  -> { StatusCode = unbox xhr.status; ResponseBody = xhr.responseText })\r\n\r\n    /// Sends the request to the server and asynchronously returns the response as byte array\r\n    let sendAndReadBinary =\r\n        sendAndRead\r\n            (Some (fun xhr -> xhr.responseType <- \"arraybuffer\" )) // read response as byte array\r\n            (fun xhr ->\r\n                let bytes = InternalUtilities.createUInt8Array xhr.response\r\n                (bytes, xhr.status))\r\n\r\n","namespace Fable.Remoting.Client\r\n\r\nopen System\r\nopen Browser.Types\r\nopen Fable.Core\r\nopen Fable.Core.JsInterop\r\nopen System.Runtime.CompilerServices\r\n\r\n/// Utilities for working with binary data types in the browser\r\nmodule InternalUtilities =\r\n    /// Creates a new instance of a FileReader\r\n    [<Emit(\"new FileReader()\")>]\r\n    let createFileReader() : FileReader = jsNative\r\n    [<Emit(\"new Uint8Array($0)\")>]\r\n    let createUInt8Array(x: 'a) : byte[]  = jsNative\r\n    /// Creates a Blob from the given input string\r\n    [<Emit(\"new Blob([$0.buffer], { type: $1 })\")>]\r\n    let createBlobFromBytesAndMimeType (value: byte[]) (mimeType: string) : Blob = jsNative\r\n    /// Creates an object URL (also known as data url) from a Blob\r\n    [<Emit(\"window.URL.createObjectURL($0)\")>]\r\n    let createObjectUrl (blob: Blob) : string = jsNative\r\n    /// Releases an existing object URL which was previously created by calling createObjectURL(). Call this method when you've finished using an object URL to let the browser know not to keep the reference to the file any longer.\r\n    [<Emit \"URL.revokeObjectURL($0)\">]\r\n    let revokeObjectUrl (dataUrl: string) : unit = jsNative\r\n    /// Returns whether the input byte array is a typed array of type Uint8Array\r\n    [<Emit \"$0 instanceof Uint8Array\">]\r\n    let isUInt8Array (data: byte[]) : bool = jsNative\r\n    /// Creates a typed byte array of binary data if it not already typed\r\n    let toUInt8Array(data: byte[]) : byte[] =\r\n        if isUInt8Array data\r\n        then data\r\n        else createUInt8Array data\r\n\r\n[<AutoOpenAttribute>]\r\nmodule BrowserFileExtensions =\r\n\r\n    type File with\r\n\r\n        /// Asynchronously reads the File content as byte[]\r\n        member instance.ReadAsByteArray() =\r\n            Async.FromContinuations <| fun (resolve, _, _) ->\r\n                let reader = InternalUtilities.createFileReader()\r\n                reader.onload <- fun _ ->\r\n                    if reader.readyState = FileReaderState.DONE\r\n                    then resolve(InternalUtilities.createUInt8Array(reader.result))\r\n\r\n                reader.readAsArrayBuffer(instance)\r\n\r\n        /// Asynchronously reads the File content as a data url string\r\n        member instance.ReadAsDataUrl() =\r\n            Async.FromContinuations <| fun (resolve, _, _) ->\r\n                let reader = InternalUtilities.createFileReader()\r\n                reader.onload <- fun _ ->\r\n                    if reader.readyState = FileReaderState.DONE\r\n                    then resolve(unbox<string> reader.result)\r\n\r\n                reader.readAsDataURL(instance)\r\n\r\n        /// Asynchronously reads the File contents as text\r\n        member instance.ReadAsText() =\r\n            Async.FromContinuations <| fun (resolve, _, _) ->\r\n                let reader = InternalUtilities.createFileReader()\r\n                reader.onload <- fun _ ->\r\n                    if reader.readyState = FileReaderState.DONE\r\n                    then resolve(unbox<string> reader.result)\r\n\r\n                reader.readAsText(instance)\r\n\r\n[<Extension>]\r\ntype ByteArrayExtensions =\r\n    /// Saves the binary content as a file using the provided file name.\r\n    [<Extension>]\r\n    static member SaveFileAs(content: byte[], fileName: string) =\r\n\r\n        if String.IsNullOrWhiteSpace(fileName) then\r\n            ()\r\n        else\r\n        let mimeType = \"application/octet-stream\"\r\n        let binaryData = InternalUtilities.toUInt8Array content\r\n        let blob = InternalUtilities.createBlobFromBytesAndMimeType binaryData mimeType\r\n        let dataUrl = InternalUtilities.createObjectUrl blob\r\n        let anchor =  (Browser.Dom.document.createElement \"a\")\r\n        anchor?style <- \"display: none\"\r\n        anchor?href <- dataUrl\r\n        anchor?download <- fileName\r\n        anchor?rel <- \"noopener\"\r\n        anchor.click()\r\n        // clean up\r\n        anchor.remove()\r\n        // clean up the created object url because it is being kept in memory\r\n        Browser.Dom.window.setTimeout(unbox(fun () -> InternalUtilities.revokeObjectUrl(dataUrl)), 40 * 1000)\r\n        |> ignore\r\n\r\n    /// Saves the binary content as a file using the provided file name.\r\n    [<Extension>]\r\n    static member SaveFileAs(content: byte[], fileName: string, mimeType: string) =\r\n\r\n        if String.IsNullOrWhiteSpace(fileName) then\r\n            ()\r\n        else\r\n        let binaryData = InternalUtilities.toUInt8Array content\r\n        let blob = InternalUtilities.createBlobFromBytesAndMimeType binaryData mimeType\r\n        let dataUrl = InternalUtilities.createObjectUrl blob\r\n        let anchor =  Browser.Dom.document.createElement \"a\"\r\n        anchor?style <- \"display: none\"\r\n        anchor?href <- dataUrl\r\n        anchor?download <- fileName\r\n        anchor?rel <- \"noopener\"\r\n        anchor.click()\r\n        // clean up element\r\n        anchor.remove()\r\n        // clean up the created object url because it is being kept in memory\r\n        Browser.Dom.window.setTimeout(unbox(fun () -> InternalUtilities.revokeObjectUrl(dataUrl)), 40 * 1000)\r\n        |> ignore\r\n\r\n    \r\n    /// Converts the binary content into a data url by first converting it to a Blob of type \"application/octet-stream\" and reading it as a data url.\r\n    [<Extension>]\r\n    static member AsDataUrl(content: byte[]) : string =\r\n        let binaryData = InternalUtilities.toUInt8Array content\r\n        let blob = InternalUtilities.createBlobFromBytesAndMimeType binaryData \"application/octet-stream\"\r\n        let dataUrl = InternalUtilities.createObjectUrl blob\r\n        dataUrl\r\n\r\n    /// Converts the binary content into a data url by first converting it to a Blob of the provided mime-type and reading it as a data url.\r\n    [<Extension>]\r\n    static member AsDataUrl(content: byte[], mimeType:string) : string =\r\n        let binaryData = InternalUtilities.toUInt8Array content\r\n        let blob = InternalUtilities.createBlobFromBytesAndMimeType binaryData mimeType\r\n        let dataUrl = InternalUtilities.createObjectUrl blob\r\n        dataUrl","\"use strict\";\r\n\r\nexport function Parsimmon(action) {\r\n  if (!(this instanceof Parsimmon)) {\r\n    return new Parsimmon(action);\r\n  }\r\n  this._ = action;\r\n}\r\n\r\nvar _ = Parsimmon.prototype;\r\n\r\nexport function times(n, f) {\r\n  var i = 0;\r\n  for (i; i < n; i++) {\r\n    f(i);\r\n  }\r\n}\r\n\r\nexport function forEach(f, arr) {\r\n  times(arr.length, function(i) {\r\n    f(arr[i], i, arr);\r\n  });\r\n}\r\n\r\nexport function reduce(f, seed, arr) {\r\n  forEach(function(elem, i, arr) {\r\n    seed = f(seed, elem, i, arr);\r\n  }, arr);\r\n  return seed;\r\n}\r\n\r\nexport function map(f, arr) {\r\n  return reduce(\r\n    function(acc, elem, i, a) {\r\n      return acc.concat([f(elem, i, a)]);\r\n    },\r\n    [],\r\n    arr\r\n  );\r\n}\r\n\r\nexport function lshiftBuffer(input) {\r\n  var asTwoBytes = reduce(\r\n    function(a, v, i, b) {\r\n      return a.concat(\r\n        i === b.length - 1\r\n          ? Buffer.from([v, 0]).readUInt16BE(0)\r\n          : b.readUInt16BE(i)\r\n      );\r\n    },\r\n    [],\r\n    input\r\n  );\r\n  return Buffer.from(\r\n    map(function(x) {\r\n      return ((x << 1) & 0xffff) >> 8;\r\n    }, asTwoBytes)\r\n  );\r\n}\r\n\r\nfunction consumeBitsFromBuffer(n, input) {\r\n  var state = { v: 0, buf: input };\r\n  times(n, function() {\r\n    state = {\r\n      v: (state.v << 1) | bitPeekBuffer(state.buf),\r\n      buf: lshiftBuffer(state.buf)\r\n    };\r\n  });\r\n  return state;\r\n}\r\n\r\nfunction bitPeekBuffer(input) {\r\n  return input[0] >> 7;\r\n}\r\n\r\nexport function sum(numArr) {\r\n  return reduce(\r\n    function(x, y) {\r\n      return x + y;\r\n    },\r\n    0,\r\n    numArr\r\n  );\r\n}\r\n\r\nexport function find(pred, arr) {\r\n  return reduce(\r\n    function(found, elem) {\r\n      return found || (pred(elem) ? elem : found);\r\n    },\r\n    null,\r\n    arr\r\n  );\r\n}\r\n\r\nfunction bufferExists() {\r\n  return typeof Buffer !== \"undefined\";\r\n}\r\n\r\nfunction ensureBuffer() {\r\n  if (!bufferExists()) {\r\n    throw new Error(\r\n      \"Buffer global does not exist; please consider using https://github.com/feross/buffer if you are running Parsimmon in a browser.\"\r\n    );\r\n  }\r\n}\r\n\r\nfunction bitSeq(alignments) {\r\n  ensureBuffer();\r\n  var totalBits = sum(alignments);\r\n  if (totalBits % 8 !== 0) {\r\n    throw new Error(\r\n      \"The bits [\" +\r\n        alignments.join(\", \") +\r\n        \"] add up to \" +\r\n        totalBits +\r\n        \" which is not an even number of bytes; the total should be divisible by 8\"\r\n    );\r\n  }\r\n  var bytes = totalBits / 8;\r\n\r\n  var tooBigRange = find(function(x) {\r\n    return x > 48;\r\n  }, alignments);\r\n  if (tooBigRange) {\r\n    throw new Error(\r\n      tooBigRange + \" bit range requested exceeds 48 bit (6 byte) Number max.\"\r\n    );\r\n  }\r\n\r\n  return new Parsimmon(function(input, i) {\r\n    var newPos = bytes + i;\r\n    if (newPos > input.length) {\r\n      return makeFailure(i, bytes.toString() + \" bytes\");\r\n    }\r\n    return makeSuccess(\r\n      newPos,\r\n      reduce(\r\n        function(acc, bits) {\r\n          var state = consumeBitsFromBuffer(bits, acc.buf);\r\n          return {\r\n            coll: acc.coll.concat(state.v),\r\n            buf: state.buf\r\n          };\r\n        },\r\n        { coll: [], buf: input.slice(i, newPos) },\r\n        alignments\r\n      ).coll\r\n    );\r\n  });\r\n}\r\n\r\nfunction bitSeqObj(namedAlignments) {\r\n  ensureBuffer();\r\n  var seenKeys = {};\r\n  var totalKeys = 0;\r\n  var fullAlignments = map(function(item) {\r\n    if (isArray(item)) {\r\n      var pair = item;\r\n      if (pair.length !== 2) {\r\n        throw new Error(\r\n          \"[\" +\r\n            pair.join(\", \") +\r\n            \"] should be length 2, got length \" +\r\n            pair.length\r\n        );\r\n      }\r\n      assertString(pair[0]);\r\n      assertNumber(pair[1]);\r\n      if (Object.prototype.hasOwnProperty.call(seenKeys, pair[0])) {\r\n        throw new Error(\"duplicate key in bitSeqObj: \" + pair[0]);\r\n      }\r\n      seenKeys[pair[0]] = true;\r\n      totalKeys++;\r\n      return pair;\r\n    } else {\r\n      assertNumber(item);\r\n      return [null, item];\r\n    }\r\n  }, namedAlignments);\r\n  if (totalKeys < 1) {\r\n    throw new Error(\r\n      \"bitSeqObj expects at least one named pair, got [\" +\r\n        namedAlignments.join(\", \") +\r\n        \"]\"\r\n    );\r\n  }\r\n  var namesOnly = map(function(pair) {\r\n    return pair[0];\r\n  }, fullAlignments);\r\n  var alignmentsOnly = map(function(pair) {\r\n    return pair[1];\r\n  }, fullAlignments);\r\n\r\n  return bitSeq(alignmentsOnly).map(function(parsed) {\r\n    var namedParsed = map(function(name, i) {\r\n      return [name, parsed[i]];\r\n    }, namesOnly);\r\n\r\n    return reduce(\r\n      function(obj, kv) {\r\n        if (kv[0] !== null) {\r\n          obj[kv[0]] = kv[1];\r\n        }\r\n        return obj;\r\n      },\r\n      {},\r\n      namedParsed\r\n    );\r\n  });\r\n}\r\n\r\nfunction parseBufferFor(other, length) {\r\n  ensureBuffer();\r\n  return new Parsimmon(function(input, i) {\r\n    if (i + length > input.length) {\r\n      return makeFailure(i, length + \" bytes for \" + other);\r\n    }\r\n    return makeSuccess(i + length, input.slice(i, i + length));\r\n  });\r\n}\r\n\r\nfunction parseBuffer(length) {\r\n  return parseBufferFor(\"buffer\", length).map(function(unsafe) {\r\n    return Buffer.from(unsafe);\r\n  });\r\n}\r\n\r\nfunction encodedString(encoding, length) {\r\n  return parseBufferFor(\"string\", length).map(function(buff) {\r\n    return buff.toString(encoding);\r\n  });\r\n}\r\n\r\nfunction isInteger(value) {\r\n  return typeof value === \"number\" && Math.floor(value) === value;\r\n}\r\n\r\nfunction assertValidIntegerByteLengthFor(who, length) {\r\n  if (!isInteger(length) || length < 0 || length > 6) {\r\n    throw new Error(who + \" requires integer length in range [0, 6].\");\r\n  }\r\n}\r\n\r\nfunction uintBE(length) {\r\n  assertValidIntegerByteLengthFor(\"uintBE\", length);\r\n  return parseBufferFor(\"uintBE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readUIntBE(0, length);\r\n  });\r\n}\r\n\r\nfunction uintLE(length) {\r\n  assertValidIntegerByteLengthFor(\"uintLE\", length);\r\n  return parseBufferFor(\"uintLE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readUIntLE(0, length);\r\n  });\r\n}\r\n\r\nfunction intBE(length) {\r\n  assertValidIntegerByteLengthFor(\"intBE\", length);\r\n  return parseBufferFor(\"intBE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readIntBE(0, length);\r\n  });\r\n}\r\n\r\nfunction intLE(length) {\r\n  assertValidIntegerByteLengthFor(\"intLE\", length);\r\n  return parseBufferFor(\"intLE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readIntLE(0, length);\r\n  });\r\n}\r\n\r\nfunction floatBE() {\r\n  return parseBufferFor(\"floatBE\", 4).map(function(buff) {\r\n    return buff.readFloatBE(0);\r\n  });\r\n}\r\n\r\nfunction floatLE() {\r\n  return parseBufferFor(\"floatLE\", 4).map(function(buff) {\r\n    return buff.readFloatLE(0);\r\n  });\r\n}\r\n\r\nfunction doubleBE() {\r\n  return parseBufferFor(\"doubleBE\", 8).map(function(buff) {\r\n    return buff.readDoubleBE(0);\r\n  });\r\n}\r\n\r\nfunction doubleLE() {\r\n  return parseBufferFor(\"doubleLE\", 8).map(function(buff) {\r\n    return buff.readDoubleLE(0);\r\n  });\r\n}\r\n\r\nfunction toArray(arrLike) {\r\n  return Array.prototype.slice.call(arrLike);\r\n}\r\n// -*- Helpers -*-\r\n\r\nfunction isParser(obj) {\r\n  return obj instanceof Parsimmon;\r\n}\r\n\r\nfunction isArray(x) {\r\n  return {}.toString.call(x) === \"[object Array]\";\r\n}\r\n\r\nfunction isBuffer(x) {\r\n  /* global Buffer */\r\n  return bufferExists() && Buffer.isBuffer(x);\r\n}\r\n\r\nexport function makeSuccess(index, value) {\r\n  return {\r\n    status: true,\r\n    index: index,\r\n    value: value,\r\n    furthest: -1,\r\n    expected: []\r\n  };\r\n}\r\n\r\nexport function makeFailure(index, expected) {\r\n  if (!isArray(expected)) {\r\n    expected = [expected];\r\n  }\r\n  return {\r\n    status: false,\r\n    index: -1,\r\n    value: null,\r\n    furthest: index,\r\n    expected: expected\r\n  };\r\n}\r\n\r\nfunction mergeReplies(result, last) {\r\n  if (!last) {\r\n    return result;\r\n  }\r\n  if (result.furthest > last.furthest) {\r\n    return result;\r\n  }\r\n  var expected =\r\n    result.furthest === last.furthest\r\n      ? union(result.expected, last.expected)\r\n      : last.expected;\r\n  return {\r\n    status: result.status,\r\n    index: result.index,\r\n    value: result.value,\r\n    furthest: last.furthest,\r\n    expected: expected\r\n  };\r\n}\r\n\r\nfunction makeLineColumnIndex(input, i) {\r\n  if (isBuffer(input)) {\r\n    return {\r\n      offset: i,\r\n      line: -1,\r\n      column: -1\r\n    };\r\n  }\r\n  var lines = input.slice(0, i).split(\"\\n\");\r\n  // Note that unlike the character offset, the line and column offsets are\r\n  // 1-based.\r\n  var lineWeAreUpTo = lines.length;\r\n  var columnWeAreUpTo = lines[lines.length - 1].length + 1;\r\n  return {\r\n    offset: i,\r\n    line: lineWeAreUpTo,\r\n    column: columnWeAreUpTo\r\n  };\r\n}\r\n\r\n// Returns the sorted set union of two arrays of strings\r\nfunction union(xs, ys) {\r\n  var obj = {};\r\n  for (var i = 0; i < xs.length; i++) {\r\n    obj[xs[i]] = true;\r\n  }\r\n  for (var j = 0; j < ys.length; j++) {\r\n    obj[ys[j]] = true;\r\n  }\r\n  var keys = [];\r\n  for (var k in obj) {\r\n    if ({}.hasOwnProperty.call(obj, k)) {\r\n      keys.push(k);\r\n    }\r\n  }\r\n  keys.sort();\r\n  return keys;\r\n}\r\n\r\nfunction assertParser(p) {\r\n  if (!isParser(p)) {\r\n    throw new Error(\"not a parser: \" + p);\r\n  }\r\n}\r\n\r\nfunction get(input, i) {\r\n  if (typeof input === \"string\") {\r\n    return input.charAt(i);\r\n  }\r\n  return input[i];\r\n}\r\n\r\n// TODO[ES5]: Switch to Array.isArray eventually.\r\nfunction assertArray(x) {\r\n  if (!isArray(x)) {\r\n    throw new Error(\"not an array: \" + x);\r\n  }\r\n}\r\n\r\nfunction assertNumber(x) {\r\n  if (typeof x !== \"number\") {\r\n    throw new Error(\"not a number: \" + x);\r\n  }\r\n}\r\n\r\nfunction assertRegexp(x) {\r\n  if (!(x instanceof RegExp)) {\r\n    throw new Error(\"not a regexp: \" + x);\r\n  }\r\n  var f = flags(x);\r\n  for (var i = 0; i < f.length; i++) {\r\n    var c = f.charAt(i);\r\n    // Only allow regexp flags [imu] for now, since [g] and [y] specifically\r\n    // mess up Parsimmon. If more non-stateful regexp flags are added in the\r\n    // future, this will need to be revisited.\r\n    if (c !== \"i\" && c !== \"m\" && c !== \"u\") {\r\n      throw new Error('unsupported regexp flag \"' + c + '\": ' + x);\r\n    }\r\n  }\r\n}\r\n\r\nfunction assertFunction(x) {\r\n  if (typeof x !== \"function\") {\r\n    throw new Error(\"not a function: \" + x);\r\n  }\r\n}\r\n\r\nfunction assertString(x) {\r\n  if (typeof x !== \"string\") {\r\n    throw new Error(\"not a string: \" + x);\r\n  }\r\n}\r\n\r\n// -*- Error Formatting -*-\r\n\r\nvar linesBeforeStringError = 2;\r\nvar linesAfterStringError = 3;\r\nvar bytesPerLine = 8;\r\nvar bytesBefore = bytesPerLine * 5;\r\nvar bytesAfter = bytesPerLine * 4;\r\nvar defaultLinePrefix = \"  \";\r\n\r\nexport function repeat(string, amount) {\r\n  return new Array(amount + 1).join(string);\r\n}\r\n\r\nexport function formatExpected(expected) {\r\n  if (expected.length === 1) {\r\n    return \"Expected:\\n\\n\" + expected[0];\r\n  }\r\n  return \"Expected one of the following: \\n\\n\" + expected.join(\", \");\r\n}\r\n\r\nexport function leftPad(str, pad, char) {\r\n  var add = pad - str.length;\r\n  if (add <= 0) {\r\n    return str;\r\n  }\r\n  return repeat(char, add) + str;\r\n}\r\n\r\nfunction toChunks(arr, chunkSize) {\r\n  var length = arr.length;\r\n  var chunks = [];\r\n  var chunkIndex = 0;\r\n\r\n  if (length <= chunkSize) {\r\n    return [arr.slice()];\r\n  }\r\n\r\n  for (var i = 0; i < length; i++) {\r\n    if (!chunks[chunkIndex]) {\r\n      chunks.push([]);\r\n    }\r\n\r\n    chunks[chunkIndex].push(arr[i]);\r\n\r\n    if ((i + 1) % chunkSize === 0) {\r\n      chunkIndex++;\r\n    }\r\n  }\r\n\r\n  return chunks;\r\n}\r\n\r\n// Get a range of indexes including `i`-th element and `before` and `after` amount of elements from `arr`.\r\nexport function rangeFromIndexAndOffsets(i, before, after, length) {\r\n  return {\r\n    // Guard against the negative upper bound for lines included in the output.\r\n    from: i - before > 0 ? i - before : 0,\r\n    to: i + after > length ? length : i + after\r\n  };\r\n}\r\n\r\nexport function byteRangeToRange(byteRange) {\r\n  // Exception for inputs smaller than `bytesPerLine`\r\n  if (byteRange.from === 0 && byteRange.to === 1) {\r\n    return {\r\n      from: byteRange.from,\r\n      to: byteRange.to\r\n    };\r\n  }\r\n\r\n  return {\r\n    from: byteRange.from / bytesPerLine,\r\n    // Round `to`, so we don't get float if the amount of bytes is not divisible by `bytesPerLine`\r\n    to: Math.floor(byteRange.to / bytesPerLine)\r\n  };\r\n}\r\n\r\nexport function formatGot(input, error) {\r\n  var index = error.index;\r\n  var i = index.offset;\r\n\r\n  var verticalMarkerLength = 1;\r\n  var column;\r\n  var lineWithErrorIndex;\r\n  var lines;\r\n  var lineRange;\r\n  var lastLineNumberLabelLength;\r\n\r\n  if (i === input.length) {\r\n    return \"Got the end of the input\";\r\n  }\r\n\r\n  if (isBuffer(input)) {\r\n    var byteLineWithErrorIndex = i - (i % bytesPerLine);\r\n    var columnByteIndex = i - byteLineWithErrorIndex;\r\n    var byteRange = rangeFromIndexAndOffsets(\r\n      byteLineWithErrorIndex,\r\n      bytesBefore,\r\n      bytesAfter + bytesPerLine,\r\n      input.length\r\n    );\r\n    var bytes = input.slice(byteRange.from, byteRange.to);\r\n    var bytesInChunks = toChunks(bytes.toJSON().data, bytesPerLine);\r\n\r\n    var byteLines = map(function(byteRow) {\r\n      return map(function(byteValue) {\r\n        // Prefix byte values with a `0` if they are shorter than 2 characters.\r\n        return leftPad(byteValue.toString(16), 2, \"0\");\r\n      }, byteRow);\r\n    }, bytesInChunks);\r\n\r\n    lineRange = byteRangeToRange(byteRange);\r\n    lineWithErrorIndex = byteLineWithErrorIndex / bytesPerLine;\r\n    column = columnByteIndex * 3;\r\n\r\n    // Account for an extra space.\r\n    if (columnByteIndex >= 4) {\r\n      column += 1;\r\n    }\r\n\r\n    verticalMarkerLength = 2;\r\n    lines = map(function(byteLine) {\r\n      return byteLine.length <= 4\r\n        ? byteLine.join(\" \")\r\n        : byteLine.slice(0, 4).join(\" \") + \"  \" + byteLine.slice(4).join(\" \");\r\n    }, byteLines);\r\n    lastLineNumberLabelLength = (\r\n      (lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8\r\n    ).toString(16).length;\r\n\r\n    if (lastLineNumberLabelLength < 2) {\r\n      lastLineNumberLabelLength = 2;\r\n    }\r\n  } else {\r\n    var inputLines = input.split(/\\r\\n|[\\n\\r\\u2028\\u2029]/);\r\n    column = index.column - 1;\r\n    lineWithErrorIndex = index.line - 1;\r\n    lineRange = rangeFromIndexAndOffsets(\r\n      lineWithErrorIndex,\r\n      linesBeforeStringError,\r\n      linesAfterStringError,\r\n      inputLines.length\r\n    );\r\n\r\n    lines = inputLines.slice(lineRange.from, lineRange.to);\r\n    lastLineNumberLabelLength = lineRange.to.toString().length;\r\n  }\r\n\r\n  var lineWithErrorCurrentIndex = lineWithErrorIndex - lineRange.from;\r\n\r\n  if (isBuffer(input)) {\r\n    lastLineNumberLabelLength = (\r\n      (lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8\r\n    ).toString(16).length;\r\n\r\n    if (lastLineNumberLabelLength < 2) {\r\n      lastLineNumberLabelLength = 2;\r\n    }\r\n  }\r\n\r\n  var linesWithLineNumbers = reduce(\r\n    function(acc, lineSource, index) {\r\n      var isLineWithError = index === lineWithErrorCurrentIndex;\r\n      var prefix = isLineWithError ? \"> \" : defaultLinePrefix;\r\n      var lineNumberLabel;\r\n\r\n      if (isBuffer(input)) {\r\n        lineNumberLabel = leftPad(\r\n          ((lineRange.from + index) * 8).toString(16),\r\n          lastLineNumberLabelLength,\r\n          \"0\"\r\n        );\r\n      } else {\r\n        lineNumberLabel = leftPad(\r\n          (lineRange.from + index + 1).toString(),\r\n          lastLineNumberLabelLength,\r\n          \" \"\r\n        );\r\n      }\r\n\r\n      return [].concat(\r\n        acc,\r\n        [prefix + lineNumberLabel + \" | \" + lineSource],\r\n        isLineWithError\r\n          ? [\r\n              defaultLinePrefix +\r\n                repeat(\" \", lastLineNumberLabelLength) +\r\n                \" | \" +\r\n                leftPad(\"\", column, \" \") +\r\n                repeat(\"^\", verticalMarkerLength)\r\n            ]\r\n          : []\r\n      );\r\n    },\r\n    [],\r\n    lines\r\n  );\r\n\r\n  return linesWithLineNumbers.join(\"\\n\");\r\n}\r\n\r\nexport function formatError(input, error) {\r\n  return [\r\n    \"\\n\",\r\n    \"-- PARSING FAILED \" + repeat(\"-\", 50),\r\n    \"\\n\\n\",\r\n    formatGot(input, error),\r\n    \"\\n\\n\",\r\n    formatExpected(error.expected),\r\n    \"\\n\"\r\n  ].join(\"\");\r\n}\r\n\r\nexport function flags(re) {\r\n  var s = \"\" + re;\r\n  return s.slice(s.lastIndexOf(\"/\") + 1);\r\n}\r\n\r\nexport function anchoredRegexp(re) {\r\n  return RegExp(\"^(?:\" + re.source + \")\", flags(re));\r\n}\r\n\r\n// -*- Combinators -*-\r\n\r\nexport function seq() {\r\n  var parsers = [].slice.call(arguments);\r\n  var numParsers = parsers.length;\r\n  for (var j = 0; j < numParsers; j += 1) {\r\n    assertParser(parsers[j]);\r\n  }\r\n  return Parsimmon(function(input, i) {\r\n    var result;\r\n    var accum = new Array(numParsers);\r\n    for (var j = 0; j < numParsers; j += 1) {\r\n      result = mergeReplies(parsers[j]._(input, i), result);\r\n      if (!result.status) {\r\n        return result;\r\n      }\r\n      accum[j] = result.value;\r\n      i = result.index;\r\n    }\r\n    return mergeReplies(makeSuccess(i, accum), result);\r\n  });\r\n}\r\n\r\nexport function seqObj() {\r\n  var seenKeys = {};\r\n  var totalKeys = 0;\r\n  var parsers = toArray(arguments);\r\n  var numParsers = parsers.length;\r\n  for (var j = 0; j < numParsers; j += 1) {\r\n    var p = parsers[j];\r\n    if (isParser(p)) {\r\n      continue;\r\n    }\r\n    if (isArray(p)) {\r\n      var isWellFormed =\r\n        p.length === 2 && typeof p[0] === \"string\" && isParser(p[1]);\r\n      if (isWellFormed) {\r\n        var key = p[0];\r\n        if (Object.prototype.hasOwnProperty.call(seenKeys, key)) {\r\n          throw new Error(\"seqObj: duplicate key \" + key);\r\n        }\r\n        seenKeys[key] = true;\r\n        totalKeys++;\r\n        continue;\r\n      }\r\n    }\r\n    throw new Error(\r\n      \"seqObj arguments must be parsers or [string, parser] array pairs.\"\r\n    );\r\n  }\r\n  if (totalKeys === 0) {\r\n    throw new Error(\"seqObj expects at least one named parser, found zero\");\r\n  }\r\n  return Parsimmon(function(input, i) {\r\n    var result;\r\n    var accum = {};\r\n    for (var j = 0; j < numParsers; j += 1) {\r\n      var name;\r\n      var parser;\r\n      if (isArray(parsers[j])) {\r\n        name = parsers[j][0];\r\n        parser = parsers[j][1];\r\n      } else {\r\n        name = null;\r\n        parser = parsers[j];\r\n      }\r\n      result = mergeReplies(parser._(input, i), result);\r\n      if (!result.status) {\r\n        return result;\r\n      }\r\n      if (name) {\r\n        accum[name] = result.value;\r\n      }\r\n      i = result.index;\r\n    }\r\n    return mergeReplies(makeSuccess(i, accum), result);\r\n  });\r\n}\r\n\r\nexport function seqMap() {\r\n  var args = [].slice.call(arguments);\r\n  if (args.length === 0) {\r\n    throw new Error(\"seqMap needs at least one argument\");\r\n  }\r\n  var mapper = args.pop();\r\n  assertFunction(mapper);\r\n  return seq.apply(null, args).map(function(results) {\r\n    return mapper.apply(null, results);\r\n  });\r\n}\r\n\r\n// TODO[ES5]: Revisit this with Object.keys and .bind.\r\nexport function createLanguage(parsers) {\r\n  var language = {};\r\n  for (var key in parsers) {\r\n    if ({}.hasOwnProperty.call(parsers, key)) {\r\n      (function(key) {\r\n        var func = function() {\r\n          return parsers[key](language);\r\n        };\r\n        language[key] = lazy(func);\r\n      })(key);\r\n    }\r\n  }\r\n  return language;\r\n}\r\n\r\nexport function alt() {\r\n  var parsers = [].slice.call(arguments);\r\n  var numParsers = parsers.length;\r\n  if (numParsers === 0) {\r\n    return fail(\"zero alternates\");\r\n  }\r\n  for (var j = 0; j < numParsers; j += 1) {\r\n    assertParser(parsers[j]);\r\n  }\r\n  return Parsimmon(function(input, i) {\r\n    var result;\r\n    for (var j = 0; j < parsers.length; j += 1) {\r\n      result = mergeReplies(parsers[j]._(input, i), result);\r\n      if (result.status) {\r\n        return result;\r\n      }\r\n    }\r\n    return result;\r\n  });\r\n}\r\n\r\nexport function sepBy(parser, separator) {\r\n  // Argument asserted by sepBy1\r\n  return sepBy1(parser, separator).or(succeed([]));\r\n}\r\n\r\nexport function sepBy1(parser, separator) {\r\n  assertParser(parser);\r\n  assertParser(separator);\r\n  var pairs = separator.then(parser).many();\r\n  return seqMap(parser, pairs, function(r, rs) {\r\n    return [r].concat(rs);\r\n  });\r\n}\r\n\r\n// -*- Core Parsing Methods -*-\r\n\r\n_.parse = function(input) {\r\n  if (typeof input !== \"string\" && !isBuffer(input)) {\r\n    throw new Error(\r\n      \".parse must be called with a string or Buffer as its argument\"\r\n    );\r\n  }\r\n  var result = this.skip(eof)._(input, 0);\r\n  if (result.status) {\r\n    return {\r\n      status: true,\r\n      value: result.value\r\n    };\r\n  }\r\n  return {\r\n    status: false,\r\n    index: makeLineColumnIndex(input, result.furthest),\r\n    expected: result.expected\r\n  };\r\n};\r\n\r\n// -*- Other Methods -*-\r\n\r\n_.tryParse = function(str) {\r\n  var result = this.parse(str);\r\n  if (result.status) {\r\n    return result.value;\r\n  } else {\r\n    var msg = formatError(str, result);\r\n    var err = new Error(msg);\r\n    err.type = \"ParsimmonError\";\r\n    err.result = result;\r\n    throw err;\r\n  }\r\n};\r\n\r\n_.or = function(alternative) {\r\n  return alt(this, alternative);\r\n};\r\n\r\n_.trim = function(parser) {\r\n  return this.wrap(parser, parser);\r\n};\r\n\r\n_.wrap = function(leftParser, rightParser) {\r\n  return seqMap(leftParser, this, rightParser, function(left, middle) {\r\n    return middle;\r\n  });\r\n};\r\n\r\n_.thru = function(wrapper) {\r\n  return wrapper(this);\r\n};\r\n\r\n_.then = function(next) {\r\n  assertParser(next);\r\n  return seq(this, next).map(function(results) {\r\n    return results[1];\r\n  });\r\n};\r\n\r\n_.many = function() {\r\n  var self = this;\r\n\r\n  return Parsimmon(function(input, i) {\r\n    var accum = [];\r\n    var result = undefined;\r\n\r\n    for (;;) {\r\n      result = mergeReplies(self._(input, i), result);\r\n      if (result.status) {\r\n        if (i === result.index) {\r\n          throw new Error(\r\n            \"infinite loop detected in .many() parser --- calling .many() on \" +\r\n              \"a parser which can accept zero characters is usually the cause\"\r\n          );\r\n        }\r\n        i = result.index;\r\n        accum.push(result.value);\r\n      } else {\r\n        return mergeReplies(makeSuccess(i, accum), result);\r\n      }\r\n    }\r\n  });\r\n};\r\n\r\n_.tieWith = function(separator) {\r\n  assertString(separator);\r\n  return this.map(function(args) {\r\n    assertArray(args);\r\n    if (args.length) {\r\n      assertString(args[0]);\r\n      var s = args[0];\r\n      for (var i = 1; i < args.length; i++) {\r\n        assertString(args[i]);\r\n        s += separator + args[i];\r\n      }\r\n      return s;\r\n    } else {\r\n      return \"\";\r\n    }\r\n  });\r\n};\r\n\r\n_.tie = function() {\r\n  return this.tieWith(\"\");\r\n};\r\n\r\n_.times = function(min, max) {\r\n  var self = this;\r\n  if (arguments.length < 2) {\r\n    max = min;\r\n  }\r\n  assertNumber(min);\r\n  assertNumber(max);\r\n  return Parsimmon(function(input, i) {\r\n    var accum = [];\r\n    var result = undefined;\r\n    var prevResult = undefined;\r\n    for (var times = 0; times < min; times += 1) {\r\n      result = self._(input, i);\r\n      prevResult = mergeReplies(result, prevResult);\r\n      if (result.status) {\r\n        i = result.index;\r\n        accum.push(result.value);\r\n      } else {\r\n        return prevResult;\r\n      }\r\n    }\r\n    for (; times < max; times += 1) {\r\n      result = self._(input, i);\r\n      prevResult = mergeReplies(result, prevResult);\r\n      if (result.status) {\r\n        i = result.index;\r\n        accum.push(result.value);\r\n      } else {\r\n        break;\r\n      }\r\n    }\r\n    return mergeReplies(makeSuccess(i, accum), prevResult);\r\n  });\r\n};\r\n\r\n_.result = function(res) {\r\n  return this.map(function() {\r\n    return res;\r\n  });\r\n};\r\n\r\n_.atMost = function(n) {\r\n  return this.times(0, n);\r\n};\r\n\r\n_.atLeast = function(n) {\r\n  return seqMap(this.times(n), this.many(), function(init, rest) {\r\n    return init.concat(rest);\r\n  });\r\n};\r\n\r\n_.map = function(fn) {\r\n  assertFunction(fn);\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var result = self._(input, i);\r\n    if (!result.status) {\r\n      return result;\r\n    }\r\n    return mergeReplies(makeSuccess(result.index, fn(result.value)), result);\r\n  });\r\n};\r\n\r\n_.contramap = function(fn) {\r\n  assertFunction(fn);\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var result = self.parse(fn(input.slice(i)));\r\n    if (!result.status) {\r\n      return result;\r\n    }\r\n    return makeSuccess(i + input.length, result.value);\r\n  });\r\n};\r\n\r\n_.promap = function(f, g) {\r\n  assertFunction(f);\r\n  assertFunction(g);\r\n  return this.contramap(f).map(g);\r\n};\r\n\r\n_.skip = function(next) {\r\n  return seq(this, next).map(function(results) {\r\n    return results[0];\r\n  });\r\n};\r\n\r\n_.mark = function() {\r\n  return seqMap(index, this, index, function(start, value, end) {\r\n    return {\r\n      start: start,\r\n      value: value,\r\n      end: end\r\n    };\r\n  });\r\n};\r\n\r\n_.node = function(name) {\r\n  return seqMap(index, this, index, function(start, value, end) {\r\n    return {\r\n      name: name,\r\n      value: value,\r\n      start: start,\r\n      end: end\r\n    };\r\n  });\r\n};\r\n\r\n_.sepBy = function(separator) {\r\n  return sepBy(this, separator);\r\n};\r\n\r\n_.sepBy1 = function(separator) {\r\n  return sepBy1(this, separator);\r\n};\r\n\r\n_.lookahead = function(x) {\r\n  return this.skip(lookahead(x));\r\n};\r\n\r\n_.notFollowedBy = function(x) {\r\n  return this.skip(notFollowedBy(x));\r\n};\r\n\r\n_.desc = function(expected) {\r\n  if (!isArray(expected)) {\r\n    expected = [expected];\r\n  }\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var reply = self._(input, i);\r\n    if (!reply.status) {\r\n      reply.expected = expected;\r\n    }\r\n    return reply;\r\n  });\r\n};\r\n\r\n_.fallback = function(result) {\r\n  return this.or(succeed(result));\r\n};\r\n\r\n_.ap = function(other) {\r\n  return seqMap(other, this, function(f, x) {\r\n    return f(x);\r\n  });\r\n};\r\n\r\n_.chain = function(f) {\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var result = self._(input, i);\r\n    if (!result.status) {\r\n      return result;\r\n    }\r\n    var nextParser = f(result.value);\r\n    return mergeReplies(nextParser._(input, result.index), result);\r\n  });\r\n};\r\n\r\n// -*- Constructors -*-\r\n\r\nexport function string(str) {\r\n  assertString(str);\r\n  var expected = \"'\" + str + \"'\";\r\n  return Parsimmon(function(input, i) {\r\n    var j = i + str.length;\r\n    var head = input.slice(i, j);\r\n    if (head === str) {\r\n      return makeSuccess(j, head);\r\n    } else {\r\n      return makeFailure(i, expected);\r\n    }\r\n  });\r\n}\r\n\r\nexport function byte(b) {\r\n  ensureBuffer();\r\n  assertNumber(b);\r\n  if (b > 0xff) {\r\n    throw new Error(\r\n      \"Value specified to byte constructor (\" +\r\n        b +\r\n        \"=0x\" +\r\n        b.toString(16) +\r\n        \") is larger in value than a single byte.\"\r\n    );\r\n  }\r\n  var expected = (b > 0xf ? \"0x\" : \"0x0\") + b.toString(16);\r\n  return Parsimmon(function(input, i) {\r\n    var head = get(input, i);\r\n    if (head === b) {\r\n      return makeSuccess(i + 1, head);\r\n    } else {\r\n      return makeFailure(i, expected);\r\n    }\r\n  });\r\n}\r\n\r\nexport function regexp(re, group) {\r\n  assertRegexp(re);\r\n  if (arguments.length >= 2) {\r\n    assertNumber(group);\r\n  } else {\r\n    group = 0;\r\n  }\r\n  var anchored = anchoredRegexp(re);\r\n  var expected = \"\" + re;\r\n  return Parsimmon(function(input, i) {\r\n    var match = anchored.exec(input.slice(i));\r\n    if (match) {\r\n      if (0 <= group && group <= match.length) {\r\n        var fullMatch = match[0];\r\n        var groupMatch = match[group];\r\n        return makeSuccess(i + fullMatch.length, groupMatch);\r\n      }\r\n      var message =\r\n        \"valid match group (0 to \" + match.length + \") in \" + expected;\r\n      return makeFailure(i, message);\r\n    }\r\n    return makeFailure(i, expected);\r\n  });\r\n}\r\n\r\nexport function succeed(value) {\r\n  return Parsimmon(function(input, i) {\r\n    return makeSuccess(i, value);\r\n  });\r\n}\r\n\r\nexport function fail(expected) {\r\n  return Parsimmon(function(input, i) {\r\n    return makeFailure(i, expected);\r\n  });\r\n}\r\n\r\nexport function lookahead(x) {\r\n  if (isParser(x)) {\r\n    return Parsimmon(function(input, i) {\r\n      var result = x._(input, i);\r\n      result.index = i;\r\n      result.value = \"\";\r\n      return result;\r\n    });\r\n  } else if (typeof x === \"string\") {\r\n    return lookahead(string(x));\r\n  } else if (x instanceof RegExp) {\r\n    return lookahead(regexp(x));\r\n  }\r\n  throw new Error(\"not a string, regexp, or parser: \" + x);\r\n}\r\n\r\nexport function notFollowedBy(parser) {\r\n  assertParser(parser);\r\n  return Parsimmon(function(input, i) {\r\n    var result = parser._(input, i);\r\n    var text = input.slice(i, result.index);\r\n    return result.status\r\n      ? makeFailure(i, 'not \"' + text + '\"')\r\n      : makeSuccess(i, null);\r\n  });\r\n}\r\n\r\nexport function test(predicate) {\r\n  assertFunction(predicate);\r\n  return Parsimmon(function(input, i) {\r\n    var char = get(input, i);\r\n    if (i < input.length && predicate(char)) {\r\n      return makeSuccess(i + 1, char);\r\n    } else {\r\n      return makeFailure(i, \"a character/byte matching \" + predicate);\r\n    }\r\n  });\r\n}\r\n\r\nexport function oneOf(str) {\r\n  var expected = str.split(\"\");\r\n  for (var idx = 0; idx < expected.length; idx++) {\r\n    expected[idx] = \"'\" + expected[idx] + \"'\";\r\n  }\r\n  return test(function(ch) {\r\n    return str.indexOf(ch) >= 0;\r\n  }).desc(expected);\r\n}\r\n\r\nexport function noneOf(str) {\r\n  return test(function(ch) {\r\n    return str.indexOf(ch) < 0;\r\n  }).desc(\"none of '\" + str + \"'\");\r\n}\r\n\r\nexport function custom(parsingFunction) {\r\n  return Parsimmon(parsingFunction(makeSuccess, makeFailure));\r\n}\r\n\r\n// TODO[ES5]: Improve error message using JSON.stringify eventually.\r\nexport function range(begin, end) {\r\n  return test(function(ch) {\r\n    return begin <= ch && ch <= end;\r\n  }).desc(begin + \"-\" + end);\r\n}\r\n\r\nexport function takeWhile(predicate) {\r\n  assertFunction(predicate);\r\n\r\n  return Parsimmon(function(input, i) {\r\n    var j = i;\r\n    while (j < input.length && predicate(get(input, j))) {\r\n      j++;\r\n    }\r\n    return makeSuccess(j, input.slice(i, j));\r\n  });\r\n}\r\n\r\nexport function lazy(desc, f) {\r\n  if (arguments.length < 2) {\r\n    f = desc;\r\n    desc = undefined;\r\n  }\r\n\r\n  var parser = Parsimmon(function(input, i) {\r\n    parser._ = f()._;\r\n    return parser._(input, i);\r\n  });\r\n\r\n  if (desc) {\r\n    return parser.desc(desc);\r\n  } else {\r\n    return parser;\r\n  }\r\n}\r\n\r\n// -*- Fantasy Land Extras -*-\r\n\r\nfunction empty() {\r\n  return fail(\"fantasy-land/empty\");\r\n}\r\n\r\n_.concat = _.or;\r\n_.empty = empty;\r\n_.of = succeed;\r\n_[\"fantasy-land/ap\"] = _.ap;\r\n_[\"fantasy-land/chain\"] = _.chain;\r\n_[\"fantasy-land/concat\"] = _.concat;\r\n_[\"fantasy-land/empty\"] = _.empty;\r\n_[\"fantasy-land/of\"] = _.of;\r\n_[\"fantasy-land/map\"] = _.map;\r\n\r\n// -*- Base Parsers -*-\r\n\r\nexport const index = Parsimmon(function(input, i) {\r\n  return makeSuccess(i, makeLineColumnIndex(input, i));\r\n});\r\n\r\nexport const any = Parsimmon(function(input, i) {\r\n  if (i >= input.length) {\r\n    return makeFailure(i, \"any character/byte\");\r\n  }\r\n  return makeSuccess(i + 1, get(input, i));\r\n});\r\n\r\nexport const all = Parsimmon(function(input, i) {\r\n  return makeSuccess(input.length, input.slice(i));\r\n});\r\n\r\nexport const eof = Parsimmon(function(input, i) {\r\n  if (i < input.length) {\r\n    return makeFailure(i, \"EOF\");\r\n  }\r\n  return makeSuccess(i, null);\r\n});\r\n\r\nexport const digit = regexp(/[0-9]/).desc(\"a digit\");\r\nexport const digits = regexp(/[0-9]*/).desc(\"optional digits\");\r\nexport const letter = regexp(/[a-z]/i).desc(\"a letter\");\r\nexport const letters = regexp(/[a-z]*/i).desc(\"optional letters\");\r\nexport const optWhitespace = regexp(/\\s*/).desc(\"optional whitespace\");\r\nexport const whitespace = regexp(/\\s+/).desc(\"whitespace\");\r\nexport const cr = string(\"\\r\");\r\nexport const lf = string(\"\\n\");\r\nexport const crlf = string(\"\\r\\n\");\r\nexport const newline = alt(crlf, lf, cr).desc(\"newline\");\r\nexport const end = alt(newline, eof);","namespace Fable.Parsimmon\r\n\r\nopen Fable.Core\r\nopen Fable.Core.JsInterop\r\n\r\ntype ParseResult<'t> =\r\n    abstract status : bool\r\n    abstract value : 't\r\n\r\ntype IParserOffSet =\r\n    abstract offset : int\r\n    abstract line : int\r\n    abstract column : int\r\n\r\ntype TokenPosition =\r\n    { offset: int\r\n      line: int\r\n      column: int }\r\n\r\ntype NodeResult<'t> =\r\n    { name: string\r\n      value: 't\r\n      start: TokenPosition\r\n      ``end``: TokenPosition }\r\n\r\ntype IParser<'t> =\r\n    abstract map<'u> : ('t -> 'u) -> IParser<'u>\r\n    abstract parse : string -> ParseResult<'t>\r\n    abstract times : int -> IParser<'t []>\r\n    abstract times : int * int -> IParser<'t []>\r\n    abstract many : unit -> IParser<'t []>\r\n    [<Emit(\"$0.then($1)\")>]\r\n    abstract chain : IParser<'u> -> IParser<'u>\r\n    [<Emit(\"$0.chain($1)\")>]\r\n    abstract bind : ('t -> IParser<'u>) -> IParser<'u>\r\n    abstract skip : IParser<'u> -> IParser<'t>\r\n    abstract sepBy : IParser<'u> -> IParser<'t []>\r\n    abstract fallback : 't -> IParser<'t>\r\n    abstract trim : IParser<'u> -> IParser<'t>\r\n    abstract notFollowedBy : IParser<'u> -> IParser<'t>\r\n    abstract atMost : int -> IParser<'t[]>\r\n    abstract atLeast : int -> IParser<'t[]>\r\n    [<Emit(\"$0.or($1)\")>]\r\n    abstract orTry : IParser<'t> -> IParser<'t>\r\n    abstract sepBy1 : IParser<'u> -> IParser<'t []>\r\n    [<Emit(\"$0.node($1)\")>]\r\n    abstract node : string -> IParser<NodeResult<'t>>\r\n\r\nmodule Parsimmon =\r\n    let parseRaw (input: string) (parser: IParser<'t>) =\r\n        parser.parse input\r\n\r\n    let parse (input: string) (parser: IParser<'t>) =\r\n        parser.parse input\r\n        |> fun result ->\r\n            match result.status with\r\n            | true -> Some result.value\r\n            | false -> None\r\n\r\n    /// A parser that consumes no input and yields an object an object representing the current offset into the parse: it has a 0-based character offset property and 1-based line and column properties\r\n    let index : IParser<IParserOffSet> =\r\n        import \"index\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a new parser which tries parser, and if it fails uses otherParser. Example:\r\n    let orTry (otherParser: IParser<'t>) (parser: IParser<'t>) : IParser<'t> =\r\n        parser.orTry(otherParser)\r\n\r\n    /// Returns a new parser that tries to parse the input exactly `n` times\r\n    let times<'t> (n: int) (parser : IParser<'t>) : IParser<'t[]> =\r\n        parser.times n\r\n\r\n    /// Expects parser at least n times. Yields an array of the results.\r\n    let atLeast (n: int) (parser: IParser<'t>) : IParser<'t[]> =\r\n        parser.atLeast n\r\n\r\n\r\n    /// Expects parser at most n times. Yields an array of the results.\r\n    let atMost (n: int) (parser: IParser<'t>) : IParser<'t[]> =\r\n        parser.atMost n\r\n\r\n    let skip (skipped: IParser<'u>) (keep: IParser<'t>) : IParser<'t> =\r\n        keep.skip skipped\r\n\r\n    let many (parser : IParser<'t>) : IParser<'t[]> =\r\n        parser.many()\r\n\r\n    /// Returns a parser that looks for a match to the regexp and yields the entire text matched. The regexp will always match starting at the current parse location.\r\n    [<Import(\"regexp\", \"./Parsimmon.js\"); Emit(\"$0(new RegExp($1))\")>]\r\n    let regex (pattern: string) : IParser<string> = jsNative\r\n    /// Returns a parser that looks for a match to the regexp and yields the entire text matched. The regexp will always match starting at the current parse location.\r\n    [<Import(\"regexp\", \"./Parsimmon.js\"); Emit(\"$0(new RegExp($1), $2)\")>]\r\n    let regexGroupNumber (pattern: string) (groupNumber: int): IParser<string> = jsNative\r\n    let ofLazy (f: unit -> IParser<'t>) : IParser<'t> =\r\n        import \"lazy\" \"./Parsimmon.js\"\r\n\r\n    /// This is the same as Parsimmon.sepBy, but matches the parser at least once.\r\n    let seperateByAtLeastOne (seperator : IParser<'u>) (parser: IParser<'t>) : IParser<'t[]> =\r\n        parser.sepBy1(seperator)\r\n\r\n    /// Expects parser \"after\" to follow parser \"before\", and yields the result of \"before\".\r\n    let chain  (after: IParser<'u>) (before: IParser<'t>) : IParser<'u> =\r\n        before.chain after\r\n\r\n    /// Returns a new parser which tries parser \"p\", and on success calls the function \"f\" with the result of the parse, which is expected to return another parser, which will be tried next. This allows you to dynamically decide how to continue the parse, which is impossible with the other combinators.\r\n    let bind (f: 't -> IParser<'u>) (p: IParser<'t>) : IParser<'u> =\r\n        p.bind f\r\n\r\n    /// A parser that consumes one letter\r\n    let letter : IParser<string> =\r\n        import \"letter\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser that tries `parser` and succeeds if `parser` is able to parse between `min` and `max` times\r\n    let timesBetween (min: int) (max: int) (parser: IParser<'u>) =\r\n        parser.times(min, max)\r\n\r\n    /// A parser that consumes one or more letters\r\n    let letters : IParser<string[]> =\r\n        import \"letters\" \"./Parsimmon.js\"\r\n\r\n    /// A parser that expects to be at the end of the input (zero characters left).\r\n    let endOfFile : IParser<string> =\r\n        import \"eof\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser that looks for anything but whatever \"p\" wants to parse, and does not consume it. Yields the same result as \"before\".\r\n    let notFollowedBy (p: IParser<'u>) (before: IParser<'t>) : IParser<'t> =\r\n        before.notFollowedBy p\r\n\r\n    /// Returns a parser that doesn't consume any input, and yields the given value\r\n    let succeed (value: 't) : IParser<'t> =\r\n        import \"succeed\" \"./Parsimmon.js\"\r\n\r\n    /// Parses using parser, but does not consume what it parses. Yields an empty string.\r\n    let lookahead (parser: IParser<'t>) : IParser<string> =\r\n        import \"lookahead\" \"./Parsimmon.js\"\r\n\r\n    // A parser that consumes one digit\r\n    let digit : IParser<string> =\r\n        import \"digit\" \"./Parsimmon.js\"\r\n\r\n    // A parser that consumes one or more digits\r\n    let digits : IParser<string[]> =\r\n        digit\r\n        |> many\r\n\r\n    /// Returns a new parser which tries \"parser\" and, if it fails, yields value without consuming any input.\r\n    let fallback (value: 't) (parser: IParser<'t>) : IParser<'t> =\r\n        parser.fallback value\r\n\r\n    let seperateBy (content: IParser<'u>) (others: IParser<'t>) : IParser<'t[]> =\r\n        others.sepBy(content)\r\n\r\n    let between (left: IParser<'t>) (right: IParser<'u>) (middle: IParser<'v>) =\r\n        left\r\n        |> chain middle\r\n        |> skip right\r\n\r\n    /// Transforms the parsed value of the given parser.\r\n    let map (f: 't -> 'u) (parser: IParser<'t>) = parser.map f\r\n\r\n    /// Alias of Parsimmon.concat\r\n    let tie (parser: IParser<string[]>) : IParser<string> =\r\n        map (String.concat \"\") parser\r\n\r\n    /// A parser that consumes and yields the next character of the input.\r\n    let any : IParser<string> =\r\n        import \"any\" \"./Parsimmon.js\"\r\n\r\n    /// Accepts any number of parsers, yielding the value of the first one that succeeds, backtracking in between.\r\n    let choose (ps: IParser<'t> list) : IParser<'t> =\r\n        List.reduce (fun acc parser -> acc.orTry(parser)) ps\r\n\r\n    /// A parser that consumes and yields the entire remainder of the input.\r\n    let all : IParser<string> =\r\n        import \"all\"  \"./Parsimmon.js\"\r\n\r\n    /// Returns a failing parser with the given message.\r\n    let fail (input: string) : IParser<string> =\r\n        import \"fail\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser that yield a single character if it passes the predicate function.\r\n    let satisfy (f: string -> bool) : IParser<string> =\r\n        import \"test\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser yield a string containing all the next characters that pass the predicate \"f\"\r\n    let takeWhile (f: string -> bool) : IParser<string> =\r\n        import \"takeWhile\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser that can only parse the exact given input string\r\n    let str (input: string) : IParser<string> =\r\n        import \"string\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser that parses any of the characters of the input string\r\n    let oneOf (input: string) : IParser<string> =\r\n        import \"oneOf\" \"./Parsimmon.js\"\r\n\r\n    let whitespace : IParser<string> =\r\n        import \"whitespace\" \"./Parsimmon.js\"\r\n\r\n    let optionalWhitespace : IParser<string> =\r\n        import \"optWhitespace\" \"./Parsimmon.js\"\r\n\r\n    /// Returns a parser that succeeds one or more times\r\n    let atLeastOneOrMany (parser: IParser<'t>) : IParser<'t[]> =\r\n        atLeast 1 parser\r\n\r\n    let stringReturn (input: string) (value: 't) : IParser<'t> =\r\n        str input\r\n        |> map (fun _ -> value)\r\n\r\n    /// Returns a parser that parses comsumes any character of a string other than the characters of the input string\r\n    let noneOf (input: string) : IParser<string> =\r\n        import \"noneOf\" \"./Parsimmon.js\"\r\n\r\n    let seq2 (p1: IParser<'t>) (p2:IParser<'u>) :  IParser<'t * 'u> =\r\n        import \"seq\" \"./Parsimmon.js\"\r\n\r\n    let trim (trimmed: IParser<'a>) (p: IParser<'t>) : IParser<'t> =\r\n        p.trim trimmed\r\n\r\n    /// Equivalent to `parser.map (String.concat \"\")`\r\n    let concat (parser: IParser<string[]>) : IParser<string> =\r\n        parser.map (String.concat \"\")\r\n\r\n    let seq3 (p1: IParser<'t>)\r\n             (p2: IParser<'u>)\r\n             (p3:IParser<'v>) :  IParser<'t * 'u * 'v> =\r\n        import \"seq\" \"./Parsimmon.js\"\r\n\r\n    let seq4 (p1: IParser<'t>)\r\n             (p2: IParser<'u>)\r\n             (p3:IParser<'v>)\r\n             (p4:IParser<'w>) :  IParser<'t * 'u * 'v * 'w> =\r\n        import \"seq\" \"./Parsimmon.js\"\r\n\r\n    let seq5 (p1: IParser<'t>)\r\n             (p2: IParser<'u>)\r\n             (p3: IParser<'v>)\r\n             (p4: IParser<'w>)\r\n             (p5: IParser<'q>) : IParser<'t * 'u * 'v * 'w * 'q> =\r\n        import \"seq\" \"./Parsimmon.js\"\r\n\r\n    /// Equivalent to `parser.node(\"description\")`\r\n    let node<'t> description (p:IParser<'t>) = p.node(description)","import { FSharpRef } from \"./Types.js\";\nexport function tryParse(str, defValue) {\n    // TODO: test if value is valid and in range\n    if (str != null && /\\S/.test(str)) {\n        const v = +str.replace(\"_\", \"\");\n        if (!Number.isNaN(v)) {\n            defValue.contents = v;\n            return true;\n        }\n    }\n    return false;\n}\nexport function parse(str) {\n    const defValue = new FSharpRef(0);\n    if (tryParse(str, defValue)) {\n        return defValue.contents;\n    }\n    else {\n        throw new Error(\"Input string was not in a correct format.\");\n    }\n}\n// JS Number.isFinite function evals false for NaN\nexport function isInfinity(x) {\n    return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;\n}\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { singleton, ofArrayWithTail, head, tail, isEmpty as isEmpty_1, FSharpList, fold as fold_1, empty as empty_1, cons } from \"./List.js\";\r\nimport { map as map_2, fill } from \"./Array.js\";\r\nimport { structuralHash, compare, toIterator, equals, disposeSafe, getEnumerator, isArrayLike } from \"./Util.js\";\r\nimport { Record } from \"./Types.js\";\r\nimport { tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, map as map_1, unfold } from \"./Seq.js\";\r\nimport { format, join } from \"./String.js\";\r\nimport { LanguagePrimitives_FastGenericComparer } from \"./FSharp.Core.js\";\r\n\r\nexport class MapTreeLeaf$2 {\r\n    constructor(k, v) {\r\n        this.k = k;\r\n        this.v = v;\r\n    }\r\n}\r\n\r\nexport function MapTreeLeaf$2$reflection(gen0, gen1) {\r\n    return class_type(\"Map.MapTreeLeaf`2\", [gen0, gen1], MapTreeLeaf$2);\r\n}\r\n\r\nexport function MapTreeLeaf$2_$ctor_5BDDA1(k, v) {\r\n    return new MapTreeLeaf$2(k, v);\r\n}\r\n\r\nexport function MapTreeLeaf$2__get_Key(_) {\r\n    return _.k;\r\n}\r\n\r\nexport function MapTreeLeaf$2__get_Value(_) {\r\n    return _.v;\r\n}\r\n\r\nexport class MapTreeNode$2 extends MapTreeLeaf$2 {\r\n    constructor(k, v, left, right, h) {\r\n        super(k, v);\r\n        this.left = left;\r\n        this.right = right;\r\n        this.h = (h | 0);\r\n    }\r\n}\r\n\r\nexport function MapTreeNode$2$reflection(gen0, gen1) {\r\n    return class_type(\"Map.MapTreeNode`2\", [gen0, gen1], MapTreeNode$2, MapTreeLeaf$2$reflection(gen0, gen1));\r\n}\r\n\r\nexport function MapTreeNode$2_$ctor_499A11FD(k, v, left, right, h) {\r\n    return new MapTreeNode$2(k, v, left, right, h);\r\n}\r\n\r\nexport function MapTreeNode$2__get_Left(_) {\r\n    return _.left;\r\n}\r\n\r\nexport function MapTreeNode$2__get_Right(_) {\r\n    return _.right;\r\n}\r\n\r\nexport function MapTreeNode$2__get_Height(_) {\r\n    return _.h;\r\n}\r\n\r\nexport function MapTreeModule_empty() {\r\n    return void 0;\r\n}\r\n\r\nexport function MapTreeModule_sizeAux(acc_mut, m_mut) {\r\n    MapTreeModule_sizeAux:\r\n    while (true) {\r\n        const acc = acc_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                acc_mut = MapTreeModule_sizeAux(acc + 1, MapTreeNode$2__get_Left(m2));\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_sizeAux;\r\n            }\r\n            else {\r\n                return (acc + 1) | 0;\r\n            }\r\n        }\r\n        else {\r\n            return acc | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_size(x) {\r\n    return MapTreeModule_sizeAux(0, x);\r\n}\r\n\r\nexport function MapTreeModule_mk(l, k, v, r) {\r\n    let hl;\r\n    const m = l;\r\n    if (m != null) {\r\n        const m2 = m;\r\n        hl = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\r\n    }\r\n    else {\r\n        hl = 0;\r\n    }\r\n    let hr;\r\n    const m_1 = r;\r\n    if (m_1 != null) {\r\n        const m2_1 = m_1;\r\n        hr = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\r\n    }\r\n    else {\r\n        hr = 0;\r\n    }\r\n    const m_2 = ((hl < hr) ? hr : hl) | 0;\r\n    if (m_2 === 0) {\r\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n    }\r\n    else {\r\n        return MapTreeNode$2_$ctor_499A11FD(k, v, l, r, m_2 + 1);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_rebalance(t1, k, v, t2) {\r\n    let m_2, m2_2, m_3, m2_3;\r\n    let t1h;\r\n    const m = t1;\r\n    if (m != null) {\r\n        const m2 = m;\r\n        t1h = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\r\n    }\r\n    else {\r\n        t1h = 0;\r\n    }\r\n    let t2h;\r\n    const m_1 = t2;\r\n    if (m_1 != null) {\r\n        const m2_1 = m_1;\r\n        t2h = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\r\n    }\r\n    else {\r\n        t2h = 0;\r\n    }\r\n    if (t2h > (t1h + 2)) {\r\n        const matchValue = value_1(t2);\r\n        if (matchValue instanceof MapTreeNode$2) {\r\n            if (((m_2 = MapTreeNode$2__get_Left(matchValue), (m_2 != null) ? ((m2_2 = m_2, (m2_2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_2) : 1)) : 0)) > (t1h + 1)) {\r\n                const matchValue_1 = value_1(MapTreeNode$2__get_Left(matchValue));\r\n                if (matchValue_1 instanceof MapTreeNode$2) {\r\n                    return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue_1)), MapTreeLeaf$2__get_Key(matchValue_1), MapTreeLeaf$2__get_Value(matchValue_1), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_1), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue)));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Map.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue)), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Map.rebalance\"));\r\n        }\r\n    }\r\n    else if (t1h > (t2h + 2)) {\r\n        const matchValue_2 = value_1(t1);\r\n        if (matchValue_2 instanceof MapTreeNode$2) {\r\n            if (((m_3 = MapTreeNode$2__get_Right(matchValue_2), (m_3 != null) ? ((m2_3 = m_3, (m2_3 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_3) : 1)) : 0)) > (t2h + 1)) {\r\n                const matchValue_3 = value_1(MapTreeNode$2__get_Right(matchValue_2));\r\n                if (matchValue_3 instanceof MapTreeNode$2) {\r\n                    return MapTreeModule_mk(MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeNode$2__get_Left(matchValue_3)), MapTreeLeaf$2__get_Key(matchValue_3), MapTreeLeaf$2__get_Value(matchValue_3), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_3), k, v, t2));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Map.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_2), k, v, t2));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Map.rebalance\"));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_mk(t1, k, v, t2);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_add(comparer, k, v, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else if (c < 0) {\r\n            return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeModule_empty(), m, 2);\r\n        }\r\n        else if (c === 0) {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n        }\r\n        else {\r\n            return MapTreeNode$2_$ctor_499A11FD(k, v, m, MapTreeModule_empty(), 2);\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_tryFind(comparer_mut, k_mut, m_mut) {\r\n    MapTreeModule_tryFind:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c === 0) {\r\n                return some(MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n            else if (m2 instanceof MapTreeNode$2) {\r\n                comparer_mut = comparer;\r\n                k_mut = k;\r\n                m_mut = ((c < 0) ? MapTreeNode$2__get_Left(m2) : MapTreeNode$2__get_Right(m2));\r\n                continue MapTreeModule_tryFind;\r\n            }\r\n            else {\r\n                return void 0;\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_find(comparer, k, m) {\r\n    const matchValue = MapTreeModule_tryFind(comparer, k, m);\r\n    if (matchValue == null) {\r\n        throw (new Error());\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partition1(comparer, f, k, v, acc1, acc2) {\r\n    if (f(k, v)) {\r\n        return [MapTreeModule_add(comparer, k, v, acc1), acc2];\r\n    }\r\n    else {\r\n        return [acc1, MapTreeModule_add(comparer, k, v, acc2)];\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partitionAux(comparer_mut, f_mut, m_mut, acc_0_mut, acc_1_mut) {\r\n    MapTreeModule_partitionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\r\n        const acc = [acc_0, acc_1];\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const acc_2 = MapTreeModule_partitionAux(comparer, f, MapTreeNode$2__get_Right(m2), acc[0], acc[1]);\r\n                const acc_3 = MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_2[0], acc_2[1]);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Left(m2);\r\n                acc_0_mut = acc_3[0];\r\n                acc_1_mut = acc_3[1];\r\n                continue MapTreeModule_partitionAux;\r\n            }\r\n            else {\r\n                return MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc[0], acc[1]);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partition(comparer, f, m) {\r\n    return MapTreeModule_partitionAux(comparer, f, m, MapTreeModule_empty(), MapTreeModule_empty());\r\n}\r\n\r\nexport function MapTreeModule_filter1(comparer, f, k, v, acc) {\r\n    if (f(k, v)) {\r\n        return MapTreeModule_add(comparer, k, v, acc);\r\n    }\r\n    else {\r\n        return acc;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_filterAux(comparer_mut, f_mut, m_mut, acc_mut) {\r\n    MapTreeModule_filterAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc = acc_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const acc_1 = MapTreeModule_filterAux(comparer, f, MapTreeNode$2__get_Left(m2), acc);\r\n                const acc_2 = MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_1);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                acc_mut = acc_2;\r\n                continue MapTreeModule_filterAux;\r\n            }\r\n            else {\r\n                return MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_filter(comparer, f, m) {\r\n    return MapTreeModule_filterAux(comparer, f, m, MapTreeModule_empty());\r\n}\r\n\r\nexport function MapTreeModule_spliceOutSuccessor(m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (MapTreeNode$2__get_Left(m2) == null) {\r\n                return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2)];\r\n            }\r\n            else {\r\n                const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Left(m2));\r\n                return [patternInput[0], patternInput[1], MapTreeModule_mk(patternInput[2], MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2))];\r\n            }\r\n        }\r\n        else {\r\n            return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_empty()];\r\n        }\r\n    }\r\n    else {\r\n        throw (new Error(\"internal error: Map.spliceOutSuccessor\"));\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_remove(comparer, k, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                if (MapTreeNode$2__get_Left(m2) == null) {\r\n                    return MapTreeNode$2__get_Right(m2);\r\n                }\r\n                else if (MapTreeNode$2__get_Right(m2) == null) {\r\n                    return MapTreeNode$2__get_Left(m2);\r\n                }\r\n                else {\r\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\r\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else if (c === 0) {\r\n            return MapTreeModule_empty();\r\n        }\r\n        else {\r\n            return m;\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_change(comparer, k, u, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                const matchValue_1 = u(some(MapTreeLeaf$2__get_Value(m2)));\r\n                if (matchValue_1 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_1), MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\r\n                }\r\n                else if (MapTreeNode$2__get_Left(m2) == null) {\r\n                    return MapTreeNode$2__get_Right(m2);\r\n                }\r\n                else if (MapTreeNode$2__get_Right(m2) == null) {\r\n                    return MapTreeNode$2__get_Left(m2);\r\n                }\r\n                else {\r\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\r\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c_1 < 0) {\r\n                const matchValue_2 = u(void 0);\r\n                if (matchValue_2 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_2), MapTreeModule_empty(), m, 2);\r\n                }\r\n                else {\r\n                    return m;\r\n                }\r\n            }\r\n            else if (c_1 === 0) {\r\n                const matchValue_3 = u(some(MapTreeLeaf$2__get_Value(m2)));\r\n                if (matchValue_3 != null) {\r\n                    return MapTreeLeaf$2_$ctor_5BDDA1(k, value_1(matchValue_3));\r\n                }\r\n                else {\r\n                    return MapTreeModule_empty();\r\n                }\r\n            }\r\n            else {\r\n                const matchValue_4 = u(void 0);\r\n                if (matchValue_4 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_4), m, MapTreeModule_empty(), 2);\r\n                }\r\n                else {\r\n                    return m;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        const matchValue = u(void 0);\r\n        if (matchValue != null) {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, value_1(matchValue));\r\n        }\r\n        else {\r\n            return m;\r\n        }\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {\r\n    MapTreeModule_mem:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (c < 0) {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    m_mut = MapTreeNode$2__get_Left(m2);\r\n                    continue MapTreeModule_mem;\r\n                }\r\n                else if (c === 0) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_mem;\r\n                }\r\n            }\r\n            else {\r\n                return c === 0;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_iterOpt(f_mut, m_mut) {\r\n    MapTreeModule_iterOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                MapTreeModule_iterOpt(f, MapTreeNode$2__get_Left(m2));\r\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_iterOpt;\r\n            }\r\n            else {\r\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_iter(f, m) {\r\n    MapTreeModule_iterOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_tryPickOpt(f_mut, m_mut) {\r\n    MapTreeModule_tryPickOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const matchValue = MapTreeModule_tryPickOpt(f, MapTreeNode$2__get_Left(m2));\r\n                if (matchValue == null) {\r\n                    const matchValue_1 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                    if (matchValue_1 == null) {\r\n                        f_mut = f;\r\n                        m_mut = MapTreeNode$2__get_Right(m2);\r\n                        continue MapTreeModule_tryPickOpt;\r\n                    }\r\n                    else {\r\n                        return matchValue_1;\r\n                    }\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_tryPick(f, m) {\r\n    return MapTreeModule_tryPickOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_existsOpt(f_mut, m_mut) {\r\n    MapTreeModule_existsOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (MapTreeModule_existsOpt(f, MapTreeNode$2__get_Left(m2)) ? true : f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_existsOpt;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_exists(f, m) {\r\n    return MapTreeModule_existsOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_forallOpt(f_mut, m_mut) {\r\n    MapTreeModule_forallOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (MapTreeModule_forallOpt(f, MapTreeNode$2__get_Left(m2)) && f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\r\n                    f_mut = f;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_forallOpt;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_forall(f, m) {\r\n    return MapTreeModule_forallOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_map(f, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const l2 = MapTreeModule_map(f, MapTreeNode$2__get_Left(m2));\r\n            const v2 = f(MapTreeLeaf$2__get_Value(m2));\r\n            const r2 = MapTreeModule_map(f, MapTreeNode$2__get_Right(m2));\r\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\r\n        }\r\n        else {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Value(m2)));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mapiOpt(f, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const l2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Left(m2));\r\n            const v2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            const r2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Right(m2));\r\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\r\n        }\r\n        else {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mapi(f, m) {\r\n    return MapTreeModule_mapiOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_foldBackOpt(f_mut, m_mut, x_mut) {\r\n    MapTreeModule_foldBackOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut, x = x_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const x_1 = MapTreeModule_foldBackOpt(f, MapTreeNode$2__get_Right(m2), x);\r\n                const x_2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Left(m2);\r\n                x_mut = x_2;\r\n                continue MapTreeModule_foldBackOpt;\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x);\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_foldBack(f, m, x) {\r\n    return MapTreeModule_foldBackOpt(f, m, x);\r\n}\r\n\r\nexport function MapTreeModule_foldOpt(f_mut, x_mut, m_mut) {\r\n    MapTreeModule_foldOpt:\r\n    while (true) {\r\n        const f = f_mut, x = x_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                f_mut = f;\r\n                x_mut = f(MapTreeModule_foldOpt(f, x, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_foldOpt;\r\n            }\r\n            else {\r\n                return f(x, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_fold(f, x, m) {\r\n    return MapTreeModule_foldOpt(f, x, m);\r\n}\r\n\r\nexport function MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x) {\r\n    const foldFromTo = (f_1_mut, m_1_mut, x_1_mut) => {\r\n        foldFromTo:\r\n        while (true) {\r\n            const f_1 = f_1_mut, m_1 = m_1_mut, x_1 = x_1_mut;\r\n            if (m_1 != null) {\r\n                const m2 = m_1;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    const cLoKey = comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n                    const cKeyHi = comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) | 0;\r\n                    const x_2 = (cLoKey < 0) ? foldFromTo(f_1, MapTreeNode$2__get_Left(m2), x_1) : x_1;\r\n                    const x_3 = ((cLoKey <= 0) && (cKeyHi <= 0)) ? f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_2) : x_2;\r\n                    if (cKeyHi < 0) {\r\n                        f_1_mut = f_1;\r\n                        m_1_mut = MapTreeNode$2__get_Right(m2);\r\n                        x_1_mut = x_3;\r\n                        continue foldFromTo;\r\n                    }\r\n                    else {\r\n                        return x_3;\r\n                    }\r\n                }\r\n                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) <= 0) && (comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) <= 0)) {\r\n                    return f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\r\n                }\r\n                else {\r\n                    return x_1;\r\n                }\r\n            }\r\n            else {\r\n                return x_1;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (comparer.Compare(lo, hi) === 1) {\r\n        return x;\r\n    }\r\n    else {\r\n        return foldFromTo(f, m, x);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_foldSection(comparer, lo, hi, f, m, x) {\r\n    return MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x);\r\n}\r\n\r\nexport function MapTreeModule_toList(m) {\r\n    const loop = (m_1_mut, acc_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const m_1 = m_1_mut, acc = acc_mut;\r\n            if (m_1 != null) {\r\n                const m2 = m_1;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    m_1_mut = MapTreeNode$2__get_Left(m2);\r\n                    acc_mut = cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], loop(MapTreeNode$2__get_Right(m2), acc));\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], acc);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(m, empty_1());\r\n}\r\n\r\nexport function MapTreeModule_copyToArray(m, arr, i) {\r\n    let j = i;\r\n    MapTreeModule_iter((x, y) => {\r\n        arr[j] = [x, y];\r\n        j = ((j + 1) | 0);\r\n    }, m);\r\n}\r\n\r\nexport function MapTreeModule_toArray(m) {\r\n    const n = MapTreeModule_size(m) | 0;\r\n    const res = fill(new Array(n), 0, n, [null, null]);\r\n    MapTreeModule_copyToArray(m, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function MapTreeModule_ofList(comparer, l) {\r\n    return fold_1((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);\r\n}\r\n\r\nexport function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\r\n    MapTreeModule_mkFromEnumerator:\r\n    while (true) {\r\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const patternInput = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            comparer_mut = comparer;\r\n            acc_mut = MapTreeModule_add(comparer, patternInput[0], patternInput[1], acc);\r\n            e_mut = e;\r\n            continue MapTreeModule_mkFromEnumerator;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_ofArray(comparer, arr) {\r\n    let res = MapTreeModule_empty();\r\n    for (let idx = 0; idx <= (arr.length - 1); idx++) {\r\n        const forLoopVar = arr[idx];\r\n        res = MapTreeModule_add(comparer, forLoopVar[0], forLoopVar[1], res);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function MapTreeModule_ofSeq(comparer, c) {\r\n    if (isArrayLike(c)) {\r\n        return MapTreeModule_ofArray(comparer, c);\r\n    }\r\n    else if (c instanceof FSharpList) {\r\n        return MapTreeModule_ofList(comparer, c);\r\n    }\r\n    else {\r\n        const ie = getEnumerator(c);\r\n        try {\r\n            return MapTreeModule_mkFromEnumerator(comparer, MapTreeModule_empty(), ie);\r\n        }\r\n        finally {\r\n            disposeSafe(ie);\r\n        }\r\n    }\r\n}\r\n\r\nexport class MapTreeModule_MapIterator$2 extends Record {\r\n    constructor(stack, started) {\r\n        super();\r\n        this.stack = stack;\r\n        this.started = started;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_MapIterator$2$reflection(gen0, gen1) {\r\n    return record_type(\"Map.MapTreeModule.MapIterator`2\", [gen0, gen1], MapTreeModule_MapIterator$2, () => [[\"stack\", list_type(option_type(MapTreeLeaf$2$reflection(gen0, gen1)))], [\"started\", bool_type]]);\r\n}\r\n\r\nexport function MapTreeModule_collapseLHS(stack_mut) {\r\n    MapTreeModule_collapseLHS:\r\n    while (true) {\r\n        const stack = stack_mut;\r\n        if (!isEmpty_1(stack)) {\r\n            const rest = tail(stack);\r\n            const m = head(stack);\r\n            if (m != null) {\r\n                const m2 = m;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    stack_mut = ofArrayWithTail([MapTreeNode$2__get_Left(m2), MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)), MapTreeNode$2__get_Right(m2)], rest);\r\n                    continue MapTreeModule_collapseLHS;\r\n                }\r\n                else {\r\n                    return stack;\r\n                }\r\n            }\r\n            else {\r\n                stack_mut = rest;\r\n                continue MapTreeModule_collapseLHS;\r\n            }\r\n        }\r\n        else {\r\n            return empty_1();\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mkIterator(m) {\r\n    return new MapTreeModule_MapIterator$2(MapTreeModule_collapseLHS(singleton(m)), false);\r\n}\r\n\r\nexport function MapTreeModule_notStarted() {\r\n    throw (new Error(\"enumeration not started\"));\r\n}\r\n\r\nexport function MapTreeModule_alreadyFinished() {\r\n    throw (new Error(\"enumeration already finished\"));\r\n}\r\n\r\nexport function MapTreeModule_current(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const m = head(matchValue);\r\n                if (m instanceof MapTreeNode$2) {\r\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\r\n                }\r\n                else {\r\n                    return [MapTreeLeaf$2__get_Key(m), MapTreeLeaf$2__get_Value(m)];\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\r\n            }\r\n        }\r\n        else {\r\n            return MapTreeModule_alreadyFinished();\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_notStarted();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_moveNext(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const m = head(matchValue);\r\n                if (m instanceof MapTreeNode$2) {\r\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\r\n                }\r\n                else {\r\n                    i.stack = MapTreeModule_collapseLHS(tail(matchValue));\r\n                    return !isEmpty_1(i.stack);\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else {\r\n        i.started = true;\r\n        return !isEmpty_1(i.stack);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mkIEnumerator(m) {\r\n    let i = MapTreeModule_mkIterator(m);\r\n    return {\r\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n            return MapTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.get_Current\"]() {\r\n            return MapTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n            return MapTreeModule_moveNext(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.Reset\"]() {\r\n            i = MapTreeModule_mkIterator(m);\r\n        },\r\n        Dispose() {\r\n        },\r\n    };\r\n}\r\n\r\nexport function MapTreeModule_toSeq(s) {\r\n    return unfold((en_1) => {\r\n        if (en_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return [en_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), en_1];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, MapTreeModule_mkIEnumerator(s));\r\n}\r\n\r\nexport class FSharpMap {\r\n    constructor(comparer, tree) {\r\n        this.comparer = comparer;\r\n        this.tree = tree;\r\n    }\r\n    GetHashCode() {\r\n        const this$ = this;\r\n        return FSharpMap__ComputeHashCode(this$) | 0;\r\n    }\r\n    Equals(that) {\r\n        const this$ = this;\r\n        if (that instanceof FSharpMap) {\r\n            const e1 = getEnumerator(this$);\r\n            try {\r\n                const e2 = getEnumerator(that);\r\n                try {\r\n                    const loop = () => {\r\n                        const m1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                        if (m1 === e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            if (!m1) {\r\n                                return true;\r\n                            }\r\n                            else {\r\n                                const e1c = e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                                const e2c = e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                                if (equals(e1c[0], e2c[0]) && equals(e1c[1], e2c[1])) {\r\n                                    return loop();\r\n                                }\r\n                                else {\r\n                                    return false;\r\n                                }\r\n                            }\r\n                        }\r\n                        else {\r\n                            return false;\r\n                        }\r\n                    };\r\n                    return loop();\r\n                }\r\n                finally {\r\n                    disposeSafe(e2);\r\n                }\r\n            }\r\n            finally {\r\n                disposeSafe(e1);\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    toString() {\r\n        const this$ = this;\r\n        return (\"map [\" + join(\"; \", map_1((kv) => format(\"({0}, {1})\", kv[0], kv[1]), this$))) + \"]\";\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"FSharpMap\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const __ = this;\r\n        return MapTreeModule_mkIEnumerator(__.tree);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const __ = this;\r\n        return MapTreeModule_mkIEnumerator(__.tree);\r\n    }\r\n    CompareTo(obj) {\r\n        const m = this;\r\n        if (obj instanceof FSharpMap) {\r\n            return compareWith((kvp1, kvp2) => {\r\n                const c = m.comparer.Compare(kvp1[0], kvp2[0]) | 0;\r\n                return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;\r\n            }, m, obj) | 0;\r\n        }\r\n        else {\r\n            throw (new Error(\"not comparable\\\\nParameter name: obj\"));\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\r\n        const m = this;\r\n        return FSharpMap__ContainsKey(m, x[0]) && equals(FSharpMap__get_Item(m, x[0]), x[1]);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\r\n        const m = this;\r\n        MapTreeModule_copyToArray(m.tree, arr, i);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return true;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    get size() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    clear() {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    delete(_arg1) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n        return false;\r\n    }\r\n    entries() {\r\n        const m = this;\r\n        return map_1((p) => [p[0], p[1]], m);\r\n    }\r\n    get(k) {\r\n        const m = this;\r\n        return FSharpMap__get_Item(m, k);\r\n    }\r\n    has(k) {\r\n        const m = this;\r\n        return FSharpMap__ContainsKey(m, k);\r\n    }\r\n    keys() {\r\n        const m = this;\r\n        return map_1((p) => p[0], m);\r\n    }\r\n    set(k, v) {\r\n        const m = this;\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n        return m;\r\n    }\r\n    values() {\r\n        const m = this;\r\n        return map_1((p) => p[1], m);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const m = this;\r\n        iterate_1((p) => {\r\n            f(p[1], p[0], m);\r\n        }, m);\r\n    }\r\n}\r\n\r\nexport function FSharpMap$reflection(gen0, gen1) {\r\n    return class_type(\"Map.FSharpMap\", [gen0, gen1], FSharpMap);\r\n}\r\n\r\nexport function FSharpMap_$ctor(comparer, tree) {\r\n    return new FSharpMap(comparer, tree);\r\n}\r\n\r\n(() => {\r\n    FSharpMap.empty = FSharpMap_$ctor(LanguagePrimitives_FastGenericComparer(), MapTreeModule_empty());\r\n})();\r\n\r\nexport function FSharpMap_get_Empty() {\r\n    return FSharpMap.empty;\r\n}\r\n\r\nexport function FSharpMap_Create(ie) {\r\n    const comparer = LanguagePrimitives_FastGenericComparer();\r\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, ie));\r\n}\r\n\r\nexport function FSharpMap__get_Comparer(m) {\r\n    return m.comparer;\r\n}\r\n\r\nexport function FSharpMap__get_Tree(m) {\r\n    return m.tree;\r\n}\r\n\r\nexport function FSharpMap__Add(m, key, value) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_add(m.comparer, key, value, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Change(m, key, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_change(m.comparer, key, f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__get_IsEmpty(m) {\r\n    return m.tree == null;\r\n}\r\n\r\nexport function FSharpMap__get_Item(m, key) {\r\n    return MapTreeModule_find(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__TryPick(m, f) {\r\n    return MapTreeModule_tryPick(f, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Exists(m, predicate) {\r\n    return MapTreeModule_exists(predicate, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Filter(m, predicate) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_filter(m.comparer, predicate, m.tree));\r\n}\r\n\r\nexport function FSharpMap__ForAll(m, predicate) {\r\n    return MapTreeModule_forall(predicate, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Fold(m, f, acc) {\r\n    return MapTreeModule_foldBack(f, m.tree, acc);\r\n}\r\n\r\nexport function FSharpMap__FoldSection(m, lo, hi, f, acc) {\r\n    return MapTreeModule_foldSection(m.comparer, lo, hi, f, m.tree, acc);\r\n}\r\n\r\nexport function FSharpMap__Iterate(m, f) {\r\n    MapTreeModule_iter(f, m.tree);\r\n}\r\n\r\nexport function FSharpMap__MapRange(m, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_map(f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Map(m, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_mapi(f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Partition(m, predicate) {\r\n    const patternInput = MapTreeModule_partition(m.comparer, predicate, m.tree);\r\n    return [FSharpMap_$ctor(m.comparer, patternInput[0]), FSharpMap_$ctor(m.comparer, patternInput[1])];\r\n}\r\n\r\nexport function FSharpMap__get_Count(m) {\r\n    return MapTreeModule_size(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ContainsKey(m, key) {\r\n    return MapTreeModule_mem(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Remove(m, key) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_remove(m.comparer, key, m.tree));\r\n}\r\n\r\nexport function FSharpMap__TryGetValue(__, key, value) {\r\n    const matchValue = MapTreeModule_tryFind(__.comparer, key, __.tree);\r\n    if (matchValue == null) {\r\n        return false;\r\n    }\r\n    else {\r\n        const v = value_1(matchValue);\r\n        value.contents = v;\r\n        return true;\r\n    }\r\n}\r\n\r\nexport function FSharpMap__get_Keys(__) {\r\n    return map_2((kvp) => kvp[0], MapTreeModule_toArray(__.tree));\r\n}\r\n\r\nexport function FSharpMap__get_Values(__) {\r\n    return map_2((kvp) => kvp[1], MapTreeModule_toArray(__.tree));\r\n}\r\n\r\nexport function FSharpMap__TryFind(m, key) {\r\n    return MapTreeModule_tryFind(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__ToList(m) {\r\n    return MapTreeModule_toList(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ToArray(m) {\r\n    return MapTreeModule_toArray(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ComputeHashCode(this$) {\r\n    const combineHash = (x, y) => (((x << 1) + y) + 631);\r\n    let res = 0;\r\n    const enumerator = getEnumerator(this$);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const activePatternResult8263 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            res = (combineHash(res, structuralHash(activePatternResult8263[0])) | 0);\r\n            res = (combineHash(res, structuralHash(activePatternResult8263[1])) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return res | 0;\r\n}\r\n\r\nexport function isEmpty(table) {\r\n    return FSharpMap__get_IsEmpty(table);\r\n}\r\n\r\nexport function add(key, value, table) {\r\n    return FSharpMap__Add(table, key, value);\r\n}\r\n\r\nexport function change(key, f, table) {\r\n    return FSharpMap__Change(table, key, f);\r\n}\r\n\r\nexport function find(key, table) {\r\n    return FSharpMap__get_Item(table, key);\r\n}\r\n\r\nexport function tryFind(key, table) {\r\n    return FSharpMap__TryFind(table, key);\r\n}\r\n\r\nexport function remove(key, table) {\r\n    return FSharpMap__Remove(table, key);\r\n}\r\n\r\nexport function containsKey(key, table) {\r\n    return FSharpMap__ContainsKey(table, key);\r\n}\r\n\r\nexport function iterate(action, table) {\r\n    FSharpMap__Iterate(table, action);\r\n}\r\n\r\nexport function tryPick(chooser, table) {\r\n    return FSharpMap__TryPick(table, chooser);\r\n}\r\n\r\nexport function pick(chooser, table) {\r\n    const matchValue = tryPick(chooser, table);\r\n    if (matchValue != null) {\r\n        return value_1(matchValue);\r\n    }\r\n    else {\r\n        throw (new Error());\r\n    }\r\n}\r\n\r\nexport function exists(predicate, table) {\r\n    return FSharpMap__Exists(table, predicate);\r\n}\r\n\r\nexport function filter(predicate, table) {\r\n    return FSharpMap__Filter(table, predicate);\r\n}\r\n\r\nexport function partition(predicate, table) {\r\n    return FSharpMap__Partition(table, predicate);\r\n}\r\n\r\nexport function forAll(predicate, table) {\r\n    return FSharpMap__ForAll(table, predicate);\r\n}\r\n\r\nexport function map(mapping, table) {\r\n    return FSharpMap__Map(table, mapping);\r\n}\r\n\r\nexport function fold(folder, state, table) {\r\n    return MapTreeModule_fold(folder, state, FSharpMap__get_Tree(table));\r\n}\r\n\r\nexport function foldBack(folder, table, state) {\r\n    return MapTreeModule_foldBack(folder, FSharpMap__get_Tree(table), state);\r\n}\r\n\r\nexport function toSeq(table) {\r\n    return map_1((kvp) => [kvp[0], kvp[1]], table);\r\n}\r\n\r\nexport function findKey(predicate, table) {\r\n    return pick_1((kvp) => {\r\n        const k = kvp[0];\r\n        if (predicate(k, kvp[1])) {\r\n            return some(k);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, table);\r\n}\r\n\r\nexport function tryFindKey(predicate, table) {\r\n    return tryPick_1((kvp) => {\r\n        const k = kvp[0];\r\n        if (predicate(k, kvp[1])) {\r\n            return some(k);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, table);\r\n}\r\n\r\nexport function ofList(elements) {\r\n    return FSharpMap_Create(elements);\r\n}\r\n\r\nexport function ofSeq(elements) {\r\n    return FSharpMap_Create(elements);\r\n}\r\n\r\nexport function ofArray(elements) {\r\n    const comparer = LanguagePrimitives_FastGenericComparer();\r\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofArray(comparer, elements));\r\n}\r\n\r\nexport function toList(table) {\r\n    return FSharpMap__ToList(table);\r\n}\r\n\r\nexport function toArray(table) {\r\n    return FSharpMap__ToArray(table);\r\n}\r\n\r\nexport function keys(table) {\r\n    return FSharpMap__get_Keys(table);\r\n}\r\n\r\nexport function values(table) {\r\n    return FSharpMap__get_Values(table);\r\n}\r\n\r\nexport function empty() {\r\n    return FSharpMap_get_Empty();\r\n}\r\n\r\nexport function count(table) {\r\n    return FSharpMap__get_Count(table);\r\n}\r\n\r\n","namespace Fable.SimpleJson\r\n\r\nopen Fable.Parsimmon\r\n\r\n#nowarn \"40\"\r\n\r\nmodule Parser =\r\n\r\n    let digits = \r\n        Parsimmon.digit \r\n        |> Parsimmon.atLeastOneOrMany\r\n        |> Parsimmon.concat\r\n\r\n    let jint = digits |> Parsimmon.map float\r\n\r\n    let negJint = \r\n        Parsimmon.seq2 (Parsimmon.str \"-\") jint \r\n        |> Parsimmon.map (fun (sign, number) -> -number)\r\n\r\n    let jfloat =\r\n        let floatWithComma =\r\n            Parsimmon.regex \"-?(0|[1-9][0-9]*)?[.][0-9]+([eE][+-]?[0-9]+)?\"\r\n        let floatWithoutComma =\r\n            Parsimmon.regex \"-?[1-9][0-9]*[eE][+-]?[0-9]+\"\r\n\r\n        [ floatWithComma; floatWithoutComma ]\r\n        |> Parsimmon.choose\r\n        |> Parsimmon.map float\r\n\r\n    let jnumber = \r\n        [jfloat; jint; negJint] \r\n        |> Parsimmon.choose\r\n        |> Parsimmon.map JNumber\r\n\r\n    let jbool = \r\n        [ Parsimmon.stringReturn \"true\" (JBool true)\r\n          Parsimmon.stringReturn \"false\" (JBool false)]\r\n        |> Parsimmon.choose\r\n\r\n    let jnull = Parsimmon.stringReturn \"null\" JNull\r\n\r\n    let stringLiteral =\r\n        let escape =  \r\n            Parsimmon.oneOf \"\\\"\\\\/bfnrt\"\r\n            |> Parsimmon.map(function\r\n                | \"b\" -> \"\\b\"\r\n                | \"f\" -> \"\\u000C\"\r\n                | \"n\" -> \"\\n\"\r\n                | \"r\" -> \"\\r\"\r\n                | \"t\" -> \"\\t\"\r\n                | c   -> c) // every other char is mapped to itself\r\n\r\n        let escapedCharSnippet = \r\n            Parsimmon.seq2 (Parsimmon.str \"\\\\\") escape\r\n            |> Parsimmon.map snd\r\n\r\n        let normalCharSnippet = Parsimmon.satisfy (fun c -> c <> \"\\\"\" && c <> \"\\\\\")\r\n\r\n        let anyCharSnippet = \r\n            normalCharSnippet\r\n            |> Parsimmon.orTry escapedCharSnippet\r\n            |> Parsimmon.many\r\n            |> Parsimmon.concat\r\n\r\n        anyCharSnippet\r\n        |> Parsimmon.between (Parsimmon.str \"\\\"\") (Parsimmon.str \"\\\"\")\r\n        \r\n    let jstring = stringLiteral.map JString\r\n\r\n    let withWhitespace p = \r\n        Parsimmon.between (Parsimmon.optionalWhitespace) (Parsimmon.optionalWhitespace) p\r\n        \r\n    let jvalue = \r\n        [ jnull; jbool; jnumber; jstring ]\r\n        |> List.map withWhitespace\r\n        |> Parsimmon.choose\r\n    \r\n    let comma = withWhitespace (Parsimmon.str \",\")\r\n \r\n    let rec json = Parsimmon.ofLazy <| fun () ->\r\n        \r\n        let leftBracket = withWhitespace (Parsimmon.str \"[\")\r\n        let rightBracket = withWhitespace (Parsimmon.str \"]\")\r\n                    \r\n        let arrayValue = Parsimmon.seperateBy comma json\r\n        \r\n        let jarray = \r\n            arrayValue\r\n            |> Parsimmon.between leftBracket rightBracket\r\n            |> Parsimmon.map (List.ofArray >> JArray)\r\n\r\n        let leftBrace = withWhitespace (Parsimmon.str \"{\")\r\n        let rightBrace = withWhitespace (Parsimmon.str \"}\")\r\n            \r\n        let keyValues = \r\n            Parsimmon.seq3 \r\n                (withWhitespace stringLiteral)\r\n                (withWhitespace (Parsimmon.str \":\"))\r\n                (withWhitespace json)\r\n            |> Parsimmon.map (fun (key, _ , value) -> key,value)\r\n            |> Parsimmon.seperateBy comma\r\n\r\n        let jobject = \r\n            keyValues\r\n            |> Parsimmon.between leftBrace rightBrace\r\n            |> Parsimmon.map (List.ofArray >> Map.ofList >> JObject)\r\n\r\n        [jvalue; jarray; jobject]\r\n        |> Parsimmon.choose\r\n        \r\n    let jsonParser = withWhitespace json\r\n","// Adapted from https://github.com/MikeMcl/big.js/blob/0f94dc9110d55c4f324a47ba6a2e832ce23ac589/big.mjs\n/* tslint:disable */\nimport { combineHashCodes } from \"../Util.js\";\nimport { symbol } from \"../Numeric.js\";\n// The shared prototype object.\nvar P = {\n    GetHashCode() { return combineHashCodes([this.s, this.e].concat(this.c)); },\n    Equals(x) { return !this.cmp(x); },\n    CompareTo(x) { return this.cmp(x); },\n    [symbol]() {\n        const _this = this;\n        return {\n            multiply: y => _this.mul(y),\n            toPrecision: sd => _this.toPrecision(sd),\n            toExponential: dp => _this.toExponential(dp),\n            toFixed: dp => _this.toFixed(dp),\n            toHex: () => (Number(_this) >>> 0).toString(16),\n        };\n    }\n};\n/*\n *  big.js v6.0.3\n *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.\n *  Copyright (c) 2020 Michael Mclaughlin\n *  https://github.com/MikeMcl/big.js/LICENCE.md\n */\n/************************************** EDITABLE DEFAULTS *****************************************/\n// The default values below must be integers within the stated ranges.\n/*\n * The maximum number of decimal places (DP) of the results of operations involving division:\n * div and sqrt, and pow with negative exponents.\n */\nvar DP = 28, // 0 to MAX_DP\n/*\n * The rounding mode (RM) used when rounding to the above decimal places.\n *\n *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)\n *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)\n *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)\n *  3  Away from zero.                                  (ROUND_UP)\n */\nRM = 1, // 0, 1, 2 or 3\n// The maximum value of DP and Big.DP.\nMAX_DP = 1E6, // 0 to 1000000\n// The maximum magnitude of the exponent argument to the pow method.\nMAX_POWER = 1E6, // 1 to 1000000\n/*\n * The negative exponent (NE) at and beneath which toString returns exponential notation.\n * (JavaScript numbers: -7)\n * -1000000 is the minimum recommended exponent value of a Big.\n */\nNE = -29, // 0 to -1000000\n/*\n * The positive exponent (PE) at and above which toString returns exponential notation.\n * (JavaScript numbers: 21)\n * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.\n */\nPE = 29, // 0 to 1000000\n/*\n * When true, an error will be thrown if a primitive number is passed to the Big constructor,\n * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a\n * primitive number without a loss of precision.\n */\nSTRICT = false, // true or false\n/**************************************************************************************************/\n// Error messages.\nNAME = '[big.js] ', INVALID = NAME + 'Invalid ', INVALID_DP = INVALID + 'decimal places', INVALID_RM = INVALID + 'rounding mode', DIV_BY_ZERO = NAME + 'Division by zero', UNDEFINED = void 0, NUMERIC = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i;\n/*\n * Create and return a Big constructor.\n */\nfunction _Big_() {\n    /*\n     * The Big constructor and exported function.\n     * Create and return a new instance of a Big number object.\n     *\n     * n {number|string|Big} A numeric value.\n     */\n    function Big(n) {\n        var x = this;\n        // Enable constructor usage without new.\n        if (!(x instanceof Big))\n            return n === UNDEFINED ? _Big_() : new Big(n);\n        // Duplicate.\n        if (n instanceof Big) {\n            x.s = n.s;\n            x.e = n.e;\n            x.c = n.c.slice();\n            normalize(x);\n        }\n        else {\n            if (typeof n !== 'string') {\n                if (Big.strict === true) {\n                    throw TypeError(INVALID + 'number');\n                }\n                // Minus zero?\n                n = n === 0 && 1 / n < 0 ? '-0' : String(n);\n            }\n            parse(x, n);\n        }\n        // Retain a reference to this Big constructor.\n        // Shadow Big.prototype.constructor which points to Object.\n        x.constructor = Big;\n    }\n    Big.prototype = P;\n    Big.DP = DP;\n    Big.RM = RM;\n    Big.NE = NE;\n    Big.PE = PE;\n    Big.strict = STRICT;\n    return Big;\n}\nfunction normalize(x) {\n    // x = round(x, DP, 0);\n    if (x.c.length > 1 && !x.c[0]) {\n        let i = x.c.findIndex(x => x);\n        x.c = x.c.slice(i);\n        x.e = x.e - i;\n    }\n}\n/*\n * Parse the number or string value passed to a Big constructor.\n *\n * x {Big} A Big number instance.\n * n {number|string} A numeric value.\n */\nfunction parse(x, n) {\n    var e, i, nl;\n    if (!NUMERIC.test(n)) {\n        throw Error(INVALID + 'number');\n    }\n    // Determine sign.\n    x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;\n    // Decimal point?\n    if ((e = n.indexOf('.')) > -1)\n        n = n.replace('.', '');\n    // Exponential form?\n    if ((i = n.search(/e/i)) > 0) {\n        // Determine exponent.\n        if (e < 0)\n            e = i;\n        e += +n.slice(i + 1);\n        n = n.substring(0, i);\n    }\n    else if (e < 0) {\n        // Integer.\n        e = n.length;\n    }\n    nl = n.length;\n    // Determine leading zeros before decimal point.\n    for (i = 0; i < e && i < nl && n.charAt(i) == '0';)\n        ++i;\n    // original version (ignores decimal point).\n    // // Determine leading zeros.\n    // for (i = 0; i < nl && n.charAt(i) == '0';) ++i;\n    if (i == nl) {\n        // Zero.\n        x.c = [x.e = 0];\n    }\n    else {\n        x.e = e - i - 1;\n        x.c = [];\n        // Convert string to array of digits without leading zeros\n        for (e = 0; i < nl;)\n            x.c[e++] = +n.charAt(i++);\n        // older version (doesn't keep trailing zeroes).\n        // // Determine trailing zeros.\n        // for (; nl > 0 && n.charAt(--nl) == '0';);\n        // // Convert string to array of digits without leading/trailing zeros.\n        // for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);\n    }\n    x = round(x, Big.DP + 1, Big.RM);\n    return x;\n}\n/*\n * Round Big x to a maximum of sd significant digits using rounding mode rm.\n *\n * x {Big} The Big to round.\n * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.\n * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n * [more] {boolean} Whether the result of division was truncated.\n */\nfunction round(x, sd, rm, more) {\n    var xc = x.c;\n    if (rm === UNDEFINED)\n        rm = Big.RM;\n    if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {\n        throw Error(INVALID_RM);\n    }\n    if (sd < 1) {\n        more =\n            rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 ||\n                rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));\n        xc.length = 1;\n        if (more) {\n            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\n            x.e = x.e - sd + 1;\n            xc[0] = 1;\n        }\n        else {\n            // Zero.\n            xc[0] = x.e = 0;\n        }\n    }\n    else if (sd < xc.length) {\n        // xc[sd] is the digit after the digit that may be rounded up.\n        const isZero = xc.findIndex((xci, idx) => idx >= sd && xci > 0) < 0;\n        more =\n            rm === 1 && xc[sd] >= 5 ||\n                rm === 2 && (xc[sd] > 5 || xc[sd] === 5 &&\n                    (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) ||\n                rm === 3 && (more || !isZero);\n        // Remove any digits after the required precision.\n        xc.length = sd--;\n        // Round up?\n        if (more) {\n            // Rounding up may mean the previous digit has to be rounded up.\n            for (; ++xc[sd] > 9;) {\n                xc[sd] = 0;\n                if (!sd--) {\n                    ++x.e;\n                    xc.unshift(1);\n                }\n            }\n        }\n        // Remove trailing zeros.\n        for (sd = xc.length; !xc[--sd];)\n            xc.pop();\n    }\n    return x;\n}\n/*\n * Return a string representing the value of Big x in normal or exponential notation.\n * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.\n */\nfunction stringify(x, doExponential, isNonzero) {\n    var e = x.e, s = x.c.join(''), n = s.length;\n    // Exponential notation?\n    if (doExponential) {\n        s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;\n        // Normal notation.\n    }\n    else if (e < 0) {\n        for (; ++e;)\n            s = '0' + s;\n        s = '0.' + s;\n    }\n    else if (e > 0) {\n        if (++e > n) {\n            for (e -= n; e--;)\n                s += '0';\n        }\n        else if (e < n) {\n            s = s.slice(0, e) + '.' + s.slice(e);\n        }\n    }\n    else if (n > 1) {\n        s = s.charAt(0) + '.' + s.slice(1);\n    }\n    return x.s < 0 && isNonzero ? '-' + s : s;\n}\n// Prototype/instance methods\n/*\n * Return a new Big whose value is the absolute value of this Big.\n */\nP.abs = function () {\n    var x = new this.constructor(this);\n    x.s = 1;\n    return x;\n};\n/*\n * Return 1 if the value of this Big is greater than the value of Big y,\n *       -1 if the value of this Big is less than the value of Big y, or\n *        0 if they have the same value.\n */\nP.cmp = function (y) {\n    var isneg, Big = this.constructor, x = new Big(this), y = new Big(y), xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;\n    // Either zero?\n    if (!xc[0] || !yc[0])\n        return !xc[0] ? !yc[0] ? 0 : -j : i;\n    // Signs differ?\n    if (i != j)\n        return i;\n    isneg = i < 0;\n    // Compare exponents.\n    if (k != l)\n        return k > l ^ isneg ? 1 : -1;\n    // Compare digit by digit.\n    j = Math.max(xc.length, yc.length);\n    for (i = 0; i < j; i++) {\n        k = i < xc.length ? xc[i] : 0;\n        l = i < yc.length ? yc[i] : 0;\n        if (k != l)\n            return k > l ^ isneg ? 1 : -1;\n    }\n    return 0;\n    // original version (doesn't compare well trailing zeroes, e.g. 1.0 with 1.00)\n    // j = (k = xc.length) < (l = yc.length) ? k : l;\n    // // Compare digit by digit.\n    // for (i = -1; ++i < j;) {\n    //   if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;\n    // }\n    // // Compare lengths.\n    // return k == l ? 0 : k > l ^ isneg ? 1 : -1;\n};\n/*\n * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,\n * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\n */\nP.div = function (y) {\n    var Big = this.constructor, x = new Big(this), y = new Big(y), a = x.c, // dividend\n    b = y.c, // divisor\n    k = x.s == y.s ? 1 : -1, dp = Big.DP;\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\n        throw Error(INVALID_DP);\n    }\n    // Divisor is zero?\n    if (!b[0]) {\n        throw Error(DIV_BY_ZERO);\n    }\n    // Dividend is 0? Return +-0.\n    if (!a[0]) {\n        y.s = k;\n        y.c = [y.e = 0];\n        return y;\n    }\n    var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), // remainder\n    rl = r.length, q = y, // quotient\n    qc = q.c = [], qi = 0, p = dp + (q.e = x.e - y.e) + 1; // precision of the result\n    q.s = k;\n    k = p < 0 ? 0 : p;\n    // Create version of divisor with leading zero.\n    bz.unshift(0);\n    // Add zeros to make remainder as long as divisor.\n    for (; rl++ < bl;)\n        r.push(0);\n    do {\n        // n is how many times the divisor goes into current remainder.\n        for (n = 0; n < 10; n++) {\n            // Compare divisor and remainder.\n            if (bl != (rl = r.length)) {\n                cmp = bl > rl ? 1 : -1;\n            }\n            else {\n                for (ri = -1, cmp = 0; ++ri < bl;) {\n                    if (b[ri] != r[ri]) {\n                        cmp = b[ri] > r[ri] ? 1 : -1;\n                        break;\n                    }\n                }\n            }\n            // If divisor < remainder, subtract divisor from remainder.\n            if (cmp < 0) {\n                // Remainder can't be more than 1 digit longer than divisor.\n                // Equalise lengths using divisor with extra leading zero?\n                for (bt = rl == bl ? b : bz; rl;) {\n                    if (r[--rl] < bt[rl]) {\n                        ri = rl;\n                        for (; ri && !r[--ri];)\n                            r[ri] = 9;\n                        --r[ri];\n                        r[rl] += 10;\n                    }\n                    r[rl] -= bt[rl];\n                }\n                for (; !r[0];)\n                    r.shift();\n            }\n            else {\n                break;\n            }\n        }\n        // Add the digit n to the result array.\n        qc[qi++] = cmp ? n : ++n;\n        // Update the remainder.\n        if (r[0] && cmp)\n            r[rl] = a[ai] || 0;\n        else\n            r = [a[ai]];\n    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);\n    // Leading zero? Do not remove if result is simply zero (qi == 1).\n    if (!qc[0] && qi != 1) {\n        // There can't be more than one zero.\n        qc.shift();\n        q.e--;\n        p--;\n    }\n    // Round?\n    if (qi > p)\n        round(q, p, Big.RM, r[0] !== UNDEFINED);\n    return q;\n};\n/*\n * Return true if the value of this Big is equal to the value of Big y, otherwise return false.\n */\nP.eq = function (y) {\n    return this.cmp(y) === 0;\n};\n/*\n * Return true if the value of this Big is greater than the value of Big y, otherwise return\n * false.\n */\nP.gt = function (y) {\n    return this.cmp(y) > 0;\n};\n/*\n * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise\n * return false.\n */\nP.gte = function (y) {\n    return this.cmp(y) > -1;\n};\n/*\n * Return true if the value of this Big is less than the value of Big y, otherwise return false.\n */\nP.lt = function (y) {\n    return this.cmp(y) < 0;\n};\n/*\n * Return true if the value of this Big is less than or equal to the value of Big y, otherwise\n * return false.\n */\nP.lte = function (y) {\n    return this.cmp(y) < 1;\n};\n/*\n * Return a new Big whose value is the value of this Big minus the value of Big y.\n */\nP.minus = P.sub = function (y) {\n    var i, j, t, xlty, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    // Signs differ?\n    if (a != b) {\n        y.s = -b;\n        return x.plus(y);\n    }\n    var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;\n    // Either zero?\n    if (!xc[0] || !yc[0]) {\n        if (yc[0]) {\n            y.s = -b;\n        }\n        else if (xc[0]) {\n            y = new Big(x);\n        }\n        else {\n            y.s = 1;\n        }\n        return y;\n    }\n    // Determine which is the bigger number. Prepend zeros to equalise exponents.\n    if (a = xe - ye) {\n        if (xlty = a < 0) {\n            a = -a;\n            t = xc;\n        }\n        else {\n            ye = xe;\n            t = yc;\n        }\n        t.reverse();\n        for (b = a; b--;)\n            t.push(0);\n        t.reverse();\n    }\n    else {\n        // Exponents equal. Check digit by digit.\n        j = ((xlty = xc.length < yc.length) ? xc : yc).length;\n        for (a = b = 0; b < j; b++) {\n            if (xc[b] != yc[b]) {\n                xlty = xc[b] < yc[b];\n                break;\n            }\n        }\n    }\n    // x < y? Point xc to the array of the bigger number.\n    if (xlty) {\n        t = xc;\n        xc = yc;\n        yc = t;\n        y.s = -y.s;\n    }\n    /*\n     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only\n     * needs to start at yc.length.\n     */\n    if ((b = (j = yc.length) - (i = xc.length)) > 0)\n        for (; b--;)\n            xc[i++] = 0;\n    // Subtract yc from xc.\n    for (b = i; j > a;) {\n        if (xc[--j] < yc[j]) {\n            for (i = j; i && !xc[--i];)\n                xc[i] = 9;\n            --xc[i];\n            xc[j] += 10;\n        }\n        xc[j] -= yc[j];\n    }\n    // Remove trailing zeros.\n    for (; xc[--b] === 0;)\n        xc.pop();\n    // Remove leading zeros and adjust exponent accordingly.\n    for (; xc[0] === 0;) {\n        xc.shift();\n        --ye;\n    }\n    if (!xc[0]) {\n        // n - n = +0\n        y.s = 1;\n        // Result must be zero.\n        xc = [ye = 0];\n    }\n    y.c = xc;\n    y.e = ye;\n    return y;\n};\n/*\n * Return a new Big whose value is the value of this Big modulo the value of Big y.\n */\nP.mod = function (y) {\n    var ygtx, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    if (!y.c[0]) {\n        throw Error(DIV_BY_ZERO);\n    }\n    x.s = y.s = 1;\n    ygtx = y.cmp(x) == 1;\n    x.s = a;\n    y.s = b;\n    if (ygtx)\n        return new Big(x);\n    a = Big.DP;\n    b = Big.RM;\n    Big.DP = Big.RM = 0;\n    x = x.div(y);\n    Big.DP = a;\n    Big.RM = b;\n    return this.minus(x.times(y));\n};\n/*\n * Return a new Big whose value is the value of this Big plus the value of Big y.\n */\nP.plus = P.add = function (y) {\n    var e, k, t, Big = this.constructor, x = new Big(this), y = new Big(y);\n    // Signs differ?\n    if (x.s != y.s) {\n        y.s = -y.s;\n        return x.minus(y);\n    }\n    var xe = x.e, xc = x.c, ye = y.e, yc = y.c;\n    // Either zero?\n    if (!xc[0] || !yc[0]) {\n        if (!yc[0]) {\n            if (xc[0]) {\n                y = new Big(x);\n            }\n            else {\n                y.s = x.s;\n            }\n        }\n        return y;\n    }\n    xc = xc.slice();\n    // Prepend zeros to equalise exponents.\n    // Note: reverse faster than unshifts.\n    if (e = xe - ye) {\n        if (e > 0) {\n            ye = xe;\n            t = yc;\n        }\n        else {\n            e = -e;\n            t = xc;\n        }\n        t.reverse();\n        for (; e--;)\n            t.push(0);\n        t.reverse();\n    }\n    // Point xc to the longer array.\n    if (xc.length - yc.length < 0) {\n        t = yc;\n        yc = xc;\n        xc = t;\n    }\n    e = yc.length;\n    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.\n    for (k = 0; e; xc[e] %= 10)\n        k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\n    if (k) {\n        xc.unshift(k);\n        ++ye;\n    }\n    // Remove trailing zeros.\n    for (e = xc.length; xc[--e] === 0;)\n        xc.pop();\n    y.c = xc;\n    y.e = ye;\n    return y;\n};\n/*\n * Return a Big whose value is the value of this Big raised to the power n.\n * If n is negative, round to a maximum of Big.DP decimal places using rounding\n * mode Big.RM.\n *\n * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.\n */\nP.pow = function (n) {\n    var Big = this.constructor, x = new Big(this), y = new Big('1'), one = new Big('1'), isneg = n < 0;\n    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {\n        throw Error(INVALID + 'exponent');\n    }\n    if (isneg)\n        n = -n;\n    for (;;) {\n        if (n & 1)\n            y = y.times(x);\n        n >>= 1;\n        if (!n)\n            break;\n        x = x.times(x);\n    }\n    return isneg ? one.div(y) : y;\n};\n/*\n * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd\n * significant digits using rounding mode rm, or Big.RM if rm is not specified.\n *\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.prec = function (sd, rm) {\n    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\n        throw Error(INVALID + 'precision');\n    }\n    return round(new this.constructor(this), sd, rm);\n};\n/*\n * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places\n * using rounding mode rm, or Big.RM if rm is not specified.\n * If dp is negative, round to an integer which is a multiple of 10**-dp.\n * If dp is not specified, round to 0 decimal places.\n *\n * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.round = function (dp, rm) {\n    if (dp === UNDEFINED)\n        dp = 0;\n    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {\n        throw Error(INVALID_DP);\n    }\n    return round(new this.constructor(this), dp + this.e + 1, rm);\n};\n/*\n * Return a new Big whose value is the square root of the value of this Big, rounded, if\n * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\n */\nP.sqrt = function () {\n    var r, c, t, Big = this.constructor, x = new Big(this), s = x.s, e = x.e, half = new Big('0.5');\n    // Zero?\n    if (!x.c[0])\n        return new Big(x);\n    // Negative?\n    if (s < 0) {\n        throw Error(NAME + 'No square root');\n    }\n    // Estimate.\n    s = Math.sqrt(x + '');\n    // Math.sqrt underflow/overflow?\n    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.\n    if (s === 0 || s === 1 / 0) {\n        c = x.c.join('');\n        if (!(c.length + e & 1))\n            c += '0';\n        s = Math.sqrt(c);\n        e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);\n        r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);\n    }\n    else {\n        r = new Big(s + '');\n    }\n    e = r.e + (Big.DP += 4);\n    // Newton-Raphson iteration.\n    do {\n        t = r;\n        r = half.times(t.plus(x.div(t)));\n    } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));\n    return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);\n};\n/*\n * Return a new Big whose value is the value of this Big times the value of Big y.\n */\nP.times = P.mul = function (y) {\n    var c, Big = this.constructor, x = new Big(this), y = new Big(y), xc = x.c, yc = y.c, a = xc.length, b = yc.length, i = x.e, j = y.e;\n    // Determine sign of result.\n    y.s = x.s == y.s ? 1 : -1;\n    // Return signed 0 if either 0.\n    if (!xc[0] || !yc[0]) {\n        y.c = [y.e = 0];\n        return y;\n    }\n    // Initialise exponent of result as x.e + y.e.\n    y.e = i + j;\n    // If array xc has fewer digits than yc, swap xc and yc, and lengths.\n    if (a < b) {\n        c = xc;\n        xc = yc;\n        yc = c;\n        j = a;\n        a = b;\n        b = j;\n    }\n    // Initialise coefficient array of result with zeros.\n    for (c = new Array(j = a + b); j--;)\n        c[j] = 0;\n    // Multiply.\n    // i is initially xc.length.\n    for (i = b; i--;) {\n        b = 0;\n        // a is yc.length.\n        for (j = a + i; j > i;) {\n            // Current sum of products at this digit position, plus carry.\n            b = c[j] + yc[i] * xc[j - i - 1] + b;\n            c[j--] = b % 10;\n            // carry\n            b = b / 10 | 0;\n        }\n        c[j] = b;\n    }\n    // Increment result exponent if there is a final carry, otherwise remove leading zero.\n    if (b)\n        ++y.e;\n    else\n        c.shift();\n    // Remove trailing zeros.\n    for (i = c.length; !c[--i];)\n        c.pop();\n    y.c = c;\n    return y;\n};\n/*\n * Return a string representing the value of this Big in exponential notation rounded to dp fixed\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\n *\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.toExponential = function (dp, rm) {\n    var x = this, n = x.c[0];\n    if (dp !== UNDEFINED) {\n        if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\n            throw Error(INVALID_DP);\n        }\n        x = round(new x.constructor(x), ++dp, rm);\n        for (; x.c.length < dp;)\n            x.c.push(0);\n    }\n    return stringify(x, true, !!n);\n};\n/*\n * Return a string representing the value of this Big in normal notation rounded to dp fixed\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\n *\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n *\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\n */\nP.toFixed = function (dp, rm) {\n    var x = this, n = x.c[0];\n    if (dp !== UNDEFINED) {\n        if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\n            throw Error(INVALID_DP);\n        }\n        x = round(new x.constructor(x), dp + x.e + 1, rm);\n        // x.e may have changed if the value is rounded up.\n        for (dp = dp + x.e + 1; x.c.length < dp;)\n            x.c.push(0);\n    }\n    return stringify(x, false, !!n);\n};\n/*\n * Return a string representing the value of this Big.\n * Return exponential notation if this Big has a positive exponent equal to or greater than\n * Big.PE, or a negative exponent equal to or less than Big.NE.\n * Omit the sign for negative zero.\n */\nP.toJSON = P.toString = function () {\n    var x = this, Big = x.constructor;\n    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);\n};\n/*\n * Return the value of this Big as a primitve number.\n */\nP.toNumber = function () {\n    var n = Number(stringify(this, true, true));\n    if (this.constructor.strict === true && !this.eq(n.toString())) {\n        throw Error(NAME + 'Imprecise conversion');\n    }\n    return n;\n};\n/*\n * Return a string representing the value of this Big rounded to sd significant digits using\n * rounding mode rm, or Big.RM if rm is not specified.\n * Use exponential notation if sd is less than the number of digits necessary to represent\n * the integer part of the value in normal notation.\n *\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.toPrecision = function (sd, rm) {\n    var x = this, Big = x.constructor, n = x.c[0];\n    if (sd !== UNDEFINED) {\n        if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\n            throw Error(INVALID + 'precision');\n        }\n        x = round(new Big(x), sd, rm);\n        for (; x.c.length < sd;)\n            x.c.push(0);\n    }\n    return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);\n};\n/*\n * Return a string representing the value of this Big.\n * Return exponential notation if this Big has a positive exponent equal to or greater than\n * Big.PE, or a negative exponent equal to or less than Big.NE.\n * Include the sign for negative zero.\n */\nP.valueOf = function () {\n    var x = this, Big = x.constructor;\n    if (Big.strict === true) {\n        throw Error(NAME + 'valueOf disallowed');\n    }\n    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);\n};\n// Export\nexport var Big = _Big_();\n/// <reference types=\"https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/master/types/big.js/index.d.ts\" />\nexport default Big;\n","import Decimal from \"./lib/big.js\";\nimport { FSharpRef } from \"./Types.js\";\nexport default Decimal;\nexport const get_Zero = new Decimal(0);\nexport const get_One = new Decimal(1);\nexport const get_MinusOne = new Decimal(-1);\nexport const get_MaxValue = new Decimal(\"79228162514264337593543950335\");\nexport const get_MinValue = new Decimal(\"-79228162514264337593543950335\");\nexport function compare(x, y) {\n    return x.cmp(y);\n}\nexport function equals(x, y) {\n    return !x.cmp(y);\n}\nexport function abs(x) {\n    return x.abs();\n}\nexport function round(x, digits = 0) {\n    return x.round(digits, 2 /* ROUND_HALF_EVEN */);\n}\nexport function truncate(x) {\n    return x.round(0, 0 /* ROUND_DOWN */);\n}\nexport function ceiling(x) {\n    return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);\n}\nexport function floor(x) {\n    return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);\n}\nexport function pow(x, n) {\n    return x.pow(n);\n}\nexport function sqrt(x) {\n    return x.sqrt();\n}\nexport function op_Addition(x, y) {\n    return x.add(y);\n}\nexport function op_Subtraction(x, y) {\n    return x.sub(y);\n}\nexport function op_Multiply(x, y) {\n    return x.mul(y);\n}\nexport function op_Division(x, y) {\n    return x.div(y);\n}\nexport function op_Modulus(x, y) {\n    return x.mod(y);\n}\nexport function op_UnaryNegation(x) {\n    const x2 = new Decimal(x);\n    x2.s = -x2.s || 0;\n    return x2;\n}\nexport const add = op_Addition;\nexport const subtract = op_Subtraction;\nexport const multiply = op_Multiply;\nexport const divide = op_Division;\nexport const remainder = op_Modulus;\nexport const negate = op_UnaryNegation;\nexport function toString(x) {\n    return x.toString();\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = new Decimal(str.trim());\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function parse(str) {\n    const defValue = new FSharpRef(get_Zero);\n    if (tryParse(str, defValue)) {\n        return defValue.contents;\n    }\n    else {\n        throw new Error(\"Input string was not in a correct format.\");\n    }\n}\nexport function toNumber(x) {\n    return +x;\n}\nfunction decimalToHex(dec, bitSize) {\n    const hex = new Uint8Array(bitSize / 4 | 0);\n    let hexCount = 1;\n    for (let d = 0; d < dec.length; d++) {\n        let value = dec[d];\n        for (let i = 0; i < hexCount; i++) {\n            const digit = hex[i] * 10 + value | 0;\n            hex[i] = digit & 0xF;\n            value = digit >> 4;\n        }\n        if (value !== 0) {\n            hex[hexCount++] = value;\n        }\n    }\n    return hex.slice(0, hexCount); // digits in reverse order\n}\nfunction hexToDecimal(hex, bitSize) {\n    const dec = new Uint8Array(bitSize * 301 / 1000 + 1 | 0);\n    let decCount = 1;\n    for (let d = hex.length - 1; d >= 0; d--) {\n        let carry = hex[d];\n        for (let i = 0; i < decCount; i++) {\n            const val = dec[i] * 16 + carry | 0;\n            dec[i] = (val % 10) | 0;\n            carry = (val / 10) | 0;\n        }\n        while (carry > 0) {\n            dec[decCount++] = (carry % 10) | 0;\n            carry = (carry / 10) | 0;\n        }\n    }\n    return dec.slice(0, decCount); // digits in reverse order\n}\nfunction setInt32Bits(hexDigits, bits, offset) {\n    for (let i = 0; i < 8; i++) {\n        hexDigits[offset + i] = (bits >> (i * 4)) & 0xF;\n    }\n}\nfunction getInt32Bits(hexDigits, offset) {\n    let bits = 0;\n    for (let i = 0; i < 8; i++) {\n        bits = bits | (hexDigits[offset + i] << (i * 4));\n    }\n    return bits;\n}\nexport function fromIntArray(bits) {\n    return fromInts(bits[0], bits[1], bits[2], bits[3]);\n}\nexport function fromInts(low, mid, high, signExp) {\n    const isNegative = signExp < 0;\n    const scale = (signExp >> 16) & 0x7F;\n    return fromParts(low, mid, high, isNegative, scale);\n}\nexport function fromParts(low, mid, high, isNegative, scale) {\n    const bitSize = 96;\n    const hexDigits = new Uint8Array(bitSize / 4);\n    setInt32Bits(hexDigits, low, 0);\n    setInt32Bits(hexDigits, mid, 8);\n    setInt32Bits(hexDigits, high, 16);\n    const decDigits = hexToDecimal(hexDigits, bitSize);\n    scale = scale & 0x7F;\n    const big = new Decimal(0);\n    big.c = Array.from(decDigits.reverse());\n    big.e = decDigits.length - scale - 1;\n    big.s = isNegative ? -1 : 1;\n    const d = new Decimal(big);\n    return d;\n}\nexport function getBits(d) {\n    const bitSize = 96;\n    const decDigits = Uint8Array.from(d.c);\n    const hexDigits = decimalToHex(decDigits, bitSize);\n    const low = getInt32Bits(hexDigits, 0);\n    const mid = getInt32Bits(hexDigits, 8);\n    const high = getInt32Bits(hexDigits, 16);\n    const decStr = d.toString();\n    const dotPos = decStr.indexOf(\".\");\n    const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;\n    const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);\n    return [low, mid, high, signExp];\n}\n// export function makeRangeStepFunction(step: Decimal, last: Decimal) {\n//   const stepComparedWithZero = step.cmp(get_Zero);\n//   if (stepComparedWithZero === 0) {\n//     throw new Error(\"The step of a range cannot be zero\");\n//   }\n//   const stepGreaterThanZero = stepComparedWithZero > 0;\n//   return (x: Decimal) => {\n//     const comparedWithLast = x.cmp(last);\n//     if ((stepGreaterThanZero && comparedWithLast <= 0)\n//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n//       return [x, op_Addition(x, step)];\n//     } else {\n//       return undefined;\n//     }\n//   };\n// }\n","import { Record } from \"../Types.js\";\r\nimport { record_type, array_type, int32_type } from \"../Reflection.js\";\r\nimport { op_LeftShift, op_BitwiseAnd, op_Addition, compare, op_Subtraction, op_Division, equals, fromInteger, op_Multiply, op_Modulus, toInt, fromBits } from \"../Long.js\";\r\nimport { copy, initialize, map, fill } from \"../Array.js\";\r\nimport { toArray, empty, head, tail, isEmpty, cons } from \"../List.js\";\r\nimport { int32ToString } from \"../Util.js\";\r\nimport { isNullOrEmpty, join } from \"../String.js\";\r\n\r\nexport class BigNat extends Record {\r\n    constructor(bound, digits) {\r\n        super();\r\n        this.bound = (bound | 0);\r\n        this.digits = digits;\r\n    }\r\n}\r\n\r\nexport function BigNat$reflection() {\r\n    return record_type(\"BigInt.BigNat\", [], BigNat, () => [[\"bound\", int32_type], [\"digits\", array_type(int32_type)]]);\r\n}\r\n\r\nexport function BigNatModule_FFT_pow32(x_mut, n_mut) {\r\n    BigNatModule_FFT_pow32:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return 1;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (x * x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_FFT_pow32;\r\n        }\r\n        else {\r\n            return (x * BigNatModule_FFT_pow32(x * x, ~(~(n / 2)))) | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_leastBounding2Power(b) {\r\n    const findBounding2Power = (b_1_mut, tp_mut, i_mut) => {\r\n        findBounding2Power:\r\n        while (true) {\r\n            const b_1 = b_1_mut, tp = tp_mut, i = i_mut;\r\n            if (b_1 <= tp) {\r\n                return [tp, i];\r\n            }\r\n            else {\r\n                b_1_mut = b_1;\r\n                tp_mut = (tp * 2);\r\n                i_mut = (i + 1);\r\n                continue findBounding2Power;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return findBounding2Power(b, 1, 0);\r\n}\r\n\r\nexport const BigNatModule_FFT_p = fromBits(2013265921, 0, false);\r\n\r\nconst BigNatModule_FFT_patternInput$004075 = [27, 15, 31, 440564289];\r\n\r\nexport const BigNatModule_FFT_w = BigNatModule_FFT_patternInput$004075[3];\r\n\r\nexport const BigNatModule_FFT_m = BigNatModule_FFT_patternInput$004075[1];\r\n\r\nexport const BigNatModule_FFT_k = BigNatModule_FFT_patternInput$004075[0];\r\n\r\nexport const BigNatModule_FFT_g = BigNatModule_FFT_patternInput$004075[2];\r\n\r\nexport const BigNatModule_FFT_primeP = BigNatModule_FFT_p;\r\n\r\nexport const BigNatModule_FFT_maxBitsInsideFp = 30;\r\n\r\nexport const BigNatModule_FFT_Fp_p = 2013265921;\r\n\r\nexport const BigNatModule_FFT_Fp_p64 = fromBits(2013265921, 0, true);\r\n\r\nexport function BigNatModule_FFT_Fp_toInt(x) {\r\n    return ~(~x);\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_ofInt32(x) {\r\n    return x >>> 0;\r\n}\r\n\r\nexport const BigNatModule_FFT_Fp_mzero = 0;\r\n\r\nexport const BigNatModule_FFT_Fp_mone = 1;\r\n\r\nexport const BigNatModule_FFT_Fp_mtwo = 2;\r\n\r\nexport function BigNatModule_FFT_Fp_mpow(x_mut, n_mut) {\r\n    BigNatModule_FFT_Fp_mpow:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return BigNatModule_FFT_Fp_mone;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_FFT_Fp_mpow;\r\n        }\r\n        else {\r\n            const y_2 = BigNatModule_FFT_Fp_mpow(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, ~(~(n / 2)));\r\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_mpowL(x_mut, n_mut) {\r\n    BigNatModule_FFT_Fp_mpowL:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (equals(n, fromBits(0, 0, false))) {\r\n            return BigNatModule_FFT_Fp_mone;\r\n        }\r\n        else if (equals(op_Modulus(n, fromBits(2, 0, false)), fromBits(0, 0, false))) {\r\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\r\n            n_mut = op_Division(n, fromBits(2, 0, false));\r\n            continue BigNatModule_FFT_Fp_mpowL;\r\n        }\r\n        else {\r\n            const y_2 = BigNatModule_FFT_Fp_mpowL(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, op_Division(n, fromBits(2, 0, false)));\r\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_m2PowNthRoot(n) {\r\n    return BigNatModule_FFT_Fp_mpow(BigNatModule_FFT_w >>> 0, BigNatModule_FFT_pow32(2, BigNatModule_FFT_k - n));\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_minv(x) {\r\n    return BigNatModule_FFT_Fp_mpowL(x, op_Subtraction(BigNatModule_FFT_primeP, fromBits(2, 0, false)));\r\n}\r\n\r\nexport function BigNatModule_FFT_computeFFT(lambda, mu, n, w, u, res, offset) {\r\n    let x_1, x_3, y_5;\r\n    if (n === 1) {\r\n        res[offset] = u[mu];\r\n    }\r\n    else {\r\n        const halfN = (~(~(n / 2))) | 0;\r\n        const ww = toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(w, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        const offsetHalfN = (offset + halfN) | 0;\r\n        BigNatModule_FFT_computeFFT(lambda * 2, mu, halfN, ww, u, res, offset);\r\n        BigNatModule_FFT_computeFFT(lambda * 2, lambda + mu, halfN, ww, u, res, offsetHalfN);\r\n        let wj = BigNatModule_FFT_Fp_mone;\r\n        for (let j = 0; j <= (halfN - 1); j++) {\r\n            const even = res[offset + j];\r\n            const odd = res[offsetHalfN + j];\r\n            res[offset + j] = ((even + ((x_1 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_1, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0))) % BigNatModule_FFT_Fp_p);\r\n            res[offsetHalfN + j] = (((even + BigNatModule_FFT_Fp_p) - ((x_3 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_3, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0))) % BigNatModule_FFT_Fp_p);\r\n            wj = ((y_5 = wj, toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(y_5, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_computFftInPlace(n, w, u) {\r\n    const res = fill(new Uint32Array(n), 0, n, BigNatModule_FFT_Fp_mzero);\r\n    BigNatModule_FFT_computeFFT(1, 0, n, w, u, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function BigNatModule_FFT_computeInverseFftInPlace(n, w, uT) {\r\n    const bigKInv = BigNatModule_FFT_Fp_minv(n >>> 0);\r\n    return map((y) => (toInt(op_Modulus(op_Multiply(fromInteger(bigKInv, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0), BigNatModule_FFT_computFftInPlace(n, BigNatModule_FFT_Fp_minv(w), uT), Uint32Array);\r\n}\r\n\r\nexport const BigNatModule_FFT_maxTwoPower = 29;\r\n\r\nexport const BigNatModule_FFT_twoPowerTable = initialize(BigNatModule_FFT_maxTwoPower - 1, (i) => BigNatModule_FFT_pow32(2, i), Int32Array);\r\n\r\nexport function BigNatModule_FFT_computeFftPaddedPolynomialProduct(bigK, k, u, v) {\r\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(k);\r\n    const n = bigK | 0;\r\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u);\r\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v);\r\n    return BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\r\n        const x = uT[i];\r\n        const y = vT[i];\r\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n    }, Uint32Array));\r\n}\r\n\r\nexport function BigNatModule_FFT_padTo(n, u) {\r\n    const uBound = u.length | 0;\r\n    return initialize(n, (i) => ((i < uBound) ? BigNatModule_FFT_Fp_ofInt32(u[i]) : BigNatModule_FFT_Fp_mzero), Uint32Array);\r\n}\r\n\r\nexport function BigNatModule_FFT_computeFftPolynomialProduct(degu, u, degv, v) {\r\n    const patternInput = BigNatModule_FFT_leastBounding2Power((degu + degv) + 1);\r\n    const bigK = patternInput[0] | 0;\r\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(patternInput[1]);\r\n    const u_1 = BigNatModule_FFT_padTo(bigK, u);\r\n    const v_1 = BigNatModule_FFT_padTo(bigK, v);\r\n    const n = bigK | 0;\r\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u_1);\r\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v_1);\r\n    return map(BigNatModule_FFT_Fp_toInt, BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\r\n        const x = uT[i];\r\n        const y = vT[i];\r\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n    }, Uint32Array)), Int32Array);\r\n}\r\n\r\nexport const BigNatModule_FFT_mzero = BigNatModule_FFT_Fp_mzero;\r\n\r\nexport const BigNatModule_FFT_mone = BigNatModule_FFT_Fp_mone;\r\n\r\nexport const BigNatModule_FFT_maxFp = ((BigNatModule_FFT_Fp_p + BigNatModule_FFT_Fp_p) - BigNatModule_FFT_mone) % BigNatModule_FFT_Fp_p;\r\n\r\nexport function BigNatModule_bound(n) {\r\n    return n.bound;\r\n}\r\n\r\nexport function BigNatModule_setBound(n, v) {\r\n    n.bound = (v | 0);\r\n}\r\n\r\nexport function BigNatModule_coeff(n, i) {\r\n    return n.digits[i];\r\n}\r\n\r\nexport function BigNatModule_coeff64(n, i) {\r\n    return fromInteger(BigNatModule_coeff(n, i), false, 2);\r\n}\r\n\r\nexport function BigNatModule_setCoeff(n, i, v) {\r\n    n.digits[i] = (v | 0);\r\n}\r\n\r\nexport function BigNatModule_pow64(x_mut, n_mut) {\r\n    BigNatModule_pow64:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return fromBits(1, 0, false);\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = op_Multiply(x, x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_pow64;\r\n        }\r\n        else {\r\n            return op_Multiply(x, BigNatModule_pow64(op_Multiply(x, x), ~(~(n / 2))));\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_pow32(x_mut, n_mut) {\r\n    BigNatModule_pow32:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return 1;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (x * x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_pow32;\r\n        }\r\n        else {\r\n            return (x * BigNatModule_pow32(x * x, ~(~(n / 2)))) | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_hash(n) {\r\n    let res = 0;\r\n    for (let i = 0; i <= (n.bound - 1); i++) {\r\n        res = ((n.digits[i] + (res << 3)) | 0);\r\n    }\r\n    return res | 0;\r\n}\r\n\r\nexport function BigNatModule_maxInt(a, b) {\r\n    if (a < b) {\r\n        return b | 0;\r\n    }\r\n    else {\r\n        return a | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_minInt(a, b) {\r\n    if (a < b) {\r\n        return a | 0;\r\n    }\r\n    else {\r\n        return b | 0;\r\n    }\r\n}\r\n\r\nexport const BigNatModule_baseBits = 24;\r\n\r\nexport const BigNatModule_baseN = 16777216;\r\n\r\nexport const BigNatModule_baseMask = 16777215;\r\n\r\nexport const BigNatModule_baseNi64 = fromBits(16777216, 0, false);\r\n\r\nexport const BigNatModule_baseMaski64 = fromBits(16777215, 0, false);\r\n\r\nexport const BigNatModule_baseMaskU = fromBits(16777215, 0, true);\r\n\r\nexport const BigNatModule_baseMask32A = 16777215;\r\n\r\nexport const BigNatModule_baseMask32B = 255;\r\n\r\nexport const BigNatModule_baseShift32B = 24;\r\n\r\nexport const BigNatModule_baseMask64A = 16777215;\r\n\r\nexport const BigNatModule_baseMask64B = 16777215;\r\n\r\nexport const BigNatModule_baseMask64C = 65535;\r\n\r\nexport const BigNatModule_baseShift64B = 24;\r\n\r\nexport const BigNatModule_baseShift64C = 48;\r\n\r\nexport function BigNatModule_divbase(x) {\r\n    return ~(~((x >>> 0) >>> BigNatModule_baseBits));\r\n}\r\n\r\nexport function BigNatModule_modbase(x) {\r\n    return x & BigNatModule_baseMask;\r\n}\r\n\r\nexport function BigNatModule_createN(b) {\r\n    return new BigNat(b, new Int32Array(b));\r\n}\r\n\r\nexport function BigNatModule_copyN(x) {\r\n    return new BigNat(x.bound, copy(x.digits));\r\n}\r\n\r\nexport function BigNatModule_normN(n) {\r\n    const findLeastBound = (na_mut, i_mut) => {\r\n        findLeastBound:\r\n        while (true) {\r\n            const na = na_mut, i = i_mut;\r\n            if ((i === -1) ? true : (na[i] !== 0)) {\r\n                return (i + 1) | 0;\r\n            }\r\n            else {\r\n                na_mut = na;\r\n                i_mut = (i - 1);\r\n                continue findLeastBound;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const bound = findLeastBound(n.digits, n.bound - 1) | 0;\r\n    n.bound = (bound | 0);\r\n    return n;\r\n}\r\n\r\nexport const BigNatModule_boundInt = 2;\r\n\r\nexport const BigNatModule_boundInt64 = 3;\r\n\r\nexport const BigNatModule_boundBase = 1;\r\n\r\nexport function BigNatModule_embed(x) {\r\n    const x_1 = ((x < 0) ? 0 : x) | 0;\r\n    if (x_1 < BigNatModule_baseN) {\r\n        const r = BigNatModule_createN(1);\r\n        r.digits[0] = (x_1 | 0);\r\n        return BigNatModule_normN(r);\r\n    }\r\n    else {\r\n        const r_1 = BigNatModule_createN(BigNatModule_boundInt);\r\n        for (let i = 0; i <= (BigNatModule_boundInt - 1); i++) {\r\n            r_1.digits[i] = (((~(~(x_1 / BigNatModule_pow32(BigNatModule_baseN, i)))) % BigNatModule_baseN) | 0);\r\n        }\r\n        return BigNatModule_normN(r_1);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_embed64(x) {\r\n    const x_1 = (compare(x, fromBits(0, 0, false)) < 0) ? fromBits(0, 0, false) : x;\r\n    const r = BigNatModule_createN(BigNatModule_boundInt64);\r\n    for (let i = 0; i <= (BigNatModule_boundInt64 - 1); i++) {\r\n        r.digits[i] = ((~(~toInt(op_Modulus(op_Division(x_1, BigNatModule_pow64(BigNatModule_baseNi64, i)), BigNatModule_baseNi64)))) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_eval32(n) {\r\n    if (n.bound === 1) {\r\n        return n.digits[0] | 0;\r\n    }\r\n    else {\r\n        let acc = 0;\r\n        for (let i = n.bound - 1; i >= 0; i--) {\r\n            acc = ((n.digits[i] + (BigNatModule_baseN * acc)) | 0);\r\n        }\r\n        return acc | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_eval64(n) {\r\n    if (n.bound === 1) {\r\n        return fromInteger(n.digits[0], false, 2);\r\n    }\r\n    else {\r\n        let acc = fromBits(0, 0, false);\r\n        for (let i = n.bound - 1; i >= 0; i--) {\r\n            acc = op_Addition(fromInteger(n.digits[i], false, 2), op_Multiply(BigNatModule_baseNi64, acc));\r\n        }\r\n        return acc;\r\n    }\r\n}\r\n\r\nexport const BigNatModule_one = BigNatModule_embed(1);\r\n\r\nexport const BigNatModule_zero = BigNatModule_embed(0);\r\n\r\nexport function BigNatModule_restrictTo(d, n) {\r\n    return new BigNat(BigNatModule_minInt(d, n.bound), n.digits);\r\n}\r\n\r\nexport function BigNatModule_shiftUp(d, n) {\r\n    const m = BigNatModule_createN(n.bound + d);\r\n    for (let i = 0; i <= (n.bound - 1); i++) {\r\n        m.digits[i + d] = (n.digits[i] | 0);\r\n    }\r\n    return m;\r\n}\r\n\r\nexport function BigNatModule_shiftDown(d, n) {\r\n    if ((n.bound - d) <= 0) {\r\n        return BigNatModule_zero;\r\n    }\r\n    else {\r\n        const m = BigNatModule_createN(n.bound - d);\r\n        for (let i = 0; i <= (m.bound - 1); i++) {\r\n            m.digits[i] = (n.digits[i + d] | 0);\r\n        }\r\n        return m;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_degree(n) {\r\n    return n.bound - 1;\r\n}\r\n\r\nexport function BigNatModule_addP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\r\n    let z, i_1, z_1, i_2;\r\n    BigNatModule_addP:\r\n    while (true) {\r\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\r\n        if (i < n) {\r\n            const x = ((((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0))) + ((z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0)))) + c) | 0;\r\n            r.digits[i] = (BigNatModule_modbase(x) | 0);\r\n            i_mut = (i + 1);\r\n            n_mut = n;\r\n            c_mut = BigNatModule_divbase(x);\r\n            p_mut = p;\r\n            q_mut = q;\r\n            r_mut = r;\r\n            continue BigNatModule_addP;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_add(p, q) {\r\n    const rbound = (1 + BigNatModule_maxInt(p.bound, q.bound)) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    BigNatModule_addP(0, rbound, 0, p, q, r);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_subP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\r\n    let z, i_1, z_1, i_2;\r\n    BigNatModule_subP:\r\n    while (true) {\r\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\r\n        if (i < n) {\r\n            const x = ((((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0))) - ((z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0)))) + c) | 0;\r\n            if (x > 0) {\r\n                r.digits[i] = (BigNatModule_modbase(x) | 0);\r\n                i_mut = (i + 1);\r\n                n_mut = n;\r\n                c_mut = BigNatModule_divbase(x);\r\n                p_mut = p;\r\n                q_mut = q;\r\n                r_mut = r;\r\n                continue BigNatModule_subP;\r\n            }\r\n            else {\r\n                const x_1 = (x + BigNatModule_baseN) | 0;\r\n                r.digits[i] = (BigNatModule_modbase(x_1) | 0);\r\n                i_mut = (i + 1);\r\n                n_mut = n;\r\n                c_mut = (BigNatModule_divbase(x_1) - 1);\r\n                p_mut = p;\r\n                q_mut = q;\r\n                r_mut = r;\r\n                continue BigNatModule_subP;\r\n            }\r\n        }\r\n        else {\r\n            return c !== 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_sub(p, q) {\r\n    const rbound = BigNatModule_maxInt(p.bound, q.bound) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    if (BigNatModule_subP(0, rbound, 0, p, q, r)) {\r\n        return BigNatModule_embed(0);\r\n    }\r\n    else {\r\n        return BigNatModule_normN(r);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_isZero(p) {\r\n    return p.bound === 0;\r\n}\r\n\r\nexport function BigNatModule_IsZero(p) {\r\n    return BigNatModule_isZero(p);\r\n}\r\n\r\nexport function BigNatModule_isOne(p) {\r\n    if (p.bound === 1) {\r\n        return p.digits[0] === 1;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_equal(p, q) {\r\n    if (p.bound === q.bound) {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return true;\r\n                }\r\n                else if (pa[i] === qa[i]) {\r\n                    pa_mut = pa;\r\n                    qa_mut = qa;\r\n                    i_mut = (i - 1);\r\n                    continue check;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, p.bound - 1);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_shiftCompare(p, pn, q, qn) {\r\n    if ((p.bound + pn) < (q.bound + qn)) {\r\n        return -1;\r\n    }\r\n    else if ((p.bound + pn) > (q.bound + pn)) {\r\n        return 1;\r\n    }\r\n    else {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return 0;\r\n                }\r\n                else {\r\n                    const pai = ((i < pn) ? 0 : pa[i - pn]) | 0;\r\n                    const qai = ((i < qn) ? 0 : qa[i - qn]) | 0;\r\n                    if (pai === qai) {\r\n                        pa_mut = pa;\r\n                        qa_mut = qa;\r\n                        i_mut = (i - 1);\r\n                        continue check;\r\n                    }\r\n                    else if (pai < qai) {\r\n                        return -1;\r\n                    }\r\n                    else {\r\n                        return 1;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, (p.bound + pn) - 1) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_compare(p, q) {\r\n    if (p.bound < q.bound) {\r\n        return -1;\r\n    }\r\n    else if (p.bound > q.bound) {\r\n        return 1;\r\n    }\r\n    else {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return 0;\r\n                }\r\n                else if (pa[i] === qa[i]) {\r\n                    pa_mut = pa;\r\n                    qa_mut = qa;\r\n                    i_mut = (i - 1);\r\n                    continue check;\r\n                }\r\n                else if (pa[i] < qa[i]) {\r\n                    return -1;\r\n                }\r\n                else {\r\n                    return 1;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, p.bound - 1) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_lt(p, q) {\r\n    return BigNatModule_compare(p, q) === -1;\r\n}\r\n\r\nexport function BigNatModule_gt(p, q) {\r\n    return BigNatModule_compare(p, q) === 1;\r\n}\r\n\r\nexport function BigNatModule_lte(p, q) {\r\n    return BigNatModule_compare(p, q) !== 1;\r\n}\r\n\r\nexport function BigNatModule_gte(p, q) {\r\n    return BigNatModule_compare(p, q) !== -1;\r\n}\r\n\r\nexport function BigNatModule_min(a, b) {\r\n    if (BigNatModule_lt(a, b)) {\r\n        return a;\r\n    }\r\n    else {\r\n        return b;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_max(a, b) {\r\n    if (BigNatModule_lt(a, b)) {\r\n        return b;\r\n    }\r\n    else {\r\n        return a;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_contributeArr(a_mut, i_mut, c_mut) {\r\n    BigNatModule_contributeArr:\r\n    while (true) {\r\n        const a = a_mut, i = i_mut, c = c_mut;\r\n        const x = op_Addition(fromInteger(a[i], false, 2), c);\r\n        const c_1 = op_Division(x, BigNatModule_baseNi64);\r\n        const x_3 = (~(~toInt(op_BitwiseAnd(x, BigNatModule_baseMaski64)))) | 0;\r\n        a[i] = (x_3 | 0);\r\n        if (compare(c_1, fromBits(0, 0, false)) > 0) {\r\n            a_mut = a;\r\n            i_mut = (i + 1);\r\n            c_mut = c_1;\r\n            continue BigNatModule_contributeArr;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_scale(k, p) {\r\n    const r = BigNatModule_createN(p.bound + BigNatModule_boundInt);\r\n    const k_1 = fromInteger(k, false, 2);\r\n    for (let i = 0; i <= (p.bound - 1); i++) {\r\n        BigNatModule_contributeArr(r.digits, i, op_Multiply(k_1, fromInteger(p.digits[i], false, 2)));\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookBothSmall(p, q) {\r\n    const r = BigNatModule_createN(2);\r\n    const rak = op_Multiply(fromInteger(p, false, 2), fromInteger(q, false, 2));\r\n    BigNatModule_setCoeff(r, 0, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n    BigNatModule_setCoeff(r, 1, ~(~toInt(op_Division(rak, BigNatModule_baseNi64))));\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookCarry(r_mut, c_mut, k_mut) {\r\n    BigNatModule_mulSchoolBookCarry:\r\n    while (true) {\r\n        const r = r_mut, c = c_mut, k = k_mut;\r\n        if (compare(c, fromBits(0, 0, false)) > 0) {\r\n            const rak = op_Addition(BigNatModule_coeff64(r, k), c);\r\n            BigNatModule_setCoeff(r, k, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n            r_mut = r;\r\n            c_mut = op_Division(rak, BigNatModule_baseNi64);\r\n            k_mut = (k + 1);\r\n            continue BigNatModule_mulSchoolBookCarry;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookOneSmall(p, q) {\r\n    const bp = BigNatModule_bound(p) | 0;\r\n    const r = BigNatModule_createN(bp + 1);\r\n    const q_1 = fromInteger(q, false, 2);\r\n    let c = fromBits(0, 0, false);\r\n    for (let i = 0; i <= (bp - 1); i++) {\r\n        const rak = op_Addition(op_Addition(c, BigNatModule_coeff64(r, i)), op_Multiply(BigNatModule_coeff64(p, i), q_1));\r\n        BigNatModule_setCoeff(r, i, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n        c = op_Division(rak, BigNatModule_baseNi64);\r\n    }\r\n    BigNatModule_mulSchoolBookCarry(r, c, bp);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookNeitherSmall(p, q) {\r\n    const r = BigNatModule_createN(p.bound + q.bound);\r\n    const ra = r.digits;\r\n    for (let i = 0; i <= (p.bound - 1); i++) {\r\n        const pai = fromInteger(p.digits[i], false, 2);\r\n        let c = fromBits(0, 0, false);\r\n        let k = i;\r\n        for (let j = 0; j <= (q.bound - 1); j++) {\r\n            const qaj = fromInteger(q.digits[j], false, 2);\r\n            const rak = op_Addition(op_Addition(fromInteger(ra[k], false, 2), c), op_Multiply(pai, qaj));\r\n            ra[k] = ((~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64)))) | 0);\r\n            c = op_Division(rak, BigNatModule_baseNi64);\r\n            k = ((k + 1) | 0);\r\n        }\r\n        BigNatModule_mulSchoolBookCarry(r, c, k);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBook(p, q) {\r\n    const pSmall = BigNatModule_bound(p) === 1;\r\n    const qSmall = BigNatModule_bound(q) === 1;\r\n    if (pSmall && qSmall) {\r\n        return BigNatModule_mulSchoolBookBothSmall(BigNatModule_coeff(p, 0), BigNatModule_coeff(q, 0));\r\n    }\r\n    else if (pSmall) {\r\n        return BigNatModule_mulSchoolBookOneSmall(q, BigNatModule_coeff(p, 0));\r\n    }\r\n    else if (qSmall) {\r\n        return BigNatModule_mulSchoolBookOneSmall(p, BigNatModule_coeff(q, 0));\r\n    }\r\n    else {\r\n        return BigNatModule_mulSchoolBookNeitherSmall(p, q);\r\n    }\r\n}\r\n\r\nexport class BigNatModule_encoding extends Record {\r\n    constructor(bigL, twoToBigL, k, bigK, bigN, split, splits) {\r\n        super();\r\n        this.bigL = (bigL | 0);\r\n        this.twoToBigL = (twoToBigL | 0);\r\n        this.k = (k | 0);\r\n        this.bigK = (bigK | 0);\r\n        this.bigN = (bigN | 0);\r\n        this.split = (split | 0);\r\n        this.splits = splits;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_encoding$reflection() {\r\n    return record_type(\"BigInt.BigNatModule.encoding\", [], BigNatModule_encoding, () => [[\"bigL\", int32_type], [\"twoToBigL\", int32_type], [\"k\", int32_type], [\"bigK\", int32_type], [\"bigN\", int32_type], [\"split\", int32_type], [\"splits\", array_type(int32_type)]]);\r\n}\r\n\r\nexport function BigNatModule_mkEncoding(bigL, k, bigK, bigN) {\r\n    return new BigNatModule_encoding(bigL, BigNatModule_pow32(2, bigL), k, bigK, bigN, ~(~(BigNatModule_baseBits / bigL)), initialize(~(~(BigNatModule_baseBits / bigL)), (i) => BigNatModule_pow32(2, bigL * i), Int32Array));\r\n}\r\n\r\nexport const BigNatModule_table = [BigNatModule_mkEncoding(1, 28, 268435456, 268435456), BigNatModule_mkEncoding(2, 26, 67108864, 134217728), BigNatModule_mkEncoding(3, 24, 16777216, 50331648), BigNatModule_mkEncoding(4, 22, 4194304, 16777216), BigNatModule_mkEncoding(5, 20, 1048576, 5242880), BigNatModule_mkEncoding(6, 18, 262144, 1572864), BigNatModule_mkEncoding(7, 16, 65536, 458752), BigNatModule_mkEncoding(8, 14, 16384, 131072), BigNatModule_mkEncoding(9, 12, 4096, 36864), BigNatModule_mkEncoding(10, 10, 1024, 10240), BigNatModule_mkEncoding(11, 8, 256, 2816), BigNatModule_mkEncoding(12, 6, 64, 768), BigNatModule_mkEncoding(13, 4, 16, 208)];\r\n\r\nexport function BigNatModule_calculateTableTow(bigL) {\r\n    const k = (BigNatModule_FFT_maxBitsInsideFp - (2 * bigL)) | 0;\r\n    const bigK = BigNatModule_pow64(fromBits(2, 0, false), k);\r\n    return [bigL, k, bigK, op_Multiply(bigK, fromInteger(bigL, false, 2))];\r\n}\r\n\r\nexport function BigNatModule_encodingGivenResultBits(bitsRes) {\r\n    const selectFrom = (i_mut) => {\r\n        selectFrom:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (((i + 1) < BigNatModule_table.length) && (bitsRes < BigNatModule_table[i + 1].bigN)) {\r\n                i_mut = (i + 1);\r\n                continue selectFrom;\r\n            }\r\n            else {\r\n                return BigNatModule_table[i];\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (bitsRes >= BigNatModule_table[0].bigN) {\r\n        throw (new Error(\"Product is huge, around 268435456 bits, beyond quickmul\"));\r\n    }\r\n    else {\r\n        return selectFrom(0);\r\n    }\r\n}\r\n\r\nexport const BigNatModule_bitmask = initialize(BigNatModule_baseBits, (i) => (BigNatModule_pow32(2, i) - 1), Int32Array);\r\n\r\nexport const BigNatModule_twopowers = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow32(2, i), Int32Array);\r\n\r\nexport const BigNatModule_twopowersI64 = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow64(fromBits(2, 0, false), i));\r\n\r\nexport function BigNatModule_wordBits(word) {\r\n    const hi = (k_mut) => {\r\n        hi:\r\n        while (true) {\r\n            const k = k_mut;\r\n            if (k === 0) {\r\n                return 0;\r\n            }\r\n            else if ((word & BigNatModule_twopowers[k - 1]) !== 0) {\r\n                return k | 0;\r\n            }\r\n            else {\r\n                k_mut = (k - 1);\r\n                continue hi;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return hi(BigNatModule_baseBits) | 0;\r\n}\r\n\r\nexport function BigNatModule_bits(u) {\r\n    if (u.bound === 0) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return ((BigNatModule_degree(u) * BigNatModule_baseBits) + BigNatModule_wordBits(u.digits[BigNatModule_degree(u)])) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_extractBits(n, enc, bi) {\r\n    let z, i, z_1, i_1, z_2, i_2;\r\n    const biw = (~(~(bi / BigNatModule_baseBits))) | 0;\r\n    const bjw = (~(~(((bi + enc.bigL) - 1) / BigNatModule_baseBits))) | 0;\r\n    if (biw !== bjw) {\r\n        const xbit = (bi % BigNatModule_baseBits) | 0;\r\n        return (((((z = n, (i = (biw | 0), (i < z.bound) ? z.digits[i] : 0))) >> xbit) | (((z_1 = n, (i_1 = (bjw | 0), (i_1 < z_1.bound) ? z_1.digits[i_1] : 0))) << (BigNatModule_baseBits - xbit))) & BigNatModule_bitmask[enc.bigL]) | 0;\r\n    }\r\n    else {\r\n        return ((((z_2 = n, (i_2 = (biw | 0), (i_2 < z_2.bound) ? z_2.digits[i_2] : 0))) >> (bi % BigNatModule_baseBits)) & BigNatModule_bitmask[enc.bigL]) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_encodePoly(enc, n) {\r\n    const poly = fill(new Uint32Array(enc.bigK), 0, enc.bigK, BigNatModule_FFT_Fp_ofInt32(0));\r\n    const biMax = (n.bound * BigNatModule_baseBits) | 0;\r\n    const encoder = (i_mut, bi_mut) => {\r\n        encoder:\r\n        while (true) {\r\n            const i = i_mut, bi = bi_mut;\r\n            if ((i === enc.bigK) ? true : (bi > biMax)) {\r\n            }\r\n            else {\r\n                const pi = BigNatModule_extractBits(n, enc, bi) | 0;\r\n                poly[i] = BigNatModule_FFT_Fp_ofInt32(pi);\r\n                i_mut = (i + 1);\r\n                bi_mut = (bi + enc.bigL);\r\n                continue encoder;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    encoder(0, 0);\r\n    return poly;\r\n}\r\n\r\nexport function BigNatModule_decodeResultBits(enc, poly) {\r\n    let n = 0;\r\n    for (let i = 0; i <= (poly.length - 1); i++) {\r\n        if (poly[i] !== BigNatModule_FFT_mzero) {\r\n            n = (i | 0);\r\n        }\r\n    }\r\n    return (((BigNatModule_FFT_maxBitsInsideFp + (enc.bigL * n)) + 1) + 1) | 0;\r\n}\r\n\r\nexport function BigNatModule_decodePoly(enc, poly) {\r\n    const rbound = ((~(~(BigNatModule_decodeResultBits(enc, poly) / BigNatModule_baseBits))) + 1) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    const evaluate = (i_mut, j_mut, d_mut) => {\r\n        evaluate:\r\n        while (true) {\r\n            const i = i_mut, j = j_mut, d = d_mut;\r\n            if (i === enc.bigK) {\r\n            }\r\n            else {\r\n                if (j >= rbound) {\r\n                }\r\n                else {\r\n                    BigNatModule_contributeArr(r.digits, j, op_Multiply(fromInteger(BigNatModule_FFT_Fp_toInt(poly[i]), false, 2), BigNatModule_twopowersI64[d]));\r\n                }\r\n                const d_1 = (d + enc.bigL) | 0;\r\n                const patternInput = (d_1 >= BigNatModule_baseBits) ? [j + 1, d_1 - BigNatModule_baseBits] : [j, d_1];\r\n                i_mut = (i + 1);\r\n                j_mut = patternInput[0];\r\n                d_mut = patternInput[1];\r\n                continue evaluate;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    evaluate(0, 0, 0);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_quickMulUsingFft(u, v) {\r\n    const enc = BigNatModule_encodingGivenResultBits(BigNatModule_bits(u) + BigNatModule_bits(v));\r\n    return BigNatModule_normN(BigNatModule_decodePoly(enc, BigNatModule_FFT_computeFftPaddedPolynomialProduct(enc.bigK, enc.k, BigNatModule_encodePoly(enc, u), BigNatModule_encodePoly(enc, v))));\r\n}\r\n\r\nexport const BigNatModule_minDigitsKaratsuba = 16;\r\n\r\nexport function BigNatModule_recMulKaratsuba(mul, p, q) {\r\n    const bmax = BigNatModule_maxInt(p.bound, q.bound) | 0;\r\n    if (bmax > BigNatModule_minDigitsKaratsuba) {\r\n        const k = (~(~(bmax / 2))) | 0;\r\n        const a0 = BigNatModule_restrictTo(k, p);\r\n        const a1 = BigNatModule_shiftDown(k, p);\r\n        const b0 = BigNatModule_restrictTo(k, q);\r\n        const b1 = BigNatModule_shiftDown(k, q);\r\n        const q0 = mul(a0, b0);\r\n        const q1 = mul(BigNatModule_add(a0, a1), BigNatModule_add(b0, b1));\r\n        const q2 = mul(a1, b1);\r\n        return BigNatModule_add(q0, BigNatModule_shiftUp(k, BigNatModule_add(BigNatModule_sub(q1, BigNatModule_add(q0, q2)), BigNatModule_shiftUp(k, q2))));\r\n    }\r\n    else {\r\n        return BigNatModule_mulSchoolBook(p, q);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_mulKaratsuba(x, y) {\r\n    return BigNatModule_recMulKaratsuba(BigNatModule_mulKaratsuba, x, y);\r\n}\r\n\r\nexport const BigNatModule_productDigitsUpperSchoolBook = ~(~(64000 / BigNatModule_baseBits));\r\n\r\nexport const BigNatModule_singleDigitForceSchoolBook = ~(~(32000 / BigNatModule_baseBits));\r\n\r\nexport const BigNatModule_productDigitsUpperFft = ~(~(BigNatModule_table[0].bigN / BigNatModule_baseBits));\r\n\r\nexport function BigNatModule_mul(p, q) {\r\n    return BigNatModule_mulSchoolBook(p, q);\r\n}\r\n\r\nexport function BigNatModule_scaleSubInPlace(x, f, a, n) {\r\n    const patternInput = [x.digits, BigNatModule_degree(x)];\r\n    const x_1 = patternInput[0];\r\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\r\n    const ad = patternInput_1[1] | 0;\r\n    const a_1 = patternInput_1[0];\r\n    const f_1 = fromInteger(f, false, 2);\r\n    let j = 0;\r\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\r\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\r\n        if (j > patternInput[1]) {\r\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\r\n        }\r\n        let zLo = ~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)));\r\n        let zHi = op_Division(z, BigNatModule_baseNi64);\r\n        if (zLo <= x_1[j + n]) {\r\n            x_1[j + n] = ((x_1[j + n] - zLo) | 0);\r\n        }\r\n        else {\r\n            x_1[j + n] = ((x_1[j + n] + (BigNatModule_baseN - zLo)) | 0);\r\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\r\n        }\r\n        if (j < ad) {\r\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\r\n        }\r\n        else {\r\n            z = zHi;\r\n        }\r\n        j = ((j + 1) | 0);\r\n    }\r\n    BigNatModule_normN(x);\r\n}\r\n\r\nexport function BigNatModule_scaleSub(x, f, a, n) {\r\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\r\n    BigNatModule_scaleSubInPlace(freshx, f, a, n);\r\n    return BigNatModule_normN(freshx);\r\n}\r\n\r\nexport function BigNatModule_scaleAddInPlace(x, f, a, n) {\r\n    const patternInput = [x.digits, BigNatModule_degree(x)];\r\n    const x_1 = patternInput[0];\r\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\r\n    const ad = patternInput_1[1] | 0;\r\n    const a_1 = patternInput_1[0];\r\n    const f_1 = fromInteger(f, false, 2);\r\n    let j = 0;\r\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\r\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\r\n        if (j > patternInput[1]) {\r\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\r\n        }\r\n        let zLo = ~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)));\r\n        let zHi = op_Division(z, BigNatModule_baseNi64);\r\n        if (zLo < (BigNatModule_baseN - x_1[j + n])) {\r\n            x_1[j + n] = ((x_1[j + n] + zLo) | 0);\r\n        }\r\n        else {\r\n            x_1[j + n] = ((zLo - (BigNatModule_baseN - x_1[j + n])) | 0);\r\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\r\n        }\r\n        if (j < ad) {\r\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\r\n        }\r\n        else {\r\n            z = zHi;\r\n        }\r\n        j = ((j + 1) | 0);\r\n    }\r\n    BigNatModule_normN(x);\r\n}\r\n\r\nexport function BigNatModule_scaleAdd(x, f, a, n) {\r\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\r\n    BigNatModule_scaleAddInPlace(freshx, f, a, n);\r\n    return BigNatModule_normN(freshx);\r\n}\r\n\r\nexport function BigNatModule_removeFactor(x, a, n) {\r\n    const patternInput = [BigNatModule_degree(a), BigNatModule_degree(x)];\r\n    const degx = patternInput[1] | 0;\r\n    const dega = patternInput[0] | 0;\r\n    if (degx < (dega + n)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        const patternInput_1 = [a.digits, x.digits];\r\n        const xa = patternInput_1[1];\r\n        const aa = patternInput_1[0];\r\n        const f = ((dega === 0) ? ((degx === n) ? (~(~(xa[n] / aa[0]))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), fromInteger(aa[0], false, 2)))))) : ((degx === (dega + n)) ? (~(~(xa[degx] / (aa[dega] + 1)))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), op_Addition(fromInteger(aa[dega], false, 2), fromBits(1, 0, false)))))))) | 0;\r\n        if (f === 0) {\r\n            if (BigNatModule_shiftCompare(a, n, x, 0) !== 1) {\r\n                return 1;\r\n            }\r\n            else {\r\n                return 0;\r\n            }\r\n        }\r\n        else {\r\n            return f | 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_divmod(b, a) {\r\n    if (BigNatModule_isZero(a)) {\r\n        throw (new Error());\r\n    }\r\n    else if (BigNatModule_degree(b) < BigNatModule_degree(a)) {\r\n        return [BigNatModule_zero, b];\r\n    }\r\n    else {\r\n        const x = BigNatModule_copyN(b);\r\n        const d = BigNatModule_createN(((BigNatModule_degree(b) - BigNatModule_degree(a)) + 1) + 1);\r\n        let p = BigNatModule_degree(b);\r\n        const m = BigNatModule_degree(a) | 0;\r\n        let n = p - m;\r\n        const Invariant = (tupledArg) => {\r\n        };\r\n        let finished = false;\r\n        while (!finished) {\r\n            Invariant([d, x, n, p]);\r\n            const f = BigNatModule_removeFactor(x, a, n) | 0;\r\n            if (f > 0) {\r\n                BigNatModule_scaleSubInPlace(x, f, a, n);\r\n                BigNatModule_scaleAddInPlace(d, f, BigNatModule_one, n);\r\n                Invariant([d, x, n, p]);\r\n            }\r\n            else {\r\n                finished = ((f === 0) && (n === 0));\r\n                if (!finished) {\r\n                    if (p === (m + n)) {\r\n                        Invariant([d, x, n - 1, p]);\r\n                        n = ((n - 1) | 0);\r\n                    }\r\n                    else {\r\n                        Invariant([d, x, n - 1, p - 1]);\r\n                        n = ((n - 1) | 0);\r\n                        p = ((p - 1) | 0);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return [BigNatModule_normN(d), BigNatModule_normN(x)];\r\n    }\r\n}\r\n\r\nexport function BigNatModule_div(b, a) {\r\n    return BigNatModule_divmod(b, a)[0];\r\n}\r\n\r\nexport function BigNatModule_rem(b, a) {\r\n    return BigNatModule_divmod(b, a)[1];\r\n}\r\n\r\nexport function BigNatModule_bitAnd(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_minInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (r.bound - 1); i++) {\r\n        r.digits[i] = ((a.digits[i] & b.digits[i]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_bitOr(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (a.bound - 1); i++) {\r\n        r.digits[i] = ((r.digits[i] | a.digits[i]) | 0);\r\n    }\r\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\r\n        r.digits[i_1] = ((r.digits[i_1] | b.digits[i_1]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_bitXor(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (a.bound - 1); i++) {\r\n        r.digits[i] = ((r.digits[i] ^ a.digits[i]) | 0);\r\n    }\r\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\r\n        r.digits[i_1] = ((r.digits[i_1] ^ b.digits[i_1]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_hcf(a, b) {\r\n    const hcfloop = (a_1_mut, b_1_mut) => {\r\n        hcfloop:\r\n        while (true) {\r\n            const a_1 = a_1_mut, b_1 = b_1_mut;\r\n            if (BigNatModule_equal(BigNatModule_zero, a_1)) {\r\n                return b_1;\r\n            }\r\n            else {\r\n                a_1_mut = BigNatModule_divmod(b_1, a_1)[1];\r\n                b_1_mut = a_1;\r\n                continue hcfloop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (BigNatModule_lt(a, b)) {\r\n        return hcfloop(a, b);\r\n    }\r\n    else {\r\n        return hcfloop(b, a);\r\n    }\r\n}\r\n\r\nexport const BigNatModule_two = BigNatModule_embed(2);\r\n\r\nexport function BigNatModule_powi(x, n) {\r\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\r\n        power:\r\n        while (true) {\r\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\r\n            if (n_1 === 0) {\r\n                return acc;\r\n            }\r\n            else if ((n_1 % 2) === 0) {\r\n                acc_mut = acc;\r\n                x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                n_1_mut = (~(~(n_1 / 2)));\r\n                continue power;\r\n            }\r\n            else {\r\n                acc_mut = BigNatModule_mul(x_1, acc);\r\n                x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                n_1_mut = (~(~(n_1 / 2)));\r\n                continue power;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return power(BigNatModule_one, x, n);\r\n}\r\n\r\nexport function BigNatModule_pow(x, n) {\r\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\r\n        power:\r\n        while (true) {\r\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\r\n            if (BigNatModule_isZero(n_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                const patternInput = BigNatModule_divmod(n_1, BigNatModule_two);\r\n                const ndiv2 = patternInput[0];\r\n                if (BigNatModule_isZero(patternInput[1])) {\r\n                    acc_mut = acc;\r\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                    n_1_mut = ndiv2;\r\n                    continue power;\r\n                }\r\n                else {\r\n                    acc_mut = BigNatModule_mul(x_1, acc);\r\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                    n_1_mut = ndiv2;\r\n                    continue power;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return power(BigNatModule_one, x, n);\r\n}\r\n\r\nexport function BigNatModule_toFloat(n) {\r\n    const evalFloat = (acc_mut, k_mut, i_mut) => {\r\n        evalFloat:\r\n        while (true) {\r\n            const acc = acc_mut, k = k_mut, i = i_mut;\r\n            if (i === n.bound) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = (acc + (k * n.digits[i]));\r\n                k_mut = (k * BigNatModule_baseN);\r\n                i_mut = (i + 1);\r\n                continue evalFloat;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return evalFloat(0, 1, 0);\r\n}\r\n\r\nexport function BigNatModule_ofInt32(n) {\r\n    return BigNatModule_embed(n);\r\n}\r\n\r\nexport function BigNatModule_ofInt64(n) {\r\n    return BigNatModule_embed64(n);\r\n}\r\n\r\nexport function BigNatModule_toUInt32(n) {\r\n    const matchValue = n.bound | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return 0;\r\n        }\r\n        case 1: {\r\n            const value = n.digits[0] | 0;\r\n            return value >>> 0;\r\n        }\r\n        case 2: {\r\n            const patternInput = [n.digits[0], n.digits[1]];\r\n            const xB = patternInput[1] | 0;\r\n            if (xB > BigNatModule_baseMask32B) {\r\n                throw (new Error());\r\n            }\r\n            return ((patternInput[0] & BigNatModule_baseMask32A) >>> 0) + ((((xB & BigNatModule_baseMask32B) >>> 0) << BigNatModule_baseShift32B) >>> 0);\r\n        }\r\n        default: {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_toUInt64(n) {\r\n    const matchValue = n.bound | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return fromBits(0, 0, true);\r\n        }\r\n        case 1: {\r\n            return fromInteger(n.digits[0], true, 2);\r\n        }\r\n        case 2: {\r\n            const patternInput = [n.digits[0], n.digits[1]];\r\n            return op_Addition(fromInteger(patternInput[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B));\r\n        }\r\n        case 3: {\r\n            const patternInput_1 = [n.digits[0], n.digits[1], n.digits[2]];\r\n            const xC = patternInput_1[2] | 0;\r\n            if (xC > BigNatModule_baseMask64C) {\r\n                throw (new Error());\r\n            }\r\n            return op_Addition(op_Addition(fromInteger(patternInput_1[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput_1[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B)), op_LeftShift(fromInteger(xC & BigNatModule_baseMask64C, true, 2), BigNatModule_baseShift64C));\r\n        }\r\n        default: {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_toString(n) {\r\n    const degn = BigNatModule_degree(n) | 0;\r\n    const route = (prior_mut, k_mut, ten2k_mut) => {\r\n        route:\r\n        while (true) {\r\n            const prior = prior_mut, k = k_mut, ten2k = ten2k_mut;\r\n            if (BigNatModule_degree(ten2k) > degn) {\r\n                return cons([k, ten2k], prior);\r\n            }\r\n            else {\r\n                prior_mut = cons([k, ten2k], prior);\r\n                k_mut = (k + 1);\r\n                ten2k_mut = BigNatModule_mul(ten2k, ten2k);\r\n                continue route;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const collect = (isLeading_mut, digits_mut, n_1_mut, _arg1_mut) => {\r\n        collect:\r\n        while (true) {\r\n            const isLeading = isLeading_mut, digits = digits_mut, n_1 = n_1_mut, _arg1 = _arg1_mut;\r\n            if (!isEmpty(_arg1)) {\r\n                const prior_1 = tail(_arg1);\r\n                const patternInput = BigNatModule_divmod(n_1, head(_arg1)[1]);\r\n                const nL = patternInput[1];\r\n                const nH = patternInput[0];\r\n                if (isLeading && BigNatModule_isZero(nH)) {\r\n                    isLeading_mut = isLeading;\r\n                    digits_mut = digits;\r\n                    n_1_mut = nL;\r\n                    _arg1_mut = prior_1;\r\n                    continue collect;\r\n                }\r\n                else {\r\n                    isLeading_mut = isLeading;\r\n                    digits_mut = collect(false, digits, nL, prior_1);\r\n                    n_1_mut = nH;\r\n                    _arg1_mut = prior_1;\r\n                    continue collect;\r\n                }\r\n            }\r\n            else {\r\n                const n_2 = BigNatModule_eval32(n_1) | 0;\r\n                if (isLeading && (n_2 === 0)) {\r\n                    return digits;\r\n                }\r\n                else {\r\n                    return cons(int32ToString(n_2), digits);\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const digits_4 = collect(true, empty(), n, route(empty(), 0, BigNatModule_embed(10)));\r\n    if (isEmpty(digits_4)) {\r\n        return \"0\";\r\n    }\r\n    else {\r\n        return join(\"\", toArray(digits_4));\r\n    }\r\n}\r\n\r\nexport function BigNatModule_ofString(str) {\r\n    const len = str.length | 0;\r\n    if (isNullOrEmpty(str)) {\r\n        throw (new Error(\"empty string\\\\nParameter name: str\"));\r\n    }\r\n    const ten = BigNatModule_embed(10);\r\n    const build = (acc_mut, i_mut) => {\r\n        build:\r\n        while (true) {\r\n            const acc = acc_mut, i = i_mut;\r\n            if (i === len) {\r\n                return acc;\r\n            }\r\n            else {\r\n                const c = str[i];\r\n                const d = (c.charCodeAt(0) - 48) | 0;\r\n                if ((0 <= d) && (d <= 9)) {\r\n                    acc_mut = BigNatModule_add(BigNatModule_mul(ten, acc), BigNatModule_embed(d));\r\n                    i_mut = (i + 1);\r\n                    continue build;\r\n                }\r\n                else {\r\n                    throw (new Error());\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return build(BigNatModule_embed(0), 0);\r\n}\r\n\r\nexport function BigNatModule_isSmall(n) {\r\n    return n.bound <= 1;\r\n}\r\n\r\nexport function BigNatModule_getSmall(n) {\r\n    const z = n;\r\n    const i = 0;\r\n    if (i < z.bound) {\r\n        return z.digits[i] | 0;\r\n    }\r\n    else {\r\n        return 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_factorial(n) {\r\n    const productR = (a, b) => {\r\n        if (BigNatModule_equal(a, b)) {\r\n            return a;\r\n        }\r\n        else {\r\n            const m = BigNatModule_div(BigNatModule_add(a, b), BigNatModule_ofInt32(2));\r\n            return BigNatModule_mul(productR(a, m), productR(BigNatModule_add(m, BigNatModule_one), b));\r\n        }\r\n    };\r\n    return productR(BigNatModule_one, n);\r\n}\r\n\r\n","import { BigNatModule_factorial, BigNatModule_ofString, BigNatModule_toFloat, BigNatModule_toUInt64, BigNatModule_toUInt32, BigNatModule_pow, BigNatModule_two, BigNatModule_rem, BigNatModule_lte, BigNatModule_hcf, BigNatModule_bitXor, BigNatModule_bitOr, BigNatModule_bitAnd, BigNatModule_divmod, BigNatModule_mul, BigNatModule_isOne, BigNatModule_sub, BigNatModule_gte, BigNatModule_scale, BigNatModule_one, BigNatModule_add, BigNatModule_ofInt64, BigNatModule_hash, BigNatModule_gt, BigNatModule_lt, BigNatModule_equal, BigNatModule_getSmall, BigNatModule_isSmall, BigNatModule_ofInt32, BigNatModule_toString, BigNatModule_isZero } from \"./n.js\";\r\nimport { Record, toString } from \"../Types.js\";\r\nimport { class_type } from \"../Reflection.js\";\r\nimport { initialize } from \"../Array.js\";\r\nimport { op_Addition, op_Multiply, fromValue, equals, fromBits, compare, fromInteger, op_UnaryNegation } from \"../Long.js\";\r\nimport { op_UnaryNegation_Int32 } from \"../Int32.js\";\r\nimport Decimal from \"../Decimal.js\";\r\n\r\nexport class BigInteger extends Record {\r\n    constructor(signInt, v) {\r\n        super();\r\n        this.signInt = (signInt | 0);\r\n        this.v = v;\r\n    }\r\n    toString() {\r\n        const x = this;\r\n        const matchValue = BigInteger__get_SignInt(x) | 0;\r\n        switch (matchValue) {\r\n            case -1: {\r\n                return BigNatModule_isZero(BigInteger__get_V(x)) ? \"0\" : (\"-\" + BigNatModule_toString(BigInteger__get_V(x)));\r\n            }\r\n            case 0: {\r\n                return \"0\";\r\n            }\r\n            case 1: {\r\n                return BigNatModule_toString(BigInteger__get_V(x));\r\n            }\r\n            default: {\r\n                throw (new Error(\"signs should be +/- 1 or 0\"));\r\n            }\r\n        }\r\n    }\r\n    Equals(obj) {\r\n        const this$ = this;\r\n        return (obj instanceof BigInteger) && BigInteger_op_Equality_56F059C0(this$, obj);\r\n    }\r\n    GetHashCode() {\r\n        const x = this;\r\n        return BigInteger_hash_Z665282C2(x) | 0;\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return toString(this$);\r\n    }\r\n    CompareTo(obj) {\r\n        const this$ = this;\r\n        if (obj instanceof BigInteger) {\r\n            return BigInteger_compare_56F059C0(this$, obj) | 0;\r\n        }\r\n        else {\r\n            throw (new Error(\"the objects are not comparable\\\\nParameter name: obj\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger$reflection() {\r\n    return class_type(\"BigInt.BigInteger\", void 0, BigInteger, class_type(\"System.ValueType\"));\r\n}\r\n\r\nexport function BigInteger_$ctor_Z2BE94A1(signInt, v) {\r\n    return new BigInteger(signInt, v);\r\n}\r\n\r\n(() => {\r\n    BigInteger.smallLim = 4096;\r\n    BigInteger.smallPosTab = initialize(BigInteger.smallLim, BigNatModule_ofInt32);\r\n    BigInteger.one = BigInteger_$ctor_Z524259A4(1);\r\n    BigInteger.two = BigInteger_$ctor_Z524259A4(2);\r\n    BigInteger.zero = BigInteger_$ctor_Z524259A4(0);\r\n})();\r\n\r\nexport function BigInteger_nat_Z67CCE57D(n) {\r\n    if (BigNatModule_isSmall(n) && (BigNatModule_getSmall(n) < BigInteger.smallLim)) {\r\n        return BigInteger.smallPosTab[BigNatModule_getSmall(n)];\r\n    }\r\n    else {\r\n        return n;\r\n    }\r\n}\r\n\r\nexport function BigInteger_create_Z2BE94A1(s, n) {\r\n    return BigInteger_$ctor_Z2BE94A1(s, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger_posn_Z67CCE57D(n) {\r\n    return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger_negn_Z67CCE57D(n) {\r\n    return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger__get_Sign(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return x.signInt | 0;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_SignInt(x) {\r\n    return x.signInt;\r\n}\r\n\r\nexport function BigInteger__get_V(x) {\r\n    return x.v;\r\n}\r\n\r\nexport function BigInteger_op_Equality_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 2: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 3: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 6: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 7: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 8: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Inequality_56F059C0(x, y) {\r\n    return !BigInteger_op_Equality_56F059C0(x, y);\r\n}\r\n\r\nexport function BigInteger_op_LessThan_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_lt(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_lt(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            return false;\r\n        }\r\n        case 3: {\r\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return true;\r\n            }\r\n            else {\r\n                return !BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n        }\r\n        case 4: {\r\n            return false;\r\n        }\r\n        case 5: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 6: {\r\n            return false;\r\n        }\r\n        case 7: {\r\n            return false;\r\n        }\r\n        case 8: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_GreaterThan_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_gt(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_gt(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return true;\r\n            }\r\n            else {\r\n                return !BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n        }\r\n        case 3: {\r\n            return false;\r\n        }\r\n        case 4: {\r\n            return false;\r\n        }\r\n        case 5: {\r\n            return false;\r\n        }\r\n        case 6: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 7: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 8: {\r\n            return false;\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_compare_56F059C0(n, nn) {\r\n    if (BigInteger_op_LessThan_56F059C0(n, nn)) {\r\n        return -1;\r\n    }\r\n    else if (BigInteger_op_Equality_56F059C0(n, nn)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return 1;\r\n    }\r\n}\r\n\r\nexport function BigInteger_hash_Z665282C2(z) {\r\n    if (BigInteger__get_SignInt(z) === 0) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return (BigInteger__get_SignInt(z) + BigNatModule_hash(BigInteger__get_V(z))) | 0;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_StructuredDisplayString(x) {\r\n    return toString(x);\r\n}\r\n\r\nexport function BigInteger_$ctor_Z524259A4(n) {\r\n    if (n >= 0) {\r\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(n)));\r\n    }\r\n    else if (n === -2147483648) {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(fromInteger(n, false, 2)))));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(op_UnaryNegation_Int32(n))));\r\n    }\r\n}\r\n\r\nexport function BigInteger_$ctor_Z524259C1(n) {\r\n    if (compare(n, fromBits(0, 0, false)) >= 0) {\r\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(n)));\r\n    }\r\n    else if (equals(n, fromBits(0, 2147483648, false))) {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_add(BigNatModule_ofInt64(fromBits(4294967295, 2147483647, false)), BigNatModule_one)));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(n))));\r\n    }\r\n}\r\n\r\nexport function BigInteger_get_One() {\r\n    return BigInteger.one;\r\n}\r\n\r\nexport function BigInteger_get_Two() {\r\n    return BigInteger.two;\r\n}\r\n\r\nexport function BigInteger_get_Zero() {\r\n    return BigInteger.zero;\r\n}\r\n\r\nexport function BigInteger_op_UnaryNegation_Z665282C2(z) {\r\n    const matchValue = BigInteger__get_SignInt(z) | 0;\r\n    if (matchValue === 0) {\r\n        return BigInteger_get_Zero();\r\n    }\r\n    else {\r\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(matchValue), BigInteger__get_V(z));\r\n    }\r\n}\r\n\r\nexport function BigInteger_Scale_Z320F31E(k, z) {\r\n    if (BigInteger__get_SignInt(z) === 0) {\r\n        return BigInteger_get_Zero();\r\n    }\r\n    else if (k < 0) {\r\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(BigInteger__get_SignInt(z)), BigNatModule_scale(op_UnaryNegation_Int32(k), BigInteger__get_V(z)));\r\n    }\r\n    else {\r\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(z), BigNatModule_scale(k, BigInteger__get_V(z)));\r\n    }\r\n}\r\n\r\nexport function BigInteger_subnn_6A57060(nx, ny) {\r\n    if (BigNatModule_gte(nx, ny)) {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_sub(nx, ny));\r\n    }\r\n    else {\r\n        return BigInteger_negn_Z67CCE57D(BigNatModule_sub(ny, nx));\r\n    }\r\n}\r\n\r\nexport function BigInteger_addnn_6A57060(nx, ny) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_add(nx, ny));\r\n}\r\n\r\nexport function BigInteger__get_IsZero(x) {\r\n    if (BigInteger__get_SignInt(x) === 0) {\r\n        return true;\r\n    }\r\n    else {\r\n        return BigNatModule_isZero(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsOne(x) {\r\n    if (BigInteger__get_SignInt(x) === 1) {\r\n        return BigNatModule_isOne(BigInteger__get_V(x));\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Addition_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(x)) {\r\n        return y;\r\n    }\r\n    else {\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 1: {\r\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n            }\r\n            case 2: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 3: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Subtraction_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(x)) {\r\n        return BigInteger_op_UnaryNegation_Z665282C2(y);\r\n    }\r\n    else {\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 1: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\r\n            }\r\n            case 2: {\r\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 3: {\r\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Multiply_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(y)) {\r\n        return y;\r\n    }\r\n    else if (BigInteger__get_IsOne(x)) {\r\n        return y;\r\n    }\r\n    else if (BigInteger__get_IsOne(y)) {\r\n        return x;\r\n    }\r\n    else {\r\n        const m = BigNatModule_mul(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(x) * BigInteger__get_SignInt(y), m);\r\n    }\r\n}\r\n\r\nexport function BigInteger_DivRem_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        throw (new Error());\r\n    }\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return [BigInteger_get_Zero(), BigInteger_get_Zero()];\r\n    }\r\n    else {\r\n        const patternInput = BigNatModule_divmod(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        const r = patternInput[1];\r\n        const d = patternInput[0];\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\r\n            }\r\n            case 1: {\r\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\r\n            }\r\n            case 2: {\r\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\r\n            }\r\n            case 3: {\r\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Division_56F059C0(x, y) {\r\n    return BigInteger_DivRem_56F059C0(x, y)[0];\r\n}\r\n\r\nexport function BigInteger_op_Modulus_56F059C0(x, y) {\r\n    return BigInteger_DivRem_56F059C0(x, y)[1];\r\n}\r\n\r\nexport function BigInteger_op_RightShift_62E082A2(x, y) {\r\n    return BigInteger_op_Division_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\r\n}\r\n\r\nexport function BigInteger_op_LeftShift_62E082A2(x, y) {\r\n    return BigInteger_op_Multiply_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\r\n}\r\n\r\nexport function BigInteger_op_BitwiseAnd_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitAnd(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_op_BitwiseOr_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitOr(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_op_ExclusiveOr_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitXor(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_GreatestCommonDivisor_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    if (matchValue[0] === 0) {\r\n        if (matchValue[1] === 0) {\r\n            return BigInteger_get_Zero();\r\n        }\r\n        else {\r\n            return BigInteger_posn_Z67CCE57D(BigInteger__get_V(y));\r\n        }\r\n    }\r\n    else if (matchValue[1] === 0) {\r\n        return BigInteger_posn_Z67CCE57D(BigInteger__get_V(x));\r\n    }\r\n    else {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_hcf(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsNegative(x) {\r\n    if (BigInteger__get_SignInt(x) === -1) {\r\n        return !BigInteger__get_IsZero(x);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsPositive(x) {\r\n    if (BigInteger__get_SignInt(x) === 1) {\r\n        return !BigInteger__get_IsZero(x);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger_Abs_Z665282C2(x) {\r\n    if (BigInteger__get_SignInt(x) === -1) {\r\n        return BigInteger_op_UnaryNegation_Z665282C2(x);\r\n    }\r\n    else {\r\n        return x;\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_LessThanOrEqual_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_lte(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_lte(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 3: {\r\n            return true;\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 6: {\r\n            return true;\r\n        }\r\n        case 7: {\r\n            return true;\r\n        }\r\n        case 8: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_GreaterThanOrEqual_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_gte(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_gte(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            return true;\r\n        }\r\n        case 3: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return true;\r\n        }\r\n        case 6: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 7: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 8: {\r\n            return true;\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_Pow_62E082A2(x, y) {\r\n    if (y < 0) {\r\n        throw (new Error(\"y\"));\r\n    }\r\n    const matchValue = [BigInteger__get_IsZero(x), y];\r\n    if (matchValue[0]) {\r\n        if (matchValue[1] === 0) {\r\n            return BigInteger_get_One();\r\n        }\r\n        else {\r\n            return BigInteger_get_Zero();\r\n        }\r\n    }\r\n    else {\r\n        const yval = BigInteger_$ctor_Z524259A4(y);\r\n        return BigInteger_create_Z2BE94A1(BigNatModule_isZero(BigNatModule_rem(BigInteger__get_V(yval), BigNatModule_two)) ? 1 : BigInteger__get_SignInt(x), BigNatModule_pow(BigInteger__get_V(x), BigInteger__get_V(yval)));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToInt32(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        const u = BigNatModule_toUInt32(BigInteger__get_V(x));\r\n        if (u <= (2147483647 >>> 0)) {\r\n            return (BigInteger__get_SignInt(x) * (~(~u))) | 0;\r\n        }\r\n        else if ((BigInteger__get_SignInt(x) === -1) && (u === ((2147483647 + 1) >>> 0))) {\r\n            return -2147483648;\r\n        }\r\n        else {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToUInt32(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return BigNatModule_toUInt32(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToInt64(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return fromBits(0, 0, false);\r\n    }\r\n    else {\r\n        const u = BigNatModule_toUInt64(BigInteger__get_V(x));\r\n        if (compare(u, fromValue(fromBits(4294967295, 2147483647, false), true)) <= 0) {\r\n            return op_Multiply(fromInteger(BigInteger__get_SignInt(x), false, 2), fromValue(u, false));\r\n        }\r\n        else if ((BigInteger__get_SignInt(x) === -1) && equals(u, fromValue(op_Addition(fromBits(4294967295, 2147483647, false), fromBits(1, 0, false)), true))) {\r\n            return fromBits(0, 2147483648, false);\r\n        }\r\n        else {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToUInt64(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return fromBits(0, 0, true);\r\n    }\r\n    else {\r\n        return BigNatModule_toUInt64(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToDouble(x) {\r\n    const matchValue = BigInteger__get_SignInt(x) | 0;\r\n    switch (matchValue) {\r\n        case -1: {\r\n            return -BigNatModule_toFloat(BigInteger__get_V(x));\r\n        }\r\n        case 0: {\r\n            return 0;\r\n        }\r\n        case 1: {\r\n            return BigNatModule_toFloat(BigInteger__get_V(x));\r\n        }\r\n        default: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToSByte(x) {\r\n    return (BigInteger__get_ToInt32(x) + 0x80 & 0xFF) - 0x80;\r\n}\r\n\r\nexport function BigInteger__get_ToByte(x) {\r\n    return BigInteger__get_ToUInt32(x) & 0xFF;\r\n}\r\n\r\nexport function BigInteger__get_ToInt16(x) {\r\n    return (BigInteger__get_ToInt32(x) + 0x8000 & 0xFFFF) - 0x8000;\r\n}\r\n\r\nexport function BigInteger__get_ToUInt16(x) {\r\n    return BigInteger__get_ToUInt32(x) & 0xFFFF;\r\n}\r\n\r\nexport function BigInteger__get_ToSingle(x) {\r\n    return BigInteger__get_ToDouble(x);\r\n}\r\n\r\nexport function BigInteger__get_ToDecimal(x) {\r\n    return new Decimal(BigInteger__get_ToDouble(x));\r\n}\r\n\r\nexport function BigInteger_Parse_Z721C83C5(text) {\r\n    if (text == null) {\r\n        throw (new Error(\"text\"));\r\n    }\r\n    const text_1 = text.trim();\r\n    const len = text_1.length | 0;\r\n    if (len === 0) {\r\n        throw (new Error());\r\n    }\r\n    const matchValue = [text_1[0], len];\r\n    if (matchValue[0] === \"+\") {\r\n        if (matchValue[1] === 1) {\r\n            throw (new Error());\r\n        }\r\n        else {\r\n            return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\r\n        }\r\n    }\r\n    else if (matchValue[0] === \"-\") {\r\n        if (matchValue[1] === 1) {\r\n            throw (new Error());\r\n        }\r\n        else {\r\n            return BigInteger_negn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\r\n        }\r\n    }\r\n    else {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsSmall(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return true;\r\n    }\r\n    else {\r\n        return BigNatModule_isSmall(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger_Factorial_Z665282C2(x) {\r\n    if (BigInteger__get_IsNegative(x)) {\r\n        throw (new Error(\"mustBeNonNegative\\\\nParameter name: x\"));\r\n    }\r\n    if (BigInteger__get_IsPositive(x)) {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_factorial(BigInteger__get_V(x)));\r\n    }\r\n    else {\r\n        return BigInteger_get_One();\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_UnaryPlus_Z665282C2(n1) {\r\n    return n1;\r\n}\r\n\r\nexport function BigInteger_FromInt64_Z524259C1(x) {\r\n    return BigInteger_$ctor_Z524259C1(x);\r\n}\r\n\r\nexport function BigInteger_FromInt32_Z524259A4(x) {\r\n    return BigInteger_$ctor_Z524259A4(x);\r\n}\r\n\r\n","import { BigInteger_op_Inequality_56F059C0, BigInteger_op_Equality_56F059C0, BigInteger_op_GreaterThanOrEqual_56F059C0, BigInteger_op_GreaterThan_56F059C0, BigInteger_op_LessThanOrEqual_56F059C0, BigInteger_op_LessThan_56F059C0, BigInteger_op_ExclusiveOr_56F059C0, BigInteger_op_BitwiseOr_56F059C0, BigInteger_op_BitwiseAnd_56F059C0, BigInteger_op_LeftShift_62E082A2, BigInteger_op_RightShift_62E082A2, BigInteger_op_UnaryPlus_Z665282C2, BigInteger_op_UnaryNegation_Z665282C2, BigInteger_op_Modulus_56F059C0, BigInteger_op_Division_56F059C0, BigInteger_op_Multiply_56F059C0, BigInteger_op_Subtraction_56F059C0, BigInteger_op_Addition_56F059C0, BigInteger__get_IsOne, BigInteger__get_IsZero, BigInteger__get_Sign, BigInteger__get_ToDecimal, BigInteger__get_ToDouble, BigInteger__get_ToSingle, BigInteger__get_ToUInt64, BigInteger__get_ToInt64, BigInteger__get_ToUInt32, BigInteger__get_ToInt32, BigInteger__get_ToUInt16, BigInteger__get_ToInt16, BigInteger__get_ToByte, BigInteger__get_ToSByte, BigInteger_$ctor_Z524259A4, BigInteger_$ctor_Z524259C1, BigInteger_get_Two, BigInteger_get_One, BigInteger_get_Zero, BigInteger_Abs_Z665282C2, BigInteger_Pow_62E082A2, BigInteger_GreatestCommonDivisor_56F059C0, BigInteger_DivRem_56F059C0, BigInteger_Parse_Z721C83C5, BigInteger } from \"./BigInt/z.js\";\r\nimport { fromInteger } from \"./Long.js\";\r\nimport { comparePrimitives, min, compare as compare_1, equals as equals_1, safeHash } from \"./Util.js\";\r\nimport { toString as toString_1 } from \"./Types.js\";\r\nimport { fold, empty, ofArrayWithTail, cons, toArray, head, skipWhile } from \"./List.js\";\r\nimport { fill, reverse } from \"./Array.js\";\r\n\r\nexport function isBigInt(x) {\r\n    return x instanceof BigInteger;\r\n}\r\n\r\nexport function tryParse(str, res) {\r\n    try {\r\n        res.contents = BigInteger_Parse_Z721C83C5(str);\r\n        return true;\r\n    }\r\n    catch (matchValue) {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function divRem(x, y, remainder) {\r\n    const patternInput = BigInteger_DivRem_56F059C0(x, y);\r\n    remainder.contents = patternInput[1];\r\n    return patternInput[0];\r\n}\r\n\r\nexport function parse(arg00) {\r\n    return BigInteger_Parse_Z721C83C5(arg00);\r\n}\r\n\r\nexport function greatestCommonDivisor(arg00, arg01) {\r\n    return BigInteger_GreatestCommonDivisor_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function pow(arg00, arg01) {\r\n    return BigInteger_Pow_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function abs(arg00) {\r\n    return BigInteger_Abs_Z665282C2(arg00);\r\n}\r\n\r\nexport const zero = BigInteger_get_Zero();\r\n\r\nexport const one = BigInteger_get_One();\r\n\r\nexport const two = BigInteger_get_Two();\r\n\r\nexport function fromString(s) {\r\n    return BigInteger_Parse_Z721C83C5(s);\r\n}\r\n\r\nexport function fromZero() {\r\n    return BigInteger_get_Zero();\r\n}\r\n\r\nexport function fromOne() {\r\n    return BigInteger_get_One();\r\n}\r\n\r\nexport function fromInt64(i) {\r\n    return BigInteger_$ctor_Z524259C1(i);\r\n}\r\n\r\nexport function fromInt32(i) {\r\n    if (i > 2147483647) {\r\n        return BigInteger_$ctor_Z524259C1(fromInteger(i, false, 6));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z524259A4(i);\r\n    }\r\n}\r\n\r\nexport function toSByte(x) {\r\n    return BigInteger__get_ToSByte(x);\r\n}\r\n\r\nexport function toByte(x) {\r\n    return BigInteger__get_ToByte(x);\r\n}\r\n\r\nexport function toInt16(x) {\r\n    return BigInteger__get_ToInt16(x);\r\n}\r\n\r\nexport function toUInt16(x) {\r\n    return BigInteger__get_ToUInt16(x);\r\n}\r\n\r\nexport function toInt32(x) {\r\n    return BigInteger__get_ToInt32(x);\r\n}\r\n\r\nexport function toUInt32(x) {\r\n    return BigInteger__get_ToUInt32(x);\r\n}\r\n\r\nexport function toInt64(x) {\r\n    return BigInteger__get_ToInt64(x);\r\n}\r\n\r\nexport function toUInt64(x) {\r\n    return BigInteger__get_ToUInt64(x);\r\n}\r\n\r\nexport function toSingle(x) {\r\n    return BigInteger__get_ToSingle(x);\r\n}\r\n\r\nexport function toDouble(x) {\r\n    return BigInteger__get_ToDouble(x);\r\n}\r\n\r\nexport function toDecimal(x) {\r\n    return BigInteger__get_ToDecimal(x);\r\n}\r\n\r\nexport function sign(x) {\r\n    return BigInteger__get_Sign(x);\r\n}\r\n\r\nexport function isZero(x) {\r\n    return BigInteger__get_IsZero(x);\r\n}\r\n\r\nexport function isOne(x) {\r\n    return BigInteger__get_IsOne(x);\r\n}\r\n\r\nexport function hash(x) {\r\n    return safeHash(x);\r\n}\r\n\r\nexport function compare(x, y) {\r\n    return x.CompareTo(y);\r\n}\r\n\r\nexport function equals(x, y) {\r\n    return equals_1(x, y);\r\n}\r\n\r\nexport function toString(x) {\r\n    return toString_1(x);\r\n}\r\n\r\nexport const get_Zero = BigInteger_get_Zero();\r\n\r\nexport const get_One = BigInteger_get_One();\r\n\r\nexport function op_Addition(arg00, arg01) {\r\n    return BigInteger_op_Addition_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Subtraction(arg00, arg01) {\r\n    return BigInteger_op_Subtraction_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Multiply(arg00, arg01) {\r\n    return BigInteger_op_Multiply_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Division(arg00, arg01) {\r\n    return BigInteger_op_Division_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Modulus(arg00, arg01) {\r\n    return BigInteger_op_Modulus_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_UnaryNegation(arg00) {\r\n    return BigInteger_op_UnaryNegation_Z665282C2(arg00);\r\n}\r\n\r\nexport function op_UnaryPlus(arg00) {\r\n    return BigInteger_op_UnaryPlus_Z665282C2(arg00);\r\n}\r\n\r\nexport function op_RightShift(arg00, arg01) {\r\n    return BigInteger_op_RightShift_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function op_LeftShift(arg00, arg01) {\r\n    return BigInteger_op_LeftShift_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function op_BitwiseAnd(arg00, arg01) {\r\n    return BigInteger_op_BitwiseAnd_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_BitwiseOr(arg00, arg01) {\r\n    return BigInteger_op_BitwiseOr_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_ExclusiveOr(arg00, arg01) {\r\n    return BigInteger_op_ExclusiveOr_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_LessThan(arg00, arg01) {\r\n    return BigInteger_op_LessThan_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_LessThanOrEqual(arg00, arg01) {\r\n    return BigInteger_op_LessThanOrEqual_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_GreaterThan(arg00, arg01) {\r\n    return BigInteger_op_GreaterThan_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_GreaterThanOrEqual(arg00, arg01) {\r\n    return BigInteger_op_GreaterThanOrEqual_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Equality(arg00, arg01) {\r\n    return BigInteger_op_Equality_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Inequality(arg00, arg01) {\r\n    return BigInteger_op_Inequality_56F059C0(arg00, arg01);\r\n}\r\n\r\nfunction flipTwosComplement(currByte, lowBitFound) {\r\n    let array;\r\n    const matchValue = [currByte, lowBitFound];\r\n    if (matchValue[1]) {\r\n        return [(currByte ^ 255) & 255, true];\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        return [0, false];\r\n    }\r\n    else {\r\n        return [(currByte ^ (254 << ((array = (new Int32Array([0, 1, 2, 3, 4, 5, 6, 7])), array.find((i) => ((currByte & (1 << i)) > 0)))))) & 255, true];\r\n    }\r\n}\r\n\r\nexport function toByteArray(value) {\r\n    if (equals_1(value, zero)) {\r\n        return new Uint8Array([0]);\r\n    }\r\n    else {\r\n        const isPositive = compare_1(value, zero) > 0;\r\n        const value_1 = isPositive ? value : BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value);\r\n        const mask32 = fromInt64(fromInteger(4294967295, false, 6));\r\n        const loop = (accumBytes_mut, consumeValue_mut, lowBitFound_mut) => {\r\n            let value_6, value_8, value_9, value_10;\r\n            loop:\r\n            while (true) {\r\n                const accumBytes = accumBytes_mut, consumeValue = consumeValue_mut, lowBitFound = lowBitFound_mut;\r\n                if (compare_1(consumeValue, zero) <= 0) {\r\n                    const accumBytes_1 = isPositive ? skipWhile((b) => (b === 0), accumBytes) : skipWhile((b_1) => (b_1 === 255), accumBytes);\r\n                    const isHighBitOne = (head(accumBytes_1) & 128) !== 0;\r\n                    return reverse(toArray((isPositive && isHighBitOne) ? cons(0, accumBytes_1) : (((!isPositive) && (!isHighBitOne)) ? cons(255, accumBytes_1) : accumBytes_1)));\r\n                }\r\n                else {\r\n                    const currValue = toUInt32(BigInteger_op_BitwiseAnd_56F059C0(consumeValue, mask32));\r\n                    if (isPositive) {\r\n                        const b0 = currValue & 0xFF;\r\n                        let b1;\r\n                        const value_4 = currValue >>> 8;\r\n                        b1 = (value_4 & 0xFF);\r\n                        let b2;\r\n                        const value_5 = currValue >>> 16;\r\n                        b2 = (value_5 & 0xFF);\r\n                        accumBytes_mut = ofArrayWithTail([(value_6 = (currValue >>> 24), value_6 & 0xFF), b2, b1, b0], accumBytes);\r\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\r\n                        lowBitFound_mut = false;\r\n                        continue loop;\r\n                    }\r\n                    else {\r\n                        const patternInput = flipTwosComplement(currValue & 0xFF, lowBitFound);\r\n                        const patternInput_1 = flipTwosComplement((value_8 = (currValue >>> 8), value_8 & 0xFF), patternInput[1]);\r\n                        const patternInput_2 = flipTwosComplement((value_9 = (currValue >>> 16), value_9 & 0xFF), patternInput_1[1]);\r\n                        const patternInput_3 = flipTwosComplement((value_10 = (currValue >>> 24), value_10 & 0xFF), patternInput_2[1]);\r\n                        accumBytes_mut = ofArrayWithTail([patternInput_3[0], patternInput_2[0], patternInput_1[0], patternInput[0]], accumBytes);\r\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\r\n                        lowBitFound_mut = patternInput_3[1];\r\n                        continue loop;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(empty(), value_1, false);\r\n    }\r\n}\r\n\r\nexport function fromByteArray(bytes) {\r\n    if (bytes == null) {\r\n        throw (new Error(\"bytes\"));\r\n    }\r\n    if (bytes.length === 0) {\r\n        return zero;\r\n    }\r\n    else {\r\n        const isPositive = (bytes[bytes.length - 1] & 128) === 0;\r\n        const buffer = fill(new Uint8Array(4), 0, 4, 0);\r\n        const loop = (accumUInt32_mut, currIndex_mut, bytesRemaining_mut, lowBitFound_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const accumUInt32 = accumUInt32_mut, currIndex = currIndex_mut, bytesRemaining = bytesRemaining_mut, lowBitFound = lowBitFound_mut;\r\n                if (bytesRemaining === 0) {\r\n                    const value_2 = fold((acc, value) => BigInteger_op_Addition_56F059C0(BigInteger_op_LeftShift_62E082A2(acc, 32), fromInt64(fromInteger(value, false, 6))), zero, accumUInt32);\r\n                    if (isPositive) {\r\n                        return value_2;\r\n                    }\r\n                    else {\r\n                        return BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value_2);\r\n                    }\r\n                }\r\n                else {\r\n                    const bytesToProcess = min(comparePrimitives, bytesRemaining, 4) | 0;\r\n                    for (let i_1 = 0; i_1 <= (bytesToProcess - 1); i_1++) {\r\n                        buffer[i_1] = bytes[currIndex + i_1];\r\n                    }\r\n                    if (isPositive) {\r\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 0);\r\n                        accumUInt32_mut = cons((((((buffer[0] | ((buffer[1] << 8) >>> 0)) >>> 0) | ((buffer[2] << 16) >>> 0)) >>> 0) | ((buffer[3] << 24) >>> 0)) >>> 0, accumUInt32);\r\n                        currIndex_mut = (currIndex + bytesToProcess);\r\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\r\n                        lowBitFound_mut = false;\r\n                        continue loop;\r\n                    }\r\n                    else {\r\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 255);\r\n                        const patternInput = flipTwosComplement(buffer[0], lowBitFound);\r\n                        const patternInput_1 = flipTwosComplement(buffer[1], patternInput[1]);\r\n                        const patternInput_2 = flipTwosComplement(buffer[2], patternInput_1[1]);\r\n                        const patternInput_3 = flipTwosComplement(buffer[3], patternInput_2[1]);\r\n                        accumUInt32_mut = cons((((((patternInput[0] | ((patternInput_1[0] << 8) >>> 0)) >>> 0) | ((patternInput_2[0] << 16) >>> 0)) >>> 0) | ((patternInput_3[0] << 24) >>> 0)) >>> 0, accumUInt32);\r\n                        currIndex_mut = (currIndex + bytesToProcess);\r\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\r\n                        lowBitFound_mut = patternInput_3[1];\r\n                        continue loop;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(empty(), 0, bytes.length, false);\r\n    }\r\n}\r\n\r\n","namespace Fable.SimpleJson\r\n\r\nopen Fable.Core\r\nopen Fable.Parsimmon\r\nopen Parser\r\nopen Fable.Import\r\nopen System\r\nopen Fable.Core.JsInterop\r\n\r\n[<AutoOpen>]\r\nmodule InteropUtil =\r\n    [<Emit(\"Array.from($0)\")>]\r\n    let arrayFrom (xs: obj) : obj = jsNative\r\n    [<Emit(\"$1[$0]\")>]\r\n    let get<'a> (key: string) (x: obj) : 'a = jsNative\r\n    [<Emit(\"$0 instanceof Date\")>]\r\n    let isDate (x: obj) = jsNative\r\n    [<Emit(\"$0 in $1\")>]\r\n    let hasKey (key: string) (x: 'a) = jsNative\r\n    let isDateOffset (x: obj) = isDate x && hasKey \"offset\" x\r\n    [<Emit(\"typeof $0\")>]\r\n    let getTypeOf (x: obj) : string = jsNative\r\n    let isObjectLiteral (x: obj) = getTypeOf x = \"object\"\r\n    let isBigInt (x: obj) =\r\n        not (isNull x)\r\n        && isObjectLiteral x\r\n        && hasKey \"signInt\" x\r\n        && hasKey \"v\" x\r\n        && hasKey \"digits\" (get \"v\" x)\r\n        && hasKey \"bound\" (get \"v\" x)\r\n\r\n    [<Emit(\"console.log($0)\")>]\r\n    let log (x: 'a) : unit = jsNative\r\n\r\n    [<Emit \"({})\">]\r\n    let createEmptyObject() : obj = jsNative\r\n\r\nmodule SimpleJson =\r\n    /// Tries to parse a string into a Json structured JSON data.\r\n    let tryParse (input: string) : Option<Json> =\r\n        Parsimmon.parse input jsonParser\r\n\r\n    /// Parses the input string into a structured JSON data. Fails with an exception if parsing fails.\r\n    let parse (input: string) : Json =\r\n        match tryParse input with\r\n        | Some result -> result\r\n        | None -> failwithf \"Could not parse the JSON input: %s\" input\r\n\r\n    /// Stringifies a Json object back to string representation\r\n    let rec toString = function\r\n        | JNull -> \"null\"\r\n        | JBool true -> \"true\"\r\n        | JBool false -> \"false\"\r\n        | JNumber number -> string number\r\n        | JString text -> sprintf \"\\\"%s\\\"\" text\r\n        | JArray elements ->\r\n            elements\r\n            |> List.map toString\r\n            |> String.concat \",\"\r\n            |> sprintf \"[%s]\"\r\n        | JObject map ->\r\n            map\r\n            |> Map.toList\r\n            |> List.map (fun (key,value) -> sprintf \"\\\"%s\\\":%s\" key (toString value))\r\n            |> String.concat \",\"\r\n            |> sprintf \"{%s}\"\r\n\r\n    [<Emit \"$2[$0] = $1\">]\r\n    let private setValue (key: string) (value: obj) (destination: obj) = jsNative\r\n    let rec toPlainObject (input: Json) : obj =\r\n        match input with\r\n        | JNull -> unbox null\r\n        | JBool value -> unbox value\r\n        | JNumber value -> unbox value\r\n        | JString value -> unbox value\r\n        | JArray values ->\r\n            let array = new ResizeArray<obj>()\r\n            for value in values do array.Add(toPlainObject value)\r\n            unbox array\r\n        | JObject map ->\r\n            let jsObject = createEmptyObject()\r\n            for (key, value) in Map.toList map do\r\n                setValue key (toPlainObject value) jsObject\r\n            unbox jsObject\r\n\r\n    let stringify (value: 'a) : string =\r\n        if isNullOrUndefined value\r\n        then JS.JSON.stringify(null)\r\n        else JS.JSON.stringify(value, (fun key jsonValue ->\r\n            if isBigInt jsonValue then\r\n                let bigInt : bigint = unbox(jsonValue)\r\n                box (string (decimal bigInt))\r\n            elif isDate jsonValue then\r\n                let dateOffset : DateTimeOffset = unbox(jsonValue)\r\n                box (dateOffset.ToString(\"o\"))\r\n            else\r\n            match jsonValue with\r\n            | :? string -> jsonValue\r\n            | :? System.Collections.IEnumerable ->\r\n                if JS.Constructors.Array.isArray(jsonValue) then jsonValue\r\n                else arrayFrom jsonValue\r\n            | _ when isBigInt jsonValue -> box (string (decimal (unbox<bigint> jsonValue)))\r\n            | _ when isDateOffset jsonValue -> box ((unbox<DateTimeOffset> jsonValue).ToString(\"O\"))\r\n            | _ -> jsonValue\r\n        ), 0)\r\n\r\n    let rec internal parseNative' (x: obj) =\r\n        match x with\r\n        | TypeCheck.NativeString str -> JString str\r\n        | TypeCheck.NativeNumber number -> JNumber number\r\n        | TypeCheck.NativeBool value -> JBool value\r\n        | TypeCheck.Null _ -> JNull\r\n        | TypeCheck.NativeArray arr -> JArray (List.ofArray (Array.map parseNative' arr))\r\n        | TypeCheck.NativeObject object ->\r\n            [ for key in JS.Constructors.Object.keys object -> key, parseNative' (get<obj> key object)  ]\r\n            |> Map.ofList\r\n            |> JObject\r\n        | _ -> JNull\r\n\r\n    /// Parses and converts the input string to Json using Javascript's native parsing capabilities\r\n    let parseNative (input: string) =\r\n        let parsed = JS.JSON.parse input\r\n        parseNative' parsed\r\n\r\n    let tryParseNative (input: string) =\r\n        try Some (parseNative input)\r\n        with | ex -> None\r\n\r\n    /// Tries to convert an object literal to the Json by calling JSON.stringify on the object first\r\n    let fromObjectLiteral (x: 'a) =\r\n        try Some (parseNative' x)\r\n        with | _ -> None\r\n\r\n    /// Transforms all keys of the objects within the Json structure\r\n    let rec mapKeys f = function\r\n        | JObject dictionary ->\r\n            dictionary\r\n            |> Map.toList\r\n            |> List.map (fun (key, value) -> f key, mapKeys f value)\r\n            |> Map.ofList\r\n            |> JObject\r\n        | JArray values ->\r\n            values\r\n            |> List.map (mapKeys f)\r\n            |> JArray\r\n        | otherJsonValue -> otherJsonValue\r\n\r\n    /// Transforms object values recursively using function `f` that takes the key and value of the object and returns a new value\r\n    let rec mapbyKey f = function\r\n        | JObject dictionary ->\r\n            dictionary\r\n            |> Map.toList\r\n            |> List.map (fun (key, value) -> key, f key value)\r\n            |> Map.ofList\r\n            |> JObject\r\n        | JArray values ->\r\n            values\r\n            |> List.map (mapbyKey f)\r\n            |> JArray\r\n        | otherJsonValue -> otherJsonValue\r\n\r\n    /// Transforms keys of object selectively by path segments\r\n    let mapKeysByPath f json =\r\n        let rec mapKey xs = function\r\n            | JObject dictionary ->\r\n                dictionary\r\n                |> Map.toList\r\n                |> List.map (fun (key, value) ->\r\n                    let keyPath = List.concat [xs; [key]]\r\n                    match f keyPath with\r\n                    | Some nextKey -> nextKey, mapKey keyPath value\r\n                    | None -> key, mapKey keyPath value)\r\n                |> Map.ofList\r\n                |> JObject\r\n            | JArray values ->\r\n                values\r\n                |> List.map (mapKey xs)\r\n                |> JArray\r\n            | otherJsonValue -> otherJsonValue\r\n        mapKey [] json\r\n\r\n    let rec readPath (keys: string list) (input: Json) =\r\n        match keys, input with\r\n        | [ ], _ -> None\r\n        | [ key ], JObject dict -> Map.tryFind key dict\r\n        | firstKey :: rest, JObject dict ->\r\n            match Map.tryFind firstKey dict with\r\n            | Some (JObject nextDict) -> readPath rest (JObject nextDict)\r\n            | _ -> None\r\n        | _ -> None","namespace Fable.SimpleJson\r\n\r\nopen Fable.Core\r\nopen Fable.Core.JsInterop\r\n\r\nmodule TypeCheck =\r\n\r\n    [<Emit(\"typeof ($0) === 'string'\")>]\r\n    let typeofString (x: obj) : bool = jsNative\r\n\r\n    [<Emit(\"typeof ($0) === 'boolean'\")>]\r\n    let typeofBool (x: obj) : bool = jsNative\r\n\r\n    [<Emit(\"typeof ($0) === 'number'\")>]\r\n    let typeofNumber (x: obj) : bool = jsNative\r\n    [<Emit(\"typeof ($0) === 'object'\")>]\r\n    let typeofObject (x: obj) : bool = jsNative\r\n\r\n    let (|NativeString|_|) (x: obj) =\r\n        if typeofString x\r\n        then Some (unbox<string> x)\r\n        else None\r\n\r\n    let (|NativeBool|_|) (x: obj) =\r\n        if typeofBool x\r\n        then Some (unbox<bool> x)\r\n        else None\r\n\r\n    let (|NativeNumber|_|) (x: obj) =\r\n        if typeofNumber x\r\n        then Some (unbox<float> x)\r\n        else None\r\n\r\n    let (|NativeObject|_|) (x: obj) =\r\n        if typeofObject x\r\n        then Some x\r\n        else None\r\n\r\n    let (|Null|_|) (x: obj) =\r\n        if isNull x\r\n        then Some x\r\n        else None\r\n\r\n    let (|NativeArray|_|) (x: obj) =\r\n        if (JS.Constructors.Array.isArray x)\r\n        then Some (unbox<obj[]> x)\r\n        else None","const ok = (value) => ({\n    tag: \"ok\",\n    value,\n});\nconst error = (error) => ({ tag: \"error\", error });\nexport class Uri {\n    constructor(state) {\n        this.uri = state;\n    }\n    static isAbsoluteUri(uri) {\n        try {\n            // tslint:disable-next-line no-unused-expression\n            new URL(uri);\n            return true;\n        }\n        catch (_a) {\n            return false;\n        }\n    }\n    static tryCreateWithKind(uri, kind) {\n        switch (kind) {\n            case 1 /* Absolute */:\n                return Uri.isAbsoluteUri(uri)\n                    ? ok(new Uri({ original: uri, value: new URL(uri), kind }))\n                    : error(\"Invalid URI: The format of the URI could not be determined.\");\n            case 2 /* Relative */:\n                return Uri.isAbsoluteUri(uri)\n                    ? error(\"URI is not a relative path.\")\n                    : ok(new Uri({ original: uri, value: uri, kind }));\n            case 0 /* RelativeOrAbsolute */:\n                return Uri.isAbsoluteUri(uri)\n                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: 1 /* Absolute */ }))\n                    : ok(new Uri({ original: uri, value: uri, kind: 2 /* Relative */ }));\n            default:\n                const never = kind;\n                return never;\n        }\n    }\n    static tryCreateWithBase(baseUri, relativeUri) {\n        return baseUri.uri.kind !== 1 /* Absolute */\n            ? error(\"Base URI should have Absolute kind\")\n            : typeof relativeUri === \"string\"\n                ? ok(new Uri({\n                    original: new URL(relativeUri, baseUri.uri.value).toString(),\n                    value: new URL(relativeUri, baseUri.uri.value),\n                    kind: 1 /* Absolute */,\n                }))\n                : relativeUri.uri.kind === 2 /* Relative */\n                    ? ok(new Uri({\n                        original: new URL(relativeUri.uri.value, baseUri.uri.value).toString(),\n                        value: new URL(relativeUri.uri.value, baseUri.uri.value),\n                        kind: 1 /* Absolute */,\n                    }))\n                    : ok(baseUri);\n    }\n    static tryCreateImpl(value, kindOrUri = 1 /* Absolute */) {\n        return typeof value === \"string\"\n            ? typeof kindOrUri !== \"number\"\n                ? error(\"Kind must be specified when the baseUri is a string.\")\n                : Uri.tryCreateWithKind(value, kindOrUri)\n            : typeof kindOrUri === \"number\"\n                ? error(\"Kind should not be specified when the baseUri is an absolute Uri.\")\n                : Uri.tryCreateWithBase(value, kindOrUri);\n    }\n    static create(value, kindOrUri = 1 /* Absolute */) {\n        const result = Uri.tryCreateImpl(value, kindOrUri);\n        switch (result.tag) {\n            case \"ok\":\n                return result.value;\n            case \"error\":\n                throw new Error(result.error);\n            default:\n                const never = result;\n                return never;\n        }\n    }\n    static tryCreate(value, kindOrUri = 1 /* Absolute */, out) {\n        const result = Uri.tryCreateImpl(value, kindOrUri);\n        switch (result.tag) {\n            case \"ok\":\n                out.contents = result.value;\n                return true;\n            case \"error\":\n                return false;\n            default:\n                const never = result;\n                return never;\n        }\n    }\n    toString() {\n        switch (this.uri.kind) {\n            case 1 /* Absolute */:\n                return decodeURIComponent(this.asUrl().toString());\n            case 2 /* Relative */:\n                return this.uri.value;\n            default:\n                const never = this.uri;\n                return never;\n        }\n    }\n    asUrl() {\n        switch (this.uri.kind) {\n            case 1 /* Absolute */:\n                return this.uri.value;\n            case 2 /* Relative */:\n                throw new Error(\"This operation is not supported for a relative URI.\");\n            default:\n                const never = this.uri;\n                return never;\n        }\n    }\n    get isAbsoluteUri() {\n        return this.uri.kind === 1 /* Absolute */;\n    }\n    get absoluteUri() {\n        return this.asUrl().href;\n    }\n    get scheme() {\n        const protocol = this.asUrl().protocol;\n        return protocol.slice(0, protocol.length - 1);\n    }\n    get host() {\n        return this.asUrl().host;\n    }\n    get absolutePath() {\n        return this.asUrl().pathname;\n    }\n    get query() {\n        return this.asUrl().search;\n    }\n    get pathAndQuery() {\n        const url = this.asUrl();\n        return url.pathname + url.search;\n    }\n    get fragment() {\n        return this.asUrl().hash;\n    }\n    get originalString() {\n        return this.uri.original;\n    }\n}\nexport default Uri;\n","/**\n * DateTimeOffset functions.\n *\n * Note: DateOffset instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * However, this means that in order to construct an UTC date\n * from a DateOffset with offset of +5 hours, you first need\n * to subtract those 5 hours, than add the \"local\" offset.\n * As said, all kinds of messed up.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { create as createDate, dateOffsetToString, daysInMonth, parseRaw } from \"./Date.js\";\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, padWithZeros } from \"./Util.js\";\nexport default function DateTimeOffset(value, offset) {\n    checkOffsetInRange(offset);\n    const d = new Date(value);\n    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;\n    return d;\n}\nfunction checkOffsetInRange(offset) {\n    if (offset != null && offset !== 0) {\n        if (offset % 60000 !== 0) {\n            throw new Error(\"Offset must be specified in whole minutes.\");\n        }\n        if (Math.abs(offset / 3600000) > 14) {\n            throw new Error(\"Offset must be within plus or minus 14 hours.\");\n        }\n    }\n}\nexport function fromDate(date, offset) {\n    let offset2 = 0;\n    switch (date.kind) {\n        case 1 /* UTC */:\n            if (offset != null && offset !== 0) {\n                throw new Error(\"The UTC Offset for Utc DateTime instances must be 0.\");\n            }\n            offset2 = 0;\n            break;\n        case 2 /* Local */:\n            offset2 = date.getTimezoneOffset() * -60000;\n            if (offset != null && offset !== offset2) {\n                throw new Error(\"The UTC Offset of the local dateTime parameter does not match the offset argument.\");\n            }\n            break;\n        case 0 /* Unspecified */:\n        default:\n            if (offset == null) {\n                offset2 = date.getTimezoneOffset() * -60000;\n            }\n            else {\n                offset2 = offset;\n            }\n            break;\n    }\n    return DateTimeOffset(date.getTime(), offset2);\n}\nexport function fromTicks(ticks, offset) {\n    ticks = fromValue(ticks);\n    const epoc = ticksToUnixEpochMilliseconds(ticks) - offset;\n    return DateTimeOffset(epoc, offset);\n}\nexport function getUtcTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), 0);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTimeOffset(-62135596800000, 0);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTimeOffset(253402300799999, 0);\n}\nexport function parse(str) {\n    const [date, offsetMatch] = parseRaw(str);\n    const offset = offsetMatch == null\n        ? date.getTimezoneOffset() * -60000\n        : (offsetMatch === \"Z\" ? 0 : offsetMatch * 60000);\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h, m, s, ms, offset) {\n    if (offset == null) {\n        offset = ms;\n        ms = 0;\n    }\n    checkOffsetInRange(offset);\n    let date;\n    if (offset === 0) {\n        date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));\n        if (year <= 99) {\n            date.setFullYear(year, month - 1, day);\n        }\n    }\n    else {\n        const str = padWithZeros(year, 4) + \"-\" +\n            padWithZeros(month, 2) + \"-\" +\n            padWithZeros(day, 2) + \"T\" +\n            padWithZeros(h, 2) + \":\" +\n            padWithZeros(m, 2) + \":\" +\n            padWithZeros(s, 2) + \".\" +\n            padWithZeros(ms, 3) +\n            dateOffsetToString(offset);\n        date = new Date(str);\n    }\n    const dateValue = date.getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date\");\n    }\n    return DateTimeOffset(dateValue, offset);\n}\nexport function now() {\n    const date = new Date();\n    const offset = date.getTimezoneOffset() * -60000;\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function utcNow() {\n    const date = now();\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toUniversalTime(date) {\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toLocalTime(date) {\n    return DateTimeOffset(date.getTime(), date.getTimezoneOffset() * -60000);\n}\nexport function timeOfDay(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return d2.getUTCHours() * 3600000\n        + d2.getUTCMinutes() * 60000\n        + d2.getUTCSeconds() * 1000\n        + d2.getUTCMilliseconds();\n}\nexport function date(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);\n}\nexport function day(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDate();\n}\nexport function hour(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCHours();\n}\nexport function millisecond(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMilliseconds();\n}\nexport function minute(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMinutes();\n}\nexport function month(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMonth() + 1;\n}\nexport function second(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCSeconds();\n}\nexport function year(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDay();\n}\nexport function dayOfYear(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    const _year = d2.getUTCFullYear();\n    const _month = d2.getUTCMonth() + 1;\n    let _day = d2.getUTCDate();\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    var _a;\n    return DateTimeOffset(d.getTime() + ts, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addDays(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 86400000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addHours(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 3600000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMinutes(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 60000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addSeconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 1000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMilliseconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addYears(d, v) {\n    var _a;\n    const newMonth = d.getUTCMonth() + 1;\n    const newYear = d.getUTCFullYear() + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d.getUTCDate());\n    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMonths(d, v) {\n    var _a, _b;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    let newMonth = d2.getUTCMonth() + 1 + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = d2.getUTCFullYear() + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d2.getUTCDate());\n    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), ((_b = d.offset) !== null && _b !== void 0 ? _b : 0));\n}\nexport function subtract(d, that) {\n    var _a;\n    return typeof that === \"number\"\n        ? DateTimeOffset(d.getTime() - that, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0))\n        : d.getTime() - that.getTime();\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport function equalsExact(d1, d2) {\n    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;\n}\nexport function compare(d1, d2) {\n    return compareDates(d1, d2);\n}\nexport const compareTo = compare;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function toOffset(d, offset) {\n    return DateTimeOffset(d.getTime(), offset);\n}\n","import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth } from \"./Date.js\";\nimport { padWithZeros } from \"./Util.js\";\nimport { toInt, fromNumber, op_Division as Long_op_Division, op_Multiply as Long_op_Multiply, ticksToUnixEpochMilliseconds } from \"./Long.js\";\nexport function fromUnixMilliseconds(value) {\n    return DateTime(value, 1 /* UTC */);\n}\nexport function create(year, month, day) {\n    const d = fromUnixMilliseconds(Date.UTC(year, month - 1, day));\n    if (year <= 99) {\n        d.setUTCFullYear(year);\n    }\n    return d;\n}\nexport function maxValue() {\n    // This is \"9999-12-31T00:00:00.000Z\"\n    return fromUnixMilliseconds(253402214400000);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\"\n    return fromUnixMilliseconds(-62135596800000);\n}\nexport function dayNumber(d) {\n    return toInt(Long_op_Division(getTicks(d), 864000000000));\n}\nexport function fromDayNumber(dayNumber) {\n    const ticks = Long_op_Multiply(fromNumber(864000000000), dayNumber);\n    return fromUnixMilliseconds(ticksToUnixEpochMilliseconds(ticks));\n}\nexport function fromDateTime(d) {\n    return create(Date_year(d), Date_month(d), Date_day(d));\n}\nexport function day(d) {\n    return d.getUTCDate();\n}\nexport function month(d) {\n    return d.getUTCMonth() + 1;\n}\nexport function year(d) {\n    return d.getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.getUTCDay();\n}\nexport function dayOfYear(d) {\n    return Date_dayOfYear(d);\n}\nexport function toDateTime(d, time, kind = 0 /* Unspecified */) {\n    return DateTime(d.getTime() + time + (kind !== 1 /* UTC */ ? d.getTimezoneOffset() : 0) * 60000, kind);\n}\nexport function toString(d, format = \"d\", _provider) {\n    if ([\"d\", \"o\", \"O\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const y = padWithZeros(year(d), 4);\n    const m = padWithZeros(month(d), 2);\n    const dd = padWithZeros(day(d), 2);\n    return format === \"d\" ? `${m}/${dd}/${y}` : `${y}-${m}-${dd}`;\n}\nexport function parse(str) {\n    function fail() {\n        throw new Error(`String '${str}' was not recognized as a valid DateOnly.`);\n    }\n    // Allowed separators: . , / -\n    // TODO whitespace alone as the separator\n    //\n    // Whitespace around separators\n    //\n    // Allowed format types:\n    // yyyy/mm/dd\n    // mm/dd/yyyy\n    // mm/dd\n    // mm/yyyy\n    // yyyy/mm\n    const r = /^\\s*(\\d{1,4})(?:\\s*[.,-\\/]\\s*(\\d{1,2}))?\\s*[.,-\\/]\\s*(\\d{1,4})\\s*$/.exec(str);\n    if (r != null) {\n        let y = 0;\n        let m = 0;\n        let d = 1;\n        if (r[2] == null) {\n            if (r[1].length < 3) {\n                if (r[3].length < 3) {\n                    // 12/30 = December 30, {CurrentYear}\n                    y = new Date().getFullYear();\n                    m = +r[1];\n                    d = +r[3];\n                }\n                else {\n                    // 12/2000 = December 1, 2000\n                    m = +r[1];\n                    y = +r[3];\n                }\n            }\n            else {\n                if (r[3].length > 2)\n                    fail();\n                // 2000/12 = December 1, 2000\n                y = +r[1];\n                m = +r[3];\n            }\n        }\n        else {\n            // 2000/1/30 or 1/30/2000\n            const yearFirst = r[1].length > 2;\n            const yTmp = r[yearFirst ? 1 : 3];\n            y = +yTmp;\n            // year 0-29 is 2000-2029, 30-99 is 1930-1999\n            if (yTmp.length < 3)\n                y += y >= 30 ? 1900 : 2000;\n            m = +r[yearFirst ? 2 : 1];\n            d = +r[yearFirst ? 3 : 2];\n        }\n        if (y > 0 && m > 0 && m < 13 && d > 0 && d <= Date_daysInMonth(y, m))\n            return create(y, m, d);\n    }\n    return fail();\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n","import { op_Division as Long_op_Division, toNumber as Long_toNumber } from \"./Long.js\";\nimport { hours, minutes, seconds, milliseconds } from \"./TimeSpan.js\";\nimport { padWithZeros } from \"./Util.js\";\nconst millisecondsPerDay = 86400000;\nexport function create(h = 0, m = 0, s = 0, ms = 0) {\n    if (h < 0 || m < 0 || s < 0 || ms < 0)\n        throw new Error(\"The parameters describe an unrepresentable TimeOnly.\");\n    if (arguments.length === 1)\n        // ticks\n        return fromTicks(arguments[0]);\n    else\n        return h * 3600000 + m * 60000 + s * 1000 + ms;\n}\nexport function fromTicks(ticks) {\n    return Long_toNumber(Long_op_Division(ticks, 10000));\n}\nexport function fromTimeSpan(timeSpan) {\n    if (timeSpan < 0 || timeSpan >= millisecondsPerDay)\n        throw new Error(\"The TimeSpan describes an unrepresentable TimeOnly.\");\n    return timeSpan;\n}\nexport function fromDateTime(d) {\n    return d.kind === 1 /* UTC */\n        ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())\n        : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());\n}\nexport function maxValue() {\n    // This is \"23:59:59.999\"\n    return millisecondsPerDay - 1;\n}\nexport function add(t, ts, wrappedDays) {\n    if (wrappedDays === undefined) {\n        const t2 = (t + ts) % millisecondsPerDay;\n        return t2 < 0 ? millisecondsPerDay + t2 : t2;\n    }\n    wrappedDays.contents = ts / millisecondsPerDay;\n    let newMs = t + ts % millisecondsPerDay;\n    if (newMs < 0) {\n        wrappedDays.contents--;\n        newMs += millisecondsPerDay;\n    }\n    else {\n        if (newMs >= millisecondsPerDay) {\n            wrappedDays.contents++;\n            newMs -= millisecondsPerDay;\n        }\n    }\n    return newMs;\n}\nexport function addHours(t, h) {\n    return add(t, h * 3600000);\n}\nexport function addMinutes(t, m) {\n    return add(t, m * 60000);\n}\nexport function isBetween(t, start, end) {\n    return start <= end\n        ? (start <= t && end > t)\n        : (start <= t || end > t);\n}\nexport function toString(t, format = \"t\", _provider) {\n    if ([\"r\", \"R\", \"o\", \"O\", \"t\", \"T\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`;\n    if (format === \"t\")\n        return base;\n    const s = padWithZeros(seconds(t), 2);\n    // We're limited to millisecond precision, so the last 4 digits will always be 0\n    return `${base}${format === \"o\" || format === \"O\" ? `:${s}.${padWithZeros(milliseconds(t), 3)}0000` : `:${s}`}`;\n}\nexport function parse(str) {\n    // Allowed format types:\n    // hh:mm\n    // hh:mm:ss\n    // hh:mm:ss.fffffff\n    const r = /^\\s*([0-1]?\\d|2[0-3])\\s*:\\s*([0-5]?\\d)(\\s*:\\s*([0-5]?\\d)(\\.(\\d+))?)?\\s*$/.exec(str);\n    if (r != null && r[1] != null && r[2] != null) {\n        let ms = 0;\n        let s = 0;\n        const h = +r[1];\n        const m = +r[2];\n        if (r[4] != null) {\n            s = +r[4];\n        }\n        if (r[6] != null) {\n            // Depending on the number of decimals passed, we need to adapt the numbers\n            switch (r[6].length) {\n                case 1:\n                    ms = +r[6] * 100;\n                    break;\n                case 2:\n                    ms = +r[6] * 10;\n                    break;\n                case 3:\n                    ms = +r[6];\n                    break;\n                case 4:\n                    ms = +r[6] / 10;\n                    break;\n                case 5:\n                    ms = +r[6] / 100;\n                    break;\n                case 6:\n                    ms = +r[6] / 1000;\n                    break;\n                default:\n                    ms = +r[6].substring(0, 7) / 10000;\n                    break;\n            }\n        }\n        return create(h, m, s, Math.trunc(ms));\n    }\n    throw new Error(`String '${str}' was not recognized as a valid TimeOnly.`);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_Subtraction(left, right) {\n    return add(left, -right);\n}\n","import { trim } from \"./String.js\";\n// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220\n// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;\n// Relax GUID parsing, see #1637\nconst guidRegex = /^[\\(\\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\\)\\}]{0,2}$/;\nconst guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;\nconst guidRegexHex = /^\\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\\}\\}$/;\nconst guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;\nexport function toString(str, format, _provider) {\n    if (format && (format === null || format === void 0 ? void 0 : format.length) > 0) {\n        switch (format) {\n            case \"N\":\n                return str.replace(/-/g, '');\n            case \"D\":\n                return str;\n            case \"B\":\n                return \"{\" + str + \"}\";\n            case \"P\":\n                return \"(\" + str + \")\";\n            case \"X\":\n                return str.replace(guidHexCaptures, \"{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}\");\n            default:\n                throw new Error(\"Unrecognized Guid print format\");\n        }\n    }\n    else {\n        return str;\n    }\n}\n/** Validates UUID as specified in RFC4122 (versions 1-5). */\nexport function parse(str) {\n    function hyphenateGuid(str) {\n        return str.replace(guidRegexNoHyphen, \"$1-$2-$3-$4-$5\");\n    }\n    const wsTrimAndLowered = str.trim().toLowerCase();\n    if (guidRegex.test(wsTrimAndLowered)) {\n        return trim(wsTrimAndLowered, \"{\", \"}\", \"(\", \")\");\n    }\n    else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered);\n    }\n    else if (guidRegexHex.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered.replace(/[\\{\\},]|0x/g, ''));\n    }\n    else {\n        throw new Error(\"Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\");\n    }\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = parse(str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n// From https://gist.github.com/LeverOne/1308368\nexport function newGuid() {\n    let b = \"\";\n    for (let a = 0; a++ < 36;) {\n        b += a * 51 & 52\n            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)\n            : \"-\";\n    }\n    return b;\n}\n// Maps for number <-> hex string conversion\nlet _convertMapsInitialized = false;\nlet _byteToHex;\nlet _hexToByte;\nfunction initConvertMaps() {\n    _byteToHex = new Array(256);\n    _hexToByte = {};\n    for (let i = 0; i < 256; i++) {\n        _byteToHex[i] = (i + 0x100).toString(16).substr(1);\n        _hexToByte[_byteToHex[i]] = i;\n    }\n    _convertMapsInitialized = true;\n}\n/** Parse a UUID into it's component bytes */\n// Adapted from https://github.com/zefferus/uuid-parse\nexport function guidToArray(s) {\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    let i = 0;\n    const buf = new Uint8Array(16);\n    s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct) => {\n        switch (i) {\n            // .NET saves first three byte groups with different endianness\n            // See https://stackoverflow.com/a/16722909/3922220\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n                buf[3 - i++] = _hexToByte[oct];\n                break;\n            case 4:\n            case 5:\n                buf[9 - i++] = _hexToByte[oct];\n                break;\n            case 6:\n            case 7:\n                buf[13 - i++] = _hexToByte[oct];\n                break;\n            case 8:\n            case 9:\n            case 10:\n            case 11:\n            case 12:\n            case 13:\n            case 14:\n            case 15:\n                buf[i++] = _hexToByte[oct];\n                break;\n        }\n    }));\n    // Zero out remaining bytes if string was short\n    while (i < 16) {\n        buf[i++] = 0;\n    }\n    return buf;\n}\n/** Convert UUID byte array into a string */\nexport function arrayToGuid(buf) {\n    if (buf.length !== 16) {\n        throw new Error(\"Byte array for GUID must be exactly 16 bytes long\");\n    }\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    const guid = _byteToHex[buf[3]] + _byteToHex[buf[2]] +\n        _byteToHex[buf[1]] + _byteToHex[buf[0]] + \"-\" +\n        _byteToHex[buf[5]] + _byteToHex[buf[4]] + \"-\" +\n        _byteToHex[buf[7]] + _byteToHex[buf[6]] + \"-\" +\n        _byteToHex[buf[8]] + _byteToHex[buf[9]] + \"-\" +\n        _byteToHex[buf[10]] + _byteToHex[buf[11]] +\n        _byteToHex[buf[12]] + _byteToHex[buf[13]] +\n        _byteToHex[buf[14]] + _byteToHex[buf[15]];\n    return guid;\n}\n","import { fromBits, getHighBits, getHighBitsUnsigned, getLowBits, getLowBitsUnsigned } from \"./Long.js\";\nconst littleEndian = true;\nexport function isLittleEndian() {\n    return littleEndian;\n}\nexport function getBytesBoolean(value) {\n    const bytes = new Uint8Array(1);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint8(0, value ? 1 : 0);\n    return bytes;\n}\nexport function getBytesChar(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint16(0, value.charCodeAt(0), littleEndian);\n    return bytes;\n}\nexport function getBytesInt16(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt16(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesInt32(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesInt64(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt32(littleEndian ? 0 : 4, getLowBits(value), littleEndian);\n    view.setInt32(littleEndian ? 4 : 0, getHighBits(value), littleEndian);\n    return bytes;\n}\nexport function getBytesUInt16(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint16(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesUInt32(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesUInt64(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint32(littleEndian ? 0 : 4, getLowBitsUnsigned(value), littleEndian);\n    view.setUint32(littleEndian ? 4 : 0, getHighBitsUnsigned(value), littleEndian);\n    return bytes;\n}\nexport function getBytesSingle(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setFloat32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesDouble(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setFloat64(0, value, littleEndian);\n    return bytes;\n}\nexport function int64BitsToDouble(value) {\n    const buffer = new ArrayBuffer(8);\n    const view = new DataView(buffer);\n    view.setInt32(littleEndian ? 0 : 4, getLowBits(value), littleEndian);\n    view.setInt32(littleEndian ? 4 : 0, getHighBits(value), littleEndian);\n    return view.getFloat64(0, littleEndian);\n}\nexport function doubleToInt64Bits(value) {\n    const buffer = new ArrayBuffer(8);\n    const view = new DataView(buffer);\n    view.setFloat64(0, value, littleEndian);\n    const lowBits = view.getInt32(littleEndian ? 0 : 4, littleEndian);\n    const highBits = view.getInt32(littleEndian ? 4 : 0, littleEndian);\n    return fromBits(lowBits, highBits, false);\n}\nexport function toBoolean(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint8(offset) === 1 ? true : false;\n}\nexport function toChar(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const code = view.getUint16(offset, littleEndian);\n    return String.fromCharCode(code);\n}\nexport function toInt16(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getInt16(offset, littleEndian);\n}\nexport function toInt32(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getInt32(offset, littleEndian);\n}\nexport function toInt64(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const lowBits = view.getInt32(offset + (littleEndian ? 0 : 4), littleEndian);\n    const highBits = view.getInt32(offset + (littleEndian ? 4 : 0), littleEndian);\n    return fromBits(lowBits, highBits, false);\n}\nexport function toUInt16(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint16(offset, littleEndian);\n}\nexport function toUInt32(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint32(offset, littleEndian);\n}\nexport function toUInt64(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const lowBits = view.getUint32(offset + (littleEndian ? 0 : 4), littleEndian);\n    const highBits = view.getUint32(offset + (littleEndian ? 4 : 0), littleEndian);\n    return fromBits(lowBits, highBits, true);\n}\nexport function toSingle(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getFloat32(offset, littleEndian);\n}\nexport function toDouble(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getFloat64(offset, littleEndian);\n}\nexport function toString(bytes, offset, count) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);\n    if (offset != null && count != null) {\n        buffer = buffer.subarray(offset, offset + count);\n    }\n    else if (offset != null) {\n        buffer = buffer.subarray(offset);\n    }\n    return Array.from(buffer).map((b) => (\"0\" + b.toString(16)).slice(-2)).join(\"-\");\n}\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { toString, Record } from \"./Types.js\";\r\nimport { FSharpList, fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1 } from \"./List.js\";\r\nimport { fold as fold_1, fill } from \"./Array.js\";\r\nimport { structuralHash, toIterator, disposeSafe, getEnumerator, isArrayLike } from \"./Util.js\";\r\nimport { join } from \"./String.js\";\r\nimport { exists as exists_1, cache, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from \"./Seq.js\";\r\nimport { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from \"./MutableSet.js\";\r\n\r\nexport class SetTreeLeaf$1 {\r\n    constructor(k) {\r\n        this.k = k;\r\n    }\r\n}\r\n\r\nexport function SetTreeLeaf$1$reflection(gen0) {\r\n    return class_type(\"Set.SetTreeLeaf`1\", [gen0], SetTreeLeaf$1);\r\n}\r\n\r\nexport function SetTreeLeaf$1_$ctor_2B595(k) {\r\n    return new SetTreeLeaf$1(k);\r\n}\r\n\r\nexport function SetTreeLeaf$1__get_Key(_) {\r\n    return _.k;\r\n}\r\n\r\nexport class SetTreeNode$1 extends SetTreeLeaf$1 {\r\n    constructor(v, left, right, h) {\r\n        super(v);\r\n        this.left = left;\r\n        this.right = right;\r\n        this.h = (h | 0);\r\n    }\r\n}\r\n\r\nexport function SetTreeNode$1$reflection(gen0) {\r\n    return class_type(\"Set.SetTreeNode`1\", [gen0], SetTreeNode$1, SetTreeLeaf$1$reflection(gen0));\r\n}\r\n\r\nexport function SetTreeNode$1_$ctor_Z6E7BE5F7(v, left, right, h) {\r\n    return new SetTreeNode$1(v, left, right, h);\r\n}\r\n\r\nexport function SetTreeNode$1__get_Left(_) {\r\n    return _.left;\r\n}\r\n\r\nexport function SetTreeNode$1__get_Right(_) {\r\n    return _.right;\r\n}\r\n\r\nexport function SetTreeNode$1__get_Height(_) {\r\n    return _.h;\r\n}\r\n\r\nexport function SetTreeModule_empty() {\r\n    return void 0;\r\n}\r\n\r\nexport function SetTreeModule_countAux(t_mut, acc_mut) {\r\n    SetTreeModule_countAux:\r\n    while (true) {\r\n        const t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_countAux(SetTreeNode$1__get_Right(t2), acc + 1);\r\n                continue SetTreeModule_countAux;\r\n            }\r\n            else {\r\n                return (acc + 1) | 0;\r\n            }\r\n        }\r\n        else {\r\n            return acc | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_count(s) {\r\n    return SetTreeModule_countAux(s, 0);\r\n}\r\n\r\nexport function SetTreeModule_mk(l, k, r) {\r\n    let hl;\r\n    const t = l;\r\n    if (t != null) {\r\n        const t2 = t;\r\n        hl = ((t2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2) : 1);\r\n    }\r\n    else {\r\n        hl = 0;\r\n    }\r\n    let hr;\r\n    const t_1 = r;\r\n    if (t_1 != null) {\r\n        const t2_1 = t_1;\r\n        hr = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\r\n    }\r\n    else {\r\n        hr = 0;\r\n    }\r\n    const m = ((hl < hr) ? hr : hl) | 0;\r\n    if (m === 0) {\r\n        return SetTreeLeaf$1_$ctor_2B595(k);\r\n    }\r\n    else {\r\n        return SetTreeNode$1_$ctor_Z6E7BE5F7(k, l, r, m + 1);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_rebalance(t1, v, t2) {\r\n    let t_2, t2_3, t_3, t2_4;\r\n    let t1h;\r\n    const t = t1;\r\n    if (t != null) {\r\n        const t2_1 = t;\r\n        t1h = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\r\n    }\r\n    else {\r\n        t1h = 0;\r\n    }\r\n    let t2h;\r\n    const t_1 = t2;\r\n    if (t_1 != null) {\r\n        const t2_2 = t_1;\r\n        t2h = ((t2_2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_2) : 1);\r\n    }\r\n    else {\r\n        t2h = 0;\r\n    }\r\n    if (t2h > (t1h + 2)) {\r\n        const matchValue = value_1(t2);\r\n        if (matchValue instanceof SetTreeNode$1) {\r\n            if (((t_2 = SetTreeNode$1__get_Left(matchValue), (t_2 != null) ? ((t2_3 = t_2, (t2_3 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_3) : 1)) : 0)) > (t1h + 1)) {\r\n                const matchValue_1 = value_1(SetTreeNode$1__get_Left(matchValue));\r\n                if (matchValue_1 instanceof SetTreeNode$1) {\r\n                    return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue_1)), SetTreeLeaf$1__get_Key(matchValue_1), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_1), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue)));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Set.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue)), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Set.rebalance\"));\r\n        }\r\n    }\r\n    else if (t1h > (t2h + 2)) {\r\n        const matchValue_2 = value_1(t1);\r\n        if (matchValue_2 instanceof SetTreeNode$1) {\r\n            if (((t_3 = SetTreeNode$1__get_Right(matchValue_2), (t_3 != null) ? ((t2_4 = t_3, (t2_4 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_4) : 1)) : 0)) > (t2h + 1)) {\r\n                const matchValue_3 = value_1(SetTreeNode$1__get_Right(matchValue_2));\r\n                if (matchValue_3 instanceof SetTreeNode$1) {\r\n                    return SetTreeModule_mk(SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeNode$1__get_Left(matchValue_3)), SetTreeLeaf$1__get_Key(matchValue_3), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_3), v, t2));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Set.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_2), v, t2));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Set.rebalance\"));\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_mk(t1, v, t2);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_add(comparer, k, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (c < 0) {\r\n                return SetTreeModule_rebalance(SetTreeModule_add(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\r\n            }\r\n            else if (c === 0) {\r\n                return t;\r\n            }\r\n            else {\r\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_add(comparer, k, SetTreeNode$1__get_Right(t2)));\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (c_1 < 0) {\r\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, SetTreeModule_empty(), t, 2);\r\n            }\r\n            else if (c_1 === 0) {\r\n                return t;\r\n            }\r\n            else {\r\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, t, SetTreeModule_empty(), 2);\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeLeaf$1_$ctor_2B595(k);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_balance(comparer, t1, k, t2) {\r\n    if (t1 != null) {\r\n        const t1$0027 = t1;\r\n        if (t2 != null) {\r\n            const t2$0027 = t2;\r\n            if (t1$0027 instanceof SetTreeNode$1) {\r\n                if (t2$0027 instanceof SetTreeNode$1) {\r\n                    if ((SetTreeNode$1__get_Height(t1$0027) + 2) < SetTreeNode$1__get_Height(t2$0027)) {\r\n                        return SetTreeModule_rebalance(SetTreeModule_balance(comparer, t1, k, SetTreeNode$1__get_Left(t2$0027)), SetTreeLeaf$1__get_Key(t2$0027), SetTreeNode$1__get_Right(t2$0027));\r\n                    }\r\n                    else if ((SetTreeNode$1__get_Height(t2$0027) + 2) < SetTreeNode$1__get_Height(t1$0027)) {\r\n                        return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t1$0027), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_balance(comparer, SetTreeNode$1__get_Right(t1$0027), k, t2));\r\n                    }\r\n                    else {\r\n                        return SetTreeModule_mk(t1, k, t2);\r\n                    }\r\n                }\r\n                else {\r\n                    return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2));\r\n            }\r\n        }\r\n        else {\r\n            return SetTreeModule_add(comparer, k, t1);\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_add(comparer, k, t2);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_split(comparer, pivot, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            const c = comparer.Compare(pivot, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (c < 0) {\r\n                const patternInput = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Left(t2));\r\n                return [patternInput[0], patternInput[1], SetTreeModule_balance(comparer, patternInput[2], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\r\n            }\r\n            else if (c === 0) {\r\n                return [SetTreeNode$1__get_Left(t2), true, SetTreeNode$1__get_Right(t2)];\r\n            }\r\n            else {\r\n                const patternInput_1 = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Right(t2));\r\n                return [SetTreeModule_balance(comparer, SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), patternInput_1[0]), patternInput_1[1], patternInput_1[2]];\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(t2), pivot) | 0;\r\n            if (c_1 < 0) {\r\n                return [t, false, SetTreeModule_empty()];\r\n            }\r\n            else if (c_1 === 0) {\r\n                return [SetTreeModule_empty(), true, SetTreeModule_empty()];\r\n            }\r\n            else {\r\n                return [SetTreeModule_empty(), false, t];\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        return [SetTreeModule_empty(), false, SetTreeModule_empty()];\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_spliceOutSuccessor(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (SetTreeNode$1__get_Left(t2) == null) {\r\n                return [SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2)];\r\n            }\r\n            else {\r\n                const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Left(t2));\r\n                return [patternInput[0], SetTreeModule_mk(patternInput[1], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\r\n            }\r\n        }\r\n        else {\r\n            return [SetTreeLeaf$1__get_Key(t2), SetTreeModule_empty()];\r\n        }\r\n    }\r\n    else {\r\n        throw (new Error(\"internal error: Set.spliceOutSuccessor\"));\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_remove(comparer, k, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (c < 0) {\r\n                return SetTreeModule_rebalance(SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\r\n            }\r\n            else if (c === 0) {\r\n                if (SetTreeNode$1__get_Left(t2) == null) {\r\n                    return SetTreeNode$1__get_Right(t2);\r\n                }\r\n                else if (SetTreeNode$1__get_Right(t2) == null) {\r\n                    return SetTreeNode$1__get_Left(t2);\r\n                }\r\n                else {\r\n                    const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Right(t2));\r\n                    return SetTreeModule_mk(SetTreeNode$1__get_Left(t2), patternInput[0], patternInput[1]);\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Right(t2)));\r\n            }\r\n        }\r\n        else if (c === 0) {\r\n            return SetTreeModule_empty();\r\n        }\r\n        else {\r\n            return t;\r\n        }\r\n    }\r\n    else {\r\n        return t;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {\r\n    SetTreeModule_mem:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (c < 0) {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    t_mut = SetTreeNode$1__get_Left(t2);\r\n                    continue SetTreeModule_mem;\r\n                }\r\n                else if (c === 0) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_mem;\r\n                }\r\n            }\r\n            else {\r\n                return c === 0;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_iter(f_mut, t_mut) {\r\n    SetTreeModule_iter:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                SetTreeModule_iter(f, SetTreeNode$1__get_Left(t2));\r\n                f(SetTreeLeaf$1__get_Key(t2));\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                continue SetTreeModule_iter;\r\n            }\r\n            else {\r\n                f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_foldBackOpt(f_mut, t_mut, x_mut) {\r\n    SetTreeModule_foldBackOpt:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut, x = x_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                x_mut = f(SetTreeLeaf$1__get_Key(t2), SetTreeModule_foldBackOpt(f, SetTreeNode$1__get_Right(t2), x));\r\n                continue SetTreeModule_foldBackOpt;\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2), x);\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_foldBack(f, m, x) {\r\n    return SetTreeModule_foldBackOpt(f, m, x);\r\n}\r\n\r\nexport function SetTreeModule_foldOpt(f_mut, x_mut, t_mut) {\r\n    SetTreeModule_foldOpt:\r\n    while (true) {\r\n        const f = f_mut, x = x_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                f_mut = f;\r\n                x_mut = f(SetTreeModule_foldOpt(f, x, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2));\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                continue SetTreeModule_foldOpt;\r\n            }\r\n            else {\r\n                return f(x, SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_fold(f, x, m) {\r\n    return SetTreeModule_foldOpt(f, x, m);\r\n}\r\n\r\nexport function SetTreeModule_forall(f_mut, t_mut) {\r\n    SetTreeModule_forall:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (f(SetTreeLeaf$1__get_Key(t2)) && SetTreeModule_forall(f, SetTreeNode$1__get_Left(t2))) {\r\n                    f_mut = f;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_forall;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_exists(f_mut, t_mut) {\r\n    SetTreeModule_exists:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (f(SetTreeLeaf$1__get_Key(t2)) ? true : SetTreeModule_exists(f, SetTreeNode$1__get_Left(t2))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_exists;\r\n                }\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_subset(comparer, a, b) {\r\n    return SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a);\r\n}\r\n\r\nexport function SetTreeModule_properSubset(comparer, a, b) {\r\n    if (SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a)) {\r\n        return SetTreeModule_exists((x_1) => (!SetTreeModule_mem(comparer, x_1, a)), b);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_filterAux(comparer_mut, f_mut, t_mut, acc_mut) {\r\n    SetTreeModule_filterAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_1 = f(SetTreeLeaf$1__get_Key(t2)) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc) : acc;\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_filterAux(comparer, f, SetTreeNode$1__get_Right(t2), acc_1);\r\n                continue SetTreeModule_filterAux;\r\n            }\r\n            else if (f(SetTreeLeaf$1__get_Key(t2))) {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_filter(comparer, f, s) {\r\n    return SetTreeModule_filterAux(comparer, f, s, SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_diffAux(comparer_mut, t_mut, acc_mut) {\r\n    SetTreeModule_diffAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, t = t_mut, acc = acc_mut;\r\n        if (acc == null) {\r\n            return acc;\r\n        }\r\n        else if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                comparer_mut = comparer;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_diffAux(comparer, SetTreeNode$1__get_Right(t2), SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc));\r\n                continue SetTreeModule_diffAux;\r\n            }\r\n            else {\r\n                return SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_diff(comparer, a, b) {\r\n    return SetTreeModule_diffAux(comparer, b, a);\r\n}\r\n\r\nexport function SetTreeModule_union(comparer, t1, t2) {\r\n    if (t1 != null) {\r\n        const t1$0027 = t1;\r\n        if (t2 != null) {\r\n            const t2$0027 = t2;\r\n            if (t1$0027 instanceof SetTreeNode$1) {\r\n                if (t2$0027 instanceof SetTreeNode$1) {\r\n                    if (SetTreeNode$1__get_Height(t1$0027) > SetTreeNode$1__get_Height(t2$0027)) {\r\n                        const patternInput = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\r\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t1$0027), patternInput[0]), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t1$0027), patternInput[2]));\r\n                    }\r\n                    else {\r\n                        const patternInput_1 = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\r\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t2$0027), patternInput_1[0]), SetTreeLeaf$1__get_Key(t2$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t2$0027), patternInput_1[2]));\r\n                    }\r\n                }\r\n                else {\r\n                    return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\r\n            }\r\n        }\r\n        else {\r\n            return t1;\r\n        }\r\n    }\r\n    else {\r\n        return t2;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_intersectionAux(comparer_mut, b_mut, t_mut, acc_mut) {\r\n    SetTreeModule_intersectionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, b = b_mut, t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_1 = SetTreeModule_intersectionAux(comparer, b, SetTreeNode$1__get_Right(t2), acc);\r\n                const acc_2 = SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc_1) : acc_1;\r\n                comparer_mut = comparer;\r\n                b_mut = b;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = acc_2;\r\n                continue SetTreeModule_intersectionAux;\r\n            }\r\n            else if (SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b)) {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_intersection(comparer, a, b) {\r\n    return SetTreeModule_intersectionAux(comparer, b, a, SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_partition1(comparer, f, k, acc1, acc2) {\r\n    if (f(k)) {\r\n        return [SetTreeModule_add(comparer, k, acc1), acc2];\r\n    }\r\n    else {\r\n        return [acc1, SetTreeModule_add(comparer, k, acc2)];\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_partitionAux(comparer_mut, f_mut, t_mut, acc_0_mut, acc_1_mut) {\r\n    SetTreeModule_partitionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\r\n        const acc = [acc_0, acc_1];\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_2 = SetTreeModule_partitionAux(comparer, f, SetTreeNode$1__get_Right(t2), acc[0], acc[1]);\r\n                const acc_3 = SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc_2[0], acc_2[1]);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_0_mut = acc_3[0];\r\n                acc_1_mut = acc_3[1];\r\n                continue SetTreeModule_partitionAux;\r\n            }\r\n            else {\r\n                return SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc[0], acc[1]);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_partition(comparer, f, s) {\r\n    return SetTreeModule_partitionAux(comparer, f, s, SetTreeModule_empty(), SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_minimumElementAux(t_mut, n_mut) {\r\n    SetTreeModule_minimumElementAux:\r\n    while (true) {\r\n        const t = t_mut, n = n_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                n_mut = SetTreeLeaf$1__get_Key(t2);\r\n                continue SetTreeModule_minimumElementAux;\r\n            }\r\n            else {\r\n                return SetTreeLeaf$1__get_Key(t2);\r\n            }\r\n        }\r\n        else {\r\n            return n;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_minimumElementOpt(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            return some(SetTreeModule_minimumElementAux(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2)));\r\n        }\r\n        else {\r\n            return some(SetTreeLeaf$1__get_Key(t2));\r\n        }\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElementAux(t_mut, n_mut) {\r\n    SetTreeModule_maximumElementAux:\r\n    while (true) {\r\n        const t = t_mut, n = n_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                n_mut = SetTreeLeaf$1__get_Key(t2);\r\n                continue SetTreeModule_maximumElementAux;\r\n            }\r\n            else {\r\n                return SetTreeLeaf$1__get_Key(t2);\r\n            }\r\n        }\r\n        else {\r\n            return n;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElementOpt(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            return some(SetTreeModule_maximumElementAux(SetTreeNode$1__get_Right(t2), SetTreeLeaf$1__get_Key(t2)));\r\n        }\r\n        else {\r\n            return some(SetTreeLeaf$1__get_Key(t2));\r\n        }\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_minimumElement(s) {\r\n    const matchValue = SetTreeModule_minimumElementOpt(s);\r\n    if (matchValue == null) {\r\n        throw (new Error(\"Set contains no elements\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElement(s) {\r\n    const matchValue = SetTreeModule_maximumElementOpt(s);\r\n    if (matchValue == null) {\r\n        throw (new Error(\"Set contains no elements\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport class SetTreeModule_SetIterator$1 extends Record {\r\n    constructor(stack, started) {\r\n        super();\r\n        this.stack = stack;\r\n        this.started = started;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_SetIterator$1$reflection(gen0) {\r\n    return record_type(\"Set.SetTreeModule.SetIterator`1\", [gen0], SetTreeModule_SetIterator$1, () => [[\"stack\", list_type(option_type(SetTreeLeaf$1$reflection(gen0)))], [\"started\", bool_type]]);\r\n}\r\n\r\nexport function SetTreeModule_collapseLHS(stack_mut) {\r\n    SetTreeModule_collapseLHS:\r\n    while (true) {\r\n        const stack = stack_mut;\r\n        if (!isEmpty_1(stack)) {\r\n            const x = head(stack);\r\n            const rest = tail(stack);\r\n            if (x != null) {\r\n                const x2 = x;\r\n                if (x2 instanceof SetTreeNode$1) {\r\n                    stack_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2)), SetTreeNode$1__get_Right(x2)], rest);\r\n                    continue SetTreeModule_collapseLHS;\r\n                }\r\n                else {\r\n                    return stack;\r\n                }\r\n            }\r\n            else {\r\n                stack_mut = rest;\r\n                continue SetTreeModule_collapseLHS;\r\n            }\r\n        }\r\n        else {\r\n            return empty_1();\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mkIterator(s) {\r\n    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(singleton_1(s)), false);\r\n}\r\n\r\nexport function SetTreeModule_notStarted() {\r\n    throw (new Error(\"Enumeration not started\"));\r\n}\r\n\r\nexport function SetTreeModule_alreadyFinished() {\r\n    throw (new Error(\"Enumeration already started\"));\r\n}\r\n\r\nexport function SetTreeModule_current(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (isEmpty_1(matchValue)) {\r\n            return SetTreeModule_alreadyFinished();\r\n        }\r\n        else if (head(matchValue) != null) {\r\n            const t = head(matchValue);\r\n            return SetTreeLeaf$1__get_Key(t);\r\n        }\r\n        else {\r\n            throw (new Error(\"Please report error: Set iterator, unexpected stack for current\"));\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_notStarted();\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_moveNext(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const t = head(matchValue);\r\n                if (t instanceof SetTreeNode$1) {\r\n                    throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\r\n                }\r\n                else {\r\n                    i.stack = SetTreeModule_collapseLHS(tail(matchValue));\r\n                    return !isEmpty_1(i.stack);\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else {\r\n        i.started = true;\r\n        return !isEmpty_1(i.stack);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mkIEnumerator(s) {\r\n    let i = SetTreeModule_mkIterator(s);\r\n    return {\r\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n            return SetTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.get_Current\"]() {\r\n            return SetTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n            return SetTreeModule_moveNext(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.Reset\"]() {\r\n            i = SetTreeModule_mkIterator(s);\r\n        },\r\n        Dispose() {\r\n        },\r\n    };\r\n}\r\n\r\nexport function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {\r\n    SetTreeModule_compareStacks:\r\n    while (true) {\r\n        const comparer = comparer_mut, l1 = l1_mut, l2 = l2_mut;\r\n        const matchValue = [l1, l2];\r\n        if (!isEmpty_1(matchValue[0])) {\r\n            if (!isEmpty_1(matchValue[1])) {\r\n                if (head(matchValue[1]) != null) {\r\n                    if (head(matchValue[0]) != null) {\r\n                        const x1_3 = head(matchValue[0]);\r\n                        const x2_3 = head(matchValue[1]);\r\n                        if (x1_3 instanceof SetTreeNode$1) {\r\n                            if (SetTreeNode$1__get_Left(x1_3) == null) {\r\n                                if (x2_3 instanceof SetTreeNode$1) {\r\n                                    if (SetTreeNode$1__get_Left(x2_3) == null) {\r\n                                        const c = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                        if (c !== 0) {\r\n                                            return c | 0;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = cons(SetTreeNode$1__get_Right(x1_3), tail(matchValue[0]));\r\n                                            l2_mut = cons(SetTreeNode$1__get_Right(x2_3), tail(matchValue[1]));\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        const matchValue_3 = [l1, l2];\r\n                                        let pattern_matching_result, t1_6, x1_4, t2_6, x2_4;\r\n                                        if (!isEmpty_1(matchValue_3[0])) {\r\n                                            if (head(matchValue_3[0]) != null) {\r\n                                                pattern_matching_result = 0;\r\n                                                t1_6 = tail(matchValue_3[0]);\r\n                                                x1_4 = head(matchValue_3[0]);\r\n                                            }\r\n                                            else if (!isEmpty_1(matchValue_3[1])) {\r\n                                                if (head(matchValue_3[1]) != null) {\r\n                                                    pattern_matching_result = 1;\r\n                                                    t2_6 = tail(matchValue_3[1]);\r\n                                                    x2_4 = head(matchValue_3[1]);\r\n                                                }\r\n                                                else {\r\n                                                    pattern_matching_result = 2;\r\n                                                }\r\n                                            }\r\n                                            else {\r\n                                                pattern_matching_result = 2;\r\n                                            }\r\n                                        }\r\n                                        else if (!isEmpty_1(matchValue_3[1])) {\r\n                                            if (head(matchValue_3[1]) != null) {\r\n                                                pattern_matching_result = 1;\r\n                                                t2_6 = tail(matchValue_3[1]);\r\n                                                x2_4 = head(matchValue_3[1]);\r\n                                            }\r\n                                            else {\r\n                                                pattern_matching_result = 2;\r\n                                            }\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result = 2;\r\n                                        }\r\n                                        switch (pattern_matching_result) {\r\n                                            case 0: {\r\n                                                if (x1_4 instanceof SetTreeNode$1) {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_4), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_4), 0)], t1_6);\r\n                                                    l2_mut = l2;\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                                else {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_4))], t1_6);\r\n                                                    l2_mut = l2;\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                            }\r\n                                            case 1: {\r\n                                                if (x2_4 instanceof SetTreeNode$1) {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = l1;\r\n                                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_4), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_4), 0)], t2_6);\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                                else {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = l1;\r\n                                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_4))], t2_6);\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                            }\r\n                                            case 2: {\r\n                                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                            }\r\n                                        }\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                    if (c_1 !== 0) {\r\n                                        return c_1 | 0;\r\n                                    }\r\n                                    else {\r\n                                        comparer_mut = comparer;\r\n                                        l1_mut = cons(SetTreeNode$1__get_Right(x1_3), tail(matchValue[0]));\r\n                                        l2_mut = cons(SetTreeModule_empty(), tail(matchValue[1]));\r\n                                        continue SetTreeModule_compareStacks;\r\n                                    }\r\n                                }\r\n                            }\r\n                            else {\r\n                                const matchValue_4 = [l1, l2];\r\n                                let pattern_matching_result_1, t1_7, x1_5, t2_7, x2_5;\r\n                                if (!isEmpty_1(matchValue_4[0])) {\r\n                                    if (head(matchValue_4[0]) != null) {\r\n                                        pattern_matching_result_1 = 0;\r\n                                        t1_7 = tail(matchValue_4[0]);\r\n                                        x1_5 = head(matchValue_4[0]);\r\n                                    }\r\n                                    else if (!isEmpty_1(matchValue_4[1])) {\r\n                                        if (head(matchValue_4[1]) != null) {\r\n                                            pattern_matching_result_1 = 1;\r\n                                            t2_7 = tail(matchValue_4[1]);\r\n                                            x2_5 = head(matchValue_4[1]);\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result_1 = 2;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_1 = 2;\r\n                                    }\r\n                                }\r\n                                else if (!isEmpty_1(matchValue_4[1])) {\r\n                                    if (head(matchValue_4[1]) != null) {\r\n                                        pattern_matching_result_1 = 1;\r\n                                        t2_7 = tail(matchValue_4[1]);\r\n                                        x2_5 = head(matchValue_4[1]);\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_1 = 2;\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_1 = 2;\r\n                                }\r\n                                switch (pattern_matching_result_1) {\r\n                                    case 0: {\r\n                                        if (x1_5 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_5), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_5), 0)], t1_7);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_5))], t1_7);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 1: {\r\n                                        if (x2_5 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_5), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_5), 0)], t2_7);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_5))], t2_7);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 2: {\r\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        else if (x2_3 instanceof SetTreeNode$1) {\r\n                            if (SetTreeNode$1__get_Left(x2_3) == null) {\r\n                                const c_2 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                if (c_2 !== 0) {\r\n                                    return c_2 | 0;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = cons(SetTreeModule_empty(), tail(matchValue[0]));\r\n                                    l2_mut = cons(SetTreeNode$1__get_Right(x2_3), tail(matchValue[1]));\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            else {\r\n                                const matchValue_5 = [l1, l2];\r\n                                let pattern_matching_result_2, t1_8, x1_6, t2_8, x2_6;\r\n                                if (!isEmpty_1(matchValue_5[0])) {\r\n                                    if (head(matchValue_5[0]) != null) {\r\n                                        pattern_matching_result_2 = 0;\r\n                                        t1_8 = tail(matchValue_5[0]);\r\n                                        x1_6 = head(matchValue_5[0]);\r\n                                    }\r\n                                    else if (!isEmpty_1(matchValue_5[1])) {\r\n                                        if (head(matchValue_5[1]) != null) {\r\n                                            pattern_matching_result_2 = 1;\r\n                                            t2_8 = tail(matchValue_5[1]);\r\n                                            x2_6 = head(matchValue_5[1]);\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result_2 = 2;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_2 = 2;\r\n                                    }\r\n                                }\r\n                                else if (!isEmpty_1(matchValue_5[1])) {\r\n                                    if (head(matchValue_5[1]) != null) {\r\n                                        pattern_matching_result_2 = 1;\r\n                                        t2_8 = tail(matchValue_5[1]);\r\n                                        x2_6 = head(matchValue_5[1]);\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_2 = 2;\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_2 = 2;\r\n                                }\r\n                                switch (pattern_matching_result_2) {\r\n                                    case 0: {\r\n                                        if (x1_6 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_6), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_6), 0)], t1_8);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_6))], t1_8);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 1: {\r\n                                        if (x2_6 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_6), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_6), 0)], t2_8);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_6))], t2_8);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 2: {\r\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        else {\r\n                            const c_3 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                            if (c_3 !== 0) {\r\n                                return c_3 | 0;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = tail(matchValue[0]);\r\n                                l2_mut = tail(matchValue[1]);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                    }\r\n                    else {\r\n                        const x2 = head(matchValue[1]);\r\n                        const matchValue_1 = [l1, l2];\r\n                        let pattern_matching_result_3, t1_2, x1, t2_2, x2_1;\r\n                        if (!isEmpty_1(matchValue_1[0])) {\r\n                            if (head(matchValue_1[0]) != null) {\r\n                                pattern_matching_result_3 = 0;\r\n                                t1_2 = tail(matchValue_1[0]);\r\n                                x1 = head(matchValue_1[0]);\r\n                            }\r\n                            else if (!isEmpty_1(matchValue_1[1])) {\r\n                                if (head(matchValue_1[1]) != null) {\r\n                                    pattern_matching_result_3 = 1;\r\n                                    t2_2 = tail(matchValue_1[1]);\r\n                                    x2_1 = head(matchValue_1[1]);\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_3 = 2;\r\n                                }\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_3 = 2;\r\n                            }\r\n                        }\r\n                        else if (!isEmpty_1(matchValue_1[1])) {\r\n                            if (head(matchValue_1[1]) != null) {\r\n                                pattern_matching_result_3 = 1;\r\n                                t2_2 = tail(matchValue_1[1]);\r\n                                x2_1 = head(matchValue_1[1]);\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_3 = 2;\r\n                            }\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_3 = 2;\r\n                        }\r\n                        switch (pattern_matching_result_3) {\r\n                            case 0: {\r\n                                if (x1 instanceof SetTreeNode$1) {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1), 0)], t1_2);\r\n                                    l2_mut = l2;\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1))], t1_2);\r\n                                    l2_mut = l2;\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            case 1: {\r\n                                if (x2_1 instanceof SetTreeNode$1) {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = l1;\r\n                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_1), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_1), 0)], t2_2);\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = l1;\r\n                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_1))], t2_2);\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            case 2: {\r\n                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                else if (head(matchValue[0]) != null) {\r\n                    const x1_1 = head(matchValue[0]);\r\n                    const matchValue_2 = [l1, l2];\r\n                    let pattern_matching_result_4, t1_4, x1_2, t2_4, x2_2;\r\n                    if (!isEmpty_1(matchValue_2[0])) {\r\n                        if (head(matchValue_2[0]) != null) {\r\n                            pattern_matching_result_4 = 0;\r\n                            t1_4 = tail(matchValue_2[0]);\r\n                            x1_2 = head(matchValue_2[0]);\r\n                        }\r\n                        else if (!isEmpty_1(matchValue_2[1])) {\r\n                            if (head(matchValue_2[1]) != null) {\r\n                                pattern_matching_result_4 = 1;\r\n                                t2_4 = tail(matchValue_2[1]);\r\n                                x2_2 = head(matchValue_2[1]);\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_4 = 2;\r\n                            }\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_4 = 2;\r\n                        }\r\n                    }\r\n                    else if (!isEmpty_1(matchValue_2[1])) {\r\n                        if (head(matchValue_2[1]) != null) {\r\n                            pattern_matching_result_4 = 1;\r\n                            t2_4 = tail(matchValue_2[1]);\r\n                            x2_2 = head(matchValue_2[1]);\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_4 = 2;\r\n                        }\r\n                    }\r\n                    else {\r\n                        pattern_matching_result_4 = 2;\r\n                    }\r\n                    switch (pattern_matching_result_4) {\r\n                        case 0: {\r\n                            if (x1_2 instanceof SetTreeNode$1) {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_2), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_2), 0)], t1_4);\r\n                                l2_mut = l2;\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_2))], t1_4);\r\n                                l2_mut = l2;\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                        case 1: {\r\n                            if (x2_2 instanceof SetTreeNode$1) {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = l1;\r\n                                l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_2), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_2), 0)], t2_4);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = l1;\r\n                                l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_2))], t2_4);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                        case 2: {\r\n                            throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    l1_mut = tail(matchValue[0]);\r\n                    l2_mut = tail(matchValue[1]);\r\n                    continue SetTreeModule_compareStacks;\r\n                }\r\n            }\r\n            else {\r\n                return 1;\r\n            }\r\n        }\r\n        else if (isEmpty_1(matchValue[1])) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_compare(comparer, t1, t2) {\r\n    if (t1 == null) {\r\n        if (t2 == null) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n    else if (t2 == null) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return SetTreeModule_compareStacks(comparer, singleton_1(t1), singleton_1(t2)) | 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_choose(s) {\r\n    return SetTreeModule_minimumElement(s);\r\n}\r\n\r\nexport function SetTreeModule_toList(t) {\r\n    const loop = (t$0027_mut, acc_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const t$0027 = t$0027_mut, acc = acc_mut;\r\n            if (t$0027 != null) {\r\n                const t2 = t$0027;\r\n                if (t2 instanceof SetTreeNode$1) {\r\n                    t$0027_mut = SetTreeNode$1__get_Left(t2);\r\n                    acc_mut = cons(SetTreeLeaf$1__get_Key(t2), loop(SetTreeNode$1__get_Right(t2), acc));\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return cons(SetTreeLeaf$1__get_Key(t2), acc);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(t, empty_1());\r\n}\r\n\r\nexport function SetTreeModule_copyToArray(s, arr, i) {\r\n    let j = i;\r\n    SetTreeModule_iter((x) => {\r\n        arr[j] = x;\r\n        j = ((j + 1) | 0);\r\n    }, s);\r\n}\r\n\r\nexport function SetTreeModule_toArray(s) {\r\n    const n = SetTreeModule_count(s) | 0;\r\n    const res = fill(new Array(n), 0, n, null);\r\n    SetTreeModule_copyToArray(s, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\r\n    SetTreeModule_mkFromEnumerator:\r\n    while (true) {\r\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            comparer_mut = comparer;\r\n            acc_mut = SetTreeModule_add(comparer, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), acc);\r\n            e_mut = e;\r\n            continue SetTreeModule_mkFromEnumerator;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_ofArray(comparer, l) {\r\n    return fold_1((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\r\n}\r\n\r\nexport function SetTreeModule_ofList(comparer, l) {\r\n    return fold_2((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\r\n}\r\n\r\nexport function SetTreeModule_ofSeq(comparer, c) {\r\n    if (isArrayLike(c)) {\r\n        return SetTreeModule_ofArray(comparer, c);\r\n    }\r\n    else if (c instanceof FSharpList) {\r\n        return SetTreeModule_ofList(comparer, c);\r\n    }\r\n    else {\r\n        const ie = getEnumerator(c);\r\n        try {\r\n            return SetTreeModule_mkFromEnumerator(comparer, SetTreeModule_empty(), ie);\r\n        }\r\n        finally {\r\n            disposeSafe(ie);\r\n        }\r\n    }\r\n}\r\n\r\nexport class FSharpSet {\r\n    constructor(comparer, tree) {\r\n        this.comparer = comparer;\r\n        this.tree = tree;\r\n    }\r\n    GetHashCode() {\r\n        const this$ = this;\r\n        return FSharpSet__ComputeHashCode(this$) | 0;\r\n    }\r\n    Equals(that) {\r\n        const this$ = this;\r\n        return (that instanceof FSharpSet) && (SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that)) === 0);\r\n    }\r\n    toString() {\r\n        const this$ = this;\r\n        return (\"set [\" + join(\"; \", map_1((x) => {\r\n            let copyOfStruct = x;\r\n            return toString(copyOfStruct);\r\n        }, this$))) + \"]\";\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"FSharpSet\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    CompareTo(that) {\r\n        const s = this;\r\n        return SetTreeModule_compare(FSharpSet__get_Comparer(s), FSharpSet__get_Tree(s), FSharpSet__get_Tree(that)) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\r\n        const s = this;\r\n        return SetTreeModule_mem(FSharpSet__get_Comparer(s), x, FSharpSet__get_Tree(s));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\r\n        const s = this;\r\n        SetTreeModule_copyToArray(FSharpSet__get_Tree(s), arr, i);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return true;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    GetEnumerator() {\r\n        const s = this;\r\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const s = this;\r\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\r\n    }\r\n    get size() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    add(k) {\r\n        const s = this;\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n        return s;\r\n    }\r\n    clear() {\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n    }\r\n    delete(k) {\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n        return false;\r\n    }\r\n    has(k) {\r\n        const s = this;\r\n        return FSharpSet__Contains(s, k);\r\n    }\r\n    keys() {\r\n        const s = this;\r\n        return map_1((x) => x, s);\r\n    }\r\n    values() {\r\n        const s = this;\r\n        return map_1((x) => x, s);\r\n    }\r\n    entries() {\r\n        const s = this;\r\n        return map_1((v) => [v, v], s);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const s = this;\r\n        iterate_1((x) => {\r\n            f(x, x, s);\r\n        }, s);\r\n    }\r\n}\r\n\r\nexport function FSharpSet$reflection(gen0) {\r\n    return class_type(\"Set.FSharpSet\", [gen0], FSharpSet);\r\n}\r\n\r\nexport function FSharpSet_$ctor(comparer, tree) {\r\n    return new FSharpSet(comparer, tree);\r\n}\r\n\r\nexport function FSharpSet__get_Comparer(set$) {\r\n    return set$.comparer;\r\n}\r\n\r\nexport function FSharpSet__get_Tree(set$) {\r\n    return set$.tree;\r\n}\r\n\r\nexport function FSharpSet_Empty(comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_empty());\r\n}\r\n\r\nexport function FSharpSet__Add(s, value) {\r\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_add(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__Remove(s, value) {\r\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_remove(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__get_Count(s) {\r\n    return SetTreeModule_count(FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Contains(s, value) {\r\n    return SetTreeModule_mem(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Iterate(s, x) {\r\n    SetTreeModule_iter(x, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Fold(s, f, z) {\r\n    const f_1 = f;\r\n    return SetTreeModule_fold((x, z_1) => f_1(z_1, x), z, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__get_IsEmpty(s) {\r\n    return FSharpSet__get_Tree(s) == null;\r\n}\r\n\r\nexport function FSharpSet__Partition(s, f) {\r\n    if (FSharpSet__get_Tree(s) == null) {\r\n        return [s, s];\r\n    }\r\n    else {\r\n        const patternInput = SetTreeModule_partition(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s));\r\n        return [FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[0]), FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[1])];\r\n    }\r\n}\r\n\r\nexport function FSharpSet__Filter(s, f) {\r\n    if (FSharpSet__get_Tree(s) == null) {\r\n        return s;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_filter(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet__Map(s, f, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_fold((acc, k) => SetTreeModule_add(comparer, f(k), acc), SetTreeModule_empty(), FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__Exists(s, f) {\r\n    return SetTreeModule_exists(f, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__ForAll(s, f) {\r\n    return SetTreeModule_forall(f, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet_op_Subtraction(set1, set2) {\r\n    if (FSharpSet__get_Tree(set1) == null) {\r\n        return set1;\r\n    }\r\n    else if (FSharpSet__get_Tree(set2) == null) {\r\n        return set1;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_diff(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_op_Addition(set1, set2) {\r\n    if (FSharpSet__get_Tree(set2) == null) {\r\n        return set1;\r\n    }\r\n    else if (FSharpSet__get_Tree(set1) == null) {\r\n        return set2;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_union(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_Intersection(a, b) {\r\n    if (FSharpSet__get_Tree(b) == null) {\r\n        return b;\r\n    }\r\n    else if (FSharpSet__get_Tree(a) == null) {\r\n        return a;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(a), SetTreeModule_intersection(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_IntersectionMany(sets) {\r\n    return reduce(FSharpSet_Intersection, sets);\r\n}\r\n\r\nexport function FSharpSet_Equality(a, b) {\r\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) === 0;\r\n}\r\n\r\nexport function FSharpSet_Compare(a, b) {\r\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b));\r\n}\r\n\r\nexport function FSharpSet__get_Choose(x) {\r\n    return SetTreeModule_choose(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__get_MinimumElement(x) {\r\n    return SetTreeModule_minimumElement(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__get_MaximumElement(x) {\r\n    return SetTreeModule_maximumElement(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__IsSubsetOf(x, otherSet) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\r\n}\r\n\r\nexport function FSharpSet__IsSupersetOf(x, otherSet) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__IsProperSubsetOf(x, otherSet) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\r\n}\r\n\r\nexport function FSharpSet__IsProperSupersetOf(x, otherSet) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ToList(x) {\r\n    return SetTreeModule_toList(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ToArray(x) {\r\n    return SetTreeModule_toArray(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ComputeHashCode(this$) {\r\n    let y;\r\n    let res = 0;\r\n    const enumerator = getEnumerator(this$);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const x_1 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            res = (((y = (structuralHash(x_1) | 0), ((res << 1) + y) + 631)) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return Math.abs(res) | 0;\r\n}\r\n\r\nexport function isEmpty(set$) {\r\n    return FSharpSet__get_IsEmpty(set$);\r\n}\r\n\r\nexport function contains(element, set$) {\r\n    return FSharpSet__Contains(set$, element);\r\n}\r\n\r\nexport function add(value, set$) {\r\n    return FSharpSet__Add(set$, value);\r\n}\r\n\r\nexport function singleton(value, comparer) {\r\n    return FSharpSet__Add(FSharpSet_Empty(comparer), value);\r\n}\r\n\r\nexport function remove(value, set$) {\r\n    return FSharpSet__Remove(set$, value);\r\n}\r\n\r\nexport function union(set1, set2) {\r\n    return FSharpSet_op_Addition(set1, set2);\r\n}\r\n\r\nexport function unionMany(sets, comparer) {\r\n    return fold_3(FSharpSet_op_Addition, FSharpSet_Empty(comparer), sets);\r\n}\r\n\r\nexport function intersect(set1, set2) {\r\n    return FSharpSet_Intersection(set1, set2);\r\n}\r\n\r\nexport function intersectMany(sets) {\r\n    return FSharpSet_IntersectionMany(sets);\r\n}\r\n\r\nexport function iterate(action, set$) {\r\n    FSharpSet__Iterate(set$, action);\r\n}\r\n\r\nexport function empty(comparer) {\r\n    return FSharpSet_Empty(comparer);\r\n}\r\n\r\nexport function forAll(predicate, set$) {\r\n    return FSharpSet__ForAll(set$, predicate);\r\n}\r\n\r\nexport function exists(predicate, set$) {\r\n    return FSharpSet__Exists(set$, predicate);\r\n}\r\n\r\nexport function filter(predicate, set$) {\r\n    return FSharpSet__Filter(set$, predicate);\r\n}\r\n\r\nexport function partition(predicate, set$) {\r\n    return FSharpSet__Partition(set$, predicate);\r\n}\r\n\r\nexport function fold(folder, state, set$) {\r\n    return SetTreeModule_fold(folder, state, FSharpSet__get_Tree(set$));\r\n}\r\n\r\nexport function foldBack(folder, set$, state) {\r\n    return SetTreeModule_foldBack(folder, FSharpSet__get_Tree(set$), state);\r\n}\r\n\r\nexport function map(mapping, set$, comparer) {\r\n    return FSharpSet__Map(set$, mapping, comparer);\r\n}\r\n\r\nexport function count(set$) {\r\n    return FSharpSet__get_Count(set$);\r\n}\r\n\r\nexport function ofList(elements, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\r\n}\r\n\r\nexport function ofArray(array, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofArray(comparer, array));\r\n}\r\n\r\nexport function toList(set$) {\r\n    return FSharpSet__ToList(set$);\r\n}\r\n\r\nexport function toArray(set$) {\r\n    return FSharpSet__ToArray(set$);\r\n}\r\n\r\nexport function toSeq(set$) {\r\n    return map_1((x) => x, set$);\r\n}\r\n\r\nexport function ofSeq(elements, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\r\n}\r\n\r\nexport function difference(set1, set2) {\r\n    return FSharpSet_op_Subtraction(set1, set2);\r\n}\r\n\r\nexport function isSubset(set1, set2) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\r\n}\r\n\r\nexport function isSuperset(set1, set2) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\r\n}\r\n\r\nexport function isProperSubset(set1, set2) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\r\n}\r\n\r\nexport function isProperSuperset(set1, set2) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\r\n}\r\n\r\nexport function minElement(set$) {\r\n    return FSharpSet__get_MinimumElement(set$);\r\n}\r\n\r\nexport function maxElement(set$) {\r\n    return FSharpSet__get_MaximumElement(set$);\r\n}\r\n\r\nexport function unionWith(s1, s2) {\r\n    return fold_3((acc, x) => acc.add(x), s1, s2);\r\n}\r\n\r\nexport function newMutableSetWith(s1, s2) {\r\n    if (s1 instanceof HashSet) {\r\n        return HashSet_$ctor_Z6150332D(s2, HashSet__get_Comparer(s1));\r\n    }\r\n    else {\r\n        return new Set(s2);\r\n    }\r\n}\r\n\r\nexport function intersectWith(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    iterate_1((x) => {\r\n        if (!s2_1.has(x)) {\r\n            s1.delete(x);\r\n        }\r\n    }, s1.values());\r\n}\r\n\r\nexport function exceptWith(s1, s2) {\r\n    iterate_1((x) => {\r\n        s1.delete(x);\r\n    }, s2);\r\n}\r\n\r\nexport function isSubsetOf(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    return forAll_1((arg00) => s2_1.has(arg00), s1.values());\r\n}\r\n\r\nexport function isSupersetOf(s1, s2) {\r\n    return forAll_1((arg00) => s1.has(arg00), s2);\r\n}\r\n\r\nexport function isProperSubsetOf(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    if (s2_1.size > s1.size) {\r\n        return forAll_1((arg00) => s2_1.has(arg00), s1.values());\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function isProperSupersetOf(s1, s2) {\r\n    const s2_1 = cache(s2);\r\n    if (exists_1((arg) => (!s1.has(arg)), s2_1)) {\r\n        return forAll_1((arg00_1) => s1.has(arg00_1), s2_1);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\n","import { disposeSafe, toIterator, getEnumerator } from \"./Util.js\";\r\nimport { iterate, map, iterateIndexed, concat } from \"./Seq.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\r\nimport { some } from \"./Option.js\";\r\n\r\nexport class HashSet {\r\n    constructor(items, comparer) {\r\n        const this$ = new FSharpRef(null);\r\n        this.comparer = comparer;\r\n        this$.contents = this;\r\n        this.hashMap = (new Map([]));\r\n        this[\"init@8-2\"] = 1;\r\n        const enumerator = getEnumerator(items);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const item = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                HashSet__Add_2B595(this$.contents, item);\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"HashSet\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const this$ = this;\r\n        return getEnumerator(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const this$ = this;\r\n        return getEnumerator(concat(this$.hashMap.values()));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\r\n        const this$ = this;\r\n        HashSet__Add_2B595(this$, item);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        const this$ = this;\r\n        HashSet__Clear(this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\r\n        const this$ = this;\r\n        return HashSet__Contains_2B595(this$, item);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\r\n        const this$ = this;\r\n        iterateIndexed((i, e) => {\r\n            array[arrayIndex + i] = e;\r\n        }, this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const this$ = this;\r\n        return HashSet__get_Count(this$) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return false;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\r\n        const this$ = this;\r\n        return HashSet__Remove_2B595(this$, item);\r\n    }\r\n    get size() {\r\n        const this$ = this;\r\n        return HashSet__get_Count(this$) | 0;\r\n    }\r\n    add(k) {\r\n        const this$ = this;\r\n        HashSet__Add_2B595(this$, k);\r\n        return this$;\r\n    }\r\n    clear() {\r\n        const this$ = this;\r\n        HashSet__Clear(this$);\r\n    }\r\n    delete(k) {\r\n        const this$ = this;\r\n        return HashSet__Remove_2B595(this$, k);\r\n    }\r\n    has(k) {\r\n        const this$ = this;\r\n        return HashSet__Contains_2B595(this$, k);\r\n    }\r\n    keys() {\r\n        const this$ = this;\r\n        return map((x) => x, this$);\r\n    }\r\n    values() {\r\n        const this$ = this;\r\n        return map((x) => x, this$);\r\n    }\r\n    entries() {\r\n        const this$ = this;\r\n        return map((v) => [v, v], this$);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const this$ = this;\r\n        iterate((x) => {\r\n            f(x, x, this$);\r\n        }, this$);\r\n    }\r\n}\r\n\r\nexport function HashSet$reflection(gen0) {\r\n    return class_type(\"Fable.Collections.HashSet\", [gen0], HashSet);\r\n}\r\n\r\nexport function HashSet_$ctor_Z6150332D(items, comparer) {\r\n    return new HashSet(items, comparer);\r\n}\r\n\r\nfunction HashSet__TryFindIndex_2B595(this$, k) {\r\n    const h = this$.comparer.GetHashCode(k) | 0;\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return [true, h, matchValue[1].findIndex((v_1) => this$.comparer.Equals(k, v_1))];\r\n    }\r\n    else {\r\n        return [false, h, -1];\r\n    }\r\n}\r\n\r\nfunction HashSet__TryFind_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__get_Comparer(this$) {\r\n    return this$.comparer;\r\n}\r\n\r\nexport function HashSet__Clear(this$) {\r\n    this$.hashMap.clear();\r\n}\r\n\r\nexport function HashSet__get_Count(this$) {\r\n    let count = 0;\r\n    let enumerator = getEnumerator(this$.hashMap.values());\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const items = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            count = ((count + items.length) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return count | 0;\r\n}\r\n\r\nexport function HashSet__Add_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return false;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));\r\n                return true;\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [k]);\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__Contains_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__Remove_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\n","namespace Fable.SimpleJson\r\n\r\nopen System\r\nopen Fable.Core\r\nopen FSharp.Reflection\r\nopen System.Numerics\r\nopen System.Collections\r\nopen System.Collections.Generic\r\nopen Fable.Core.JsInterop\r\n\r\nmodule Node =\r\n\r\n    /// Converts Base64 string into a byte array in Node environment\r\n    [<Emit(\"Array.prototype.slice.call(Buffer.from($0, 'base64'))\")>]\r\n    let bytesFromBase64 (value: string) : byte array = jsNative\r\n\r\nmodule Convert =\r\n    [<Emit(\"new Function(\\\"try {return this===window;}catch(e){ return false;}\\\")\")>]\r\n    let internal isBrowser : unit -> bool = jsNative\r\n\r\n    let insideBrowser = isBrowser()\r\n\r\n    [<Emit \"($0 === undefined)\">]\r\n    let private isUndefined (value: obj) : bool = jsNative\r\n    let private isDefined (value: obj) : bool = not (isUndefined value)\r\n\r\n    /// <summary>Uses internal representation of F# maps to determine whether we are using Fable 3 or not</summary>\r\n    let usingFable3() =\r\n        #if FABLE_COMPILER_3\r\n        true\r\n        #else\r\n        let map = JS.JSON.parse(JS.JSON.stringify (Map.ofList [ 1, 1; 2, 2 ]))\r\n        let tree = get \"tree\" map\r\n        isDefined tree && isDefined (get \"k\" tree) && isDefined (get \"v\" tree) && isDefined (get \"h\" tree)\r\n        #endif\r\n\r\n    let isUsingFable3 = usingFable3()\r\n\r\n    [<Emit(\"typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope\")>]\r\n    let internal insideWorker :  bool = jsNative\r\n\r\n    [<Emit(\"$0[$1] = $2\")>]\r\n    let internal setProp o k v = jsNative\r\n\r\n    type InternalMap =\r\n        | MapEmpty\r\n        | MapOne of string * Json\r\n        | MapNode of string * Json * InternalMap * InternalMap\r\n\r\n    let rec flattenMap = function\r\n        | MapEmpty -> [ ]\r\n        | MapOne (key, value) -> [ key, value ]\r\n        | MapNode (key, value, left, right) ->\r\n            [ yield! flattenMap left\r\n              yield! flattenMap right\r\n              yield  (key, value) ]\r\n\r\n    let (|KeyValue|_|) key (map: Map<string, Json>) =\r\n        map\r\n        |> Map.tryFind key\r\n        |> Option.map (fun value -> key, value, Map.remove key map)\r\n\r\n    let (|NonArray|_|) = function\r\n        | JArray _ -> None\r\n        | json -> Some json\r\n\r\n    let (|MapEmpty|_|) json =\r\n        match json with\r\n        | JString \"MapEmpty\" -> Some json\r\n        | _ -> None\r\n\r\n    let (|MapKey|_|) = function\r\n        | JNumber number -> Some (string number)\r\n        | JString key -> Some key\r\n        | _ -> None\r\n\r\n    let (|MapOne|_|) = function\r\n        | JArray [ JString \"MapOne\"; MapKey key; value ] -> Some (key, value)\r\n        | _ -> None\r\n\r\n    let (|MapNode|_|) = function\r\n        | JArray [ JString \"MapNode\"; MapKey key; value; left; right; JNumber _  ] ->\r\n            Some (key, value, left, right)\r\n        | _ -> None\r\n\r\n    let rec generateMap json =\r\n        match json with\r\n        | MapEmpty _ -> Some InternalMap.MapEmpty\r\n        | MapOne (key, value) -> Some (InternalMap.MapOne (key, value))\r\n        | MapNode (key, value, left, right) ->\r\n            match generateMap left, generateMap right with\r\n            | Some leftMap, Some rightMap ->\r\n                Some (InternalMap.MapNode(key, value, leftMap, rightMap))\r\n            | _ -> None\r\n        | _ -> None\r\n\r\n    let rec flatteFable3Map (tree: Map<string, Json>) =\r\n        [\r\n            match Map.tryFind \"k\" tree, Map.tryFind \"v\" tree with\r\n            | Some (JString key), Some value -> (key, value)\r\n            | _ -> ()\r\n\r\n            match Map.tryFind \"left\" tree with\r\n            | Some (JObject left) -> yield! flatteFable3Map left\r\n            | _ -> ()\r\n\r\n            match Map.tryFind \"right\" tree with\r\n            | Some (JObject right) -> yield! flatteFable3Map right\r\n            | _ -> ()\r\n        ]\r\n\r\n    let rec flattenFable3Lists (linkedList: Map<string, Json>) =\r\n        [\r\n            match Map.tryFind \"head\" linkedList with\r\n            | Some value -> value\r\n            | None -> ()\r\n\r\n            match Map.tryFind \"tail\" linkedList with\r\n            | Some (JObject tail) -> yield! flattenFable3Lists tail\r\n            | _ -> ()\r\n        ]\r\n\r\n    /// <summary>Returns whether the type information resembles a type of a sequence of elements (including tuples)</summary>\r\n    let arrayLike = function\r\n        | TypeInfo.Array _ -> true\r\n        | TypeInfo.List _ -> true\r\n        | TypeInfo.Seq _ -> true\r\n        | TypeInfo.Tuple _ -> true\r\n        | TypeInfo.Set _ -> true\r\n        | TypeInfo.ResizeArray _ -> true\r\n        | TypeInfo.HashSet _ -> true\r\n        | _ -> false\r\n\r\n    let isRecord = function\r\n        | TypeInfo.Record recordType -> true\r\n        | _ -> false\r\n\r\n    let unionOfRecords = function\r\n        | TypeInfo.Union getCases ->\r\n            let (unionCases, unionType) = getCases()\r\n            unionCases\r\n            |> Seq.forall (fun case -> case.CaseTypes.Length = 1 && isRecord case.CaseTypes.[0])\r\n        | _ ->\r\n            false\r\n\r\n    let optional = function\r\n        | TypeInfo.Option _ -> true\r\n        | _ -> false\r\n\r\n    let isQuoted (input: string) =\r\n        input.StartsWith \"\\\"\" && input.EndsWith \"\\\"\"\r\n\r\n    let betweenQuotes (input: string) = \"\\\"\" + input + \"\\\"\"\r\n\r\n    let removeQuotes (input: string) =\r\n        input.Substring(1, input.Length - 2)\r\n\r\n    let rec fromJsonAs (input: Json) (typeInfo: Fable.SimpleJson.TypeInfo) : obj =\r\n        match input, typeInfo with\r\n        | JNumber value, TypeInfo.Float -> unbox value\r\n        | JString value, TypeInfo.Float when value.ToLower() = \"nan\" -> unbox (Double.NaN)\r\n        | JString value, TypeInfo.Float -> unbox (float value)\r\n        | JNumber value, TypeInfo.Float32 -> unbox (float32 value)\r\n        | JString value, TypeInfo.Float32 when value.ToLower() = \"nan\" -> unbox (Double.NaN)\r\n        | JString value, TypeInfo.Float32 -> unbox (float32 value)\r\n        // reading number as int -> floor it\r\n        | JNumber value, TypeInfo.Int32 -> unbox (JS.Math.floor(value))\r\n        | JBool value, TypeInfo.Bool -> unbox value\r\n        // reading int from string -> parse it\r\n        | JString value, TypeInfo.Int32 -> unbox (int value)\r\n        | JString value, TypeInfo.Char -> unbox (char value)\r\n        | JNumber value, TypeInfo.Char -> unbox (char (unbox<int> value))\r\n        // reading into strings\r\n        | JString value, TypeInfo.String -> unbox value\r\n        | JNumber value, TypeInfo.String -> unbox (string value)\r\n        // uri\r\n        | JString value, TypeInfo.Uri -> unbox(Uri(value))\r\n        // decimals\r\n        | JString value, TypeInfo.Decimal -> unbox (decimal value)\r\n        | JNumber value, TypeInfo.Decimal -> unbox (decimal value)\r\n        | JString value, TypeInfo.Short -> unbox (int16 value)\r\n        | JNumber value, TypeInfo.Short -> unbox (int16 value)\r\n        // Unsigned integers\r\n        | JNumber value, TypeInfo.UInt16 -> unbox (uint16 value)\r\n        | JString value, TypeInfo.UInt16 -> unbox (uint16 value)\r\n        | JNumber value, TypeInfo.UInt32 -> unbox (uint32 value)\r\n        | JString value, TypeInfo.UInt32 -> unbox (uint32 value)\r\n        | JNumber value, TypeInfo.UInt64 -> unbox (uint64 value)\r\n        | JString value, TypeInfo.UInt64 -> unbox (uint64 value)\r\n        | JNumber value, TypeInfo.TimeSpan -> unbox (JS.Math.floor value)\r\n        | JString value, TypeInfo.Enum getlElemType ->\r\n            let (underlyingType, originalType) = getlElemType()\r\n            match underlyingType with\r\n            | TypeInfo.Int32 ->\r\n                match Int32.TryParse(value) with\r\n                | true, parsedNumber ->\r\n                    unbox parsedNumber\r\n                | false, _ ->\r\n                    failwithf \"The value '%s' is not valid for enum of type '%s'\" value originalType.Name\r\n            | TypeInfo.Long ->\r\n                match Int64.TryParse(value) with\r\n                | true, parsedNumber ->\r\n                    unbox parsedNumber\r\n                | false, _ ->\r\n                    failwithf \"The value '%s' is not valid for enum of type '%s'\" value originalType.Name\r\n            | other ->\r\n                failwithf \"The value '%s' cannot be converted to enum of type '%s'\" value originalType.Name\r\n        | JNumber value, TypeInfo.Enum getElemType ->\r\n            let (_, originalType) = getElemType()\r\n            unbox value\r\n        // byte[] coming from the server is serialized as base64 string\r\n        // convert it back to the actual byte array\r\n        | JString value, TypeInfo.Array getElemType ->\r\n            let elemType = getElemType()\r\n            match elemType with\r\n            | TypeInfo.Byte ->\r\n                if insideWorker || insideBrowser\r\n                then unbox (Convert.FromBase64String value)\r\n                else unbox (Node.bytesFromBase64 value)\r\n            | otherType -> failwithf \"Cannot convert arbitrary string '%s' to %A\" value otherType\r\n\r\n        // null values for strings are just the null string\r\n        | JNull, TypeInfo.String -> unbox null\r\n        | JNull, TypeInfo.Unit -> unbox ()\r\n        | genericJson, TypeInfo.Object -> unbox (SimpleJson.toPlainObject genericJson)\r\n        // int64 as string -> parse it\r\n        | JString value, TypeInfo.Long -> unbox (int64 value)\r\n        | JString value, TypeInfo.Byte -> unbox (byte value)\r\n        | JNumber value, TypeInfo.Byte -> unbox (byte value)\r\n        | JNumber value, TypeInfo.SByte -> unbox (sbyte value)\r\n        | JString value, TypeInfo.SByte -> unbox (sbyte value)\r\n        // BigInt as string -> parse it\r\n        | JString value, TypeInfo.BigInt -> unbox (BigInteger.Parse value)\r\n        | JNumber value, TypeInfo.BigInt -> unbox (bigint (JS.Math.floor(value)))\r\n        // parse formatted date time\r\n        | JString value, TypeInfo.DateTime -> unbox (DateTime.Parse(value))\r\n        // parse formatted date time offset\r\n        | JString value, TypeInfo.DateTimeOffset -> unbox (DateTimeOffset.Parse(value))\r\n        | JNumber value, TypeInfo.DateTimeOffset ->\r\n            let seconds = int64 (JS.Math.floor(value))\r\n            unbox (DateTimeOffset.FromUnixTimeSeconds seconds)\r\n#if NET6_0_OR_GREATER\r\n        // TimeOnly, DateOnly\r\n        | JNumber value, TypeInfo.DateOnly -> unbox (DateOnly.FromDayNumber (int value))\r\n        | JString value, TypeInfo.DateOnly -> unbox (DateOnly.FromDayNumber (int value))\r\n        | JString value, TypeInfo.TimeOnly -> unbox (TimeOnly (int64 value))\r\n#endif\r\n\r\n        // deserialize union from objects\r\n        // { \"One\": 20 } or {\"One\": [20]} -> One of int\r\n        | JObject values, TypeInfo.Union (getTypes) ->\r\n            let (cases, unionType) = getTypes()\r\n            match Map.toList values with\r\n            | [ caseName, JArray values ] ->\r\n                cases\r\n                |> Array.tryFind (fun case -> case.CaseName = caseName)\r\n                |> function\r\n                    | None ->\r\n                        let caseNames = Array.map (fun case -> sprintf \" '%s' \" case.CaseName) cases\r\n                        let expectedCases = String.concat \", \" caseNames\r\n                        failwithf \"Case %s was not valid for type '%s', expected one of the cases [%s]\" caseName unionType.Name expectedCases\r\n                    | Some foundCase when Array.length foundCase.CaseTypes = 1 && arrayLike foundCase.CaseTypes.[0] ->\r\n                        let deserialized = fromJsonAs (JArray values) foundCase.CaseTypes.[0]\r\n                        FSharpValue.MakeUnion(foundCase.Info, [| deserialized |])\r\n                        |> unbox\r\n                    | Some foundCase when Array.length foundCase.CaseTypes = 1 && optional foundCase.CaseTypes.[0] ->\r\n                        let parsedOptional = unbox (fromJsonAs (JArray values) foundCase.CaseTypes.[0])\r\n                        FSharpValue.MakeUnion(foundCase.Info, [| parsedOptional |])\r\n                        |> unbox\r\n                    | Some foundCase ->\r\n                        if Array.length foundCase.CaseTypes = 1\r\n                            && not (arrayLike foundCase.CaseTypes.[0])\r\n                            && Array.length foundCase.CaseTypes <> List.length values\r\n                        then failwithf \"Expected case '%s' to have %d argument types but the JSON data only contained %d values\" foundCase.CaseName (Array.length foundCase.CaseTypes) (List.length values)\r\n                        let parsedValues =\r\n                            Array.ofList values\r\n                            |> Array.zip foundCase.CaseTypes\r\n                            |> Array.map (fun (valueType, value) -> fromJsonAs value valueType)\r\n                        FSharpValue.MakeUnion(foundCase.Info, parsedValues)\r\n                        |> unbox\r\n            | [ caseName, NonArray json ] ->\r\n                cases\r\n                |> Array.tryFind (fun case -> case.CaseName = caseName)\r\n                |> function\r\n                    | Some ({ CaseName = caseName; Info = caseInfo; CaseTypes = [| caseType |] }) ->\r\n                        FSharpValue.MakeUnion(caseInfo, [| unbox fromJsonAs json caseType |])\r\n                        |> unbox\r\n                    | _ ->\r\n                        let caseNames = Array.map (fun case -> sprintf \" '%s' \" case.CaseName) cases\r\n                        let expectedCases = String.concat \", \" caseNames\r\n                        failwithf \"Case %s was not valid for type '%s', expected one of the cases [%s]\" caseName unionType.Name expectedCases\r\n\r\n            // Specific for Fable 3\r\n            | otherwise when Map.containsKey \"tag\" values && Map.containsKey \"fields\" values && Map.count values = 2 ->\r\n                match Map.tryFind \"tag\" values, Map.tryFind \"fields\" values with\r\n                | Some (JNumber caseIndex), Some (JArray fieldValues) ->\r\n                    let foundCase = cases.[int caseIndex]\r\n                    let values =\r\n                        fieldValues\r\n                        |> Array.ofList\r\n                        |> Array.mapi (fun index value -> fromJsonAs value (foundCase.CaseTypes.[index]))\r\n\r\n                    FSharpValue.MakeUnion(foundCase.Info, values)\r\n                | _ ->\r\n                    failwithf \"Could not deserialize JSON(%s) into type %s\" (SimpleJson.toString (JObject values)) unionType.FullName\r\n\r\n            | otherwise when unionOfRecords typeInfo ->\r\n                let discriminators = [\"__typename\"; \"$typename\"; \"$type\" ]\r\n                let foundDiscriminatorKey =\r\n                    discriminators\r\n                    |> List.tryFind (fun keyword -> Map.containsKey keyword values)\r\n\r\n                match foundDiscriminatorKey with\r\n                | None ->\r\n                    failwithf \"Could not serialize the JSON object into the union of records of type %s because the JSON did not contain a known discriminator. Expected '__typename', '$typeName' or '$type'\" unionType.Name\r\n                | Some discriminatorKey ->\r\n                    let discriminatorValueJson = Map.find discriminatorKey values\r\n                    match discriminatorValueJson with\r\n                    | JString discriminatorValue ->\r\n                        let foundUnionCase =\r\n                            cases\r\n                            |> Seq.tryFind (fun case -> case.CaseName.ToUpperInvariant() = discriminatorValue.ToUpperInvariant())\r\n\r\n                        match foundUnionCase with\r\n                        | None ->\r\n                            failwithf \"Union of records of type '%s' does not have a matching case '%s'\" unionType.Name discriminatorValue\r\n                        | Some case ->\r\n                            // Assuming the case types is [recordType]\r\n                            // one element of types and the first element is a record\r\n                            // as satisfied by the unionOfRecords function\r\n                            let record = unbox (fromJsonAs (JObject values) (case.CaseTypes.[0]))\r\n                            FSharpValue.MakeUnion(case.Info, [| record |])\r\n                    | otherwise ->\r\n                        failwithf \"Union of records of type '%s' cannot be deserialized with the value of the discriminator key is not a string to match against a specific union case\" unionType.Name\r\n            | otherwise ->\r\n                // TODO!!! Better error messages here\r\n                let unexpectedJson = JS.JSON.stringify otherwise\r\n                let expectedType = JS.JSON.stringify cases\r\n                failwithf \"Expected JSON:\\n%s\\nto match the type\\n%s\" unexpectedJson expectedType\r\n        | JNull, TypeInfo.Option _ -> unbox None\r\n        | jsonValue, TypeInfo.Option optionalTypeDelayed when jsonValue <> JNull ->\r\n            let optionalType = optionalTypeDelayed()\r\n            let parsedOptional = unbox (fromJsonAs jsonValue optionalType)\r\n            unbox Some parsedOptional\r\n        | JString value, TypeInfo.Guid _ -> unbox (System.Guid.Parse(value))\r\n        // int64 as a number, convert it to int then to in64\r\n        | JNumber value , TypeInfo.Long _ -> unbox int64 (int value)\r\n        // int64 as the internal representation from Long.js\r\n        // then reconstruct it from the high/low (two integers) components\r\n        | JObject dict, TypeInfo.Long _ ->\r\n            let get key = Map.tryFind key dict\r\n            [ get \"low\"; get \"high\"; get \"unsigned\" ]\r\n            |> List.choose id\r\n            |> function\r\n                | [ JNumber low; JNumber high; JBool _ ] ->\r\n                    let lowBytes = BitConverter.GetBytes(int low)\r\n                    let highBytes = BitConverter.GetBytes(int high)\r\n                    let combinedBytes = Array.concat [ lowBytes; highBytes ]\r\n                    BitConverter.ToInt64(combinedBytes, 0)\r\n                    |> unbox\r\n                | _ -> failwithf \"Unable to construct int64 from object literal { low: int, high: int, unsigned: bool }\"\r\n        // convert a single case string to union\r\n        // \"One\" -> One, here is a special case where the case in quoted inside the string\r\n        | JString caseName, TypeInfo.Union getTypes when isQuoted caseName ->\r\n            let (caseTypes, unionType) = getTypes()\r\n            caseTypes\r\n            |> Array.tryFind (fun case -> case.CaseName = removeQuotes caseName)\r\n            |> function\r\n                | Some ({ Info = caseInfo }) -> unbox (FSharpValue.MakeUnion(caseInfo, [||]))\r\n                | None ->\r\n                    let caseNames = Array.map (fun case -> sprintf \" '%s' \" case.CaseName) caseTypes\r\n                    let expectedCases = String.concat \", \" caseNames\r\n                    failwithf \"Case %s was not valid for type '%s', expected one of the cases [%s]\" caseName unionType.Name expectedCases\r\n        // convert a single case string to union\r\n        // \"One\" -> One\r\n        | JString caseName, TypeInfo.Union getTypes ->\r\n            let (caseTypes, unionType) = getTypes()\r\n            caseTypes\r\n            |> Array.tryFind (fun case -> case.CaseName = caseName)\r\n            |> function\r\n                | Some ({ Info = caseInfo }) -> unbox (FSharpValue.MakeUnion(caseInfo, [||]))\r\n                | None ->\r\n                    let caseNames = Array.map (fun case -> sprintf \" '%s' \" case.CaseName) caseTypes\r\n                    let expectedCases = String.concat \", \" caseNames\r\n                    failwithf \"Case %s was not valid for type '%s', expected one of the cases [%s]\" caseName unionType.Name expectedCases\r\n        | JString serializedRecord, TypeInfo.Record getFields ->\r\n            fromJsonAs (SimpleJson.parse serializedRecord) typeInfo\r\n        // convert unions from arrays\r\n        // [\"One\", 20] -> One of int\r\n        | JArray caseValue, TypeInfo.Union getTypes ->\r\n            let (cases, unionType) = getTypes()\r\n            match caseValue with\r\n            // Union case without values\r\n            | [ JString caseName ] ->\r\n                cases\r\n                |> Array.tryFind (fun case -> case.CaseName = caseName)\r\n                |> function\r\n                    | Some ({ CaseName = caseName; Info = caseInfo; CaseTypes = caseInfoTypes }) ->\r\n                        // single case without values\r\n                        unbox (FSharpValue.MakeUnion(caseInfo, [||]))\r\n                    | None ->\r\n                        let caseNames = Array.map (fun case -> sprintf \" '%s' \" case.CaseName) cases\r\n                        let expectedCases = String.concat \", \" caseNames\r\n                        failwithf \"Case '%s' was not valid for type '%s', expected one of the cases [%s]\" caseName unionType.Name expectedCases\r\n            | JString caseName :: values ->\r\n                cases\r\n                |> Array.tryFind (fun case -> case.CaseName = caseName)\r\n                |> function\r\n                    | None ->\r\n                        let caseNames = Array.map (fun ({ CaseName = name }) -> name) cases\r\n                        let expectedCases = String.concat \", \" caseNames\r\n                        failwithf \"Case %s was not valid, expected one of [%s]\" caseName expectedCases\r\n                    | Some ({ CaseName = foundCaseName; Info = caseInfo; CaseTypes = types }) ->\r\n                        if Array.length types <> List.length values\r\n                        then failwithf \"The number of union case parameters for '%s' is different\" foundCaseName\r\n                        let parsedValues =\r\n                            Array.ofList values\r\n                            |> Array.zip types\r\n                            |> Array.map (fun (valueType, value) -> fromJsonAs value valueType)\r\n                        FSharpValue.MakeUnion(caseInfo, parsedValues)\r\n                        |> unbox\r\n            | otherwise ->\r\n                let unexpectedJson = JS.JSON.stringify otherwise\r\n                let expectedType = JS.JSON.stringify cases\r\n                failwithf \"Expected JSON:\\n%s\\nto match the type\\n%s\" unexpectedJson expectedType\r\n        // Arrays\r\n        | JArray values, TypeInfo.Array elementTypeDelayed ->\r\n            let elementType = elementTypeDelayed()\r\n            values\r\n            |> List.map (fun value -> unbox (fromJsonAs value elementType))\r\n            |> Array.ofList\r\n            |> unbox\r\n        // Lists\r\n        | JArray values, TypeInfo.List elementTypeDelayed ->\r\n            let elementType = elementTypeDelayed()\r\n            values\r\n            |> List.map (fun value -> unbox (fromJsonAs value elementType))\r\n            |> unbox\r\n\r\n        // Specific for Fable 3\r\n        | JObject linkedList, TypeInfo.List elementTypeDelayed ->\r\n            let elementType = elementTypeDelayed()\r\n            let flattenedList = flattenFable3Lists linkedList\r\n            flattenedList\r\n            |> List.map (fun value -> unbox (fromJsonAs value elementType))\r\n            |> unbox\r\n\r\n        | JArray values, TypeInfo.Set elementTypeDelayed ->\r\n            let elementType = elementTypeDelayed()\r\n            values\r\n            |> List.map (fun value -> unbox (fromJsonAs value elementType))\r\n            |> Set.ofList\r\n            |> unbox\r\n\r\n        | JArray values, TypeInfo.Seq elementTypeDelayed ->\r\n            let elementType = elementTypeDelayed()\r\n            let converted = List.map (fun value -> unbox (fromJsonAs value elementType)) values\r\n            unbox converted\r\n        // Tuples, become just arrays\r\n        | JArray array, TypeInfo.Tuple tupleTypesDelayed ->\r\n            let tupleTypes = tupleTypesDelayed()\r\n            array\r\n            |> Array.ofList\r\n            |> Array.zip tupleTypes\r\n            |> Array.map (fun (jsonType, jsonData) -> fromJsonAs jsonData jsonType)\r\n            |> unbox\r\n        // Records\r\n        | JObject dict, TypeInfo.Record getTypes ->\r\n            let fields, recordType = getTypes()\r\n            // Match the JSON object literal keys with their types\r\n            let recordValues =\r\n                let values = Map.toList dict\r\n                fields\r\n                |> Array.map (fun ({ FieldName = fieldName; FieldType = fieldType }) ->\r\n                    values\r\n                    |> List.tryFind (fun (key, value) -> fieldName = key)\r\n                    |> function\r\n                        | Some (key, value) -> unbox (fromJsonAs value fieldType)\r\n                        | None ->\r\n                            match fieldType with\r\n                            // field type is an option of something, just return None\r\n                            | TypeInfo.Option _ -> unbox None\r\n                            | _ ->\r\n                              // field type is required and it doens't exist in the JSON\r\n                              // then generate a nice error message\r\n                              let dictKeys =\r\n                                  Map.toList dict\r\n                                  |> List.map (fst >> sprintf \"'%s'\")\r\n                                  |> String.concat \", \"\r\n                                  |> sprintf \"[ %s ]\"\r\n                              let recordFields =\r\n                                  fields\r\n                                  |> Array.map (fun ({ FieldName = name; FieldType = innerFieldType }) ->\r\n                                      match innerFieldType with\r\n                                      | TypeInfo.Option _ -> sprintf \"optional('%s')\" name\r\n                                      | _ -> sprintf \"required('%s')\" name)\r\n                                  |> String.concat \", \"\r\n                                  |> sprintf \"[ %s ]\"\r\n                              failwithf \"Could not find the required key '%s' in the JSON object literal with keys %s to match with record type '%s' that has fields %s\" fieldName dictKeys recordType.Name recordFields)\r\n            unbox (FSharpValue.MakeRecord(recordType, recordValues))\r\n\r\n        | JArray tuples, TypeInfo.Map getTypes ->\r\n            let (keyType, valueType) = getTypes()\r\n            let pairs =\r\n                [ for keyValuePair in tuples do\r\n                    let tuple = fromJsonAs keyValuePair (TypeInfo.Tuple (let a = [| keyType; valueType |] in fun () -> a))\r\n                    yield tuple ]\r\n            match keyType with\r\n            | TypeInfo.Int32\r\n            | TypeInfo.String\r\n            | TypeInfo.Bool ->\r\n                pairs\r\n                |> unbox<(string * obj) list>\r\n                |> Map.ofList\r\n                |> unbox\r\n            | _ ->\r\n                pairs\r\n                |> unbox<(IStructuralComparable * obj) list>\r\n                |> Map.ofList\r\n                |> unbox\r\n\r\n        | JArray tuples, TypeInfo.Dictionary getTypes ->\r\n            let (keyType, valueType, originalType) = getTypes()\r\n            let pairs =\r\n                [ for keyValuePair in tuples do\r\n                    let tuple = fromJsonAs keyValuePair (TypeInfo.Tuple (fun () -> [| keyType; valueType |]))\r\n                    yield tuple ]\r\n\r\n            let output =\r\n                match keyType with\r\n                | TypeInfo.Union _ ->  Dictionary<Result<_, _>, _>()\r\n                | TypeInfo.Record _ -> Dictionary<{| dummy: int |}, _>() |> unbox\r\n                | _ -> Dictionary<IStructuralComparable, _>() |> unbox\r\n\r\n            for (key, value) in (unbox<(IStructuralComparable * obj) list> pairs) do output.Add(unbox key, value)\r\n            unbox output\r\n\r\n        | JObject dict, TypeInfo.Dictionary getTypes ->\r\n            let (keyType, valueType, originalType) = getTypes()\r\n            dict\r\n            |> Map.toList\r\n            |> List.map (fun (key, value) -> fromJsonAs (JString key) keyType, fromJsonAs value valueType )\r\n            |> fun pairs ->\r\n                let output =\r\n                    match keyType with\r\n                    | TypeInfo.Union _ -> Dictionary<Result<_, _>, _>()\r\n                    | TypeInfo.Record _ -> Dictionary<{| dummy: int |}, _>() |> unbox\r\n                    | _ -> Dictionary<IStructuralComparable, _>() |> unbox\r\n\r\n                for (key, value) in pairs do output.Add(unbox key, value)\r\n\r\n                unbox output\r\n\r\n        | JArray items, TypeInfo.HashSet getType ->\r\n            let elemType = getType()\r\n            let hashset =\r\n                match elemType with\r\n                | TypeInfo.Union _ -> HashSet<Result<_, _>>()\r\n                | TypeInfo.Record _ -> HashSet<{| dummy: int |}>() |> unbox\r\n                | _ -> HashSet<IStructuralComparable>() |> unbox\r\n\r\n            for item in items do\r\n                let deserialized = fromJsonAs item elemType\r\n                hashset.Add(unbox deserialized) |> ignore\r\n\r\n            unbox hashset\r\n\r\n        | JObject map, TypeInfo.Map getTypes ->\r\n            let (keyType, valueType) = getTypes()\r\n            // check whether the map is serialized to it's internal representation\r\n            // and convert that to back to a normal map from the data\r\n            match Map.tryFind \"comparer\" map, Map.tryFind \"tree\" map with\r\n            | Some (JObject comparer), Some (JArray tree) when Map.isEmpty comparer ->\r\n                match generateMap (JArray tree) with\r\n                | Some internalMap ->\r\n                    let pairs =\r\n                        flattenMap internalMap\r\n                        |> List.map (fun (key, value) ->\r\n                            let nextKey =\r\n                                if not (isQuoted key)\r\n                                then unbox (fromJsonAs (JString key) keyType)\r\n                                else unbox (fromJsonAs (SimpleJson.parseNative key) keyType)\r\n                            let nextValue = unbox (fromJsonAs value valueType)\r\n                            unbox<obj> nextKey, nextValue)\r\n                    match keyType with\r\n                    | TypeInfo.Int32\r\n                    | TypeInfo.String\r\n                    | TypeInfo.Bool ->\r\n                        pairs\r\n                        |> unbox<(string * obj) list>\r\n                        |> Map.ofList\r\n                        |> unbox\r\n                    | _ ->\r\n                        pairs\r\n                        |> unbox<(IStructuralComparable * obj) list>\r\n                        |> Map.ofList\r\n                        |> unbox\r\n\r\n                | None ->\r\n                    let inputJson = SimpleJson.toString (JArray tree)\r\n                    failwithf \"Could not generate map from JSON\\n %s\" inputJson\r\n\r\n            // Specific for Fable 3\r\n            | Some (JObject comparer), Some (JObject tree) when Map.isEmpty comparer ->\r\n                let flattenedMap = Map.ofList (flatteFable3Map tree)\r\n                fromJsonAs (JObject flattenedMap) typeInfo\r\n            | _ ->\r\n                // if comparer and tree are not present,\r\n                // assume we are parsing Fable 1 object literal\r\n                // and converting that to map\r\n                let pairs =\r\n                    map\r\n                    |> Map.toList\r\n                    |> List.map (fun (key, value) ->\r\n                        let nextKey =\r\n                            if not (isQuoted key)\r\n                            then\r\n                                if Converter.isPrimitive keyType || Converter.enumUnion keyType\r\n                                then\r\n                                    // for primitive type, just read them as string and parse\r\n                                    unbox (fromJsonAs (JString key) keyType)\r\n                                else\r\n                                    // server-side JSON can still be complex (for complex types)\r\n                                    // but doesn't have to be quoted, parse again here\r\n                                    unbox (fromJsonAs (SimpleJson.parseNative key) keyType)\r\n                            else\r\n                                unbox (fromJsonAs (SimpleJson.parseNative key) keyType)\r\n                        let nextValue = unbox (fromJsonAs value valueType)\r\n                        unbox<string> nextKey, nextValue)\r\n\r\n                match keyType with\r\n                | TypeInfo.Int32\r\n                | TypeInfo.String\r\n                | TypeInfo.Bool ->\r\n                    pairs\r\n                    |> unbox<(string * obj) list>\r\n                    |> Map.ofList\r\n                    |> unbox\r\n                | _ ->\r\n                    pairs\r\n                    |> unbox<(IStructuralComparable * obj) list>\r\n                    |> Map.ofList\r\n                    |> unbox\r\n        | _, TypeInfo.Any getType ->\r\n            let unknownType = getType()\r\n            failwithf \"Cannot convert %s to %s\" (SimpleJson.toString input) unknownType.FullName\r\n        | _ ->\r\n            failwithf \"Cannot convert %s to %s\" (SimpleJson.toString input) (JS.JSON.stringify typeInfo)\r\n\r\n    let fromJson<'t> json typeInfo =\r\n        unbox<'t> (fromJsonAs json typeInfo)\r\n\r\n    let quoteText (inputText: string) : string = importDefault \"./quote.js\"\r\n\r\n    let rec serialize value (typeInfo: TypeInfo) =\r\n        match typeInfo with\r\n        | TypeInfo.String ->\r\n            let content = unbox<string> value\r\n            if isNull content\r\n            then \"null\"\r\n            else quoteText content\r\n        | TypeInfo.Unit -> \"null\"\r\n        | TypeInfo.Float\r\n        | TypeInfo.Float32 ->\r\n            if Double.IsNaN(unbox value)\r\n            then quoteText \"NaN\"\r\n            else string (unbox<double> value)\r\n        | TypeInfo.Char -> quoteText (string (unbox<char> value))\r\n        | TypeInfo.Byte\r\n        | TypeInfo.SByte\r\n        | TypeInfo.UInt16\r\n        | TypeInfo.UInt32\r\n        | TypeInfo.Short\r\n        | TypeInfo.Enum _\r\n        | TypeInfo.TimeSpan\r\n        | TypeInfo.Int32 -> string (unbox<int> value)\r\n        | TypeInfo.UInt64\r\n        | TypeInfo.Long -> betweenQuotes (string (unbox<int64> value))\r\n        | TypeInfo.BigInt -> betweenQuotes (string (unbox<bigint> value))\r\n        | TypeInfo.Decimal -> betweenQuotes (string (unbox<decimal> value))\r\n        | TypeInfo.Bool -> if unbox<bool> value then \"true\" else \"false\"\r\n        | TypeInfo.Guid -> betweenQuotes ((unbox<Guid> value).ToString())\r\n        | TypeInfo.Uri -> betweenQuotes ((unbox<Uri> value).ToString())\r\n        | TypeInfo.DateTime -> betweenQuotes ((unbox<DateTime> value).ToString(\"O\"))\r\n        | TypeInfo.DateTimeOffset -> betweenQuotes ((unbox<DateTimeOffset> value).ToString(\"O\"))\r\n#if NET6_0_OR_GREATER\r\n        | TypeInfo.DateOnly -> string (unbox<DateOnly> value).DayNumber\r\n        | TypeInfo.TimeOnly -> betweenQuotes (string (unbox<TimeOnly> value).Ticks)\r\n#endif\r\n        | TypeInfo.Record getFields ->\r\n            let (fieldTypes, recordType) = getFields()\r\n            let serializedFields =\r\n                fieldTypes\r\n                |> Array.map (fun field ->\r\n                    let fieldValue = FSharpValue.GetRecordField(value, field.PropertyInfo)\r\n                    sprintf \"\\\"%s\\\": %s\" field.FieldName (serialize fieldValue field.FieldType)\r\n                )\r\n\r\n            \"{\" + String.concat \", \" serializedFields + \"}\"\r\n\r\n        | TypeInfo.ResizeArray getElementType ->\r\n            let elementType = getElementType()\r\n            let values =\r\n                value\r\n                |> unbox<ResizeArray<obj>>\r\n                |> Seq.map (fun element -> serialize element elementType)\r\n                |> String.concat \", \"\r\n\r\n            \"[\" + values + \"]\"\r\n\r\n        | TypeInfo.HashSet getElementType ->\r\n            let elementType = getElementType()\r\n            let values =\r\n                value\r\n                |> unbox<HashSet<obj>>\r\n                |> Seq.map (fun element -> serialize element elementType)\r\n                |> String.concat \", \"\r\n\r\n            \"[\" + values + \"]\"\r\n\r\n        | TypeInfo.Set getElementType ->\r\n            let elementType = getElementType()\r\n            let values =\r\n                value\r\n                |> unbox<Set<IComparable>>\r\n                |> Seq.map (fun element -> serialize element elementType)\r\n                |> String.concat \", \"\r\n\r\n            \"[\" + values + \"]\"\r\n\r\n        | TypeInfo.Array getElementType ->\r\n            let elementType = getElementType()\r\n            let values =\r\n                value\r\n                |> unbox<obj []>\r\n                |> Array.map (fun element -> serialize element elementType)\r\n                |> String.concat \", \"\r\n\r\n            \"[\" + values + \"]\"\r\n\r\n        | TypeInfo.List getElementType ->\r\n            let elementType = getElementType()\r\n            let values =\r\n                value\r\n                |> unbox<obj list>\r\n                |> List.map (fun element -> serialize element elementType)\r\n                |> String.concat \", \"\r\n\r\n            \"[\" + values + \"]\"\r\n\r\n        | TypeInfo.Seq getElementType ->\r\n            let elementType = getElementType()\r\n            let values =\r\n                value\r\n                |> unbox<obj seq>\r\n                |> Seq.toArray\r\n                |> Array.map (fun element -> serialize element elementType)\r\n                |> String.concat \", \"\r\n\r\n            \"[\" + values + \"]\"\r\n\r\n        | TypeInfo.Option getElementType ->\r\n            match unbox<obj option> value with\r\n            | None -> \"null\"\r\n            | Some existingValue -> serialize existingValue (getElementType())\r\n\r\n        | TypeInfo.Union getCases ->\r\n            let (unionCases, unionType) = getCases()\r\n            let (usedCase, fields) = FSharpValue.GetUnionFields(value, unionType)\r\n            let caseTypes =\r\n                unionCases\r\n                |> Array.find (fun case -> case.CaseName = usedCase.Name)\r\n                |> fun case -> case.CaseTypes\r\n\r\n            if enumUnion typeInfo || Array.isEmpty caseTypes then\r\n                betweenQuotes usedCase.Name\r\n            elif caseTypes.Length = 1 then\r\n                \"{\" + betweenQuotes usedCase.Name + \": \" + serialize fields.[0] caseTypes.[0] + \"}\"\r\n            else\r\n                let serializedFields =\r\n                    caseTypes\r\n                    |> Array.mapi (fun index caseType -> serialize fields.[index] caseType)\r\n                    |> String.concat \", \"\r\n\r\n                \"{\" + betweenQuotes usedCase.Name + \": \" + \"[\" + serializedFields + \"] }\"\r\n\r\n        | TypeInfo.Map getPairTypes ->\r\n            let (keyType, valueType) = getPairTypes()\r\n\r\n            let serializedValues =\r\n                value\r\n                |> unbox<Map<IComparable, obj>>\r\n                |> Map.toArray\r\n                |> Array.map (fun (key, value) ->\r\n                    let serializedKey = serialize key keyType\r\n                    let serializedValue = serialize value valueType\r\n\r\n                    if isPrimitive keyType || enumUnion keyType then\r\n                        if not (isQuoted serializedKey)\r\n                        then (quoteText serializedKey) + \": \" + serializedValue\r\n                        else serializedKey + \": \" + serializedValue\r\n                    else\r\n                        \"[\" + serializedKey + \", \" + serializedValue + \"]\"\r\n                )\r\n                |> String.concat \", \"\r\n\r\n            if isPrimitive keyType || enumUnion keyType\r\n            then \"{\" + serializedValues + \"}\"\r\n            else \"[\" + serializedValues + \"]\"\r\n\r\n        | TypeInfo.Dictionary getPairTypes ->\r\n            let (keyType, valueType, originalType) = getPairTypes()\r\n            let serializedValues =\r\n                value\r\n                |> unbox<Dictionary<IComparable, obj>>\r\n                |> Seq.map (fun pair ->\r\n                    let (key, value) = pair.Key, pair.Value\r\n                    let serializedKey = serialize key keyType\r\n                    let serializedValue = serialize value valueType\r\n\r\n                    if isPrimitive keyType || enumUnion keyType then\r\n                        if not (isQuoted serializedKey)\r\n                        then (betweenQuotes serializedKey) + \": \" + serializedValue\r\n                        else serializedKey + \": \" + serializedValue\r\n                    else\r\n                        \"[\" + serializedKey + \", \" + serializedValue + \"]\"\r\n                )\r\n                |> String.concat \", \"\r\n\r\n            if isPrimitive keyType || enumUnion keyType\r\n            then \"{\" + serializedValues + \"}\"\r\n            else \"[\" + serializedValues + \"]\"\r\n\r\n        | TypeInfo.Tuple getTupleTypes ->\r\n            let tupleTypes = getTupleTypes()\r\n\r\n            if tupleTypes.Length = 1 then\r\n                \"[\" + serialize value tupleTypes.[0] + \"]\"\r\n            else\r\n                let serializedValues =\r\n                    value\r\n                    |> unbox<obj array>\r\n                    |> Array.mapi (fun index element -> serialize element tupleTypes.[index])\r\n                    |> String.concat \", \"\r\n\r\n                \"[\" + serializedValues + \"]\"\r\n\r\n        | TypeInfo.Object ->\r\n            SimpleJson.stringify value\r\n\r\n        | TypeInfo.Any getType ->\r\n            // fallback to low-level serialization\r\n            SimpleJson.stringify value\r\n\r\n        | _ ->\r\n            \"null\"\r\n\r\n[<AutoOpenAttribute>]\r\nmodule ConverterExtensions =\r\n    type Json with\r\n\r\n        /// <summary>\r\n        /// Serialized the input value object into JSON, uses built-in JSON.stringify and should be used with Fable 2.x or earlier\r\n        /// </summary>\r\n        static member stringify (value: obj) : string =\r\n            if Convert.isUsingFable3\r\n            then JS.console.warn(\"It looks like you using the function Json.stringify from Fable.SimpleJson while also using Fable 3 (nagareyama). Please use Json.serialize instead which supports both Fable 3 and Fable 2.x\")\r\n            SimpleJson.stringify value\r\n\r\n        /// <summary>\r\n        /// Serialized the input value into JSON using Reflection. Compatible with Fable 2.x and Fable 3 (codename: nagareyama)\r\n        /// </summary>\r\n        static member inline serialize<'t> (value: 't) : string =\r\n            let typeInfo = TypeInfo.createFrom<'t>()\r\n            Convert.serialize value typeInfo\r\n\r\n        /// Parses the input string as JSON and tries to convert it as the given type argument\r\n        static member inline parseAs<'t> (input: string) : 't =\r\n            match SimpleJson.tryParse input with\r\n            | None -> failwith \"Couldn't parse the input JSON string because it seems to be invalid\"\r\n            | Some inputJson ->\r\n                let typeInfo = TypeInfo.createFrom<'t> ()\r\n                Convert.fromJson<'t> inputJson typeInfo\r\n\r\n        /// Parses the input string as JSON using native parsing and tries to convert it as the given type argument\r\n        static member inline parseNativeAs<'t> (input: string) : 't =\r\n            let inputJson = SimpleJson.parseNative input\r\n            let typeInfo = TypeInfo.createFrom<'t> ()\r\n            Convert.fromJson<'t> inputJson typeInfo\r\n\r\n        /// Tries to parse the input string as JSON and tries to convert it as the given type argument, returing a (hopefully) useful error message when it fails\r\n        static member inline tryParseAs<'t> (input: string) : Result<'t, string> =\r\n            try Ok (Json.parseAs<'t> input)\r\n            with | ex -> Error ex.Message\r\n\r\n        /// Tries to parse the input string as JSON using native parsing and tries to convert it as the given type argument\r\n        static member inline tryParseNativeAs<'t> (input: string) : Result<'t, string> =\r\n            try Ok (Json.parseNativeAs<'t> input)\r\n            with | ex -> Error ex.Message\r\n\r\n        /// Tries to convert parsed JSON object as the given type parameter argument, this method is used when you want to apply transformations to the JSON object before parsing\r\n        static member inline convertFromJsonAs<'t> (input: Json) : 't =\r\n            let typeInfo = TypeInfo.createFrom<'t> ()\r\n            Convert.fromJson<'t> input typeInfo\r\n\r\n        /// Tries to convert parsed JSON object as the given type parameter argument, this method is used when you want to apply transformations to the JSON object before parsing\r\n        static member inline tryConvertFromJsonAs<'t> (input: Json) : Result<'t, string> =\r\n            try Ok (Json.convertFromJsonAs<'t> input)\r\n            with | ex -> Error ex.Message\r\n","export default function quote(inputText) {\r\n    var escapable = /[\\\\\\\"\\x00-\\x1f\\x7f-\\x9f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g;\r\n    var meta = {\r\n        '\\b': '\\\\b',\r\n        '\\t': '\\\\t',\r\n        '\\n': '\\\\n',\r\n        '\\f': '\\\\f',\r\n        '\\r': '\\\\r',\r\n        '\"': '\\\\\"',\r\n        '\\\\': '\\\\\\\\'\r\n    }\r\n\r\n    escapable.lastIndex = 0;\r\n    return escapable.test(inputText) ?\r\n        '\"' + inputText.replace(escapable, function (a) {\r\n            var c = meta[a];\r\n            return typeof c === 'string' ? c :\r\n                '\\\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);\r\n        }) + '\"' :\r\n        '\"' + inputText + '\"';\r\n}","// tslint:disable:max-line-length\nimport { fromNumber as Long_fromNumber, op_Division as Long_op_Division, op_Multiply as Long_op_Multiply, toNumber as Long_toNumber } from \"./Long.js\";\nimport { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from \"./Util.js\";\n// TimeSpan in runtime just becomes a number representing milliseconds\n/**\n * Calls:\n * - `Math.ceil` if the `value` is **negative**\n * - `Math.floor` if the `value` is **positive**\n * @param value Value to round\n */\nfunction signedRound(value) {\n    return value < 0 ? Math.ceil(value) : Math.floor(value);\n}\nexport function create(d = 0, h = 0, m = 0, s = 0, ms = 0) {\n    switch (arguments.length) {\n        case 1:\n            // ticks\n            return fromTicks(arguments[0]);\n        case 3:\n            // h,m,s\n            d = 0, h = arguments[0], m = arguments[1], s = arguments[2], ms = 0;\n            break;\n        default:\n            // d,h,m,s,ms\n            break;\n    }\n    return d * 86400000 + h * 3600000 + m * 60000 + s * 1000 + ms;\n}\nexport function fromTicks(ticks) {\n    return Long_toNumber(Long_op_Division(ticks, 10000));\n}\nexport function fromDays(d) {\n    return create(d, 0, 0, 0);\n}\nexport function fromHours(h) {\n    return create(h, 0, 0);\n}\nexport function fromMinutes(m) {\n    return create(0, m, 0);\n}\nexport function fromSeconds(s) {\n    return create(0, 0, s);\n}\nexport function days(ts) {\n    return signedRound(ts / 86400000);\n}\nexport function hours(ts) {\n    return signedRound(ts % 86400000 / 3600000);\n}\nexport function minutes(ts) {\n    return signedRound(ts % 3600000 / 60000);\n}\nexport function seconds(ts) {\n    return signedRound(ts % 60000 / 1000);\n}\nexport function milliseconds(ts) {\n    return signedRound(ts % 1000);\n}\nexport function ticks(ts) {\n    return Long_op_Multiply(Long_fromNumber(ts), 10000);\n}\nexport function totalDays(ts) {\n    return ts / 86400000;\n}\nexport function totalHours(ts) {\n    return ts / 3600000;\n}\nexport function totalMinutes(ts) {\n    return ts / 60000;\n}\nexport function totalSeconds(ts) {\n    return ts / 1000;\n}\nexport function negate(ts) {\n    return ts * -1;\n}\nexport function add(ts1, ts2) {\n    return ts1 + ts2;\n}\nexport function subtract(ts1, ts2) {\n    return ts1 - ts2;\n}\nexport function multiply(ts, factor) {\n    return ts * factor;\n}\nexport function divide(ts, b) {\n    return ts / b;\n}\nexport const op_Addition = add;\nexport const op_Subtraction = subtract;\nexport const op_Multiply = multiply;\nexport const op_Division = divide;\nexport const compare = comparePrimitives;\nexport const compareTo = comparePrimitives;\nexport function duration(x) {\n    return Math.abs(x);\n}\nexport function toString(ts, format = \"c\", _provider) {\n    if ([\"c\", \"g\", \"G\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const d = Math.abs(days(ts));\n    const h = Math.abs(hours(ts));\n    const m = Math.abs(minutes(ts));\n    const s = Math.abs(seconds(ts));\n    const ms = Math.abs(milliseconds(ts));\n    const sign = ts < 0 ? \"-\" : \"\";\n    return `${sign}${d === 0 && (format === \"c\" || format === \"g\") ? \"\" : format === \"c\" ? d + \".\" : d + \":\"}${format === \"g\" ? h : padWithZeros(h, 2)}:${padWithZeros(m, 2)}:${padWithZeros(s, 2)}${ms === 0 && (format === \"c\" || format === \"g\") ? \"\" : format === \"g\" ? \".\" + padWithZeros(ms, 3) : \".\" + padLeftAndRightWithZeros(ms, 3, 7)}`;\n}\nexport function parse(str) {\n    const firstDot = str.search(\"\\\\.\");\n    const firstColon = str.search(\"\\\\:\");\n    if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4\n        const d = parseInt(str, 0);\n        if (isNaN(d)) {\n            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n        }\n        else {\n            return create(d, 0, 0, 0, 0);\n        }\n    }\n    if (firstColon > 0) { // process time part\n        // WIP: (-?)(((\\d+)\\.)?([0-9]|0[0-9]|1[0-9]|2[0-3]):(\\d+)(:\\d+(\\.\\d{1,7})?)?|\\d+(?:(?!\\.)))\n        const r = /^(-?)((\\d+)\\.)?(?:0*)([0-9]|0[0-9]|1[0-9]|2[0-3]):(?:0*)([0-5][0-9]|[0-9])(:(?:0*)([0-5][0-9]|[0-9]))?\\.?(\\d+)?$/.exec(str);\n        if (r != null && r[4] != null && r[5] != null) {\n            let d = 0;\n            let ms = 0;\n            let s = 0;\n            const sign = r[1] != null && r[1] === \"-\" ? -1 : 1;\n            const h = +r[4];\n            const m = +r[5];\n            if (r[3] != null) {\n                d = +r[3];\n            }\n            if (r[7] != null) {\n                s = +r[7];\n            }\n            if (r[8] != null) {\n                // Depending on the number of decimals passed, we need to adapt the numbers\n                switch (r[8].length) {\n                    case 1:\n                        ms = +r[8] * 100;\n                        break;\n                    case 2:\n                        ms = +r[8] * 10;\n                        break;\n                    case 3:\n                        ms = +r[8];\n                        break;\n                    case 4:\n                        ms = +r[8] / 10;\n                        break;\n                    case 5:\n                        ms = +r[8] / 100;\n                        break;\n                    case 6:\n                        ms = +r[8] / 1000;\n                        break;\n                    case 7:\n                        ms = +r[8] / 10000;\n                        break;\n                    default:\n                        throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n                }\n            }\n            return sign * create(d, h, m, s, ms);\n        }\n    }\n    throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n","namespace Fable.Remoting.Client\r\n\r\nopen System\r\nopen Fable.Core\r\nopen Fable.SimpleJson\r\nopen Browser.Types\r\n\r\nmodule internal Blob =\r\n    /// Creates a Blob from the given input string\r\n    [<Emit(\"new Blob([$0.buffer], { type: 'text/plain' })\")>]\r\n    let fromBinaryEncodedText (value: byte[]) : Blob = jsNative\r\n\r\n    /// Asynchronously reads the blob data content as string\r\n    let readBlobAsText (blob: Blob) : Async<string> =\r\n        Async.FromContinuations <| fun (resolve, _, _) ->\r\n            let reader = InternalUtilities.createFileReader()\r\n            reader.onload <- fun _ ->\r\n                if reader.readyState = FileReaderState.DONE\r\n                then resolve (unbox reader.result)\r\n\r\n            reader.readAsText(blob)\r\n\r\nmodule Proxy =\r\n    let combineRouteWithBaseUrl route (baseUrl: string option) =\r\n        match baseUrl with\r\n        | None -> route\r\n        | Some url -> sprintf \"%s%s\" (url.TrimEnd('/')) route\r\n\r\n    let isByteArray = function\r\n        | TypeInfo.Array getElemType ->\r\n            match getElemType() with\r\n            | TypeInfo.Byte -> true\r\n            | otherwise -> false\r\n        | otherwise -> false\r\n\r\n    let isAsyncOfByteArray = function\r\n        | TypeInfo.Async getAsyncType ->\r\n            match getAsyncType() with\r\n            | TypeInfo.Array getElemType ->\r\n                match getElemType() with\r\n                | TypeInfo.Byte -> true\r\n                | otherwise -> false\r\n            | otherwise -> false\r\n        | otherwise -> false\r\n\r\n    let rec getReturnType typ =\r\n        if Reflection.FSharpType.IsFunction typ then\r\n            let _, res = Reflection.FSharpType.GetFunctionElements typ\r\n            getReturnType res\r\n        elif typ.IsGenericType then\r\n            typ.GetGenericArguments () |> Array.head\r\n        else\r\n            typ\r\n\r\n    let proxyFetch options typeName (func: RecordField) fieldType =\r\n        let funcArgs : (TypeInfo [ ]) =\r\n            match func.FieldType with\r\n            | TypeInfo.Async inner -> [| func.FieldType |]\r\n            | TypeInfo.Promise inner -> [| func.FieldType |]\r\n            | TypeInfo.Func getArgs -> getArgs()\r\n            | _ -> failwithf \"Field %s does not have a valid definiton\" func.FieldName\r\n\r\n        let argumentCount = (Array.length funcArgs) - 1\r\n        let returnTypeAsync = Array.last funcArgs\r\n\r\n        let binaryInput =\r\n            match func.FieldType with\r\n            | TypeInfo.Func getArgs ->\r\n                match getArgs() with\r\n                | [| input; output |] -> isByteArray input\r\n                | otherwise -> false\r\n            | otherwise -> false\r\n\r\n        let route = options.RouteBuilder typeName func.FieldName\r\n        let url = combineRouteWithBaseUrl route options.BaseUrl\r\n        let funcNeedParameters =\r\n            match funcArgs with\r\n            | [| TypeInfo.Async _ |] -> false\r\n            | [| TypeInfo.Promise _ |] -> false\r\n            | [| TypeInfo.Unit; TypeInfo.Async _ |] -> false\r\n            | otherwise -> true\r\n\r\n        let contentType =\r\n            if binaryInput\r\n            then \"application/octet-stream\"\r\n            else \"application/json; charset=utf-8\"\r\n\r\n        let inputArgumentTypes = Array.take argumentCount funcArgs\r\n\r\n        let headers = [\r\n            yield \"Content-Type\", contentType\r\n            yield \"x-remoting-proxy\", \"true\"\r\n            yield! options.CustomHeaders\r\n            match options.Authorization with\r\n            | Some authToken -> yield \"Authorization\", authToken\r\n            | None -> () ]\r\n\r\n        let executeRequest =\r\n            if options.CustomResponseSerialization.IsSome || isAsyncOfByteArray returnTypeAsync then\r\n                let onOk =\r\n                    match options.CustomResponseSerialization with\r\n                    | Some serializer ->\r\n                        let returnType = getReturnType fieldType\r\n                        fun response -> serializer response returnType\r\n                    | _ -> box\r\n\r\n                fun requestBody -> async {\r\n                    // read as arraybuffer and deserialize\r\n                    let! (response, statusCode) =\r\n                        if funcNeedParameters then\r\n                            Http.post url\r\n                            |> Http.withBody requestBody\r\n                            |> Http.withHeaders headers\r\n                            |> Http.sendAndReadBinary\r\n                        else\r\n                            Http.get url\r\n                            |> Http.withHeaders headers\r\n                            |> Http.sendAndReadBinary\r\n\r\n                    match statusCode with\r\n                    | 200 ->\r\n                        return onOk response\r\n                    | n ->\r\n                        let responseAsBlob = Blob.fromBinaryEncodedText response\r\n                        let! responseText = Blob.readBlobAsText responseAsBlob\r\n                        let response = { StatusCode = statusCode; ResponseBody = responseText }\r\n                        let errorMsg = if n = 500 then sprintf \"Internal server error (500) while making request to %s\" url else sprintf \"Http error (%d) while making request to %s\" n url\r\n                        return! raise (ProxyRequestException(response, errorMsg, response.ResponseBody))\r\n                }\r\n            else\r\n                let returnType =\r\n                    match returnTypeAsync with\r\n                    | TypeInfo.Async getAsyncTypeArgument -> getAsyncTypeArgument()\r\n                    | TypeInfo.Promise getPromiseTypeArgument -> getPromiseTypeArgument()\r\n                    | _ -> failwithf \"Expected field %s to have a return type of Async<'t>\" func.FieldName\r\n\r\n                fun requestBody -> async {\r\n                    // make plain RPC request and let it go through the deserialization pipeline\r\n                    let! response =\r\n                        if funcNeedParameters then\r\n                            Http.post url\r\n                            |> Http.withBody requestBody\r\n                            |> Http.withHeaders headers\r\n                            |> Http.send\r\n                        else\r\n                            Http.get url\r\n                            |> Http.withHeaders headers\r\n                            |> Http.send\r\n\r\n                    match response.StatusCode with\r\n                    | 200 ->\r\n                        let parsedJson = SimpleJson.parseNative response.ResponseBody\r\n                        return Convert.fromJsonAs parsedJson returnType\r\n                    | 500 -> return! raise (ProxyRequestException(response, sprintf \"Internal server error (500) while making request to %s\" url, response.ResponseBody))\r\n                    | n ->   return! raise (ProxyRequestException(response, sprintf \"Http error (%d) from server occured while making request to %s\" n url, response.ResponseBody))\r\n                }\r\n\r\n        fun arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 ->\r\n            let inputArguments =\r\n               if funcNeedParameters\r\n               then Array.take argumentCount [| box arg0;box arg1;box arg2;box arg3; box arg4; box arg5; box arg6; box arg7 |]\r\n               else [| |]\r\n\r\n            let requestBody =\r\n                if binaryInput then\r\n                    RequestBody.Binary (unbox arg0)\r\n                else\r\n                    match inputArgumentTypes.Length with\r\n                    | 1 when not (Convert.arrayLike inputArgumentTypes.[0]) ->\r\n                        let typeInfo = TypeInfo.Tuple(fun _ -> inputArgumentTypes)\r\n                        let requestBodyJson = Convert.serialize inputArguments.[0] typeInfo\r\n                        RequestBody.Json requestBodyJson\r\n                    | 1 ->\r\n                        // for array-like types, use an explicit array surranding the input array argument\r\n                        let requestBodyJson = Convert.serialize [| inputArguments.[0] |] (TypeInfo.Array (fun _ -> inputArgumentTypes.[0]))\r\n                        RequestBody.Json requestBodyJson\r\n                    | n ->\r\n                        let typeInfo = TypeInfo.Tuple(fun _ -> inputArgumentTypes)\r\n                        let requestBodyJson = Convert.serialize inputArguments typeInfo\r\n                        RequestBody.Json requestBodyJson\r\n\r\n            executeRequest requestBody\r\n","namespace Fable.Remoting.Client\r\n\r\nopen Fable.Core\r\nopen Fable.SimpleJson\r\nopen System\r\nopen Microsoft.FSharp.Reflection\r\nopen Fable.Remoting\r\n\r\nmodule Remoting =\r\n    /// Starts with default configuration for building a proxy\r\n    let createApi() = {\r\n        CustomHeaders = [ ]\r\n        BaseUrl = None\r\n        Authorization = None\r\n        WithCredentials = false\r\n        RouteBuilder = sprintf (\"/%s/%s\")\r\n        CustomResponseSerialization = None\r\n    }\r\n\r\n    /// Defines how routes are built using the type name and method name. By default, the generated routes are of the form `/typeName/methodName`.\r\n    let withRouteBuilder builder (options: RemoteBuilderOptions) =\r\n        { options with RouteBuilder = builder }\r\n\r\n    /// Sets the base url for the request. Useful if you are making cross-domain requests\r\n    let withBaseUrl url (options: RemoteBuilderOptions) =\r\n        { options with BaseUrl = Some url }\r\n\r\n    /// Adds custom headers to each request of the proxy\r\n    let withCustomHeader headers (options: RemoteBuilderOptions) =\r\n        { options with CustomHeaders = headers }\r\n\r\n    /// Sets the authorization header of every request from the proxy\r\n    let withAuthorizationHeader token (options: RemoteBuilderOptions) =\r\n        { options with Authorization = Some token }\r\n\r\n    /// Sets the withCredentials option on the XHR request, which is useful for CORS scenarios\r\n    let withCredentials withCredentials (options: RemoteBuilderOptions) =\r\n        { options with WithCredentials = withCredentials }\r\n\r\n    /// Specifies that the API uses binary serialization for responses\r\n    let withBinarySerialization (options: RemoteBuilderOptions) =\r\n        let serializer response returnType = MsgPack.Read.Reader(response).Read returnType\r\n        { options with CustomResponseSerialization = Some serializer }\r\n\r\ntype Remoting() =\r\n    static member buildProxy<'t>(options: RemoteBuilderOptions, [<Inject>] ?resolver: ITypeResolver<'t>) : 't =\r\n        let resolvedType = resolver.Value.ResolveType()\r\n        let schemaType = createTypeInfo resolvedType\r\n        match schemaType with\r\n        | TypeInfo.Record getFields ->\r\n            let (fields, recordType) = getFields()\r\n            let fieldTypes = Reflection.FSharpType.GetRecordFields recordType |> Array.map (fun prop -> prop.Name, prop.PropertyType)\r\n            let recordFields = [|\r\n                for field in fields do\r\n                    let normalize n =\r\n                        let fieldType = fieldTypes |> Array.pick (fun (name, typ) -> if name = field.FieldName then Some typ else None)\r\n                        let fn = Proxy.proxyFetch options recordType.Name field fieldType\r\n                        match n with\r\n                        | 0 -> box (fn null null null null null null null null)\r\n                        | 1 -> box (fun a ->\r\n                            fn a null null null null null null null)\r\n                        | 2 ->\r\n                            let proxyF a b = fn a b null null null null null null\r\n                            unbox (System.Func<_,_,_> proxyF)\r\n                        | 3 ->\r\n                            let proxyF a b c = fn a b c null null null null null\r\n                            unbox (System.Func<_,_,_,_> proxyF)\r\n                        | 4 ->\r\n                            let proxyF a b c d = fn a b c d null null null null\r\n                            unbox (System.Func<_,_,_,_,_> proxyF)\r\n                        | 5 ->\r\n                            let proxyF a b c d e = fn a b c d e null null null\r\n                            unbox (System.Func<_,_,_,_,_,_> proxyF)\r\n                        | 6 ->\r\n                            let proxyF a b c d e f = fn a b c d e f null null\r\n                            unbox (System.Func<_,_,_,_,_,_,_> proxyF)\r\n                        | 7 ->\r\n                            let proxyF a b c d e f g = fn a b c d e f g null\r\n                            unbox (System.Func<_,_,_,_,_,_,_,_> proxyF)\r\n                        | 8 ->\r\n                            let proxyF a b c d e f g h = fn a b c d e f g h\r\n                            unbox (System.Func<_,_,_,_,_,_,_,_,_> proxyF)\r\n                        | _ ->\r\n                            failwithf \"Cannot generate proxy function for %s. Only up to 8 arguments are supported. Consider using a record type as input\" field.FieldName\r\n\r\n                    let argumentCount =\r\n                        match field.FieldType with\r\n                        | TypeInfo.Async _  -> 0\r\n                        | TypeInfo.Promise _  -> 0\r\n                        | TypeInfo.Func getArgs -> Array.length (getArgs()) - 1\r\n                        | _ -> 0\r\n\r\n                    normalize argumentCount\r\n                |]\r\n\r\n            let proxy = FSharpValue.MakeRecord(recordType, recordFields)\r\n            unbox proxy\r\n        | _ ->\r\n            failwithf \"Cannot build proxy. Exepected type %s to be a valid protocol definition which is a record of functions\" resolvedType.FullName\r\n\r\n","module AppModel\r\n\r\nopen Shared\r\n\r\ntype Mode =\r\n|NotSelected\r\n|Single\r\n|File\r\n\r\ntype DisplayHelp =\r\n|NoHelp\r\n|TechnicalScientificDetails\r\n|Contact\r\n|HowToUse\r\n|InputFormat\r\n\r\ntype PlotMode =\r\n|Propensity\r\n|TargetPScore\r\n\r\nmodule Server =\r\n\r\n    open Shared\r\n    open Fable.Remoting.Client\r\n\r\n    let targetPApi : ITargetPApi = \r\n        Remoting.createApi()\r\n        |> Remoting.withRouteBuilder Route.builder\r\n        |> Remoting.buildProxy<ITargetPApi>\r\n\r\n// The model holds data that you want to keep track of while the application is running\r\ntype Model = { \r\n    SessionGuid                 :   System.Guid\r\n    EULAAccepted                :   bool\r\n    EULAModalVisible            :   bool\r\n    BurgerVisible               :   bool\r\n    SelectedComputationMode     :   ComputationMode\r\n    SelectedOrganismModel       :   OrganismModel\r\n    SingleSequence              :   string\r\n    SingleSequenceResultLegacy  :   LegacyResult Option\r\n    SingleSequenceResultIMLP    :   IMLPResult Option\r\n    FastaFileInput              :   string []\r\n    FastaFileInputName          :   string\r\n    FastaFileInputResultLegacy  :   (LegacyResult array) Option\r\n    FastaFileInputResultIMLP    :   (IMLPResult array) Option\r\n    SeqMode                     :   Mode\r\n    ShowResults                 :   bool\r\n    ResultHeadingIsSticky       :   bool\r\n    CurrentResultViewIndex      :   int\r\n    DownloadReady               :   bool\r\n    DownloadFileName            :   string\r\n    FileProcessIndex            :   int\r\n    HasValidFasta               :   bool\r\n    InvalidFastaChars           :   char list\r\n    HasJobRunning               :   bool\r\n    ShowProgressDetails         :   bool\r\n    InformationSectionDisplay   :   DisplayHelp\r\n    HasError                    :   bool\r\n    ErrorState                  :   exn Option\r\n    ShowErrorStack              :   bool\r\n    PlotMode                    :   PlotMode\r\n} with\r\n\r\n    static member validateInputState (model:Model) =\r\n        match model.SeqMode with\r\n        |Single -> \r\n            match model.SingleSequence with\r\n            |\"\" -> false,\"No data provided\"\r\n            | _ ->\r\n                match model.HasValidFasta with\r\n                | false -> false, \"Fasta is invalid\"\r\n                | _ ->  if model.EULAAccepted then\r\n                            true,\"Start legacy computation\"\r\n                        else\r\n                            true,\"Start computation\"\r\n        |File -> \r\n            match model.FastaFileInput with\r\n            |[||] -> false,\"No data provided\"\r\n            | x when x.Length > 1000 ->\r\n                false, \"Too many sequences (>1000).\"\r\n            | _ ->\r\n                match model.HasValidFasta with\r\n                | false -> false, \"Fasta is invalid\"\r\n                | _ ->  if model.EULAAccepted then\r\n                            true,\"Start legacy computation\"\r\n                        else\r\n                            true,\"Start computation\"\r\n        |_ -> false,\"No data provided\"\r\n\r\n    static member getMultiResultLength (model:Model) =\r\n        match model.SelectedComputationMode with\r\n        | Legacy -> model.FastaFileInputResultLegacy.Value.Length\r\n        | IMLP -> model.FastaFileInputResultIMLP.Value.Length\r\n\r\n    static member hasMultiResult (model:Model) =\r\n        match model.SelectedComputationMode with\r\n        | Legacy -> model.FastaFileInputResultLegacy.IsSome\r\n        | IMLP -> model.FastaFileInputResultIMLP.IsSome\r\n\r\n    static member hasSingleResult (model:Model) =\r\n        match model.SelectedComputationMode with\r\n        | Legacy -> model.SingleSequenceResultLegacy.IsSome\r\n        | IMLP -> model.SingleSequenceResultIMLP.IsSome\r\n\r\n    static member tryGetSingleSequenceScoresOfInterest (model:Model) =\r\n        match (model.SelectedComputationMode, model.SeqMode) with\r\n        | (IMLP, Single)    -> model.SingleSequenceResultIMLP |> Option.map (fun x -> x.PropensityScores)\r\n        | (Legacy, Single)  ->\r\n            match model.PlotMode with\r\n            | PlotMode.Propensity   ->  model.SingleSequenceResultLegacy |> Option.map (fun x -> x.PropensityScores)\r\n            | PlotMode.TargetPScore ->  model.SingleSequenceResultLegacy |> Option.map (fun x -> x.RawTargetPScores)\r\n        | _ -> None\r\n\r\nlet initialModel = {\r\n    SessionGuid                 =   System.Guid.NewGuid()\r\n    EULAAccepted                =   false\r\n    EULAModalVisible            =   false\r\n    BurgerVisible               =   false\r\n    SelectedComputationMode     =   ComputationMode.IMLP\r\n    SelectedOrganismModel       =   NonPlant\r\n    SingleSequence              =   \"\"\r\n    SingleSequenceResultLegacy  =   None\r\n    SingleSequenceResultIMLP    =   None\r\n    FastaFileInput              =   [||]\r\n    FastaFileInputName          =   \"No file selected\"\r\n    FastaFileInputResultLegacy  =   None\r\n    FastaFileInputResultIMLP    =   None\r\n    SeqMode                     =   Mode.NotSelected\r\n    ShowResults                 =   false\r\n    ResultHeadingIsSticky       =   false\r\n    CurrentResultViewIndex      =   0\r\n    DownloadReady               =   false\r\n    DownloadFileName            =   \"IMTS_prediction_results.txt\"\r\n    FileProcessIndex            =   0\r\n    HasValidFasta               =   true\r\n    InvalidFastaChars           =   []\r\n    HasJobRunning               =   false\r\n    ShowProgressDetails         =   false\r\n    InformationSectionDisplay   =   NoHelp\r\n    HasError                    =   false\r\n    ErrorState                  =   None\r\n    ShowErrorStack              =   false\r\n    PlotMode                    =   Propensity\r\n}\r\n\r\n// The Msg type defines what events/actions can occur while the application is running\r\n// the state of the application changes *only* in reaction to these events\r\ntype Msg =\r\n| Reset\r\n| ToggleBurger\r\n| EULAAcceptedChange\r\n| ShowEulaModal                     of bool\r\n| SeqModeSelection                  of Mode\r\n| OrganismModelSelection            of OrganismModel\r\n| FastaUploadInput                  of string*string\r\n| SingleSequenceInput               of string\r\n// Upload a single sequence and execute serverside computation based on computation mode\r\n| SingleSequenceRequest             of ComputationMode\r\n| SingleSequenceResponseLegacy      of Result<LegacyResult,exn>\r\n| SingleSequenceResponseIMLP        of Result<IMLPResult,exn>\r\n// Upload a fasta file and execute serverside computation based on computation mode\r\n| FastaUploadRequest                of ComputationMode\r\n| FastaUploadResponseLegacy         of Result<LegacyResult,exn>\r\n| FastaUploadResponseIMLP           of Result<IMLPResult,exn>\r\n| FileProcessingDone\r\n| ShowPlot                          of int \r\n| PrepareDownloadCSV\r\n| DownloadResponse                  of Result<unit,exn>\r\n| DownloadFileNameChange            of string\r\n| ShowProgressDetails\r\n| ToggleResultHeadingSticky         of bool\r\n| ChangeViewIndex                   of int\r\n| ChangeHelpDisplay                 of DisplayHelp\r\n| FastaValidation                   of Result<string,char list>\r\n| GenericError                      of exn\r\n| ChangeErrorStateVisibility\r\n| ChangePlotMode                    of PlotMode","namespace Shared\n\ntype Counter = int\n\nmodule Route =\n    /// Defines how routes are generated on server and mapped from client\n    let builder typeName methodName =\n        sprintf \"/api/%s/%s\" typeName methodName\n\ntype OrganismModel =\n|Plant\n|NonPlant\n\ntype ComputationMode =\n| Legacy\n| IMLP\n\ntype ParseState =\n    | EmptySequence\n    | FilteredEmptySequence\n    | InvalidCharacters of char []\n    | ShortSequence of string\n    | FilteredShortSequence of string\n    | ContainsGapTerOJ of string\n    | Success of string\n    | InternalServerError\n\ntype LegacyResult =\n    {\n        Header                  : string\n        Sequence                : string\n        RawTargetPScores        : float array\n        SmoothedTargetPScores   : float array\n        PropensityScores        : float array\n        PropensityPlotHtml      : string\n        ScorePlotHtml           : string\n        ParseState              : ParseState\n    } with\n        static member create header sequence raw smoothed prop propPlot scorePlot parseState =\n            {\n                Header                  = header\n                Sequence                = sequence\n                RawTargetPScores        = raw\n                SmoothedTargetPScores   = smoothed\n                PropensityScores        = prop\n                PropensityPlotHtml      = propPlot\n                ScorePlotHtml           = scorePlot\n                ParseState              = parseState\n            }\n\ntype IMLPResult =\n    {\n        Header              : string\n        Sequence            : string\n        PropensityScores    : float array\n        PropensityPlotHtml  : string\n        ParseState          : ParseState\n    } with\n        static member create header sequence prop propPlot parseState=\n            {\n                Header              = header\n                Sequence            = sequence\n                PropensityScores    = prop\n                PropensityPlotHtml  = propPlot\n                ParseState          = parseState\n            }\n\n/// A type that specifies the communication protocol between client and server\n/// to learn more, read the docs at https://zaid-ajaj.github.io/Fable.Remoting/src/basics.html\n\ntype ITargetPApi = {\n\n    getVersion: unit -> Async<string>\n\n    // Legacy model\n    SingleSequenceRequestLegacy : OrganismModel*string -> Async<LegacyResult>\n    DownloadRequestSingleLegacy: LegacyResult*System.Guid -> Async<unit>\n    DownloadRequestMultipleLegacy: LegacyResult array * System.Guid -> Async<unit>\n\n    //iMLP model\n    SingleSequenceRequestIMLP : OrganismModel*string -> Async<IMLPResult>\n    DownloadRequestSingleIMLP: IMLPResult*System.Guid -> Async<unit>\n    DownloadRequestMultipleIMLP: IMLPResult array * System.Guid -> Async<unit>\n}","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\nopen Browser.Types\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Modal =\r\n\r\n    type Option =\r\n        | Props of IHTMLProp list\r\n        /// Add `is-active` class if true\r\n        | [<CompiledName(\"is-active\")>] IsActive of bool\r\n        | CustomClass of string\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    module Close =\r\n        type Option =\r\n            | Size of ISize\r\n            | OnClick of (MouseEvent -> unit)\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"modal\"></div>\r\n    let modal (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | IsActive state -> if state then result.AddCaseName option else result\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"modal\").ToReactElement(div, children)\r\n\r\n    /// Generate <button class=\"modal-close\"></button>\r\n    let close (options : Close.Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Close.Size IsSmall\r\n            | Close.Size IsMedium ->\r\n                Fable.Core.JS.console.warn(\"`is-small` and `is-medium` are not valid sizes for 'modal close'\")\r\n                result\r\n            | Close.Size size -> ofSize size |> result.AddClass\r\n            | Close.OnClick cb -> DOMAttr.OnClick cb |> result.AddProp\r\n            | Close.Props props -> result.AddProps props\r\n            | Close.CustomClass customClass -> result.AddClass customClass\r\n            | Close.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"modal-close\").ToReactElement(button, children)\r\n\r\n    /// Generate <div class=\"modal-background\"></div>\r\n    let background (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"modal-background\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"modal-content\"></div>\r\n    let content (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"modal-content\").ToReactElement(div, children)\r\n\r\n    module Card =\r\n\r\n        /// Generate <div class=\"modal-card\"></div>\r\n        let card (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"modal-card\").ToReactElement(div, children)\r\n\r\n        /// Generate <header class=\"modal-card-head\"></header>\r\n        let head (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"modal-card-head\").ToReactElement(header, children)\r\n\r\n        /// Generate <footer class=\"modal-card-foot\"></footer>\r\n        let foot (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"modal-card-foot\").ToReactElement(footer, children)\r\n\r\n        /// Generate <div class=\"modal-card-title\"></div>\r\n        let title (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"modal-card-title\").ToReactElement(div, children)\r\n\r\n        /// Generate <div class=\"modal-card-body\"></div>\r\n        let body (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"modal-card-body\").ToReactElement(section, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Heading =\r\n\r\n    type Option =\r\n        /// Add `is-1` class\r\n        | [<CompiledName(\"is-1\")>]Is1\r\n        /// Add `is-2` class\r\n        | [<CompiledName(\"is-2\")>]Is2\r\n        /// Add `is-3` class\r\n        | [<CompiledName(\"is-3\")>]Is3\r\n        /// Add `is-4` class\r\n        | [<CompiledName(\"is-4\")>]Is4\r\n        /// Add `is-5` class\r\n        | [<CompiledName(\"is-5\")>]Is5\r\n        /// Add `is-6` class\r\n        | [<CompiledName(\"is-6\")>]Is6\r\n        /// Add `subtitle` class\r\n        | [<CompiledName(\"subtitle\")>]IsSubtitle\r\n        /// Add `is-spaced` class\r\n        | [<CompiledName(\"is-spaced\")>]IsSpaced\r\n        // Extra\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    let internal title (element : IHTMLProp list -> ReactElement list -> ReactElement) (options : Option list)\r\n        (children) =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            // Sizes\r\n            | Is1\r\n            | Is2\r\n            | Is3\r\n            | Is4\r\n            | Is5\r\n            | Is6\r\n            | IsSpaced -> result.AddCaseName option\r\n            // Styles\r\n            | IsSubtitle ->\r\n                result.RemoveClass(\"title\").AddClass(\"subtitle\")\r\n            // Extra\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, baseClass=\"title\").ToReactElement(element, children)\r\n\r\n    // Alias\r\n    /// Generate <h1 class=\"title is-1\"></h1>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let h1 (options : Option list) = title h1 (Is1 :: options)\r\n    /// Generate <h2 class=\"title is-2\"></h2>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let h2 (options : Option list) = title h2 (Is2 :: options)\r\n    /// Generate <h3 class=\"title is-3\"></h3>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let h3 (options : Option list) = title h3 (Is3 :: options)\r\n    /// Generate <h4 class=\"title is-4\"></h4>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let h4 (options : Option list) = title h4 (Is4 :: options)\r\n    /// Generate <h5 class=\"title is-5\"></h5>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let h5 (options : Option list) = title h5 (Is5 :: options)\r\n    /// Generate <h6 class=\"title is-6\"></h6>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let h6 (options : Option list) = title h6 (Is6 :: options)\r\n    /// Generate <p class=\"title\"></p>\r\n    /// Class can be `subtitle` if you pass `Heading.IsSubtitle`\r\n    let p opts children = title p opts children\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\nopen Browser.Types\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Button =\r\n\r\n    type Option =\r\n        // Colors\r\n        | Color of IColor\r\n        | Size of ISize\r\n        /// Add `is-fullwidth` class\r\n        | [<CompiledName(\"is-fullwidth\")>] IsFullWidth\r\n        /// Add `is-link` class\r\n        | [<CompiledName(\"is-link\")>] IsLink\r\n        /// Add `is-outlined` class\r\n        | [<CompiledName(\"is-outlined\")>] IsOutlined\r\n        /// Add `is-inverted` class\r\n        | [<CompiledName(\"is-inverted\")>] IsInverted\r\n        /// Add `is-text` class\r\n        | [<CompiledName(\"is-text\")>] IsText\r\n        /// Add `is-ghost` class\r\n        | [<CompiledName(\"is-ghost\")>] IsGhost\r\n        /// Add `is-rounded` class\r\n        | [<CompiledName(\"is-rounded\")>] IsRounded\r\n        /// Add `is-expanded` class\r\n        | [<CompiledName(\"is-expanded\")>] IsExpanded\r\n        /// Add `is-hovered` class if true\r\n        | [<CompiledName(\"is-hovered\")>] IsHovered of bool\r\n        /// Add `is-focused` class if true\r\n        | [<CompiledName(\"is-focused\")>] IsFocused of bool\r\n        /// Add `is-active` class if true\r\n        | [<CompiledName(\"is-active\")>] IsActive of bool\r\n        /// Add `is-loading` class if true\r\n        | [<CompiledName(\"is-loading\")>] IsLoading of bool\r\n        /// Add `is-static` class if true\r\n        | [<CompiledName(\"is-static\")>] IsStatic of bool\r\n        /// Add `is-light` class\r\n        | [<CompiledName(\"is-light\")>] IsLight\r\n        /// Set `disabled` HTMLAttr\r\n        | Disabled of bool\r\n        | Props of IHTMLProp list\r\n        | OnClick of (MouseEvent -> unit)\r\n        | CustomClass of string\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    let internal btnView element (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | Size size -> ofSize size |> result.AddClass\r\n            // Styles\r\n            | IsLink\r\n            | IsFullWidth\r\n            | IsOutlined\r\n            | IsInverted\r\n            | IsText\r\n            | IsRounded\r\n            | IsExpanded\r\n            | IsGhost\r\n            | IsLight -> result.AddCaseName option\r\n            // States\r\n            | IsHovered state\r\n            | IsFocused state\r\n            | IsActive state\r\n            | IsLoading state\r\n            | IsStatic state -> if state then result.AddCaseName option else result\r\n            | Disabled isDisabled -> Fable.React.Props.Disabled isDisabled |> result.AddProp\r\n            | OnClick cb -> DOMAttr.OnClick cb |> result.AddProp\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"button\").ToReactElement(element, children)\r\n\r\n    /// Generate <button class=\"button\"></button>\r\n    let button options children = btnView button options children\r\n    /// Generate <span class=\"button\"></span>\r\n    let span options children = btnView span options children\r\n    /// Generate <a class=\"button\"></a>\r\n    let a options children = btnView a options children\r\n\r\n    module Input =\r\n        let internal btnInput typ options =\r\n            let hasProps =\r\n                options\r\n                |> List.exists (fun opts ->\r\n                    match opts with\r\n                    | Props _ -> true\r\n                    | _ -> false\r\n                )\r\n\r\n            if hasProps then\r\n                let newOptions =\r\n                    options\r\n                    |> List.map (fun opts ->\r\n                        match opts with\r\n                        | Props props -> Props ((Type typ :> IHTMLProp) ::props)\r\n                        | forward -> forward\r\n                    )\r\n                btnView (fun options _ -> input options) newOptions [ ]\r\n\r\n            else\r\n                btnView (fun options _ -> input options) ((Props [ Type typ ])::options) [ ]\r\n\r\n        /// Generate <input type=\"reset\" class=\"button\" />\r\n        let reset options = btnInput \"reset\" options\r\n        /// Generate <input type=\"submit\" class=\"button\" />\r\n        let submit options = btnInput \"submit\" options\r\n\r\n    module List =\r\n\r\n        type Option =\r\n            /// Add `has-addons` class\r\n            | [<CompiledName(\"has-addons\")>] HasAddons\r\n            /// Add `is-centered` class\r\n            | [<CompiledName(\"is-centered\")>] IsCentered\r\n            | [<CompiledName(\"is-right\")>] IsRight\r\n            /// Add `are-small` class\r\n            | [<CompiledName(\"are-small\")>] AreSmall\r\n            /// Add `are-medium` class\r\n            | [<CompiledName(\"are-medium\")>] AreMedium\r\n            /// Add `are-large` class\r\n            | [<CompiledName(\"are-large\")>] AreLarge\r\n            // | Size of ISize\r\n            | Props of IHTMLProp list\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"buttons\"></div>\r\n    let list (options : List.Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | List.HasAddons\r\n            | List.IsCentered\r\n            | List.IsRight\r\n            | List.AreSmall\r\n            | List.AreMedium\r\n            | List.AreLarge -> result.AddCaseName option\r\n            | List.Props props -> result.AddProps props\r\n            | List.CustomClass customClass -> result.AddClass customClass\r\n            | List.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"buttons\").ToReactElement(div, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Icon =\r\n\r\n    type Option =\r\n        // Sizes\r\n        | Size of ISize\r\n        /// Add `is-left` class\r\n        | [<CompiledName(\"is-left\")>] IsLeft\r\n        /// Add `is-right` class\r\n        | [<CompiledName(\"is-right\")>] IsRight\r\n        // Extra\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <span class=\"icon\"></span>\r\n    let icon options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            // Sizes\r\n            | Size size -> ofSize size |> result.AddClass\r\n            // Position\r\n            | IsLeft\r\n            | IsRight -> result.AddCaseName option\r\n            // Extra\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"icon\").ToReactElement(span, children)\r\n\r\n    module Text =\r\n\r\n        let span (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"icon-text\").ToReactElement(span, children)\r\n\r\n        let div (options: GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"icon-text\").ToReactElement(div, children)\r\n","namespace Fable.FontAwesome\n\nopen Fable.Core\nopen Fable.React\nopen Fable.React.Props\n\nmodule internal Helpers =\n\n    let classes std (options : string option list) (booleans: (string * bool) list) =\n        let std = (std, options) ||> List.fold (fun complete opt ->\n            match opt with Some name -> complete + \" \" + name | None -> complete)\n        (std, booleans) ||> List.fold (fun complete (name, flag) ->\n            if flag then complete + \" \" + name else complete)\n        |> ClassName :> IHTMLProp\n\n[<RequireQualifiedAccess>]\nmodule Fa =\n\n    module Classes =\n        module Size =\n            let [<Literal>] FaExtraSmall = \"fa-xs\"\n            let [<Literal>] FaSmall = \"fa-sm\"\n            let [<Literal>] FaLarge = \"fa-lg\"\n            let [<Literal>] Fa2x = \"fa-2x\"\n            let [<Literal>] Fa3x = \"fa-3x\"\n            let [<Literal>] Fa4x = \"fa-4x\"\n            let [<Literal>] Fa5x = \"fa-5x\"\n            let [<Literal>] Fa6x = \"fa-6x\"\n            let [<Literal>] Fa7x = \"fa-7x\"\n            let [<Literal>] Fa8x = \"fa-8x\"\n            let [<Literal>] Fa9x = \"fa-9x\"\n            let [<Literal>] Fa10 = \"fa-10x\"\n\n        module Style =\n            let [<Literal>] FixedWidth = \"fa-fw\"\n            let [<Literal>] IsLi = \"fa-li\"\n            let [<Literal>] Border = \"fa-border\"\n            let [<Literal>] Inverse = \"fa-inverse\"\n\n        module Rotations =\n            let [<Literal>] Rotate90 = \"fa-rotate-90\"\n            let [<Literal>] Rotate180 = \"fa-rotate-180\"\n            let [<Literal>] Rotate270 = \"fa-rotate-270\"\n\n        module Flips =\n            let [<Literal>] Horizontal = \"fa-flip-horizontal\"\n            let [<Literal>] Vertical = \"fa-flip-vertical\"\n\n        module Animations =\n            let [<Literal>] Spin = \"fa-spin\"\n            let [<Literal>] Pulse = \"fa-pulse\"\n\n        module Pull =\n            let [<Literal>] Right = \"fa-pull-right\"\n            let [<Literal>] Left = \"fa-pull-left\"\n\n        module Stack =\n\n            let [<Literal>] Container = \"fa-stack\"\n\n            module Size =\n                let [<Literal>] Fa1x = \"fa-stack-1x\"\n                let [<Literal>] Fa2x = \"fa-stack-2x\"\n\n    type ISize =\n        | FaExtraSmall\n        | FaSmall\n        | FaLarge\n        | Fa2x\n        | Fa3x\n        | Fa4x\n        | Fa5x\n        | Fa6x\n        | Fa7x\n        | Fa8x\n        | Fa9x\n        | Fa10\n\n    type IconOption =\n        | Size of ISize\n        | Border\n        | PullLeft\n        | PullRight\n        | Inverse\n        | Rotate90\n        | Rotate180\n        | Rotate270\n        | FlipHorizontal\n        | FlipVertical\n        | IsLi\n        | Icon of string\n        | Spin\n        | Pulse\n        | Props of IHTMLProp list\n        | CustomClass of string\n        | FixedWidth\n        | Stack1x\n        | Stack2x\n\n    let internal ofSize (size : ISize) =\n        match size with\n        | FaExtraSmall -> Classes.Size.FaExtraSmall\n        | FaSmall -> Classes.Size.FaSmall\n        | FaLarge -> Classes.Size.FaLarge\n        | Fa2x -> Classes.Size.Fa2x\n        | Fa3x -> Classes.Size.Fa3x\n        | Fa4x -> Classes.Size.Fa4x\n        | Fa5x -> Classes.Size.Fa5x\n        | Fa6x -> Classes.Size.Fa6x\n        | Fa7x -> Classes.Size.Fa7x\n        | Fa8x -> Classes.Size.Fa8x\n        | Fa9x -> Classes.Size.Fa9x\n        | Fa10 -> Classes.Size.Fa10\n\n    type IconOptions =\n        { Icon : string option\n          Size : string option\n          Border : string option\n          Pull : string option\n          HaveSpin : bool\n          HavePulse : bool\n          Rotation : string option\n          Flip : string option\n          IsInverse : bool\n          Props : IHTMLProp list\n          FixedWidth : bool\n          IsLi : bool\n          StackSize : string option\n          CustomClass : string option }\n\n        static member Empty =\n            { Icon = None\n              Size = None\n              Border = None\n              Pull = None\n              HaveSpin = false\n              HavePulse = false\n              Rotation = None\n              Flip = None\n              IsInverse = false\n              Props = [ ]\n              FixedWidth = false\n              IsLi = false\n              StackSize = None\n              CustomClass = None }\n\n    let toIconOptions (faOptions: IconOption list) =\n        let parseOptions (result: IconOptions) (option: IconOption) =\n            match option with\n            | Size s ->\n                { result with Size = ofSize s |> Some }\n            | Border ->\n                { result with Border = Some Classes.Style.Border }\n            | PullLeft ->\n                { result with Pull = Some Classes.Pull.Left }\n            | PullRight ->\n                { result with Pull = Some Classes.Pull.Right }\n            | Inverse ->\n                { result with IsInverse = true }\n            | Icon faIcon ->\n                { result with Icon = faIcon |> Some }\n            | Rotate90 ->\n                { result with Rotation = Classes.Rotations.Rotate90 |> Some }\n            | Rotate180 ->\n                { result with Rotation = Classes.Rotations.Rotate180 |> Some }\n            | Rotate270 ->\n                { result with Rotation = Classes.Rotations.Rotate270 |> Some }\n            | FlipHorizontal ->\n                { result with Rotation = Classes.Flips.Horizontal |> Some }\n            | FlipVertical ->\n                { result with Rotation = Classes.Flips.Vertical |> Some }\n            | Spin ->\n                { result with HaveSpin = true }\n            | Pulse ->\n                { result with HavePulse = true }\n            | Props props ->\n                { result with Props = props }\n            | FixedWidth ->\n                { result with FixedWidth = true }\n            | IsLi ->\n                { result with IsLi = true }\n            | CustomClass customClass ->\n                { result with CustomClass = Some customClass }\n            | Stack1x ->\n                { result with StackSize = Some Classes.Stack.Size.Fa1x }\n            | Stack2x ->\n                { result with StackSize = Some Classes.Stack.Size.Fa2x }\n\n        faOptions |> List.fold parseOptions IconOptions.Empty\n\n    /// Logic used to display one icon alone or as one item in an unordered list:\n    let internal displayIcon baseElement baseClass (opts: IconOptions) children  =\n        let classes =\n            Helpers.classes baseClass\n                [ opts.Icon\n                  opts.Size\n                  opts.Border\n                  opts.Pull\n                  opts.Rotation\n                  opts.Flip\n                  opts.CustomClass\n                  opts.StackSize ]\n                [ Classes.Style.FixedWidth, opts.FixedWidth\n                  Classes.Style.IsLi, opts.IsLi\n                  Classes.Animations.Pulse, opts.HavePulse\n                  Classes.Animations.Spin, opts.HaveSpin\n                  Classes.Style.Inverse, opts.IsInverse ]\n\n        baseElement (classes::opts.Props)\n          children\n\n    let ul props children =\n        ul [ ClassName \"fa-ul\" ]\n            children\n\n    let ol props children =\n        ol [ ClassName \"fa-ul\" ]\n            children\n\n    let i (faOptions: IconOption list) children =\n        let opts = toIconOptions faOptions\n        displayIcon i \"\" opts children\n\n    let span (faOptions: IconOption list) children =\n        let opts = toIconOptions faOptions\n        displayIcon span \"\" opts children\n\n    module Stack =\n        type Option =\n            | Size of ISize\n            | CustomClass of string\n            | Props of IHTMLProp list\n\n        type internal Options =\n            { Size : string option\n              Props : IHTMLProp list\n              CustomClass : string option }\n\n            static member Empty =\n                { Size = None\n                  Props = [ ]\n                  CustomClass = None }\n\n\n    let stack options children =\n        let parseOption (result : Stack.Options) opt =\n            match opt with\n            | Stack.Size size ->\n                { result with Size = ofSize size |> Some }\n            | Stack.CustomClass customClass ->\n                { result with CustomClass = Some customClass }\n            | Stack.Props props ->\n                { result with Props = props }\n\n        let opts = options |> List.fold parseOption Stack.Options.Empty\n        let classes = Helpers.classes\n                        Classes.Stack.Container\n                        ( opts.Size\n                            :: opts.CustomClass\n                            :: [] )\n                        [ ]\n\n        Fable.React.Standard.span (classes::opts.Props)\n            children\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Container =\r\n\r\n    type Option =\r\n        /// Add `is-fluid` class\r\n        | [<CompiledName(\"is-fluid\")>] IsFluid\r\n        /// Add `is-widescreen` class\r\n        | [<CompiledName(\"is-widescreen\")>] IsWideScreen\r\n        /// Add `is-fullhd` class\r\n        | [<CompiledName(\"is-fullhd\")>] IsFullHD\r\n        | Props of IHTMLProp list\r\n        | CustomClass of string\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"container\"></div>\r\n    let container (options: Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | IsFluid\r\n            | IsWideScreen\r\n            | IsFullHD -> result.AddCaseName option\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"container\").ToReactElement(div, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Content =\r\n\r\n    type Option =\r\n        | Size of ISize\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"content\"></div>\r\n    let content (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Size size -> ofSize size |> result.AddClass\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"content\").ToReactElement(div, children)\r\n\r\n    module Ol =\r\n\r\n        type Option =\r\n            | [<CompiledName(\"is-lower-roman\")>] IsLowerRoman\r\n            | [<CompiledName(\"is-upper-roman\")>] IsUpperRoman\r\n            | [<CompiledName(\"is-lower-alpha\")>] IsLowerAlpha\r\n            | [<CompiledName(\"is-upper-alpha\")>] IsUpperAlpha\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n            | Props of IHTMLProp list\r\n\r\n        /// Generate <ol></ol>\r\n        let ol (options : Option list) children =\r\n            let parseOptions (result : GenericOptions) option =\r\n                match option with\r\n                | IsLowerRoman\r\n                | IsUpperRoman\r\n                | IsLowerAlpha\r\n                | IsUpperAlpha -> result.AddCaseName option\r\n                | Props props -> result.AddProps props\r\n                | CustomClass customClass -> result.AddClass customClass\r\n                | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n            GenericOptions.Parse(options, parseOptions).ToReactElement(ol, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Columns =\r\n\r\n    type ISize =\r\n        | [<CompiledName(\"is-1\")>] Is1\r\n        | [<CompiledName(\"is-2\")>] Is2\r\n        | [<CompiledName(\"is-3\")>] Is3\r\n        | [<CompiledName(\"is-4\")>] Is4\r\n        | [<CompiledName(\"is-5\")>] Is5\r\n        | [<CompiledName(\"is-6\")>] Is6\r\n        | [<CompiledName(\"is-7\")>] Is7\r\n        | [<CompiledName(\"is-8\")>] Is8\r\n\r\n        static member ToString (x : ISize)=\r\n            Reflection.getCaseName x\r\n\r\n    let inline private gapSizeGeneric (screen : Screen) (size : ISize) =\r\n        ISize.ToString size + Screen.ToString screen\r\n\r\n    let inline private gapSizeOnly (screen : Screen) (size : ISize) =\r\n        match screen with\r\n        | Screen.Tablet\r\n        | Screen.Desktop\r\n        | Screen.WideScreen ->\r\n            ISize.ToString size + Screen.ToString screen + \"-only\"\r\n        | x ->\r\n            let msg = sprintf \"Screen `%s` does not support `is-%s-%s-only`.\" (Screen.ToString x) (ISize.ToString size) (Screen.ToString x)\r\n            Fable.Core.JS.console.warn(msg)\r\n            \"\"\r\n\r\n    type Option =\r\n        /// Add `is-centered` class\r\n        | [<CompiledName(\"is-centered\")>] IsCentered\r\n        /// Add `is-vcentered` class\r\n        | [<CompiledName(\"is-vcentered\")>] IsVCentered\r\n        /// Add `is-multiline` class\r\n        | [<CompiledName(\"is-multiline\")>] IsMultiline\r\n        /// Add `is-gapless` class\r\n        | [<CompiledName(\"is-gapless\")>] IsGapless\r\n        /// Add `is-mobile` class\r\n        | [<CompiledName(\"is-mobile\")>] IsMobile\r\n        /// Add `is-desktop` class\r\n        | [<CompiledName(\"is-desktop\")>] IsDesktop\r\n        /// Configure the gap size. You can configure the display and gap size\r\n        /// Example: Columns.IsGap (Columns.Desktop, Columns.Is6)\r\n        /// Becomes: `is-6-desktop`\r\n        | IsGap of Screen * ISize\r\n        /// Configure the gap size. You can configure the display and gap size\r\n        /// Example: Columns.IsGapOnly (Columns.Tablet, Columns.Is6)\r\n        /// Becomes: `is-6-tablet-only`\r\n        | IsGapOnly of Screen * ISize\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"columns\"></div>\r\n    let columns (options: Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | IsCentered\r\n            | IsVCentered\r\n            | IsMultiline\r\n            | IsGapless\r\n            | IsMobile\r\n            | IsDesktop -> result.AddCaseName option\r\n            | IsGap (screen, size) ->\r\n                if not (List.contains \"is-variable\" result.Classes) then\r\n                    result.AddClass(\"is-variable\").AddClass(gapSizeGeneric screen size)\r\n                else\r\n                    result.AddClass(gapSizeGeneric screen size)\r\n            | IsGapOnly (screen, size) ->\r\n                if not (List.contains \"is-variable\" result.Classes) then\r\n                    result.AddClass(\"is-variable\").AddClass(gapSizeOnly screen size)\r\n                else\r\n                    result.AddClass(gapSizeOnly screen size)\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"columns\").ToReactElement(div, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Column =\r\n\r\n    type ISize =\r\n        | [<CompiledName(\"is-one-quarter\")>] IsOneQuarter\r\n        | [<CompiledName(\"is-one-third\")>] IsOneThird\r\n        | [<CompiledName(\"is-half\")>] IsHalf\r\n        | [<CompiledName(\"is-two-thirds\")>] IsTwoThirds\r\n        | [<CompiledName(\"is-three-quarters\")>] IsThreeQuarters\r\n        | [<CompiledName(\"is-1\")>] Is1\r\n        | [<CompiledName(\"is-2\")>] Is2\r\n        | [<CompiledName(\"is-3\")>] Is3\r\n        | [<CompiledName(\"is-4\")>] Is4\r\n        | [<CompiledName(\"is-5\")>] Is5\r\n        | [<CompiledName(\"is-6\")>] Is6\r\n        | [<CompiledName(\"is-7\")>] Is7\r\n        | [<CompiledName(\"is-8\")>] Is8\r\n        | [<CompiledName(\"is-9\")>] Is9\r\n        | [<CompiledName(\"is-10\")>] Is10\r\n        | [<CompiledName(\"is-11\")>] Is11\r\n        | [<CompiledName(\"is-12\")>] Is12\r\n        | [<CompiledName(\"is-narrow\")>] IsNarrow\r\n        | [<CompiledName(\"is-full\")>] IsFull\r\n        | [<CompiledName(\"is-one-fifth\")>] IsOneFifth\r\n        | [<CompiledName(\"is-two-fifths\")>] IsTwoFifths\r\n        | [<CompiledName(\"is-three-fifths\")>] IsThreeFifths\r\n        | [<CompiledName(\"is-four-fifths\")>] IsFourFifths\r\n\r\n    type Option =\r\n        /// Configure the width of the column. You can configure the display and size\r\n        /// Example: Column.Width (Column.Desktop, Column.Is6)\r\n        /// Becomes: `is-6-desktop`\r\n        | Width of Screen * ISize\r\n        /// Configure the offset of the column. You can configure the display and offset size\r\n        /// Example: Column.Offset (Column.Desktop, Column.Is6)\r\n        /// Becomes: `is-offset-6-desktop`\r\n        | Offset of Screen * ISize\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    let private suffix = function\r\n        | Screen.All -> \"\"\r\n        | Screen.Desktop -> \"-desktop\"\r\n        | Screen.Tablet -> \"-tablet\"\r\n        | Screen.Mobile -> \"-mobile\"\r\n        | Screen.WideScreen -> \"-widescreen\"\r\n        | Screen.FullHD -> \"-fullhd\"\r\n        | Screen.Touch -> \"-touch\"\r\n\r\n    let internal ofWidth (screen, size) =\r\n        Reflection.getCaseName size + suffix screen\r\n\r\n    let internal ofOffset (screen, offset) =\r\n        let className = Reflection.getCaseName offset\r\n        \"is-offset-\" + className.[3..] + suffix screen\r\n\r\n    /// Generate <div class=\"column\"></div>\r\n    let column (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Width (screen, width) ->\r\n                ofWidth (screen, width) |> result.AddClass\r\n            | Offset (screen, offset) ->\r\n                ofOffset (screen, offset) |> result.AddClass\r\n            | CustomClass customClass ->\r\n                result.AddClass customClass\r\n            | Props props ->\r\n                result.AddProps props\r\n            | Modifiers modifiers ->\r\n                result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"column\")\r\n            .ToReactElement(div, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\nopen Browser.Types\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Input =\r\n\r\n    module Classes =\r\n        let [<Literal>] Container = \"input\"\r\n        module State =\r\n            let [<Literal>] IsFocused = \"is-focused\"\r\n            let [<Literal>] IsActive = \"is-active\"\r\n            let [<Literal>] IsHovered = \"is-hovered\"\r\n            let [<Literal>] IsLoading = \"is-loading\"\r\n            let [<Literal>] IsStatic = \"is-static\"\r\n        module Styles =\r\n            let [<Literal>] IsRounded = \"is-rounded\"\r\n        module Size =\r\n            let [<Literal>] IsSmall = \"is-small\"\r\n            let [<Literal>] IsMedium = \"is-medium\"\r\n            let [<Literal>] IsLarge = \"is-large\"\r\n            let [<Literal>] IsFullwidth = \"is-fullwidth\"\r\n            let [<Literal>] IsInline = \"is-inline\"\r\n\r\n    type IInputType =\r\n        | Text\r\n        | Password\r\n        | DatetimeLocal\r\n        | Date\r\n        | Month\r\n        | Time\r\n        | Week\r\n        | Number\r\n        | Email\r\n        | Url\r\n        | Search\r\n        | Tel\r\n        | ColorType\r\n\r\n    type Option =\r\n        | Size of ISize\r\n        /// Set `Type` HTMLAttr\r\n        /// Don't use if you used one of the helpers like: `Input.password`\r\n        | Type of IInputType\r\n        | Color of IColor\r\n        /// Set `Id` HTMLAttr\r\n        | Id of string\r\n        /// Add `disabled` HTMLAttr if true\r\n        | Disabled of bool\r\n        /// Set `IsReadOnly` HTMLAttr\r\n        | IsReadOnly of bool\r\n        /// Add `is-static` class if true\r\n        | [<CompiledName(\"is-static\")>] IsStatic of bool\r\n        /// Add `is-rounded` class\r\n        | [<CompiledName(\"is-rounded\")>] IsRounded\r\n        /// Set `Value` HTMLAttr\r\n        | Value of string\r\n        | Key of string\r\n        /// Set `DefaultValue` HTMLAttr\r\n        | DefaultValue of string\r\n        /// `Ref` callback that sets the value of an input textbox after DOM element is created.\r\n        | ValueOrDefault of string\r\n        /// Set `Placeholder` HTMLAttr\r\n        | Placeholder of string\r\n        | OnChange of (Event -> unit)\r\n        | Ref of (Element->unit)\r\n        | Props of IHTMLProp list\r\n        | CustomClass of string\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    let private ofType (typ : IInputType) =\r\n        match typ with\r\n        | Text -> \"text\"\r\n        | Password -> \"password\"\r\n        | DatetimeLocal -> \"datetime-local\"\r\n        | Date -> \"date\"\r\n        | Month -> \"month\"\r\n        | Time -> \"time\"\r\n        | Week -> \"week\"\r\n        | Number -> \"number\"\r\n        | Email -> \"email\"\r\n        | Url -> \"url\"\r\n        | Search -> \"search\"\r\n        | Tel -> \"tel\"\r\n        | IInputType.ColorType -> \"color\"\r\n\r\n    open Fable.Core.JsInterop\r\n\r\n    /// Generate <input class=\"input\" />\r\n    let input (options : Option list) =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | IsStatic state -> if state then result.AddCaseName option else result\r\n            | IsRounded -> result.AddCaseName option\r\n            | Size size -> ofSize size |> result.AddClass\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | Type type' -> Props.Type (ofType type') |> result.AddProp\r\n            | Id id -> Props.Id id |> result.AddProp\r\n            | Disabled disabled -> Props.Disabled disabled |> result.AddProp\r\n            | IsReadOnly state -> Props.ReadOnly state |> result.AddProp\r\n            | Value value -> Props.Value value |> result.AddProp\r\n            | DefaultValue defaultValue -> Props.DefaultValue defaultValue |> result.AddProp\r\n            | ValueOrDefault valueOrDefault ->\r\n                Props.Ref <| (fun e ->\r\n                    if e |> isNull |> not\r\n                        && !!e?value <> valueOrDefault then\r\n                        e?value <- valueOrDefault\r\n                ) |> result.AddProp\r\n            | Placeholder placeholder -> Props.Placeholder placeholder |> result.AddProp\r\n            | OnChange cb -> Props.OnChange cb |> result.AddProp\r\n            | Ref ref -> Props.Ref ref |> result.AddProp\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n            | Key k -> Props.Prop.Key k |> result.AddProp\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"input\").ToReactElement(input)\r\n\r\n    /// Generate <input type=\"text\" class=\"input\" />\r\n    let inline text options = input (Type Text :: options)\r\n    /// Generate <input type=\"password\" class=\"input\" />\r\n    let inline password options = input (Type Password :: options)\r\n    /// Generate <input type=\"datetime-local\" class=\"input\" />\r\n    let inline datetimeLocal options = input (Type DatetimeLocal :: options)\r\n    /// Generate <input type=\"date\" class=\"input\" />\r\n    let inline date options = input (Type Date :: options)\r\n    /// Generate <input type=\"month\" class=\"input\" />\r\n    let inline month options = input (Type Month :: options)\r\n    /// Generate <input type=\"time\" class=\"input\" />\r\n    let inline time options = input (Type Time :: options)\r\n    /// Generate <input type=\"week\" class=\"input\" />\r\n    let inline week options = input (Type Week :: options)\r\n    /// Generate <input type=\"number\" class=\"input\" />\r\n    let inline number options = input (Type Number :: options)\r\n    /// Generate <input type=\"email\" class=\"input\" />\r\n    let inline email options = input (Type Email :: options)\r\n    /// Generate <input type=\"url\" class=\"input\" />\r\n    let inline url options = input (Type Url :: options)\r\n    /// Generate <input type=\"search\" class=\"input\" />\r\n    let inline search options = input (Type Search :: options)\r\n    /// Generate <input type=\"tel\" class=\"input\" />\r\n    let inline tel options = input (Type Tel :: options)\r\n    /// Generate <input type=\"color\" class=\"input\" />\r\n    let inline color options = input (Type IInputType.ColorType :: options)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule File =\r\n\r\n    type Option =\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Size of ISize\r\n        /// Add `is-focused` class if true\r\n        | [<CompiledName(\"is-focused\")>]IsFocused of bool\r\n        /// Add `is-active` class if true\r\n        | [<CompiledName(\"is-active\")>]IsActive of bool\r\n        /// Add `is-hovered` class if true\r\n        | [<CompiledName(\"is-hovered\")>]IsHovered of bool\r\n        /// Add `is-fullwidth` class\r\n        | [<CompiledName(\"is-fullwidth\")>]IsFullWidth\r\n        /// Add `is-centered` class\r\n        | [<CompiledName(\"is-centered\")>]IsCentered\r\n        /// Add `is-right` class\r\n        | [<CompiledName(\"is-right\")>]IsRight\r\n        /// Add `is-boxed` class\r\n        | [<CompiledName(\"is-boxed\")>]IsBoxed\r\n        /// Add `has-name` class\r\n        | [<CompiledName(\"has-name\")>]HasName\r\n        /// Add `is-empty` class if true\r\n        | [<CompiledName(\"is-empty\")>]IsEmpty of bool\r\n        | Color of IColor\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"file\"></div>\r\n    let file (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Size size -> ofSize size |> result.AddClass\r\n            | IsFullWidth\r\n            | IsCentered\r\n            | IsRight\r\n            | IsBoxed\r\n            | HasName -> result.AddCaseName option\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | IsFocused state\r\n            | IsActive state\r\n            | IsHovered state\r\n            | IsEmpty state -> if state then result.AddCaseName option else result\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"file\").ToReactElement(div, children)\r\n\r\n    /// Generate <input type=\"file\" class=\"file-input\"/>\r\n    let input (options : GenericOption list) =\r\n        GenericOptions.Parse(options, parseOptions, \"file-input\", [Type \"file\" :> IHTMLProp]).ToReactElement(input)\r\n\r\n    /// Generate <span class=\"file-cta\"></span>\r\n    let cta (options : GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"file-cta\").ToReactElement(span, children)\r\n\r\n    /// Generate <span class=\"file-name\"></span>\r\n    let name (options : GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"file-name\").ToReactElement(span, children)\r\n\r\n    /// Generate <span class=\"file-icon\"></span>\r\n    let icon (options : GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"file-icon\").ToReactElement(span, children)\r\n\r\n    module Label =\r\n\r\n        /// Generate <span class=\"file-label\"></span>\r\n        let span (options : GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"file-label\").ToReactElement(span, children)\r\n\r\n        /// Generate <label class=\"file-label\"></label>\r\n        let label (options : GenericOption list) children =\r\n            GenericOptions.Parse(options, parseOptions, \"file-label\").ToReactElement(label, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Label =\r\n\r\n    type Option =\r\n        | Size of ISize\r\n        /// Set `For` HTMLAttr\r\n        | For of string\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <label class=\"label\"></label>\r\n    let label options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Size size -> ofSize size |> result.AddClass\r\n            | For htmlFor -> HtmlFor htmlFor |> result.AddProp\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"label\").ToReactElement(label, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Field =\r\n\r\n    type Option =\r\n        /// Add `has-addons` class\r\n        | [<CompiledName(\"has-addons\")>] HasAddons\r\n        /// Add `has-addons-centered` class\r\n        | [<CompiledName(\"has-addons-centered\")>] HasAddonsCentered\r\n        /// Add `has-addons-right` class\r\n        | [<CompiledName(\"has-addons-right\")>] HasAddonsRight\r\n        /// Add `has-addons-fullwidth` class\r\n        | [<CompiledName(\"has-addons-fullwidth\")>] HasAddonsFullWidth\r\n        /// Add `is-grouped` class\r\n        | [<CompiledName(\"is-grouped\")>] IsGrouped\r\n        /// Add `is-grouped-centered` class\r\n        | [<CompiledName(\"is-grouped-centered\")>] IsGroupedCentered\r\n        /// Add `is-grouped-right` class\r\n        | [<CompiledName(\"is-grouped-right\")>] IsGroupedRight\r\n        /// Add `is-grouped-multiline` class\r\n        | [<CompiledName(\"is-grouped-multiline\")>] IsGroupedMultiline\r\n        /// Add `is-horizontal` class\r\n        | [<CompiledName(\"is-horizontal\")>] IsHorizontal\r\n        /// Add `is-expanded` class\r\n        | [<CompiledName(\"is-expanded\")>] IsExpanded\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    module Label =\r\n\r\n        type Option =\r\n            | Size of ISize\r\n            /// Add `is-normal` class\r\n            | [<CompiledName(\"is-normal\")>] IsNormal\r\n            | CustomClass of string\r\n            | Props of IHTMLProp list\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"field-body\"></div>\r\n    let body (options : GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"field-body\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"field-label\"></div>\r\n    let label options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Label.Size size -> ofSize size |> result.AddClass\r\n            | Label.IsNormal -> result.AddCaseName option\r\n            | Label.Props props -> result.AddProps props\r\n            | Label.CustomClass customClass -> result.AddClass customClass\r\n            | Label.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"field-label\").ToReactElement(div, children)\r\n\r\n    let internal fieldView element options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | HasAddonsCentered -> result.AddClass(\"has-addons\").AddCaseName option\r\n            | HasAddonsRight -> result.AddClass(\"has-addons\").AddCaseName option\r\n            | HasAddonsFullWidth -> result.AddClass(\"has-addons\").AddCaseName option\r\n            | IsGroupedCentered -> result.AddClass(\"is-grouped\").AddCaseName option\r\n            | IsGroupedRight -> result.AddClass(\"is-grouped\").AddCaseName option\r\n            | IsGroupedMultiline -> result.AddClass(\"is-grouped\").AddCaseName option\r\n            | HasAddons\r\n            | IsGrouped\r\n            | IsHorizontal\r\n            | IsExpanded -> result.AddCaseName option\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"field\").ToReactElement(element, children)\r\n\r\n    /// Generate <div class=\"field\"></div>\r\n    let div x y = fieldView div x y\r\n    /// Generate <p class=\"field\"></p>\r\n    let p x y = fieldView p x y\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Control =\r\n\r\n    type Option =\r\n        /// Add `has-icons-right` class\r\n        | [<CompiledName(\"has-icons-right\")>] HasIconRight\r\n        /// Add `has-icons-left` class\r\n        | [<CompiledName(\"has-icons-left\")>] HasIconLeft\r\n        /// Add `is-loading` class if true\r\n        | [<CompiledName(\"is-loading\")>] IsLoading of bool\r\n        /// Add `is-expanded` class\r\n        | [<CompiledName(\"is-expanded\")>] IsExpanded\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    let internal controlView element options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | HasIconRight\r\n            | HasIconLeft\r\n            | IsExpanded -> result.AddCaseName option\r\n            | IsLoading state -> if state then result.AddCaseName option else result\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"control\").ToReactElement(element, children)\r\n\r\n    /// Generate <div class=\"control\"></div>\r\n    let div x y = controlView div x y\r\n    /// Generate <p class=\"control\"></p>\r\n    let p x y = controlView p x y\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Checkbox =\r\n\r\n    /// Generate <label class=\"checkbox\"></label>\r\n    let checkbox (options : GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"checkbox\").ToReactElement(label, children)\r\n\r\n    /// Generate <input type=\"checkbox\" class=\"checkbox\"/>\r\n    let input (options : GenericOption list) =\r\n        GenericOptions.Parse(options, parseOptions, \"checkbox\", [ Type \"checkbox\" :> IHTMLProp ]).ToReactElement(input)\r\n","module GenericViewComponents\r\n\r\nopen Elmish\r\nopen Elmish.React\r\n\r\nopen Fable.React.Props\r\nopen Fable.Core.JsInterop\r\nopen Shared\r\nopen Fulma\r\nopen Fable.FontAwesome\r\nopen Fable.React\r\nopen Browser.Dom\r\nopen Browser.Types\r\n\r\nopen Shared\r\nopen JSInterop\r\nopen FileInputHelper\r\nopen FileInputHelper.React\r\n\r\nopen AppModel\r\nopen StateHandling\r\n\r\nlet block children = div [Class \"block\"] children \r\n\r\nlet navbar (model : Model) (dispatch : Msg -> unit) =\r\n    let currentDisp = model.InformationSectionDisplay\r\n    Navbar.navbar [Navbar.IsFixedTop; Navbar.CustomClass \"is-dark csbNav\"; Navbar.Props [Props.Role \"navigation\"; AriaLabel \"main navigation\" ]] [\r\n        Navbar.Brand.a [] [\r\n            Navbar.Item.a [Navbar.Item.Props [Props.Href \"https://csb.bio.uni-kl.de/\"]] [\r\n                img [Props.Src \"../Images/Logo.png\"]\r\n            ]\r\n            Navbar.burger   [   Navbar.Burger.IsActive model.BurgerVisible\r\n                                Navbar.Burger.Props [\r\n                                    Props.Role \"button\"\r\n                                    AriaLabel \"menu\"\r\n                                    Props.AriaExpanded false\r\n                                    OnClick (fun e -> ToggleBurger |> dispatch)\r\n                                ]\r\n                            ] [\r\n                span [AriaHidden true] []\r\n                span [AriaHidden true] []\r\n                span [AriaHidden true] []\r\n            ]\r\n        ]\r\n        Navbar.menu [Navbar.Menu.Props [Id \"navbarMenu\"; Class (if model.BurgerVisible then \"navbar-menu is-active\" else \"navbar-menu\") ]] [\r\n            Navbar.Start.div [] [\r\n                Navbar.Item.a\r\n                    [\r\n                        Navbar.Item.Props [OnClick (fun _ -> ChangeHelpDisplay (if currentDisp = HowToUse then NoHelp else HowToUse) |> dispatch)]\r\n                        Navbar.Item.IsActive (currentDisp = HowToUse)\r\n                    ] [\r\n                    str \"How to use\"\r\n                ]\r\n                Navbar.Item.a\r\n                    [\r\n                        Navbar.Item.Props [OnClick (fun _ -> ChangeHelpDisplay (if currentDisp = InputFormat then NoHelp else InputFormat) |> dispatch)]\r\n                        Navbar.Item.IsActive (currentDisp = InputFormat)\r\n                    ] [\r\n                    str \"Input format\"\r\n\r\n                ]\r\n                Navbar.Item.a\r\n                    [\r\n                        Navbar.Item.Props [OnClick (fun _ -> ChangeHelpDisplay (if currentDisp = TechnicalScientificDetails then NoHelp else TechnicalScientificDetails) |> dispatch)]\r\n                        Navbar.Item.IsActive (currentDisp = TechnicalScientificDetails)\r\n                    ] [\r\n                    str \"Technical details\"\r\n                ]\r\n            ]\r\n            Navbar.End.div [] [\r\n                Navbar.Item.a\r\n                    [\r\n                        Navbar.Item.Props [OnClick (fun _ -> ChangeHelpDisplay (if currentDisp = Contact then NoHelp else Contact) |> dispatch)]\r\n                        Navbar.Item.IsActive (currentDisp = Contact)\r\n                    ] [\r\n                    str \"Contact\"\r\n                ]\r\n            ]\r\n        ]\r\n    ]\r\n\r\nlet eulaModal (model:Model) (dispatch:Msg -> unit) =\r\n    Modal.modal [Modal.IsActive model.EULAModalVisible] [\r\n        Modal.background [] []\r\n        Modal.content [Props[Style[BackgroundColor \"white\"; Padding \"1em 1em 1em 1em\"; TextAlign TextAlignOptions.Justify; Width \"80%\"]]] [\r\n            Heading.h5 [] [str \"ACADEMIC SOFTWARE LICENSE AGREEMENT FOR END-USERS AT PUBLICLY FUNDED ACADEMIC, EDUCATION OR RESEARCH INSTITUTIONS FOR THE USE OF targetp and iMLP.\"]\r\n            p   [] [str \"\"\"By accepting this License Agreement you are consenting to be bound by and become a party to this agreement as the \"Licensee\". If you do not agree to all of the terms of this agreement, you must not click the Acceptance button, nor use the product, and you do not become a LICENSEE under this agreement.\"\"\"]\r\n            br  []\r\n            p   [] [str \"\"\"If you are not a member of a publicly funded Academic and/or Education and/or Research Institution you must obtain a commercial license. This software license agreement is entered into by and between Technische Universität Kaiserslautern (hereinafter \"LICENSOR\") and the \"LICENSEE\".\"\"\"]\r\n            br  []\r\n            p   [] [str \"\"\"WHEREAS LICENSEE is a public funded Academic and/or Education and/or Research Institution.\"\"\"]\r\n            br  []\r\n            p   [] [str \"\"\"WHEREAS LICENSEE desires to acquire a free non-exclusive license to use the Software for internal research purposes only.\"\"\"]\r\n            br  []\r\n            p   [] [str \"\"\"NOW, THEREFORE, in consideration of the mutual promises and covenants contained herein, the parties agree as follows:\"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"1. Definitions\"]\r\n            p   [] [str \"\"\"\"Licensed Software\" means the specific version targetp and iMLP pursuant to this Agreement. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"2. License\"]\r\n            p   [] [str \"\"\"Subject to the terms and conditions of this Agreement a non-exclusive, non-transferable License to use and copy the Licensed Software is made available free of charge for the LICENSEE which is a non-profit educational, academic and/or research institution. The License is only granted for personal and internal use in research only at one Site, where a Site is defined as a set of contiguous buildings in one location. The software will be used at only one location of LICENSEE. \"\"\"]\r\n            br  []\r\n            p   [] [str \"\"\"This license does not entitle Licensee to receive from LICENSOR copies of the Licensed software on disks, tapes or CD's, hard-copy documentation, technical support, telephone assistance, or enhancements or updates to the Licensed Software. \"\"\"]\r\n            br  []\r\n            p   [] [str \"\"\"The user and any research assistants, co-workers or other workers who may use the Software agree to not give the program to third parties or grant licenses on software, which include the Software, alone or integrated into other software, to third parties. Modification of the source code is prohibited without the prior written consent of LICENSOR. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"3. Ownership \"]\r\n            p   [] [str \"\"\"Except as expressly licensed in this Agreement, LICENSOR shall retain title to the Licensed Software, and any upgrades and modifications created by LICENSOR.\"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"4. Consideration \"]\r\n            p   [] [str \"\"\"In consideration for the license rights granted by LICENSOR, LICENSEE will obtain this academic license free of charge. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"5. Copies\"] \r\n            p   [] [str \"\"\" LICENSEE shall have the right to make copies of the Licensed Software for internal use at the Site and for back-up purposes under this Agreement, but agrees that all such copies shall contain the copyright notices and all other reasonable and appropriate proprietary markings or confidential legends that appear on the Licensed Software provided hereunder.\"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"6. Support\"] \r\n            p   [] [ str \"\"\"LICENSOR shall have no obligation to offer support services to LICENSEE, and nothing contained herein shall be interpreted as to require LICENSOR to provide maintenance, installation services, version updates, debugging, consultation or end-user support of any kind. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"7. Software Protection\"] \r\n            p   [] [ str \"\"\"LICENSEE acknowledges that the Licensed Software is proprietary The software code shall be treated as trade secrets and confidential information of LICENSOR, and LICENSEE agrees to use best efforts to hold the same in confidence. LICENSEE's obligation for confidentiality shall not extend to any information which is or becomes generally available to the public, is already known to or subsequently disclosed by third parties to LICENSEE and at its free disposal, or is independently developed by LICENSEE or its affiliates without the use of the confidential information disclosed by LICENSOR, or is required by law or legal process. \"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"Except as other wise expressly permitted in this Agreement, Licensee my not (i) modify or create any derivative works of the Licensed Software or documentation, including customization, translation or localization; (ii) decompile, disassemble, reverse engineer, or otherwise attempt to derive the source code for the Product; (iii) redistribute, encumber, sell, rent, lease, sublicense, or otherwise transfer rights to the Licensed Software; (iv) remove or alter any trademark, logo, copyright or other proprietary notices, legends, symbols or labels in the Product; or (v) publish any results of benchmark tests run on the Product to a third party without LICENSOR's prior written consent. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"8. Representations of LICENSOR to LICENSEE\"] \r\n            p   [] [ str \"\"\" LICENSOR represents to LICENSEE that (i) LICENSOR has the right to grant the License and to enter into this agreement, (ii) that, to the best of LICENSOR's knowledge, the Licensed software does not infringe any patent, copyright or trade secrets of any third party, provided however that such representation and warranty shall not apply to any addition to, or modifications or adaptation of, the Licensed Software made by LICENSEE and (iii) LICENSOR undertakes to use best efforts to cooperate with and assist LICENSEE, at LICENSEE's expense, in defending itself against any action based on the alleged infringement of any third party patent, copyright or trade secret rights resulting from or relating to the use or licensing of the Licensed Software by LICENSEE. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"9. Indemnity and Disclaimer of Warranties\"] \r\n            p   [] [ str \"\"\"Except as expressly set forth in this agreement, LICENSOR makes no representations or warranties, express or implied. \"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"The product is provided free of charge, and, therefore, on an \"as is\" basis, without warranty of any kind, express or implied, including without limitation the warranties that it is free of defects, virus free, able to operate on an uninterrupted basis, merchantable, fit for a particular purpose or non-interfering. The entire risk as to the quality and performance of the Licensed Software is borne by LICENSEE.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"By way of example, but not limitation, LICENSOR makes no representations or warranties of merchantability or fitness for any particular application or, except as set forth in paragraph 8, that the use of the Software will not infringe any patents, copyrights or trademarks or other rights of third parties. The entire risk as to the quality and performance of the product is borne by LICENSEE. LICENSOR shall not be liable for any liability or damages with respect to any claim by LICENSEE or any third party on account of, or arising from the license or use of the Software.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"Should the Licensed Software prove defective in any respect, LICENSEE and not LICENSOR or its affiliates should assume the entire cost of any service and repair. This disclaimer of warranty constitutes an essential part of this agreement. No use of the licensed product is authorized hereunder except under this disclaimer.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"In no event will LICENSOR or its affiliates be liable for any indirect, special, incidental or consequential damages arising out of the use of or inability to use the product, including, without limitation, damages for lost profits, loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses, even if advised of the possibility thereof, and regardless of the legal or equitable theory (contract, tort or otherwise) upon which the claim is based. \"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"10. Promotional Advertising & References\"]\r\n            p   [] [ str \"\"\"LICENSEE may not use the name of the Licensed Software in its promotional advertising, product literature, and other similar promotional materials to be disseminated to the public or any portion thereof. LICENSEE agrees not to identify LICENSOR in any promotional advertising or other promotional materials to be disseminated to the public, or any portion thereof without LICENSOR's prior written consent.\"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"11. Term \"]\r\n            p   [] [ str \"\"\"This Agreement and the license rights granted herein shall become effective as of the date this Agreement is executed by both parties and shall be perpetual unless terminated in accordance with this Section.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"LICENSOR may terminate this Agreement at any time.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"Either party may terminate this Agreement at any time effective upon the other party's breach of any agreement, covenant, or representation made in this Agreement, such breach remaining uncorrected sixty (60) days after written notice thereof.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"LICENSEE shall have the right, at any time, to terminate this Agreement without cause by written notice to LICENSOR specifying the date of termination.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"Upon termination, LICENSEE shall destroy all full and partial copies of the Licensed Software.\"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"12. Governing Law\"] \r\n            p   [] [ str \"\"\"This Agreement shall be construed in accordance with the laws of Germany.\"\"\"]\r\n            br  []\r\n            Heading.h6 [] [str \"13. General\"]\r\n            p   [] [ str \"\"\"The parties agree that this Agreement is the complete and exclusive agreement among the parties and supersedes all proposals and prior agreements whether written or oral, and all other communications among the parties relating to the subject matter of this Agreement. This Agreement cannot be modified except in writing and signed by both parties. Failure by either party at any time to enforce any of the provisions of this Agreement shall not constitute a waiver by such party of such provision nor in any way affect the validity of this Agreement.]\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"The invalidity of singular provisions does not affect the validity of the entire understanding. The parties are obligated, however, to replace the invalid provisions by a regulation which comes closest to the economic intent of the invalid provision. The same shall apply mutatis mutandis in case of a gap.\"\"\"]\r\n            br  []\r\n            p   [] [ str \"\"\"IN WITNESS WHEREOF, the LICENSEE hereto have caused this Agreement to be duly executed on the date of accepting the license conditions by pressing the Acceptance button.\"\"\" ]\r\n        ]\r\n        Modal.close [Modal.Close.OnClick (fun _ -> ShowEulaModal false |> dispatch)] [str \"close\"]\r\n    ]\r\n\r\nlet createDropdown dropdownBtnText id children =\r\n    Dropdown.dropdown [] [\r\n        div [Class \"dropdown-trigger\"] [\r\n            Button.button [Button.Props [AriaHasPopup true; AriaControls id]] [\r\n                span [] [str dropdownBtnText]\r\n                Icon.icon [] [Fa.i [Fa.Solid.AngleDown] []]\r\n            ]\r\n        ]\r\n        Dropdown.menu [Props [Id id ; Role \"menu\"]] [\r\n            Dropdown.content [] [\r\n                yield! children\r\n            ]   \r\n        ]\r\n    ]\r\n\r\n\r\nlet getDisplayHelpText (model:Model) (dispatch:Msg->unit) =\r\n    \r\n    match model.InformationSectionDisplay with\r\n    |NoHelp         -> []\r\n    |TechnicalScientificDetails ->\r\n        [\r\n            block [ Heading.h4 [] [str \"Scientific Details - our research about iMTS-L prediction:\" ; Icon.icon [Icon.Props [OnClick (fun _ -> ChangeHelpDisplay NoHelp |> dispatch); Style [Color \"red\"; Float FloatOptions.Right; Cursor (box \"pointer\")]]] [Fa.i [Fa.Solid.Times] []]]]\r\n            block [\r\n                ul [] [\r\n                    li [] [str \"Backes, S. et al. (2018) Tom70 enhances mitochondrial preprotein import efficiency by binding to internal targeting sequences. J. Cell Biol., 2018: 10.1083/jcb.201708044.\"]\r\n                    li [] [str \"Boos, F. et al. (2018) Detection of Internal Matrix Targeting Signal-like Sequences (iMTS-Ls) in Mitochondrial Precursor Proteins Using the TargetP Prediction Tool. BIO-PROTOCOL, 8, 2018: 10.21769/BioProtoc.2474.\"]\r\n                ]\r\n            ]\r\n            Heading.h4 [] [str \"Technical Details   \"]\r\n            block [ str \"iMLP is based on the long short-term memory (LSTM) recurrent neural network architecture. These architectures are specially designed for feature detection in sequences and therefore well suited for the recognition of iMTS-Ls. The network is built and consumed using\"; a [Href \"https://docs.microsoft.com/en-us/cognitive-toolkit/\"] [str \" CNTK.\"]]\r\n        ]\r\n    |Contact        ->\r\n        [\r\n            block [ Heading.h4 [] [str \"Contact   \"; Icon.icon [Icon.Props [OnClick (fun _ -> ChangeHelpDisplay NoHelp |> dispatch); Style [Color \"red\"; Float FloatOptions.Right; Cursor (box \"pointer\")]]] [Fa.i [Fa.Solid.Times] []]]]\r\n            block [\r\n                ul [] [\r\n                    li [] [a[Props.Href \"mailto:muehlhaus@bio.uni-kl.de\"] [str \"Timo Mühlhaus\"] ; str \", Computational Systems Biology Kaiserslautern\"]\r\n                    li [] [a[Props.Href \"mailto:schneike@rhrk.uni-kl.de\"] [str \"Kevin Schneider\"] ; str \", Computational Systems Biology Kaiserslautern\"]\r\n                ]\r\n            ]\r\n        ]\r\n    |HowToUse       ->\r\n        [\r\n            block [ Heading.h4 [] [str \"How To Use   \"; Icon.icon [Icon.Props [OnClick (fun _ -> ChangeHelpDisplay NoHelp |> dispatch); Style [Color \"red\"; Float FloatOptions.Right; Cursor (box \"pointer\")]]] [Fa.i [Fa.Solid.Times] []]]]\r\n            ul [] [\r\n                li [Class \"block\"] [\r\n                    block [Heading.h6 [Heading.IsSubtitle] [str \"General\"]]\r\n                    block [str \"The general workflow supported by this website contains these steps:\"]\r\n                    block [\r\n                        ol [] [\r\n                            li [Class \"block\"] [str \"Provide input peptide sequences either as text or as fasta file\"]\r\n                            li [Class \"block\"] [str \"Select the model closest to your organism of interest (plant or non-plant). Please note that the plant model is highly experimental.\"]\r\n                            li [Class \"block\"] [str \"Run the iMTS-L propensity profile prediction\"] \r\n                            li [Class \"block\"] [str \"Results are provided on the webpage and can be downloaded\"] \r\n                        ]\r\n                    ]\r\n                ]\r\n                block [\r\n                    li [Class \"block\"] [\r\n                        block [ Heading.h6 [Heading.IsSubtitle] [str \"Input\"]]\r\n                        block [ a [OnClick (fun _ -> ChangeHelpDisplay (InputFormat) |> dispatch)] [str \"Learn more about the input format here\"]]\r\n                        block [\r\n                            strong [] [str \"for batch computations with more than 1000 sequences, please \"]\r\n                            a [OnClick (fun _ -> ChangeHelpDisplay (Contact) |> dispatch)] [str \"contact us\"]\r\n                            strong [] [str \" or use the \"]\r\n                            a [Href \"https://github.com/CSBiology/iMLP/releases/\"] [str \"standalone tool\"]\r\n                        ]\r\n                        block [ str \"Provide input either via entering a single protein sequence in the textbox or by oploading a file pressing the file link below the textbox.\"]\r\n                        block [ str \"When provided a single sequence via the textbox, a single iMTS-L prediction report will pop in the Result section once the prediction is finished.\"]\r\n                        block [ str \"When provided a file with multiple sequences, iMTS-L prediction results will be generated one after another. You can view the results in the Result section as they are generated, meaning the amount of tabs in the Result section will increase over time while the predictions are finished. You can observe the progress on a per-sequence basis via the progress bar.\"]\r\n                    ]\r\n                ]\r\n                block [\r\n                    li [Class \"block\"] [\r\n                        Heading.h6 [Heading.IsSubtitle] [\r\n                            str \"Output - Plots\"\r\n                        ]\r\n                        block [str \"Output of the webpage is twofold: \"]\r\n                        block [\r\n                            ol [] [\r\n                                li [Class \"block\"] [\r\n                                    block [ str \"static iMTS-L propensity score heatmap over the protein sequence\"]\r\n                                ]\r\n                                li [Class \"block\"] [\r\n                                    block [str \"Interactive iMTS-L propensity score profile area plot\"]\r\n                                    block [str \"iMTS-L propensity scores above zero indicate iMTS-L stretches. In yeast current studies suggests a length of 12 – 20 amino acids that might vary between species, but further studies are needed to provide solid statistics about the stretch length.\"]\r\n                                    block [str \"These generated plots are fully interactive, meaning you can zoom, pinch, etc.\"]\r\n                                    block [str \"If you like these plots, you can download them by hovering over them and selecting the \\\"Download plot\\\" button (the camera image) \"]\r\n                                ]\r\n                            ]\r\n                        ]\r\n                    ]\r\n                ]\r\n                block [\r\n                    li [Class \"block\"] [\r\n                        block [Heading.h6 [Heading.IsSubtitle] [str \"Output - Download tab separated results\"]]\r\n                        block [str \"A download link for your results in tab separated form can be generated using the button on the bottom of the results section.\"]\r\n                        block [str \"Format:\"]\r\n                        block [pre [] [str \"\\\"Header\\\"\\t\\\"Sequence\\\"\\t\\\"iMTS-L_Propensity_Scores\\\"\\\"\\n\\\"FirstHeader\\\"\\t\\\"A  ...  K\\\"\\t\\\"0.425000; ... ; 0.056000\\\"\\n...     \\t...     \\t...     \\n\\\"LastHeader\\\"\\t\\\"M  ...  F\\\"\\t\\\"1.905452; ... ; -2.100000\\\"\"]]\r\n                        block [str \"Once you generated the link, press on the download button to start the download.\"]\r\n                    ]\r\n                ]\r\n            ]\r\n        ]\r\n    |InputFormat    ->\r\n        [\r\n            br []\r\n            Heading.h4 [] [str \"Input format help   \"; Icon.icon [Icon.Props [OnClick (fun _ -> ChangeHelpDisplay NoHelp |> dispatch); Style [Color \"red\"; Float FloatOptions.Right; Cursor (box \"pointer\")]]] [Fa.i [Fa.Solid.Times] []]]\r\n            br []\r\n            str \"The input for both single sequence or file mode has to be in fasta conform format. As this prediction algorithm predicts iMTS-L propensity of proteins, only protein sequences will produce valid output.\"\r\n            br []\r\n            str \"Fasta conform means:\"\r\n            ul [] [\r\n                li [] [str \"each protein sequence is headed by a single line identifying header, started by the '>' character. In the case of a single sequence input the header can be omitted.\"]\r\n                li [] [str \"The sequence starts in the next line and only consist of valid amino acid characters (ACDEFGHIKLMNPQRSTUVWY)\"]\r\n                li [] [str \"Ambiguity characters (XZB) are okay\"]\r\n                li [] [str \"Gap and terminator characters (- and *), as well as O(Pyrrolysine) and J(XLE - XleLeucine or Isoleucine) are filtered out by us. Just keep this in mind when you look at your profiles.\"]\r\n                li [] [str \"All other characters not mentioned above can lead to invalid output.\"]\r\n            ]\r\n        ]\r\nlet displayHelpModal (model:Model) (dispatch:Msg->unit) =\r\n    Modal.modal [Modal.IsActive (not (model.InformationSectionDisplay = NoHelp))] [\r\n        Modal.background [] []\r\n        Modal.content [Props[Style[Width \"80%\"; BackgroundColor \"white\"; Padding \"1em 1em 1em 1em\"; TextAlign TextAlignOptions.Justify]]] [\r\n            Container.container [] [\r\n                Content.content [] (getDisplayHelpText model dispatch)\r\n            ]\r\n        ]\r\n        Modal.close [Modal.Close.OnClick (fun _ -> ChangeHelpDisplay NoHelp |> dispatch)] [str \"close\"]\r\n    ]\r\n\r\n\r\nlet downloadBtn (location:string) (model:Model) (dispatch: Msg -> unit)=\r\n    Columns.columns[] [\r\n        Column.column [Column.Width (Screen.Desktop, Column.Is2)] [\r\n            str \"Enter filename:\"\r\n        ]\r\n        Column.column [Column.Width (Screen.Desktop, Column.Is8)] [\r\n            Input.text [\r\n                        Input.Props []\r\n                        Input.Placeholder model.DownloadFileName\r\n                        Input.OnChange (fun e ->    let dname = !!e.target?value\r\n                                                    DownloadFileNameChange dname |> dispatch)\r\n                        ] \r\n        ]\r\n        Column.column [Column.Width (Screen.Desktop, Column.Is2)] [\r\n            a[\r\n                Props.Download (  if ( model.DownloadFileName.EndsWith(\".txt\")) then\r\n                                        model.DownloadFileName\r\n                                    else \r\n                                        sprintf \"%s.txt\" model.DownloadFileName\r\n                                        )\r\n                Props.Href location\r\n                Props.Class \"is-primary is-full-width\"\r\n                ] [\r\n                Icon.icon [] [Fa.i [Fa.Solid.Download] []]\r\n                str \"Click to download\"\r\n            ]\r\n        ]\r\n    ]\r\n\r\nlet downloadView (model:Model) (dispatch: Msg -> unit) =\r\n    if model.DownloadReady then\r\n        downloadBtn (sprintf \"./CsvResults/%s.txt\" (model.SessionGuid.ToString())) model dispatch\r\n    else\r\n        Button.button [\r\n                    Button.IsLoading model.HasJobRunning\r\n                    Button.Props [Props.Id \"prepareDownload\"]\r\n                    Button.CustomClass \"is-success\" \r\n                    Button.IsFullWidth\r\n                    Button.OnClick (fun _ -> PrepareDownloadCSV |> dispatch)] [\r\n            str \"Prepare Results as tab separated file for download\"\r\n        ]\r\n\r\n\r\nlet modeSelection (model : Model) (dispatch : Msg -> unit) =\r\n    match model.SeqMode with\r\n    | Single | NotSelected ->\r\n        Textarea.textarea [\r\n            Textarea.Size Size.IsMedium\r\n            \r\n            Textarea.Placeholder \"insert a single amino acid sequence in FASTA format (with or without header)\"\r\n            Textarea.OnChange (fun e ->\r\n                let sequence = !!e.target?value\r\n                SingleSequenceInput sequence |> dispatch)\r\n            ] []\r\n    | _ ->\r\n        File.file [File.IsBoxed;File.IsFullWidth;File.HasName] [\r\n            File.Label.label [] [\r\n                singleFileInput [\r\n                    Props.Hidden true\r\n                    OnTextReceived(fun x -> FastaUploadInput (x.Data,x.Name) |> dispatch)\r\n                    ] \r\n                File.cta [Props [Class \"file-cta fastaFileUploadBtn\"]] [\r\n                    Heading.h4 [] [str \"Click to choose a file\"]\r\n                    Icon.icon [] [Fa.i [Fa.Solid.Upload] []]\r\n                ]\r\n                File.name [] [str model.FastaFileInputName]\r\n            ]\r\n        ]\r\n\r\n\r\nlet inputSelection (model : Model) (dispatch : Msg -> unit) =\r\n    let isValidState,buttonMsg = Model.validateInputState model\r\n\r\n    let leftHeader,leftAlternative =\r\n        match model.SeqMode with \r\n        | Single | NotSelected -> \"Or upload a \", \"file\"\r\n        | _ -> \"Or insert a single amino acid \", \"sequence\"\r\n\r\n    \r\n    div [] [\r\n        Columns.columns [Columns.CustomClass \"ProcessDecision\"] [\r\n            Column.column [Column.Width (Screen.Desktop, Column.Is7);Column.CustomClass \"leftSelector\"] [\r\n                Columns.columns [] [\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is3)] []\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is9)] [\r\n                        yield br []\r\n                        yield Heading.h3 [] [str \"Input\"]\r\n                        yield hr []\r\n                        if (not model.HasValidFasta) then\r\n                            yield p [Class \"is-danger\"] [str \"Your fasta contained invalid characters:\"]\r\n                            yield p [Class \"is-danger\"] [str (sprintf \"%A\" model.InvalidFastaChars)   ]\r\n                            yield Button.button [Button.CustomClass \"is-danger\";Button.OnClick (fun _ -> Reset |> dispatch)] [str \"Click to reset Input\"]\r\n                        yield modeSelection model dispatch\r\n                        yield br []\r\n                        yield\r\n                            Heading.h5 [Heading.IsSubtitle]\r\n                                [\r\n                                    str leftHeader\r\n                                    a [ Class \"leftAlternative\"\r\n                                        Props.OnClick\r\n                                            (fun _ ->\r\n                                                match model.SeqMode with \r\n                                                | Single | NotSelected -> SeqModeSelection File |> dispatch\r\n                                                | _ -> SeqModeSelection Single |> dispatch\r\n                                            )] [\r\n                                        str leftAlternative\r\n                                    ]\r\n                                ]\r\n                        yield br []\r\n                    ]\r\n                ]\r\n            ]\r\n            Column.column [Column.Width (Screen.Desktop, Column.Is5);Column.CustomClass \"rightSelector\"] [\r\n                Columns.columns [] [\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is8)] [\r\n                        br []\r\n                        Heading.h3 [] [str \"Start Prediction\"]\r\n                        hr []\r\n                        \r\n                        Button.button [\r\n                            (if isValidState then\r\n                                Button.Disabled false \r\n                            else \r\n                                Button.Disabled true)\r\n\r\n                            (if isValidState then\r\n                                Button.CustomClass \"is-success\"\r\n                            else \r\n                                Button.CustomClass \"is-danger\" )\r\n\r\n                            Button.IsLoading model.HasJobRunning \r\n                            Button.IsFullWidth\r\n                            Button.CustomClass \"startBtn\"\r\n                            Button.OnClick (fun e ->\r\n                                match model.SeqMode with\r\n                                | Single    -> SingleSequenceRequest model.SelectedComputationMode |> dispatch\r\n                                | File      -> FastaUploadRequest model.SelectedComputationMode |> dispatch\r\n                                | _ -> ())\r\n                        ] [str buttonMsg ]\r\n                        br []\r\n                        Label.label [Label.Size IsMedium; Label.Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"]]] [str \"select iMLP Model:\"]\r\n                        Field.div [Field.IsGrouped] [\r\n                            let isNonPlant = model.SelectedOrganismModel = OrganismModel.NonPlant\r\n                            Control.div [Control.Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"]]] [\r\n\r\n                                Checkbox.checkbox [Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"] ]] [\r\n                                    Checkbox.input [Props [OnClick (fun _ -> OrganismModelSelection OrganismModel.NonPlant |> dispatch); Checked isNonPlant]]\r\n                                    b [] [ str \"NonPlant\"]\r\n                                ]\r\n                            ]\r\n                            Control.div [Control.Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"]]] [\r\n                                Checkbox.checkbox [Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"]]] [\r\n                                    Checkbox.input [Props[OnClick (fun _ -> OrganismModelSelection OrganismModel.Plant |> dispatch); Checked (not isNonPlant)]]\r\n                                    b [] [ str \"Plant\"]\r\n                                ]\r\n                            ]\r\n                        ]\r\n                        //Control.div [Control.Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"]]] [\r\n                        //    Checkbox.checkbox [Props [Style[CSSProp.Color \"rgb(237, 125, 49)\"]]] [\r\n                        //        Checkbox.input [Props[OnClick (fun _ -> EULAAcceptedChange |> dispatch)]]\r\n                        //        b [] [ str\" Use legacy computation model\"]\r\n                        //    ]\r\n                        //    div [Class \"block\"] [\r\n                        //        str \"in order to use the targetP-based legacy model you have to agree to iMLP's \"\r\n                        //        a [ OnClick (fun _ -> ShowEulaModal true |> dispatch)\r\n                        //            Style [Color \"white\";]] [\r\n                        //            str \"end user license agreement (EULA)\"\r\n                        //    ]\r\n                        //    ]\r\n                        //]\r\n                    ]\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is4)] []\r\n                ]\r\n                \r\n            ]\r\n        ]\r\n    ]\r\n\r\n\r\nlet hero (model : Model) (dispatch : Msg -> unit) =\r\n    Hero.hero [Hero.IsMedium; Hero.CustomClass \"csbHero\"] [\r\n        Hero.body [] [\r\n            Container.container [] [\r\n                Heading.h1 [Heading.IsSpaced] [\r\n                    str \"iMLP : iMTS-L predictor service\"\r\n                ]\r\n                br []\r\n                Heading.h4 [Heading.IsSubtitle;Heading.IsSpaced] [\r\n                    str \"Additional to their N-terminal matrix-targeting signals (MTSs), many preproteins contain additional internal MTS-like signals (iMTS-Ls) in their mature region which improve the import competence of preproteins and increases the efficiency of their translocation into the mitochondrial matrix.\"\r\n                    br []\r\n                    br []\r\n                    str \"This tool allows the prediction of iMTS-Ls for proteins of interest.\"\r\n                    br []\r\n                    br []\r\n                    str\"For more scientific background, take a look at the \"\r\n                    a [\r\n                        OnClick (fun _ -> ChangeHelpDisplay TechnicalScientificDetails |> dispatch)\r\n                        Style [\r\n                            TextDecoration \"none\"\r\n                            Color \"white\"\r\n                        ]\r\n                        ] [\r\n                            str \"'Details'\"\r\n                    ]\r\n                    str \" section.\" \r\n                    ]\r\n            ]\r\n        ]\r\n    ]\r\n\r\nlet errorModal (showStackTrace:bool) (model : Model) (dispatch : Msg -> unit) =\r\n    let msg,stackTrace =\r\n        match model.ErrorState with\r\n        | Some ex  -> match ex with\r\n                      | :? Fable.Remoting.Client.ProxyRequestException as fe -> fe.Message, fe.ResponseText\r\n                      | _ -> ex.Message,ex.StackTrace\r\n        | None      -> \"Unexpected Error\",\"App failed without Exception message\"\r\n\r\n    Modal.modal [Modal.IsActive model.HasError] [\r\n        Modal.background [] []\r\n        Modal.content [Props[Style[Width \"80%\"; BackgroundColor \"salmon\"; Padding \"1em 1em 1em 1em\"; TextAlign TextAlignOptions.Justify]]] [\r\n            Container.container [] [\r\n                Content.content [] [\r\n                    Heading.h2 [] [str \"An error occured. Click the button below to reset the app state:\"]\r\n                    div [Class \"block\"] [ Heading.h5 [] [str msg]]\r\n                    Button.button [Button.CustomClass \"is-info resetBtn\";Button.OnClick (fun _ -> Reset |> dispatch)] [str \"RESET APP STATE\"]\r\n                    br []\r\n                    br []\r\n                    Heading.h3 [] [str \"If you are a developer and/or interested in the stack trace you can see the error message below.\"]\r\n                    br []\r\n                    Button.button [Button.Color IsInfo; Button.OnClick (fun _ -> ChangeErrorStateVisibility |> dispatch)] [str \"toggle stack trace\"]\r\n                    br []\r\n                    if showStackTrace then Content.content [Content.Props [Hidden (not model.ShowErrorStack)]] [\r\n                        div [Class \"block\"] [ Heading.h5 [] [str \"StackTrace:\"]]\r\n                        pre [Class \"block is-white\"] (\r\n                                stackTrace.Split([|\" at \"|],System.StringSplitOptions.None)\r\n                                |> Array.map (fun blck ->\r\n                                    p [Class \"block\"] [str blck]\r\n                                )\r\n                        )\r\n                    ]\r\n                ]\r\n            ]\r\n        ]\r\n        Modal.close [Modal.Close.OnClick (fun _ -> Reset |> dispatch)] [str \"close\"]\r\n    ]\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\nopen Browser.Types\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Textarea =\r\n\r\n    type Option =\r\n        | Size of ISize\r\n        /// Add `is-fullwidth` class\r\n        | [<CompiledName(\"is-fullwidth\")>] IsFullWidth\r\n        /// Add `is-inline` class\r\n        | [<CompiledName(\"is-inline\")>] IsInline\r\n        /// Add `is-loading` class if true\r\n        | [<CompiledName(\"is-loading\")>] IsLoading of bool\r\n        /// Add `is-focused` class\r\n        | [<CompiledName(\"is-focused\")>] IsFocused of bool\r\n        /// Add `is-active` class if true\r\n        | [<CompiledName(\"is-active\")>] IsActive of bool\r\n        /// Add `IsReadOnly` HTMLAttr\r\n        | IsReadOnly of bool\r\n        | Color of IColor\r\n        | Id of string\r\n        /// Add `disabled` HTMLAttr if true\r\n        | Disabled of bool\r\n        /// Set `Value` HTMLAttr\r\n        | Value of string\r\n        /// Set `DefaultValue` HTMLAttr\r\n        | DefaultValue of string\r\n        /// `Ref` callback that sets the value of an input textbox after DOM element is created.\r\n        | ValueOrDefault of string\r\n        /// Set `Placeholder` HTMLAttr\r\n        | Placeholder of string\r\n        | Props of IHTMLProp list\r\n        | OnChange of (Event -> unit)\r\n        | Ref of (Element->unit)\r\n        | CustomClass of string\r\n        /// Add `has-fixed-size` class\r\n        | [<CompiledName(\"has-fixed-size\")>] HasFixedSize\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    open Fable.Core.JsInterop\r\n\r\n    /// Generate <textarea class=\"textarea\"></textarea>\r\n    let textarea options children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Size size -> ofSize size |> result.AddClass\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | IsFullWidth\r\n            | HasFixedSize\r\n            | IsInline -> result.AddCaseName option\r\n            | IsLoading state\r\n            | IsFocused state\r\n            | IsActive state -> if state then result.AddCaseName option else result\r\n            | Id id -> Props.Id id |> result.AddProp\r\n            | Disabled disabled -> Props.Disabled disabled |> result.AddProp\r\n            | IsReadOnly state -> Props.ReadOnly state |> result.AddProp\r\n            | Value value -> Props.Value value |> result.AddProp\r\n            | DefaultValue defaultValue -> Props.DefaultValue defaultValue |> result.AddProp\r\n            | ValueOrDefault valueOrDefault ->\r\n                Props.Ref <| (fun e ->\r\n                    if e |> isNull |> not\r\n                        && !!e?value <> valueOrDefault then\r\n                        e?value <- valueOrDefault\r\n                ) |> result.AddProp\r\n            | Placeholder placeholder -> Props.Placeholder placeholder |> result.AddProp\r\n            | OnChange cb -> Props.OnChange cb |> result.AddProp\r\n            | Ref ref -> Props.Ref ref |> result.AddProp\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"textarea\").ToReactElement(textarea, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Hero =\r\n\r\n    type Option =\r\n        /// Add `is-bold` class\r\n        | [<CompiledName(\"is-bold\")>] IsBold\r\n        /// Add `is-medium` class\r\n        | [<CompiledName(\"is-medium\")>] IsMedium\r\n        /// Add `is-large` class\r\n        | [<CompiledName(\"is-large\")>] IsLarge\r\n        /// Add `is-halfheight` class\r\n        | [<CompiledName(\"is-halfheight\")>] IsHalfHeight\r\n        /// Add `is-fullheight-with-navbar` class\r\n        | [<CompiledName(\"is-fullheight-with-navbar\")>] IsFullheightWithNavbar\r\n        /// Add `is-fullheight` class\r\n        | [<CompiledName(\"is-fullheight\")>] IsFullHeight\r\n        | Color of IColor\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"hero\"></div>\r\n    let hero (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | IsMedium\r\n            | IsLarge\r\n            | IsHalfHeight\r\n            | IsFullHeight\r\n            | IsFullheightWithNavbar\r\n            | IsBold -> result.AddCaseName option\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"hero\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"hero-head\"></div>\r\n    let head (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"hero-head\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"hero-body\"></div>\r\n    let body (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"hero-body\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"hero-foot\"></div>\r\n    let foot (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"hero-foot\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"hero-video\"></div>\r\n    let video (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"hero-video\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"hero-buttons\"></div>\r\n    let buttons (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"hero-buttons\").ToReactElement(div, children)\r\n","import { compare } from \"./Util.js\";\r\nimport { unfold, delay } from \"./Seq.js\";\r\nimport { op_Addition, fromZero } from \"./BigInt.js\";\r\nimport { op_Addition as op_Addition_1, fromParts } from \"./Decimal.js\";\r\nimport { op_Addition as op_Addition_2, fromBits } from \"./Long.js\";\r\n\r\nexport function makeRangeStepFunction(step, stop, zero, add) {\r\n    const stepComparedWithZero = compare(step, zero) | 0;\r\n    if (stepComparedWithZero === 0) {\r\n        throw (new Error(\"The step of a range cannot be zero\"));\r\n    }\r\n    const stepGreaterThanZero = stepComparedWithZero > 0;\r\n    return (x) => {\r\n        const comparedWithLast = compare(x, stop) | 0;\r\n        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : ((!stepGreaterThanZero) && (comparedWithLast >= 0))) ? [x, add(x, step)] : (void 0);\r\n    };\r\n}\r\n\r\nexport function integralRangeStep(start, step, stop, zero, add) {\r\n    const stepFn = makeRangeStepFunction(step, stop, zero, add);\r\n    return delay(() => unfold(stepFn, start));\r\n}\r\n\r\nexport function rangeBigInt(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromZero(), op_Addition);\r\n}\r\n\r\nexport function rangeDecimal(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition_1);\r\n}\r\n\r\nexport function rangeDouble(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));\r\n}\r\n\r\nexport function rangeInt64(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromBits(0, 0, false), op_Addition_2);\r\n}\r\n\r\nexport function rangeUInt64(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromBits(0, 0, true), op_Addition_2);\r\n}\r\n\r\nexport function rangeChar(start, stop) {\r\n    const intStop = stop.charCodeAt(0) | 0;\r\n    return delay(() => unfold((c) => {\r\n        if (c <= intStop) {\r\n            return [String.fromCharCode(c), c + 1];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, start.charCodeAt(0)));\r\n}\r\n\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Level =\r\n\r\n    module Level =\r\n\r\n        type Option =\r\n            | Props of IHTMLProp list\r\n            /// Add `is-mobile` class\r\n            | [<CompiledName(\"is-mobile\")>] IsMobile\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    module Item =\r\n\r\n        type Option =\r\n            | Props of IHTMLProp list\r\n            /// Add `has-text-centered` class\r\n            | [<CompiledName(\"has-text-centered\")>] HasTextCentered\r\n            | CustomClass of string\r\n            | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <nav class=\"level\"></nav>\r\n    let level (options : Level.Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Level.Option.IsMobile -> result.AddCaseName option\r\n            | Level.Props props -> result.AddProps props\r\n            | Level.CustomClass customClass -> result.AddClass customClass\r\n            | Level.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"level\").ToReactElement(nav, children)\r\n\r\n    /// Generate <div class=\"level-left\"></div>\r\n    let left (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"level-left\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"level-right\"></div>\r\n    let right (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"level-right\").ToReactElement(div, children)\r\n\r\n    /// Generate <div class=\"level-item\"></div>\r\n    let item (options : Item.Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Item.HasTextCentered -> result.AddCaseName option\r\n            | Item.Props props -> result.AddProps props\r\n            | Item.CustomClass customClass -> result.AddClass customClass\r\n            | Item.Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"level-item\").ToReactElement(div, children)\r\n\r\n    /// Generate <p class=\"heading\"></p>\r\n    let heading (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"heading\").ToReactElement(p, children)\r\n\r\n    /// Generate <p class=\"title\"></p>\r\n    let title (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"title\").ToReactElement(p, children)\r\n","import { toList, toArray, map, filter, delay } from \"./Seq.js\";\r\nimport { HashSet } from \"./MutableSet.js\";\r\nimport { addToDict, getItemFromDict, tryGetValue, addToSet } from \"./MapUtil.js\";\r\nimport { Dictionary } from \"./MutableMap.js\";\r\nimport { disposeSafe, getEnumerator } from \"./Util.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\n\r\nexport function distinct(xs, comparer) {\r\n    return delay(() => {\r\n        const hashSet = new HashSet([], comparer);\r\n        return filter((x) => addToSet(x, hashSet), xs);\r\n    });\r\n}\r\n\r\nexport function distinctBy(projection, xs, comparer) {\r\n    return delay(() => {\r\n        const hashSet = new HashSet([], comparer);\r\n        return filter((x) => addToSet(projection(x), hashSet), xs);\r\n    });\r\n}\r\n\r\nexport function except(itemsToExclude, xs, comparer) {\r\n    return delay(() => {\r\n        const hashSet = new HashSet(itemsToExclude, comparer);\r\n        return filter((x) => addToSet(x, hashSet), xs);\r\n    });\r\n}\r\n\r\nexport function countBy(projection, xs, comparer) {\r\n    return delay(() => {\r\n        const dict = new Dictionary([], comparer);\r\n        const keys = [];\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const key = projection(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                let matchValue;\r\n                let outArg = 0;\r\n                matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {\r\n                    outArg = (v | 0);\r\n                })), outArg];\r\n                if (matchValue[0]) {\r\n                    dict.set(key, matchValue[1] + 1);\r\n                }\r\n                else {\r\n                    dict.set(key, 1);\r\n                    void (keys.push(key));\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n        return map((key_1) => [key_1, getItemFromDict(dict, key_1)], keys);\r\n    });\r\n}\r\n\r\nexport function groupBy(projection, xs, comparer) {\r\n    return delay(() => {\r\n        const dict = new Dictionary([], comparer);\r\n        const keys = [];\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                const key = projection(x);\r\n                let matchValue;\r\n                let outArg = null;\r\n                matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {\r\n                    outArg = v;\r\n                })), outArg];\r\n                if (matchValue[0]) {\r\n                    void (matchValue[1].push(x));\r\n                }\r\n                else {\r\n                    addToDict(dict, key, [x]);\r\n                    void (keys.push(key));\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n        return map((key_1) => [key_1, getItemFromDict(dict, key_1)], keys);\r\n    });\r\n}\r\n\r\nexport function Array_distinct(xs, comparer) {\r\n    return toArray(distinct(xs, comparer));\r\n}\r\n\r\nexport function Array_distinctBy(projection, xs, comparer) {\r\n    return toArray(distinctBy(projection, xs, comparer));\r\n}\r\n\r\nexport function Array_except(itemsToExclude, xs, comparer) {\r\n    return toArray(except(itemsToExclude, xs, comparer));\r\n}\r\n\r\nexport function Array_countBy(projection, xs, comparer) {\r\n    return toArray(countBy(projection, xs, comparer));\r\n}\r\n\r\nexport function Array_groupBy(projection, xs, comparer) {\r\n    return toArray(map((tupledArg) => [tupledArg[0], toArray(tupledArg[1])], groupBy(projection, xs, comparer)));\r\n}\r\n\r\nexport function List_distinct(xs, comparer) {\r\n    return toList(distinct(xs, comparer));\r\n}\r\n\r\nexport function List_distinctBy(projection, xs, comparer) {\r\n    return toList(distinctBy(projection, xs, comparer));\r\n}\r\n\r\nexport function List_except(itemsToExclude, xs, comparer) {\r\n    return toList(except(itemsToExclude, xs, comparer));\r\n}\r\n\r\nexport function List_countBy(projection, xs, comparer) {\r\n    return toList(countBy(projection, xs, comparer));\r\n}\r\n\r\nexport function List_groupBy(projection, xs, comparer) {\r\n    return toList(map((tupledArg) => [tupledArg[0], toList(tupledArg[1])], groupBy(projection, xs, comparer)));\r\n}\r\n\r\n","namespace Feliz.Plotly\n\nmodule Bindings =\n    open Browser.Types\n    open Fable.Core\n    open Fable.Core.JsInterop\n    open Fable.React\n\n    type Plotly =\n        abstract downloadImage: U2<#HTMLElement,string> * obj -> unit\n        abstract toImage: U2<#HTMLElement,string> * obj -> JS.Promise<string>\n        abstract register: obj -> unit\n\n    let plotly: Plotly = importAll \"plotly.js/dist/plotly\"\n    let plotFactory: Plotly -> obj = importDefault \"react-plotly.js/factory.js\"\n    let plotComponent = plotFactory plotly\n    let createPlot props: ReactElement = \n        ReactBindings.React.createElement (plotComponent, props, [])\n    \n    let getKV value : string * obj = unbox value\n\n    let extractTraces (properties: #ITracesProperty list) =\n        properties \n        |> List.map (getKV >> snd) \n        |> ResizeArray \n        |> Interop.mkPlotAttr \"data\"\n                    \n    let convertTracesToTemplate (traces: ITracesProperty list) =\n        traces\n        |> List.map (unbox<string * obj> >> (fun (name, props) -> name, Array.singleton props))\n    \n    let inline optToString (value: 'T Option) =\n        match value with\n        | Some v -> string v\n        | _ -> \"None\"        \n","module PlotComponent\r\n\r\nopen Elmish\r\nopen Elmish.React\r\n\r\nopen Fable.React.Props\r\nopen Fable.Core.JsInterop\r\nopen Shared\r\nopen Fulma\r\n//open Fulma.FontAwesome\r\nopen Fable.React\r\nopen Browser.Dom\r\nopen Browser.Types\r\n\r\nopen Shared\r\nopen JSInterop\r\nopen AppModel\r\nopen StateHandling\r\n\r\nopen Feliz\r\nopen Feliz.Plotly\r\n\r\nlet plotIMLPResult (res: IMLPResult) =\r\n    div [Style [MinHeight 600]] [\r\n        Plotly.plot [\r\n            plot.traces [\r\n                traces.scatter [\r\n                    scatter.x [ 1 .. res.Sequence.Length]\r\n                    scatter.y res.PropensityScores\r\n                    scatter.mode.lines\r\n                    scatter.line [\r\n                        line.color \"rgb(237, 125, 49, 0.9)\";\r\n                        line.width 2.5;\r\n                        line.shape.spline\r\n                    ]\r\n                    scatter.fill.tozeroy\r\n                    scatter.name \"Propensity Score\"\r\n                ]\r\n            ]\r\n            plot.layout [\r\n                layout.paperBgcolor \"rgba(0,0,0,0)\"\r\n                layout.plotBgcolor \"white\"\r\n                layout.font [font.family \"Arial\"; font.size 18]\r\n                layout.legend [\r\n                    legend.x 0.02\r\n                    legend.y 0.98\r\n                    legend.traceorder.normal\r\n                    legend.bgcolor \"rgba(222, 235, 247, 0.6)\"\r\n                    legend.bordercolor \"rgb(68, 84, 106)\"\r\n                    legend.borderwidth 2\r\n                ]\r\n                layout.xaxis [\r\n                    xaxis.title \"Score\"\r\n                    xaxis.showgrid false\r\n                    xaxis.showline true\r\n                    xaxis.mirror.allticks\r\n                    xaxis.zeroline true\r\n                    xaxis.tickmode.auto\r\n                    xaxis.ticks.inside\r\n                    xaxis.tickfont [tickfont.family \"Arial\"; tickfont.size 18]\r\n                ]\r\n                layout.yaxis [\r\n                    yaxis.title \"Index of AminoAcid\"\r\n                    yaxis.showgrid false\r\n                    yaxis.showline true\r\n                    yaxis.mirror.allticks\r\n                    yaxis.zeroline true\r\n                    yaxis.tickmode.auto\r\n                    yaxis.ticks.inside\r\n                    yaxis.tickfont [tickfont.family \"Arial\"; tickfont.size 18]\r\n                ]\r\n            ]\r\n            plot.config [\r\n                config.responsive true\r\n                config.toImageButtonOptions [toImageButtonOptions.format.svg \"iMLP_propensity_plot.svg\"]\r\n            ]\r\n        ]\r\n    ]","module ResultViews\r\n\r\nopen Elmish\r\nopen Elmish.React\r\n\r\nopen Fable.React.Props\r\nopen Fable.Core.JsInterop\r\nopen Shared\r\nopen Fulma\r\n//open Fulma.FontAwesome\r\nopen Fable.React\r\nopen Browser.Dom\r\nopen Browser.Types\r\n\r\nopen Shared\r\nopen JSInterop\r\nopen AppModel\r\nopen StateHandling\r\n\r\nopen GenericViewComponents\r\n\r\nmodule ViewComponents = \r\n\r\n    let pageinateFromIndex (index:int) (model:Model) (dispatch:Msg->unit)  =\r\n        let ofClass () = \r\n            if index = model.CurrentResultViewIndex then \r\n                Props.Class\"pagination-link is-current\"\r\n            else \r\n                Props.Class \"pagination-link\"\r\n        li [\r\n            ofClass ()\r\n            Props.OnClick (fun _ -> ShowPlot (index) |> dispatch)\r\n        ] [\r\n            span [] [str (string (index+1))]\r\n        ]\r\n\r\n    let pageinateDynamic (pos: int) (model:Model) (dispatch:Msg->unit) = \r\n        let resultLenght = Model.getMultiResultLength model\r\n        let indices =\r\n            [0 .. resultLenght-1]\r\n        let numbers =\r\n            let x = indices.[(max 1 (pos-2)) .. (min (pos+2) (resultLenght-2)) ]\r\n            x\r\n            |> List.map (fun index -> pageinateFromIndex index model dispatch) \r\n        numbers\r\n\r\n\r\n    let progressView (model : Model)  (dispatch: Msg -> unit)  =\r\n        let progr = (float model.FileProcessIndex / float model.FastaFileInput.Length)\r\n        div [] [\r\n            if model.HasJobRunning then \r\n                yield str (if progr < 1. then sprintf \"Progress: %i/%i Proteins\" model.FileProcessIndex model.FastaFileInput.Length else \"Done.\")\r\n                yield progress [Class \"progress is-link is-large\"; Props.Value progr] [str (sprintf \"%.2f%s\" (float model.FileProcessIndex / float model.FastaFileInput.Length) \"%\")]\r\n        ]\r\n\r\n    let resultBar (model : Model) (dispatch : Msg -> unit) =\r\n        let index = model.CurrentResultViewIndex\r\n        let hasMultiResult = Model.hasMultiResult model\r\n        div\r\n            [\r\n                yield Props.Class \"resultBar\"\r\n                if (not (model.SeqMode = File && hasMultiResult)) then\r\n                    yield Props.Style [Props.Display DisplayOptions.None]\r\n            ] [\r\n                Columns.columns [] [\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is7);Column.CustomClass \"leftResultBar\"] [\r\n                        Heading.h3 [] [str \"Navigate through results:\"]\r\n                    ]\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is7);Column.CustomClass \"rightResultBar\"] [\r\n                        if model.SeqMode = File && hasMultiResult then\r\n                            yield\r\n                                nav [Class \"pagination is-left\"; Role \"navigation\"; AriaLabel \"pagination\"] [\r\n                                    ul [Class \"pagination-list\"] [\r\n                                        let len = Model.getMultiResultLength model\r\n                                        yield pageinateFromIndex 0 model dispatch\r\n                                        if len >5 then yield li [Class \"pagination-ellipsis\"] [span [] [str \"…\"]]\r\n                                        yield! pageinateDynamic index model dispatch\r\n                                        if len >5 then yield li [Class \"pagination-ellipsis\"] [span [] [str \"…\"]]\r\n                                        yield pageinateFromIndex (len-1) model dispatch\r\n                                    ]\r\n                                ]\r\n                    ]\r\n                ]\r\n        ]\r\n\r\n    let resultHeading (model:Model) (dispatch: Msg -> unit) =\r\n        let index = model.CurrentResultViewIndex\r\n        let hasMultiResult = Model.hasMultiResult model\r\n        let hasSingleResult = Model.hasMultiResult model\r\n        Columns.columns\r\n            [\r\n                if model.ResultHeadingIsSticky then\r\n                    yield Columns.CustomClass \"ResultHeadingSticky\"\r\n                else\r\n                    yield Columns.CustomClass \"ResultHeadingNonSticky\"\r\n                yield\r\n                    Columns.Props\r\n                        [\r\n                            yield Id \"ResultHeading\"\r\n                            match model.SeqMode with\r\n                            |File   when hasMultiResult -> ()\r\n                            |Single when hasSingleResult-> ()\r\n                            | _ -> yield Props.Style [Props.Display DisplayOptions.None]\r\n                        ]\r\n\r\n            ] [\r\n            Column.column [Column.Width (Screen.Desktop, Column.Is7);Column.CustomClass \"leftResultHeading\"] [\r\n                Columns.columns [] [\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is3)] []\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is9)] [\r\n                        br []\r\n                        Heading.h3 [] [str \"Results\"]\r\n                        hr []\r\n                    ]\r\n                ]\r\n            ]\r\n            Column.column [Column.Width (Screen.Desktop, Column.Is5);Column.CustomClass \"rightResultHeading\"] [\r\n                Columns.columns [] [\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is8)] [\r\n                        yield br []\r\n                        if model.SeqMode = File && hasMultiResult then\r\n                            yield\r\n                                nav [Class \"pagination is-left\"; Role \"navigation\"; AriaLabel \"pagination\"] [\r\n                                    ul [Class \"pagination-list\"] [\r\n                                        let len = Model.getMultiResultLength model\r\n                                        yield pageinateFromIndex 0 model dispatch\r\n                                        if len >5 then yield li [Class \"pagination-ellipsis\"] [span [] [str \"…\"]]\r\n                                        yield! pageinateDynamic index model dispatch\r\n                                        if len >5 then yield li [Class \"pagination-ellipsis\"] [span [] [str \"…\"]]\r\n                                        yield pageinateFromIndex (len-1) model dispatch\r\n                                    ]\r\n                                ]\r\n                        else\r\n                            yield Heading.h3 [] [br[]]\r\n                        yield hr []\r\n                        if model.SeqMode = File then\r\n                            yield progressView model dispatch\r\n                    ]\r\n                    Column.column [Column.Width (Screen.Desktop, Column.Is4)] [\r\n                    ]\r\n                ]\r\n\r\n            ]\r\n        ]\r\n\r\n    let plotModeSwitch (model : Model) (dispatch: Msg -> unit) =\r\n        Level.level [] [\r\n            Level.left [] [\r\n                Button.button [\r\n                    yield Button.IsFullWidth\r\n                    if model.PlotMode = Propensity then\r\n                        yield Button.CustomClass \"plotModeBtnActive\"\r\n                    else\r\n                        yield Button.CustomClass \"plotModeBtnInactive\"\r\n                    yield Button.OnClick (fun _ -> ChangePlotMode Propensity |> dispatch)\r\n                ] [\r\n                    str \"Plot iMTS-L propensity\"\r\n                ]\r\n                Button.button [\r\n                    yield Button.IsFullWidth\r\n                    if model.PlotMode = TargetPScore then\r\n                        yield Button.CustomClass \"plotModeBtnActive\"\r\n                    else\r\n                        yield Button.CustomClass \"plotModeBtnInactive\"\r\n                    yield Button.OnClick (fun _ -> ChangePlotMode TargetPScore |> dispatch)\r\n                ] [\r\n                    str \"Plot raw TargetP score\"\r\n                ]\r\n            ]\r\n            Level.right [] [\r\n            ]\r\n        ]\r\n\r\n    \r\n    let fastaFormatDisplay (model:Model) (sequence:char array) (scores: float array) =\r\n        let scores' =\r\n            if model.PlotMode = Propensity then\r\n                scores\r\n                |> fun x ->\r\n                    let minVal = Array.min x\r\n                    x\r\n                    |> Array.map (fun x -> x + (abs minVal))\r\n            else\r\n                scores\r\n        let maxVal = Array.max scores'\r\n        \r\n        let norm = \r\n            scores'\r\n            |> Array.map (fun s -> s/maxVal)\r\n            |> fun x ->\r\n                //console.log(sprintf \"score length: %i\" x.Length)\r\n                //console.log(sprintf \"sequence length: %i\" sequence.Length)\r\n                //console.log(sequence)\r\n                x |> Array.map2 (fun char score -> int ((score) * 100.) ,char) sequence\r\n        let spans =\r\n            norm \r\n            |> Array.mapi\r\n                (fun i (score,char) ->\r\n                    span [\r\n                        Props.Style [\r\n                            yield CSSProp.BackgroundColor (gradientColorTable.[int (round (float score / 10.))])\r\n                            yield CSSProp.Color \"#44546A\"\r\n                            ]] [b [] [str (string char)\r\n                        ]\r\n                    ]\r\n                )\r\n        let formatStrings = \r\n            spans\r\n            |> Array.chunkBySize 60\r\n            |> Array.mapi\r\n                (fun i spans ->\r\n                    let lineIndex = (i * 60 + 1)\r\n                    let indexText =\r\n                        sprintf\r\n                            \"%i%s\"\r\n                            lineIndex\r\n                            ([for x in 1 .. (10 - (string lineIndex).Length) do yield \".\"] |> String.concat \"\")\r\n                    div [] [  \r\n                        yield span [] [ str indexText]; \r\n                        yield! spans \r\n                    ]\r\n                )\r\n        let minLegend = Array.min scores\r\n        let maxLegend = Array.max scores\r\n        Content.content [] [\r\n            yield br []\r\n            yield! formatStrings \r\n            yield br []\r\n            yield\r\n                div[Class \"gradient-legend\"] [str \"\"]\r\n                \r\n            yield\r\n                div [] [\r\n                    span [Style [TextAlign TextAlignOptions.Left]] [ str (sprintf \"%.2f\" minLegend) ]\r\n                    div [Class \"spacer\"] []\r\n                    span [Style [TextAlign TextAlignOptions.Right]] [ str (sprintf \"%.2f\" maxLegend) ]\r\n                ]\r\n        ]\r\n\r\nmodule CompositeViews =\r\n\r\n    let parseStateMessage (p:ParseState) =\r\n        \r\n        let importance = \r\n            match p with\r\n            | Success _ ->\r\n                Notification.Color Color.IsSuccess\r\n            | ContainsGapTerOJ _ | FilteredShortSequence _ | ShortSequence _ ->\r\n                Notification.Color Color.IsWarning\r\n            | InvalidCharacters _ | FilteredEmptySequence | EmptySequence | InternalServerError ->\r\n                Notification.Color Color.IsDanger\r\n\r\n        Notification.notification [importance] [\r\n            match p with\r\n            | Success _ -> str \"Success\"\r\n            | ContainsGapTerOJ sanitized ->\r\n                block [h3 [Class \"title\"] [str \"Warning\" ]]\r\n                block [str \"Input sequence contained Gap,Terminator,Pyrrolysine, and/or J(Xle -Leucine or Isoleucine) characters ('*'/'-'/O/J) and was filtered for them\"]\r\n                block [str \"Sanitized input:\"]\r\n                block [str sanitized]\r\n            | ShortSequence sanitized ->\r\n                block [h3 [Class \"title\"] [str \"Warning\" ]]\r\n                block [str \"Input sequence was short (<=21 amino acids). Sequences of this length may likely not contain iMTS-Ls.\"]\r\n            | FilteredShortSequence sanitized ->\r\n                block [h3 [Class \"title\"] [str \"Warning\" ]]\r\n                block [str \"Input sequence contained Gap,Terminator,Pyrrolysine, and/or J(Xle -Leucine or Isoleucine) characters ('*'/'-'/O/J) and was filtered for them\"]\r\n                block [str \"Sanitized input:\"]\r\n                block [str sanitized]\r\n                block [str \"Additionally this input sequence was short (<=21 amino acids). Sequences of this length may likely not contain iMTS-Ls.\"]\r\n            | InvalidCharacters inv ->\r\n                block [h3 [Class \"title\"] [str \"Error\" ]]\r\n                block [str \"Input sequence contained invalid characters\"]\r\n                block [str \"Invalid Characters:\"]\r\n                block [str (inv |> Array.distinct |> Array.fold (fun acc elem -> sprintf \"%s, %c\" acc elem) \"\")]\r\n            | FilteredEmptySequence ->\r\n                block [h3 [Class \"title\"] [str \"Error\" ]]\r\n                block [str \"Input sequence was empty after filtering illegal characters and/or Gap,Terminator,Pyrrolysine, and/or J(Xle -Leucine or Isoleucine)  ('*'/'-'/O/J)\"]\r\n            | EmptySequence ->\r\n                block [h3 [Class \"title\"] [str \"Error\" ]]\r\n                block [str \"Input sequence was empty\"]\r\n            | InternalServerError ->\r\n                block [h3 [Class \"title\"] [str \"Error\" ]]\r\n                block [str \"Internal server error during prediction of this protein. Please contact us if this error persists.\"]\r\n\r\n        ]\r\n\r\n    module Legacy = \r\n\r\n        let singleResult (model : Model) (dispatch: Msg -> unit) (res: LegacyResult) =\r\n            Columns.columns [Columns.IsCentered] [\r\n                Column.column [Column.Width (Screen.Desktop, Column.Is2)] []\r\n                Column.column [Column.CustomClass \"transparent fastaDisplay\";Column.Width (Screen.Desktop, Column.Is8)] [\r\n                    match res.ParseState with\r\n                    | Success sanitized | ContainsGapTerOJ sanitized | FilteredShortSequence sanitized | ShortSequence sanitized ->\r\n                        br []\r\n                        Heading.h4 [] [str res.Header]\r\n                        ViewComponents.plotModeSwitch model dispatch\r\n                        hr []\r\n                        parseStateMessage res.ParseState\r\n                        Heading.h4 [] [\r\n                            if model.PlotMode = Propensity || model.SelectedComputationMode = ComputationMode.IMLP then\r\n                                yield str \"iMTS-L propensity heatmap:\"\r\n                            else\r\n                                yield str \"Raw TargetP sequence score heatmap:\"\r\n                        ]\r\n                        ViewComponents.fastaFormatDisplay\r\n                            model\r\n                            (sanitized.ToCharArray())\r\n                            (\r\n                                if model.PlotMode = Propensity then\r\n                                    res.PropensityScores\r\n                                else\r\n                                    res.RawTargetPScores\r\n                            )\r\n                        hr []\r\n                        Heading.h4 [] [str (if model.PlotMode = PlotMode.Propensity || model.SelectedComputationMode = ComputationMode.IMLP then \"Predicted iMTS-L propensity profile:\" else \"Predicted raw TargetP scores:\")]\r\n                        iframe [\r\n                            Props.SrcDoc\r\n                                (\r\n                                    if model.PlotMode = Propensity || model.SelectedComputationMode = ComputationMode.IMLP then\r\n                                        res.PropensityPlotHtml.Replace(\"</head>\",\"<style>.js-plotly-plot{width: 50% !important;margin: auto !important;}</style></head>\")\r\n                                    else\r\n                                        res.ScorePlotHtml.Replace(\"</head>\",\"<style>.js-plotly-plot{width: 50% !important;margin: auto !important;}</style></head>\")\r\n                                )\r\n                            Props.Class \"ResultFrame\"\r\n                            Props.Scrolling \"no\"]\r\n                            [\r\n                                p [] [\r\n                                    str \"Your browser does not support the srcDoc attribute of iframes. See https://caniuse.com/#search=iframe for Browser version that support iframes.\"\r\n                                ]\r\n                        ]\r\n                        Heading.h4 [] [str \"Download your results\"]\r\n                        hr[]\r\n                        downloadView model dispatch\r\n                    | InvalidCharacters _ | FilteredEmptySequence | EmptySequence | InternalServerError ->\r\n                        br []\r\n                        Heading.h4 [] [str res.Header]\r\n                        ViewComponents.plotModeSwitch model dispatch\r\n                        hr []\r\n                        parseStateMessage res.ParseState\r\n                ]\r\n                Column.column [Column.Width (Screen.Desktop, Column.Is2)] []\r\n            ]\r\n\r\n        let multipleResults (model : Model) (dispatch: Msg -> unit) (res: LegacyResult array) =\r\n            let index = model.CurrentResultViewIndex\r\n            let sequence = res.[index].Sequence \r\n            let scores = res.[index].RawTargetPScores\r\n            let propensity = res.[index].PropensityScores\r\n            let progr = (float model.FileProcessIndex / float model.FastaFileInput.Length)\r\n            Columns.columns [Columns.IsCentered] [\r\n                Column.column\r\n                    [\r\n                        Column.Width (Screen.Desktop, Column.Is2)\r\n                        Column.Props [OnClick (fun _ -> ChangeViewIndex -1 |> dispatch)]\r\n                        Column.CustomClass \"viewManipulator\"\r\n                    ] [\r\n                        div [Class \"has-text-centered\"] [str \"<\"]\r\n                    ]\r\n                Column.column [Column.CustomClass \"transparent fastaDisplay\";Column.Width (Screen.Desktop, Column.Is8)] [\r\n\r\n                    let currentRes = res.[index]\r\n\r\n                    match currentRes.ParseState with\r\n                    | Success _ | ContainsGapTerOJ _ | FilteredShortSequence _ | ShortSequence _ ->\r\n                        parseStateMessage currentRes.ParseState\r\n                        br []\r\n                        Heading.h4 [] [str res.[index].Header]\r\n                        ViewComponents.plotModeSwitch model dispatch\r\n                        hr []\r\n                        Heading.h4 [] [str \"Sequence score heatmap:\"]\r\n                        ViewComponents.fastaFormatDisplay\r\n                            model\r\n                            (currentRes.Sequence.ToCharArray())\r\n                            (if model.PlotMode = Propensity then currentRes.PropensityScores else currentRes.RawTargetPScores)\r\n                        hr []\r\n                        Heading.h4 [] [str \"Predicted iMTS-L propensity profile:\"]\r\n                        iframe [\r\n                            Props.SrcDoc\r\n                                (\r\n                                    if model.PlotMode = Propensity then\r\n                                        currentRes.PropensityPlotHtml.Replace(\"</head>\",\"<style>.js-plotly-plot{width: 50% !important;margin: auto !important;}</style></head>\")\r\n                                    else\r\n                                        currentRes.ScorePlotHtml.Replace(\"</head>\",\"<style>.js-plotly-plot{width: 50% !important;margin: auto !important;}</style></head>\") \r\n                                )\r\n                            Props.Class \"ResultFrame\"\r\n                            Props.Scrolling \"no\"]\r\n                            [\r\n                                p [] [\r\n                                    str \"Your browser does not support the srcDoc attribute of iframes. See https://caniuse.com/#search=iframe for Browser version that support iframes.\"\r\n                                ]\r\n                        ]\r\n                        Heading.h4 [] [str \"Download your results\"]\r\n                        hr[]\r\n                        downloadView model dispatch\r\n                    | InvalidCharacters _ | FilteredEmptySequence | EmptySequence | InternalServerError ->\r\n                        br []\r\n                        Heading.h4 [] [str currentRes.Header]\r\n                        ViewComponents.plotModeSwitch model dispatch\r\n                        hr []\r\n                        parseStateMessage currentRes.ParseState\r\n                ]\r\n                Column.column\r\n                    [\r\n                        Column.Width (Screen.Desktop, Column.Is2)\r\n                        Column.Props [OnClick (fun _ -> ChangeViewIndex 1 |> dispatch)]\r\n                        Column.CustomClass \"viewManipulator\"\r\n                    ] [\r\n                        div [Class \"has-text-centered\"] [str \">\"]\r\n                    ]\r\n            ]\r\n\r\n    module IMLP = \r\n\r\n        let singleResult (model : Model) (dispatch: Msg -> unit) (res: IMLPResult) =\r\n            Columns.columns [Columns.IsCentered] [\r\n                Column.column [Column.Width (Screen.Desktop, Column.Is2)] []\r\n                Column.column [Column.CustomClass \"transparent fastaDisplay\";Column.Width (Screen.Desktop, Column.Is8)] [\r\n                    match res.ParseState with\r\n                    | Success sanitized | ContainsGapTerOJ sanitized | FilteredShortSequence sanitized | ShortSequence sanitized ->\r\n                        br []\r\n                        Heading.h4 [] [str res.Header]\r\n                        hr []\r\n                        Heading.h4 [] [\r\n                            if model.PlotMode = Propensity || model.SelectedComputationMode = ComputationMode.IMLP then\r\n                                yield str \"iMTS-L propensity heatmap:\"\r\n                            else\r\n                                yield str \"Raw TargetP sequence score heatmap:\"\r\n                        ]\r\n                        ViewComponents.fastaFormatDisplay\r\n                            model\r\n                            (sanitized.ToCharArray())\r\n                            res.PropensityScores\r\n                        hr []\r\n                        Heading.h4 [] [str (if model.PlotMode = PlotMode.Propensity || model.SelectedComputationMode = ComputationMode.IMLP then \"Predicted iMTS-L propensity profile:\" else \"Predicted raw TargetP scores:\")]\r\n                        PlotComponent.plotIMLPResult res\r\n                        //iframe [\r\n                        //    Props.SrcDoc (res.PropensityPlotHtml.Replace(\"</head>\",\"<style>.js-plotly-plot{width: 50% !important;margin: auto !important;}</style></head>\") )\r\n                        //    Props.Class \"ResultFrame\"\r\n                        //    Props.Style [Width 600; Height 600]\r\n                        //    Props.Scrolling \"no\"]\r\n                        //    [\r\n                        //        p [] [\r\n                        //            str \"Your browser does not support the srcDoc attribute of iframes. See https://caniuse.com/#search=iframe for Browser version that support iframes.\"\r\n                        //        ]\r\n                        //]\r\n                        hr []\r\n                        Heading.h4 [] [str \"RunInfo\"]\r\n                        parseStateMessage res.ParseState\r\n                        Heading.h4 [] [str \"Download your results\"]\r\n                        hr []\r\n                        downloadView model dispatch\r\n                    | InvalidCharacters _ | FilteredEmptySequence | EmptySequence | InternalServerError ->\r\n                        br []\r\n                        Heading.h4 [] [str res.Header]\r\n                        hr []\r\n                        Heading.h4 [] [str \"RunInfo\"]\r\n                        parseStateMessage res.ParseState\r\n                ]\r\n                Column.column [Column.Width (Screen.Desktop, Column.Is2)] []\r\n            ]\r\n\r\n        let multipleResults (model : Model) (dispatch: Msg -> unit) (res: IMLPResult array) =\r\n            let index = model.CurrentResultViewIndex\r\n            let sequence = res.[index].Sequence \r\n            let propensity = res.[index].PropensityScores\r\n            let progr = (float model.FileProcessIndex / float model.FastaFileInput.Length)\r\n            Columns.columns [Columns.IsCentered] [\r\n                Column.column\r\n                    [\r\n                        Column.Width (Screen.Desktop, Column.Is2)\r\n                        Column.Props [OnClick (fun _ -> ChangeViewIndex -1 |> dispatch)]\r\n                        Column.CustomClass \"viewManipulator\"\r\n                    ] [\r\n                        div [Class \"has-text-centered\"] [str \"<\"]\r\n                    ]\r\n                Column.column [Column.CustomClass \"transparent fastaDisplay\";Column.Width (Screen.Desktop, Column.Is8)] [\r\n                    let currentRes = res.[index]\r\n                    \r\n                    match currentRes.ParseState with\r\n                    | Success _ | ContainsGapTerOJ _ | FilteredShortSequence _ | ShortSequence _ ->\r\n                        br []\r\n                        Heading.h4 [] [str res.[index].Header]\r\n                        hr []\r\n                        Heading.h4 [] [str \"Sequence score heatmap:\"]\r\n                        ViewComponents.fastaFormatDisplay\r\n                            model\r\n                            (res.[index].Sequence.ToCharArray())\r\n                            res.[index].PropensityScores\r\n                        hr []\r\n                        Heading.h4 [] [str \"Predicted iMTS-L propensity profile:\"]\r\n                        PlotComponent.plotIMLPResult res.[index]\r\n                        //iframe [\r\n                        //    Props.SrcDoc (res.[index].PropensityPlotHtml.Replace(\"</head>\",\"<style>.js-plotly-plot{width: 50% !important;margin: auto !important;}</style></head>\") )\r\n                        //    Props.Class \"ResultFrame\"\r\n                        //    Props.Scrolling \"no\"]\r\n                        //    [\r\n                        //        p [] [\r\n                        //            str \"Your browser does not support the srcDoc attribute of iframes. See https://caniuse.com/#search=iframe for Browser version that support iframes.\"\r\n                        //        ]\r\n                        //]\r\n                        hr []\r\n                        Heading.h4 [] [str \"RunInfo\"]\r\n                        parseStateMessage currentRes.ParseState\r\n                        Heading.h4 [] [str \"Download your results\"]\r\n                        hr []\r\n                        downloadView model dispatch\r\n                    | InvalidCharacters _ | FilteredEmptySequence | EmptySequence | InternalServerError ->\r\n                        br []\r\n                        Heading.h4 [] [str currentRes.Header]\r\n                        hr []\r\n                        Heading.h4 [] [str \"RunInfo\"]\r\n                        parseStateMessage currentRes.ParseState\r\n                ]\r\n                Column.column\r\n                    [\r\n                        Column.Width (Screen.Desktop, Column.Is2)\r\n                        Column.Props [OnClick (fun _ -> ChangeViewIndex 1 |> dispatch)]\r\n                        Column.CustomClass \"viewManipulator\"\r\n                    ] [\r\n                        div [Class \"has-text-centered\"] [str \">\"]\r\n                    ]\r\n            ]\r\n\r\n    let resultSection (model : Model) (dispatch: Msg -> unit) =\r\n        Section.section [\r\n            if model.ShowResults = false then yield Section.Props [Props.Style [Props.Display DisplayOptions.None]] \r\n            yield Section.CustomClass \"resultSection\"\r\n        ] [\r\n            let hasSingleResult, hasMultiResult =\r\n                Model.hasSingleResult model,\r\n                Model.hasMultiResult model\r\n\r\n            match model.SelectedComputationMode with\r\n            | Legacy ->\r\n                if model.SeqMode = Single && hasSingleResult then\r\n                    match model.SingleSequenceResultLegacy with\r\n                    |Some res -> yield Legacy.singleResult model dispatch res\r\n                    |None -> ()\r\n                elif model.SeqMode = File && hasMultiResult then\r\n                    match model.FastaFileInputResultLegacy with\r\n                    |Some res -> yield Legacy.multipleResults model dispatch res\r\n                    |None -> ()\r\n            | IMLP ->\r\n                if model.SeqMode = Single && hasSingleResult then\r\n                    match model.SingleSequenceResultIMLP with\r\n                    |Some res -> yield IMLP.singleResult model dispatch res\r\n                    |None -> ()\r\n                elif model.SeqMode = File && hasMultiResult then\r\n                    match model.FastaFileInputResultIMLP with\r\n                    |Some res -> yield IMLP.multipleResults model dispatch res\r\n                    |None -> ()\r\n        ]\r\n    ","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Notification =\r\n\r\n    type Option =\r\n        | Color of IColor\r\n        /// Add `is-light` class\r\n        | [<CompiledName(\"is-light\")>] IsLight\r\n        | CustomClass of string\r\n        | Props of IHTMLProp list\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <div class=\"notification\"></div>\r\n    let notification (options : Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | Color color -> ofColor color |> result.AddClass\r\n            | IsLight -> result.AddCaseName option\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"notification\").ToReactElement(div, children)\r\n\r\n    /// Generate <button class=\"delete\"></button>\r\n    let delete (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"delete\").ToReactElement(button, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Section =\r\n\r\n    type Option =\r\n        | Props of IHTMLProp list\r\n        | CustomClass of string\r\n        /// Add `is-medium` class\r\n        | [<CompiledName(\"is-medium\")>] IsMedium\r\n        /// Add `is-large` class\r\n        | [<CompiledName(\"is-large\")>] IsLarge\r\n        | Modifiers of Modifier.IModifier list\r\n\r\n    /// Generate <section class=\"section\"></section>\r\n    let section (options: Option list) children =\r\n        let parseOptions (result : GenericOptions) option =\r\n            match option with\r\n            | IsMedium\r\n            | IsLarge -> result.AddCaseName option\r\n            | Props props -> result.AddProps props\r\n            | CustomClass customClass -> result.AddClass customClass\r\n            | Modifiers modifiers -> result.AddModifiers modifiers\r\n\r\n        GenericOptions.Parse(options, parseOptions, \"section\").ToReactElement(section, children)\r\n","namespace Fulma\r\n\r\nopen Fulma\r\nopen Fable.React\r\n\r\n[<RequireQualifiedAccess>]\r\nmodule Footer =\r\n\r\n    /// Generate <footer class=\"footer\"></footer>\r\n    let footer (options: GenericOption list) children =\r\n        GenericOptions.Parse(options, parseOptions, \"footer\").ToReactElement(footer, children)\r\n","import { Observer } from \"./Observable.js\";\nimport { some, value } from \"./Option.js\";\nimport { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from \"./Choice.js\";\nexport class Event {\n    constructor() {\n        this.delegates = [];\n    }\n    Add(f) {\n        this._addHandler(f);\n    }\n    get Publish() {\n        return this;\n    }\n    Trigger(senderOrValue, valueOrUndefined) {\n        let sender;\n        let value;\n        if (valueOrUndefined === undefined) {\n            sender = null;\n            value = senderOrValue;\n        }\n        else {\n            sender = senderOrValue;\n            value = valueOrUndefined;\n        }\n        this.delegates.forEach((f) => f.length === 1 ? f(value) : f(sender, value));\n    }\n    // IDelegateEvent<T> methods\n    AddHandler(handler) {\n        this._addHandler(handler);\n    }\n    RemoveHandler(handler) {\n        this._removeHandler(handler);\n    }\n    // IObservable<T> methods\n    Subscribe(arg) {\n        const callback = typeof arg === \"function\"\n            ? arg\n            : arg.OnNext;\n        this._addHandler(callback);\n        return { Dispose: () => { this._removeHandler(callback); } };\n    }\n    _addHandler(f) {\n        this.delegates.push(f);\n    }\n    _removeHandler(f) {\n        const index = this.delegates.indexOf(f);\n        if (index > -1) {\n            this.delegates.splice(index, 1);\n        }\n    }\n}\nexport function add(callback, sourceEvent) {\n    if (sourceEvent instanceof Event) {\n        sourceEvent.Add(callback);\n    }\n    else {\n        sourceEvent.Subscribe(new Observer(callback));\n    }\n}\nexport function choose(chooser, sourceEvent) {\n    const ev = new Event();\n    add((t) => {\n        const u = chooser(t);\n        if (u != null) {\n            ev.Trigger(value(u));\n        }\n    }, sourceEvent);\n    return ev;\n}\nexport function filter(predicate, sourceEvent) {\n    return choose((x) => predicate(x) ? some(x) : undefined, sourceEvent);\n}\nexport function map(mapping, sourceEvent) {\n    const ev = new Event();\n    add((t) => ev.Trigger(mapping(t)), sourceEvent);\n    return ev;\n}\nexport function merge(event1, event2) {\n    const ev = new Event();\n    const fn = (x) => ev.Trigger(x);\n    add(fn, event1);\n    add(fn, event2);\n    return ev;\n}\nexport function pairwise(sourceEvent) {\n    const ev = new Event();\n    let last;\n    let haveLast = false;\n    add((next) => {\n        if (haveLast) {\n            ev.Trigger([last, next]);\n        }\n        last = next;\n        haveLast = true;\n    }, sourceEvent);\n    return ev;\n}\nexport function partition(predicate, sourceEvent) {\n    return [filter(predicate, sourceEvent), filter((x) => !predicate(x), sourceEvent)];\n}\nexport function scan(collector, state, sourceEvent) {\n    return map((t) => state = collector(state, t), sourceEvent);\n}\nexport function split(splitter, sourceEvent) {\n    return [\n        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), sourceEvent),\n        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), sourceEvent),\n    ];\n}\nexport function createEvent(addHandler, removeHandler) {\n    return {\n        AddHandler(h) { addHandler(h); },\n        RemoveHandler(h) { removeHandler(h); },\n        Subscribe(r) {\n            const h = (_, args) => r.OnNext(args);\n            addHandler(h);\n            return {\n                Dispose() { removeHandler(h); }\n            };\n        }\n    };\n}\nexport default Event;\n","import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from \"./Choice.js\";\nimport { value } from \"./Option.js\";\nexport class Observer {\n    constructor(onNext, onError, onCompleted) {\n        this.OnNext = onNext;\n        this.OnError = onError || ((_e) => { return; });\n        this.OnCompleted = onCompleted || (() => { return; });\n    }\n}\nclass Observable {\n    constructor(subscribe) {\n        this.Subscribe = subscribe;\n    }\n}\nexport function protect(f, succeed, fail) {\n    try {\n        return succeed(f());\n    }\n    catch (e) {\n        fail(e);\n    }\n}\nexport function add(callback, source) {\n    source.Subscribe(new Observer(callback));\n}\nexport function choose(chooser, source) {\n    return new Observable((observer) => source.Subscribe(new Observer((t) => protect(() => chooser(t), (u) => { if (u != null) {\n        observer.OnNext(value(u));\n    } }, observer.OnError), observer.OnError, observer.OnCompleted)));\n}\nexport function filter(predicate, source) {\n    return choose((x) => predicate(x) ? x : null, source);\n}\nexport function map(mapping, source) {\n    return new Observable((observer) => source.Subscribe(new Observer((t) => {\n        protect(() => mapping(t), observer.OnNext, observer.OnError);\n    }, observer.OnError, observer.OnCompleted)));\n}\nexport function merge(source1, source2) {\n    return new Observable((observer) => {\n        let stopped = false;\n        let completed1 = false;\n        let completed2 = false;\n        const h1 = source1.Subscribe(new Observer((v) => { if (!stopped) {\n            observer.OnNext(v);\n        } }, (e) => {\n            if (!stopped) {\n                stopped = true;\n                observer.OnError(e);\n            }\n        }, () => {\n            if (!stopped) {\n                completed1 = true;\n                if (completed2) {\n                    stopped = true;\n                    observer.OnCompleted();\n                }\n            }\n        }));\n        const h2 = source2.Subscribe(new Observer((v) => { if (!stopped) {\n            observer.OnNext(v);\n        } }, (e) => {\n            if (!stopped) {\n                stopped = true;\n                observer.OnError(e);\n            }\n        }, () => {\n            if (!stopped) {\n                completed2 = true;\n                if (completed1) {\n                    stopped = true;\n                    observer.OnCompleted();\n                }\n            }\n        }));\n        return {\n            Dispose() {\n                h1.Dispose();\n                h2.Dispose();\n            },\n        };\n    });\n}\nexport function pairwise(source) {\n    return new Observable((observer) => {\n        let last;\n        return source.Subscribe(new Observer((next) => {\n            if (last != null) {\n                observer.OnNext([last, next]);\n            }\n            last = next;\n        }, observer.OnError, observer.OnCompleted));\n    });\n}\nexport function partition(predicate, source) {\n    return [filter(predicate, source), filter((x) => !predicate(x), source)];\n}\nexport function scan(collector, state, source) {\n    return new Observable((observer) => {\n        return source.Subscribe(new Observer((t) => {\n            protect(() => collector(state, t), (u) => { state = u; observer.OnNext(u); }, observer.OnError);\n        }, observer.OnError, observer.OnCompleted));\n    });\n}\nexport function split(splitter, source) {\n    return [\n        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), source),\n        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), source)\n    ];\n}\nexport function subscribe(callback, source) {\n    return source.Subscribe(new Observer(callback));\n}\n","namespace Elmish\n\n(**\nLog\n---------\nBasic cross-platform logging API.\n\n*)\nmodule internal Log =\n\n#if FABLE_COMPILER\n    open Fable.Core.JS\n\n    let onError (text: string, ex: exn) = console.error (text,ex)\n    let toConsole(text: string, o: #obj) = console.log(text,o)\n\n#else\n#if NETSTANDARD2_0\n    let onError (text: string, ex: exn) = System.Diagnostics.Trace.TraceError(\"{0}: {1}\", text, ex)\n    let toConsole(text: string, o: #obj) = printfn \"%s: %A\" text o\n#else\n    let onError (text: string, ex: exn) = System.Console.Error.WriteLine(\"{0}: {1}\", text, ex)\n    let toConsole(text: string, o: #obj) = printfn \"%s: %A\" text o\n#endif\n#endif\n\n#if FABLE_COMPILER\nmodule internal Timer =\n    open System.Timers\n    let delay interval callback =\n        let t = new Timer(float interval, AutoReset = false)\n        t.Elapsed.Add callback\n        t.Enabled <- true\n        t.Start()\n#endif\n","import Event from \"./Event.js\";\nexport class Timer {\n    constructor(interval) {\n        this._enabled = false;\n        this._isDisposed = false;\n        this._intervalId = 0;\n        this._timeoutId = 0;\n        this.Interval = interval && interval > 0 ? interval : 100;\n        this.AutoReset = true;\n        this._elapsed = new Event();\n    }\n    Elapsed() {\n        return this._elapsed;\n    }\n    get Enabled() {\n        return this._enabled;\n    }\n    set Enabled(x) {\n        if (!this._isDisposed && this._enabled !== x) {\n            this._enabled = x;\n            if (this._enabled) {\n                if (this.AutoReset) {\n                    this._intervalId = setInterval(() => {\n                        if (!this.AutoReset) {\n                            this.Enabled = false;\n                        }\n                        this._elapsed.Trigger(new Date());\n                    }, this.Interval);\n                }\n                else {\n                    this._timeoutId = setTimeout(() => {\n                        this.Enabled = false;\n                        this._timeoutId = 0;\n                        if (this.AutoReset) {\n                            this.Enabled = true;\n                        }\n                        this._elapsed.Trigger(new Date());\n                    }, this.Interval);\n                }\n            }\n            else {\n                if (this._timeoutId) {\n                    clearTimeout(this._timeoutId);\n                    this._timeoutId = 0;\n                }\n                if (this._intervalId) {\n                    clearInterval(this._intervalId);\n                    this._intervalId = 0;\n                }\n            }\n        }\n    }\n    Dispose() {\n        this.Enabled = false;\n        this._isDisposed = true;\n    }\n    Close() {\n        this.Dispose();\n    }\n    Start() {\n        this.Enabled = true;\n    }\n    Stop() {\n        this.Enabled = false;\n    }\n}\nexport default Timer;\n","(**\nCmd\n---------\nCore abstractions for dispatching messages in Elmish.\n\n*)\n\nnamespace Elmish\n\nopen System\n\n/// Dispatch - feed new message into the processing loop\ntype Dispatch<'msg> = 'msg -> unit\n\n/// Subscription - return immediately, but may schedule dispatch of a message at any time\ntype Sub<'msg> = Dispatch<'msg> -> unit\n\n/// Cmd - container for subscriptions that may produce messages\ntype Cmd<'msg> = Sub<'msg> list\n\n/// Cmd module for creating and manipulating commands\n[<RequireQualifiedAccess>]\nmodule Cmd =\n    /// Execute the commands using the supplied dispatcher\n    let internal exec onError (dispatch: Dispatch<'msg>) (cmd: Cmd<'msg>) =\n        cmd |> List.iter (fun call -> try call dispatch with ex -> onError ex)\n\n    /// None - no commands, also known as `[]`\n    let none : Cmd<'msg> =\n        []\n\n    /// When emitting the message, map to another type\n    let map (f: 'a -> 'msg) (cmd: Cmd<'a>) : Cmd<'msg> =\n        cmd |> List.map (fun g -> (fun dispatch -> f >> dispatch) >> g)\n\n    /// Aggregate multiple commands\n    let batch (cmds: #seq<Cmd<'msg>>) : Cmd<'msg> =\n        cmds |> List.concat\n\n    /// Command to call the subscriber\n    let ofSub (sub: Sub<'msg>) : Cmd<'msg> =\n        [sub]\n\n    module OfFunc =\n        /// Command to evaluate a simple function and map the result\n        /// into success or error (of exception)\n        let either (task: 'a -> _) (arg: 'a) (ofSuccess: _ -> 'msg) (ofError: _ -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                try\n                    task arg\n                    |> (ofSuccess >> dispatch)\n                with x ->\n                    x |> (ofError >> dispatch)\n            [bind]\n\n        /// Command to evaluate a simple function and map the success to a message\n        /// discarding any possible error\n        let perform (task: 'a -> _) (arg: 'a) (ofSuccess: _ -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                try\n                    task arg\n                    |> (ofSuccess >> dispatch)\n                with x ->\n                    ()\n            [bind]\n\n        /// Command to evaluate a simple function and map the error (in case of exception)\n        let attempt (task: 'a -> unit) (arg: 'a) (ofError: _ -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                try\n                    task arg\n                with x ->\n                    x |> (ofError >> dispatch)\n            [bind]\n\n        /// Command to issue a specific message\n        let result (msg:'msg) : Cmd<'msg> =\n            [fun dispatch -> dispatch msg]\n\n    module OfAsyncWith =\n        /// Command that will evaluate an async block and map the result\n        /// into success or error (of exception)\n        let either (start: Async<unit> -> unit) \n                   (task: 'a -> Async<_>)\n                   (arg: 'a)\n                   (ofSuccess: _ -> 'msg)\n                   (ofError: _ -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                async {\n                    let! r = task arg |> Async.Catch\n                    dispatch (match r with\n                             | Choice1Of2 x -> ofSuccess x\n                             | Choice2Of2 x -> ofError x)\n                }\n            [bind >> start]\n\n        /// Command that will evaluate an async block and map the success\n        let perform (start: Async<unit> -> unit) \n                    (task: 'a -> Async<_>)\n                    (arg: 'a)\n                    (ofSuccess: _ -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                async {\n                    let! r = task arg |> Async.Catch\n                    match r with\n                    | Choice1Of2 x -> dispatch (ofSuccess x)\n                    | _ -> ()\n                }\n            [bind >> start]\n\n        /// Command that will evaluate an async block and map the error (of exception)\n        let attempt (start: Async<unit> -> unit) \n                    (task: 'a -> Async<_>)\n                    (arg: 'a)\n                    (ofError: _ -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                async {\n                    let! r = task arg |> Async.Catch\n                    match r with\n                    | Choice2Of2 x -> dispatch (ofError x)\n                    | _ -> ()\n                }\n            [bind >> start]\n\n        /// Command that will evaluate an async block to the message\n        let result (start: Async<unit> -> unit) \n                   (task: Async<'msg>) : Cmd<'msg> =\n            let bind dispatch =\n                async {\n                    let! r = task\n                    dispatch r\n                }\n            [bind >> start]\n\n    module OfAsync =\n#if FABLE_COMPILER\n        let start x = Timer.delay 0 (fun _ -> Async.StartImmediate x)\n#else\n        let inline start x = Async.Start x\n#endif    \n        /// Command that will evaluate an async block and map the result\n        /// into success or error (of exception)\n        let inline either (task: 'a -> Async<_>)\n                          (arg: 'a)\n                          (ofSuccess: _ -> 'msg)\n                          (ofError: _ -> 'msg) : Cmd<'msg> =\n            OfAsyncWith.either start task arg ofSuccess ofError\n\n        /// Command that will evaluate an async block and map the success\n        let inline perform (task: 'a -> Async<_>)\n                           (arg: 'a)\n                           (ofSuccess: _ -> 'msg) : Cmd<'msg> =\n            OfAsyncWith.perform start task arg ofSuccess\n\n        /// Command that will evaluate an async block and map the error (of exception)\n        let inline attempt (task: 'a -> Async<_>)\n                           (arg: 'a)\n                           (ofError: _ -> 'msg) : Cmd<'msg> =\n            OfAsyncWith.attempt start task arg ofError\n\n        /// Command that will evaluate an async block to the message\n        let inline result (task: Async<'msg>) : Cmd<'msg> =\n            OfAsyncWith.result start task\n\n    module OfAsyncImmediate =\n        /// Command that will evaluate an async block and map the result\n        /// into success or error (of exception)\n        let inline either (task: 'a -> Async<_>)\n                          (arg: 'a)\n                          (ofSuccess: _ -> 'msg)\n                          (ofError: _ -> 'msg) : Cmd<'msg> =\n            OfAsyncWith.either Async.StartImmediate task arg ofSuccess ofError\n\n        /// Command that will evaluate an async block and map the success\n        let inline perform (task: 'a -> Async<_>)\n                           (arg: 'a)\n                           (ofSuccess: _ -> 'msg) : Cmd<'msg> =\n            OfAsyncWith.perform Async.StartImmediate task arg ofSuccess\n\n        /// Command that will evaluate an async block and map the error (of exception)\n        let inline attempt (task: 'a -> Async<_>)\n                           (arg: 'a)\n                           (ofError: _ -> 'msg) : Cmd<'msg> =\n            OfAsyncWith.attempt Async.StartImmediate task arg ofError\n\n        /// Command that will evaluate an async block to the message\n        let inline result (task: Async<'msg>) : Cmd<'msg> =\n            OfAsyncWith.result Async.StartImmediate task\n\n#if FABLE_COMPILER\n    module OfPromise =\n        /// Command to call `promise` block and map the results\n        let either (task: 'a -> Fable.Core.JS.Promise<_>)\n                   (arg:'a)\n                   (ofSuccess: _ -> 'msg)\n                   (ofError: #exn -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                (task arg)\n                    .``then``(ofSuccess >> dispatch)\n                    .catch(unbox >> ofError >> dispatch)\n                    |> ignore\n            [bind]\n\n        /// Command to call `promise` block and map the success\n        let perform (task: 'a -> Fable.Core.JS.Promise<_>)\n                   (arg:'a)\n                   (ofSuccess: _ -> 'msg) =\n            let bind dispatch =\n                (task arg)\n                    .``then``(ofSuccess >> dispatch)\n                    |> ignore\n            [bind]\n\n        /// Command to call `promise` block and map the error\n        let attempt (task: 'a -> Fable.Core.JS.Promise<_>)\n                    (arg:'a)\n                    (ofError: #exn -> 'msg) : Cmd<'msg> =\n            let bind dispatch =\n                (task arg)\n                    .catch(unbox >> ofError >> dispatch)\n                    |> ignore\n            [bind]\n\n        /// Command to dispatch the `promise` result\n        let result (task: Fable.Core.JS.Promise<'msg>) =\n            let bind dispatch =\n                task.``then`` dispatch\n                |> ignore\n            [bind]\n\n    [<Obsolete(\"Use `OfPromise.either` instead\")>]\n    let inline ofPromise (task: 'a -> Fable.Core.JS.Promise<_>)\n                         (arg:'a)\n                         (ofSuccess: _ -> 'msg)\n                         (ofError: _ -> 'msg) : Cmd<'msg> =\n        OfPromise.either task arg ofSuccess ofError                     \n#else\n    open System.Threading.Tasks\n    module OfTask =\n        /// Command to call a task and map the results\n        let inline either (task: 'a -> Task<_>)\n                          (arg:'a)\n                          (ofSuccess: _ -> 'msg)\n                          (ofError: _ -> 'msg) : Cmd<'msg> =\n            OfAsync.either (task >> Async.AwaitTask) arg ofSuccess ofError\n\n        /// Command to call a task and map the success\n        let inline perform (task: 'a -> Task<_>)\n                           (arg:'a)\n                           (ofSuccess: _ -> 'msg) : Cmd<'msg> =\n            OfAsync.perform (task >> Async.AwaitTask) arg ofSuccess\n\n        /// Command to call a task and map the error\n        let inline attempt (task: 'a -> Task<_>)\n                           (arg:'a)\n                           (ofError: _ -> 'msg) : Cmd<'msg> =\n            OfAsync.attempt (task >> Async.AwaitTask) arg ofError\n\n        /// Command and map the task success\n        let inline result (task: Task<'msg>) : Cmd<'msg> =\n            OfAsync.result (task |> Async.AwaitTask)\n\n    [<Obsolete(\"Use OfTask.either instead\")>]\n    let inline ofTask (task: 'a -> Task<_>)\n                      (arg:'a)\n                      (ofSuccess: _ -> 'msg)\n                      (ofError: _ -> 'msg) : Cmd<'msg> =\n        OfTask.either task arg ofSuccess ofError\n#endif\n\n    // Synonymous with `OfFunc.result`, may be removed in the future\n    let inline ofMsg (msg:'msg) : Cmd<'msg> =\n        OfFunc.result msg\n\n    [<Obsolete(\"Use `Cmd.OfAsync.either` instead\")>]\n    let inline ofAsync (task: 'a -> Async<_>)\n                       (arg: 'a)\n                       (ofSuccess: _ -> 'msg)\n                       (ofError: _ -> 'msg) : Cmd<'msg> =\n        OfAsync.either task arg ofSuccess ofError\n\n    [<Obsolete(\"Use `Cmd.OfFunc.either` instead\")>]\n    let inline ofFunc (task: 'a -> _) (arg: 'a) (ofSuccess: _ -> 'msg) (ofError: _ -> 'msg) : Cmd<'msg> =\n        OfFunc.either task arg ofSuccess ofError\n\n    [<Obsolete(\"Use `Cmd.OfFunc.perform` instead\")>]\n    let inline performFunc (task: 'a -> _) (arg: 'a) (ofSuccess: _ -> 'msg) : Cmd<'msg> =\n        OfFunc.perform task arg ofSuccess\n\n    [<Obsolete(\"Use `Cmd.OfFunc.attempt` instead\")>]\n    let attemptFunc (task: 'a -> unit) (arg: 'a) (ofError: _ -> 'msg) : Cmd<'msg> =\n        OfFunc.attempt task arg ofError\n\n","namespace Elmish\nopen System\n\n[<Struct>]\ntype internal RingState<'item> =\n    | Writable of wx:'item array * ix:int\n    | ReadWritable of rw:'item array * wix:int * rix:int\n\ntype internal RingBuffer<'item>(size) =\n    let doubleSize ix (items: 'item array) =\n        seq { yield! items |> Seq.skip ix\n              yield! items |> Seq.take ix\n              for _ in 0..items.Length do\n                yield Unchecked.defaultof<'item> }\n        |> Array.ofSeq\n\n    let mutable state : 'item RingState =\n        Writable (Array.zeroCreate (max size 10), 0)\n\n    member __.Pop() =\n        match state with\n        | ReadWritable (items, wix, rix) ->\n            let rix' = (rix + 1) % items.Length\n            match rix' = wix with\n            | true -> \n                state <- Writable(items, wix)\n            | _ ->\n                state <- ReadWritable(items, wix, rix')\n            Some items.[rix]\n        | _ ->\n            None\n\n    member __.Push (item:'item) =\n        match state with\n        | Writable (items, ix) ->\n            items.[ix] <- item\n            let wix = (ix + 1) % items.Length\n            state <- ReadWritable(items, wix, ix)\n        | ReadWritable (items, wix, rix) ->\n            items.[wix] <- item\n            let wix' = (wix + 1) % items.Length\n            match wix' = rix with\n            | true -> \n                state <- ReadWritable(items |> doubleSize rix, items.Length, 0)\n            | _ -> \n                state <- ReadWritable(items, wix', rix)","(**\nProgram\n---------\nCore abstractions for creating and running the dispatch loop.\n\n*)\n\nnamespace Elmish\n\n\n/// Program type captures various aspects of program behavior\ntype Program<'arg, 'model, 'msg, 'view> = private {\n    init : 'arg -> 'model * Cmd<'msg>\n    update : 'msg -> 'model -> 'model * Cmd<'msg>\n    subscribe : 'model -> Cmd<'msg>\n    view : 'model -> Dispatch<'msg> -> 'view\n    setState : 'model -> Dispatch<'msg> -> unit\n    onError : (string*exn) -> unit\n    syncDispatch: Dispatch<'msg> -> Dispatch<'msg>\n}\n\n/// Program module - functions to manipulate program instances\n[<RequireQualifiedAccess>]\n[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]\nmodule Program =\n    /// Typical program, new commands are produced by `init` and `update` along with the new state.\n    let mkProgram \n        (init : 'arg -> 'model * Cmd<'msg>) \n        (update : 'msg -> 'model -> 'model * Cmd<'msg>)\n        (view : 'model -> Dispatch<'msg> -> 'view) =\n        { init = init\n          update = update\n          view = view\n          setState = fun model -> view model >> ignore\n          subscribe = fun _ -> Cmd.none\n          onError = Log.onError\n          syncDispatch = id }\n\n    /// Simple program that produces only new state with `init` and `update`.\n    let mkSimple \n        (init : 'arg -> 'model) \n        (update : 'msg -> 'model -> 'model)\n        (view : 'model -> Dispatch<'msg> -> 'view) =\n        { init = init >> fun state -> state,Cmd.none\n          update = fun msg -> update msg >> fun state -> state,Cmd.none\n          view = view\n          setState = fun model -> view model >> ignore\n          subscribe = fun _ -> Cmd.none\n          onError = Log.onError\n          syncDispatch = id }\n\n    /// Subscribe to external source of events.\n    /// The subscription is called once - with the initial model, but can dispatch new messages at any time.\n    let withSubscription (subscribe : 'model -> Cmd<'msg>) (program: Program<'arg, 'model, 'msg, 'view>) =\n        let sub model =\n            Cmd.batch [ program.subscribe model\n                        subscribe model ]\n        { program with subscribe = sub }\n\n    /// Trace all the updates to the console\n    let withConsoleTrace (program: Program<'arg, 'model, 'msg, 'view>) =\n        let traceInit (arg:'arg) =\n            let initModel,cmd = program.init arg\n            Log.toConsole (\"Initial state:\", initModel)\n            initModel,cmd\n\n        let traceUpdate msg model =\n            Log.toConsole (\"New message:\", msg)\n            let newModel,cmd = program.update msg model\n            Log.toConsole (\"Updated state:\", newModel)\n            newModel,cmd\n\n        { program with\n            init = traceInit \n            update = traceUpdate }\n\n    /// Trace all the messages as they update the model\n    let withTrace trace (program: Program<'arg, 'model, 'msg, 'view>) =\n        let update msg model =\n            let state,cmd = program.update msg model\n            trace msg state\n            state,cmd\n        { program\n            with update = update }\n\n    /// Handle dispatch loop exceptions\n    let withErrorHandler onError (program: Program<'arg, 'model, 'msg, 'view>) =\n        { program\n            with onError = onError }\n\n    /// For library authors only: map existing error handler and return new `Program` \n    let mapErrorHandler map (program: Program<'arg, 'model, 'msg, 'view>) =\n        { program\n            with onError = map program.onError }\n\n    /// For library authors only: get the current error handler \n    let onError (program: Program<'arg, 'model, 'msg, 'view>) =\n        program.onError\n\n    /// For library authors only: function to render the view with the latest state \n    let withSetState (setState:'model -> Dispatch<'msg> -> unit)\n                     (program: Program<'arg, 'model, 'msg, 'view>) =        \n        { program\n            with setState = setState }\n\n    /// For library authors only: return the function to render the state \n    let setState (program: Program<'arg, 'model, 'msg, 'view>) =        \n        program.setState\n\n    /// For library authors only: return the view function \n    let view (program: Program<'arg, 'model, 'msg, 'view>) =        \n        program.view\n\n    /// For library authors only: function to synchronize the dispatch function\n    let withSyncDispatch (syncDispatch:Dispatch<'msg> -> Dispatch<'msg>)\n                         (program: Program<'arg, 'model, 'msg, 'view>) =        \n        { program\n            with syncDispatch = syncDispatch }\n\n    /// For library authors only: map the program type\n    let map mapInit mapUpdate mapView mapSetState mapSubscribe\n            (program: Program<'arg, 'model, 'msg, 'view>) =\n        { init = mapInit program.init\n          update = mapUpdate program.update\n          view = mapView program.view\n          setState = mapSetState program.setState\n          subscribe = mapSubscribe program.subscribe\n          onError = program.onError\n          syncDispatch = id }\n\n    /// Start the program loop.\n    /// arg: argument to pass to the init() function.\n    /// program: program created with 'mkSimple' or 'mkProgram'.\n    let runWith (arg: 'arg) (program: Program<'arg, 'model, 'msg, 'view>) =\n        let (model,cmd) = program.init arg\n        let rb = RingBuffer 10\n        let mutable reentered = false\n        let mutable state = model        \n        let rec dispatch msg = \n            if reentered then\n                rb.Push msg\n            else\n                reentered <- true\n                let mutable nextMsg = Some msg\n                while Option.isSome nextMsg do\n                    let msg = nextMsg.Value\n                    try\n                        let (model',cmd') = program.update msg state\n                        program.setState model' syncDispatch\n                        cmd' |> Cmd.exec (fun ex -> program.onError (sprintf \"Error in command while handling: %A\" msg, ex)) syncDispatch\n                        state <- model'\n                    with ex ->\n                        program.onError (sprintf \"Unable to process the message: %A\" msg, ex)\n                    nextMsg <- rb.Pop()\n                reentered <- false\n        and syncDispatch = program.syncDispatch dispatch            \n\n        program.setState model syncDispatch\n        let sub = \n            try \n                program.subscribe model \n            with ex ->\n                program.onError (\"Unable to subscribe:\", ex)\n                Cmd.none\n        Cmd.batch [sub; cmd]\n        |> Cmd.exec (fun ex -> program.onError (\"Error intitializing:\", ex)) syncDispatch\n\n    /// Start the dispatch loop with `unit` for the init() function.\n    let run (program: Program<unit, 'model, 'msg, 'view>) = runWith () program\n","namespace Elmish.React\n\n[<AutoOpen>]\nmodule Helpers =\n    open Fable.React.Props\n    open Fable.Core.JsInterop\n\n    /// `Ref` callback that sets the value of an input textbox after DOM element is created.\n    /// Can be used instead of `DefaultValue` and `Value` props to override input box value.\n    let inline valueOrDefault value =\n        Ref <| (fun e -> if e |> isNull |> not && !!e?value <> !!value then e?value <- !!value)\n\n[<RequireQualifiedAccess>]\nmodule Program =\n\n    module Internal =\n\n        open Fable.React\n        open Browser\n        open Elmish\n\n        let withReactBatchedUsing lazyView2With placeholderId (program:Program<_,_,_,_>) =\n            let mutable lastRequest = None\n            let setState model dispatch =\n                match lastRequest with\n                | Some r -> window.cancelAnimationFrame r\n                | _ -> ()\n\n                lastRequest <- Some (window.requestAnimationFrame (fun _ ->\n                    ReactDom.render(\n                        lazyView2With (fun x y -> obj.ReferenceEquals(x,y)) (Program.view program) model dispatch,\n                        document.getElementById placeholderId\n                    )))\n\n            program\n            |> Program.withSetState setState\n\n        let withReactSynchronousUsing lazyView2With placeholderId (program:Elmish.Program<_,_,_,_>) =\n            let setState model dispatch =\n                ReactDom.render(\n                    lazyView2With (fun x y -> obj.ReferenceEquals(x,y)) (Program.view program) model dispatch,\n                    document.getElementById placeholderId\n                )\n\n            program\n            |> Program.withSetState setState\n\n        let withReactHydrateUsing lazyView2With placeholderId (program:Elmish.Program<_,_,_,_>) =\n            let setState model dispatch =\n                ReactDom.hydrate(\n                    lazyView2With (fun x y -> obj.ReferenceEquals(x,y)) (Program.view program) model dispatch,\n                    document.getElementById placeholderId\n                )\n\n            program\n            |> Program.withSetState setState\n\n\n    /// Renders React root component inside html element identified by placeholderId.\n    /// Uses `requestAnimationFrame` to batch updates to prevent drops in frame rate.\n    /// NOTE: This may have unexpected effects in React controlled inputs, see https://github.com/elmish/react/issues/12\n    let withReactBatched placeholderId (program:Elmish.Program<_,_,_,_>) =\n        Internal.withReactBatchedUsing lazyView2With placeholderId program\n\n    /// Renders React root component inside html element identified by placeholderId.\n    /// New renders are triggered immediately after an update.\n    let withReactSynchronous placeholderId (program:Elmish.Program<_,_,_,_>) =\n        Internal.withReactSynchronousUsing lazyView2With placeholderId program\n\n    [<System.Obsolete(\"Use withReactBatched\")>]\n    let withReact placeholderId (program:Elmish.Program<_,_,_,_>) =\n        Internal.withReactBatchedUsing lazyView2With placeholderId program\n\n    [<System.Obsolete(\"Use withReactSynchronous\")>]\n    let withReactUnoptimized placeholderId (program:Elmish.Program<_,_,_,_>) =\n        Internal.withReactSynchronousUsing lazyView2With placeholderId program\n\n    /// Renders React root component inside html element identified by placeholderId using `React.hydrate`.\n    let withReactHydrate placeholderId (program:Elmish.Program<_,_,_,_>) =\n        Internal.withReactHydrateUsing lazyView2With placeholderId program\n","namespace Elmish.React\n\nopen Fable.React\nopen Elmish\n\ntype LazyProps<'model> = {\n    model:'model\n    render:unit->ReactElement\n    equal:'model->'model->bool\n}\n\nmodule Components =\n    type LazyView<'model>(props) =\n        inherit Component<LazyProps<'model>,obj>(props)\n\n        override this.shouldComponentUpdate(nextProps, _nextState) =\n            not <| this.props.equal this.props.model nextProps.model\n\n        override this.render () =\n            this.props.render ()\n\n[<AutoOpen>]\nmodule Common =\n    /// Avoid rendering the view unless the model has changed.\n    /// equal: function to compare the previous and the new states\n    /// view: function to render the model\n    /// state: new state to render\n    let lazyViewWith (equal:'model->'model->bool)\n                     (view:'model->ReactElement)\n                     (state:'model) =\n        ofType<Components.LazyView<_>,_,_>\n            { render = fun () -> view state\n              equal = equal\n              model = state }\n            []\n\n    /// Avoid rendering the view unless the model has changed.\n    /// equal: function to compare the previous and the new states\n    /// view: function to render the model using the dispatch\n    /// state: new state to render\n    /// dispatch: dispatch function\n    let lazyView2With (equal:'model->'model->bool)\n                      (view:'model->'msg Dispatch->ReactElement)\n                      (state:'model)\n                      (dispatch:'msg Dispatch) =\n        ofType<Components.LazyView<_>,_,_>\n            { render = fun () -> view state dispatch\n              equal = equal\n              model = state }\n            []\n\n    /// Avoid rendering the view unless the model has changed.\n    /// equal: function to compare the previous and the new model (a tuple of two states)\n    /// view: function to render the model using the dispatch\n    /// state1: new state to render\n    /// state2: new state to render\n    /// dispatch: dispatch function\n    let lazyView3With (equal:_->_->bool) (view:_->_->_->ReactElement) state1 state2 (dispatch:'msg Dispatch) =\n        ofType<Components.LazyView<_>,_,_>\n            { render = fun () -> view state1 state2 dispatch\n              equal = equal\n              model = (state1,state2) }\n            []\n\n    /// Avoid rendering the view unless the model has changed.\n    /// view: function of model to render the view\n    let lazyView (view:'model->ReactElement) =\n        lazyViewWith (=) view\n\n    /// Avoid rendering the view unless the model has changed.\n    /// view: function of two arguments to render the model using the dispatch\n    let lazyView2 (view:'model->'msg Dispatch->ReactElement) =\n        lazyView2With (=) view\n\n    /// Avoid rendering the view unless the model has changed.\n    /// view: function of three arguments to render the model using the dispatch\n    let lazyView3 (view:_->_->_->ReactElement) =\n        lazyView3With (=) view\n\n\n","module StateHandling\r\n\r\nopen Elmish\r\nopen Shared\r\n//open Fulma.FontAwesome\r\nopen Browser.Dom\r\nopen AppModel\r\n\r\n\r\nlet validateFastaText (fsa:string) =\r\n    let allSeqs =\r\n        fsa\r\n        |> fun x -> x.Replace(\"\\r\\n\",\"\\n\")\r\n        |> fun x -> x.Split('\\n')\r\n        |> Array.filter (fun x -> not (x.StartsWith(\">\")))\r\n    let validSet =\r\n        set [\r\n            'A';'C';'D';'E';'F';'G';'H';'I';'K';'L';'M';'N';'O';'P';'Q';'R';'S';'T';'U';'V';'W';'Y';'X';'J';'Z';'B';'*';'-';'\\n';'\\r'\r\n            'a';'c';'d';'e';'f';'g';'h';'i';'k';'l';'m';'n';'o';'p';'q';'r';'s';'t';'u';'v';'w';'y';'x';'j';'z';'b'\r\n            ]\r\n\r\n    let invalidChars =\r\n        allSeqs\r\n        |> Array.map (String.filter (fun x -> not (validSet.Contains(x))))\r\n        |> Array.filter (fun s -> s.Length > 0)\r\n        |> String.concat \"\"\r\n        |> fun x -> [for c in x do yield c]\r\n        |> List.distinct\r\n\r\n    let isValid = invalidChars.Length = 0\r\n\r\n    if isValid then Ok fsa else Error (invalidChars)\r\n\r\n// defines the initial state and initial command (= side-effect) of the application\r\nlet init () : Model * Cmd<Msg> =\r\n    initialModel, Cmd.none\r\n\r\n// The update function computes the next state of the application based on the current state and the incoming events/messages\r\n// It can also run side-effects (encoded as commands) like calling the server via Http.\r\n// these commands in turn, can dispatch messages to which the update function will react.\r\nlet update (msg : Msg) (currentModel : Model) : Model * Cmd<Msg> =\r\n    match msg with\r\n    | Reset -> init ()\r\n    | EULAAcceptedChange ->\r\n        let isAccepted = not currentModel.EULAAccepted\r\n        let computationMode = if isAccepted then ComputationMode.Legacy else ComputationMode.IMLP\r\n        let updatedModel = {\r\n            currentModel with\r\n                EULAAccepted = isAccepted\r\n                SelectedComputationMode = computationMode\r\n            }\r\n        updatedModel,Cmd.none\r\n    | ShowEulaModal isVisible ->\r\n        let updatedModel = {currentModel with EULAModalVisible = isVisible}\r\n        updatedModel,Cmd.none\r\n    | GenericError exn ->\r\n        let updatedModel = {currentModel with HasError = true; ErrorState=Some exn}\r\n        updatedModel,Cmd.none\r\n    | ChangeErrorStateVisibility ->\r\n        let updatedModel = {currentModel with ShowErrorStack = not currentModel.ShowErrorStack}\r\n        updatedModel,Cmd.none\r\n    | ChangePlotMode pm ->\r\n        let updatedModel = {currentModel with PlotMode = pm}\r\n        updatedModel,Cmd.none\r\n    | ChangeHelpDisplay hd ->\r\n        let updatedModel = {currentModel with InformationSectionDisplay = hd}\r\n        updatedModel,Cmd.none\r\n    | ChangeViewIndex i ->\r\n        let newIndex = currentModel.CurrentResultViewIndex + i\r\n        let updatedModel =\r\n            if newIndex >= 0 && newIndex < currentModel.FileProcessIndex then\r\n                {currentModel with CurrentResultViewIndex = currentModel.CurrentResultViewIndex + i}\r\n            else\r\n                currentModel\r\n        updatedModel,Cmd.none\r\n    | SeqModeSelection sm ->\r\n        let updatedModel = {currentModel with SeqMode = sm}\r\n        updatedModel,Cmd.none\r\n\r\n    | OrganismModelSelection m ->\r\n        let updatedModel = {currentModel with SelectedOrganismModel = m}\r\n        updatedModel,Cmd.none\r\n\r\n    | ToggleBurger -> \r\n        let updatedModel = {currentModel with BurgerVisible = not currentModel.BurgerVisible}\r\n        updatedModel,Cmd.none\r\n\r\n    | SingleSequenceInput s -> \r\n        let seqMode =\r\n            if s.Length > 0 then \r\n                Mode.Single\r\n            else\r\n                Mode.NotSelected\r\n        let updatedModel = {currentModel with SingleSequence = s; SeqMode = seqMode}\r\n        let validateCmd =\r\n            Cmd.OfFunc.perform\r\n                validateFastaText\r\n                s\r\n                FastaValidation\r\n\r\n\r\n        updatedModel, validateCmd\r\n\r\n    | FastaValidation (Ok _) ->\r\n        let updatedModel = {currentModel with HasValidFasta = true; InvalidFastaChars = []}\r\n        updatedModel,Cmd.none\r\n\r\n    | FastaValidation (Error invalidChars) ->\r\n        let updatedModel = {currentModel with HasValidFasta = false; InvalidFastaChars = invalidChars}\r\n        updatedModel,Cmd.none\r\n        \r\n\r\n    | FastaUploadInput (fileData,fileName) -> \r\n        let seqMode =\r\n            if fileData.Length > 0 then \r\n                Mode.File\r\n            else\r\n                Mode.NotSelected\r\n        let updatedModel = {\r\n            currentModel with\r\n                FastaFileInput =\r\n                    fileData.Split('>')\r\n                    |> fun x -> [|yield ([x.[0];x.[1]] |> String.concat \"\"); yield! x.[2 ..]|]\r\n                    |> Array.map (sprintf \">%s\")\r\n                FastaFileInputName = fileName\r\n                SeqMode = seqMode\r\n            }\r\n        let validateCmd =\r\n            Cmd.OfFunc.perform\r\n                validateFastaText\r\n                fileData\r\n\r\n                FastaValidation\r\n\r\n        updatedModel,validateCmd\r\n            \r\n\r\n    | SingleSequenceRequest mode ->\r\n\r\n        match mode with\r\n        | Legacy  ->\r\n        \r\n            let updatedModel = {\r\n                currentModel with\r\n                    DownloadReady = false;\r\n                    HasJobRunning = true\r\n                    }\r\n            let requestCmd = \r\n                Cmd.OfAsync.either\r\n                    Server.targetPApi.SingleSequenceRequestLegacy\r\n                    (currentModel.SelectedOrganismModel, currentModel.SingleSequence)\r\n                    (Ok >> SingleSequenceResponseLegacy)\r\n                    (Error >> SingleSequenceResponseLegacy)\r\n            updatedModel,requestCmd\r\n\r\n        | IMLP ->\r\n\r\n            let updatedModel = {\r\n                currentModel with\r\n                    DownloadReady = false;\r\n                    HasJobRunning = true\r\n                    }\r\n            let requestCmd = \r\n                Cmd.OfAsync.either\r\n                    Server.targetPApi.SingleSequenceRequestIMLP\r\n                    (currentModel.SelectedOrganismModel, currentModel.SingleSequence)\r\n                    (Ok >> SingleSequenceResponseIMLP)\r\n                    (Error >> SingleSequenceResponseIMLP)\r\n            updatedModel,requestCmd\r\n\r\n    | FastaUploadRequest mode ->\r\n\r\n        match mode with\r\n        | Legacy -> \r\n            let updatedModel = {\r\n                currentModel with\r\n                    DownloadReady = false;\r\n                    HasJobRunning = true;\r\n                }\r\n            let fileLength = currentModel.FastaFileInput.Length\r\n            let processIndex = currentModel.FileProcessIndex\r\n\r\n            let requestCmd =\r\n                if processIndex < fileLength then\r\n                    Cmd.OfAsync.either\r\n                        Server.targetPApi.SingleSequenceRequestLegacy\r\n                        (currentModel.SelectedOrganismModel, currentModel.FastaFileInput.[processIndex])\r\n                        (Ok >> FastaUploadResponseLegacy )\r\n                        (Error >> FastaUploadResponseLegacy )\r\n                else\r\n                    Cmd.ofMsg FileProcessingDone\r\n                    \r\n            updatedModel,requestCmd\r\n\r\n        | IMLP ->\r\n            let updatedModel = {\r\n                currentModel with\r\n                    DownloadReady = false;\r\n                    HasJobRunning = true;\r\n                }\r\n            let fileLength = currentModel.FastaFileInput.Length\r\n            let processIndex = currentModel.FileProcessIndex\r\n\r\n            let requestCmd =\r\n                if processIndex < fileLength then\r\n                    Cmd.OfAsync.either\r\n                        Server.targetPApi.SingleSequenceRequestIMLP\r\n                        (currentModel.SelectedOrganismModel, currentModel.FastaFileInput.[processIndex])\r\n                        (Ok >> FastaUploadResponseIMLP )\r\n                        (Error >> FastaUploadResponseIMLP )\r\n                else\r\n                    Cmd.ofMsg FileProcessingDone\r\n                    \r\n            updatedModel,requestCmd\r\n\r\n    | SingleSequenceResponseLegacy (Ok res) ->\r\n        let updatedModel = {\r\n            currentModel with \r\n                SingleSequenceResultLegacy = Some res\r\n                ShowResults = true\r\n                HasJobRunning = false\r\n                }\r\n        updatedModel,Cmd.none\r\n\r\n    | SingleSequenceResponseLegacy (Error res) ->\r\n        console.log(res)\r\n        currentModel,Cmd.ofMsg (GenericError res)\r\n\r\n    | SingleSequenceResponseIMLP (Ok res) ->\r\n        let updatedModel = {\r\n            currentModel with \r\n                SingleSequenceResultIMLP = Some res\r\n                ShowResults = true\r\n                HasJobRunning = false\r\n                }\r\n        updatedModel,Cmd.none\r\n\r\n    | SingleSequenceResponseIMLP (Error res) ->\r\n        console.log(res)\r\n        currentModel,Cmd.ofMsg (GenericError res)\r\n\r\n    | FastaUploadResponseLegacy (Ok res) ->\r\n        let updatedModel = {\r\n            currentModel with \r\n                FastaFileInputResultLegacy =\r\n                    match currentModel.FastaFileInputResultLegacy with\r\n                    |Some cres  -> Some [|yield! cres; yield res|]\r\n                    |None       -> Some [|res|]\r\n                ShowResults = true\r\n                FileProcessIndex = currentModel.FileProcessIndex + 1\r\n                }\r\n        updatedModel,Cmd.ofMsg (FastaUploadRequest ComputationMode.Legacy)\r\n\r\n    | FastaUploadResponseLegacy (Error res) ->\r\n        //TODO: handle request error!\r\n        console.log(res)\r\n        currentModel,Cmd.ofMsg (GenericError res)\r\n\r\n    | FastaUploadResponseIMLP (Ok res) ->\r\n        let updatedModel = {\r\n            currentModel with \r\n                FastaFileInputResultIMLP =\r\n                    match currentModel.FastaFileInputResultIMLP with\r\n                    |Some cres  -> Some [|yield! cres; yield res|]\r\n                    |None       -> Some [|res|]\r\n                ShowResults = true\r\n                FileProcessIndex = currentModel.FileProcessIndex + 1\r\n                }\r\n        updatedModel,Cmd.ofMsg (FastaUploadRequest ComputationMode.IMLP)\r\n\r\n    | FastaUploadResponseIMLP (Error res) ->\r\n        //TODO: handle request error!\r\n        console.log(res)\r\n        currentModel,Cmd.ofMsg (GenericError res)\r\n\r\n    | ToggleResultHeadingSticky state ->\r\n        let updatedModel = {currentModel with ResultHeadingIsSticky = state}\r\n        updatedModel,Cmd.none\r\n\r\n    | ShowPlot index ->\r\n        let updatedModel = {currentModel with CurrentResultViewIndex = index}\r\n        updatedModel,Cmd.none\r\n\r\n    | PrepareDownloadCSV ->\r\n        match (currentModel.SeqMode, currentModel.SelectedComputationMode) with\r\n        |(Single, Legacy) ->\r\n            match currentModel.SingleSequenceResultLegacy with\r\n            |Some res ->\r\n                let requestCmd = \r\n                    Cmd.OfAsync.either\r\n                        Server.targetPApi.DownloadRequestSingleLegacy\r\n                        (res,currentModel.SessionGuid)\r\n                        (Ok >> DownloadResponse)\r\n                        (Error >> DownloadResponse)\r\n                currentModel,requestCmd\r\n            |_ -> currentModel,Cmd.none\r\n        |(Single, IMLP) ->\r\n            match currentModel.SingleSequenceResultIMLP with\r\n            |Some res ->\r\n                let requestCmd = \r\n                    Cmd.OfAsync.either\r\n                        Server.targetPApi.DownloadRequestSingleIMLP\r\n                        (res,currentModel.SessionGuid)\r\n                        (Ok >> DownloadResponse)\r\n                        (Error >> DownloadResponse)\r\n                currentModel,requestCmd\r\n            |_ -> currentModel,Cmd.none\r\n        |(File, Legacy) ->\r\n            match currentModel.FastaFileInputResultLegacy with\r\n                |Some res ->\r\n                    let requestCmd = \r\n                        Cmd.OfAsync.either\r\n                            Server.targetPApi.DownloadRequestMultipleLegacy\r\n                            (res,currentModel.SessionGuid)\r\n                            (Ok >> DownloadResponse)\r\n                            (Error >> DownloadResponse)\r\n                    currentModel,requestCmd\r\n                |_ -> currentModel,Cmd.none\r\n        |(File, IMLP) ->\r\n            match currentModel.FastaFileInputResultIMLP with\r\n                |Some res ->\r\n                    let requestCmd = \r\n                        Cmd.OfAsync.either\r\n                            Server.targetPApi.DownloadRequestMultipleIMLP\r\n                            (res,currentModel.SessionGuid)\r\n                            (Ok >> DownloadResponse)\r\n                            (Error >> DownloadResponse)\r\n                    currentModel,requestCmd\r\n                |_ -> currentModel,Cmd.none\r\n        |_ -> currentModel,Cmd.none\r\n\r\n    | ShowProgressDetails ->\r\n        let updatedModel = {currentModel with ShowProgressDetails = not currentModel.ShowProgressDetails}\r\n        updatedModel, Cmd.none\r\n\r\n    | FileProcessingDone ->\r\n        let updatedModel = {currentModel with HasJobRunning = false}\r\n        updatedModel, Cmd.none\r\n\r\n    | DownloadResponse (Ok _) ->\r\n        let updatedModel = {currentModel with DownloadReady = true}\r\n        updatedModel,Cmd.none\r\n\r\n    | DownloadResponse (Error ex) ->\r\n        let updatedModel = {currentModel with DownloadReady = false}\r\n        updatedModel,Cmd.ofMsg (GenericError ex)\r\n\r\n    | DownloadFileNameChange dname ->\r\n        let updatedModel = {currentModel with DownloadFileName = dname}\r\n        updatedModel,Cmd.none","module Client\r\n\r\nopen Elmish\r\nopen Elmish.React\r\n\r\nopen Fable.React.Props\r\nopen Fable.Core.JsInterop\r\nopen Shared\r\nopen Fulma\r\n//open Fulma.FontAwesome\r\nopen Fable.React\r\nopen Browser.Dom\r\nopen Browser.Types\r\n\r\nopen Shared\r\n\r\nopen AppModel\r\nopen StateHandling\r\n\r\nopen GenericViewComponents\r\nopen ResultViews\r\n\r\n//let progressDetails (show:bool) (model : Model)  (dispatch: Msg -> unit)  =\r\n//    div [] [\r\n//        if model.HasJobRunning then \r\n//            yield Button.button [Button.OnClick (fun _ -> ShowProgressDetails |> dispatch)] [if show then yield str \"Hide progress details\" else yield str \"Show progress details\"]\r\n//            yield\r\n//                Container.container [if (not show) then yield Container.Props [Props.Style [Props.Display DisplayOptions.None]]] [\r\n//                    Table.table [][\r\n//                        thead [] [\r\n//                            th [] [\r\n//                                str \"Protein entry header\"\r\n//                            ]\r\n//                            th [] [\r\n//                                str \"Status\"\r\n//                                ]\r\n//                        ]\r\n//                        tbody [] [\r\n//                           yield!\r\n//                            model.FastaFileInput\r\n//                            |> Array.mapi\r\n//                                (fun i entry ->\r\n//                                    let rowEntry =\r\n//                                        [\r\n//                                            td [] [\r\n//                                                str (entry.Split('\\n') |> Array.head)\r\n//                                            ]\r\n//                                        ]\r\n//                                    if i < model.FileProcessIndex then\r\n//                                        tr [] [\r\n//                                            yield! rowEntry\r\n//                                            yield\r\n//                                                td [] [\r\n//                                                    str \"Done\"\r\n//                                                    Icon.icon [] [Fa.i [Fa.Solid.Check] []]\r\n//                                                ]\r\n//                                        ]\r\n//                                    elif i = model.FileProcessIndex then\r\n//                                        tr [] [\r\n//                                            yield! rowEntry\r\n//                                            yield\r\n//                                                td [] [\r\n//                                                    str \"Processing\"\r\n//                                                    Icon.icon [] [Fa.i [Fa.Solid.Spinner] []]\r\n//                                                ]\r\n//                                        ]\r\n//                                    else\r\n//                                        tr [] [\r\n//                                            yield! rowEntry\r\n//                                            yield\r\n//                                                td [] [\r\n//                                                    str \"Queued\"\r\n//                                                    Icon.icon [] [Fa.i [Fa.Solid.TruckLoading] []]\r\n//                                                ]\r\n//                                        ]\r\n//                                )\r\n//                        ]\r\n//                    ]\r\n//                ]\r\n//    ]\r\n\r\n\r\n//let targetPModelSelector (isTargetSelector: bool) (model : Model) (dispatch : Msg -> unit) =\r\n    \r\n//    let selectionClassPlant = \r\n//        match model.SelectedTargetPModel with\r\n//        | Plant when isTargetSelector -> \"is-selected-model\"\r\n//        | _     -> \"\"\r\n\r\n//    let selectionClassNonPlant = \r\n//        match model.SelectedTargetPModel with\r\n//        | NonPlant when isTargetSelector-> \"is-selected-model\"\r\n//        | _         -> \"\"\r\n\r\n//    Columns.columns [] [\r\n//        Column.column [Column.CustomClass \"has-text-centered\"] [\r\n//            Heading.h6 [] [str \"Plant model\"]\r\n//            Image.image [\r\n//                Image.Option.Is128x128;\r\n//                Image.CustomClass (sprintf \"is-centered is-inline-block is-rounded %s\" selectionClassPlant)] [\r\n//                img [\r\n//                    Props.Src \"/Images/PlantModel.png\";\r\n//                    Props.OnClick (fun ev -> if not (model.SeqMode = NotSelected) then TargetPModelSelection TargetPModel.Plant |> dispatch)\r\n//                ]\r\n//            ]\r\n//        ]\r\n//        Column.column [Column.CustomClass \"has-text-centered\"] [\r\n//            Heading.h6 [] [str \"Non-Plant model\"]\r\n//            Image.image [\r\n//                Image.Option.Is128x128;\r\n//                Image.CustomClass (sprintf \"is-centered is-inline-block is-rounded %s\" selectionClassNonPlant)] [\r\n//                img [\r\n//                    Props.Src \"/Images/YeastModel.png\"\r\n//                    Props.OnClick (fun ev -> if not (model.SeqMode = NotSelected) then TargetPModelSelection TargetPModel.NonPlant |> dispatch)\r\n//                ]\r\n//            ]\r\n//        ]\r\n//    ]\r\n\r\nlet view (model : Model) (dispatch : Msg -> unit) =\r\n    div [] [\r\n        navbar model dispatch\r\n        errorModal true model dispatch\r\n        eulaModal model dispatch\r\n        displayHelpModal model dispatch\r\n        hero model dispatch\r\n        inputSelection model dispatch\r\n        ResultViews.ViewComponents.resultHeading model dispatch \r\n        ResultViews.CompositeViews.resultSection model dispatch\r\n        Footer.footer [] [\r\n            Content.content [] [\r\n                str \"This service is developed and maintained by the \"\r\n                a [Props.Href \"https://csb.bio.uni-kl.de/\"] [str \"Computational Systems Biology department \"]\r\n                str \"of the TU Kaiserslautern, Germany.\"\r\n            ]\r\n        ]\r\n    ]\r\n\r\n#if DEBUG\r\nopen Elmish.Debug\r\nopen Elmish.HMR\r\n#endif\r\n\r\nProgram.mkProgram init update view\r\n#if DEBUG\r\n|> Program.withConsoleTrace\r\n#endif\r\n|> Program.withReactSynchronous \"elmish-app\"\r\n#if DEBUG\r\n|> Program.withDebugger\r\n#endif\r\n|> Program.run\r\n"],"names":["x","Array","isArray","ArrayBuffer","isView","isHashable","GetHashCode","Dispose","sameConstructor","y","Object","getPrototypeOf","constructor","Enumerator","iter","this","current","cur","next","value","done","Error","o","GetEnumerator","Symbol","iterator","en","hasNext","undefined","Lazy","factory","isValueCreated","Value","createdValue","IsValueCreated","i","length","str","toString","date","date1","offset","kind","getTimezoneOffset","int32ToString","radix","ObjectRef","static","idMap","has","set","count","get","stringHash","s","h","len","charCodeAt","numberHash","combineHashCodes","hashes","reduce","h1","h2","arrayHash","Date","getTime","dateHash","values","map","v","id","equalArraysWith","eq","Equals","isEquatable","xKeys","keys","yKeys","sort","equalObjects","xtime","ytime","compareArrays","comp","j","compareArraysWith","CompareTo","isComparable","key","compareObjects","max","comparer","createObj","fields","obj","kv","WeakMap","CURRIED","arity","f","uncurried","args","res","_curry","arg","concat","callStack","self","seqToString","cons","entries","k","join","name","String","cases","tag","toJSON","fieldStr","withParens","indexOf","unionToString","splice","other","recordToJSON","recordToString","recordGetHashCode","thisNames","recordEquals","result","recordCompareTo","contentsOrGetter","setter","getter","contents","CaseInfo","declaringType","TypeInfo","fullname","generics","construct","parent","enumCases","fullName","getHashCode","getGenerics","t","t1","t2","getRecordElements","k1","v1","k2","v2","caseNames","prototype","argType","returnType","generic","info","elemType","getElementType","lastIndexOf","substr","_a","getUnionCases","getFunctionElements","isFunction","gen","isTuple","startsWith","getUnionFields","case_","getRecordField","field","makeUnion","uci","expectedLength","makeRecord","_t","assertUnion","NumberStyles","getRange","unsigned","bitsize","isValid","style","exec","replace","prefix","digits","AllowHexSpecifier","getRadix","invalidDigits","getInvalidDigits","test","regexMatch","sign","validResponse","parse","Number","parseInt","isNaN","umin","umax","min","tryParse","defValue","symbol","isNumeric","multiply","toFixed","dp","toPrecision","sd","toExponential","toHex","wasm","WebAssembly","Instance","Module","Uint8Array","exports","e","Long","low","high","isLong","bytes","le","fromBytesLE","fromBytesBE","fromBytes","$this","hi","lo","toBytesLE","toBytesBE","__isLong__","defineProperty","INT_CACHE","UINT_CACHE","fromInt","cachedObj","cache","fromNumber","UZERO","ZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","negate","TWO_PWR_32_DBL","lowBits","highBits","pow_dbl","Math","pow","fromString","RangeError","p","substring","radixToPower","size","add","val","TWO_PWR_16_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","toNumber","isZero","isNegative","radixLong","div","divide","rem1","subtract","rem","remDiv","isOdd","lessThan","greaterThan","greaterThanOrEqual","thisNeg","otherNeg","not","addend","a48","a32","a16","a00","b48","b32","b16","c48","c32","c16","c00","subtrahend","multiplier","mul","get_high","b00","divisor","approx","div_u","div_s","toUnsigned","numBits","shiftRightUnsigned","shiftLeft","shiftRight","floor","log2","ceil","log","LN2","delta","approxRes","approxRem","op_UnaryNegation","xh","_bitsize","lessOrEqual","padStart","maxValue","getMaxValue","toUpperCase","isMinus","minutes","abs","dateToHalfUTCString","half","toISOString","dateToStringWithCustomFormat","format","utc","match","rep","NaN","getUTCFullYear","getFullYear","getUTCMonth","getMonth","getUTCDate","getDate","getUTCHours","getHours","getUTCMinutes","getMinutes","getUTCSeconds","getSeconds","getUTCMilliseconds","getMilliseconds","_provider","_b","_c","d","dateWithOffset","dateToISOStringWithOffset","dateToStringWithOffset","toUTCString","toLocaleString","toLocaleDateString","toLocaleTimeString","printOffset","dateToISOString","dateToStringWithKind","parseRaw","input","fail","trim","m","baseDate","timeInSeconds","timeParts","split","parseFloat","offsetInMinutes","detectUTC","fsFormatRegExp","formatRegExp","isLessThan","printf","cont","lastIndex","strParts","matches","strIdx","matchIndex","index","push","createPrinter","continuePrint","toText","toFail","formatReplacement","flags","padLength","precision","toLowerCase","zeroFlag","minusFlag","ch","padLeft","_strParts","_matches","_result","padArg","slice","_padLength","shift","_","idx","pattern","intPart","decimalPart","decimalPartLength","thousandGroups","thousands","intPartLength","endsWith","search","isNullOrEmpty","delimiter","xs","from","fromBase64String","b64Encoded","binary","atob","notSupported","isRight","RegExp","splitters","options","removeEmpty","filter","splits","reg","findSplits","candidate","Some","opt","defaultValue","Helpers_allocateArrayFromCons","indexNotFound","target","targetIndex","start","fill","mapIndexed","source","arrays","arrays_1","totalIdx","totalLength","idx_1","arr_2","ar","initializer","take","array","predicate","find","folder","state","zip","array1","array2","differentLengths","equalsWith","equals","length1","length2","reduction","reduction_1","Compare","head","tail","super","xs_1_mut","ys_1_mut","loop","xs_1","ys_1","matchValue","xt","yt","i_mut","h_mut","_key","c","ListEnumerator$1","it","__","FSharpList_get_Empty","FSharpList_Cons_305B8EAC","FSharpList__get_IsEmpty","FSharpList__get_Length","FSharpList__get_Head","FSharpList__get_Tail","acc","action","unitVar0","tail_1","ys","mapping","root","node","t_2","case","screen","level","parser","baseClass","baseProps","prop","props","cl","modifiers","option","arg10","display","typ","amount","direction","cls","el","children","dashify","separator","charAt","caseRule","definedCaseRule","kvPair","assign","changeCase","dict","element","DOMAttr","readMethod","blob","resolve","reject","reader","_arg1","list","seek","traversed","message","response","errorMsg","reponseText","Enumerator_notStarted","Enumerator_alreadyFinished","Enumerator_Seq","Enumerator_FromFunctions$1","dispose","Enumerator_noReset","Enumerator_FromFunctions$1_$ctor_58C54629","Enumerator_generateWhileSome","openf","compute","closef","curr","started","x_1","finish","matchValue_1","mkSeq","Enumerator_Seq_$ctor_673A07F2","argName","Operators_NullArg","generator","sources","outerOpt","innerOpt","finished","inner","outer","copyOfStruct","inner_1","outer_1","Enumerator_concat","xs_3","enumerator","xs_5","ofSeq","generate","create","e_1","Enumerator_enumerateThenFinally","pairs","this$","hashMap","Map","pair","Dictionary__Add_5BDDA1","toStringTag","item","Dictionary__Clear","Dictionary__TryFind_2B595","pattern_matching_result","arrayIndex","Dictionary__get_Count","Dictionary__Remove_2B595","Dictionary__ContainsKey_2B595","Dictionary__get_Item_2B595","Dictionary__set_Item_5BDDA1","clear","delete","forEach","thisArg","Dictionary__TryFindIndex_2B595","outArg","findIndex","msg","typeDef","patternInput","flattenFuncTypes","l","resolvedType","activePatternResult5374","primType","activePatternResult5373","types","createTypeInfo","lazyToDelayed","activePatternResult5372","activePatternResult5371","activePatternResult5370","activePatternResult5369","activePatternResult5368","activePatternResult5367","activePatternResult5366","activePatternResult5365","activePatternResult5364","activePatternResult5363","activePatternResult5362","activePatternResult5361","genArgs","keyType","valueType","activePatternResult5360","activePatternResult5359","activePatternResult5358","activePatternResult5357","typeInfoCache","ti","_createTypeInfo","setPrototypeOf","Trampoline","callCount","maxTrampolineCallCount","incrementAndCheck","hijack","setTimeout","ctx","cancelToken","isCancelled","onCancel","trampoline","err","onError","Bind","computation","binder","onSuccess","ex","Combine","computation1","computation2","Delay","For","sequence","body","While","Return","ReturnFrom","TryFinally","compensation","TryWith","catchHandler","ex2","Using","resource","guard","Zero","FSharpChoice$2","emptyContinuation","_x","defaultCancellationToken","cancelled","_id","_cancelled","_listeners","cancel","listener","addListener","removeListener","register","$","startImmediate","cancellationToken","continuation","exceptionContinuation","cancellationContinuation","startWithContinuations","url","headers","req","preparation","resultMapper","token","request","tupledArg","xhr","XMLHttpRequest","Url","forLoopVar","WithCredentials","readyState","RequestBody","data","Parsimmon","seed","arr","n","times","elem","a","isParser","call","isBuffer","Buffer","makeSuccess","status","furthest","expected","makeFailure","mergeReplies","last","hasOwnProperty","union","makeLineColumnIndex","line","column","lines","assertParser","assertNumber","assertRegexp","assertFunction","assertString","repeat","string","leftPad","pad","char","rangeFromIndexAndOffsets","before","after","to","formatGot","error","lineWithErrorIndex","lineRange","lastLineNumberLabelLength","verticalMarkerLength","byteLineWithErrorIndex","columnByteIndex","byteRange","bytesPerLine","bytesAfter","bytesInChunks","chunkSize","chunks","chunkIndex","toChunks","byteLines","byteRow","byteValue","byteRangeToRange","byteLine","inputLines","lineWithErrorCurrentIndex","linesWithLineNumbers","lineSource","lineNumberLabel","isLineWithError","re","anchoredRegexp","parsers","arguments","numParsers","accum","seqMap","mapper","pop","apply","results","alt","sepBy1","then","many","r","rs","regexp","group","anchored","fullMatch","groupMatch","skip","formatError","type","or","alternative","wrap","leftParser","rightParser","left","middle","thru","wrapper","tieWith","assertArray","tie","prevResult","atMost","atLeast","init","rest","fn","contramap","promap","g","mark","end","sepBy","lookahead","notFollowedBy","text","desc","reply","fallback","ap","chain","empty","of","digit","optWhitespace","cr","lf","newline","content","others","right","skipped","ps","strings","MapTreeLeaf$2","MapTreeLeaf$2_$ctor_5BDDA1","MapTreeLeaf$2__get_Key","MapTreeLeaf$2__get_Value","MapTreeNode$2","MapTreeNode$2_$ctor_499A11FD","MapTreeNode$2__get_Left","MapTreeNode$2__get_Right","MapTreeNode$2__get_Height","MapTreeModule_sizeAux","acc_mut","m_mut","m2","MapTreeModule_size","MapTreeModule_mk","hl","hr","m2_1","m_2","MapTreeModule_rebalance","m2_2","m_3","m2_3","t1h","t2h","matchValue_2","matchValue_3","MapTreeModule_add","MapTreeModule_empty","MapTreeModule_tryFind","comparer_mut","k_mut","MapTreeModule_iterOpt","f_mut","MapTreeModule_iter","MapTreeModule_copyToArray","MapTreeModule_ofSeq","MapTreeModule_ofArray","MapTreeModule_ofList","ie","e_mut","MapTreeModule_mkFromEnumerator","MapTreeModule_MapIterator$2","stack","MapTreeModule_collapseLHS","stack_mut","MapTreeModule_mkIterator","MapTreeModule_current","MapTreeModule_alreadyFinished","MapTreeModule_notStarted","MapTreeModule_mkIEnumerator","MapTreeModule_moveNext","FSharpMap","tree","combineHash","activePatternResult8263","FSharpMap__ComputeHashCode","that","e1","e2","m1","e1c","e2c","b1","b2","kvp1","kvp2","FSharpMap__ContainsKey","FSharpMap__get_Item","FSharpMap__get_Count","FSharpMap_$ctor","MapTreeModule_find","MapTreeModule_mem","table","FSharpMap__TryFind","containsKey","elements","FSharpMap_Create","m_1_mut","m_1","MapTreeModule_toList","MapTreeModule_toArray","jint","arg0","jfloat","negJint","escape","anyCharSnippet","otherParser","tuple","withWhitespace","jnull","jbool","jnumber","stringLiteral","jvalue","comma","P","cmp","_this","MAX_DP","NAME","INVALID","INVALID_DP","DIV_BY_ZERO","UNDEFINED","NUMERIC","nl","Big","DP","RM","rm","more","xc","xci","unshift","stringify","doExponential","isNonzero","isneg","yc","b","bl","bt","ri","bz","ai","al","rl","q","qc","qi","gt","gte","lt","lte","minus","sub","xlty","plus","xe","ye","reverse","mod","ygtx","one","prec","round","sqrt","NE","PE","strict","valueOf","_Big_","normalize","TypeError","BigNat","bound","BigNatModule_FFT_pow32","x_mut","n_mut","BigNatModule_bound","BigNatModule_coeff","BigNatModule_coeff64","BigNatModule_setCoeff","BigNatModule_pow64","BigNatModule_pow32","BigNatModule_FFT_maxTwoPower","Int32Array","BigNatModule_baseBits","BigNatModule_baseN","BigNatModule_baseNi64","BigNatModule_baseMaski64","BigNatModule_divbase","BigNatModule_modbase","BigNatModule_createN","BigNatModule_normN","na_mut","na","findLeastBound","BigNatModule_embed","r_1","BigNatModule_eval32","BigNatModule_one","BigNatModule_zero","BigNatModule_degree","rbound","c_mut","p_mut","q_mut","r_mut","z","i_1","z_1","i_2","BigNatModule_addP","BigNatModule_lt","pa_mut","qa_mut","pa","qa","check","BigNatModule_compare","BigNatModule_mulSchoolBookCarry","rak","BigNatModule_mulSchoolBookOneSmall","bp","q_1","BigNatModule_encoding","bigL","twoToBigL","bigK","bigN","BigNatModule_mkEncoding","BigNatModule_table","pSmall","qSmall","BigNatModule_mulSchoolBookBothSmall","ra","pai","qaj","BigNatModule_mulSchoolBookNeitherSmall","BigNatModule_mulSchoolBook","BigNatModule_scaleSubInPlace","patternInput_1","ad","a_1","f_1","zLo","zHi","BigNatModule_scaleAddInPlace","BigNatModule_removeFactor","degx","dega","xa","aa","pn","qai","BigNatModule_copyN","Invariant","BigNatModule_toFloat","evalFloat","BigNatModule_ofInt32","BigNatModule_ofInt64","rem_u","rem_s","BigNatModule_embed64","BigNatModule_toString","degn","collect","isLeading_mut","digits_mut","n_1_mut","_arg1_mut","isLeading","n_1","n_2","prior_1","nL","nH","digits_4","prior_mut","ten2k_mut","prior","ten2k","route","BigNatModule_ofString","ten","build","BigNatModule_getSmall","signInt","BigInteger__get_SignInt","BigInteger__get_V","BigNatModule_hash","nn","BigInteger_$ctor_Z2BE94A1","BigInteger_nat_Z67CCE57D","smallLim","smallPosTab","BigInteger_posn_Z67CCE57D","zero","arg00","text_1","toDecimal","BigInteger__get_ToDecimal","number","arg20","jsObject","jsonValue","activePatternResult5704","activePatternResult5703","activePatternResult5702","activePatternResult5700","parseNative'","activePatternResult5699","object","two","ok","Uri","uri","URL","isAbsoluteUri","original","baseUri","relativeUri","kindOrUri","tryCreateWithKind","tryCreateWithBase","tryCreateImpl","out","decodeURIComponent","asUrl","absoluteUri","href","scheme","protocol","host","absolutePath","pathname","query","pathAndQuery","fragment","hash","originalString","DateTimeOffset","checkOffsetInRange","offsetMatch","fromDayNumber","dayNumber","ticks","Long_op_Multiply","ms","guidRegex","guidRegexNoHyphen","guidRegexHex","hyphenateGuid","wsTrimAndLowered","chars","littleEndian","getBytesInt32","DataView","buffer","byteOffset","byteLength","setInt32","view","getInt32","SetTreeLeaf$1","SetTreeLeaf$1_$ctor_2B595","SetTreeLeaf$1__get_Key","SetTreeNode$1","SetTreeNode$1_$ctor_Z6E7BE5F7","SetTreeNode$1__get_Left","SetTreeNode$1__get_Right","SetTreeNode$1__get_Height","SetTreeModule_countAux","t_mut","SetTreeModule_count","SetTreeModule_mk","t2_1","SetTreeModule_rebalance","t2_3","t_3","t2_4","t2_2","SetTreeModule_add","c_1","SetTreeModule_empty","SetTreeModule_mem","SetTreeModule_iter","SetTreeModule_SetIterator$1","SetTreeModule_collapseLHS","x2","SetTreeModule_mkIterator","SetTreeModule_current","SetTreeModule_alreadyFinished","SetTreeModule_notStarted","SetTreeModule_mkIEnumerator","SetTreeModule_moveNext","SetTreeModule_compare","l1_mut","l2_mut","SetTreeModule_compareStacks","l1","l2","x1_3","x2_3","t1_6","x1_4","t2_6","x2_4","matchValue_4","pattern_matching_result_1","t1_7","x1_5","t2_7","x2_5","c_3","c_2","matchValue_5","pattern_matching_result_2","t1_8","x1_6","t2_8","x2_6","pattern_matching_result_3","t1_2","x1","x2_1","pattern_matching_result_4","t1_4","x1_2","x2_2","SetTreeModule_copyToArray","SetTreeModule_ofSeq","SetTreeModule_ofArray","SetTreeModule_ofList","SetTreeModule_mkFromEnumerator","FSharpSet","FSharpSet__ComputeHashCode","FSharpSet__get_Comparer","FSharpSet__get_Tree","FSharpSet__get_Count","FSharpSet__Contains","FSharpSet_$ctor","set$","items","HashSet__Add_2B595","HashSet__Clear","HashSet__Contains_2B595","HashSet__get_Count","HashSet__Remove_2B595","HashSet__TryFindIndex_2B595","v_1","json","activePatternResult5812","activePatternResult5807","activePatternResult5811","activePatternResult5809","leftMap","rightMap","linkedList","found","startIndex","foundCase","testExpr","typeInfo","getlElemType","getElemType","genericJson","getTypes","optionalTypeDelayed","underlyingType","originalType","insideBrowser","unionType","caseName","activePatternResult5899","expectedCases","CaseTypes","arg30","_arg2","caseInfo","caseType","foundDiscriminatorKey","keyword","discriminatorValueJson","discriminatorValue","foundUnionCase","unexpectedJson","expectedType","caseIndex","fieldValues","_arg3","caseTypes","_arg4","getFields","serializedRecord","caseValue","elementTypeDelayed","tupleTypesDelayed","tuples","getType","_arg5","otherwise","_arg6","_arg7","foundCaseName","elementType","recordType","fieldType","fieldName","_arg8","dictKeys","recordFields","keyValuePair","output","hashset","inputJson","inputText","escapable","meta","Long_fromNumber","PropertyInfo","FieldType","FieldName","usedCase","enumUnion","serializedFields","serializedValues","serializedKey","serializedValue","isPrimitive","tupleTypes","typeName","func","funcArgs","argumentCount","returnTypeAsync","binaryInput","baseUrl","trimEnd","RouteBuilder","BaseUrl","funcNeedParameters","contentType","inputArgumentTypes","CustomHeaders","Authorization","executeRequest","onOk","CustomResponseSerialization","serializer","requestBody","sendAndRead","statusCode","responseAsBlob","Blob","responseText","parsedJson","arg1","arg2","arg3","arg4","arg5","arg6","arg7","inputArguments","resolver","schemaType","fieldTypes","chooser","delegateArg0","delegateArg1","delegateArg2","delegateArg3","delegateArg4","delegateArg5","delegateArg6","delegateArg7","clo1","methodName","model","FastaFileInputResultIMLP","FastaFileInputResultLegacy","SingleSequenceResultIMLP","SingleSequenceResultLegacy","random","ComputationMode","cb","customClass","title","btnView","baseElement","opts","std","booleans","complete","Icon","Size","Border","Pull","Rotation","Flip","CustomClass","StackSize","FixedWidth","IsLi","HavePulse","HaveSpin","IsInverse","Props","faOptions","Classes","className","suffix","ofOffset","ofType","valueOrDefault","Prop","controlView","dispatch","currentDisp","InformationSectionDisplay","BurgerVisible","EULAModalVisible","block","getDisplayHelpText","DownloadReady","location","DownloadFileName","downloadBtn","SessionGuid","HasJobRunning","SeqMode","EULAAccepted","FastaFileInput","isValidState","HasValidFasta","InvalidFastaChars","existingChangeHandler","loadCallback","Data","Name","files","file","FastaFileInputName","modeSelection","SelectedComputationMode","isNonPlant","OrganismModel","fieldView","showStackTrace","ErrorState","HasError","ShowErrorStack","blck","integralRangeStep","step","stop","stepFn","stepComparedWithZero","stepGreaterThanZero","comparedWithLast","makeRangeStepFunction","st_1","Enumerator_unfold","rangeDouble","distinct","hashSet","plotFactory","plotly","plotComponent","properties","Sequence","PropensityScores","CurrentResultViewIndex","pos","resultLenght","indices","endIndex","startIndex_1","endIndex_1","count_mut","xs_mut","hasMultiResult","hasSingleResult","progr","FileProcessIndex","PlotMode","scores","scores'","minVal","maxVal","formatStrings","spans","lineIndex","indexText","start_1","css","CSSProp","gradientColorTable","source1","source2","score","minLegend","maxLegend","ShowResults","ParseState","sanitized","Header","currentRes","RawTargetPScores","delegates","Add","_addHandler","Publish","Trigger","senderOrValue","valueOrUndefined","sender","AddHandler","handler","RemoveHandler","_removeHandler","Subscribe","callback","OnNext","onNext","onCompleted","OnError","_e","OnCompleted","interval","returnVal","_enabled","_isDisposed","_intervalId","_timeoutId","Interval","AutoReset","_elapsed","Elapsed","Enabled","setInterval","clearTimeout","clearInterval","Close","Start","Stop","cmd","task","ofSuccess","ofError","work","Choice_makeChoice1Of2","wix","rix","rix'","wix'","ix","program","rb","reentered","syncDispatch","nextMsg","update","model'","lists","xs_6","subscribe","nextProps","_nextState","fsa","allSeqs","validSet","invalidChars","pred","console","currentModel","cres","isAccepted","newIndex","validateFastaText","seqMode","SelectedOrganismModel","SingleSequence","processIndex","ShowProgressDetails","errorModal","eulaModal","displayHelpModal","inputSelection","lazyView2With","placeholderId","setState","document","getElementById","equal"],"sourceRoot":""}