{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./.fable/fable-library.2.3.12/Util.js","webpack:///./.fable/fable-library.2.3.12/Types.js","webpack:///./.fable/fable-library.2.3.12/Reflection.js","webpack:///./.fable/fable-library.2.3.12/Int32.js","webpack:///./.fable/fable-library.2.3.12/Long.js","webpack:///./.fable/fable-library.2.3.12/RegExp.js","webpack:///./.fable/fable-library.2.3.12/String.js","webpack:///./.fable/fable-library.2.3.12/Option.js","webpack:///./.fable/fable-library.2.3.12/Seq.js","webpack:///./.fable/fable-library.2.3.12/Map.js","webpack:///./.fable/fable-library.2.3.12/Set.js","webpack:///./.fable/fable-library.2.3.12/Array.js","webpack:///./.fable/fable-library.2.3.12/List.js","webpack:///src/Informedica.GenForm.Shared/Models.fs","webpack:///.fable/Fable.Elmish.React.3.0.1/common.fs","webpack:///.fable/Fable.MaterialUI.4.1.0/Fable.MaterialUI.fs","webpack:///.fable/Fable.Fetch.2.1.0/Fetch.fs","webpack:///.fable/Fable.Elmish.Browser.3.0.1/prelude.fs","webpack:///.fable/Fable.Elmish.Browser.3.0.1/parser.fs","webpack:///./.fable/fable-library.2.3.12/AsyncBuilder.js","webpack:///./.fable/fable-library.2.3.12/Async.js","webpack:///.fable/Fable.Elmish.3.0.6/cmd.fs","webpack:///.fable/Fable.Elmish.3.0.6/ring.fs","webpack:///.fable/Fable.Elmish.3.0.6/program.fs","webpack:///.fable/Fable.Elmish.React.3.0.1/react.fs","webpack:///src/Informedica.GenForm.Client/Client.fs"],"names":["webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","installedChunks","push","Object","prototype","hasOwnProperty","call","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","0","exports","module","l","m","c","d","name","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","p","jsonpArray","window","oldJsonpFunction","slice","isDisposable","x","Dispose","dateOffset","date","date1","offset","kind","getTimezoneOffset","ObjectRef","_classCallCheck","this","_createClass","idMap","has","set","count","stringHash","h","len","charCodeAt","numberHash","combineHashCodes","hashes","reduce","h1","h2","structuralHash","_typeof","GetHashCode","isArray","ar","Array","String","ArrayBuffer","isView","equalArraysWith","y","eq","equalArrays","equals","Equals","Date","compareDates","xtime","ytime","getTime","comparePrimitives","compareArraysWith","comp","compareArrays","compare","CompareTo","max","comparer","WeakMap","CaseRules","None","LowerFirst","changeCase","str","caseRule","charAt","toLowerCase","createObj","fields","fail","kvPair","Error","definedCaseRule","arguments","undefined","_iteratorNormalCompletion2","_didIteratorError2","_iteratorError2","_step2","_iterator2","iterator","next","done","toJSON","err","CURRIED_KEY","uncurry","arity","f","uncurriedFn","a1","a2","a3","a4","a5","a6","a7","a8","curry","partialApply","args","concat","sameType","getPrototypeOf","constructor","declare","cons","superClass","subClass","writable","configurable","inherits","SystemObject","compareList","self","other","tail","res","head","List","Union","tag","_len","_key","recordToJson","record","getFieldNames","keys","recordEquals","thisNames","recordCompare","Record","toString","_this","map","k","join","id","identityHash","from","cur","tmp","_this2","_this3","contents","Exception","msg","stack","message","getFSharpExceptionFieldNames","filter","FSharpException","_this4","fieldNames","_this5","arg1","arg2","arg3","CaseInfo","declaringType","Reflection_classCallCheck","TypeInfo","fullname","generics","cases","fullName","gen","getGenerics","t1","t2","union","option","generic","list","string","endsWith","NumberStyles","wasm","WebAssembly","Instance","Module","Uint8Array","e","Long","low","high","unsigned","radix","isLong","obj","__isLong__","INT_CACHE","UINT_CACHE","fromInt","cachedObj","cache","fromBits","fromNumber","isNaN","UZERO","ZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","op_UnaryNegation","TWO_PWR_32_DBL","lowBits","highBits","pow_dbl","Math","pow","fromString","RangeError","indexOf","substring","radixToPower","size","min","parseInt","op_Addition","op_Multiply","fromValue","val","TWO_PWR_16_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","toInt","$this","toNumber","isZero","isNegative","radixLong","div","op_Division","rem1","op_Subtraction","rem","remDiv","digits","isOdd","lessThan","greaterThan","greaterThanOrEqual","thisNeg","otherNeg","op_LogicalNot","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","op_RightShiftUnsigned","op_LeftShift","op_RightShift","floor","log2","ceil","log","LN2","delta","approxRes","approxRem","fromBytes","bytes","le","fromBytesLE","fromBytesBE","escape","replace","fsFormatRegExp","toHex","longToString","longFromBytes","hi","lo","toBytesLE","toBytesBE","Number","printf","input","cont","test","createPrinter","strCopy","_len2","_key2","_i","_args","arg","formatOnce","toConsole","console","toText","str2","rep","_","prefix","flags","pad","precision","format","toFixed","toPrecision","toExponential","toUpperCase","plusPrefix","ch","padLeft","abs","delimiter","_len4","xs","_key4","isRight","search","RegExp","Some","Option_classCallCheck","some","acceptNull","defaultArg","defaultValue","field","Result","Enumerator","iter","Seq_classCallCheck","current","getEnumerator","toIterator","en","MoveNext","Current","append","ys","delay","firstDone","iters","unfold","output","innerIter","hasFinished","collect","_defineProperty","fold","acc","rangeNumber","first","step","last","singleton","skip","take","truncate","fst","MapTree$00602","MapTreeModule$$$empty","MapTreeModule$$$height","_arg1","MapTreeModule$$$mk","l$$1","v","r$$1","matchValue","hl","hr","MapTreeModule$$$rebalance","k$$1","v$$1","t1h","t2h","t2v","t2r","t2l","t2k","t2lv","t2lr","t2ll","t2lk","t1v","t1r","t1l","t1k","t1rv","t1rr","t1rl","t1rk","MapTreeModule$$$add","k$$2","v$$2","m$$3","k2","Compare","v2","r$$2","l$$2","k2$$1","h$$1","c$$1","MapTreeModule$$$ofSeq","comparer$$16","c$$9","ie","comparer$$14","acc$$10","patternInput$$2","$acc$$10$$77","$comparer$$14$$76","$e$$78","MapTreeModule$$$mkFromEnumerator","MapTreeModule$002EMapIterator$00602","started","MapTreeModule$$$collapseLHS","$stack$$81","MapTreeModule$$$mkIterator","s$$5","MapTreeModule$$$current","i$$2","matchValue$$4","MapTreeModule$$$alreadyFinished","MapTreeModule$$$notStarted","MapTreeModule$002EmkIEnumerator$0027$00602","s$$6","MapTreeModule$$$mkIEnumerator","s$$7","MapTreeModule$002EmkIEnumerator$0027$00602$$$$002Ector$$Z26BC498C","i$$3","matchValue$$5","MapTreeModule$$$moveNext","Reset","FSharpMap","comparer$$17","tree","FSharpMap$$$$002Ector$$58ADD115","FSharpMap$$get_Tree","__$$5","Map_toConsumableArray","map$$1","kv","combineHash","x$$16","y$$3","res$$3","e$$1","activePatternResult3097","that","m2","res$$4","finished","e1","e2","matchValue$$7","kvp1","kvp2","c$$10","SetTree$00601","SetTreeModule$$$SetOne","SetTreeModule$$$SetNode","SetTreeModule$002ESetIterator$00601","SetTreeModule$$$collapseLHS","$stack$$49","SetTreeModule$$$mkIterator","s$$13","SetTreeModule$$$current","matchValue$$6","SetTreeModule$$$alreadyFinished","SetTreeModule$$$notStarted","SetTreeModule$002EmkIEnumerator$00601","s$$14","SetTreeModule$$$mkIEnumerator","s$$15","SetTreeModule$002EmkIEnumerator$00601$$$$002Ector$$Z5B395D56","SetTreeModule$$$compare","comparer$$18","s1","s2","matchValue$$9","l1","l2","SetTreeModule$$$compareStacks","$target$$52","t1$$6","t2$$6","n1k","n2k","t1$$7","t2$$7","n1k$$1","n2k$$1","n2r","t1$$8","t2$$8","emp","n1k$$2","n1r","n2k$$2","t1$$9","t2$$9","n1k$$3","n1r$$1","n2k$$3","n2r$$1","t1$$10","t2$$10","n1k$$4","t1$$11","n1k$$5","n1l","n1r$$2","t1$$12","n2k$$4","t2$$11","n2k$$5","n2l","n2r$$2","t2$$12","matchValue$$8","c$$7","c$$8","$l2$$59","$l2$$61","i$$1","SetTreeModule$$$moveNext","FSharpSet","comparer$$22","FSharpSet$$get_Comparer","__$$4","FSharpSet$$get_Tree","toList","source$$10","len$$20","target$$7","i$$51","foldIndexed","f$$1","state","xs$$7","$arg$$7","$arg$$8","$arg$$9","$arg$$10","_arg1$$5","xs$$6","foldIndexedAux","$arg$$14","$arg$$15","$arg$$16","f$$2","state$$1","xs$$8","reverse","xs$$9","acc$$1","x$$6","ofSeq","xs$$12","fold$$1","acc$$3","x$$9","xs$$27","acc$$9","_arg1$$7","xs$$28","ys$$10","x$$15","f$$15","xs$$29","collect$$1","f$$16","xs$$31","acc$$11","mapIndexed","f$$17","xs$$33","acc$$12","x$$17","iterate","f$$24","xs$$46","unitVar0","x$$24","ofArray","xs$$50","col","res$$1","i$$9","Set_toConsumableArray","x$$22","y$$4","that$$1","tostr","List_append","List_map","List_ofSeq","List_mapIndexed","List_length","tupledArg","String_replace","props","styles","options","fn","styles'","func","$arg$$1","withStyles","theme","List_ofArray","Themes$002EStylesModule$$$Custom","CSSProp","react","$this$$1","viewWithStyles","Core$$$withStyles","classes","title","dispatch","AppBar","Core$$$toObj","Props$002EAppBarProp","Toolbar","Typography","HTMLAttr","Props$002ETypographyProp","className","flex","IconButton","Props$002EMaterialProp$00601","DOMAttr","Msg","Icon","url","init","fetch","then","response","ok","status","statusText","PromiseBuilder$$$$002Ector","visited","unvisited","State$00601","tipe","stringToSomething","inner","rest","nextValue","mkState","custom","arg0","Option_Result","subValue","parse","( arg10@ )","parser","states","parseHelp","split","$target$$16","segments","splitUrl","segment","comparer$$12","array1$$6","array2$$6","i$$43","result$$13","length1","length2","compareWith","a","b","$target$$1","Option_value","prelude_tuple","ofFunc","decodeURI","querystring","l$$23","choose","Seq_map","toKeyValuePair","substr","comparer$$19","CancellationToken","cancelled","AsyncBuilder_classCallCheck","_id","_cancelled","_listeners","Map","AsyncBuilder_createClass","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","listener","AsyncBuilder_slicedToArray","$","addListener","removeListener","OperationCanceledError","_Error","_getPrototypeOf","setPrototypeOf","_assertThisInitialized","_inherits","_wrapNativeSuper","protectedCont","ctx","cancelToken","isCancelled","onCancel","trampoline","incrementAndCheck","hijack","onError","protectedBind","computation","binder","onSuccess","ex","protectedReturn","AsyncBuilder","computation1","computation2","Bind","generator","sequence","body","While","Delay","compensation","catchHandler","ex2","resource","TryFinally","guard","Return","text","error","cmd","List_iterate","sub","g","$arg$$2","cmds","lists","state$$3","xs$$14","acc$$4","x$$10","task","ofSuccess","target","targetIndex","RingState$00601","fill","__","wix","rix","items","rix'","item","ix","source$$8","wix'","setState","program","Program$00604","update","subscribe","view","syncDispatch","patternInput","rb","RingBuffer$00601$$$$002Ector$$Z524259A4","reentered","RingBuffer$00601$$Push$$2B595","nextMsg","Cmd$$$exec","RingBuffer$00601$$Pop","Cmd$$$none","lastLocation","onChangeRef","location","href","Navigable$00601","addEventListener","clo1","arg10","urlUpdate","onLocationChange","mapUpdate","mapView","mapSetState","mapSubscribe","Cmd$$$map","userUpdate","model","userView","userSetState","userSubscribe","Cmd$$$batch","userInit","unitVar1","equal","Components$002ELazyView$00601","LazyProps$00601","lazyView2With","placeholderId","lastRequest","ProgramModule$$$withSetState","cancelAnimationFrame","requestAnimationFrame","react_dom","ProgramModule$$$view","document","getElementById","nextProps","_nextState","render","dangerouslySetInnerHTML","DangerousHtml","Client_ages","tuple","ages","Client_weights","weights","Fetch_fetch$","json","_arg2","grps","Promise","resolve","Array_toList","f1","f2","er","reject","success","parsers","parser_map","Navigation$002EPage","parser_s","parseBefore","List_collect","parser_str","oneOf","hash","parseParams","parseHash","pageParser","Model","Selected","RuleView","Page","Cmd$002EOfPromise$$$perform","fetchStringList","Informedica_GenForm_Client_Client_Msg","nav","newUrl","toHash","history","pushState","ev","CustomEvent","dispatchEvent","fetched","gl","$target$$12","Cmd$002EOfFunc$$$result","rl","Age","w","Weight","Generic","filler","flexGrow","Component","age","weight","aitems","MenuItem","witems","ainput","FormControl","marginRight","Select","Props$002ESelectProp","Client_toConsumableArray","winput","marginLeft","FormGroup","Props$002EFormGroupProp","display","marginBottom","onInput","lbl","debounce_default","TextField","List_List","ListItem","Button","wght","content","marginTop","patientInput","searchInput","createList","$arg$$3","$arg$$4","$arg$$5","cursor","innerHtml","$target$$22","rd","rw","splitters","removeEmpty","splits","reg","exec","index","lastIndex","String_split","CircularProgress","Container","Props$002EContainerProp","headerBar","urlParser","Log$$$onError","toNavigableWith","runWith","withReactBatchedUsing","Common$$$lazyView2With"],"mappings":"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","file":"app.40ec4928d14ea8d88f42.js","sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t0: 0\n \t};\n\n \tvar deferredModules = [];\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \tvar jsonpArray = window[\"webpackJsonp\"] = window[\"webpackJsonp\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([248,1]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\n","// tslint:disable:ban-types\n// Object.assign flattens getters and setters\n// See https://stackoverflow.com/questions/37054596/js-es5-how-to-assign-objects-with-setters-and-getters\nexport function extend(target, ...sources) {\n    for (const source of sources) {\n        for (const key of Object.keys(source)) {\n            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n        }\n    }\n    return target;\n}\nexport function isDisposable(x) {\n    return x != null && typeof x.Dispose === \"function\";\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 (typeof comparer.Compare === \"function\") {\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}\n// TODO: Move these three 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    return map.has(key) ? [true, map.get(key)] : [false, defaultValue];\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 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 identityHash(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 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 (typeof x.GetHashCode === \"function\") {\n                return x.GetHashCode();\n            }\n            else if (isArray(x)) {\n                const ar = x;\n                const len = ar.length;\n                const hashes = new Array(len);\n                for (let i = 0; i < len; i++) {\n                    hashes[i] = structuralHash(ar[i]);\n                }\n                return combineHashCodes(hashes);\n            }\n            else {\n                return stringHash(String(x));\n            }\n        }\n    }\n}\nexport function isArray(x) {\n    return Array.isArray(x) || ArrayBuffer.isView(x);\n}\nexport function isIterable(x) {\n    return x != null && typeof x === \"object\" && Symbol.iterator in 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}\n// export function equalObjects(x: { [k: string]: any }, y: { [k: string]: any }): boolean {\n//   if (x == null) { return y == null; }\n//   if (y == null) { return false; }\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 (typeof x.Equals === \"function\") {\n        return x.Equals(y);\n    }\n    else if (isArray(x)) {\n        return isArray(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 false;\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}\nexport function compareObjects(x, y) {\n    if (x == null) {\n        return y == null ? 0 : 1;\n    }\n    if (y == null) {\n        return -1;\n    }\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 (typeof x.CompareTo === \"function\") {\n        return x.CompareTo(y);\n    }\n    else if (isArray(x)) {\n        return isArray(y) && compareArrays(x, y);\n    }\n    else if (x instanceof Date) {\n        return (y instanceof Date) && compareDates(x, y);\n    }\n    else {\n        return 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 createAtom(value) {\n    let atom = value;\n    return (value) => {\n        if (value === void 0) {\n            return atom;\n        }\n        else {\n            atom = value;\n            return void 0;\n        }\n    };\n}\nconst CaseRules = {\n    None: 0,\n    LowerFirst: 1,\n};\nfunction changeCase(str, caseRule) {\n    switch (caseRule) {\n        case CaseRules.LowerFirst:\n            return str.charAt(0).toLowerCase() + str.slice(1);\n        case CaseRules.None:\n        default:\n            return str;\n    }\n}\nexport function createObj(fields, caseRule = CaseRules.None) {\n    function fail(kvPair) {\n        throw new Error(\"Cannot infer key and value of \" + String(kvPair));\n    }\n    const o = {};\n    const definedCaseRule = caseRule;\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 (typeof kvPair.toJSON === \"function\") {\n            kvPair = kvPair.toJSON();\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                    o[changeCase(kvPair[0], caseRule)] = true;\n                    break;\n                case 2:\n                    const value = kvPair[1];\n                    o[changeCase(kvPair[0], caseRule)] = value;\n                    break;\n                default:\n                    o[changeCase(kvPair[0], caseRule)] = kvPair.slice(1);\n            }\n        }\n        else if (typeof kvPair === \"string\") {\n            o[changeCase(kvPair, caseRule)] = true;\n        }\n        else {\n            fail(kvPair);\n        }\n    }\n    return o;\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 randomNext(min, max) {\n    return Math.floor(Math.random() * (max - min)) + min;\n}\nexport function randomBytes(buffer) {\n    if (buffer == null) {\n        throw new Error(\"Buffer cannot be null\");\n    }\n    for (let i = 0; i < buffer.length; i += 6) {\n        // Pick random 48-bit number. Fill buffer in 2 24-bit chunks to avoid bitwise truncation.\n        let r = Math.floor(Math.random() * 281474976710656); // Low 24 bits = chunk 1.\n        const rhi = Math.floor(r / 16777216); // High 24 bits shifted via division = chunk 2.\n        for (let j = 0; j < 6 && i + j < buffer.length; j++) {\n            if (j === 3) {\n                r = rhi;\n            }\n            buffer[i + j] = r & 255;\n            r >>>= 8;\n        }\n    }\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    return isArray(col) ? col.length : col.size;\n}\nexport function clear(col) {\n    if (isArray(col)) {\n        col.splice(0);\n    }\n    else {\n        col.clear();\n    }\n}\nconst CURRIED_KEY = \"__CURRIED__\";\nexport function uncurry(arity, f) {\n    // f may be a function option with None value\n    if (f == null) {\n        return null;\n    }\n    // The function is already uncurried\n    if (f.length > 1) {\n        //   if (CURRIED_KEY in f) { // This doesn't always work\n        return f;\n    }\n    let uncurriedFn;\n    switch (arity) {\n        case 2:\n            uncurriedFn = (a1, a2) => f(a1)(a2);\n            break;\n        case 3:\n            uncurriedFn = (a1, a2, a3) => f(a1)(a2)(a3);\n            break;\n        case 4:\n            uncurriedFn = (a1, a2, a3, a4) => f(a1)(a2)(a3)(a4);\n            break;\n        case 5:\n            uncurriedFn = (a1, a2, a3, a4, a5) => f(a1)(a2)(a3)(a4)(a5);\n            break;\n        case 6:\n            uncurriedFn = (a1, a2, a3, a4, a5, a6) => f(a1)(a2)(a3)(a4)(a5)(a6);\n            break;\n        case 7:\n            uncurriedFn = (a1, a2, a3, a4, a5, a6, a7) => f(a1)(a2)(a3)(a4)(a5)(a6)(a7);\n            break;\n        case 8:\n            uncurriedFn = (a1, a2, a3, a4, a5, a6, a7, a8) => f(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8);\n            break;\n        default:\n            throw new Error(\"Uncurrying to more than 8-arity is not supported: \" + arity);\n    }\n    uncurriedFn[CURRIED_KEY] = f;\n    return uncurriedFn;\n}\nexport function curry(arity, f) {\n    if (f == null) {\n        return null;\n    }\n    if (CURRIED_KEY in f) {\n        return f[CURRIED_KEY];\n    }\n    switch (arity) {\n        case 2:\n            return (a1) => (a2) => f(a1, a2);\n        case 3:\n            return (a1) => (a2) => (a3) => f(a1, a2, a3);\n        case 4:\n            return (a1) => (a2) => (a3) => (a4) => f(a1, a2, a3, a4);\n        case 5:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => f(a1, a2, a3, a4, a5);\n        case 6:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => f(a1, a2, a3, a4, a5, a6);\n        case 7:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => f(a1, a2, a3, a4, a5, a6, a7);\n        case 8:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => (a8) => f(a1, a2, a3, a4, a5, a6, a7, a8);\n        default:\n            throw new Error(\"Currying to more than 8-arity is not supported: \" + arity);\n    }\n}\nexport function partialApply(arity, f, args) {\n    if (f == null) {\n        return null;\n    }\n    else if (CURRIED_KEY in f) {\n        f = f[CURRIED_KEY];\n        for (var i = 0; i < args.length; i++) {\n            f = f(args[i]);\n        }\n        return f;\n    }\n    else {\n        switch (arity) {\n            case 1:\n                // Wrap arguments to make sure .concat doesn't destruct arrays. Example\n                // [1,2].concat([3,4],5)   --> [1,2,3,4,5]    // fails\n                // [1,2].concat([[3,4],5]) --> [1,2,[3,4],5]  // ok\n                return (a1) => f.apply(null, args.concat([a1]));\n            case 2:\n                return (a1) => (a2) => f.apply(null, args.concat([a1, a2]));\n            case 3:\n                return (a1) => (a2) => (a3) => f.apply(null, args.concat([a1, a2, a3]));\n            case 4:\n                return (a1) => (a2) => (a3) => (a4) => f.apply(null, args.concat([a1, a2, a3, a4]));\n            case 5:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => f.apply(null, args.concat([a1, a2, a3, a4, a5]));\n            case 6:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => f.apply(null, args.concat([a1, a2, a3, a4, a5, a6]));\n            case 7:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => f.apply(null, args.concat([a1, a2, a3, a4, a5, a6, a7]));\n            case 8:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => (a8) => f.apply(null, args.concat([a1, a2, a3, a4, a5, a6, a7, a8]));\n            default:\n                throw new Error(\"Partially applying to more than 8-arity is not supported: \" + arity);\n        }\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 function (arg) {\n                return mapArg(res, arg, mappings, idx + 1);\n            };\n        }\n    }\n    return function (arg) {\n        return mapArg(fn, arg, mappings, 0);\n    };\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","import { combineHashCodes, compare, compareArrays, equals, equalArrays, identityHash, structuralHash, numberHash } from \"./Util\";\nfunction sameType(x, y) {\n    return y != null && Object.getPrototypeOf(x).constructor === Object.getPrototypeOf(y).constructor;\n}\n// Taken from Babel helpers\nfunction inherits(subClass, superClass) {\n    // if (typeof superClass !== \"function\" && superClass !== null) {\n    //   throw new TypeError(\n    //     \"Super expression must either be null or a function, not \" +\n    //       typeof superClass\n    //   );\n    // }\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n        constructor: {\n            value: subClass,\n            enumerable: false,\n            writable: true,\n            configurable: true,\n        },\n    });\n    // if (superClass)\n    //   Object.setPrototypeOf\n    //     ? Object.setPrototypeOf(subClass, superClass)\n    //     : (subClass.__proto__ = superClass);\n}\nexport function declare(cons, superClass) {\n    inherits(cons, superClass || SystemObject);\n    return cons;\n}\nexport function SystemObject() {\n}\nSystemObject.prototype.toString = function () {\n    return \"{\" + Object.keys(this).map(k => k + \" = \" + String(this[k])).join(\";\\n \") + \"}\";\n};\nSystemObject.prototype.GetHashCode = function () {\n    return identityHash(this);\n};\nSystemObject.prototype.Equals = function (other) {\n    return this === other;\n};\nfunction compareList(self, other) {\n    if (self === other) {\n        return 0;\n    }\n    else {\n        if (other == null) {\n            return -1;\n        }\n        while (self.tail != null) {\n            if (other.tail == null) {\n                return 1;\n            }\n            const res = compare(self.head, other.head);\n            if (res !== 0) {\n                return res;\n            }\n            self = self.tail;\n            other = other.tail;\n        }\n        return other.tail == null ? 0 : -1;\n    }\n}\nexport function List(head, tail) {\n    this.head = head;\n    this.tail = tail;\n}\nList.prototype.toString = function () {\n    return \"[\" + Array.from(this).map(x => String(x)).join(\"; \") + \"]\";\n};\nList.prototype.toJSON = function () {\n    return Array.from(this);\n};\nList.prototype[Symbol.iterator] = function () {\n    let cur = this;\n    return {\n        next: () => {\n            const tmp = cur;\n            cur = cur.tail;\n            return { done: tmp.tail == null, value: tmp.head };\n        },\n    };\n};\nList.prototype.GetHashCode = function () {\n    const hashes = Array.from(this).map(structuralHash);\n    return combineHashCodes(hashes);\n};\nList.prototype.Equals = function (other) {\n    return compareList(this, other) === 0;\n};\nList.prototype.CompareTo = function (other) {\n    return compareList(this, other);\n};\nexport function Union(tag, name, ...fields) {\n    this.tag = tag | 0;\n    this.name = name;\n    this.fields = fields;\n}\nUnion.prototype.toString = function () {\n    const len = this.fields.length;\n    if (len === 0) {\n        return this.name;\n    }\n    else if (len === 1) {\n        return this.name + \" \" + String(this.fields[0]);\n    }\n    else {\n        return this.name + \" (\" + this.fields.map(x => String(x)).join(\",\") + \")\";\n    }\n};\nUnion.prototype.toJSON = function () {\n    return this.fields.length === 0\n        ? this.name\n        : [this.name].concat(this.fields);\n};\nUnion.prototype.GetHashCode = function () {\n    let hashes = this.fields.map(x => structuralHash(x));\n    hashes.splice(0, 0, numberHash(this.tag));\n    return combineHashCodes(hashes);\n};\nUnion.prototype.Equals = function (other) {\n    return this === other\n        || (sameType(this, other)\n            && this.tag === other.tag\n            && equalArrays(this.fields, other.fields));\n};\nUnion.prototype.CompareTo = function (other) {\n    if (this === other) {\n        return 0;\n    }\n    else if (!sameType(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};\nfunction recordToJson(record, getFieldNames) {\n    const o = {};\n    const keys = getFieldNames == null ? Object.keys(record) : getFieldNames(record);\n    for (let i = 0; i < keys.length; i++) {\n        o[keys[i]] = record[keys[i]];\n    }\n    return o;\n}\nfunction recordEquals(self, other, getFieldNames) {\n    if (self === other) {\n        return true;\n    }\n    else if (!sameType(self, other)) {\n        return false;\n    }\n    else {\n        const thisNames = getFieldNames == null ? Object.keys(self) : getFieldNames(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 recordCompare(self, other, getFieldNames) {\n    if (self === other) {\n        return 0;\n    }\n    else if (!sameType(self, other)) {\n        return -1;\n    }\n    else {\n        const thisNames = getFieldNames == null ? Object.keys(self) : getFieldNames(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 function Record() {\n}\nRecord.prototype.toString = function () {\n    return \"{\" + Object.keys(this).map(k => k + \" = \" + String(this[k])).join(\";\\n \") + \"}\";\n};\nRecord.prototype.toJSON = function () {\n    return recordToJson(this);\n};\nRecord.prototype.GetHashCode = function () {\n    const hashes = Object.keys(this).map(k => structuralHash(this[k]));\n    return combineHashCodes(hashes);\n};\nRecord.prototype.Equals = function (other) {\n    return recordEquals(this, other);\n};\nRecord.prototype.CompareTo = function (other) {\n    return recordCompare(this, other);\n};\nexport function anonRecord(o) {\n    return Object.assign(Object.create(Record.prototype), o);\n}\nexport const FSharpRef = declare(function FSharpRef(contents) {\n    this.contents = contents;\n}, Record);\n// EXCEPTIONS\nexport const Exception = declare(function Exception(msg) {\n    this.stack = Error().stack;\n    this.message = msg;\n});\nexport function isException(x) {\n    return x instanceof Error || x instanceof Exception;\n}\nfunction getFSharpExceptionFieldNames(self) {\n    return Object.keys(self).filter(k => k !== \"message\" && k !== \"stack\");\n}\nexport const FSharpException = declare(function FSharpException() {\n    Exception.call(this);\n}, Exception);\nFSharpException.prototype.toString = function () {\n    const fieldNames = getFSharpExceptionFieldNames(this);\n    const len = fieldNames.length;\n    if (len === 0) {\n        return this.message;\n    }\n    else if (len === 1) {\n        return this.message + \" \" + String(this[fieldNames[0]]);\n    }\n    else {\n        return this.message + \" (\" + fieldNames.map(k => String(this[k])).join(\",\") + \")\";\n    }\n};\nFSharpException.prototype.toJSON = function () {\n    return recordToJson(this, getFSharpExceptionFieldNames);\n};\nFSharpException.prototype.GetHashCode = function () {\n    const hashes = getFSharpExceptionFieldNames(this).map(k => structuralHash(this[k]));\n    return combineHashCodes(hashes);\n};\nFSharpException.prototype.Equals = function (other) {\n    return recordEquals(this, other, getFSharpExceptionFieldNames);\n};\nFSharpException.prototype.CompareTo = function (other) {\n    return recordCompare(this, other, getFSharpExceptionFieldNames);\n};\nexport const MatchFailureException = declare(function MatchFailureException(arg1, arg2, arg3) {\n    this.arg1 = arg1;\n    this.arg2 = arg2 | 0;\n    this.arg3 = arg3 | 0;\n    this.message = \"The match cases were incomplete\";\n}, FSharpException);\nexport const Attribute = declare(function Attribute() { });\n","import { Record, Union, anonRecord as makeAnonRecord } from \"./Types\";\nimport { compareArraysWith, equalArraysWith } from \"./Util\";\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 TypeInfo {\n    constructor(fullname, generics, constructor, fields, cases) {\n        this.fullname = fullname;\n        this.generics = generics;\n        this.constructor = constructor;\n        this.fields = fields;\n        this.cases = cases;\n    }\n    toString() {\n        return fullName(this);\n    }\n    Equals(other) {\n        return equals(this, other);\n    }\n    CompareTo(other) {\n        return compare(this, other);\n    }\n}\nexport function getGenerics(t) {\n    return t.generics != null ? t.generics : [];\n}\nexport function equals(t1, t2) {\n    return t1.fullname === t2.fullname\n        && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);\n}\n// System.Type is not comparable in .NET, but let's implement this\n// in case users want to create a dictionary with types as keys\nexport function compare(t1, t2) {\n    if (t1.fullname !== t2.fullname) {\n        return t1.fullname < t2.fullname ? -1 : 1;\n    }\n    else {\n        return compareArraysWith(getGenerics(t1), getGenerics(t2), compare);\n    }\n}\nexport function type(fullname, generics) {\n    return new TypeInfo(fullname, generics);\n}\nexport function record(fullname, generics, constructor, fields) {\n    return new TypeInfo(fullname, generics, constructor, fields);\n}\nexport function anonRecord(...fields) {\n    return new TypeInfo(\"\", null, null, () => fields);\n}\nexport function union(fullname, generics, constructor, cases) {\n    const t = new TypeInfo(fullname, generics, constructor, null, () => cases().map((x, i) => typeof x === \"string\" ? new CaseInfo(t, i, x) : new CaseInfo(t, i, x[0], x[1])));\n    return t;\n}\nexport function tuple(...generics) {\n    return new TypeInfo(\"System.Tuple`\" + generics.length, generics);\n}\nexport function delegate(...generics) {\n    return new TypeInfo(\"System.Func`\" + generics.length, generics);\n}\nexport function lambda(argType, returnType) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpFunc`2\", [argType, returnType]);\n}\nexport function option(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpOption`1\", [generic]);\n}\nexport function list(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Collections.FSharpList`1\", [generic]);\n}\nexport function array(generic) {\n    return new TypeInfo(generic.fullname + \"[]\", [generic]);\n}\nexport const obj = new TypeInfo(\"System.Object\");\nexport const unit = new TypeInfo(\"Microsoft.FSharp.Core.Unit\");\nexport const char = new TypeInfo(\"System.Char\");\nexport const string = new TypeInfo(\"System.String\");\nexport const bool = new TypeInfo(\"System.Boolean\");\nexport const int8 = new TypeInfo(\"System.SByte\");\nexport const uint8 = new TypeInfo(\"System.Byte\");\nexport const int16 = new TypeInfo(\"System.Int16\");\nexport const uint16 = new TypeInfo(\"System.UInt16\");\nexport const int32 = new TypeInfo(\"System.Int32\");\nexport const uint32 = new TypeInfo(\"System.UInt32\");\nexport const float32 = new TypeInfo(\"System.Single\");\nexport const float64 = new TypeInfo(\"System.Double\");\nexport const decimal = new TypeInfo(\"System.Decimal\");\nexport function name(info) {\n    if (Array.isArray(info)) {\n        return info[0];\n    }\n    else if (info instanceof CaseInfo) {\n        return info.name;\n    }\n    else {\n        const i = info.fullname.lastIndexOf(\".\");\n        return i === -1 ? info.fullname : info.fullname.substr(i + 1);\n    }\n}\nexport function fullName(t) {\n    const gen = t.generics != null && !isArray(t) ? t.generics : [];\n    if (gen.length > 0) {\n        return t.fullname + \"[\" + gen.map((x) => fullName(x)).join(\",\") + \"]\";\n    }\n    else {\n        return t.fullname;\n    }\n}\nexport function namespace(t) {\n    const i = t.fullname.lastIndexOf(\".\");\n    return i === -1 ? \"\" : t.fullname.substr(0, i);\n}\nexport function isArray(t) {\n    return t.fullname.endsWith(\"[]\");\n}\nexport function getElementType(t) {\n    return isArray(t) ? t.generics[0] : null;\n}\nexport function isGenericType(t) {\n    return t.generics != null && t.generics.length > 0;\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));\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)) {\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)) {\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.map((t, i) => [\"Data\" + i, t]);\n}\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 new uci.declaringType.constructor(uci.tag, uci.name, ...values);\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.constructor != null\n        ? new t.constructor(...values)\n        : makeAnonRecord(fields.reduce((obj, [key,], i) => {\n            obj[key] = values[i];\n            return obj;\n        }, {}));\n}\nexport function makeTuple(values, t) {\n    return values;\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.name;\n}\nexport function getCaseFields(x) {\n    assertUnion(x);\n    return x.fields;\n}\n","export 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(\"_\", \"\"));\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) {\n    try {\n        const v = parse(str, style, unsigned, bitsize);\n        return [true, v];\n    }\n    catch (_a) {\n        // supress error\n    }\n    return [false, 0];\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}\n","// Adapted from: https://github.com/dcodeIO/long.js/blob/f572e3a17d313730cf11eb838f6d2a5e31626f8a/src/long.js\n// Apache License 2.0: https://github.com/dcodeIO/long.js/blob/master/LICENSE\n/* tslint:disable */\nimport { isValid } from \"./Int32\";\nimport { combineHashCodes } from \"./Util\";\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 default 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    return combineHashCodes([this.unsigned ? 1 : 0, this.high, this.low]);\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); };\nexport const neg = op_UnaryNegation;\nexport const not = op_LogicalNot;\nexport const add = op_Addition;\nexport const sub = op_Subtraction;\nexport const mul = op_Multiply;\nexport const div = op_Division;\nexport const mod = op_Modulus;\nexport const shl = op_LeftShift;\nexport const shr = op_RightShift;\nexport const and = op_BitwiseAnd;\nexport const or = op_BitwiseOr;\nexport const xor = op_ExclusiveOr;\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 */\nfunction isLong(obj) {\n    return (obj && obj[\"__isLong__\"]) === true;\n}\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 * @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 op_UnaryNegation(fromNumber(-value, unsigned));\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\n}\n/**\n * @param {number} value\n * @param {boolean} unsigned\n * @param {number} kind\n * @returns {!Long}\n * @inner\n */\nexport function fromInteger(value, unsigned, kind) {\n    var x;\n    var 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: x = value >>> 0;\n    }\n    return fromBits(x, xh >> 31, unsigned);\n}\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 * @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 op_UnaryNegation(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 = op_Addition(op_Multiply(result, power), fromNumber(value));\n        }\n        else {\n            result = op_Multiply(result, radixToPower);\n            result = op_Addition(result, fromNumber(value));\n        }\n    }\n    result.unsigned = unsigned;\n    return result;\n}\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 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\") <= maxValue.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, maxValue)) {\n            str = isNegative ? res.sign + res.digits : res.digits;\n            return 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) {\n    try {\n        const v = parse(str, style, unsigned, bitsize);\n        return [true, v];\n    }\n    catch (_a) {\n        // supress error\n    }\n    return [false, ZERO];\n}\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// 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 * @type {!Long}\n * @inner\n */\nexport var UZERO = fromInt(0, true);\n/**\n * @type {!Long}\n * @inner\n */\nexport var ONE = fromInt(1);\n/**\n * @type {!Long}\n * @inner\n */\nexport var UONE = fromInt(1, true);\n/**\n * @type {!Long}\n * @inner\n */\nexport var NEG_ONE = fromInt(-1);\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false);\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true);\n/**\n * @type {!Long}\n * @inner\n */\nexport var MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n/**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\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 * @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 * @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 = op_Division($this, radixLong), rem1 = op_Subtraction(op_Multiply(div, radixLong), $this);\n            return toString(div, radix) + toInt(rem1).toString(radix);\n        }\n        else\n            return '-' + toString(op_UnaryNegation($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 = op_Division(rem, radixToPower), intval = toInt(op_Subtraction(rem, op_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 * @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 * @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 * @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 * @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 * @returns {number}\n */\nexport function getNumBitsAbs($this) {\n    if (isNegative($this)) // Unsigned Longs are never negative\n        return equals($this, MIN_VALUE) ? 64 : getNumBitsAbs(op_UnaryNegation($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 * @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 is negative.\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 * @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 * @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 * @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 * @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 differs from the specified's.\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 is less than the specified's.\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 or equal the specified's.\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 greater than the specified's.\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 or equal the specified's.\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 * Compares this Long's value with the specified's.\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(op_Subtraction($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 * Absolute value of the given number.\n */\nexport function abs($this) {\n    if (!$this.unsigned && isNegative($this))\n        return op_UnaryNegation($this);\n    else\n        return $this;\n}\n/**\n * Negates this Long's value.\n * @returns {!Long} Negated Long\n */\nexport function op_UnaryNegation($this) {\n    if (!$this.unsigned && equals($this, MIN_VALUE))\n        return MIN_VALUE;\n    return op_Addition(op_LogicalNot($this), ONE);\n}\n;\n/**\n * Returns the sum of this and the specified Long.\n * @param {!Long|number|string} addend Addend\n * @returns {!Long} Sum\n */\nexport function op_Addition($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 * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nexport function op_Subtraction($this, subtrahend) {\n    if (!isLong(subtrahend))\n        subtrahend = fromValue(subtrahend);\n    return op_Addition($this, op_UnaryNegation(subtrahend));\n}\n;\n/**\n * Returns the product of this and the specified Long.\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nexport function op_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 op_Multiply(op_UnaryNegation($this), op_UnaryNegation(multiplier));\n        else\n            return op_UnaryNegation(op_Multiply(op_UnaryNegation($this), multiplier));\n    }\n    else if (isNegative(multiplier))\n        return op_UnaryNegation(op_Multiply($this, op_UnaryNegation(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 this Long divided by the specified. The result is signed if this Long is signed or\n *  unsigned if this Long is unsigned.\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nexport function op_Division($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 = op_RightShift($this, 1);\n                approx = op_LeftShift(op_Division(halfThis, divisor), 1);\n                if (equals(approx, ZERO)) {\n                    return isNegative(divisor) ? ONE : NEG_ONE;\n                }\n                else {\n                    rem = op_Subtraction($this, op_Multiply(divisor, approx));\n                    res = op_Addition(approx, op_Division(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 op_Division(op_UnaryNegation($this), op_UnaryNegation(divisor));\n            return op_UnaryNegation(op_Division(op_UnaryNegation($this), divisor));\n        }\n        else if (isNegative(divisor))\n            return op_UnaryNegation(op_Division($this, op_UnaryNegation(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, op_RightShiftUnsigned($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 = op_Multiply(approxRes, divisor);\n        while (isNegative(approxRem) || greaterThan(approxRem, rem)) {\n            approx -= delta;\n            approxRes = fromNumber(approx, $this.unsigned);\n            approxRem = op_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 = op_Addition(res, approxRes);\n        rem = op_Subtraction(rem, approxRem);\n    }\n    return res;\n}\n;\n/**\n * Returns this Long modulo the specified.\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nexport function op_Modulus($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 op_Subtraction($this, op_Multiply(op_Division($this, divisor), divisor));\n}\n;\n/**\n * Returns the bitwise NOT of this Long.\n * @returns {!Long}\n */\nexport function op_LogicalNot($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 * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function op_BitwiseAnd($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 * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function op_BitwiseOr($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 * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function op_ExclusiveOr($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 * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function op_LeftShift($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 arithmetically shifted to the right by the given amount.\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function op_RightShift($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 logically shifted to the right by the given amount.\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function op_RightShiftUnsigned($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 * Converts this Long to signed.\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 * @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 * @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 * @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 * @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;\nexport function unixEpochMillisecondsToTicks(ms, offset) {\n    return op_Multiply(op_Addition(op_Addition(fromNumber(ms), 62135596800000), offset), 10000);\n}\nexport function ticksToUnixEpochMilliseconds(ticks) {\n    return toNumber(op_Subtraction(op_Division(ticks, 10000), 62135596800000));\n}\nexport function makeRangeStepFunction(step, last, unsigned) {\n    const zero = unsigned ? UZERO : ZERO;\n    return (x) => greaterThan(step, zero) && lessThanOrEqual(x, last)\n        || lessThan(step, zero) && greaterThanOrEqual(x, last)\n        ? [x, op_Addition(x, step)] : null;\n}\n","export function create(pattern, options) {\n    // Supported RegexOptions\n    // * IgnoreCase:  0x0001\n    // * Multiline:   0x0002\n    // * ECMAScript:  0x0100 (ignored)\n    if ((options & ~(1 ^ 2 ^ 256)) !== 0) {\n        throw new Error(\"RegexOptions only supports: IgnoreCase, Multiline and ECMAScript\");\n    }\n    let flags = \"g\";\n    flags += options & 1 ? \"i\" : \"\"; // 0x0001 RegexOptions.IgnoreCase\n    flags += options & 2 ? \"m\" : \"\";\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(str, pattern, options = 0) {\n    let reg;\n    reg = str instanceof RegExp\n        ? (reg = str, str = pattern, reg.lastIndex = options, reg)\n        : reg = create(pattern, options);\n    return reg.test(str);\n}\nexport function match(str, pattern, options = 0) {\n    let reg;\n    reg = str instanceof RegExp\n        ? (reg = str, str = pattern, reg.lastIndex = options, reg)\n        : reg = create(pattern, options);\n    return reg.exec(str);\n}\nexport function matches(str, pattern, options = 0) {\n    let reg;\n    reg = str instanceof RegExp\n        ? (reg = str, str = pattern, reg.lastIndex = options, reg)\n        : reg = create(pattern, options);\n    if (!reg.global) {\n        throw new Error(\"Non-global RegExp\"); // Prevent infinite loop\n    }\n    let m = reg.exec(str);\n    const matches = [];\n    while (m !== null) {\n        matches.push(m);\n        m = reg.exec(str);\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 !== 0) {\n            limit--;\n            const match = [];\n            const len = arguments.length;\n            for (let i = 0; i < len - 2; i++) {\n                match.push(arguments[i]);\n            }\n            match.index = arguments[len - 2];\n            match.input = arguments[len - 1];\n            res = replacement(match);\n        }\n        return res;\n    }\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit);\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        // $0 doesn't work with JS regex, see #1155\n        replacement = replacement.replace(/\\$0/g, (s) => \"$&\");\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);\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\";\nimport Long, { fromBytes as longFromBytes, toBytes as longToBytes, toString as longToString } from \"./Long\";\nimport { escape } from \"./RegExp\";\nconst fsFormatRegExp = /(^|[^%])%([0+ ]*)(-?\\d+)?(?:\\.(\\d+))?(\\w)/;\nconst formatRegExp = /\\{(\\d+)(,-?\\d+)?(?:\\:([a-zA-Z])(\\d{0,2})|\\:(.+?))?\\}/g;\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-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;\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}\nfunction toHex(x) {\n    if (x instanceof Long) {\n        return longToString(x.unsigned ? x : longFromBytes(longToBytes(x), true), 16);\n    }\n    else {\n        return (Number(x) >>> 0).toString(16);\n    }\n}\nexport function printf(input) {\n    return {\n        input,\n        cont: fsFormat(input),\n    };\n}\nexport function toConsole(arg) {\n    // Don't remove the lambda here, see #1357\n    return arg.cont((x) => { console.log(x); });\n}\nexport function toConsoleError(arg) {\n    return arg.cont((x) => { console.error(x); });\n}\nexport function toText(arg) {\n    return arg.cont((x) => x);\n}\nexport function toFail(arg) {\n    return arg.cont((x) => { throw new Error(x); });\n}\nfunction formatOnce(str2, rep) {\n    return str2.replace(fsFormatRegExp, (_, prefix, flags, pad, precision, format) => {\n        switch (format) {\n            case \"f\":\n            case \"F\":\n                rep = Number(rep).toFixed(precision || 6);\n                break;\n            case \"g\":\n            case \"G\":\n                rep = Number(rep).toPrecision(precision);\n                break;\n            case \"e\":\n            case \"E\":\n                rep = Number(rep).toExponential(precision);\n                break;\n            case \"O\":\n            case \"A\":\n                rep = String(rep);\n                break;\n            case \"x\":\n                rep = toHex(rep);\n                break;\n            case \"X\":\n                rep = toHex(rep).toUpperCase();\n                break;\n        }\n        const plusPrefix = flags.indexOf(\"+\") >= 0 && parseInt(rep, 10) >= 0;\n        pad = parseInt(pad, 10);\n        if (!isNaN(pad)) {\n            const ch = pad >= 0 && flags.indexOf(\"0\") >= 0 ? \"0\" : \" \";\n            rep = padLeft(String(rep), Math.abs(pad) - (plusPrefix ? 1 : 0), ch, pad < 0);\n        }\n        const once = prefix + (plusPrefix ? \"+\" + rep : rep);\n        return once.replace(/%/g, \"%%\");\n    });\n}\nfunction createPrinter(str, cont) {\n    return (...args) => {\n        // Make a copy as the function may be used several times\n        let strCopy = str;\n        for (const arg of args) {\n            strCopy = formatOnce(strCopy, arg);\n        }\n        return fsFormatRegExp.test(strCopy)\n            ? createPrinter(strCopy, cont)\n            : cont(strCopy.replace(/%%/g, \"%\"));\n    };\n}\nexport function fsFormat(str) {\n    return (cont) => {\n        return fsFormatRegExp.test(str)\n            ? createPrinter(str, cont)\n            : cont(str);\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, (match, idx, pad, format, precision, pattern) => {\n        let rep = args[idx];\n        let padSymbol = \" \";\n        const isNumericType = (typeof rep === \"number\") || (rep instanceof Long);\n        // TODO: || (rep instanceof Decimal) || (rep instanceof BigInt);\n        if (isNumericType) {\n            switch (format) {\n                case \"f\":\n                case \"F\":\n                    rep = precision ? rep.toFixed(precision) : rep.toFixed(2);\n                    break;\n                case \"g\":\n                case \"G\":\n                    rep = precision ? rep.toPrecision(precision) : rep.toPrecision();\n                    break;\n                case \"e\":\n                case \"E\":\n                    rep = precision ? rep.toExponential(precision) : rep.toExponential();\n                    break;\n                case \"p\":\n                case \"P\":\n                    rep = (precision ? (rep * 100).toFixed(precision) : (rep * 100).toFixed(2)) + \" %\";\n                    break;\n                case \"d\":\n                case \"D\":\n                    rep = precision ? padLeft(rep.toString(), precision, \"0\") : rep.toString();\n                    break;\n                case \"x\":\n                case \"X\":\n                    rep = precision ? padLeft(toHex(rep), precision, \"0\") : toHex(rep);\n                    if (format === \"X\") {\n                        rep = rep.toUpperCase();\n                    }\n                    break;\n                default:\n                    const m = /^(0+)(\\.0+)?$/.exec(pattern);\n                    if (m != null) {\n                        let decs = 0;\n                        if (m[2] != null) {\n                            rep = rep.toFixed(decs = m[2].length - 1);\n                        }\n                        pad = \",\" + (m[1].length + (decs ? decs + 1 : 0)).toString();\n                        padSymbol = \"0\";\n                    }\n                    else if (pattern) {\n                        rep = pattern;\n                    }\n            }\n        }\n        else if (rep instanceof Date) {\n            rep = dateToString(rep, pattern || format);\n        }\n        pad = parseInt((pad || \"\").substring(1), 10);\n        if (!isNaN(pad)) {\n            rep = padLeft(String(rep), Math.abs(pad), padSymbol, pad < 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 join(delimiter, ...xs) {\n    return xs.map((x) => String(x)).join(delimiter);\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 join(delimiter, ...xs.slice(startIndex, endIndexPlusOne));\n}\n/** Validates UUID as specified in RFC4122 (versions 1-5). Trims braces. */\nexport function validateGuid(str, doNotThrow) {\n    const trimmedAndLowered = trim(str, \"{\", \"}\").toLowerCase();\n    if (guidRegex.test(trimmedAndLowered)) {\n        return doNotThrow ? [true, trimmedAndLowered] : trimmedAndLowered;\n    }\n    else if (doNotThrow) {\n        return [false, \"00000000-0000-0000-0000-000000000000\"];\n    }\n    throw new Error(\"Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\");\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    return _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}\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, removeEmpty) {\n    count = typeof count === \"number\" ? count : null;\n    removeEmpty = typeof removeEmpty === \"number\" ? removeEmpty : null;\n    if (count < 0) {\n        throw new Error(\"Count cannot be less than zero\");\n    }\n    if (count === 0) {\n        return [];\n    }\n    if (!Array.isArray(splitters)) {\n        if (removeEmpty === 0) {\n            return str.split(splitters, count);\n        }\n        const len = arguments.length;\n        splitters = Array(len - 1);\n        for (let key = 1; key < len; key++) {\n            splitters[key - 1] = arguments[key];\n        }\n    }\n    splitters = splitters.map((x) => escape(x));\n    splitters = splitters.length > 0 ? splitters : [\" \"];\n    let i = 0;\n    const splits = [];\n    const reg = new RegExp(splitters.join(\"|\"), \"g\");\n    while (count == null || count > 1) {\n        const m = reg.exec(str);\n        if (m === null) {\n            break;\n        }\n        if (!removeEmpty || (m.index - i) > 0) {\n            count = count != null ? count - 1 : count;\n            splits.push(str.substring(i, m.index));\n        }\n        i = reg.lastIndex;\n    }\n    if (!removeEmpty || (str.length - i) > 0) {\n        splits.push(str.substring(i));\n    }\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}\n","import { declare, Union } from \"./Types\";\nimport { compare, equals, structuralHash } from \"./Util\";\n// Options are erased in runtime by Fable, but we have\n// the `Some` type below to wrap values that would evaluate\n// to null in runtime. These two rules must be followed:\n// 1- None is always null in runtime, a non-strict null check\n//    (`x == null`) is enough to check the case of an option.\n// 2- To get the value of an option the `getValue` helper\n//    below must **always** be used.\n// export type Option<T> = T | Some<T>;\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    // Don't add \"Some\" for consistency with erased options\n    toString() {\n        return String(this.value);\n    }\n    toJSON() {\n        return this.value;\n    }\n    GetHashCode() {\n        return structuralHash(this.value);\n    }\n    Equals(other) {\n        return other == null\n            ? false\n            : equals(this.value, other instanceof Some ? other.value : other);\n    }\n    CompareTo(other) {\n        return other == null\n            ? 1\n            : compare(this.value, other instanceof Some ? other.value : other);\n    }\n}\nexport function some(x) {\n    return x == null || x instanceof Some ? new Some(x) : x;\n}\nexport function value(x, acceptNull) {\n    if (x == null) {\n        if (!acceptNull) {\n            throw new Error(\"Option has no value\");\n        }\n        return null;\n    }\n    else {\n        return x instanceof Some ? x.value : x;\n    }\n}\nexport function defaultArg(arg, defaultValue, f) {\n    return arg == null ? defaultValue : (f != null ? f(value(arg)) : value(arg));\n}\nexport function defaultArgWith(arg, defThunk) {\n    return arg == null ? defThunk() : value(arg);\n}\nexport function filter(predicate, arg) {\n    return arg != null ? (!predicate(value(arg)) ? null : arg) : arg;\n}\nexport function map(predicate, ...args) {\n    return args.every(x => x != null) ? predicate.apply(null, args) : null;\n}\n// CHOICE\nexport const Choice = declare(function Choice(tag, name, field) {\n    Union.call(this, tag, name, field);\n}, Union);\nexport function choice1(x) {\n    return new Choice(0, \"Choice1Of2\", x);\n}\nexport function choice2(x) {\n    return new Choice(1, \"Choice2Of2\", x);\n}\nexport function tryValueIfChoice1(x) {\n    return x.tag === 0 ? some(x.fields[0]) : null;\n}\nexport function tryValueIfChoice2(x) {\n    return x.tag === 1 ? some(x.fields[0]) : null;\n}\n// RESULT\nexport const Result = declare(function Result(tag, name, field) {\n    Union.call(this, tag, name, field);\n}, Union);\nexport function ok(x) {\n    return new Result(0, \"Ok\", x);\n}\nexport function error(x) {\n    return new Result(1, \"Error\", x);\n}\nexport function mapOk(f, result) {\n    return result.tag === 0 ? ok(f(result.fields[0])) : result;\n}\nexport function mapError(f, result) {\n    return result.tag === 1 ? error(f(result.fields[0])) : result;\n}\nexport function bindOk(f, result) {\n    return result.tag === 0 ? f(result.fields[0]) : result;\n}\n","import { makeRangeStepFunction } from \"./Long\";\nimport { some, value } from \"./Option\";\nimport { compare, equals } from \"./Util\";\nexport class Enumerator {\n    constructor(iter) {\n        this.iter = iter;\n    }\n    MoveNext() {\n        const cur = this.iter.next();\n        this.current = cur.value;\n        return !cur.done;\n    }\n    get Current() {\n        return this.current;\n    }\n    Reset() {\n        throw new Error(\"JS iterators cannot be reset\");\n    }\n    Dispose() {\n        return;\n    }\n}\nexport function getEnumerator(o) {\n    return new Enumerator(o[Symbol.iterator]());\n}\nexport function toIterator(en) {\n    return {\n        next() {\n            return en.MoveNext()\n                ? { done: false, value: en.Current }\n                : { done: true, value: null };\n        },\n    };\n}\n// export function toIterable<T>(en: IEnumerable<T>): Iterable<T> {\n//   return {\n//     [Symbol.iterator]() {\n//       return toIterator(en.GetEnumerator());\n//     },\n//   };\n// }\nfunction __failIfNone(res) {\n    if (res == null) {\n        throw new Error(\"Seq did not contain any matching element\");\n    }\n    return value(res);\n}\nexport function ofArray(xs) {\n    return delay(() => unfold((i) => i < xs.length ? [xs[i], i + 1] : null, 0));\n}\nexport function allPairs(xs, ys) {\n    let firstEl = true;\n    const ysCache = [];\n    return collect((x) => {\n        if (firstEl) {\n            firstEl = false;\n            return map((y) => {\n                ysCache.push(y);\n                return [x, y];\n            }, ys);\n        }\n        else {\n            return ysCache.map(y => [x, y]);\n            // return map(function (i) {\n            //     return [x, ysCache[i]];\n            // }, rangeNumber(0, 1, ysCache.length - 1));\n        }\n    }, xs);\n}\nexport function append(xs, ys) {\n    return delay(() => {\n        let firstDone = false;\n        const i = xs[Symbol.iterator]();\n        let iters = [i, null];\n        return unfold(() => {\n            let cur;\n            if (!firstDone) {\n                cur = iters[0].next();\n                if (!cur.done) {\n                    return [cur.value, iters];\n                }\n                else {\n                    firstDone = true;\n                    iters = [null, ys[Symbol.iterator]()];\n                }\n            }\n            cur = iters[1].next();\n            return !cur.done ? [cur.value, iters] : null;\n        }, iters);\n    });\n}\nexport function average(xs, averager) {\n    let count = 0;\n    const total = fold((acc, x) => {\n        count++;\n        return averager.Add(acc, x);\n    }, averager.GetZero(), xs);\n    return averager.DivideByInt(total, count);\n}\nexport function averageBy(f, xs, averager) {\n    let count = 0;\n    const total = fold((acc, x) => {\n        count++;\n        return averager.Add(acc, f(x));\n    }, averager.GetZero(), xs);\n    return averager.DivideByInt(total, count);\n}\nexport function concat(xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        let output = { value: null };\n        return unfold((innerIter) => {\n            let hasFinished = false;\n            while (!hasFinished) {\n                if (innerIter == null) {\n                    const cur = iter.next();\n                    if (!cur.done) {\n                        innerIter = cur.value[Symbol.iterator]();\n                    }\n                    else {\n                        hasFinished = true;\n                    }\n                }\n                else {\n                    const cur = innerIter.next();\n                    if (!cur.done) {\n                        output = { value: cur.value };\n                        hasFinished = true;\n                    }\n                    else {\n                        innerIter = null;\n                    }\n                }\n            }\n            return innerIter != null && output != null ? [output.value, innerIter] : null;\n        }, null);\n    });\n}\nexport function collect(f, xs) {\n    return concat(map(f, xs));\n}\nexport function choose(f, xs) {\n    return delay(() => unfold((iter) => {\n        let cur = iter.next();\n        while (!cur.done) {\n            const y = f(cur.value);\n            if (y != null) {\n                return [value(y), iter];\n            }\n            cur = iter.next();\n        }\n        return null;\n    }, xs[Symbol.iterator]()));\n}\nexport function compareWith(f, xs, ys) {\n    const nonZero = tryFind((i) => i !== 0, map2((x, y) => f(x, y), xs, ys));\n    return nonZero != null ? value(nonZero) : length(xs) - length(ys);\n}\nexport function delay(f) {\n    return {\n        [Symbol.iterator]: () => f()[Symbol.iterator](),\n    };\n}\nexport function empty() {\n    return unfold(() => void 0);\n}\nexport function enumerateWhile(cond, xs) {\n    return concat(unfold(() => cond() ? [xs, true] : null));\n}\nexport function enumerateThenFinally(xs, finalFn) {\n    return delay(() => {\n        let iter;\n        try {\n            iter = xs[Symbol.iterator]();\n        }\n        catch (err) {\n            return void 0;\n        }\n        finally {\n            finalFn();\n        }\n        return unfold((it) => {\n            try {\n                const cur = it.next();\n                return !cur.done ? [cur.value, it] : null;\n            }\n            catch (err) {\n                return void 0;\n            }\n            finally {\n                finalFn();\n            }\n        }, iter);\n    });\n}\nexport function enumerateUsing(disp, work) {\n    let isDisposed = false;\n    const disposeOnce = () => {\n        if (!isDisposed) {\n            isDisposed = true;\n            disp.Dispose();\n        }\n    };\n    try {\n        return enumerateThenFinally(work(disp), disposeOnce);\n    }\n    catch (err) {\n        return void 0;\n    }\n    finally {\n        disposeOnce();\n    }\n}\nexport function exactlyOne(xs) {\n    const iter = xs[Symbol.iterator]();\n    const fst = iter.next();\n    if (fst.done) {\n        throw new Error(\"Seq was empty\");\n    }\n    const snd = iter.next();\n    if (!snd.done) {\n        throw new Error(\"Seq had multiple items\");\n    }\n    return fst.value;\n}\nexport function except(itemsToExclude, source) {\n    const exclusionItems = Array.from(itemsToExclude);\n    const testIsNotInExclusionItems = (element) => !exclusionItems.some((excludedItem) => equals(excludedItem, element));\n    return filter(testIsNotInExclusionItems, source);\n}\nexport function exists(f, xs) {\n    let cur;\n    for (const iter = xs[Symbol.iterator]();;) {\n        cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (f(cur.value)) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function exists2(f, xs, ys) {\n    let cur1;\n    let cur2;\n    for (const iter1 = xs[Symbol.iterator](), iter2 = ys[Symbol.iterator]();;) {\n        cur1 = iter1.next();\n        cur2 = iter2.next();\n        if (cur1.done || cur2.done) {\n            break;\n        }\n        if (f(cur1.value, cur2.value)) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function forAll(f, xs) {\n    return !exists((x) => !f(x), xs);\n}\nexport function forAll2(f, xs, ys) {\n    return !exists2((x, y) => !f(x, y), xs, ys);\n}\nexport function contains(i, xs) {\n    return exists((x) => equals(x, i), xs);\n}\nexport function filter(f, xs) {\n    return delay(() => unfold((iter) => {\n        let cur = iter.next();\n        while (!cur.done) {\n            if (f(cur.value)) {\n                return [cur.value, iter];\n            }\n            cur = iter.next();\n        }\n        return null;\n    }, xs[Symbol.iterator]()));\n}\nexport function where(f, xs) {\n    return filter(f, xs);\n}\nexport function fold(f, acc, xs) {\n    if (Array.isArray(xs) || ArrayBuffer.isView(xs)) {\n        return xs.reduce(f, acc);\n    }\n    else {\n        let cur;\n        for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n            cur = iter.next();\n            if (cur.done) {\n                break;\n            }\n            acc = f(acc, cur.value, i);\n        }\n        return acc;\n    }\n}\nexport function foldBack(f, xs, acc) {\n    const arr = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs : Array.from(xs);\n    for (let i = arr.length - 1; i >= 0; i--) {\n        acc = f(arr[i], acc, i);\n    }\n    return acc;\n}\nexport function fold2(f, acc, xs, ys) {\n    const iter1 = xs[Symbol.iterator]();\n    const iter2 = ys[Symbol.iterator]();\n    let cur1;\n    let cur2;\n    for (let i = 0;; i++) {\n        cur1 = iter1.next();\n        cur2 = iter2.next();\n        if (cur1.done || cur2.done) {\n            break;\n        }\n        acc = f(acc, cur1.value, cur2.value, i);\n    }\n    return acc;\n}\nexport function foldBack2(f, xs, ys, acc) {\n    const ar1 = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs : Array.from(xs);\n    const ar2 = Array.isArray(ys) || ArrayBuffer.isView(ys) ? ys : Array.from(ys);\n    for (let i = ar1.length - 1; i >= 0; i--) {\n        acc = f(ar1[i], ar2[i], acc, i);\n    }\n    return acc;\n}\nexport function tryHead(xs) {\n    const iter = xs[Symbol.iterator]();\n    const cur = iter.next();\n    return cur.done ? null : some(cur.value);\n}\nexport function head(xs) {\n    return __failIfNone(tryHead(xs));\n}\nexport function initialize(n, f) {\n    return delay(() => unfold((i) => i < n ? [f(i), i + 1] : null, 0));\n}\nexport function initializeInfinite(f) {\n    return delay(() => unfold((i) => [f(i), i + 1], 0));\n}\nexport function tryItem(i, xs) {\n    if (i < 0) {\n        return null;\n    }\n    if (Array.isArray(xs) || ArrayBuffer.isView(xs)) {\n        return i < xs.length ? some(xs[i]) : null;\n    }\n    for (let j = 0, iter = xs[Symbol.iterator]();; j++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (j === i) {\n            return some(cur.value);\n        }\n    }\n    return null;\n}\nexport function item(i, xs) {\n    return __failIfNone(tryItem(i, xs));\n}\nexport function iterate(f, xs) {\n    fold((_, x) => f(x), null, xs);\n}\nexport function iterate2(f, xs, ys) {\n    fold2((_, x, y) => f(x, y), null, xs, ys);\n}\nexport function iterateIndexed(f, xs) {\n    fold((_, x, i) => f(i, x), null, xs);\n}\nexport function iterateIndexed2(f, xs, ys) {\n    fold2((_, x, y, i) => f(i, x, y), null, xs, ys);\n}\nexport function isEmpty(xs) {\n    const i = xs[Symbol.iterator]();\n    return i.next().done;\n}\nexport function tryLast(xs) {\n    return isEmpty(xs) ? null : some(reduce((_, x) => x, xs));\n}\nexport function last(xs) {\n    return __failIfNone(tryLast(xs));\n}\nexport function length(xs) {\n    return Array.isArray(xs) || ArrayBuffer.isView(xs)\n        ? xs.length\n        : fold((acc, x) => acc + 1, 0, xs);\n}\nexport function map(f, xs) {\n    return delay(() => unfold((iter) => {\n        const cur = iter.next();\n        return !cur.done ? [f(cur.value), iter] : null;\n    }, xs[Symbol.iterator]()));\n}\nexport function mapIndexed(f, xs) {\n    return delay(() => {\n        let i = 0;\n        return unfold((iter) => {\n            const cur = iter.next();\n            return !cur.done ? [f(i++, cur.value), iter] : null;\n        }, xs[Symbol.iterator]());\n    });\n}\nexport function indexed(xs) {\n    return mapIndexed((i, x) => [i, x], xs);\n}\nexport function map2(f, xs, ys) {\n    return delay(() => {\n        const iter1 = xs[Symbol.iterator]();\n        const iter2 = ys[Symbol.iterator]();\n        return unfold(() => {\n            const cur1 = iter1.next();\n            const cur2 = iter2.next();\n            return !cur1.done && !cur2.done ? [f(cur1.value, cur2.value), null] : null;\n        });\n    });\n}\nexport function mapIndexed2(f, xs, ys) {\n    return delay(() => {\n        let i = 0;\n        const iter1 = xs[Symbol.iterator]();\n        const iter2 = ys[Symbol.iterator]();\n        return unfold(() => {\n            const cur1 = iter1.next();\n            const cur2 = iter2.next();\n            return !cur1.done && !cur2.done ? [f(i++, cur1.value, cur2.value), null] : null;\n        });\n    });\n}\nexport function map3(f, xs, ys, zs) {\n    return delay(() => {\n        const iter1 = xs[Symbol.iterator]();\n        const iter2 = ys[Symbol.iterator]();\n        const iter3 = zs[Symbol.iterator]();\n        return unfold(() => {\n            const cur1 = iter1.next();\n            const cur2 = iter2.next();\n            const cur3 = iter3.next();\n            return !cur1.done && !cur2.done && !cur3.done ? [f(cur1.value, cur2.value, cur3.value), null] : null;\n        });\n    });\n}\nexport function mapFold(f, acc, xs, transform) {\n    const result = [];\n    let r;\n    let cur;\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        [r, acc] = f(acc, cur.value);\n        result.push(r);\n    }\n    return transform !== void 0 ? [transform(result), acc] : [result, acc];\n}\nexport function mapFoldBack(f, xs, acc, transform) {\n    const arr = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs : Array.from(xs);\n    const result = [];\n    let r;\n    for (let i = arr.length - 1; i >= 0; i--) {\n        [r, acc] = f(arr[i], acc);\n        result.push(r);\n    }\n    return transform !== void 0 ? [transform(result), acc] : [result, acc];\n}\nexport function max(xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(acc, x) === 1 ? acc : x, xs);\n}\nexport function maxBy(f, xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(f(acc), f(x)) === 1 ? acc : x, xs);\n}\nexport function min(xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(acc, x) === -1 ? acc : x, xs);\n}\nexport function minBy(f, xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(f(acc), f(x)) === -1 ? acc : x, xs);\n}\nexport function pairwise(xs) {\n    return skip(2, scan((last, next) => [last[1], next], [0, 0], xs));\n}\nexport function rangeChar(first, last) {\n    return delay(() => unfold((x) => x <= last ? [x, String.fromCharCode(x.charCodeAt(0) + 1)] : null, first));\n}\nexport function rangeLong(first, step, last, unsigned) {\n    const stepFn = makeRangeStepFunction(step, last, unsigned);\n    return delay(() => unfold(stepFn, first));\n}\nexport function rangeNumber(first, step, last) {\n    if (step === 0) {\n        throw new Error(\"Step cannot be 0\");\n    }\n    return delay(() => unfold((x) => step > 0 && x <= last || step < 0 && x >= last ? [x, x + step] : null, first));\n}\nexport function readOnly(xs) {\n    return map((x) => x, xs);\n}\nexport function reduce(f, xs) {\n    if (Array.isArray(xs) || ArrayBuffer.isView(xs)) {\n        return xs.reduce(f);\n    }\n    const iter = xs[Symbol.iterator]();\n    let cur = iter.next();\n    if (cur.done) {\n        throw new Error(\"Seq was empty\");\n    }\n    let acc = cur.value;\n    while (true) {\n        cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        acc = f(acc, cur.value);\n    }\n    return acc;\n}\nexport function reduceBack(f, xs) {\n    const ar = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs : Array.from(xs);\n    if (ar.length === 0) {\n        throw new Error(\"Seq was empty\");\n    }\n    let acc = ar[ar.length - 1];\n    for (let i = ar.length - 2; i >= 0; i--) {\n        acc = f(ar[i], acc, i);\n    }\n    return acc;\n}\nexport function replicate(n, x) {\n    return initialize(n, () => x);\n}\nexport function reverse(xs) {\n    const ar = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs.slice(0) : Array.from(xs);\n    return ofArray(ar.reverse());\n}\nexport function scan(f, seed, xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        return unfold((acc) => {\n            if (acc == null) {\n                return [seed, seed];\n            }\n            const cur = iter.next();\n            if (!cur.done) {\n                acc = f(acc, cur.value);\n                return [acc, acc];\n            }\n            return void 0;\n        }, null);\n    });\n}\nexport function scanBack(f, xs, seed) {\n    return reverse(scan((acc, x) => f(x, acc), seed, reverse(xs)));\n}\nexport function singleton(y) {\n    return [y];\n}\nexport function skip(n, xs) {\n    return {\n        [Symbol.iterator]: () => {\n            const iter = xs[Symbol.iterator]();\n            for (let i = 1; i <= n; i++) {\n                if (iter.next().done) {\n                    throw new Error(\"Seq has not enough elements\");\n                }\n            }\n            return iter;\n        },\n    };\n}\nexport function skipWhile(f, xs) {\n    return delay(() => {\n        let hasPassed = false;\n        return filter((x) => hasPassed || (hasPassed = !f(x)), xs);\n    });\n}\nexport function sortWith(f, xs) {\n    const ys = Array.from(xs);\n    return ofArray(ys.sort(f));\n}\nexport function sum(xs, adder) {\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\n}\nexport function sumBy(f, xs, adder) {\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\n}\nexport function tail(xs) {\n    const iter = xs[Symbol.iterator]();\n    const cur = iter.next();\n    if (cur.done) {\n        throw new Error(\"Seq was empty\");\n    }\n    return {\n        [Symbol.iterator]: () => iter,\n    };\n}\nexport function take(n, xs, truncate = false) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        return unfold((i) => {\n            if (i < n) {\n                const cur = iter.next();\n                if (!cur.done) {\n                    return [cur.value, i + 1];\n                }\n                if (!truncate) {\n                    throw new Error(\"Seq has not enough elements\");\n                }\n            }\n            return void 0;\n        }, 0);\n    });\n}\nexport function truncate(n, xs) {\n    return take(n, xs, true);\n}\nexport function takeWhile(f, xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        return unfold((i) => {\n            const cur = iter.next();\n            if (!cur.done && f(cur.value)) {\n                return [cur.value, null];\n            }\n            return void 0;\n        }, 0);\n    });\n}\nexport function tryFind(f, xs, defaultValue) {\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (f(cur.value, i)) {\n            return some(cur.value);\n        }\n    }\n    return defaultValue === void 0 ? null : some(defaultValue);\n}\nexport function find(f, xs) {\n    return __failIfNone(tryFind(f, xs));\n}\nexport function tryFindBack(f, xs, defaultValue) {\n    const arr = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs.slice(0) : Array.from(xs);\n    return tryFind(f, arr.reverse(), defaultValue);\n}\nexport function findBack(f, xs) {\n    return __failIfNone(tryFindBack(f, xs));\n}\nexport function tryFindIndex(f, xs) {\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (f(cur.value, i)) {\n            return i;\n        }\n    }\n    return null;\n}\nexport function findIndex(f, xs) {\n    return __failIfNone(tryFindIndex(f, xs));\n}\nexport function tryFindIndexBack(f, xs) {\n    const arr = Array.isArray(xs) || ArrayBuffer.isView(xs) ? xs.slice(0) : Array.from(xs);\n    for (let i = arr.length - 1; i >= 0; i--) {\n        if (f(arr[i], i)) {\n            return i;\n        }\n    }\n    return null;\n}\nexport function findIndexBack(f, xs) {\n    return __failIfNone(tryFindIndexBack(f, xs));\n}\nexport function tryPick(f, xs) {\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        const y = f(cur.value, i);\n        if (y != null) {\n            return y;\n        }\n    }\n    return null;\n}\nexport function pick(f, xs) {\n    return __failIfNone(tryPick(f, xs));\n}\nexport function unfold(f, fst) {\n    return {\n        [Symbol.iterator]: () => {\n            // Capture a copy of the first value in the closure\n            // so the sequence is restarted every time, see #1230\n            let acc = fst;\n            return {\n                next: () => {\n                    const res = f(acc);\n                    if (res != null) {\n                        acc = res[1];\n                        return { done: false, value: res[0] };\n                    }\n                    return { done: true };\n                },\n            };\n        },\n    };\n}\nexport function zip(xs, ys) {\n    return map2((x, y) => [x, y], xs, ys);\n}\nexport function zip3(xs, ys, zs) {\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\n}\nexport function windowed(windowSize, source) {\n    if (windowSize <= 0) {\n        throw new Error(\"windowSize must be positive\");\n    }\n    return {\n        [Symbol.iterator]: () => {\n            let window = [];\n            const iter = source[Symbol.iterator]();\n            return {\n                next: () => {\n                    let cur;\n                    while (window.length < windowSize) {\n                        if ((cur = iter.next()).done) {\n                            return { done: true };\n                        }\n                        window.push(cur.value);\n                    }\n                    const value = window;\n                    window = window.slice(1);\n                    return { done: false, value };\n                },\n            };\n        },\n    };\n}\n","import { Record, List, declare, Union } from \"./Types.js\";\nimport { type, record, bool, list, union, int32 } from \"./Reflection.js\";\nimport { value as value$$3, some } from \"./Option.js\";\nimport { iterate as iterate$$1, empty as empty$$1, toIterator, map as map$$1, unfold, getEnumerator, fold as fold$$1 } from \"./Seq.js\";\nimport { compare, structuralHash, isDisposable } from \"./Util.js\";\nimport { join, toText, printf } from \"./String.js\";\nexport const MapTree$00602 = declare(function Map_MapTree(tag, name, ...fields) {\n  Union.call(this, tag, name, ...fields);\n}, Union);\nexport function MapTree$00602$reflection($gen$$3, $gen$$4) {\n  return union(\"Map.MapTree`2\", [$gen$$3, $gen$$4], MapTree$00602, () => [\"MapEmpty\", [\"MapOne\", [$gen$$3, $gen$$4]], [\"MapNode\", [$gen$$3, $gen$$4, MapTree$00602$reflection($gen$$3, $gen$$4), MapTree$00602$reflection($gen$$3, $gen$$4), int32]]]);\n}\nexport function MapTreeModule$$$sizeAux(acc, m) {\n  MapTreeModule$$$sizeAux: while (true) {\n    switch (m.tag) {\n      case 1:\n        {\n          return acc + 1 | 0;\n        }\n\n      case 2:\n        {\n          const r = m.fields[3];\n          const l = m.fields[2];\n          const $acc$$5 = acc;\n          acc = MapTreeModule$$$sizeAux($acc$$5 + 1, l);\n          m = r;\n          continue MapTreeModule$$$sizeAux;\n        }\n\n      default:\n        {\n          return acc | 0;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$size(x) {\n  return MapTreeModule$$$sizeAux(0, x);\n}\nexport function MapTreeModule$$$empty() {\n  return new MapTree$00602(0, \"MapEmpty\");\n}\nexport function MapTreeModule$$$height(_arg1) {\n  switch (_arg1.tag) {\n    case 1:\n      {\n        return 1;\n      }\n\n    case 2:\n      {\n        const h = _arg1.fields[4] | 0;\n        return h | 0;\n      }\n\n    default:\n      {\n        return 0;\n      }\n  }\n}\nexport function MapTreeModule$$$isEmpty(m$$1) {\n  if (m$$1.tag === 0) {\n    return true;\n  } else {\n    return false;\n  }\n}\nexport function MapTreeModule$$$mk(l$$1, k, v, r$$1) {\n  const matchValue = [l$$1, r$$1];\n  var $target$$6;\n\n  if (matchValue[0].tag === 0) {\n    if (matchValue[1].tag === 0) {\n      $target$$6 = 0;\n    } else {\n      $target$$6 = 1;\n    }\n  } else {\n    $target$$6 = 1;\n  }\n\n  switch ($target$$6) {\n    case 0:\n      {\n        return new MapTree$00602(1, \"MapOne\", k, v);\n      }\n\n    case 1:\n      {\n        const hl = MapTreeModule$$$height(l$$1) | 0;\n        const hr = MapTreeModule$$$height(r$$1) | 0;\n        const m$$2 = (hl < hr ? hr : hl) | 0;\n        return new MapTree$00602(2, \"MapNode\", k, v, l$$1, r$$1, m$$2 + 1);\n      }\n  }\n}\nexport function MapTreeModule$$$rebalance(t1, k$$1, v$$1, t2) {\n  const t1h = MapTreeModule$$$height(t1) | 0;\n  const t2h = MapTreeModule$$$height(t2) | 0;\n\n  if (t2h > t1h + 2) {\n    if (t2.tag === 2) {\n      const t2v = t2.fields[1];\n      const t2r = t2.fields[3];\n      const t2l = t2.fields[2];\n      const t2k = t2.fields[0];\n\n      if (MapTreeModule$$$height(t2l) > t1h + 1) {\n        if (t2l.tag === 2) {\n          const t2lv = t2l.fields[1];\n          const t2lr = t2l.fields[3];\n          const t2ll = t2l.fields[2];\n          const t2lk = t2l.fields[0];\n          return MapTreeModule$$$mk(MapTreeModule$$$mk(t1, k$$1, v$$1, t2ll), t2lk, t2lv, MapTreeModule$$$mk(t2lr, t2k, t2v, t2r));\n        } else {\n          throw new Error(\"rebalance\");\n        }\n      } else {\n        return MapTreeModule$$$mk(MapTreeModule$$$mk(t1, k$$1, v$$1, t2l), t2k, t2v, t2r);\n      }\n    } else {\n      throw new Error(\"rebalance\");\n    }\n  } else if (t1h > t2h + 2) {\n    if (t1.tag === 2) {\n      const t1v = t1.fields[1];\n      const t1r = t1.fields[3];\n      const t1l = t1.fields[2];\n      const t1k = t1.fields[0];\n\n      if (MapTreeModule$$$height(t1r) > t2h + 1) {\n        if (t1r.tag === 2) {\n          const t1rv = t1r.fields[1];\n          const t1rr = t1r.fields[3];\n          const t1rl = t1r.fields[2];\n          const t1rk = t1r.fields[0];\n          return MapTreeModule$$$mk(MapTreeModule$$$mk(t1l, t1k, t1v, t1rl), t1rk, t1rv, MapTreeModule$$$mk(t1rr, k$$1, v$$1, t2));\n        } else {\n          throw new Error(\"re  balance\");\n        }\n      } else {\n        return MapTreeModule$$$mk(t1l, t1k, t1v, MapTreeModule$$$mk(t1r, k$$1, v$$1, t2));\n      }\n    } else {\n      throw new Error(\"rebalance\");\n    }\n  } else {\n    return MapTreeModule$$$mk(t1, k$$1, v$$1, t2);\n  }\n}\nexport function MapTreeModule$$$add(comparer, k$$2, v$$2, m$$3) {\n  switch (m$$3.tag) {\n    case 1:\n      {\n        const k2 = m$$3.fields[0];\n        const c = comparer.Compare(k$$2, k2) | 0;\n\n        if (c < 0) {\n          return new MapTree$00602(2, \"MapNode\", k$$2, v$$2, new MapTree$00602(0, \"MapEmpty\"), m$$3, 2);\n        } else if (c === 0) {\n          return new MapTree$00602(1, \"MapOne\", k$$2, v$$2);\n        } else {\n          return new MapTree$00602(2, \"MapNode\", k$$2, v$$2, m$$3, new MapTree$00602(0, \"MapEmpty\"), 2);\n        }\n      }\n\n    case 2:\n      {\n        const v2 = m$$3.fields[1];\n        const r$$2 = m$$3.fields[3];\n        const l$$2 = m$$3.fields[2];\n        const k2$$1 = m$$3.fields[0];\n        const h$$1 = m$$3.fields[4] | 0;\n        const c$$1 = comparer.Compare(k$$2, k2$$1) | 0;\n\n        if (c$$1 < 0) {\n          return MapTreeModule$$$rebalance(MapTreeModule$$$add(comparer, k$$2, v$$2, l$$2), k2$$1, v2, r$$2);\n        } else if (c$$1 === 0) {\n          return new MapTree$00602(2, \"MapNode\", k$$2, v$$2, l$$2, r$$2, h$$1);\n        } else {\n          return MapTreeModule$$$rebalance(l$$2, k2$$1, v2, MapTreeModule$$$add(comparer, k$$2, v$$2, r$$2));\n        }\n      }\n\n    default:\n      {\n        return new MapTree$00602(1, \"MapOne\", k$$2, v$$2);\n      }\n  }\n}\nexport function MapTreeModule$$$find(comparer$$1, k$$3, m$$4) {\n  MapTreeModule$$$find: while (true) {\n    switch (m$$4.tag) {\n      case 1:\n        {\n          const v2$$1 = m$$4.fields[1];\n          const k2$$2 = m$$4.fields[0];\n          const c$$2 = comparer$$1.Compare(k$$3, k2$$2) | 0;\n\n          if (c$$2 === 0) {\n            return v2$$1;\n          } else {\n            throw new Error(\"key not found\");\n          }\n        }\n\n      case 2:\n        {\n          const v2$$2 = m$$4.fields[1];\n          const r$$3 = m$$4.fields[3];\n          const l$$3 = m$$4.fields[2];\n          const k2$$3 = m$$4.fields[0];\n          const c$$3 = comparer$$1.Compare(k$$3, k2$$3) | 0;\n\n          if (c$$3 < 0) {\n            const $comparer$$1$$7 = comparer$$1;\n            const $k$$3$$8 = k$$3;\n            comparer$$1 = $comparer$$1$$7;\n            k$$3 = $k$$3$$8;\n            m$$4 = l$$3;\n            continue MapTreeModule$$$find;\n          } else if (c$$3 === 0) {\n            return v2$$2;\n          } else {\n            const $comparer$$1$$9 = comparer$$1;\n            const $k$$3$$10 = k$$3;\n            comparer$$1 = $comparer$$1$$9;\n            k$$3 = $k$$3$$10;\n            m$$4 = r$$3;\n            continue MapTreeModule$$$find;\n          }\n        }\n\n      default:\n        {\n          throw new Error(\"key not found\");\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$tryFind(comparer$$2, k$$4, m$$5) {\n  MapTreeModule$$$tryFind: while (true) {\n    switch (m$$5.tag) {\n      case 1:\n        {\n          const v2$$3 = m$$5.fields[1];\n          const k2$$4 = m$$5.fields[0];\n          const c$$4 = comparer$$2.Compare(k$$4, k2$$4) | 0;\n\n          if (c$$4 === 0) {\n            return some(v2$$3);\n          } else {\n            return null;\n          }\n        }\n\n      case 2:\n        {\n          const v2$$4 = m$$5.fields[1];\n          const r$$4 = m$$5.fields[3];\n          const l$$4 = m$$5.fields[2];\n          const k2$$5 = m$$5.fields[0];\n          const c$$5 = comparer$$2.Compare(k$$4, k2$$5) | 0;\n\n          if (c$$5 < 0) {\n            const $comparer$$2$$11 = comparer$$2;\n            const $k$$4$$12 = k$$4;\n            comparer$$2 = $comparer$$2$$11;\n            k$$4 = $k$$4$$12;\n            m$$5 = l$$4;\n            continue MapTreeModule$$$tryFind;\n          } else if (c$$5 === 0) {\n            return some(v2$$4);\n          } else {\n            const $comparer$$2$$13 = comparer$$2;\n            const $k$$4$$14 = k$$4;\n            comparer$$2 = $comparer$$2$$13;\n            k$$4 = $k$$4$$14;\n            m$$5 = r$$4;\n            continue MapTreeModule$$$tryFind;\n          }\n        }\n\n      default:\n        {\n          return null;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$partition1(comparer$$3, f, k$$5, v$$3, acc1, acc2) {\n  if (f(k$$5, v$$3)) {\n    return [MapTreeModule$$$add(comparer$$3, k$$5, v$$3, acc1), acc2];\n  } else {\n    return [acc1, MapTreeModule$$$add(comparer$$3, k$$5, v$$3, acc2)];\n  }\n}\nexport function MapTreeModule$$$partitionAux($arg$$21, $arg$$22, $arg$$23, $arg$$24, $arg$$25) {\n  MapTreeModule$$$partitionAux: while (true) {\n    const comparer$$4 = $arg$$21,\n          f$$1 = $arg$$22,\n          s = $arg$$23,\n          acc_0 = $arg$$24,\n          acc_1 = $arg$$25;\n    const acc$$1 = [acc_0, acc_1];\n\n    switch (s.tag) {\n      case 1:\n        {\n          const v$$4 = s.fields[1];\n          const k$$6 = s.fields[0];\n          return MapTreeModule$$$partition1(comparer$$4, f$$1, k$$6, v$$4, acc$$1[0], acc$$1[1]);\n        }\n\n      case 2:\n        {\n          const v$$5 = s.fields[1];\n          const r$$5 = s.fields[3];\n          const l$$5 = s.fields[2];\n          const k$$7 = s.fields[0];\n          const acc$$2 = MapTreeModule$$$partitionAux(comparer$$4, f$$1, r$$5, acc$$1[0], acc$$1[1]);\n          const acc$$3 = MapTreeModule$$$partition1(comparer$$4, f$$1, k$$7, v$$5, acc$$2[0], acc$$2[1]);\n          $arg$$21 = comparer$$4;\n          $arg$$22 = f$$1;\n          $arg$$23 = l$$5;\n          $arg$$24 = acc$$3[0];\n          $arg$$25 = acc$$3[1];\n          continue MapTreeModule$$$partitionAux;\n        }\n\n      default:\n        {\n          return acc$$1;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$partition(comparer$$5, f$$2, s$$1) {\n  return MapTreeModule$$$partitionAux(comparer$$5, f$$2, s$$1, MapTreeModule$$$empty(), MapTreeModule$$$empty());\n}\nexport function MapTreeModule$$$filter1(comparer$$6, f$$3, k$$8, v$$6, acc$$4) {\n  if (f$$3(k$$8, v$$6)) {\n    return MapTreeModule$$$add(comparer$$6, k$$8, v$$6, acc$$4);\n  } else {\n    return acc$$4;\n  }\n}\nexport function MapTreeModule$$$filterAux($arg$$34, $arg$$35, $arg$$36, $arg$$37) {\n  MapTreeModule$$$filterAux: while (true) {\n    const comparer$$7 = $arg$$34,\n          f$$4 = $arg$$35,\n          s$$2 = $arg$$36,\n          acc$$5 = $arg$$37;\n\n    switch (s$$2.tag) {\n      case 1:\n        {\n          const v$$7 = s$$2.fields[1];\n          const k$$9 = s$$2.fields[0];\n          return MapTreeModule$$$filter1(comparer$$7, f$$4, k$$9, v$$7, acc$$5);\n        }\n\n      case 2:\n        {\n          const v$$8 = s$$2.fields[1];\n          const r$$6 = s$$2.fields[3];\n          const l$$6 = s$$2.fields[2];\n          const k$$10 = s$$2.fields[0];\n          const acc$$6 = MapTreeModule$$$filterAux(comparer$$7, f$$4, l$$6, acc$$5);\n          const acc$$7 = MapTreeModule$$$filter1(comparer$$7, f$$4, k$$10, v$$8, acc$$6);\n          $arg$$34 = comparer$$7;\n          $arg$$35 = f$$4;\n          $arg$$36 = r$$6;\n          $arg$$37 = acc$$7;\n          continue MapTreeModule$$$filterAux;\n        }\n\n      default:\n        {\n          return acc$$5;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$filter(comparer$$8, f$$5, s$$3) {\n  return MapTreeModule$$$filterAux(comparer$$8, f$$5, s$$3, MapTreeModule$$$empty());\n}\nexport function MapTreeModule$$$spliceOutSuccessor(m$$6) {\n  switch (m$$6.tag) {\n    case 1:\n      {\n        const v2$$5 = m$$6.fields[1];\n        const k2$$6 = m$$6.fields[0];\n        return [k2$$6, v2$$5, new MapTree$00602(0, \"MapEmpty\")];\n      }\n\n    case 2:\n      {\n        const v2$$6 = m$$6.fields[1];\n        const r$$7 = m$$6.fields[3];\n        const l$$7 = m$$6.fields[2];\n        const k2$$7 = m$$6.fields[0];\n\n        if (l$$7.tag === 0) {\n          return [k2$$7, v2$$6, r$$7];\n        } else {\n          const patternInput = MapTreeModule$$$spliceOutSuccessor(l$$7);\n          return [patternInput[0], patternInput[1], MapTreeModule$$$mk(patternInput[2], k2$$7, v2$$6, r$$7)];\n        }\n      }\n\n    default:\n      {\n        throw new Error(\"internal error: Map.spliceOutSuccessor\");\n      }\n  }\n}\nexport function MapTreeModule$$$remove(comparer$$9, k$$11, m$$7) {\n  switch (m$$7.tag) {\n    case 1:\n      {\n        const k2$$8 = m$$7.fields[0];\n        const c$$6 = comparer$$9.Compare(k$$11, k2$$8) | 0;\n\n        if (c$$6 === 0) {\n          return new MapTree$00602(0, \"MapEmpty\");\n        } else {\n          return m$$7;\n        }\n      }\n\n    case 2:\n      {\n        const v2$$7 = m$$7.fields[1];\n        const r$$8 = m$$7.fields[3];\n        const l$$8 = m$$7.fields[2];\n        const k2$$9 = m$$7.fields[0];\n        const c$$7 = comparer$$9.Compare(k$$11, k2$$9) | 0;\n\n        if (c$$7 < 0) {\n          return MapTreeModule$$$rebalance(MapTreeModule$$$remove(comparer$$9, k$$11, l$$8), k2$$9, v2$$7, r$$8);\n        } else if (c$$7 === 0) {\n          const matchValue$$1 = [l$$8, r$$8];\n\n          if (matchValue$$1[0].tag === 0) {\n            return r$$8;\n          } else if (matchValue$$1[1].tag === 0) {\n            return l$$8;\n          } else {\n            const patternInput$$1 = MapTreeModule$$$spliceOutSuccessor(r$$8);\n            return MapTreeModule$$$mk(l$$8, patternInput$$1[0], patternInput$$1[1], patternInput$$1[2]);\n          }\n        } else {\n          return MapTreeModule$$$rebalance(l$$8, k2$$9, v2$$7, MapTreeModule$$$remove(comparer$$9, k$$11, r$$8));\n        }\n      }\n\n    default:\n      {\n        return MapTreeModule$$$empty();\n      }\n  }\n}\nexport function MapTreeModule$$$mem(comparer$$10, k$$12, m$$8) {\n  MapTreeModule$$$mem: while (true) {\n    switch (m$$8.tag) {\n      case 1:\n        {\n          const k2$$10 = m$$8.fields[0];\n          return comparer$$10.Compare(k$$12, k2$$10) === 0;\n        }\n\n      case 2:\n        {\n          const r$$9 = m$$8.fields[3];\n          const l$$9 = m$$8.fields[2];\n          const k2$$11 = m$$8.fields[0];\n          const c$$8 = comparer$$10.Compare(k$$12, k2$$11) | 0;\n\n          if (c$$8 < 0) {\n            const $comparer$$10$$41 = comparer$$10;\n            const $k$$12$$42 = k$$12;\n            comparer$$10 = $comparer$$10$$41;\n            k$$12 = $k$$12$$42;\n            m$$8 = l$$9;\n            continue MapTreeModule$$$mem;\n          } else if (c$$8 === 0) {\n            return true;\n          } else {\n            const $comparer$$10$$43 = comparer$$10;\n            const $k$$12$$44 = k$$12;\n            comparer$$10 = $comparer$$10$$43;\n            k$$12 = $k$$12$$44;\n            m$$8 = r$$9;\n            continue MapTreeModule$$$mem;\n          }\n        }\n\n      default:\n        {\n          return false;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$iter($arg$$45, $arg$$46) {\n  MapTreeModule$$$iter: while (true) {\n    const f$$6 = $arg$$45,\n          m$$9 = $arg$$46;\n\n    switch (m$$9.tag) {\n      case 1:\n        {\n          const v2$$8 = m$$9.fields[1];\n          const k2$$12 = m$$9.fields[0];\n          f$$6(k2$$12, v2$$8);\n          break;\n        }\n\n      case 2:\n        {\n          const v2$$9 = m$$9.fields[1];\n          const r$$10 = m$$9.fields[3];\n          const l$$10 = m$$9.fields[2];\n          const k2$$13 = m$$9.fields[0];\n          MapTreeModule$$$iter(f$$6, l$$10);\n          f$$6(k2$$13, v2$$9);\n          $arg$$45 = f$$6;\n          $arg$$46 = r$$10;\n          continue MapTreeModule$$$iter;\n          break;\n        }\n\n      default:\n        {}\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$tryPick($arg$$47, $arg$$48) {\n  MapTreeModule$$$tryPick: while (true) {\n    const f$$7 = $arg$$47,\n          m$$10 = $arg$$48;\n\n    switch (m$$10.tag) {\n      case 1:\n        {\n          const v2$$10 = m$$10.fields[1];\n          const k2$$14 = m$$10.fields[0];\n          return f$$7(k2$$14, v2$$10);\n        }\n\n      case 2:\n        {\n          const v2$$11 = m$$10.fields[1];\n          const r$$11 = m$$10.fields[3];\n          const l$$11 = m$$10.fields[2];\n          const k2$$15 = m$$10.fields[0];\n          const matchValue$$2 = MapTreeModule$$$tryPick(f$$7, l$$11);\n\n          if (matchValue$$2 == null) {\n            const matchValue$$3 = f$$7(k2$$15, v2$$11);\n\n            if (matchValue$$3 == null) {\n              $arg$$47 = f$$7;\n              $arg$$48 = r$$11;\n              continue MapTreeModule$$$tryPick;\n            } else {\n              const res$$1 = matchValue$$3;\n              return res$$1;\n            }\n          } else {\n            const res = matchValue$$2;\n            return res;\n          }\n        }\n\n      default:\n        {\n          return null;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$exists($arg$$49, $arg$$50) {\n  MapTreeModule$$$exists: while (true) {\n    const f$$8 = $arg$$49,\n          m$$11 = $arg$$50;\n\n    switch (m$$11.tag) {\n      case 1:\n        {\n          const v2$$12 = m$$11.fields[1];\n          const k2$$16 = m$$11.fields[0];\n          return f$$8(k2$$16, v2$$12);\n        }\n\n      case 2:\n        {\n          const v2$$13 = m$$11.fields[1];\n          const r$$12 = m$$11.fields[3];\n          const l$$12 = m$$11.fields[2];\n          const k2$$17 = m$$11.fields[0];\n\n          if (MapTreeModule$$$exists(f$$8, l$$12) ? true : f$$8(k2$$17, v2$$13)) {\n            return true;\n          } else {\n            $arg$$49 = f$$8;\n            $arg$$50 = r$$12;\n            continue MapTreeModule$$$exists;\n          }\n        }\n\n      default:\n        {\n          return false;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$forall($arg$$51, $arg$$52) {\n  MapTreeModule$$$forall: while (true) {\n    const f$$9 = $arg$$51,\n          m$$12 = $arg$$52;\n\n    switch (m$$12.tag) {\n      case 1:\n        {\n          const v2$$14 = m$$12.fields[1];\n          const k2$$18 = m$$12.fields[0];\n          return f$$9(k2$$18, v2$$14);\n        }\n\n      case 2:\n        {\n          const v2$$15 = m$$12.fields[1];\n          const r$$13 = m$$12.fields[3];\n          const l$$13 = m$$12.fields[2];\n          const k2$$19 = m$$12.fields[0];\n\n          if (MapTreeModule$$$forall(f$$9, l$$13) ? f$$9(k2$$19, v2$$15) : false) {\n            $arg$$51 = f$$9;\n            $arg$$52 = r$$13;\n            continue MapTreeModule$$$forall;\n          } else {\n            return false;\n          }\n        }\n\n      default:\n        {\n          return true;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$map(f$$10, m$$13) {\n  switch (m$$13.tag) {\n    case 1:\n      {\n        const v$$9 = m$$13.fields[1];\n        const k$$13 = m$$13.fields[0];\n        return new MapTree$00602(1, \"MapOne\", k$$13, f$$10(v$$9));\n      }\n\n    case 2:\n      {\n        const v$$10 = m$$13.fields[1];\n        const r$$14 = m$$13.fields[3];\n        const l$$14 = m$$13.fields[2];\n        const k$$14 = m$$13.fields[0];\n        const h$$2 = m$$13.fields[4] | 0;\n        const l2 = MapTreeModule$$$map(f$$10, l$$14);\n        const v2$$16 = f$$10(v$$10);\n        const r2 = MapTreeModule$$$map(f$$10, r$$14);\n        return new MapTree$00602(2, \"MapNode\", k$$14, v2$$16, l2, r2, h$$2);\n      }\n\n    default:\n      {\n        return MapTreeModule$$$empty();\n      }\n  }\n}\nexport function MapTreeModule$$$mapi(f$$11, m$$14) {\n  switch (m$$14.tag) {\n    case 1:\n      {\n        const v$$11 = m$$14.fields[1];\n        const k$$15 = m$$14.fields[0];\n        return new MapTree$00602(1, \"MapOne\", k$$15, f$$11(k$$15, v$$11));\n      }\n\n    case 2:\n      {\n        const v$$12 = m$$14.fields[1];\n        const r$$15 = m$$14.fields[3];\n        const l$$15 = m$$14.fields[2];\n        const k$$16 = m$$14.fields[0];\n        const h$$3 = m$$14.fields[4] | 0;\n        const l2$$1 = MapTreeModule$$$mapi(f$$11, l$$15);\n        const v2$$17 = f$$11(k$$16, v$$12);\n        const r2$$1 = MapTreeModule$$$mapi(f$$11, r$$15);\n        return new MapTree$00602(2, \"MapNode\", k$$16, v2$$17, l2$$1, r2$$1, h$$3);\n      }\n\n    default:\n      {\n        return MapTreeModule$$$empty();\n      }\n  }\n}\nexport function MapTreeModule$$$foldBack($arg$$57, $arg$$58, $arg$$59) {\n  MapTreeModule$$$foldBack: while (true) {\n    const f$$12 = $arg$$57,\n          m$$15 = $arg$$58,\n          x$$1 = $arg$$59;\n\n    switch (m$$15.tag) {\n      case 1:\n        {\n          const v$$13 = m$$15.fields[1];\n          const k$$17 = m$$15.fields[0];\n          return f$$12(k$$17, v$$13, x$$1);\n        }\n\n      case 2:\n        {\n          const v$$14 = m$$15.fields[1];\n          const r$$16 = m$$15.fields[3];\n          const l$$16 = m$$15.fields[2];\n          const k$$18 = m$$15.fields[0];\n          const x$$2 = MapTreeModule$$$foldBack(f$$12, r$$16, x$$1);\n          const x$$3 = f$$12(k$$18, v$$14, x$$2);\n          $arg$$57 = f$$12;\n          $arg$$58 = l$$16;\n          $arg$$59 = x$$3;\n          continue MapTreeModule$$$foldBack;\n        }\n\n      default:\n        {\n          return x$$1;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$fold($arg$$60, $arg$$61, $arg$$62) {\n  MapTreeModule$$$fold: while (true) {\n    const f$$13 = $arg$$60,\n          x$$4 = $arg$$61,\n          m$$16 = $arg$$62;\n\n    switch (m$$16.tag) {\n      case 1:\n        {\n          const v$$15 = m$$16.fields[1];\n          const k$$19 = m$$16.fields[0];\n          return f$$13(x$$4, k$$19, v$$15);\n        }\n\n      case 2:\n        {\n          const v$$16 = m$$16.fields[1];\n          const r$$17 = m$$16.fields[3];\n          const l$$17 = m$$16.fields[2];\n          const k$$20 = m$$16.fields[0];\n          const x$$5 = MapTreeModule$$$fold(f$$13, x$$4, l$$17);\n          const x$$6 = f$$13(x$$5, k$$20, v$$16);\n          $arg$$60 = f$$13;\n          $arg$$61 = x$$6;\n          $arg$$62 = r$$17;\n          continue MapTreeModule$$$fold;\n        }\n\n      default:\n        {\n          return x$$4;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$foldFromTo(comparer$$11, lo, hi, f$$14, m$$17, x$$7) {\n  switch (m$$17.tag) {\n    case 1:\n      {\n        const v$$17 = m$$17.fields[1];\n        const k$$21 = m$$17.fields[0];\n        const cLoKey = comparer$$11.Compare(lo, k$$21) | 0;\n        const cKeyHi = comparer$$11.Compare(k$$21, hi) | 0;\n        const x$$8 = (cLoKey <= 0 ? cKeyHi <= 0 : false) ? f$$14(k$$21, v$$17, x$$7) : x$$7;\n        return x$$8;\n      }\n\n    case 2:\n      {\n        const v$$18 = m$$17.fields[1];\n        const r$$18 = m$$17.fields[3];\n        const l$$18 = m$$17.fields[2];\n        const k$$22 = m$$17.fields[0];\n        const cLoKey$$1 = comparer$$11.Compare(lo, k$$22) | 0;\n        const cKeyHi$$1 = comparer$$11.Compare(k$$22, hi) | 0;\n        const x$$9 = cLoKey$$1 < 0 ? MapTreeModule$$$foldFromTo(comparer$$11, lo, hi, f$$14, l$$18, x$$7) : x$$7;\n        const x$$10 = (cLoKey$$1 <= 0 ? cKeyHi$$1 <= 0 : false) ? f$$14(k$$22, v$$18, x$$9) : x$$9;\n        const x$$11 = cKeyHi$$1 < 0 ? MapTreeModule$$$foldFromTo(comparer$$11, lo, hi, f$$14, r$$18, x$$10) : x$$10;\n        return x$$11;\n      }\n\n    default:\n      {\n        return x$$7;\n      }\n  }\n}\nexport function MapTreeModule$$$foldSection(comparer$$12, lo$$1, hi$$1, f$$15, m$$18, x$$12) {\n  if (comparer$$12.Compare(lo$$1, hi$$1) === 1) {\n    return x$$12;\n  } else {\n    return MapTreeModule$$$foldFromTo(comparer$$12, lo$$1, hi$$1, f$$15, m$$18, x$$12);\n  }\n}\nexport function MapTreeModule$$$loop(m$$19, acc$$8) {\n  MapTreeModule$$$loop: while (true) {\n    switch (m$$19.tag) {\n      case 1:\n        {\n          const v$$19 = m$$19.fields[1];\n          const k$$23 = m$$19.fields[0];\n          return new List([k$$23, v$$19], acc$$8);\n        }\n\n      case 2:\n        {\n          const v$$20 = m$$19.fields[1];\n          const r$$19 = m$$19.fields[3];\n          const l$$19 = m$$19.fields[2];\n          const k$$24 = m$$19.fields[0];\n          const $acc$$8$$75 = acc$$8;\n          m$$19 = l$$19;\n          acc$$8 = new List([k$$24, v$$20], MapTreeModule$$$loop(r$$19, $acc$$8$$75));\n          continue MapTreeModule$$$loop;\n        }\n\n      default:\n        {\n          return acc$$8;\n        }\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$toList(m$$20) {\n  return MapTreeModule$$$loop(m$$20, new List());\n}\nexport function MapTreeModule$$$ofList(comparer$$13, l$$20) {\n  return fold$$1(function (acc$$9, tupledArg) {\n    return MapTreeModule$$$add(comparer$$13, tupledArg[0], tupledArg[1], acc$$9);\n  }, MapTreeModule$$$empty(), l$$20);\n}\nexport function MapTreeModule$$$mkFromEnumerator(comparer$$14, acc$$10, e) {\n  MapTreeModule$$$mkFromEnumerator: while (true) {\n    if (e.MoveNext()) {\n      const patternInput$$2 = e.Current;\n      const $acc$$10$$77 = acc$$10;\n      const $comparer$$14$$76 = comparer$$14;\n      const $e$$78 = e;\n      comparer$$14 = $comparer$$14$$76;\n      acc$$10 = MapTreeModule$$$add($comparer$$14$$76, patternInput$$2[0], patternInput$$2[1], $acc$$10$$77);\n      e = $e$$78;\n      continue MapTreeModule$$$mkFromEnumerator;\n    } else {\n      return acc$$10;\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$ofArray(comparer$$15, arr) {\n  let res$$2 = MapTreeModule$$$empty();\n\n  for (let i = 0; i <= arr.length - 1; i++) {\n    const patternInput$$3 = arr[i];\n    res$$2 = MapTreeModule$$$add(comparer$$15, patternInput$$3[0], patternInput$$3[1], res$$2);\n  }\n\n  return res$$2;\n}\nexport function MapTreeModule$$$ofSeq(comparer$$16, c$$9) {\n  const ie = getEnumerator(c$$9);\n\n  try {\n    return MapTreeModule$$$mkFromEnumerator(comparer$$16, MapTreeModule$$$empty(), ie);\n  } finally {\n    if (isDisposable(ie)) {\n      ie.Dispose();\n    }\n  }\n}\nexport function MapTreeModule$$$copyToArray(s$$4, arr$$1, i$$1) {\n  let j = i$$1 | 0;\n  MapTreeModule$$$iter(function f$$16(x$$15, y$$2) {\n    arr$$1[j] = [x$$15, y$$2];\n    j = j + 1;\n  }, s$$4);\n}\nexport const MapTreeModule$002EMapIterator$00602 = declare(function Map_MapTreeModule_MapIterator(arg1, arg2) {\n  this.stack = arg1;\n  this.started = arg2;\n}, Record);\nexport function MapTreeModule$002EMapIterator$00602$reflection($gen$$79, $gen$$80) {\n  return record(\"Map.MapTreeModule.MapIterator`2\", [$gen$$79, $gen$$80], MapTreeModule$002EMapIterator$00602, () => [[\"stack\", list(MapTree$00602$reflection($gen$$79, $gen$$80))], [\"started\", bool]]);\n}\nexport function MapTreeModule$$$collapseLHS(stack) {\n  MapTreeModule$$$collapseLHS: while (true) {\n    if (stack.tail != null) {\n      if (stack.head.tag === 1) {\n        return stack;\n      } else if (stack.head.tag === 2) {\n        const $stack$$81 = stack;\n        stack = new List($stack$$81.head.fields[2], new List(new MapTree$00602(1, \"MapOne\", $stack$$81.head.fields[0], $stack$$81.head.fields[1]), new List($stack$$81.head.fields[3], $stack$$81.tail)));\n        continue MapTreeModule$$$collapseLHS;\n      } else {\n        const $stack$$82 = stack;\n        stack = $stack$$82.tail;\n        continue MapTreeModule$$$collapseLHS;\n      }\n    } else {\n      return new List();\n    }\n\n    break;\n  }\n}\nexport function MapTreeModule$$$mkIterator(s$$5) {\n  return new MapTreeModule$002EMapIterator$00602(MapTreeModule$$$collapseLHS(new List(s$$5, new List())), false);\n}\nexport function MapTreeModule$$$notStarted() {\n  throw new Error(\"enumeration not started\");\n}\nexport function MapTreeModule$$$alreadyFinished() {\n  throw new Error(\"enumeration already finished\");\n}\nexport function MapTreeModule$$$current(i$$2) {\n  if (i$$2.started) {\n    const matchValue$$4 = i$$2.stack;\n\n    if (matchValue$$4.tail == null) {\n      return MapTreeModule$$$alreadyFinished();\n    } else if (matchValue$$4.head.tag === 1) {\n      return [matchValue$$4.head.fields[0], matchValue$$4.head.fields[1]];\n    } else {\n      throw new Error(\"Please report error: Map iterator, unexpected stack for current\");\n    }\n  } else {\n    return MapTreeModule$$$notStarted();\n  }\n}\nexport function MapTreeModule$$$moveNext(i$$3) {\n  if (i$$3.started) {\n    const matchValue$$5 = i$$3.stack;\n\n    if (matchValue$$5.tail == null) {\n      return false;\n    } else if (matchValue$$5.head.tag === 1) {\n      i$$3.stack = MapTreeModule$$$collapseLHS(matchValue$$5.tail);\n      return !(i$$3.stack.tail == null);\n    } else {\n      throw new Error(\"Please report error: Map iterator, unexpected stack for moveNext\");\n    }\n  } else {\n    i$$3.started = true;\n    return !(i$$3.stack.tail == null);\n  }\n}\nexport const MapTreeModule$002EmkIEnumerator$0027$00602 = declare(function Map_MapTreeModule_mkIEnumerator_(s$$6) {\n  const $this$$1 = this;\n  $this$$1.s = s$$6;\n  $this$$1.i = MapTreeModule$$$mkIterator($this$$1.s);\n});\nexport function MapTreeModule$002EmkIEnumerator$0027$00602$reflection($gen$$83, $gen$$84) {\n  return type(\"Map.MapTreeModule.mkIEnumerator'`2\", [$gen$$83, $gen$$84]);\n}\nexport function MapTreeModule$002EmkIEnumerator$0027$00602$$$$002Ector$$Z26BC498C(s$$6) {\n  return this instanceof MapTreeModule$002EmkIEnumerator$0027$00602 ? MapTreeModule$002EmkIEnumerator$0027$00602.call(this, s$$6) : new MapTreeModule$002EmkIEnumerator$0027$00602(s$$6);\n}\nObject.defineProperty(MapTreeModule$002EmkIEnumerator$0027$00602.prototype, \"Current\", {\n  \"get\": function () {\n    const __ = this;\n    return MapTreeModule$$$current(__.i);\n  }\n});\n\nMapTreeModule$002EmkIEnumerator$0027$00602.prototype.MoveNext = function () {\n  const __$$1 = this;\n  return MapTreeModule$$$moveNext(__$$1.i);\n};\n\nMapTreeModule$002EmkIEnumerator$0027$00602.prototype.Reset = function () {\n  const __$$2 = this;\n  __$$2.i = MapTreeModule$$$mkIterator(__$$2.s);\n};\n\nMapTreeModule$002EmkIEnumerator$0027$00602.prototype.Dispose = function () {};\n\nexport function MapTreeModule$$$mkIEnumerator(s$$7) {\n  return MapTreeModule$002EmkIEnumerator$0027$00602$$$$002Ector$$Z26BC498C(s$$7);\n}\nexport function MapTreeModule$$$toSeq(s$$8) {\n  const en = MapTreeModule$$$mkIEnumerator(s$$8);\n  return unfold(function generator(en$$1) {\n    if (en$$1.MoveNext()) {\n      return [en$$1.Current, en$$1];\n    } else {\n      return null;\n    }\n  }, en);\n}\nexport const FSharpMap = declare(function Map_Map(comparer$$17, tree) {\n  const $this$$2 = this;\n  $this$$2.comparer = comparer$$17;\n  $this$$2.tree = tree;\n});\nexport function FSharpMap$reflection($gen$$85, $gen$$86) {\n  return type(\"Map.FSharpMap\", [$gen$$85, $gen$$86]);\n}\nexport function FSharpMap$$$$002Ector$$58ADD115(comparer$$17, tree) {\n  return this instanceof FSharpMap ? FSharpMap.call(this, comparer$$17, tree) : new FSharpMap(comparer$$17, tree);\n}\nexport function FSharpMap$$get_Comparer(__$$4) {\n  return __$$4.comparer;\n}\nexport function FSharpMap$$get_Tree(__$$5) {\n  return __$$5.tree;\n}\nexport function FSharpMap$$Add$$5BDDA1(__$$6, k$$28, v$$24) {\n  return FSharpMap$$$$002Ector$$58ADD115(__$$6.comparer, MapTreeModule$$$add(__$$6.comparer, k$$28, v$$24, __$$6.tree));\n}\nexport function FSharpMap$$get_IsEmpty(__$$7) {\n  return MapTreeModule$$$isEmpty(__$$7.tree);\n}\nexport function FSharpMap$$get_Item$$2B595(__$$8, k$$29) {\n  return MapTreeModule$$$find(__$$8.comparer, k$$29, __$$8.tree);\n}\nexport function FSharpMap$$TryGetValue$$5BDDA1(__$$9, k$$30, defValue) {\n  const matchValue$$6 = MapTreeModule$$$tryFind(__$$9.comparer, k$$30, __$$9.tree);\n\n  if (matchValue$$6 == null) {\n    return [false, defValue];\n  } else {\n    const v$$25 = value$$3(matchValue$$6);\n    return [true, v$$25];\n  }\n}\nexport function FSharpMap$$TryPick$$72321DD7(__$$10, f$$17) {\n  return MapTreeModule$$$tryPick(f$$17, __$$10.tree);\n}\nexport function FSharpMap$$Exists$$Z395DDC35(__$$11, f$$18) {\n  return MapTreeModule$$$exists(f$$18, __$$11.tree);\n}\nexport function FSharpMap$$Filter$$Z395DDC35(__$$12, f$$19) {\n  return FSharpMap$$$$002Ector$$58ADD115(__$$12.comparer, MapTreeModule$$$filter(__$$12.comparer, f$$19, __$$12.tree));\n}\nexport function FSharpMap$$ForAll$$Z395DDC35(__$$13, f$$20) {\n  return MapTreeModule$$$forall(f$$20, __$$13.tree);\n}\nexport function FSharpMap$$Fold(__$$14, f$$21, acc$$11) {\n  return MapTreeModule$$$foldBack(f$$21, __$$14.tree, acc$$11);\n}\nexport function FSharpMap$$FoldSection(__$$15, lo$$2, hi$$2, f$$22, acc$$12) {\n  return MapTreeModule$$$foldSection(__$$15.comparer, lo$$2, hi$$2, f$$22, __$$15.tree, acc$$12);\n}\nexport function FSharpMap$$Iterate$$1DCFB91D(__$$16, f$$23) {\n  MapTreeModule$$$iter(f$$23, __$$16.tree);\n}\nexport function FSharpMap$$MapRange$$6DC7247(__$$17, f$$24) {\n  return FSharpMap$$$$002Ector$$58ADD115(__$$17.comparer, MapTreeModule$$$map(f$$24, __$$17.tree));\n}\nexport function FSharpMap$$Map$$Z6F6B671C(__$$18, f$$25) {\n  return FSharpMap$$$$002Ector$$58ADD115(__$$18.comparer, MapTreeModule$$$mapi(f$$25, __$$18.tree));\n}\nexport function FSharpMap$$Partition$$Z395DDC35(__$$19, f$$26) {\n  const patternInput$$4 = MapTreeModule$$$partition(__$$19.comparer, f$$26, __$$19.tree);\n  return [FSharpMap$$$$002Ector$$58ADD115(__$$19.comparer, patternInput$$4[0]), FSharpMap$$$$002Ector$$58ADD115(__$$19.comparer, patternInput$$4[1])];\n}\nexport function FSharpMap$$get_Count(__$$20) {\n  return MapTreeModule$$$size(__$$20.tree);\n}\nexport function FSharpMap$$ContainsKey$$2B595(__$$21, k$$31) {\n  return MapTreeModule$$$mem(__$$21.comparer, k$$31, __$$21.tree);\n}\nexport function FSharpMap$$Remove$$2B595(__$$22, k$$32) {\n  return FSharpMap$$$$002Ector$$58ADD115(__$$22.comparer, MapTreeModule$$$remove(__$$22.comparer, k$$32, __$$22.tree));\n}\nexport function FSharpMap$$TryFind$$2B595(__$$23, k$$33) {\n  return MapTreeModule$$$tryFind(__$$23.comparer, k$$33, __$$23.tree);\n}\nexport function FSharpMap$$ToList(__$$24) {\n  return MapTreeModule$$$toList(__$$24.tree);\n}\n\nFSharpMap.prototype.toString = function () {\n  const this$ = this;\n  return \"map [\" + join(\"; \", ...map$$1(function mapping(kv) {\n    return toText(printf(\"(%A, %A)\"))(kv[0])(kv[1]);\n  }, this$)) + \"]\";\n};\n\nFSharpMap.prototype.GetHashCode = function () {\n  const this$$$1 = this;\n\n  const combineHash = function combineHash(x$$16, y$$3) {\n    return (x$$16 << 1) + y$$3 + 631;\n  };\n\n  let res$$3 = 0;\n  const e$$1 = MapTreeModule$$$mkIEnumerator(FSharpMap$$get_Tree(this$$$1));\n\n  while (e$$1.MoveNext()) {\n    const patternInput$$5 = e$$1.Current;\n    const activePatternResult3097 = patternInput$$5;\n    res$$3 = combineHash(res$$3, structuralHash(activePatternResult3097[0]));\n    res$$3 = combineHash(res$$3, structuralHash(activePatternResult3097[1]));\n  }\n\n  return Math.abs(res$$3) | 0;\n};\n\nFSharpMap.prototype.Equals = function (that) {\n  const this$$$2 = this;\n  return this$$$2.CompareTo(that) === 0;\n};\n\nFSharpMap.prototype[Symbol.iterator] = function () {\n  const __$$25 = this;\n  return toIterator(MapTreeModule$$$mkIEnumerator(__$$25.tree));\n};\n\nFSharpMap.prototype.CompareTo = function (obj) {\n  const m$$22 = this;\n  const m2 = obj;\n  let res$$4 = 0;\n  let finished = false;\n  const e1 = MapTreeModule$$$mkIEnumerator(FSharpMap$$get_Tree(m$$22));\n\n  try {\n    const e2 = MapTreeModule$$$mkIEnumerator(FSharpMap$$get_Tree(m2));\n\n    try {\n      while (!finished ? res$$4 === 0 : false) {\n        const matchValue$$7 = [e1.MoveNext(), e2.MoveNext()];\n\n        if (matchValue$$7[0]) {\n          if (matchValue$$7[1]) {\n            const kvp1 = e1.Current;\n            const kvp2 = e2.Current;\n            const c$$10 = m$$22.comparer.Compare(kvp1[0], kvp2[0]) | 0;\n            res$$4 = c$$10 !== 0 ? c$$10 : compare(kvp1[1], kvp2[1]);\n          } else {\n            res$$4 = 1;\n          }\n        } else if (matchValue$$7[1]) {\n          res$$4 = -1;\n        } else {\n          finished = true;\n        }\n      }\n\n      return res$$4 | 0;\n    } finally {\n      if (isDisposable(e2)) {\n        e2.Dispose();\n      }\n    }\n  } finally {\n    if (isDisposable(e1)) {\n      e1.Dispose();\n    }\n  }\n};\n\nexport function isEmpty(m$$23) {\n  return FSharpMap$$get_IsEmpty(m$$23);\n}\nexport function add(k$$34, v$$26, m$$24) {\n  return FSharpMap$$Add$$5BDDA1(m$$24, k$$34, v$$26);\n}\nexport function find(k$$35, m$$25) {\n  return FSharpMap$$get_Item$$2B595(m$$25, k$$35);\n}\nexport function tryFind(k$$36, m$$26) {\n  return FSharpMap$$TryFind$$2B595(m$$26, k$$36);\n}\nexport function remove(k$$37, m$$27) {\n  return FSharpMap$$Remove$$2B595(m$$27, k$$37);\n}\nexport function containsKey(k$$38, m$$28) {\n  return FSharpMap$$ContainsKey$$2B595(m$$28, k$$38);\n}\nexport function iterate(f$$27, m$$29) {\n  FSharpMap$$Iterate$$1DCFB91D(m$$29, f$$27);\n}\nexport function tryPick(f$$28, m$$30) {\n  return FSharpMap$$TryPick$$72321DD7(m$$30, f$$28);\n}\nexport function pick(f$$29, m$$31) {\n  const matchValue$$8 = tryPick(f$$29, m$$31);\n\n  if (matchValue$$8 != null) {\n    const res$$5 = value$$3(matchValue$$8);\n    return res$$5;\n  } else {\n    throw new Error(\"key not found\");\n  }\n}\nexport function exists(f$$30, m$$32) {\n  return FSharpMap$$Exists$$Z395DDC35(m$$32, f$$30);\n}\nexport function filter(f$$31, m$$33) {\n  return FSharpMap$$Filter$$Z395DDC35(m$$33, f$$31);\n}\nexport function partition(f$$32, m$$34) {\n  return FSharpMap$$Partition$$Z395DDC35(m$$34, f$$32);\n}\nexport function forAll(f$$33, m$$35) {\n  return FSharpMap$$ForAll$$Z395DDC35(m$$35, f$$33);\n}\nexport function mapRange(f$$34, m$$36) {\n  return FSharpMap$$MapRange$$6DC7247(m$$36, f$$34);\n}\nexport function map(f$$35, m$$37) {\n  return FSharpMap$$Map$$Z6F6B671C(m$$37, f$$35);\n}\nexport function fold(f$$36, z, m$$38) {\n  return MapTreeModule$$$fold(f$$36, z, FSharpMap$$get_Tree(m$$38));\n}\nexport function foldBack(f$$37, m$$39, z$$1) {\n  return MapTreeModule$$$foldBack(f$$37, FSharpMap$$get_Tree(m$$39), z$$1);\n}\nexport function toSeq(m$$40) {\n  return MapTreeModule$$$toSeq(FSharpMap$$get_Tree(m$$40));\n}\nexport function findKey(f$$38, m$$41) {\n  const _arg1$$1 = MapTreeModule$$$tryPick(function f$$39(k$$39, v$$27) {\n    if (f$$38(k$$39, v$$27)) {\n      return some(k$$39);\n    } else {\n      return null;\n    }\n  }, FSharpMap$$get_Tree(m$$41));\n\n  if (_arg1$$1 == null) {\n    throw new Error(\"Key not found\");\n  } else {\n    const k$$40 = value$$3(_arg1$$1);\n    return k$$40;\n  }\n}\nexport function tryFindKey(f$$40, m$$43) {\n  return MapTreeModule$$$tryPick(function f$$41(k$$41, v$$28) {\n    if (f$$40(k$$41, v$$28)) {\n      return some(k$$41);\n    } else {\n      return null;\n    }\n  }, FSharpMap$$get_Tree(m$$43));\n}\nexport function ofList(l$$22, comparer$$18) {\n  return FSharpMap$$$$002Ector$$58ADD115(comparer$$18, MapTreeModule$$$ofList(comparer$$18, l$$22));\n}\nexport function ofSeq(l$$23, comparer$$19) {\n  return FSharpMap$$$$002Ector$$58ADD115(comparer$$19, MapTreeModule$$$ofSeq(comparer$$19, l$$23));\n}\nexport function ofArray(array, comparer$$20) {\n  return FSharpMap$$$$002Ector$$58ADD115(comparer$$20, MapTreeModule$$$ofArray(comparer$$20, array));\n}\nexport function toList(m$$45) {\n  return FSharpMap$$ToList(m$$45);\n}\nexport function toArray(m$$46) {\n  const res$$6 = new Array(FSharpMap$$get_Count(m$$46));\n  MapTreeModule$$$copyToArray(FSharpMap$$get_Tree(m$$46), res$$6, 0);\n  return res$$6;\n}\nexport function empty(comparer$$21) {\n  return FSharpMap$$$$002Ector$$58ADD115(comparer$$21, new MapTree$00602(0, \"MapEmpty\"));\n}\n\nfunction createMutablePrivate(comparer$$22, tree$0027) {\n  let tree$$1 = tree$0027;\n  return {\n    get size() {\n      return MapTreeModule$$$size(tree$$1);\n    },\n\n    clear() {\n      tree$$1 = new MapTree$00602(0, \"MapEmpty\");\n    },\n\n    delete(x$$18) {\n      if (MapTreeModule$$$mem(comparer$$22, x$$18, tree$$1)) {\n        tree$$1 = MapTreeModule$$$remove(comparer$$22, x$$18, tree$$1);\n        return true;\n      } else {\n        return false;\n      }\n    },\n\n    entries() {\n      return MapTreeModule$$$toSeq(tree$$1);\n    },\n\n    get(k$$42) {\n      return MapTreeModule$$$find(comparer$$22, k$$42, tree$$1);\n    },\n\n    has(x$$19) {\n      return MapTreeModule$$$mem(comparer$$22, x$$19, tree$$1);\n    },\n\n    keys() {\n      return map$$1(function mapping$$1(kv$$1) {\n        return kv$$1[0];\n      }, MapTreeModule$$$toSeq(tree$$1));\n    },\n\n    set(k$$43, v$$29) {\n      const this$$$3 = this;\n      tree$$1 = MapTreeModule$$$add(comparer$$22, k$$43, v$$29, tree$$1);\n      return this$$$3;\n    },\n\n    values() {\n      return map$$1(function mapping$$2(kv$$2) {\n        return kv$$2[1];\n      }, MapTreeModule$$$toSeq(tree$$1));\n    },\n\n    [Symbol.iterator]() {\n      return toIterator(MapTreeModule$$$mkIEnumerator(tree$$1));\n    },\n\n    GetEnumerator() {\n      return MapTreeModule$$$mkIEnumerator(tree$$1);\n    }\n\n  };\n}\n\nexport function createMutable(source$$3, comparer$$23) {\n  return createMutablePrivate(comparer$$23, MapTreeModule$$$ofSeq(comparer$$23, source$$3));\n}\nexport function groupBy(projection, xs, comparer$$24) {\n  const dict = createMutable(empty$$1(), comparer$$24);\n  iterate$$1(function (v$$30) {\n    const key = projection(v$$30);\n\n    if (dict.has(key)) {\n      dict.get(key).push(v$$30);\n    } else {\n      dict.set(key, Array.from([v$$30])), null;\n    }\n  }, xs);\n  return map$$1(function mapping$$3(kv$$3) {\n    return [kv$$3[0], kv$$3[1]];\n  }, dict);\n}\nexport function countBy(projection$$1, xs$$1, comparer$$25) {\n  const dict$$1 = createMutable(empty$$1(), comparer$$25);\n  iterate$$1(function (value$$1) {\n    const key$$1 = projection$$1(value$$1);\n    dict$$1.has(key$$1) ? dict$$1.set(key$$1, dict$$1.get(key$$1) + 1) : dict$$1.set(key$$1, 1), null;\n  }, xs$$1);\n  return map$$1(function mapping$$4(kv$$4) {\n    return [kv$$4[0], kv$$4[1]];\n  }, dict$$1);\n}\nexport function count(m$$47) {\n  return FSharpMap$$get_Count(m$$47);\n}","import { List, Record, declare, Union } from \"./Types.js\";\nimport { type, record, bool, list, union as union$$1, int32 } from \"./Reflection.js\";\nimport { value as value$$2, some, Choice } from \"./Option.js\";\nimport { iterate as iterate$$1, empty as empty$$1, fold as fold$$1, toIterator, map as map$$1, reduce, getEnumerator, unfold } from \"./Seq.js\";\nimport { structuralHash, isDisposable } from \"./Util.js\";\nimport { join } from \"./String.js\";\nexport const SetTree$00601 = declare(function Set_SetTree(tag, name, ...fields) {\n  Union.call(this, tag, name, ...fields);\n}, Union);\nexport function SetTree$00601$reflection($gen$$3) {\n  return union$$1(\"Set.SetTree`1\", [$gen$$3], SetTree$00601, () => [\"SetEmpty\", [\"SetNode\", [$gen$$3, SetTree$00601$reflection($gen$$3), SetTree$00601$reflection($gen$$3), int32]], [\"SetOne\", [$gen$$3]]]);\n}\nexport function SetTreeModule$$$countAux(s, acc) {\n  SetTreeModule$$$countAux: while (true) {\n    switch (s.tag) {\n      case 2:\n        {\n          return acc + 1 | 0;\n        }\n\n      case 0:\n        {\n          return acc | 0;\n        }\n\n      default:\n        {\n          const r = s.fields[2];\n          const l = s.fields[1];\n          const $acc$$4 = acc;\n          s = l;\n          acc = SetTreeModule$$$countAux(r, $acc$$4 + 1);\n          continue SetTreeModule$$$countAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$count(s$$1) {\n  return SetTreeModule$$$countAux(s$$1, 0);\n}\nexport function SetTreeModule$$$SetOne(n) {\n  return new SetTree$00601(2, \"SetOne\", n);\n}\nexport function SetTreeModule$$$SetNode(x, l$$1, r$$1, h) {\n  return new SetTree$00601(1, \"SetNode\", x, l$$1, r$$1, h);\n}\nexport function SetTreeModule$$$height(t) {\n  switch (t.tag) {\n    case 2:\n      {\n        return 1;\n      }\n\n    case 1:\n      {\n        const h$$1 = t.fields[3] | 0;\n        return h$$1 | 0;\n      }\n\n    default:\n      {\n        return 0;\n      }\n  }\n}\nexport const SetTreeModule$$$tolerance = 2;\nexport function SetTreeModule$$$mk(l$$2, k, r$$2) {\n  const matchValue = [l$$2, r$$2];\n  var $target$$5;\n\n  if (matchValue[0].tag === 0) {\n    if (matchValue[1].tag === 0) {\n      $target$$5 = 0;\n    } else {\n      $target$$5 = 1;\n    }\n  } else {\n    $target$$5 = 1;\n  }\n\n  switch ($target$$5) {\n    case 0:\n      {\n        return SetTreeModule$$$SetOne(k);\n      }\n\n    case 1:\n      {\n        const hl = SetTreeModule$$$height(l$$2) | 0;\n        const hr = SetTreeModule$$$height(r$$2) | 0;\n        const m = (hl < hr ? hr : hl) | 0;\n        return SetTreeModule$$$SetNode(k, l$$2, r$$2, m + 1);\n      }\n  }\n}\nexport function SetTreeModule$$$rebalance(t1, k$$1, t2) {\n  const t1h = SetTreeModule$$$height(t1) | 0;\n  const t2h = SetTreeModule$$$height(t2) | 0;\n\n  if (t2h > t1h + SetTreeModule$$$tolerance) {\n    if (t2.tag === 1) {\n      const t2r = t2.fields[2];\n      const t2l = t2.fields[1];\n      const t2k = t2.fields[0];\n\n      if (SetTreeModule$$$height(t2l) > t1h + 1) {\n        if (t2l.tag === 1) {\n          const t2lr = t2l.fields[2];\n          const t2ll = t2l.fields[1];\n          const t2lk = t2l.fields[0];\n          return SetTreeModule$$$mk(SetTreeModule$$$mk(t1, k$$1, t2ll), t2lk, SetTreeModule$$$mk(t2lr, t2k, t2r));\n        } else {\n          throw new Error(\"rebalance\");\n        }\n      } else {\n        return SetTreeModule$$$mk(SetTreeModule$$$mk(t1, k$$1, t2l), t2k, t2r);\n      }\n    } else {\n      throw new Error(\"rebalance\");\n    }\n  } else if (t1h > t2h + SetTreeModule$$$tolerance) {\n    if (t1.tag === 1) {\n      const t1r = t1.fields[2];\n      const t1l = t1.fields[1];\n      const t1k = t1.fields[0];\n\n      if (SetTreeModule$$$height(t1r) > t2h + 1) {\n        if (t1r.tag === 1) {\n          const t1rr = t1r.fields[2];\n          const t1rl = t1r.fields[1];\n          const t1rk = t1r.fields[0];\n          return SetTreeModule$$$mk(SetTreeModule$$$mk(t1l, t1k, t1rl), t1rk, SetTreeModule$$$mk(t1rr, k$$1, t2));\n        } else {\n          throw new Error(\"rebalance\");\n        }\n      } else {\n        return SetTreeModule$$$mk(t1l, t1k, SetTreeModule$$$mk(t1r, k$$1, t2));\n      }\n    } else {\n      throw new Error(\"rebalance\");\n    }\n  } else {\n    return SetTreeModule$$$mk(t1, k$$1, t2);\n  }\n}\nexport function SetTreeModule$$$add(comparer, k$$2, t$$1) {\n  switch (t$$1.tag) {\n    case 2:\n      {\n        const k2$$1 = t$$1.fields[0];\n        const c$$1 = comparer.Compare(k$$2, k2$$1) | 0;\n\n        if (c$$1 < 0) {\n          return SetTreeModule$$$SetNode(k$$2, new SetTree$00601(0, \"SetEmpty\"), t$$1, 2);\n        } else if (c$$1 === 0) {\n          return t$$1;\n        } else {\n          return SetTreeModule$$$SetNode(k$$2, t$$1, new SetTree$00601(0, \"SetEmpty\"), 2);\n        }\n      }\n\n    case 0:\n      {\n        return SetTreeModule$$$SetOne(k$$2);\n      }\n\n    default:\n      {\n        const r$$3 = t$$1.fields[2];\n        const l$$3 = t$$1.fields[1];\n        const k2 = t$$1.fields[0];\n        const c = comparer.Compare(k$$2, k2) | 0;\n\n        if (c < 0) {\n          return SetTreeModule$$$rebalance(SetTreeModule$$$add(comparer, k$$2, l$$3), k2, r$$3);\n        } else if (c === 0) {\n          return t$$1;\n        } else {\n          return SetTreeModule$$$rebalance(l$$3, k2, SetTreeModule$$$add(comparer, k$$2, r$$3));\n        }\n      }\n  }\n}\nexport function SetTreeModule$$$balance(comparer$$1, t1$$1, k$$3, t2$$1) {\n  const matchValue$$1 = [t1$$1, t2$$1];\n  var $target$$6, t2$$2, t1$$2, k1, t2$$3, k2$$2, t1$$3, h1, h2, k1$$1, k2$$3, t11, t12, t21, t22;\n\n  if (matchValue$$1[0].tag === 2) {\n    if (matchValue$$1[1].tag === 0) {\n      $target$$6 = 1;\n      t1$$2 = matchValue$$1[0];\n    } else if (matchValue$$1[1].tag === 2) {\n      $target$$6 = 2;\n      k1 = matchValue$$1[0].fields[0];\n      t2$$3 = matchValue$$1[1];\n    } else {\n      $target$$6 = 2;\n      k1 = matchValue$$1[0].fields[0];\n      t2$$3 = matchValue$$1[1];\n    }\n  } else if (matchValue$$1[0].tag === 1) {\n    if (matchValue$$1[1].tag === 2) {\n      $target$$6 = 3;\n      k2$$2 = matchValue$$1[1].fields[0];\n      t1$$3 = matchValue$$1[0];\n    } else if (matchValue$$1[1].tag === 1) {\n      $target$$6 = 4;\n      h1 = matchValue$$1[0].fields[3];\n      h2 = matchValue$$1[1].fields[3];\n      k1$$1 = matchValue$$1[0].fields[0];\n      k2$$3 = matchValue$$1[1].fields[0];\n      t11 = matchValue$$1[0].fields[1];\n      t12 = matchValue$$1[0].fields[2];\n      t21 = matchValue$$1[1].fields[1];\n      t22 = matchValue$$1[1].fields[2];\n    } else {\n      $target$$6 = 1;\n      t1$$2 = matchValue$$1[0];\n    }\n  } else {\n    $target$$6 = 0;\n    t2$$2 = matchValue$$1[1];\n  }\n\n  switch ($target$$6) {\n    case 0:\n      {\n        return SetTreeModule$$$add(comparer$$1, k$$3, t2$$2);\n      }\n\n    case 1:\n      {\n        return SetTreeModule$$$add(comparer$$1, k$$3, t1$$2);\n      }\n\n    case 2:\n      {\n        return SetTreeModule$$$add(comparer$$1, k$$3, SetTreeModule$$$add(comparer$$1, k1, t2$$3));\n      }\n\n    case 3:\n      {\n        return SetTreeModule$$$add(comparer$$1, k$$3, SetTreeModule$$$add(comparer$$1, k2$$2, t1$$3));\n      }\n\n    case 4:\n      {\n        if (h1 + SetTreeModule$$$tolerance < h2) {\n          return SetTreeModule$$$rebalance(SetTreeModule$$$balance(comparer$$1, t1$$1, k$$3, t21), k2$$3, t22);\n        } else if (h2 + SetTreeModule$$$tolerance < h1) {\n          return SetTreeModule$$$rebalance(t11, k1$$1, SetTreeModule$$$balance(comparer$$1, t12, k$$3, t2$$1));\n        } else {\n          return SetTreeModule$$$mk(t1$$1, k$$3, t2$$1);\n        }\n      }\n  }\n}\nexport function SetTreeModule$$$split(comparer$$2, pivot, t$$2) {\n  switch (t$$2.tag) {\n    case 2:\n      {\n        const k1$$3 = t$$2.fields[0];\n        const c$$3 = comparer$$2.Compare(k1$$3, pivot) | 0;\n\n        if (c$$3 < 0) {\n          return [t$$2, false, new SetTree$00601(0, \"SetEmpty\")];\n        } else if (c$$3 === 0) {\n          return [new SetTree$00601(0, \"SetEmpty\"), true, new SetTree$00601(0, \"SetEmpty\")];\n        } else {\n          return [new SetTree$00601(0, \"SetEmpty\"), false, t$$2];\n        }\n      }\n\n    case 0:\n      {\n        return [new SetTree$00601(0, \"SetEmpty\"), false, new SetTree$00601(0, \"SetEmpty\")];\n      }\n\n    default:\n      {\n        const t12$$1 = t$$2.fields[2];\n        const t11$$1 = t$$2.fields[1];\n        const k1$$2 = t$$2.fields[0];\n        const c$$2 = comparer$$2.Compare(pivot, k1$$2) | 0;\n\n        if (c$$2 < 0) {\n          const patternInput = SetTreeModule$$$split(comparer$$2, pivot, t11$$1);\n          return [patternInput[0], patternInput[1], SetTreeModule$$$balance(comparer$$2, patternInput[2], k1$$2, t12$$1)];\n        } else if (c$$2 === 0) {\n          return [t11$$1, true, t12$$1];\n        } else {\n          const patternInput$$1 = SetTreeModule$$$split(comparer$$2, pivot, t12$$1);\n          return [SetTreeModule$$$balance(comparer$$2, t11$$1, k1$$2, patternInput$$1[0]), patternInput$$1[1], patternInput$$1[2]];\n        }\n      }\n  }\n}\nexport function SetTreeModule$$$spliceOutSuccessor(t$$3) {\n  switch (t$$3.tag) {\n    case 2:\n      {\n        const k2$$4 = t$$3.fields[0];\n        return [k2$$4, new SetTree$00601(0, \"SetEmpty\")];\n      }\n\n    case 1:\n      {\n        const r$$4 = t$$3.fields[2];\n        const l$$4 = t$$3.fields[1];\n        const k2$$5 = t$$3.fields[0];\n\n        if (l$$4.tag === 0) {\n          return [k2$$5, r$$4];\n        } else {\n          const patternInput$$2 = SetTreeModule$$$spliceOutSuccessor(l$$4);\n          return [patternInput$$2[0], SetTreeModule$$$mk(patternInput$$2[1], k2$$5, r$$4)];\n        }\n      }\n\n    default:\n      {\n        throw new Error(\"internal error: Set.spliceOutSuccessor\");\n      }\n  }\n}\nexport function SetTreeModule$$$remove(comparer$$3, k$$4, t$$4) {\n  switch (t$$4.tag) {\n    case 2:\n      {\n        const k2$$6 = t$$4.fields[0];\n        const c$$4 = comparer$$3.Compare(k$$4, k2$$6) | 0;\n\n        if (c$$4 === 0) {\n          return new SetTree$00601(0, \"SetEmpty\");\n        } else {\n          return t$$4;\n        }\n      }\n\n    case 1:\n      {\n        const r$$5 = t$$4.fields[2];\n        const l$$5 = t$$4.fields[1];\n        const k2$$7 = t$$4.fields[0];\n        const c$$5 = comparer$$3.Compare(k$$4, k2$$7) | 0;\n\n        if (c$$5 < 0) {\n          return SetTreeModule$$$rebalance(SetTreeModule$$$remove(comparer$$3, k$$4, l$$5), k2$$7, r$$5);\n        } else if (c$$5 === 0) {\n          const matchValue$$2 = [l$$5, r$$5];\n\n          if (matchValue$$2[0].tag === 0) {\n            return r$$5;\n          } else if (matchValue$$2[1].tag === 0) {\n            return l$$5;\n          } else {\n            const patternInput$$3 = SetTreeModule$$$spliceOutSuccessor(r$$5);\n            return SetTreeModule$$$mk(l$$5, patternInput$$3[0], patternInput$$3[1]);\n          }\n        } else {\n          return SetTreeModule$$$rebalance(l$$5, k2$$7, SetTreeModule$$$remove(comparer$$3, k$$4, r$$5));\n        }\n      }\n\n    default:\n      {\n        return t$$4;\n      }\n  }\n}\nexport function SetTreeModule$$$mem(comparer$$4, k$$5, t$$5) {\n  SetTreeModule$$$mem: while (true) {\n    switch (t$$5.tag) {\n      case 2:\n        {\n          const k2$$9 = t$$5.fields[0];\n          return comparer$$4.Compare(k$$5, k2$$9) === 0;\n        }\n\n      case 0:\n        {\n          return false;\n        }\n\n      default:\n        {\n          const r$$6 = t$$5.fields[2];\n          const l$$6 = t$$5.fields[1];\n          const k2$$8 = t$$5.fields[0];\n          const c$$6 = comparer$$4.Compare(k$$5, k2$$8) | 0;\n\n          if (c$$6 < 0) {\n            const $comparer$$4$$7 = comparer$$4;\n            const $k$$5$$8 = k$$5;\n            comparer$$4 = $comparer$$4$$7;\n            k$$5 = $k$$5$$8;\n            t$$5 = l$$6;\n            continue SetTreeModule$$$mem;\n          } else if (c$$6 === 0) {\n            return true;\n          } else {\n            const $comparer$$4$$9 = comparer$$4;\n            const $k$$5$$10 = k$$5;\n            comparer$$4 = $comparer$$4$$9;\n            k$$5 = $k$$5$$10;\n            t$$5 = r$$6;\n            continue SetTreeModule$$$mem;\n          }\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$iter($arg$$11, $arg$$12) {\n  SetTreeModule$$$iter: while (true) {\n    const f = $arg$$11,\n          t$$6 = $arg$$12;\n\n    switch (t$$6.tag) {\n      case 2:\n        {\n          const k2$$11 = t$$6.fields[0];\n          f(k2$$11);\n          break;\n        }\n\n      case 0:\n        {\n          break;\n        }\n\n      default:\n        {\n          const r$$7 = t$$6.fields[2];\n          const l$$7 = t$$6.fields[1];\n          const k2$$10 = t$$6.fields[0];\n          SetTreeModule$$$iter(f, l$$7);\n          f(k2$$10);\n          $arg$$11 = f;\n          $arg$$12 = r$$7;\n          continue SetTreeModule$$$iter;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$foldBack($arg$$13, $arg$$14, $arg$$15) {\n  SetTreeModule$$$foldBack: while (true) {\n    const f$$1 = $arg$$13,\n          m$$1 = $arg$$14,\n          x$$1 = $arg$$15;\n\n    switch (m$$1.tag) {\n      case 2:\n        {\n          const k$$7 = m$$1.fields[0];\n          return f$$1(k$$7, x$$1);\n        }\n\n      case 0:\n        {\n          return x$$1;\n        }\n\n      default:\n        {\n          const r$$8 = m$$1.fields[2];\n          const l$$8 = m$$1.fields[1];\n          const k$$6 = m$$1.fields[0];\n          $arg$$13 = f$$1;\n          $arg$$14 = l$$8;\n          $arg$$15 = f$$1(k$$6, SetTreeModule$$$foldBack(f$$1, r$$8, x$$1));\n          continue SetTreeModule$$$foldBack;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$fold($arg$$16, $arg$$17, $arg$$18) {\n  SetTreeModule$$$fold: while (true) {\n    const f$$2 = $arg$$16,\n          x$$2 = $arg$$17,\n          m$$2 = $arg$$18;\n\n    switch (m$$2.tag) {\n      case 2:\n        {\n          const k$$9 = m$$2.fields[0];\n          return f$$2(x$$2, k$$9);\n        }\n\n      case 0:\n        {\n          return x$$2;\n        }\n\n      default:\n        {\n          const r$$9 = m$$2.fields[2];\n          const l$$9 = m$$2.fields[1];\n          const k$$8 = m$$2.fields[0];\n          const x$$3 = SetTreeModule$$$fold(f$$2, x$$2, l$$9);\n          const x$$4 = f$$2(x$$3, k$$8);\n          $arg$$16 = f$$2;\n          $arg$$17 = x$$4;\n          $arg$$18 = r$$9;\n          continue SetTreeModule$$$fold;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$forall($arg$$19, $arg$$20) {\n  SetTreeModule$$$forall: while (true) {\n    const f$$3 = $arg$$19,\n          m$$3 = $arg$$20;\n\n    switch (m$$3.tag) {\n      case 2:\n        {\n          const k2$$13 = m$$3.fields[0];\n          return f$$3(k2$$13);\n        }\n\n      case 0:\n        {\n          return true;\n        }\n\n      default:\n        {\n          const r$$10 = m$$3.fields[2];\n          const l$$10 = m$$3.fields[1];\n          const k2$$12 = m$$3.fields[0];\n\n          if (f$$3(k2$$12) ? SetTreeModule$$$forall(f$$3, l$$10) : false) {\n            $arg$$19 = f$$3;\n            $arg$$20 = r$$10;\n            continue SetTreeModule$$$forall;\n          } else {\n            return false;\n          }\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$exists($arg$$21, $arg$$22) {\n  SetTreeModule$$$exists: while (true) {\n    const f$$4 = $arg$$21,\n          m$$4 = $arg$$22;\n\n    switch (m$$4.tag) {\n      case 2:\n        {\n          const k2$$15 = m$$4.fields[0];\n          return f$$4(k2$$15);\n        }\n\n      case 0:\n        {\n          return false;\n        }\n\n      default:\n        {\n          const r$$11 = m$$4.fields[2];\n          const l$$11 = m$$4.fields[1];\n          const k2$$14 = m$$4.fields[0];\n\n          if (f$$4(k2$$14) ? true : SetTreeModule$$$exists(f$$4, l$$11)) {\n            return true;\n          } else {\n            $arg$$21 = f$$4;\n            $arg$$22 = r$$11;\n            continue SetTreeModule$$$exists;\n          }\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$isEmpty(m$$5) {\n  if (m$$5.tag === 0) {\n    return true;\n  } else {\n    return false;\n  }\n}\nexport function SetTreeModule$$$subset(comparer$$5, a, b) {\n  return SetTreeModule$$$forall(function (x$$5) {\n    return SetTreeModule$$$mem(comparer$$5, x$$5, b);\n  }, a);\n}\nexport function SetTreeModule$$$psubset(comparer$$6, a$$1, b$$1) {\n  if (SetTreeModule$$$forall(function (x$$6) {\n    return SetTreeModule$$$mem(comparer$$6, x$$6, b$$1);\n  }, a$$1)) {\n    return SetTreeModule$$$exists(function (x$$7) {\n      return !SetTreeModule$$$mem(comparer$$6, x$$7, a$$1);\n    }, b$$1);\n  } else {\n    return false;\n  }\n}\nexport function SetTreeModule$$$filterAux($arg$$23, $arg$$24, $arg$$25, $arg$$26) {\n  SetTreeModule$$$filterAux: while (true) {\n    const comparer$$7 = $arg$$23,\n          f$$5 = $arg$$24,\n          s$$2 = $arg$$25,\n          acc$$1 = $arg$$26;\n\n    switch (s$$2.tag) {\n      case 2:\n        {\n          const k$$11 = s$$2.fields[0];\n\n          if (f$$5(k$$11)) {\n            return SetTreeModule$$$add(comparer$$7, k$$11, acc$$1);\n          } else {\n            return acc$$1;\n          }\n        }\n\n      case 0:\n        {\n          return acc$$1;\n        }\n\n      default:\n        {\n          const r$$12 = s$$2.fields[2];\n          const l$$12 = s$$2.fields[1];\n          const k$$10 = s$$2.fields[0];\n          const acc$$2 = f$$5(k$$10) ? SetTreeModule$$$add(comparer$$7, k$$10, acc$$1) : acc$$1;\n          $arg$$23 = comparer$$7;\n          $arg$$24 = f$$5;\n          $arg$$25 = l$$12;\n          $arg$$26 = SetTreeModule$$$filterAux(comparer$$7, f$$5, r$$12, acc$$2);\n          continue SetTreeModule$$$filterAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$filter(comparer$$8, f$$6, s$$3) {\n  return SetTreeModule$$$filterAux(comparer$$8, f$$6, s$$3, new SetTree$00601(0, \"SetEmpty\"));\n}\nexport function SetTreeModule$$$diffAux(comparer$$9, m$$6, acc$$3) {\n  SetTreeModule$$$diffAux: while (true) {\n    switch (m$$6.tag) {\n      case 2:\n        {\n          const k$$13 = m$$6.fields[0];\n          return SetTreeModule$$$remove(comparer$$9, k$$13, acc$$3);\n        }\n\n      case 0:\n        {\n          return acc$$3;\n        }\n\n      default:\n        {\n          const r$$13 = m$$6.fields[2];\n          const l$$13 = m$$6.fields[1];\n          const k$$12 = m$$6.fields[0];\n          const $acc$$3$$31 = acc$$3;\n          const $comparer$$9$$30 = comparer$$9;\n          comparer$$9 = $comparer$$9$$30;\n          m$$6 = l$$13;\n          acc$$3 = SetTreeModule$$$diffAux($comparer$$9$$30, r$$13, SetTreeModule$$$remove($comparer$$9$$30, k$$12, $acc$$3$$31));\n          continue SetTreeModule$$$diffAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$diff(comparer$$10, a$$2, b$$2) {\n  return SetTreeModule$$$diffAux(comparer$$10, b$$2, a$$2);\n}\nexport function SetTreeModule$$$union(comparer$$11, t1$$4, t2$$4) {\n  const matchValue$$3 = [t1$$4, t2$$4];\n  var $target$$32, h1$$1, h2$$1, k1$$4, k2$$16, t11$$2, t12$$2, t21$$1, t22$$1, t$$7, t$$8, k1$$5, t2$$5, k2$$17, t1$$5;\n\n  if (matchValue$$3[0].tag === 0) {\n    $target$$32 = 1;\n    t$$7 = matchValue$$3[1];\n  } else if (matchValue$$3[0].tag === 2) {\n    if (matchValue$$3[1].tag === 0) {\n      $target$$32 = 2;\n      t$$8 = matchValue$$3[0];\n    } else if (matchValue$$3[1].tag === 2) {\n      $target$$32 = 3;\n      k1$$5 = matchValue$$3[0].fields[0];\n      t2$$5 = matchValue$$3[1];\n    } else {\n      $target$$32 = 3;\n      k1$$5 = matchValue$$3[0].fields[0];\n      t2$$5 = matchValue$$3[1];\n    }\n  } else if (matchValue$$3[1].tag === 0) {\n    $target$$32 = 2;\n    t$$8 = matchValue$$3[0];\n  } else if (matchValue$$3[1].tag === 2) {\n    $target$$32 = 4;\n    k2$$17 = matchValue$$3[1].fields[0];\n    t1$$5 = matchValue$$3[0];\n  } else {\n    $target$$32 = 0;\n    h1$$1 = matchValue$$3[0].fields[3];\n    h2$$1 = matchValue$$3[1].fields[3];\n    k1$$4 = matchValue$$3[0].fields[0];\n    k2$$16 = matchValue$$3[1].fields[0];\n    t11$$2 = matchValue$$3[0].fields[1];\n    t12$$2 = matchValue$$3[0].fields[2];\n    t21$$1 = matchValue$$3[1].fields[1];\n    t22$$1 = matchValue$$3[1].fields[2];\n  }\n\n  switch ($target$$32) {\n    case 0:\n      {\n        if (h1$$1 > h2$$1) {\n          const patternInput$$4 = SetTreeModule$$$split(comparer$$11, k1$$4, t2$$4);\n          return SetTreeModule$$$balance(comparer$$11, SetTreeModule$$$union(comparer$$11, t11$$2, patternInput$$4[0]), k1$$4, SetTreeModule$$$union(comparer$$11, t12$$2, patternInput$$4[2]));\n        } else {\n          const patternInput$$5 = SetTreeModule$$$split(comparer$$11, k2$$16, t1$$4);\n          return SetTreeModule$$$balance(comparer$$11, SetTreeModule$$$union(comparer$$11, t21$$1, patternInput$$5[0]), k2$$16, SetTreeModule$$$union(comparer$$11, t22$$1, patternInput$$5[2]));\n        }\n      }\n\n    case 1:\n      {\n        return t$$7;\n      }\n\n    case 2:\n      {\n        return t$$8;\n      }\n\n    case 3:\n      {\n        return SetTreeModule$$$add(comparer$$11, k1$$5, t2$$5);\n      }\n\n    case 4:\n      {\n        return SetTreeModule$$$add(comparer$$11, k2$$17, t1$$5);\n      }\n  }\n}\nexport function SetTreeModule$$$intersectionAux(comparer$$12, b$$3, m$$7, acc$$4) {\n  SetTreeModule$$$intersectionAux: while (true) {\n    switch (m$$7.tag) {\n      case 2:\n        {\n          const k$$15 = m$$7.fields[0];\n\n          if (SetTreeModule$$$mem(comparer$$12, k$$15, b$$3)) {\n            return SetTreeModule$$$add(comparer$$12, k$$15, acc$$4);\n          } else {\n            return acc$$4;\n          }\n        }\n\n      case 0:\n        {\n          return acc$$4;\n        }\n\n      default:\n        {\n          const r$$14 = m$$7.fields[2];\n          const l$$14 = m$$7.fields[1];\n          const k$$14 = m$$7.fields[0];\n          const acc$$5 = SetTreeModule$$$intersectionAux(comparer$$12, b$$3, r$$14, acc$$4);\n          const acc$$6 = SetTreeModule$$$mem(comparer$$12, k$$14, b$$3) ? SetTreeModule$$$add(comparer$$12, k$$14, acc$$5) : acc$$5;\n          const $b$$3$$34 = b$$3;\n          const $comparer$$12$$33 = comparer$$12;\n          comparer$$12 = $comparer$$12$$33;\n          b$$3 = $b$$3$$34;\n          m$$7 = l$$14;\n          acc$$4 = acc$$6;\n          continue SetTreeModule$$$intersectionAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$intersection(comparer$$13, a$$3, b$$4) {\n  return SetTreeModule$$$intersectionAux(comparer$$13, b$$4, a$$3, new SetTree$00601(0, \"SetEmpty\"));\n}\nexport function SetTreeModule$$$partition1(comparer$$14, f$$7, k$$16, acc1, acc2) {\n  if (f$$7(k$$16)) {\n    return [SetTreeModule$$$add(comparer$$14, k$$16, acc1), acc2];\n  } else {\n    return [acc1, SetTreeModule$$$add(comparer$$14, k$$16, acc2)];\n  }\n}\nexport function SetTreeModule$$$partitionAux($arg$$40, $arg$$41, $arg$$42, $arg$$43, $arg$$44) {\n  SetTreeModule$$$partitionAux: while (true) {\n    const comparer$$15 = $arg$$40,\n          f$$8 = $arg$$41,\n          s$$4 = $arg$$42,\n          acc_0 = $arg$$43,\n          acc_1 = $arg$$44;\n    const acc$$7 = [acc_0, acc_1];\n\n    switch (s$$4.tag) {\n      case 2:\n        {\n          const k$$18 = s$$4.fields[0];\n          return SetTreeModule$$$partition1(comparer$$15, f$$8, k$$18, acc$$7[0], acc$$7[1]);\n        }\n\n      case 0:\n        {\n          return acc$$7;\n        }\n\n      default:\n        {\n          const r$$15 = s$$4.fields[2];\n          const l$$15 = s$$4.fields[1];\n          const k$$17 = s$$4.fields[0];\n          const acc$$8 = SetTreeModule$$$partitionAux(comparer$$15, f$$8, r$$15, acc$$7[0], acc$$7[1]);\n          const acc$$9 = SetTreeModule$$$partition1(comparer$$15, f$$8, k$$17, acc$$8[0], acc$$8[1]);\n          $arg$$40 = comparer$$15;\n          $arg$$41 = f$$8;\n          $arg$$42 = l$$15;\n          $arg$$43 = acc$$9[0];\n          $arg$$44 = acc$$9[1];\n          continue SetTreeModule$$$partitionAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$partition(comparer$$16, f$$9, s$$5) {\n  const seed = [new SetTree$00601(0, \"SetEmpty\"), new SetTree$00601(0, \"SetEmpty\")];\n  return SetTreeModule$$$partitionAux(comparer$$16, f$$9, s$$5, seed[0], seed[1]);\n}\nexport function SetTreeModule$$$$007CMatchSetNode$007CMatchSetEmpty$007C(s$$6) {\n  switch (s$$6.tag) {\n    case 2:\n      {\n        const k2$$19 = s$$6.fields[0];\n        return new Choice(0, \"Choice1Of2\", [k2$$19, new SetTree$00601(0, \"SetEmpty\"), new SetTree$00601(0, \"SetEmpty\")]);\n      }\n\n    case 0:\n      {\n        return new Choice(1, \"Choice2Of2\", null);\n      }\n\n    default:\n      {\n        const r$$16 = s$$6.fields[2];\n        const l$$16 = s$$6.fields[1];\n        const k2$$18 = s$$6.fields[0];\n        return new Choice(0, \"Choice1Of2\", [k2$$18, l$$16, r$$16]);\n      }\n  }\n}\nexport function SetTreeModule$$$minimumElementAux(s$$7, n$$1) {\n  SetTreeModule$$$minimumElementAux: while (true) {\n    switch (s$$7.tag) {\n      case 2:\n        {\n          const k$$20 = s$$7.fields[0];\n          return k$$20;\n        }\n\n      case 0:\n        {\n          return n$$1;\n        }\n\n      default:\n        {\n          const l$$17 = s$$7.fields[1];\n          const k$$19 = s$$7.fields[0];\n          s$$7 = l$$17;\n          n$$1 = k$$19;\n          continue SetTreeModule$$$minimumElementAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$minimumElementOpt(s$$8) {\n  switch (s$$8.tag) {\n    case 2:\n      {\n        const k$$22 = s$$8.fields[0];\n        return some(k$$22);\n      }\n\n    case 0:\n      {\n        return null;\n      }\n\n    default:\n      {\n        const l$$18 = s$$8.fields[1];\n        const k$$21 = s$$8.fields[0];\n        return some(SetTreeModule$$$minimumElementAux(l$$18, k$$21));\n      }\n  }\n}\nexport function SetTreeModule$$$maximumElementAux(s$$9, n$$2) {\n  SetTreeModule$$$maximumElementAux: while (true) {\n    switch (s$$9.tag) {\n      case 2:\n        {\n          const k$$24 = s$$9.fields[0];\n          return k$$24;\n        }\n\n      case 0:\n        {\n          return n$$2;\n        }\n\n      default:\n        {\n          const r$$17 = s$$9.fields[2];\n          const k$$23 = s$$9.fields[0];\n          s$$9 = r$$17;\n          n$$2 = k$$23;\n          continue SetTreeModule$$$maximumElementAux;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$maximumElementOpt(s$$10) {\n  switch (s$$10.tag) {\n    case 2:\n      {\n        const k$$26 = s$$10.fields[0];\n        return some(k$$26);\n      }\n\n    case 0:\n      {\n        return null;\n      }\n\n    default:\n      {\n        const r$$18 = s$$10.fields[2];\n        const k$$25 = s$$10.fields[0];\n        return some(SetTreeModule$$$maximumElementAux(r$$18, k$$25));\n      }\n  }\n}\nexport function SetTreeModule$$$minimumElement(s$$11) {\n  const matchValue$$4 = SetTreeModule$$$minimumElementOpt(s$$11);\n\n  if (matchValue$$4 == null) {\n    throw new Error(\"Set contains no elements\");\n  } else {\n    const k$$27 = value$$2(matchValue$$4);\n    return k$$27;\n  }\n}\nexport function SetTreeModule$$$maximumElement(s$$12) {\n  const matchValue$$5 = SetTreeModule$$$maximumElementOpt(s$$12);\n\n  if (matchValue$$5 == null) {\n    throw new Error(\"Set contains no elements\");\n  } else {\n    const k$$28 = value$$2(matchValue$$5);\n    return k$$28;\n  }\n}\nexport const SetTreeModule$002ESetIterator$00601 = declare(function Set_SetTreeModule_SetIterator(arg1, arg2) {\n  this.stack = arg1;\n  this.started = arg2;\n}, Record);\nexport function SetTreeModule$002ESetIterator$00601$reflection($gen$$48) {\n  return record(\"Set.SetTreeModule.SetIterator`1\", [$gen$$48], SetTreeModule$002ESetIterator$00601, () => [[\"stack\", list(SetTree$00601$reflection($gen$$48))], [\"started\", bool]]);\n}\nexport function SetTreeModule$$$collapseLHS(stack) {\n  SetTreeModule$$$collapseLHS: while (true) {\n    if (stack.tail != null) {\n      if (stack.head.tag === 2) {\n        return stack;\n      } else if (stack.head.tag === 1) {\n        const $stack$$49 = stack;\n        stack = new List($stack$$49.head.fields[1], new List(SetTreeModule$$$SetOne($stack$$49.head.fields[0]), new List($stack$$49.head.fields[2], $stack$$49.tail)));\n        continue SetTreeModule$$$collapseLHS;\n      } else {\n        const $stack$$50 = stack;\n        stack = $stack$$50.tail;\n        continue SetTreeModule$$$collapseLHS;\n      }\n    } else {\n      return new List();\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$mkIterator(s$$13) {\n  return new SetTreeModule$002ESetIterator$00601(SetTreeModule$$$collapseLHS(new List(s$$13, new List())), false);\n}\nexport function SetTreeModule$$$notStarted() {\n  throw new Error(\"Enumeration not started\");\n}\nexport function SetTreeModule$$$alreadyFinished() {\n  throw new Error(\"Enumeration already started\");\n}\nexport function SetTreeModule$$$current(i) {\n  if (i.started) {\n    const matchValue$$6 = i.stack;\n\n    if (matchValue$$6.tail == null) {\n      return SetTreeModule$$$alreadyFinished();\n    } else if (matchValue$$6.head.tag === 2) {\n      return matchValue$$6.head.fields[0];\n    } else {\n      throw new Error(\"Please report error: Set iterator, unexpected stack for current\");\n    }\n  } else {\n    return SetTreeModule$$$notStarted();\n  }\n}\nexport function SetTreeModule$$$moveNext(i$$1) {\n  if (i$$1.started) {\n    const matchValue$$7 = i$$1.stack;\n\n    if (matchValue$$7.tail == null) {\n      return false;\n    } else if (matchValue$$7.head.tag === 2) {\n      i$$1.stack = SetTreeModule$$$collapseLHS(matchValue$$7.tail);\n      return !(i$$1.stack.tail == null);\n    } else {\n      throw new Error(\"Please report error: Set iterator, unexpected stack for moveNext\");\n    }\n  } else {\n    i$$1.started = true;\n    return !(i$$1.stack.tail == null);\n  }\n}\nexport const SetTreeModule$002EmkIEnumerator$00601 = declare(function Set_SetTreeModule_mkIEnumerator(s$$14) {\n  const $this$$1 = this;\n  $this$$1.s = s$$14;\n  $this$$1.i = SetTreeModule$$$mkIterator($this$$1.s);\n});\nexport function SetTreeModule$002EmkIEnumerator$00601$reflection($gen$$51) {\n  return type(\"Set.SetTreeModule.mkIEnumerator`1\", [$gen$$51]);\n}\nexport function SetTreeModule$002EmkIEnumerator$00601$$$$002Ector$$Z5B395D56(s$$14) {\n  return this instanceof SetTreeModule$002EmkIEnumerator$00601 ? SetTreeModule$002EmkIEnumerator$00601.call(this, s$$14) : new SetTreeModule$002EmkIEnumerator$00601(s$$14);\n}\nObject.defineProperty(SetTreeModule$002EmkIEnumerator$00601.prototype, \"Current\", {\n  \"get\": function () {\n    const __ = this;\n    return SetTreeModule$$$current(__.i);\n  }\n});\n\nSetTreeModule$002EmkIEnumerator$00601.prototype.MoveNext = function () {\n  const __$$1 = this;\n  return SetTreeModule$$$moveNext(__$$1.i);\n};\n\nSetTreeModule$002EmkIEnumerator$00601.prototype.Reset = function () {\n  const __$$2 = this;\n  __$$2.i = SetTreeModule$$$mkIterator(__$$2.s);\n};\n\nSetTreeModule$002EmkIEnumerator$00601.prototype.Dispose = function () {};\n\nexport function SetTreeModule$$$mkIEnumerator(s$$15) {\n  return SetTreeModule$002EmkIEnumerator$00601$$$$002Ector$$Z5B395D56(s$$15);\n}\nexport function SetTreeModule$$$toSeq(s$$16) {\n  const en = SetTreeModule$$$mkIEnumerator(s$$16);\n  return unfold(function generator(en$$1) {\n    if (en$$1.MoveNext()) {\n      return [en$$1.Current, en$$1];\n    } else {\n      return null;\n    }\n  }, en);\n}\nexport function SetTreeModule$$$compareStacks(comparer$$17, l1, l2) {\n  SetTreeModule$$$compareStacks: while (true) {\n    const matchValue$$8 = [l1, l2];\n    var $target$$52, t1$$6, t2$$6, n1k, n2k, t1$$7, t2$$7, n1k$$1, n2k$$1, n2r, t1$$8, t2$$8, emp, n1k$$2, n1r, n2k$$2, t1$$9, t2$$9, n1k$$3, n1r$$1, n2k$$3, n2r$$1, t1$$10, t2$$10, n1k$$4, t1$$11, n1k$$5, n1l, n1r$$2, t1$$12, n2k$$4, t2$$11, n2k$$5, n2l, n2r$$2, t2$$12;\n\n    if (matchValue$$8[0].tail != null) {\n      if (matchValue$$8[1].tail != null) {\n        if (matchValue$$8[1].head.tag === 2) {\n          if (matchValue$$8[0].head.tag === 2) {\n            $target$$52 = 4;\n            n1k = matchValue$$8[0].head.fields[0];\n            n2k = matchValue$$8[1].head.fields[0];\n            t1$$7 = matchValue$$8[0].tail;\n            t2$$7 = matchValue$$8[1].tail;\n          } else if (matchValue$$8[0].head.tag === 1) {\n            if (matchValue$$8[0].head.fields[1].tag === 0) {\n              $target$$52 = 6;\n              emp = matchValue$$8[0].head.fields[1];\n              n1k$$2 = matchValue$$8[0].head.fields[0];\n              n1r = matchValue$$8[0].head.fields[2];\n              n2k$$2 = matchValue$$8[1].head.fields[0];\n              t1$$9 = matchValue$$8[0].tail;\n              t2$$9 = matchValue$$8[1].tail;\n            } else {\n              $target$$52 = 9;\n              n1k$$5 = matchValue$$8[0].head.fields[0];\n              n1l = matchValue$$8[0].head.fields[1];\n              n1r$$2 = matchValue$$8[0].head.fields[2];\n              t1$$12 = matchValue$$8[0].tail;\n            }\n          } else {\n            $target$$52 = 10;\n            n2k$$4 = matchValue$$8[1].head.fields[0];\n            t2$$11 = matchValue$$8[1].tail;\n          }\n        } else if (matchValue$$8[1].head.tag === 1) {\n          if (matchValue$$8[1].head.fields[1].tag === 0) {\n            if (matchValue$$8[0].head.tag === 2) {\n              $target$$52 = 5;\n              n1k$$1 = matchValue$$8[0].head.fields[0];\n              n2k$$1 = matchValue$$8[1].head.fields[0];\n              n2r = matchValue$$8[1].head.fields[2];\n              t1$$8 = matchValue$$8[0].tail;\n              t2$$8 = matchValue$$8[1].tail;\n            } else if (matchValue$$8[0].head.tag === 1) {\n              if (matchValue$$8[0].head.fields[1].tag === 0) {\n                $target$$52 = 7;\n                n1k$$3 = matchValue$$8[0].head.fields[0];\n                n1r$$1 = matchValue$$8[0].head.fields[2];\n                n2k$$3 = matchValue$$8[1].head.fields[0];\n                n2r$$1 = matchValue$$8[1].head.fields[2];\n                t1$$10 = matchValue$$8[0].tail;\n                t2$$10 = matchValue$$8[1].tail;\n              } else {\n                $target$$52 = 9;\n                n1k$$5 = matchValue$$8[0].head.fields[0];\n                n1l = matchValue$$8[0].head.fields[1];\n                n1r$$2 = matchValue$$8[0].head.fields[2];\n                t1$$12 = matchValue$$8[0].tail;\n              }\n            } else {\n              $target$$52 = 11;\n              n2k$$5 = matchValue$$8[1].head.fields[0];\n              n2l = matchValue$$8[1].head.fields[1];\n              n2r$$2 = matchValue$$8[1].head.fields[2];\n              t2$$12 = matchValue$$8[1].tail;\n            }\n          } else if (matchValue$$8[0].head.tag === 2) {\n            $target$$52 = 8;\n            n1k$$4 = matchValue$$8[0].head.fields[0];\n            t1$$11 = matchValue$$8[0].tail;\n          } else if (matchValue$$8[0].head.tag === 1) {\n            $target$$52 = 9;\n            n1k$$5 = matchValue$$8[0].head.fields[0];\n            n1l = matchValue$$8[0].head.fields[1];\n            n1r$$2 = matchValue$$8[0].head.fields[2];\n            t1$$12 = matchValue$$8[0].tail;\n          } else {\n            $target$$52 = 11;\n            n2k$$5 = matchValue$$8[1].head.fields[0];\n            n2l = matchValue$$8[1].head.fields[1];\n            n2r$$2 = matchValue$$8[1].head.fields[2];\n            t2$$12 = matchValue$$8[1].tail;\n          }\n        } else if (matchValue$$8[0].head.tag === 2) {\n          $target$$52 = 8;\n          n1k$$4 = matchValue$$8[0].head.fields[0];\n          t1$$11 = matchValue$$8[0].tail;\n        } else if (matchValue$$8[0].head.tag === 1) {\n          $target$$52 = 9;\n          n1k$$5 = matchValue$$8[0].head.fields[0];\n          n1l = matchValue$$8[0].head.fields[1];\n          n1r$$2 = matchValue$$8[0].head.fields[2];\n          t1$$12 = matchValue$$8[0].tail;\n        } else {\n          $target$$52 = 3;\n          t1$$6 = matchValue$$8[0].tail;\n          t2$$6 = matchValue$$8[1].tail;\n        }\n      } else {\n        $target$$52 = 2;\n      }\n    } else if (matchValue$$8[1].tail != null) {\n      $target$$52 = 1;\n    } else {\n      $target$$52 = 0;\n    }\n\n    switch ($target$$52) {\n      case 0:\n        {\n          return 0;\n        }\n\n      case 1:\n        {\n          return -1 | 0;\n        }\n\n      case 2:\n        {\n          return 1;\n        }\n\n      case 3:\n        {\n          const $comparer$$17$$53 = comparer$$17;\n          comparer$$17 = $comparer$$17$$53;\n          l1 = t1$$6;\n          l2 = t2$$6;\n          continue SetTreeModule$$$compareStacks;\n        }\n\n      case 4:\n        {\n          const c$$7 = comparer$$17.Compare(n1k, n2k) | 0;\n\n          if (c$$7 !== 0) {\n            return c$$7 | 0;\n          } else {\n            const $comparer$$17$$54 = comparer$$17;\n            comparer$$17 = $comparer$$17$$54;\n            l1 = t1$$7;\n            l2 = t2$$7;\n            continue SetTreeModule$$$compareStacks;\n          }\n        }\n\n      case 5:\n        {\n          const c$$8 = comparer$$17.Compare(n1k$$1, n2k$$1) | 0;\n\n          if (c$$8 !== 0) {\n            return c$$8 | 0;\n          } else {\n            const $comparer$$17$$55 = comparer$$17;\n            comparer$$17 = $comparer$$17$$55;\n            l1 = new List(new SetTree$00601(0, \"SetEmpty\"), t1$$8);\n            l2 = new List(n2r, t2$$8);\n            continue SetTreeModule$$$compareStacks;\n          }\n        }\n\n      case 6:\n        {\n          const c$$9 = comparer$$17.Compare(n1k$$2, n2k$$2) | 0;\n\n          if (c$$9 !== 0) {\n            return c$$9 | 0;\n          } else {\n            const $comparer$$17$$56 = comparer$$17;\n            comparer$$17 = $comparer$$17$$56;\n            l1 = new List(n1r, t1$$9);\n            l2 = new List(emp, t2$$9);\n            continue SetTreeModule$$$compareStacks;\n          }\n        }\n\n      case 7:\n        {\n          const c$$10 = comparer$$17.Compare(n1k$$3, n2k$$3) | 0;\n\n          if (c$$10 !== 0) {\n            return c$$10 | 0;\n          } else {\n            const $comparer$$17$$57 = comparer$$17;\n            comparer$$17 = $comparer$$17$$57;\n            l1 = new List(n1r$$1, t1$$10);\n            l2 = new List(n2r$$1, t2$$10);\n            continue SetTreeModule$$$compareStacks;\n          }\n        }\n\n      case 8:\n        {\n          const $comparer$$17$$58 = comparer$$17;\n          const $l2$$59 = l2;\n          comparer$$17 = $comparer$$17$$58;\n          l1 = new List(new SetTree$00601(0, \"SetEmpty\"), new List(SetTreeModule$$$SetOne(n1k$$4), t1$$11));\n          l2 = $l2$$59;\n          continue SetTreeModule$$$compareStacks;\n        }\n\n      case 9:\n        {\n          const $comparer$$17$$60 = comparer$$17;\n          const $l2$$61 = l2;\n          comparer$$17 = $comparer$$17$$60;\n          l1 = new List(n1l, new List(SetTreeModule$$$SetNode(n1k$$5, new SetTree$00601(0, \"SetEmpty\"), n1r$$2, 0), t1$$12));\n          l2 = $l2$$61;\n          continue SetTreeModule$$$compareStacks;\n        }\n\n      case 10:\n        {\n          const $comparer$$17$$62 = comparer$$17;\n          const $l1$$63 = l1;\n          comparer$$17 = $comparer$$17$$62;\n          l1 = $l1$$63;\n          l2 = new List(new SetTree$00601(0, \"SetEmpty\"), new List(SetTreeModule$$$SetOne(n2k$$4), t2$$11));\n          continue SetTreeModule$$$compareStacks;\n        }\n\n      case 11:\n        {\n          const $comparer$$17$$64 = comparer$$17;\n          const $l1$$65 = l1;\n          comparer$$17 = $comparer$$17$$64;\n          l1 = $l1$$65;\n          l2 = new List(n2l, new List(SetTreeModule$$$SetNode(n2k$$5, new SetTree$00601(0, \"SetEmpty\"), n2r$$2, 0), t2$$12));\n          continue SetTreeModule$$$compareStacks;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$compare(comparer$$18, s1, s2) {\n  const matchValue$$9 = [s1, s2];\n\n  if (matchValue$$9[0].tag === 0) {\n    if (matchValue$$9[1].tag === 0) {\n      return 0;\n    } else {\n      return -1 | 0;\n    }\n  } else if (matchValue$$9[1].tag === 0) {\n    return 1;\n  } else {\n    return SetTreeModule$$$compareStacks(comparer$$18, new List(s1, new List()), new List(s2, new List())) | 0;\n  }\n}\nexport function SetTreeModule$$$choose(s$$17) {\n  return SetTreeModule$$$minimumElement(s$$17);\n}\nexport function SetTreeModule$$$loop(m$$8, acc$$10) {\n  SetTreeModule$$$loop: while (true) {\n    switch (m$$8.tag) {\n      case 2:\n        {\n          const k$$32 = m$$8.fields[0];\n          return new List(k$$32, acc$$10);\n        }\n\n      case 0:\n        {\n          return acc$$10;\n        }\n\n      default:\n        {\n          const r$$20 = m$$8.fields[2];\n          const l$$20 = m$$8.fields[1];\n          const k$$31 = m$$8.fields[0];\n          const $acc$$10$$66 = acc$$10;\n          m$$8 = l$$20;\n          acc$$10 = new List(k$$31, SetTreeModule$$$loop(r$$20, $acc$$10$$66));\n          continue SetTreeModule$$$loop;\n        }\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$toList(s$$18) {\n  return SetTreeModule$$$loop(s$$18, new List());\n}\nexport function SetTreeModule$$$copyToArray(s$$19, arr, i$$2) {\n  let j = i$$2 | 0;\n  SetTreeModule$$$iter(function (x$$8) {\n    arr[j] = x$$8;\n    j = j + 1;\n  }, s$$19);\n}\nexport function SetTreeModule$$$mkFromEnumerator(comparer$$19, acc$$11, e) {\n  SetTreeModule$$$mkFromEnumerator: while (true) {\n    if (e.MoveNext()) {\n      const $acc$$11$$68 = acc$$11;\n      const $comparer$$19$$67 = comparer$$19;\n      const $e$$69 = e;\n      comparer$$19 = $comparer$$19$$67;\n      acc$$11 = SetTreeModule$$$add($comparer$$19$$67, $e$$69.Current, $acc$$11$$68);\n      e = $e$$69;\n      continue SetTreeModule$$$mkFromEnumerator;\n    } else {\n      return acc$$11;\n    }\n\n    break;\n  }\n}\nexport function SetTreeModule$$$ofSeq(comparer$$20, c$$11) {\n  const ie = getEnumerator(c$$11);\n\n  try {\n    return SetTreeModule$$$mkFromEnumerator(comparer$$20, new SetTree$00601(0, \"SetEmpty\"), ie);\n  } finally {\n    if (isDisposable(ie)) {\n      ie.Dispose();\n    }\n  }\n}\nexport function SetTreeModule$$$ofArray(comparer$$21, arr$$1) {\n  let acc$$12 = new SetTree$00601(0, \"SetEmpty\");\n\n  for (let i$$3 = 0; i$$3 <= arr$$1.length - 1; i$$3++) {\n    acc$$12 = SetTreeModule$$$add(comparer$$21, arr$$1[i$$3], acc$$12);\n  }\n\n  return acc$$12;\n}\nexport const FSharpSet = declare(function Set_Set(comparer$$22, tree) {\n  const $this$$2 = this;\n  $this$$2.comparer = comparer$$22;\n  $this$$2.tree = tree;\n});\nexport function FSharpSet$reflection($gen$$70) {\n  return type(\"Set.FSharpSet\", [$gen$$70]);\n}\nexport function FSharpSet$$$$002Ector$$2528C5CB(comparer$$22, tree) {\n  return this instanceof FSharpSet ? FSharpSet.call(this, comparer$$22, tree) : new FSharpSet(comparer$$22, tree);\n}\nexport function FSharpSet$$get_Comparer(__$$4) {\n  return __$$4.comparer;\n}\nexport function FSharpSet$$get_Tree(__$$5) {\n  return __$$5.tree;\n}\nexport function FSharpSet$$Add$$2B595(s$$20, x$$9) {\n  return FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(s$$20), SetTreeModule$$$add(FSharpSet$$get_Comparer(s$$20), x$$9, FSharpSet$$get_Tree(s$$20)));\n}\nexport function FSharpSet$$Remove$$2B595(s$$21, x$$10) {\n  return FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(s$$21), SetTreeModule$$$remove(FSharpSet$$get_Comparer(s$$21), x$$10, FSharpSet$$get_Tree(s$$21)));\n}\nexport function FSharpSet$$get_Count(s$$22) {\n  return SetTreeModule$$$count(FSharpSet$$get_Tree(s$$22));\n}\nexport function FSharpSet$$Contains$$2B595(s$$23, x$$11) {\n  return SetTreeModule$$$mem(FSharpSet$$get_Comparer(s$$23), x$$11, FSharpSet$$get_Tree(s$$23));\n}\nexport function FSharpSet$$Iterate$$5028453F(s$$24, x$$12) {\n  SetTreeModule$$$iter(x$$12, FSharpSet$$get_Tree(s$$24));\n}\nexport function FSharpSet$$Fold(s$$25, f$$10, z) {\n  return SetTreeModule$$$fold(function (x$$13, z$$1) {\n    return f$$10(z$$1, x$$13);\n  }, z, FSharpSet$$get_Tree(s$$25));\n}\nexport function FSharpSet$$get_IsEmpty(s$$26) {\n  return SetTreeModule$$$isEmpty(FSharpSet$$get_Tree(s$$26));\n}\nexport function FSharpSet$$Partition$$Z1D55A0D7(s$$27, f$$11) {\n  if (FSharpSet$$get_Tree(s$$27).tag === 0) {\n    return [s$$27, s$$27];\n  } else {\n    const patternInput$$6 = SetTreeModule$$$partition(FSharpSet$$get_Comparer(s$$27), f$$11, FSharpSet$$get_Tree(s$$27));\n    return [FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(s$$27), patternInput$$6[0]), FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(s$$27), patternInput$$6[1])];\n  }\n}\nexport function FSharpSet$$Filter$$Z1D55A0D7(s$$28, f$$12) {\n  if (FSharpSet$$get_Tree(s$$28).tag === 0) {\n    return s$$28;\n  } else {\n    return FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(s$$28), SetTreeModule$$$filter(FSharpSet$$get_Comparer(s$$28), f$$12, FSharpSet$$get_Tree(s$$28)));\n  }\n}\nexport function FSharpSet$$Map$$38806891(s$$29, f$$13, comparer$$23) {\n  return FSharpSet$$$$002Ector$$2528C5CB(comparer$$23, SetTreeModule$$$fold(function (acc$$13, k$$33) {\n    return SetTreeModule$$$add(comparer$$23, f$$13(k$$33), acc$$13);\n  }, new SetTree$00601(0, \"SetEmpty\"), FSharpSet$$get_Tree(s$$29)));\n}\nexport function FSharpSet$$Exists$$Z1D55A0D7(s$$30, f$$14) {\n  return SetTreeModule$$$exists(f$$14, FSharpSet$$get_Tree(s$$30));\n}\nexport function FSharpSet$$ForAll$$Z1D55A0D7(s$$31, f$$15) {\n  return SetTreeModule$$$forall(f$$15, FSharpSet$$get_Tree(s$$31));\n}\nexport function FSharpSet$$$op_Subtraction(a$$4, b$$5) {\n  if (FSharpSet$$get_Tree(a$$4).tag === 0) {\n    return a$$4;\n  } else if (FSharpSet$$get_Tree(b$$5).tag === 0) {\n    return a$$4;\n  } else {\n    return FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(a$$4), SetTreeModule$$$diff(FSharpSet$$get_Comparer(a$$4), FSharpSet$$get_Tree(a$$4), FSharpSet$$get_Tree(b$$5)));\n  }\n}\nexport function FSharpSet$$$op_Addition(a$$5, b$$6) {\n  if (FSharpSet$$get_Tree(b$$6).tag === 0) {\n    return a$$5;\n  } else if (FSharpSet$$get_Tree(a$$5).tag === 0) {\n    return b$$6;\n  } else {\n    return FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(a$$5), SetTreeModule$$$union(FSharpSet$$get_Comparer(a$$5), FSharpSet$$get_Tree(a$$5), FSharpSet$$get_Tree(b$$6)));\n  }\n}\nexport function FSharpSet$$$Intersection$$Z3BE9BFE0(a$$6, b$$7) {\n  if (FSharpSet$$get_Tree(b$$7).tag === 0) {\n    return b$$7;\n  } else if (FSharpSet$$get_Tree(a$$6).tag === 0) {\n    return a$$6;\n  } else {\n    return FSharpSet$$$$002Ector$$2528C5CB(FSharpSet$$get_Comparer(a$$6), SetTreeModule$$$intersection(FSharpSet$$get_Comparer(a$$6), FSharpSet$$get_Tree(a$$6), FSharpSet$$get_Tree(b$$7)));\n  }\n}\nexport function FSharpSet$$$IntersectionMany$$Z15B59630(sets) {\n  return reduce(FSharpSet$$$Intersection$$Z3BE9BFE0, sets);\n}\nexport function FSharpSet$$$Equality$$Z3BE9BFE0(a$$7, b$$8) {\n  return SetTreeModule$$$compare(FSharpSet$$get_Comparer(a$$7), FSharpSet$$get_Tree(a$$7), FSharpSet$$get_Tree(b$$8)) === 0;\n}\nexport function FSharpSet$$$Compare$$Z3BE9BFE0(a$$8, b$$9) {\n  return SetTreeModule$$$compare(FSharpSet$$get_Comparer(a$$8), FSharpSet$$get_Tree(a$$8), FSharpSet$$get_Tree(b$$9));\n}\nexport function FSharpSet$$get_Choose(x$$14) {\n  return SetTreeModule$$$choose(FSharpSet$$get_Tree(x$$14));\n}\nexport function FSharpSet$$get_MinimumElement(x$$15) {\n  return SetTreeModule$$$minimumElement(FSharpSet$$get_Tree(x$$15));\n}\nexport function FSharpSet$$get_MaximumElement(x$$16) {\n  return SetTreeModule$$$maximumElement(FSharpSet$$get_Tree(x$$16));\n}\nexport function FSharpSet$$IsSubsetOf$$6A20B1FF(x$$17, y) {\n  return SetTreeModule$$$subset(FSharpSet$$get_Comparer(x$$17), FSharpSet$$get_Tree(x$$17), FSharpSet$$get_Tree(y));\n}\nexport function FSharpSet$$IsSupersetOf$$6A20B1FF(x$$18, y$$1) {\n  return SetTreeModule$$$subset(FSharpSet$$get_Comparer(x$$18), FSharpSet$$get_Tree(y$$1), FSharpSet$$get_Tree(x$$18));\n}\nexport function FSharpSet$$IsProperSubsetOf$$6A20B1FF(x$$19, y$$2) {\n  return SetTreeModule$$$psubset(FSharpSet$$get_Comparer(x$$19), FSharpSet$$get_Tree(x$$19), FSharpSet$$get_Tree(y$$2));\n}\nexport function FSharpSet$$IsProperSupersetOf$$6A20B1FF(x$$20, y$$3) {\n  return SetTreeModule$$$psubset(FSharpSet$$get_Comparer(x$$20), FSharpSet$$get_Tree(y$$3), FSharpSet$$get_Tree(x$$20));\n}\n\nFSharpSet.prototype.toString = function () {\n  const this$ = this;\n  return \"set [\" + join(\"; \", ...map$$1(String, this$)) + \"]\";\n};\n\nFSharpSet.prototype.GetHashCode = function () {\n  const this$$$1 = this;\n\n  const combineHash = function combineHash(x$$22, y$$4) {\n    return (x$$22 << 1) + y$$4 + 631;\n  };\n\n  let res = 0;\n  const e$$1 = SetTreeModule$$$mkIEnumerator(FSharpSet$$get_Tree(this$$$1));\n\n  while (e$$1.MoveNext()) {\n    res = combineHash(res, structuralHash(e$$1.Current));\n  }\n\n  return Math.abs(res) | 0;\n};\n\nFSharpSet.prototype.Equals = function (that) {\n  const this$$$2 = this;\n  return SetTreeModule$$$compare(FSharpSet$$get_Comparer(this$$$2), FSharpSet$$get_Tree(this$$$2), FSharpSet$$get_Tree(that)) === 0;\n};\n\nFSharpSet.prototype.CompareTo = function (that$$1) {\n  const this$$$3 = this;\n  return SetTreeModule$$$compare(FSharpSet$$get_Comparer(this$$$3), FSharpSet$$get_Tree(this$$$3), FSharpSet$$get_Tree(that$$1)) | 0;\n};\n\nFSharpSet.prototype[Symbol.iterator] = function () {\n  const s$$32 = this;\n  return toIterator(SetTreeModule$$$mkIEnumerator(FSharpSet$$get_Tree(s$$32)));\n};\n\nexport function isEmpty(s$$33) {\n  return FSharpSet$$get_IsEmpty(s$$33);\n}\nexport function contains(x$$23, s$$34) {\n  return FSharpSet$$Contains$$2B595(s$$34, x$$23);\n}\nexport function add(x$$24, s$$35) {\n  return FSharpSet$$Add$$2B595(s$$35, x$$24);\n}\nexport function singleton(x$$25, comparer$$24) {\n  return FSharpSet$$$$002Ector$$2528C5CB(comparer$$24, new SetTree$00601(2, \"SetOne\", x$$25));\n}\nexport function remove(x$$26, s$$36) {\n  return FSharpSet$$Remove$$2B595(s$$36, x$$26);\n}\nexport function union(s1$$2, s2$$2) {\n  return FSharpSet$$$op_Addition(s1$$2, s2$$2);\n}\nexport function unionMany(sets$$1, comparer$$25) {\n  return fold$$1(FSharpSet$$$op_Addition, FSharpSet$$$$002Ector$$2528C5CB(comparer$$25, new SetTree$00601(0, \"SetEmpty\")), sets$$1);\n}\nexport function intersect(s1$$3, s2$$3) {\n  return FSharpSet$$$Intersection$$Z3BE9BFE0(s1$$3, s2$$3);\n}\nexport function intersectMany(sets$$2) {\n  return FSharpSet$$$IntersectionMany$$Z15B59630(sets$$2);\n}\nexport function iterate(f$$16, s$$37) {\n  FSharpSet$$Iterate$$5028453F(s$$37, f$$16);\n}\nexport function empty(comparer$$26) {\n  return FSharpSet$$$$002Ector$$2528C5CB(comparer$$26, new SetTree$00601(0, \"SetEmpty\"));\n}\nexport function forAll(f$$17, s$$38) {\n  return FSharpSet$$ForAll$$Z1D55A0D7(s$$38, f$$17);\n}\nexport function exists(f$$18, s$$39) {\n  return FSharpSet$$Exists$$Z1D55A0D7(s$$39, f$$18);\n}\nexport function filter(f$$19, s$$40) {\n  return FSharpSet$$Filter$$Z1D55A0D7(s$$40, f$$19);\n}\nexport function partition(f$$20, s$$41) {\n  return FSharpSet$$Partition$$Z1D55A0D7(s$$41, f$$20);\n}\nexport function fold(f$$21, z$$2, s$$42) {\n  return SetTreeModule$$$fold(f$$21, z$$2, FSharpSet$$get_Tree(s$$42));\n}\nexport function foldBack(f$$22, s$$43, z$$3) {\n  return SetTreeModule$$$foldBack(f$$22, FSharpSet$$get_Tree(s$$43), z$$3);\n}\nexport function map(f$$23, s$$44, comparer$$27) {\n  return FSharpSet$$Map$$38806891(s$$44, f$$23, comparer$$27);\n}\nexport function count(s$$45) {\n  return FSharpSet$$get_Count(s$$45);\n}\nexport function minimumElement(s$$46) {\n  return FSharpSet$$get_MinimumElement(s$$46);\n}\nexport function maximumElement(s$$47) {\n  return FSharpSet$$get_MaximumElement(s$$47);\n}\nexport function ofList(li, comparer$$28) {\n  return FSharpSet$$$$002Ector$$2528C5CB(comparer$$28, SetTreeModule$$$ofSeq(comparer$$28, li));\n}\nexport function ofArray(arr$$2, comparer$$29) {\n  return FSharpSet$$$$002Ector$$2528C5CB(comparer$$29, SetTreeModule$$$ofArray(comparer$$29, arr$$2));\n}\nexport function toList(s$$48) {\n  return SetTreeModule$$$toList(FSharpSet$$get_Tree(s$$48));\n}\nexport function toArray(s$$49, cons) {\n  const n$$3 = count(s$$49) | 0;\n  const res$$1 = new cons(n$$3);\n  SetTreeModule$$$copyToArray(FSharpSet$$get_Tree(s$$49), res$$1, 0);\n  return res$$1;\n}\nexport function toSeq(s$$50) {\n  return SetTreeModule$$$toSeq(FSharpSet$$get_Tree(s$$50));\n}\nexport function ofSeq(elements, comparer$$30) {\n  return FSharpSet$$$$002Ector$$2528C5CB(comparer$$30, SetTreeModule$$$ofSeq(comparer$$30, elements));\n}\nexport function difference(x$$28, y$$6) {\n  return FSharpSet$$$op_Subtraction(x$$28, y$$6);\n}\nexport function isSubset(x$$29, y$$7) {\n  return FSharpSet$$IsSubsetOf$$6A20B1FF(x$$29, y$$7);\n}\nexport function isSuperset(x$$30, y$$8) {\n  return FSharpSet$$IsSupersetOf$$6A20B1FF(x$$30, y$$8);\n}\nexport function isProperSubset(x$$31, y$$9) {\n  return FSharpSet$$IsProperSubsetOf$$6A20B1FF(x$$31, y$$9);\n}\nexport function isProperSuperset(x$$32, y$$10) {\n  return FSharpSet$$IsProperSupersetOf$$6A20B1FF(x$$32, y$$10);\n}\nexport function minElement(s$$51) {\n  return FSharpSet$$get_MinimumElement(s$$51);\n}\nexport function maxElement(s$$52) {\n  return FSharpSet$$get_MaximumElement(s$$52);\n}\n\nfunction createMutablePrivate(comparer$$31, tree$0027) {\n  let tree$$1 = tree$0027;\n  return {\n    get size() {\n      return SetTreeModule$$$count(tree$$1);\n    },\n\n    add(x$$33) {\n      const this$$$4 = this;\n      tree$$1 = SetTreeModule$$$add(comparer$$31, x$$33, tree$$1);\n      return this$$$4;\n    },\n\n    add_(x$$34) {\n      if (SetTreeModule$$$mem(comparer$$31, x$$34, tree$$1)) {\n        return false;\n      } else {\n        tree$$1 = SetTreeModule$$$add(comparer$$31, x$$34, tree$$1);\n        return true;\n      }\n    },\n\n    clear() {\n      tree$$1 = new SetTree$00601(0, \"SetEmpty\");\n    },\n\n    delete(x$$35) {\n      if (SetTreeModule$$$mem(comparer$$31, x$$35, tree$$1)) {\n        tree$$1 = SetTreeModule$$$remove(comparer$$31, x$$35, tree$$1);\n        return true;\n      } else {\n        return false;\n      }\n    },\n\n    has(x$$36) {\n      return SetTreeModule$$$mem(comparer$$31, x$$36, tree$$1);\n    },\n\n    values() {\n      return SetTreeModule$$$toSeq(tree$$1);\n    },\n\n    [Symbol.iterator]() {\n      return toIterator(SetTreeModule$$$mkIEnumerator(tree$$1));\n    },\n\n    GetEnumerator() {\n      return SetTreeModule$$$mkIEnumerator(tree$$1);\n    }\n\n  };\n}\n\nexport function createMutable(source, comparer$$32) {\n  return createMutablePrivate(comparer$$32, SetTreeModule$$$ofSeq(comparer$$32, source));\n}\nexport function distinct(xs, comparer$$33) {\n  return createMutable(xs, comparer$$33);\n}\nexport function distinctBy(projection, xs$$1, comparer$$34) {\n  const li$$1 = [];\n  const hashSet = createMutable(empty$$1(), comparer$$34);\n  iterate$$1(function (x$$37) {\n    if (hashSet.add_(projection(x$$37))) {\n      li$$1.push(x$$37);\n    }\n  }, xs$$1);\n  return li$$1;\n}\nexport function unionWith(s1$$4, s2$$4) {\n  return fold$$1(function folder(acc$$14, x$$38) {\n    return acc$$14.add(x$$38);\n  }, s1$$4, s2$$4);\n}\nexport function intersectWith(s1$$5, s2$$5, comparer$$35) {\n  const s2$$6 = ofSeq(s2$$5, comparer$$35);\n  iterate$$1(function (x$$39) {\n    if (!FSharpSet$$Contains$$2B595(s2$$6, x$$39)) {\n      s1$$5.delete(x$$39), null;\n    }\n  }, s1$$5);\n}\nexport function exceptWith(s1$$6, s2$$7) {\n  iterate$$1(function (x$$40) {\n    s1$$6.delete(x$$40), null;\n  }, s2$$7);\n}\nexport function isSubsetOf(s1$$7, s2$$8, comparer$$36) {\n  return isSubset(ofSeq(s1$$7, comparer$$36), ofSeq(s2$$8, comparer$$36));\n}\nexport function isSupersetOf(s1$$8, s2$$9, comparer$$37) {\n  return isSuperset(ofSeq(s1$$8, comparer$$37), ofSeq(s2$$9, comparer$$37));\n}\nexport function isProperSubsetOf(s1$$9, s2$$10, comparer$$38) {\n  return isProperSubset(ofSeq(s1$$9, comparer$$38), ofSeq(s2$$10, comparer$$38));\n}\nexport function isProperSupersetOf(s1$$10, s2$$11, comparer$$39) {\n  return isProperSuperset(ofSeq(s1$$10, comparer$$39), ofSeq(s2$$11, comparer$$39));\n}","import { defaultArg, value as value$$10, some } from \"./Option.js\";\nimport { compare, getItemFromDict, addToDict, addToSet, tryGetValue, comparerFromEqualityComparer, max as max$$1, comparePrimitives } from \"./Util.js\";\nimport { createMutable } from \"./Map.js\";\nimport { iterateIndexed as iterateIndexed$$1, iterate as iterate$$1 } from \"./Seq.js\";\nimport { createMutable as createMutable$$1 } from \"./Set.js\";\nimport { List } from \"./Types.js\";\n\nfunction indexNotFound() {\n  throw new Error(\"An index satisfying the predicate was not found in the collection.\");\n}\n\nexport function append(array1, array2, cons) {\n  if (ArrayBuffer.isView(array1)) {\n    const len1 = array1.length | 0;\n    const len2 = array2.length | 0;\n    const newArray = new cons(len1 + len2);\n\n    for (let i = 0; i <= len1 - 1; i++) {\n      newArray[i] = array1[i];\n    }\n\n    for (let i$$1 = 0; i$$1 <= len2 - 1; i$$1++) {\n      newArray[i$$1 + len1] = array2[i$$1];\n    }\n\n    return newArray;\n  } else {\n    return array1.concat(array2);\n  }\n}\nexport function filter(predicate, array) {\n  return array.filter(predicate);\n}\nexport function fill(target, targetIndex, count, value) {\n  target.fill(value, targetIndex, targetIndex + count);\n  return target;\n}\nexport function getSubArray(array$$3, start$$1, count$$2) {\n  return array$$3.slice(start$$1, start$$1 + count$$2);\n}\nexport function last(array$$5) {\n  if (array$$5.length === 0) {\n    throw new Error(\"The input array was empty\\\\nParameter name: array\");\n  }\n\n  return array$$5[array$$5.length - 1];\n}\nexport function tryLast(array$$6) {\n  if (array$$6.length === 0) {\n    return null;\n  } else {\n    return some(array$$6[array$$6.length - 1]);\n  }\n}\nexport function mapIndexed(f, source, cons$$1) {\n  if (ArrayBuffer.isView(source)) {\n    const len = source.length | 0;\n    const target$$1 = new cons$$1(len);\n\n    for (let i$$2 = 0; i$$2 <= len - 1; i$$2++) {\n      target$$1[i$$2] = f(i$$2, source[i$$2]);\n    }\n\n    return target$$1;\n  } else {\n    return source.map(function (delegateArg0, delegateArg1) {\n      return f(delegateArg1, delegateArg0);\n    });\n  }\n}\nexport function map(f$$1, source$$1, cons$$2) {\n  if (ArrayBuffer.isView(source$$1)) {\n    const len$$1 = source$$1.length | 0;\n    const target$$2 = new cons$$2(len$$1);\n\n    for (let i$$4 = 0; i$$4 <= len$$1 - 1; i$$4++) {\n      target$$2[i$$4] = f$$1(source$$1[i$$4]);\n    }\n\n    return target$$2;\n  } else {\n    return source$$1.map(function (x$$1) {\n      return f$$1(x$$1);\n    });\n  }\n}\nexport function mapIndexed2(f$$2, source1, source2, cons$$3) {\n  if (source1.length !== source2.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const result = new cons$$3(source1.length);\n\n  for (let i$$5 = 0; i$$5 <= source1.length - 1; i$$5++) {\n    result[i$$5] = f$$2(i$$5, source1[i$$5], source2[i$$5]);\n  }\n\n  return result;\n}\nexport function map2(f$$3, source1$$1, source2$$1, cons$$4) {\n  if (source1$$1.length !== source2$$1.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const result$$1 = new cons$$4(source1$$1.length);\n\n  for (let i$$6 = 0; i$$6 <= source1$$1.length - 1; i$$6++) {\n    result$$1[i$$6] = f$$3(source1$$1[i$$6], source2$$1[i$$6]);\n  }\n\n  return result$$1;\n}\nexport function mapIndexed3(f$$4, source1$$2, source2$$2, source3, cons$$5) {\n  if (source1$$2.length !== source2$$2.length ? true : source2$$2.length !== source3.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const result$$2 = new cons$$5(source1$$2.length);\n\n  for (let i$$7 = 0; i$$7 <= source1$$2.length - 1; i$$7++) {\n    result$$2[i$$7] = f$$4(i$$7, source1$$2[i$$7], source2$$2[i$$7], source3[i$$7]);\n  }\n\n  return result$$2;\n}\nexport function map3(f$$5, source1$$3, source2$$3, source3$$1, cons$$6) {\n  if (source1$$3.length !== source2$$3.length ? true : source2$$3.length !== source3$$1.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const result$$3 = new cons$$6(source1$$3.length);\n\n  for (let i$$8 = 0; i$$8 <= source1$$3.length - 1; i$$8++) {\n    result$$3[i$$8] = f$$5(source1$$3[i$$8], source2$$3[i$$8], source3$$1[i$$8]);\n  }\n\n  return result$$3;\n}\nexport function mapFold(mapping$$2, state, array$$9, cons$$7) {\n  const matchValue = array$$9.length | 0;\n\n  if (matchValue === 0) {\n    return [[], state];\n  } else {\n    const len$$2 = matchValue | 0;\n    let acc = state;\n    const res = new cons$$7(len$$2);\n\n    for (let i$$9 = 0; i$$9 <= array$$9.length - 1; i$$9++) {\n      const patternInput = mapping$$2(acc, array$$9[i$$9]);\n      res[i$$9] = patternInput[0];\n      acc = patternInput[1];\n    }\n\n    return [res, acc];\n  }\n}\nexport function mapFoldBack(mapping$$3, array$$10, state$$1, cons$$8) {\n  const matchValue$$1 = array$$10.length | 0;\n\n  if (matchValue$$1 === 0) {\n    return [[], state$$1];\n  } else {\n    const len$$3 = matchValue$$1 | 0;\n    let acc$$1 = state$$1;\n    const res$$1 = new cons$$8(len$$3);\n\n    for (let i$$10 = array$$10.length - 1; i$$10 >= 0; i$$10--) {\n      const patternInput$$1 = mapping$$3(array$$10[i$$10], acc$$1);\n      res$$1[i$$10] = patternInput$$1[0];\n      acc$$1 = patternInput$$1[1];\n    }\n\n    return [res$$1, acc$$1];\n  }\n}\nexport function indexed(source$$2) {\n  const len$$4 = source$$2.length | 0;\n  const target$$3 = new Array(len$$4);\n\n  for (let i$$11 = 0; i$$11 <= len$$4 - 1; i$$11++) {\n    target$$3[i$$11] = [i$$11, source$$2[i$$11]];\n  }\n\n  return target$$3;\n}\nexport function truncate(count$$4, array$$11) {\n  const count$$5 = max$$1(comparePrimitives, 0, count$$4) | 0;\n  return array$$11.slice(0, 0 + count$$5);\n}\nexport function concat(arrays, cons$$9) {\n  const arrays$$1 = Array.from(arrays);\n  const matchValue$$2 = arrays$$1.length | 0;\n\n  switch (matchValue$$2) {\n    case 0:\n      {\n        return new cons$$9(0);\n      }\n\n    case 1:\n      {\n        return arrays$$1[0];\n      }\n\n    default:\n      {\n        if (ArrayBuffer.isView(arrays$$1[0])) {\n          let totalIdx = 0;\n          let totalLength = 0;\n\n          for (let idx = 0; idx <= arrays$$1.length - 1; idx++) {\n            const arr$$4 = arrays$$1[idx];\n            totalLength = totalLength + arr$$4.length;\n          }\n\n          const result$$4 = new cons$$9(totalLength);\n\n          for (let idx$$1 = 0; idx$$1 <= arrays$$1.length - 1; idx$$1++) {\n            const arr$$5 = arrays$$1[idx$$1];\n\n            for (let j = 0; j <= arr$$5.length - 1; j++) {\n              result$$4[totalIdx] = arr$$5[j];\n              totalIdx = totalIdx + 1;\n            }\n          }\n\n          return result$$4;\n        } else {\n          return arrays$$1[0].concat(...arrays$$1.slice(1));\n        }\n      }\n  }\n}\nexport function collect(mapping$$4, array$$14, cons$$10) {\n  const mapped = map(mapping$$4, array$$14, Array);\n  return concat(mapped, cons$$10);\n}\nexport function countBy(projection, array$$15, eq) {\n  const dict = createMutable([], comparerFromEqualityComparer(eq));\n\n  for (let idx$$2 = 0; idx$$2 <= array$$15.length - 1; idx$$2++) {\n    const value$$2 = array$$15[idx$$2];\n    const key = projection(value$$2);\n    const matchValue$$3 = tryGetValue(dict, key, 0);\n\n    if (matchValue$$3[0]) {\n      dict.set(key, matchValue$$3[1] + 1);\n    } else {\n      dict.set(key, 1);\n    }\n  }\n\n  const res$$2 = new Array(dict.size);\n  let i$$12 = 0;\n  iterate$$1(function (group) {\n    res$$2[i$$12] = [group[0], group[1]];\n    i$$12 = i$$12 + 1;\n  }, dict);\n  return res$$2;\n}\nexport function distinctBy(projection$$1, array$$16, eq$$1) {\n  const hashSet = createMutable$$1([], comparerFromEqualityComparer(eq$$1));\n  return filter(function predicate$$2($arg$$3) {\n    return addToSet(projection$$1($arg$$3), hashSet);\n  }, array$$16);\n}\nexport function distinct(array$$18, eq$$2) {\n  return distinctBy(function (x$$2) {\n    return x$$2;\n  }, array$$18, eq$$2);\n}\nexport function where(predicate$$3, array$$19) {\n  return array$$19.filter(predicate$$3);\n}\nexport function contains(value$$3, array$$21, eq$$3) {\n  const loop = function loop(i$$13) {\n    loop: while (true) {\n      if (i$$13 >= array$$21.length) {\n        return false;\n      } else if (eq$$3.Equals(value$$3, array$$21[i$$13])) {\n        return true;\n      } else {\n        const $i$$13$$51 = i$$13;\n        i$$13 = $i$$13$$51 + 1;\n        continue loop;\n      }\n\n      break;\n    }\n  };\n\n  return loop(0);\n}\nexport function except(itemsToExclude, array$$22, eq$$4) {\n  if (array$$22.length === 0) {\n    return array$$22;\n  } else {\n    const cached = createMutable$$1(itemsToExclude, comparerFromEqualityComparer(eq$$4));\n    return array$$22.filter(function predicate$$5(arg00$$1) {\n      return addToSet(arg00$$1, cached);\n    });\n  }\n}\nexport function groupBy(projection$$2, array$$25, cons$$11, eq$$5) {\n  const dict$$1 = createMutable([], comparerFromEqualityComparer(eq$$5));\n  const keys = [];\n\n  for (let idx$$3 = 0; idx$$3 <= array$$25.length - 1; idx$$3++) {\n    const v = array$$25[idx$$3];\n    const key$$1 = projection$$2(v);\n    const matchValue$$4 = tryGetValue(dict$$1, key$$1, null);\n\n    if (matchValue$$4[0]) {\n      dict$$1.set(key$$1, new List(v, matchValue$$4[1]));\n    } else {\n      addToDict(dict$$1, key$$1, new List(v, new List()));\n      keys.push(key$$1);\n    }\n  }\n\n  const result$$5 = new Array(keys.length);\n  iterateIndexed$$1(function action(i$$14, key$$2) {\n    result$$5[i$$14] = [key$$2, cons$$11.from(getItemFromDict(dict$$1, key$$2)).reverse()];\n  }, keys);\n  return result$$5;\n}\nexport function empty(cons$$12) {\n  return new cons$$12(0);\n}\nexport function singleton(value$$4, cons$$14) {\n  const ar = new cons$$14(1);\n  ar[0] = value$$4;\n  return ar;\n}\nexport function initialize(count$$8, initializer, cons$$15) {\n  if (count$$8 < 0) {\n    throw new Error(\"The input must be non-negative\\\\nParameter name: count\");\n  }\n\n  const result$$6 = new cons$$15(count$$8);\n\n  for (let i$$15 = 0; i$$15 <= count$$8 - 1; i$$15++) {\n    result$$6[i$$15] = initializer(i$$15);\n  }\n\n  return result$$6;\n}\nexport function pairwise(array$$28) {\n  if (array$$28.length < 2) {\n    return [];\n  } else {\n    const count$$9 = array$$28.length - 1 | 0;\n    const result$$7 = new Array(count$$9);\n\n    for (let i$$16 = 0; i$$16 <= count$$9 - 1; i$$16++) {\n      result$$7[i$$16] = [array$$28[i$$16], array$$28[i$$16 + 1]];\n    }\n\n    return result$$7;\n  }\n}\nexport function replicate(count$$10, initial, cons$$16) {\n  if (count$$10 < 0) {\n    throw new Error(\"The input must be non-negative\\\\nParameter name: count\");\n  }\n\n  const result$$8 = new cons$$16(count$$10);\n\n  for (let i$$17 = 0; i$$17 <= result$$8.length - 1; i$$17++) {\n    result$$8[i$$17] = initial;\n  }\n\n  return result$$8;\n}\nexport function copy(array$$29, cons$$17) {\n  return array$$29.slice();\n}\nexport function reverse(array$$31, cons$$18) {\n  return array$$31.slice().reverse();\n}\nexport function scan(folder, state$$2, array$$35, cons$$19) {\n  const res$$3 = new cons$$19(array$$35.length + 1);\n  res$$3[0] = state$$2;\n\n  for (let i$$18 = 0; i$$18 <= array$$35.length - 1; i$$18++) {\n    res$$3[i$$18 + 1] = folder(res$$3[i$$18], array$$35[i$$18]);\n  }\n\n  return res$$3;\n}\nexport function scanBack(folder$$1, array$$36, state$$3, cons$$20) {\n  const res$$4 = new cons$$20(array$$36.length + 1);\n  res$$4[array$$36.length] = state$$3;\n\n  for (let i$$19 = array$$36.length - 1; i$$19 >= 0; i$$19--) {\n    res$$4[i$$19] = folder$$1(array$$36[i$$19], res$$4[i$$19 + 1]);\n  }\n\n  return res$$4;\n}\nexport function skip(count$$11, array$$37, cons$$21) {\n  if (count$$11 > array$$37.length) {\n    throw new Error(\"count is greater than array length\\\\nParameter name: count\");\n  }\n\n  if (count$$11 === array$$37.length) {\n    return new cons$$21(0);\n  } else {\n    const count$$12 = (count$$11 < 0 ? 0 : count$$11) | 0;\n    return array$$37.slice(count$$12);\n  }\n}\nexport function skipWhile(predicate$$7, array$$39, cons$$23) {\n  let count$$14 = 0;\n\n  while (count$$14 < array$$39.length ? predicate$$7(array$$39[count$$14]) : false) {\n    count$$14 = count$$14 + 1;\n  }\n\n  if (count$$14 === array$$39.length) {\n    return new cons$$23(0);\n  } else {\n    return array$$39.slice(count$$14);\n  }\n}\nexport function take(count$$16, array$$41, cons$$25) {\n  if (count$$16 < 0) {\n    throw new Error(\"The input must be non-negative\\\\nParameter name: count\");\n  }\n\n  if (count$$16 > array$$41.length) {\n    throw new Error(\"count is greater than array length\\\\nParameter name: count\");\n  }\n\n  if (count$$16 === 0) {\n    return new cons$$25(0);\n  } else {\n    return array$$41.slice(0, 0 + count$$16);\n  }\n}\nexport function takeWhile(predicate$$8, array$$43, cons$$27) {\n  let count$$18 = 0;\n\n  while (count$$18 < array$$43.length ? predicate$$8(array$$43[count$$18]) : false) {\n    count$$18 = count$$18 + 1;\n  }\n\n  if (count$$18 === 0) {\n    return new cons$$27(0);\n  } else {\n    return array$$43.slice(0, 0 + count$$18);\n  }\n}\nexport function addRangeInPlace(range, array$$45) {\n  iterate$$1(function (x$$3) {\n    array$$45.push(x$$3), null;\n  }, range);\n}\nexport function removeInPlace(item$$2, array$$47) {\n  const i$$20 = array$$47.indexOf(item$$2);\n\n  if (i$$20 > -1) {\n    array$$47.splice(i$$20, 1), null;\n    return true;\n  } else {\n    return false;\n  }\n}\nexport function removeAllInPlace(predicate$$9, array$$50) {\n  const countRemoveAll = function countRemoveAll(count$$20) {\n    const i$$21 = array$$50.findIndex(predicate$$9);\n\n    if (i$$21 > -1) {\n      array$$50.splice(i$$21, 1), null;\n      return countRemoveAll(count$$20) + 1 | 0;\n    } else {\n      return count$$20 | 0;\n    }\n  };\n\n  return countRemoveAll(0) | 0;\n}\nexport function copyTo(source$$4, sourceIndex, target$$4, targetIndex$$1, count$$21) {\n  const diff = targetIndex$$1 - sourceIndex | 0;\n\n  for (let i$$22 = sourceIndex; i$$22 <= sourceIndex + count$$21 - 1; i$$22++) {\n    target$$4[i$$22 + diff] = source$$4[i$$22];\n  }\n}\nexport function partition(f$$6, source$$5, cons$$29) {\n  const len$$9 = source$$5.length | 0;\n  const res1 = new cons$$29(len$$9);\n  const res2 = new cons$$29(len$$9);\n  let iTrue = 0;\n  let iFalse = 0;\n\n  for (let i$$23 = 0; i$$23 <= len$$9 - 1; i$$23++) {\n    if (f$$6(source$$5[i$$23])) {\n      res1[iTrue] = source$$5[i$$23];\n      iTrue = iTrue + 1;\n    } else {\n      res2[iFalse] = source$$5[i$$23];\n      iFalse = iFalse + 1;\n    }\n  }\n\n  return [truncate(iTrue, res1), truncate(iFalse, res2)];\n}\nexport function find(predicate$$11, array$$55) {\n  const matchValue$$5 = array$$55.find(predicate$$11);\n\n  if (matchValue$$5 == null) {\n    return indexNotFound();\n  } else {\n    const res$$5 = value$$10(matchValue$$5);\n    return res$$5;\n  }\n}\nexport function tryFind(predicate$$13, array$$57) {\n  return array$$57.find(predicate$$13);\n}\nexport function findIndex(predicate$$15, array$$59) {\n  var index;\n  const matchValue$$6 = array$$59.findIndex(predicate$$15);\n\n  if (index = matchValue$$6 | 0, index > -1) {\n    const index$$1 = matchValue$$6 | 0;\n    return index$$1 | 0;\n  } else {\n    return indexNotFound() | 0;\n  }\n}\nexport function tryFindIndex(predicate$$17, array$$61) {\n  var index$$2;\n  const matchValue$$7 = array$$61.findIndex(predicate$$17);\n\n  if (index$$2 = matchValue$$7 | 0, index$$2 > -1) {\n    const index$$3 = matchValue$$7 | 0;\n    return index$$3;\n  } else {\n    return null;\n  }\n}\nexport function pick(chooser, array$$63) {\n  const loop$$1 = function loop$$1(i$$24) {\n    loop$$1: while (true) {\n      if (i$$24 >= array$$63.length) {\n        return indexNotFound();\n      } else {\n        const matchValue$$8 = chooser(array$$63[i$$24]);\n\n        if (matchValue$$8 != null) {\n          const res$$6 = value$$10(matchValue$$8);\n          return res$$6;\n        } else {\n          const $i$$24$$88 = i$$24;\n          i$$24 = $i$$24$$88 + 1;\n          continue loop$$1;\n        }\n      }\n\n      break;\n    }\n  };\n\n  return loop$$1(0);\n}\nexport function tryPick(chooser$$1, array$$64) {\n  const loop$$2 = function loop$$2(i$$25) {\n    loop$$2: while (true) {\n      if (i$$25 >= array$$64.length) {\n        return null;\n      } else {\n        const matchValue$$9 = chooser$$1(array$$64[i$$25]);\n\n        if (matchValue$$9 == null) {\n          const $i$$25$$91 = i$$25;\n          i$$25 = $i$$25$$91 + 1;\n          continue loop$$2;\n        } else {\n          const res$$7 = matchValue$$9;\n          return res$$7;\n        }\n      }\n\n      break;\n    }\n  };\n\n  return loop$$2(0);\n}\nexport function findBack(predicate$$19, array$$65) {\n  const loop$$3 = function loop$$3(i$$26) {\n    loop$$3: while (true) {\n      if (i$$26 < 0) {\n        return indexNotFound();\n      } else if (predicate$$19(array$$65[i$$26])) {\n        return array$$65[i$$26];\n      } else {\n        const $i$$26$$94 = i$$26;\n        i$$26 = $i$$26$$94 - 1;\n        continue loop$$3;\n      }\n\n      break;\n    }\n  };\n\n  return loop$$3(array$$65.length - 1);\n}\nexport function tryFindBack(predicate$$20, array$$66) {\n  const loop$$4 = function loop$$4(i$$27) {\n    loop$$4: while (true) {\n      if (i$$27 < 0) {\n        return null;\n      } else if (predicate$$20(array$$66[i$$27])) {\n        return some(array$$66[i$$27]);\n      } else {\n        const $i$$27$$97 = i$$27;\n        i$$27 = $i$$27$$97 - 1;\n        continue loop$$4;\n      }\n\n      break;\n    }\n  };\n\n  return loop$$4(array$$66.length - 1);\n}\nexport function findLastIndex(predicate$$21, array$$67) {\n  const loop$$5 = function loop$$5(i$$28) {\n    loop$$5: while (true) {\n      if (i$$28 < 0) {\n        return -1 | 0;\n      } else if (predicate$$21(array$$67[i$$28])) {\n        return i$$28 | 0;\n      } else {\n        const $i$$28$$100 = i$$28;\n        i$$28 = $i$$28$$100 - 1;\n        continue loop$$5;\n      }\n\n      break;\n    }\n  };\n\n  return loop$$5(array$$67.length - 1) | 0;\n}\nexport function findIndexBack(predicate$$22, array$$68) {\n  const loop$$6 = function loop$$6(i$$29) {\n    loop$$6: while (true) {\n      if (i$$29 < 0) {\n        return indexNotFound() | 0;\n      } else if (predicate$$22(array$$68[i$$29])) {\n        return i$$29 | 0;\n      } else {\n        const $i$$29$$103 = i$$29;\n        i$$29 = $i$$29$$103 - 1;\n        continue loop$$6;\n      }\n\n      break;\n    }\n  };\n\n  return loop$$6(array$$68.length - 1) | 0;\n}\nexport function tryFindIndexBack(predicate$$23, array$$69) {\n  const loop$$7 = function loop$$7(i$$30) {\n    loop$$7: while (true) {\n      if (i$$30 < 0) {\n        return null;\n      } else if (predicate$$23(array$$69[i$$30])) {\n        return i$$30;\n      } else {\n        const $i$$30$$106 = i$$30;\n        i$$30 = $i$$30$$106 - 1;\n        continue loop$$7;\n      }\n\n      break;\n    }\n  };\n\n  return loop$$7(array$$69.length - 1);\n}\nexport function choose(chooser$$2, array$$70, cons$$30) {\n  const f$$7 = function f$$7(x$$4) {\n    return chooser$$2(x$$4) != null;\n  };\n\n  const g = function g(x$$5) {\n    return value$$10(chooser$$2(x$$5));\n  };\n\n  const arr$$6 = array$$70.filter(f$$7);\n  return map(g, arr$$6, cons$$30);\n}\nexport function foldIndexed(folder$$2, state$$4, array$$72) {\n  return array$$72.reduce(function (delegateArg0$$1, delegateArg1$$1, delegateArg2) {\n    return folder$$2(delegateArg2, delegateArg0$$1, delegateArg1$$1);\n  }, state$$4);\n}\nexport function fold(folder$$4, state$$6, array$$74) {\n  return array$$74.reduce(folder$$4, state$$6);\n}\nexport function iterate(action$$1, array$$76) {\n  for (let i$$32 = 0; i$$32 <= array$$76.length - 1; i$$32++) {\n    action$$1(array$$76[i$$32]);\n  }\n}\nexport function iterateIndexed(action$$2, array$$77) {\n  for (let i$$33 = 0; i$$33 <= array$$77.length - 1; i$$33++) {\n    action$$2(i$$33, array$$77[i$$33]);\n  }\n}\nexport function iterate2(action$$3, array1$$2, array2$$2) {\n  if (array1$$2.length !== array2$$2.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  for (let i$$34 = 0; i$$34 <= array1$$2.length - 1; i$$34++) {\n    action$$3(array1$$2[i$$34], array2$$2[i$$34]);\n  }\n}\nexport function iterateIndexed2(action$$4, array1$$3, array2$$3) {\n  if (array1$$3.length !== array2$$3.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  for (let i$$35 = 0; i$$35 <= array1$$3.length - 1; i$$35++) {\n    action$$4(i$$35, array1$$3[i$$35], array2$$3[i$$35]);\n  }\n}\nexport function isEmpty(array$$78) {\n  return array$$78.length === 0;\n}\nexport function forAll(predicate$$25, array$$79) {\n  return array$$79.every(predicate$$25);\n}\nexport function permute(f$$8, array$$81) {\n  const size = array$$81.length | 0;\n  const res$$8 = new array$$81.constructor(array$$81.length);\n  const checkFlags = new Array(size);\n  iterateIndexed(function (i$$36, x$$8) {\n    const j$$1 = f$$8(i$$36) | 0;\n\n    if (j$$1 < 0 ? true : j$$1 >= size) {\n      throw new Error(\"Not a valid permutation\");\n    }\n\n    res$$8[j$$1] = x$$8;\n    checkFlags[j$$1] = 1;\n  }, array$$81);\n  const isValid = forAll(function (y) {\n    return 1 === y;\n  }, checkFlags);\n\n  if (!isValid) {\n    throw new Error(\"Not a valid permutation\");\n  }\n\n  return res$$8;\n}\nexport function setSlice(target$$5, lower, upper, source$$6) {\n  const lower$$1 = defaultArg(lower, 0) | 0;\n  const upper$$1 = defaultArg(upper, 0) | 0;\n  const length = (upper$$1 > 0 ? upper$$1 : target$$5.length - 1) - lower$$1 | 0;\n\n  if (ArrayBuffer.isView(target$$5) ? source$$6.length <= length : false) {\n    return target$$5.set(source$$6, lower$$1);\n  } else {\n    for (let i$$37 = 0; i$$37 <= length; i$$37++) {\n      target$$5[i$$37 + lower$$1] = source$$6[i$$37];\n    }\n  }\n}\nexport function sortInPlaceBy(projection$$3, xs, comparer) {\n  xs.sort(function (x$$10, y$$1) {\n    return comparer.Compare(projection$$3(x$$10), projection$$3(y$$1));\n  });\n}\nexport function sortInPlace(xs$$1, comparer$$1) {\n  xs$$1.sort(function (x$$11, y$$2) {\n    return comparer$$1.Compare(x$$11, y$$2);\n  });\n}\n\nfunction copyArray(array$$82) {\n  const result$$9 = new array$$82.constructor(array$$82.length);\n\n  for (let i$$38 = 0; i$$38 <= array$$82.length - 1; i$$38++) {\n    result$$9[i$$38] = array$$82[i$$38];\n  }\n\n  return result$$9;\n}\n\nexport function sort(xs$$2, comparer$$2) {\n  const xs$$3 = copyArray(xs$$2);\n  xs$$3.sort(function (x$$12, y$$3) {\n    return comparer$$2.Compare(x$$12, y$$3);\n  });\n  return xs$$3;\n}\nexport function sortBy(projection$$4, xs$$4, comparer$$4) {\n  const xs$$5 = copyArray(xs$$4);\n  xs$$5.sort(function (x$$13, y$$4) {\n    return comparer$$4.Compare(projection$$4(x$$13), projection$$4(y$$4));\n  });\n  return xs$$5;\n}\nexport function sortDescending(xs$$6, comparer$$6) {\n  const xs$$7 = copyArray(xs$$6);\n  xs$$7.sort(function (x$$14, y$$5) {\n    return comparer$$6.Compare(x$$14, y$$5) * -1;\n  });\n  return xs$$7;\n}\nexport function sortByDescending(projection$$5, xs$$8, comparer$$8) {\n  const xs$$9 = copyArray(xs$$8);\n  xs$$9.sort(function (x$$15, y$$6) {\n    return comparer$$8.Compare(projection$$5(x$$15), projection$$5(y$$6)) * -1;\n  });\n  return xs$$9;\n}\nexport function sortWith(comparer$$10, xs$$10) {\n  const xs$$11 = copyArray(xs$$10);\n  xs$$11.sort(comparer$$10);\n  return xs$$11;\n}\nexport function unfold(generator, state$$8) {\n  const res$$9 = [];\n\n  const loop$$8 = function loop$$8(state$$9) {\n    loop$$8: while (true) {\n      const matchValue$$10 = generator(state$$9);\n\n      if (matchValue$$10 != null) {\n        const x$$16 = matchValue$$10[0];\n        const s$0027$$2 = matchValue$$10[1];\n        res$$9.push(x$$16), null;\n        state$$9 = s$0027$$2;\n        continue loop$$8;\n      }\n\n      break;\n    }\n  };\n\n  loop$$8(state$$8);\n  return res$$9;\n}\nexport function unzip(array$$84) {\n  const len$$11 = array$$84.length | 0;\n  const res1$$1 = new Array(len$$11);\n  const res2$$1 = new Array(len$$11);\n  iterateIndexed(function (i$$39, tupledArg) {\n    res1$$1[i$$39] = tupledArg[0];\n    res2$$1[i$$39] = tupledArg[1];\n  }, array$$84);\n  return [res1$$1, res2$$1];\n}\nexport function unzip3(array$$85) {\n  const len$$14 = array$$85.length | 0;\n  const res1$$2 = new Array(len$$14);\n  const res2$$2 = new Array(len$$14);\n  const res3 = new Array(len$$14);\n  iterateIndexed(function (i$$40, tupledArg$$1) {\n    res1$$2[i$$40] = tupledArg$$1[0];\n    res2$$2[i$$40] = tupledArg$$1[1];\n    res3[i$$40] = tupledArg$$1[2];\n  }, array$$85);\n  return [res1$$2, res2$$2, res3];\n}\nexport function zip(array1$$4, array2$$4) {\n  if (array1$$4.length !== array2$$4.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const result$$10 = new Array(array1$$4.length);\n\n  for (let i$$41 = 0; i$$41 <= array1$$4.length - 1; i$$41++) {\n    result$$10[i$$41] = [array1$$4[i$$41], array2$$4[i$$41]];\n  }\n\n  return result$$10;\n}\nexport function zip3(array1$$5, array2$$5, array3) {\n  if (array1$$5.length !== array2$$5.length ? true : array2$$5.length !== array3.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const result$$11 = new Array(array1$$5.length);\n\n  for (let i$$42 = 0; i$$42 <= array1$$5.length - 1; i$$42++) {\n    result$$11[i$$42] = [array1$$5[i$$42], array2$$5[i$$42], array3[i$$42]];\n  }\n\n  return result$$11;\n}\nexport function chunkBySize(chunkSize, array$$86) {\n  if (chunkSize < 1) {\n    throw new Error(\"The input must be positive.\\\\nParameter name: size\");\n  }\n\n  if (array$$86.length === 0) {\n    return [[]];\n  } else {\n    const result$$12 = [];\n\n    for (let x$$17 = 0; x$$17 <= ~~Math.ceil(array$$86.length / chunkSize) - 1; x$$17++) {\n      const start$$8 = x$$17 * chunkSize | 0;\n      const slice = array$$86.slice(start$$8, start$$8 + chunkSize);\n      result$$12.push(slice), null;\n    }\n\n    return result$$12;\n  }\n}\nexport function splitAt(index$$4, array$$89) {\n  if (index$$4 < 0) {\n    throw new Error(\"The input must be non-negative\\\\nParameter name: index\");\n  }\n\n  if (index$$4 > array$$89.length) {\n    throw new Error(\"The input sequence has an insufficient number of elements.\\\\nParameter name: index\");\n  }\n\n  return [array$$89.slice(0, 0 + index$$4), array$$89.slice(index$$4)];\n}\nexport function compareWith(comparer$$12, array1$$6, array2$$6) {\n  if (array1$$6 == null) {\n    if (array2$$6 == null) {\n      return 0;\n    } else {\n      return -1 | 0;\n    }\n  } else if (array2$$6 == null) {\n    return 1;\n  } else {\n    let i$$43 = 0;\n    let result$$13 = 0;\n    const length1 = array1$$6.length | 0;\n    const length2 = array2$$6.length | 0;\n\n    if (length1 > length2) {\n      return 1;\n    } else if (length1 < length2) {\n      return -1 | 0;\n    } else {\n      while (i$$43 < length1 ? result$$13 === 0 : false) {\n        result$$13 = comparer$$12(array1$$6[i$$43], array2$$6[i$$43]);\n        i$$43 = i$$43 + 1;\n      }\n\n      return result$$13 | 0;\n    }\n  }\n}\nexport function equalsWith(comparer$$13, array1$$7, array2$$7) {\n  return compareWith(compare, array1$$7, array2$$7) === 0;\n}\nexport function exactlyOne(array$$92) {\n  if (array$$92.length === 1) {\n    return array$$92[0];\n  } else if (array$$92.length === 0) {\n    throw new Error(\"The input sequence was empty\\\\nParameter name: array\");\n  } else {\n    throw new Error(\"Input array too long\\\\nParameter name: array\");\n  }\n}\nexport function head(array$$93) {\n  if (array$$93.length === 0) {\n    throw new Error(\"The input array was empty\\\\nParameter name: array\");\n  } else {\n    return array$$93[0];\n  }\n}\nexport function tryHead(array$$94) {\n  if (array$$94.length === 0) {\n    return null;\n  } else {\n    return some(array$$94[0]);\n  }\n}\nexport function tail(array$$95) {\n  if (array$$95.length === 0) {\n    throw new Error(\"Not enough elements\\\\nParameter name: array\");\n  }\n\n  return array$$95.slice(1);\n}\nexport function item(index$$5, array$$97) {\n  return array$$97[index$$5];\n}\nexport function tryItem(index$$6, array$$98) {\n  if (index$$6 < 0 ? true : index$$6 >= array$$98.length) {\n    return null;\n  } else {\n    return some(array$$98[index$$6]);\n  }\n}\nexport function foldBackIndexed(folder$$6, array$$99, state$$10) {\n  return array$$99.reduceRight(function (delegateArg0$$3, delegateArg1$$3, delegateArg2$$1) {\n    return folder$$6(delegateArg2$$1, delegateArg1$$3, delegateArg0$$3);\n  }, state$$10);\n}\nexport function foldBack(folder$$8, array$$101, state$$12) {\n  return array$$101.reduceRight(function (delegateArg0$$4, delegateArg1$$4) {\n    return folder$$8(delegateArg1$$4, delegateArg0$$4);\n  }, state$$12);\n}\nexport function foldIndexed2(folder$$10, state$$14, array1$$8, array2$$8) {\n  let acc$$6 = state$$14;\n\n  if (array1$$8.length !== array2$$8.length) {\n    throw new Error(\"Arrays have different lengths\");\n  }\n\n  for (let i$$45 = 0; i$$45 <= array1$$8.length - 1; i$$45++) {\n    acc$$6 = folder$$10(i$$45, acc$$6, array1$$8[i$$45], array2$$8[i$$45]);\n  }\n\n  return acc$$6;\n}\nexport function fold2(folder$$11, state$$15, array1$$9, array2$$9) {\n  return foldIndexed2(function (_arg1, acc$$7, x$$20, y$$7) {\n    return folder$$11(acc$$7, x$$20, y$$7);\n  }, state$$15, array1$$9, array2$$9);\n}\nexport function foldBackIndexed2(folder$$12, array1$$10, array2$$10, state$$16) {\n  let acc$$8 = state$$16;\n\n  if (array1$$10.length !== array2$$10.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  const size$$1 = array1$$10.length | 0;\n\n  for (let i$$46 = 1; i$$46 <= size$$1; i$$46++) {\n    acc$$8 = folder$$12(i$$46 - 1, array1$$10[size$$1 - i$$46], array2$$10[size$$1 - i$$46], acc$$8);\n  }\n\n  return acc$$8;\n}\nexport function foldBack2(f$$9, array1$$11, array2$$11, state$$17) {\n  return foldBackIndexed2(function (_arg1$$1, x$$21, y$$8, acc$$9) {\n    return f$$9(x$$21, y$$8, acc$$9);\n  }, array1$$11, array2$$11, state$$17);\n}\nexport function reduce(reduction, array$$103) {\n  if (array$$103.length === 0) {\n    throw new Error(\"The input array was empty\");\n  }\n\n  return array$$103.reduce(reduction);\n}\nexport function reduceBack(reduction$$2, array$$105) {\n  if (array$$105.length === 0) {\n    throw new Error(\"The input array was empty\");\n  }\n\n  return array$$105.reduceRight(reduction$$2);\n}\nexport function forAll2(predicate$$27, array1$$12, array2$$12) {\n  return fold2(function (acc$$10, x$$22, y$$9) {\n    return acc$$10 ? predicate$$27(x$$22, y$$9) : false;\n  }, true, array1$$12, array2$$12);\n}\nexport function existsOffset($arg$$178, $arg$$179, $arg$$180) {\n  existsOffset: while (true) {\n    const predicate$$28 = $arg$$178,\n          array$$107 = $arg$$179,\n          index$$7 = $arg$$180;\n\n    if (index$$7 === array$$107.length) {\n      return false;\n    } else if (predicate$$28(array$$107[index$$7])) {\n      return true;\n    } else {\n      $arg$$178 = predicate$$28;\n      $arg$$179 = array$$107;\n      $arg$$180 = index$$7 + 1;\n      continue existsOffset;\n    }\n\n    break;\n  }\n}\nexport function exists(predicate$$29, array$$108) {\n  return existsOffset(predicate$$29, array$$108, 0);\n}\nexport function existsOffset2($arg$$183, $arg$$184, $arg$$185, $arg$$186) {\n  existsOffset2: while (true) {\n    const predicate$$30 = $arg$$183,\n          array1$$13 = $arg$$184,\n          array2$$13 = $arg$$185,\n          index$$8 = $arg$$186;\n\n    if (index$$8 === array1$$13.length) {\n      return false;\n    } else if (predicate$$30(array1$$13[index$$8], array2$$13[index$$8])) {\n      return true;\n    } else {\n      $arg$$183 = predicate$$30;\n      $arg$$184 = array1$$13;\n      $arg$$185 = array2$$13;\n      $arg$$186 = index$$8 + 1;\n      continue existsOffset2;\n    }\n\n    break;\n  }\n}\nexport function exists2(predicate$$31, array1$$14, array2$$14) {\n  if (array1$$14.length !== array2$$14.length) {\n    throw new Error(\"Arrays had different lengths\");\n  }\n\n  return existsOffset2(predicate$$31, array1$$14, array2$$14, 0);\n}\nexport function sum(array$$109, adder) {\n  let acc$$11 = adder.GetZero();\n\n  for (let i$$47 = 0; i$$47 <= array$$109.length - 1; i$$47++) {\n    acc$$11 = adder.Add(acc$$11, array$$109[i$$47]);\n  }\n\n  return acc$$11;\n}\nexport function sumBy(projection$$6, array$$110, adder$$1) {\n  let acc$$12 = adder$$1.GetZero();\n\n  for (let i$$48 = 0; i$$48 <= array$$110.length - 1; i$$48++) {\n    acc$$12 = adder$$1.Add(acc$$12, projection$$6(array$$110[i$$48]));\n  }\n\n  return acc$$12;\n}\nexport function maxBy(projection$$7, xs$$12, comparer$$14) {\n  return reduce(function (x$$23, y$$10) {\n    return comparer$$14.Compare(projection$$7(y$$10), projection$$7(x$$23)) > 0 ? y$$10 : x$$23;\n  }, xs$$12);\n}\nexport function max(xs$$13, comparer$$15) {\n  return reduce(function (x$$24, y$$11) {\n    return comparer$$15.Compare(y$$11, x$$24) > 0 ? y$$11 : x$$24;\n  }, xs$$13);\n}\nexport function minBy(projection$$8, xs$$14, comparer$$16) {\n  return reduce(function (x$$25, y$$12) {\n    return comparer$$16.Compare(projection$$8(y$$12), projection$$8(x$$25)) > 0 ? x$$25 : y$$12;\n  }, xs$$14);\n}\nexport function min(xs$$15, comparer$$17) {\n  return reduce(function (x$$26, y$$13) {\n    return comparer$$17.Compare(y$$13, x$$26) > 0 ? x$$26 : y$$13;\n  }, xs$$15);\n}\nexport function average(array$$111, averager) {\n  if (array$$111.length === 0) {\n    throw new Error(\"The input array was empty\\\\nParameter name: array\");\n  }\n\n  let total = averager.GetZero();\n\n  for (let i$$49 = 0; i$$49 <= array$$111.length - 1; i$$49++) {\n    total = averager.Add(total, array$$111[i$$49]);\n  }\n\n  return averager.DivideByInt(total, array$$111.length);\n}\nexport function averageBy(projection$$9, array$$112, averager$$1) {\n  if (array$$112.length === 0) {\n    throw new Error(\"The input array was empty\\\\nParameter name: array\");\n  }\n\n  let total$$1 = averager$$1.GetZero();\n\n  for (let i$$50 = 0; i$$50 <= array$$112.length - 1; i$$50++) {\n    total$$1 = averager$$1.Add(total$$1, projection$$9(array$$112[i$$50]));\n  }\n\n  return averager$$1.DivideByInt(total$$1, array$$112.length);\n}\nexport function ofSeq(source$$8, cons$$31) {\n  return cons$$31.from(source$$8);\n}\nexport function ofList(source$$9, cons$$32) {\n  return cons$$32.from(source$$9);\n}\nexport function toList(source$$10) {\n  const len$$20 = source$$10.length | 0;\n  let target$$7 = new List();\n\n  for (let i$$51 = len$$20 - 1; i$$51 >= 0; i$$51--) {\n    target$$7 = new List(source$$10[i$$51], target$$7);\n  }\n\n  return target$$7;\n}\nexport function windowed(windowSize, source$$11) {\n  if (windowSize <= 0) {\n    throw new Error(\"windowSize must be positive\");\n  }\n\n  const res$$10 = new Array(max$$1(comparePrimitives, 0, source$$11.length - windowSize));\n\n  for (let i$$52 = windowSize; i$$52 <= source$$11.length; i$$52++) {\n    res$$10[i$$52 - windowSize] = source$$11.slice(i$$52 - windowSize, i$$52 - 1 + 1);\n  }\n\n  return res$$10;\n}","import { defaultArg, value as value$$1, some } from \"./Option.js\";\nimport { FSharpRef, List } from \"./Types.js\";\nimport { iterate as iterate$$1, collect as collect$$1, scanBack as scanBack$$1, scan as scan$$1, foldBack2 as foldBack2$$1, fold2 as fold2$$1, fold as fold$$1, map as map$$1 } from \"./Seq.js\";\nimport { partialApply, getItemFromDict, addToDict, tryGetValue, addToSet, comparerFromEqualityComparer, count } from \"./Util.js\";\nimport { ofList } from \"./Array.js\";\nimport { permute as permute$$1, findIndexBack as findIndexBack$$1, tryFindIndexBack as tryFindIndexBack$$1 } from \"./Array\";\nimport { createMutable } from \"./Set.js\";\nimport { createMutable as createMutable$$1 } from \"./Map.js\";\nexport function head(_arg1) {\n  if (_arg1.tail != null) {\n    const x = _arg1.head;\n    return x;\n  } else {\n    throw new Error(\"List was empty\");\n  }\n}\nexport function tryHead(_arg1$$1) {\n  if (_arg1$$1.tail != null) {\n    const x$$1 = _arg1$$1.head;\n    return some(x$$1);\n  } else {\n    return null;\n  }\n}\nexport function tail(_arg1$$2) {\n  if (_arg1$$2.tail != null) {\n    const xs = _arg1$$2.tail;\n    return xs;\n  } else {\n    throw new Error(\"List was empty\");\n  }\n}\nexport function last(_arg1$$3) {\n  last: while (true) {\n    if (_arg1$$3.tail != null) {\n      if (_arg1$$3.tail.tail == null) {\n        return _arg1$$3.head;\n      } else {\n        const $_arg1$$3$$2 = _arg1$$3;\n        _arg1$$3 = $_arg1$$3$$2.tail;\n        continue last;\n      }\n    } else {\n      throw new Error(\"List was empty\");\n    }\n\n    break;\n  }\n}\nexport function tryLast(_arg1$$4) {\n  tryLast: while (true) {\n    if (_arg1$$4.tail != null) {\n      if (_arg1$$4.tail.tail == null) {\n        return some(_arg1$$4.head);\n      } else {\n        const $_arg1$$4$$3 = _arg1$$4;\n        _arg1$$4 = $_arg1$$4$$3.tail;\n        continue tryLast;\n      }\n    } else {\n      return null;\n    }\n\n    break;\n  }\n}\nexport function compareWith(comparer, xs$$3, ys) {\n  if (xs$$3 === ys) {\n    return 0;\n  } else {\n    const loop = function loop(xs$$4, ys$$1) {\n      loop: while (true) {\n        const matchValue = [xs$$4, ys$$1];\n\n        if (matchValue[0].tail != null) {\n          if (matchValue[1].tail != null) {\n            const matchValue$$1 = comparer(matchValue[0].head, matchValue[1].head) | 0;\n\n            if (matchValue$$1 === 0) {\n              xs$$4 = matchValue[0].tail;\n              ys$$1 = matchValue[1].tail;\n              continue loop;\n            } else {\n              const res = matchValue$$1 | 0;\n              return res | 0;\n            }\n          } else {\n            return 1;\n          }\n        } else if (matchValue[1].tail == null) {\n          return 0;\n        } else {\n          return -1 | 0;\n        }\n\n        break;\n      }\n    };\n\n    return loop(xs$$3, ys) | 0;\n  }\n}\nexport function foldIndexedAux($arg$$7, $arg$$8, $arg$$9, $arg$$10) {\n  foldIndexedAux: while (true) {\n    const f = $arg$$7,\n          i = $arg$$8,\n          acc = $arg$$9,\n          _arg1$$5 = $arg$$10;\n\n    if (_arg1$$5.tail != null) {\n      const xs$$6 = _arg1$$5.tail;\n      const x$$5 = _arg1$$5.head;\n      $arg$$7 = f;\n      $arg$$8 = i + 1;\n      $arg$$9 = f(i, acc, x$$5);\n      $arg$$10 = xs$$6;\n      continue foldIndexedAux;\n    } else {\n      return acc;\n    }\n\n    break;\n  }\n}\nexport function foldIndexed(f$$1, state, xs$$7) {\n  return foldIndexedAux(f$$1, 0, state, xs$$7);\n}\nexport function fold($arg$$14, $arg$$15, $arg$$16) {\n  fold: while (true) {\n    const f$$2 = $arg$$14,\n          state$$1 = $arg$$15,\n          xs$$8 = $arg$$16;\n\n    if (xs$$8.tail != null) {\n      const t = xs$$8.tail;\n      const h = xs$$8.head;\n      $arg$$14 = f$$2;\n      $arg$$15 = f$$2(state$$1, h);\n      $arg$$16 = t;\n      continue fold;\n    } else {\n      return state$$1;\n    }\n\n    break;\n  }\n}\nexport function reverse(xs$$9) {\n  return fold(function (acc$$1, x$$6) {\n    return new List(x$$6, acc$$1);\n  }, new List(), xs$$9);\n}\nexport function foldBack(f$$3, xs$$10, state$$2) {\n  return fold(function (acc$$2, x$$7) {\n    return f$$3(x$$7, acc$$2);\n  }, state$$2, reverse(xs$$10));\n}\nexport function toSeq(xs$$11) {\n  return map$$1(function (x$$8) {\n    return x$$8;\n  }, xs$$11);\n}\nexport function ofSeq(xs$$12) {\n  return reverse(fold$$1(function (acc$$3, x$$9) {\n    return new List(x$$9, acc$$3);\n  }, new List(), xs$$12));\n}\nexport function concat(lists) {\n  return reverse(fold$$1(function (state$$3, xs$$14) {\n    return fold(function f$$4(acc$$4, x$$10) {\n      return new List(x$$10, acc$$4);\n    }, state$$3, xs$$14);\n  }, new List(), lists));\n}\nexport function foldIndexed2Aux($arg$$20, $arg$$21, $arg$$22, $arg$$23, $arg$$24) {\n  foldIndexed2Aux: while (true) {\n    const f$$5 = $arg$$20,\n          i$$1 = $arg$$21,\n          acc$$5 = $arg$$22,\n          bs = $arg$$23,\n          cs = $arg$$24;\n    const matchValue$$2 = [bs, cs];\n    var $target$$25, x$$11, xs$$16, y$$1, ys$$3;\n\n    if (matchValue$$2[0].tail != null) {\n      if (matchValue$$2[1].tail != null) {\n        $target$$25 = 1;\n        x$$11 = matchValue$$2[0].head;\n        xs$$16 = matchValue$$2[0].tail;\n        y$$1 = matchValue$$2[1].head;\n        ys$$3 = matchValue$$2[1].tail;\n      } else {\n        $target$$25 = 2;\n      }\n    } else if (matchValue$$2[1].tail == null) {\n      $target$$25 = 0;\n    } else {\n      $target$$25 = 2;\n    }\n\n    switch ($target$$25) {\n      case 0:\n        {\n          return acc$$5;\n        }\n\n      case 1:\n        {\n          $arg$$20 = f$$5;\n          $arg$$21 = i$$1 + 1;\n          $arg$$22 = f$$5(i$$1, acc$$5, x$$11, y$$1);\n          $arg$$23 = xs$$16;\n          $arg$$24 = ys$$3;\n          continue foldIndexed2Aux;\n        }\n\n      case 2:\n        {\n          throw new Error(\"Lists had different lengths\");\n        }\n    }\n\n    break;\n  }\n}\nexport function foldIndexed2(f$$6, state$$4, xs$$17, ys$$4) {\n  return foldIndexed2Aux(f$$6, 0, state$$4, xs$$17, ys$$4);\n}\nexport function fold2(f$$7, state$$5, xs$$18, ys$$5) {\n  return fold2$$1(f$$7, state$$5, xs$$18, ys$$5);\n}\nexport function foldBack2(f$$8, xs$$19, ys$$6, state$$6) {\n  return foldBack2$$1(f$$8, xs$$19, ys$$6, state$$6);\n}\nexport function unfold(f$$9, state$$7) {\n  const unfoldInner = function unfoldInner(acc$$6, state$$8) {\n    unfoldInner: while (true) {\n      const matchValue$$3 = f$$9(state$$8);\n\n      if (matchValue$$3 != null) {\n        const x$$12 = matchValue$$3[0];\n        const state$$9 = matchValue$$3[1];\n        const $acc$$6$$40 = acc$$6;\n        acc$$6 = new List(x$$12, $acc$$6$$40);\n        state$$8 = state$$9;\n        continue unfoldInner;\n      } else {\n        return reverse(acc$$6);\n      }\n\n      break;\n    }\n  };\n\n  return unfoldInner(new List(), state$$7);\n}\nexport function foldIndexed3Aux($arg$$41, $arg$$42, $arg$$43, $arg$$44, $arg$$45, $arg$$46) {\n  foldIndexed3Aux: while (true) {\n    const f$$10 = $arg$$41,\n          i$$2 = $arg$$42,\n          acc$$7 = $arg$$43,\n          bs$$1 = $arg$$44,\n          cs$$1 = $arg$$45,\n          ds = $arg$$46;\n    const matchValue$$4 = [bs$$1, cs$$1, ds];\n    var $target$$47, x$$13, xs$$20, y$$2, ys$$7, z, zs;\n\n    if (matchValue$$4[0].tail != null) {\n      if (matchValue$$4[1].tail != null) {\n        if (matchValue$$4[2].tail != null) {\n          $target$$47 = 1;\n          x$$13 = matchValue$$4[0].head;\n          xs$$20 = matchValue$$4[0].tail;\n          y$$2 = matchValue$$4[1].head;\n          ys$$7 = matchValue$$4[1].tail;\n          z = matchValue$$4[2].head;\n          zs = matchValue$$4[2].tail;\n        } else {\n          $target$$47 = 2;\n        }\n      } else {\n        $target$$47 = 2;\n      }\n    } else if (matchValue$$4[1].tail == null) {\n      if (matchValue$$4[2].tail == null) {\n        $target$$47 = 0;\n      } else {\n        $target$$47 = 2;\n      }\n    } else {\n      $target$$47 = 2;\n    }\n\n    switch ($target$$47) {\n      case 0:\n        {\n          return acc$$7;\n        }\n\n      case 1:\n        {\n          $arg$$41 = f$$10;\n          $arg$$42 = i$$2 + 1;\n          $arg$$43 = f$$10(i$$2, acc$$7, x$$13, y$$2, z);\n          $arg$$44 = xs$$20;\n          $arg$$45 = ys$$7;\n          $arg$$46 = zs;\n          continue foldIndexed3Aux;\n        }\n\n      case 2:\n        {\n          throw new Error(\"Lists had different lengths\");\n        }\n    }\n\n    break;\n  }\n}\nexport function foldIndexed3(f$$11, seed, xs$$21, ys$$8, zs$$1) {\n  return foldIndexed3Aux(f$$11, 0, seed, xs$$21, ys$$8, zs$$1);\n}\nexport function fold3(f$$12, state$$10, xs$$22, ys$$9, zs$$2) {\n  return foldIndexed3(function (_arg1$$6, acc$$8, x$$14, y$$3, z$$1) {\n    return f$$12(acc$$8, x$$14, y$$3, z$$1);\n  }, state$$10, xs$$22, ys$$9, zs$$2);\n}\nexport function scan(f$$13, state$$11, xs$$23) {\n  return ofSeq(scan$$1(f$$13, state$$11, xs$$23));\n}\nexport function scanBack(f$$14, xs$$25, state$$12) {\n  return ofSeq(scanBack$$1(f$$14, xs$$25, state$$12));\n}\nexport function length(xs$$27) {\n  return fold(function (acc$$9, _arg1$$7) {\n    return acc$$9 + 1;\n  }, 0, xs$$27);\n}\nexport function append(xs$$28, ys$$10) {\n  return fold(function (acc$$10, x$$15) {\n    return new List(x$$15, acc$$10);\n  }, ys$$10, reverse(xs$$28));\n}\nexport function collect(f$$15, xs$$29) {\n  return ofSeq(collect$$1(f$$15, xs$$29));\n}\nexport function map(f$$16, xs$$31) {\n  return reverse(fold(function (acc$$11, x$$16) {\n    return new List(f$$16(x$$16), acc$$11);\n  }, new List(), xs$$31));\n}\nexport function mapIndexed(f$$17, xs$$33) {\n  return reverse(foldIndexed(function (i$$3, acc$$12, x$$17) {\n    return new List(f$$17(i$$3, x$$17), acc$$12);\n  }, new List(), xs$$33));\n}\nexport function indexed(xs$$35) {\n  return mapIndexed(function (i$$4, x$$18) {\n    return [i$$4, x$$18];\n  }, xs$$35);\n}\nexport function map2(f$$18, xs$$36, ys$$11) {\n  return reverse(fold2(function (acc$$13, x$$19, y$$4) {\n    return new List(f$$18(x$$19, y$$4), acc$$13);\n  }, new List(), xs$$36, ys$$11));\n}\nexport function mapIndexed2(f$$19, xs$$38, ys$$12) {\n  return reverse(foldIndexed2(function (i$$5, acc$$14, x$$20, y$$5) {\n    return new List(f$$19(i$$5, x$$20, y$$5), acc$$14);\n  }, new List(), xs$$38, ys$$12));\n}\nexport function map3(f$$20, xs$$40, ys$$13, zs$$3) {\n  return reverse(fold3(function (acc$$15, x$$21, y$$6, z$$2) {\n    return new List(f$$20(x$$21, y$$6, z$$2), acc$$15);\n  }, new List(), xs$$40, ys$$13, zs$$3));\n}\nexport function mapIndexed3(f$$21, xs$$42, ys$$14, zs$$4) {\n  return reverse(foldIndexed3(function (i$$6, acc$$16, x$$22, y$$7, z$$3) {\n    return new List(f$$21(i$$6, x$$22, y$$7, z$$3), acc$$16);\n  }, new List(), xs$$42, ys$$14, zs$$4));\n}\nexport function mapFold(f$$22, s, xs$$44) {\n  const foldFn = function foldFn(tupledArg, x$$23) {\n    const patternInput = f$$22(tupledArg[1], x$$23);\n    return [new List(patternInput[0], tupledArg[0]), patternInput[1]];\n  };\n\n  const patternInput$$1 = fold(foldFn, [new List(), s], xs$$44);\n  return [reverse(patternInput$$1[0]), patternInput$$1[1]];\n}\nexport function mapFoldBack(f$$23, xs$$45, s$$2) {\n  return mapFold(function (s$$3, v) {\n    return f$$23(v, s$$3);\n  }, s$$2, reverse(xs$$45));\n}\nexport function iterate(f$$24, xs$$46) {\n  fold(function (unitVar0, x$$24) {\n    f$$24(x$$24);\n  }, null, xs$$46);\n}\nexport function iterate2(f$$25, xs$$47, ys$$15) {\n  fold2(function (unitVar0$$1, x$$25, y$$8) {\n    f$$25(x$$25, y$$8);\n  }, null, xs$$47, ys$$15);\n}\nexport function iterateIndexed(f$$26, xs$$48) {\n  foldIndexed(function (i$$7, unitVar1, x$$26) {\n    f$$26(i$$7, x$$26);\n  }, null, xs$$48);\n}\nexport function iterateIndexed2(f$$27, xs$$49, ys$$16) {\n  foldIndexed2(function (i$$8, unitVar1$$1, x$$27, y$$9) {\n    f$$27(i$$8, x$$27, y$$9);\n  }, null, xs$$49, ys$$16);\n}\nexport function ofArray(xs$$50) {\n  let res$$1 = new List();\n\n  for (let i$$9 = count(xs$$50) - 1; i$$9 >= 0; i$$9--) {\n    res$$1 = new List(xs$$50[i$$9], res$$1);\n  }\n\n  return res$$1;\n}\nexport function empty() {\n  return new List();\n}\nexport function isEmpty(_arg1$$8) {\n  if (_arg1$$8.tail == null) {\n    return true;\n  } else {\n    return false;\n  }\n}\nexport function tryPickIndexedAux($arg$$100, $arg$$101, $arg$$102) {\n  tryPickIndexedAux: while (true) {\n    const f$$28 = $arg$$100,\n          i$$10 = $arg$$101,\n          _arg1$$9 = $arg$$102;\n\n    if (_arg1$$9.tail != null) {\n      const xs$$51 = _arg1$$9.tail;\n      const x$$28 = _arg1$$9.head;\n      const result = f$$28(i$$10, x$$28);\n\n      if (result == null) {\n        $arg$$100 = f$$28;\n        $arg$$101 = i$$10 + 1;\n        $arg$$102 = xs$$51;\n        continue tryPickIndexedAux;\n      } else {\n        return result;\n      }\n    } else {\n      return null;\n    }\n\n    break;\n  }\n}\nexport function tryPickIndexed(f$$29, xs$$52) {\n  return tryPickIndexedAux(f$$29, 0, xs$$52);\n}\nexport function tryPick(f$$30, xs$$53) {\n  return tryPickIndexed(function (_arg1$$10, x$$29) {\n    return f$$30(x$$29);\n  }, xs$$53);\n}\nexport function pick(f$$31, xs$$54) {\n  const matchValue$$5 = tryPick(f$$31, xs$$54);\n\n  if (matchValue$$5 != null) {\n    const x$$30 = value$$1(matchValue$$5);\n    return x$$30;\n  } else {\n    throw new Error(\"List did not contain any matching elements\");\n  }\n}\nexport function tryFindIndexed(f$$32, xs$$55) {\n  return tryPickIndexed(function (i$$11, x$$31) {\n    return f$$32(i$$11, x$$31) ? some(x$$31) : null;\n  }, xs$$55);\n}\nexport function tryFind(f$$33, xs$$56) {\n  return tryPickIndexed(function (_arg1$$11, x$$32) {\n    return f$$33(x$$32) ? some(x$$32) : null;\n  }, xs$$56);\n}\nexport function findIndexed(f$$34, xs$$57) {\n  const matchValue$$6 = tryFindIndexed(f$$34, xs$$57);\n\n  if (matchValue$$6 != null) {\n    const x$$33 = value$$1(matchValue$$6);\n    return x$$33;\n  } else {\n    throw new Error(\"List did not contain any matching elements\");\n  }\n}\nexport function find(f$$35, xs$$58) {\n  return findIndexed(function (_arg1$$12, x$$34) {\n    return f$$35(x$$34);\n  }, xs$$58);\n}\nexport function findBack(f$$36, xs$$59) {\n  return find(f$$36, reverse(xs$$59));\n}\nexport function tryFindBack(f$$37, xs$$62) {\n  return tryFind(f$$37, reverse(xs$$62));\n}\nexport function tryFindIndex(f$$38, xs$$65) {\n  return tryPickIndexed(function (i$$12, x$$35) {\n    return f$$38(x$$35) ? i$$12 : null;\n  }, xs$$65);\n}\nexport function tryFindIndexBack(f$$39, xs$$66) {\n  return tryFindIndexBack$$1(f$$39, ofList(xs$$66, Array));\n}\nexport function findIndex(f$$40, xs$$67) {\n  const matchValue$$7 = tryFindIndex(f$$40, xs$$67);\n\n  if (matchValue$$7 != null) {\n    const x$$36 = matchValue$$7 | 0;\n    return x$$36 | 0;\n  } else {\n    throw new Error(\"List did not contain any matching elements\");\n  }\n}\nexport function findIndexBack(f$$41, xs$$68) {\n  return findIndexBack$$1(f$$41, ofList(xs$$68, Array));\n}\nexport function item(n, xs$$69) {\n  return findIndexed(function (i$$13, _arg1$$13) {\n    return n === i$$13;\n  }, xs$$69);\n}\nexport function tryItem(n$$1, xs$$70) {\n  return tryFindIndexed(function (i$$14, _arg1$$14) {\n    return n$$1 === i$$14;\n  }, xs$$70);\n}\nexport function filter(f$$42, xs$$71) {\n  return reverse(fold(function (acc$$17, x$$37) {\n    return f$$42(x$$37) ? new List(x$$37, acc$$17) : acc$$17;\n  }, new List(), xs$$71));\n}\nexport function partition(f$$43, xs$$73) {\n  return fold(function (tupledArg$$1, x$$38) {\n    return f$$43(x$$38) ? [new List(x$$38, tupledArg$$1[0]), tupledArg$$1[1]] : [tupledArg$$1[0], new List(x$$38, tupledArg$$1[1])];\n  }, [new List(), new List()], reverse(xs$$73));\n}\nexport function choose(f$$44, xs$$74) {\n  return reverse(fold(function (acc$$18, x$$39) {\n    const matchValue$$8 = f$$44(x$$39);\n\n    if (matchValue$$8 == null) {\n      return acc$$18;\n    } else {\n      const y$$10 = value$$1(matchValue$$8);\n      return new List(y$$10, acc$$18);\n    }\n  }, new List(), xs$$74));\n}\nexport function contains(value, list, eq) {\n  const loop$$1 = function loop$$1(xs$$76) {\n    loop$$1: while (true) {\n      if (xs$$76.tail != null) {\n        const v$$1 = xs$$76.head;\n        const rest = xs$$76.tail;\n\n        if (eq.Equals(value, v$$1)) {\n          return true;\n        } else {\n          xs$$76 = rest;\n          continue loop$$1;\n        }\n      } else {\n        return false;\n      }\n\n      break;\n    }\n  };\n\n  return loop$$1(list);\n}\nexport function except(itemsToExclude, array$$2, eq$$1) {\n  if (isEmpty(array$$2)) {\n    return array$$2;\n  } else {\n    const cached = createMutable(itemsToExclude, comparerFromEqualityComparer(eq$$1));\n    return filter(function f$$45(arg00) {\n      return addToSet(arg00, cached);\n    }, array$$2);\n  }\n}\nexport function initialize(n$$2, f$$46) {\n  let xs$$78 = new List();\n\n  for (let i$$15 = 1; i$$15 <= n$$2; i$$15++) {\n    xs$$78 = new List(f$$46(n$$2 - i$$15), xs$$78);\n  }\n\n  return xs$$78;\n}\nexport function replicate(n$$3, x$$40) {\n  return initialize(n$$3, function (_arg1$$15) {\n    return x$$40;\n  });\n}\nexport function reduce(f$$47, _arg1$$16) {\n  if (_arg1$$16.tail != null) {\n    const t$$1 = _arg1$$16.tail;\n    const h$$1 = _arg1$$16.head;\n    return fold(f$$47, h$$1, t$$1);\n  } else {\n    throw new Error(\"List was empty\");\n  }\n}\nexport function reduceBack(f$$48, _arg1$$17) {\n  if (_arg1$$17.tail != null) {\n    const t$$2 = _arg1$$17.tail;\n    const h$$2 = _arg1$$17.head;\n    return foldBack(f$$48, t$$2, h$$2);\n  } else {\n    throw new Error(\"List was empty\");\n  }\n}\nexport function forAll(f$$49, xs$$79) {\n  return fold(function (acc$$19, x$$41) {\n    return acc$$19 ? f$$49(x$$41) : false;\n  }, true, xs$$79);\n}\nexport function forAll2(f$$50, xs$$80, ys$$17) {\n  return fold2(function (acc$$20, x$$42, y$$11) {\n    return acc$$20 ? f$$50(x$$42, y$$11) : false;\n  }, true, xs$$80, ys$$17);\n}\nexport function exists($arg$$146, $arg$$147) {\n  exists: while (true) {\n    const f$$51 = $arg$$146,\n          _arg1$$18 = $arg$$147;\n\n    if (_arg1$$18.tail != null) {\n      const xs$$81 = _arg1$$18.tail;\n      const x$$43 = _arg1$$18.head;\n\n      if (f$$51(x$$43)) {\n        return true;\n      } else {\n        $arg$$146 = f$$51;\n        $arg$$147 = xs$$81;\n        continue exists;\n      }\n    } else {\n      return false;\n    }\n\n    break;\n  }\n}\nexport function exists2($arg$$148, $arg$$149, $arg$$150) {\n  exists2: while (true) {\n    const f$$52 = $arg$$148,\n          bs$$2 = $arg$$149,\n          cs$$2 = $arg$$150;\n    const matchValue$$9 = [bs$$2, cs$$2];\n    var $target$$151, x$$44, xs$$82, y$$12, ys$$18;\n\n    if (matchValue$$9[0].tail != null) {\n      if (matchValue$$9[1].tail != null) {\n        $target$$151 = 1;\n        x$$44 = matchValue$$9[0].head;\n        xs$$82 = matchValue$$9[0].tail;\n        y$$12 = matchValue$$9[1].head;\n        ys$$18 = matchValue$$9[1].tail;\n      } else {\n        $target$$151 = 2;\n      }\n    } else if (matchValue$$9[1].tail == null) {\n      $target$$151 = 0;\n    } else {\n      $target$$151 = 2;\n    }\n\n    switch ($target$$151) {\n      case 0:\n        {\n          return false;\n        }\n\n      case 1:\n        {\n          if (f$$52(x$$44, y$$12)) {\n            return true;\n          } else {\n            $arg$$148 = f$$52;\n            $arg$$149 = xs$$82;\n            $arg$$150 = ys$$18;\n            continue exists2;\n          }\n        }\n\n      case 2:\n        {\n          throw new Error(\"Lists had different lengths\");\n        }\n    }\n\n    break;\n  }\n}\nexport function unzip(xs$$83) {\n  return foldBack(function (tupledArg$$2, tupledArg$$3) {\n    return [new List(tupledArg$$2[0], tupledArg$$3[0]), new List(tupledArg$$2[1], tupledArg$$3[1])];\n  }, xs$$83, [new List(), new List()]);\n}\nexport function unzip3(xs$$84) {\n  return foldBack(function (tupledArg$$4, tupledArg$$5) {\n    return [new List(tupledArg$$4[0], tupledArg$$5[0]), new List(tupledArg$$4[1], tupledArg$$5[1]), new List(tupledArg$$4[2], tupledArg$$5[2])];\n  }, xs$$84, [new List(), new List(), new List()]);\n}\nexport function zip(xs$$85, ys$$19) {\n  return map2(function (x$$47, y$$15) {\n    return [x$$47, y$$15];\n  }, xs$$85, ys$$19);\n}\nexport function zip3(xs$$86, ys$$20, zs$$5) {\n  return map3(function (x$$48, y$$16, z$$5) {\n    return [x$$48, y$$16, z$$5];\n  }, xs$$86, ys$$20, zs$$5);\n}\nexport function sort(xs$$87, comparer$$1) {\n  var xs$$88;\n  return ofArray((xs$$88 = ofList(xs$$87, Array), (xs$$88.sort(function (x$$49, y$$17) {\n    return comparer$$1.Compare(x$$49, y$$17);\n  }), xs$$88)));\n}\nexport function sortBy(projection, xs$$90, comparer$$3) {\n  var xs$$91;\n  return ofArray((xs$$91 = ofList(xs$$90, Array), (xs$$91.sort(function (x$$50, y$$18) {\n    return comparer$$3.Compare(projection(x$$50), projection(y$$18));\n  }), xs$$91)));\n}\nexport function sortDescending(xs$$93, comparer$$5) {\n  var xs$$94;\n  return ofArray((xs$$94 = ofList(xs$$93, Array), (xs$$94.sort(function (x$$51, y$$19) {\n    return comparer$$5.Compare(x$$51, y$$19) * -1;\n  }), xs$$94)));\n}\nexport function sortByDescending(projection$$1, xs$$96, comparer$$7) {\n  var xs$$97;\n  return ofArray((xs$$97 = ofList(xs$$96, Array), (xs$$97.sort(function (x$$52, y$$20) {\n    return comparer$$7.Compare(projection$$1(x$$52), projection$$1(y$$20)) * -1;\n  }), xs$$97)));\n}\nexport function sortWith(comparer$$9, xs$$99) {\n  var xs$$100;\n  return ofArray((xs$$100 = ofList(xs$$99, Array), (xs$$100.sort(comparer$$9), xs$$100)));\n}\nexport function sum(xs$$102, adder) {\n  return fold(function (acc$$21, x$$53) {\n    return adder.Add(acc$$21, x$$53);\n  }, adder.GetZero(), xs$$102);\n}\nexport function sumBy(f$$53, xs$$103, adder$$1) {\n  return fold(function (acc$$22, x$$54) {\n    return adder$$1.Add(acc$$22, f$$53(x$$54));\n  }, adder$$1.GetZero(), xs$$103);\n}\nexport function maxBy(projection$$2, xs$$104, comparer$$11) {\n  return reduce(function (x$$55, y$$21) {\n    return comparer$$11.Compare(projection$$2(y$$21), projection$$2(x$$55)) > 0 ? y$$21 : x$$55;\n  }, xs$$104);\n}\nexport function max(li, comparer$$12) {\n  return reduce(function (x$$56, y$$22) {\n    return comparer$$12.Compare(y$$22, x$$56) > 0 ? y$$22 : x$$56;\n  }, li);\n}\nexport function minBy(projection$$3, xs$$105, comparer$$13) {\n  return reduce(function (x$$57, y$$23) {\n    return comparer$$13.Compare(projection$$3(y$$23), projection$$3(x$$57)) > 0 ? x$$57 : y$$23;\n  }, xs$$105);\n}\nexport function min(xs$$106, comparer$$14) {\n  return reduce(function (x$$58, y$$24) {\n    return comparer$$14.Compare(y$$24, x$$58) > 0 ? x$$58 : y$$24;\n  }, xs$$106);\n}\nexport function average(xs$$107, averager) {\n  const total = fold(function (acc$$23, x$$59) {\n    return averager.Add(acc$$23, x$$59);\n  }, averager.GetZero(), xs$$107);\n  return averager.DivideByInt(total, length(xs$$107));\n}\nexport function averageBy(f$$54, xs$$108, averager$$1) {\n  const total$$1 = fold(function (acc$$24, x$$60) {\n    return averager$$1.Add(acc$$24, f$$54(x$$60));\n  }, averager$$1.GetZero(), xs$$108);\n  return averager$$1.DivideByInt(total$$1, length(xs$$108));\n}\nexport function permute(f$$55, xs$$109) {\n  return ofArray(permute$$1(f$$55, ofList(xs$$109, Array)));\n}\nexport function skip(i$$16, xs$$111) {\n  const skipInner = function skipInner(i$$17, xs$$112) {\n    skipInner: while (true) {\n      const matchValue$$10 = [i$$17, xs$$112];\n\n      if (matchValue$$10[0] === 0) {\n        return xs$$112;\n      } else if (matchValue$$10[1].tail != null) {\n        const xs$$113 = matchValue$$10[1].tail;\n        const $i$$17$$174 = i$$17;\n        i$$17 = $i$$17$$174 - 1;\n        xs$$112 = xs$$113;\n        continue skipInner;\n      } else {\n        throw new Error(\"The input sequence has an insufficient number of elements.\");\n      }\n\n      break;\n    }\n  };\n\n  const matchValue$$11 = [i$$16, xs$$111];\n\n  if (matchValue$$11[0] < 0) {\n    throw new Error(\"The input must be non-negative.\");\n  } else {\n    var $target$$175, i$$20, xs$$115;\n\n    if (matchValue$$11[0] === 0) {\n      $target$$175 = 0;\n    } else if (matchValue$$11[0] === 1) {\n      if (matchValue$$11[1].tail != null) {\n        $target$$175 = 1;\n      } else {\n        $target$$175 = 2;\n        i$$20 = matchValue$$11[0];\n        xs$$115 = matchValue$$11[1];\n      }\n    } else {\n      $target$$175 = 2;\n      i$$20 = matchValue$$11[0];\n      xs$$115 = matchValue$$11[1];\n    }\n\n    switch ($target$$175) {\n      case 0:\n        {\n          return xs$$111;\n        }\n\n      case 1:\n        {\n          const xs$$114 = matchValue$$11[1].tail;\n          return xs$$114;\n        }\n\n      case 2:\n        {\n          return skipInner(i$$20, xs$$115);\n        }\n    }\n  }\n}\nexport function skipWhile($arg$$176, $arg$$177) {\n  var t$$3, h$$3;\n\n  skipWhile: while (true) {\n    const predicate = $arg$$176,\n          xs$$116 = $arg$$177;\n    var $target$$178, h$$4, t$$4;\n\n    if (xs$$116.tail != null) {\n      if (t$$3 = xs$$116.tail, (h$$3 = xs$$116.head, predicate(h$$3))) {\n        $target$$178 = 0;\n        h$$4 = xs$$116.head;\n        t$$4 = xs$$116.tail;\n      } else {\n        $target$$178 = 1;\n      }\n    } else {\n      $target$$178 = 1;\n    }\n\n    switch ($target$$178) {\n      case 0:\n        {\n          $arg$$176 = predicate;\n          $arg$$177 = t$$4;\n          continue skipWhile;\n        }\n\n      case 1:\n        {\n          return xs$$116;\n        }\n    }\n\n    break;\n  }\n}\nexport function takeSplitAux(error, i$$21, acc$$25, xs$$117) {\n  takeSplitAux: while (true) {\n    const matchValue$$12 = [i$$21, xs$$117];\n\n    if (matchValue$$12[0] === 0) {\n      return [reverse(acc$$25), xs$$117];\n    } else if (matchValue$$12[1].tail != null) {\n      const xs$$118 = matchValue$$12[1].tail;\n      const x$$61 = matchValue$$12[1].head;\n      const $acc$$25$$181 = acc$$25;\n      const $error$$179 = error;\n      const $i$$21$$180 = i$$21;\n      error = $error$$179;\n      i$$21 = $i$$21$$180 - 1;\n      acc$$25 = new List(x$$61, $acc$$25$$181);\n      xs$$117 = xs$$118;\n      continue takeSplitAux;\n    } else {\n      if (error) {\n        throw new Error(\"The input sequence has an insufficient number of elements.\");\n      } else {\n        return [reverse(acc$$25), xs$$117];\n      }\n    }\n\n    break;\n  }\n}\nexport function take(i$$22, xs$$119) {\n  const matchValue$$13 = [i$$22, xs$$119];\n\n  if (matchValue$$13[0] < 0) {\n    throw new Error(\"The input must be non-negative.\");\n  } else {\n    var $target$$182, i$$25, xs$$120;\n\n    if (matchValue$$13[0] === 0) {\n      $target$$182 = 0;\n    } else if (matchValue$$13[0] === 1) {\n      if (matchValue$$13[1].tail != null) {\n        $target$$182 = 1;\n      } else {\n        $target$$182 = 2;\n        i$$25 = matchValue$$13[0];\n        xs$$120 = matchValue$$13[1];\n      }\n    } else {\n      $target$$182 = 2;\n      i$$25 = matchValue$$13[0];\n      xs$$120 = matchValue$$13[1];\n    }\n\n    switch ($target$$182) {\n      case 0:\n        {\n          return new List();\n        }\n\n      case 1:\n        {\n          const x$$62 = matchValue$$13[1].head;\n          return new List(x$$62, new List());\n        }\n\n      case 2:\n        {\n          return takeSplitAux(true, i$$25, new List(), xs$$120)[0];\n        }\n    }\n  }\n}\nexport function takeWhile(predicate$$1, xs$$121) {\n  if (xs$$121.tail != null) {\n    if (xs$$121.tail.tail == null) {\n      if (predicate$$1(xs$$121.head)) {\n        return xs$$121;\n      } else {\n        return xs$$121.tail;\n      }\n    } else {\n      if (!predicate$$1(xs$$121.head)) {\n        return new List();\n      } else {\n        return new List(xs$$121.head, takeWhile(predicate$$1, xs$$121.tail));\n      }\n    }\n  } else {\n    return xs$$121;\n  }\n}\nexport function truncate(i$$26, xs$$123) {\n  const matchValue$$14 = [i$$26, xs$$123];\n\n  if (matchValue$$14[0] < 0) {\n    throw new Error(\"The input must be non-negative.\");\n  } else {\n    var $target$$185, i$$29, xs$$124;\n\n    if (matchValue$$14[0] === 0) {\n      $target$$185 = 0;\n    } else if (matchValue$$14[0] === 1) {\n      if (matchValue$$14[1].tail != null) {\n        $target$$185 = 1;\n      } else {\n        $target$$185 = 2;\n        i$$29 = matchValue$$14[0];\n        xs$$124 = matchValue$$14[1];\n      }\n    } else {\n      $target$$185 = 2;\n      i$$29 = matchValue$$14[0];\n      xs$$124 = matchValue$$14[1];\n    }\n\n    switch ($target$$185) {\n      case 0:\n        {\n          return new List();\n        }\n\n      case 1:\n        {\n          const x$$65 = matchValue$$14[1].head;\n          return new List(x$$65, new List());\n        }\n\n      case 2:\n        {\n          return takeSplitAux(false, i$$29, new List(), xs$$124)[0];\n        }\n    }\n  }\n}\nexport function splitAt(i$$30, xs$$125) {\n  const matchValue$$15 = [i$$30, xs$$125];\n\n  if (matchValue$$15[0] < 0) {\n    throw new Error(\"The input must be non-negative.\");\n  } else {\n    var $target$$186, i$$33, xs$$127;\n\n    if (matchValue$$15[0] === 0) {\n      $target$$186 = 0;\n    } else if (matchValue$$15[0] === 1) {\n      if (matchValue$$15[1].tail != null) {\n        $target$$186 = 1;\n      } else {\n        $target$$186 = 2;\n        i$$33 = matchValue$$15[0];\n        xs$$127 = matchValue$$15[1];\n      }\n    } else {\n      $target$$186 = 2;\n      i$$33 = matchValue$$15[0];\n      xs$$127 = matchValue$$15[1];\n    }\n\n    switch ($target$$186) {\n      case 0:\n        {\n          return [new List(), xs$$125];\n        }\n\n      case 1:\n        {\n          const xs$$126 = matchValue$$15[1].tail;\n          const x$$66 = matchValue$$15[1].head;\n          return [new List(x$$66, new List()), xs$$126];\n        }\n\n      case 2:\n        {\n          return takeSplitAux(true, i$$33, new List(), xs$$127);\n        }\n    }\n  }\n}\nexport function outOfRange() {\n  throw new Error(\"Index out of range\");\n}\nexport function slice(lower, upper, xs$$128) {\n  const lower$$1 = defaultArg(lower, 0) | 0;\n  const hasUpper = upper != null;\n\n  if (lower$$1 < 0) {\n    return outOfRange();\n  } else if (hasUpper ? upper < lower$$1 : false) {\n    return new List();\n  } else {\n    let lastIndex = -1 | 0;\n    const res$$2 = foldIndexed(function f$$56(i$$34, acc$$26, x$$67) {\n      lastIndex = i$$34;\n\n      if (lower$$1 <= i$$34 ? !hasUpper ? true : i$$34 <= upper : false) {\n        return new List(x$$67, acc$$26);\n      } else {\n        return acc$$26;\n      }\n    }, new List(), xs$$128);\n\n    if (lower$$1 > lastIndex + 1 ? true : hasUpper ? upper > lastIndex : false) {\n      outOfRange();\n    }\n\n    return reverse(res$$2);\n  }\n}\nexport function distinctBy(projection$$4, xs$$130, eq$$2) {\n  const hashSet = createMutable([], comparerFromEqualityComparer(eq$$2));\n  return filter(function f$$57($arg$$1) {\n    return addToSet(projection$$4($arg$$1), hashSet);\n  }, xs$$130);\n}\nexport function distinct(xs$$132, eq$$3) {\n  return distinctBy(function (x$$68) {\n    return x$$68;\n  }, xs$$132, eq$$3);\n}\nexport function exactlyOne(xs$$133) {\n  if (xs$$133.tail != null) {\n    if (xs$$133.tail.tail != null) {\n      throw new Error(\"Input list too long\\\\nParameter name: list\");\n    } else {\n      return xs$$133.head;\n    }\n  } else {\n    throw new Error(\"The input sequence was empty\\\\nParameter name: list\");\n  }\n}\nexport function groupBy(projection$$5, xs$$135, eq$$4) {\n  const dict = createMutable$$1([], comparerFromEqualityComparer(eq$$4));\n  const keys = [];\n  iterate$$1(function (v$$2) {\n    const key = projection$$5(v$$2);\n    const matchValue$$16 = tryGetValue(dict, key, null);\n\n    if (matchValue$$16[0]) {\n      dict.set(key, new List(v$$2, matchValue$$16[1]));\n    } else {\n      addToDict(dict, key, new List(v$$2, new List()));\n      keys.push(key);\n    }\n  }, xs$$135);\n  return ofSeq(map$$1(function mapping(key$$1) {\n    return [key$$1, reverse(getItemFromDict(dict, key$$1))];\n  }, keys));\n}\nexport function countBy(projection$$6, xs$$137, eq$$5) {\n  const dict$$1 = createMutable$$1([], comparerFromEqualityComparer(eq$$5));\n  iterate(function (v$$3) {\n    const key$$2 = projection$$6(v$$3);\n    const matchValue$$17 = tryGetValue(dict$$1, key$$2, null);\n\n    if (matchValue$$17[0]) {\n      matchValue$$17[1].contents = matchValue$$17[1].contents + 1;\n    } else {\n      dict$$1.set(key$$2, new FSharpRef(1));\n    }\n  }, xs$$137);\n  let result$$1 = new List();\n  iterate$$1(function (group) {\n    result$$1 = new List([group[0], group[1].contents], result$$1);\n  }, dict$$1);\n  return result$$1;\n}\nexport function where(predicate$$2, xs$$138) {\n  return filter(predicate$$2, xs$$138);\n}\nexport function pairwise(xs$$139) {\n  const inner = function inner(xs$$140, acc$$27, x1$$1) {\n    inner: while (true) {\n      if (xs$$140.tail != null) {\n        const xs$$141 = xs$$140.tail;\n        const x2$$1 = xs$$140.head;\n        acc$$27.push([x1$$1, x2$$1]);\n        const $acc$$27$$198 = acc$$27;\n        xs$$140 = xs$$141;\n        acc$$27 = $acc$$27$$198;\n        x1$$1 = x2$$1;\n        continue inner;\n      } else {\n        return ofArray(acc$$27);\n      }\n\n      break;\n    }\n  };\n\n  var $target$$199, x1$$2, x2$$2, xs$$142;\n\n  if (xs$$139.tail != null) {\n    if (xs$$139.tail.tail != null) {\n      $target$$199 = 1;\n      x1$$2 = xs$$139.head;\n      x2$$2 = xs$$139.tail.head;\n      xs$$142 = xs$$139.tail.tail;\n    } else {\n      $target$$199 = 0;\n    }\n  } else {\n    $target$$199 = 0;\n  }\n\n  switch ($target$$199) {\n    case 0:\n      {\n        return new List();\n      }\n\n    case 1:\n      {\n        const acc$$28 = [];\n        acc$$28.push([x1$$2, x2$$2]);\n        return function (arg00$$2) {\n          const clo1 = partialApply(2, inner, [arg00$$2]);\n          return function (arg10) {\n            const clo2 = clo1(arg10);\n            return function (arg20) {\n              return clo2(arg20);\n            };\n          };\n        }(xs$$142)(acc$$28)(x2$$2);\n      }\n  }\n}\nexport function windowed(windowSize, source$$1) {\n  if (windowSize <= 0) {\n    throw new Error(\"windowSize must be positive\");\n  }\n\n  let res$$3 = new List();\n\n  for (let i$$35 = length(source$$1); i$$35 >= windowSize; i$$35--) {\n    res$$3 = new List(slice(i$$35 - windowSize, i$$35 - 1, source$$1), res$$3);\n  }\n\n  return res$$3;\n}","namespace Informedica.GenForm.Shared\r\n\r\nmodule Models =\r\n\r\n    let ages =\r\n        let tostr s x i = x, sprintf \"%i %s\" i s\r\n        [1..19] \r\n        |> (fun xs ->\r\n            xs\r\n            |> List.mapi (fun i x -> \r\n                match i with\r\n                | _ when xs |> List.length = i + 1 ->\r\n                    ((x |> float) * 12.0),\r\n                    sprintf \">%i jaar\" (x - 1)  \r\n                | _ ->\r\n                    tostr \"jaar\" ((x |> float) * 12.0) x\r\n            )\r\n        )\r\n        |> List.append ([0..11] |> List.map (fun x ->  tostr \"maanden\" (float x) x))\r\n\r\n    let weights =\r\n        let xs =\r\n            [ 1.5 .. 0.5 .. 3.5] @\r\n            [4.0 .. 1.0 .. 20.0] @\r\n            [25.0 .. 5.0 .. 75.]\r\n        xs\r\n        |> List.mapi (fun i x ->\r\n            match i with\r\n            | _ when i = 0 ->                       x, sprintf \"<%A kg\" x\r\n            | _ when i + 1 = (xs |> List.length) -> x, sprintf \">%A kg\" x\r\n            | _ ->                                  x, sprintf \"%A kg\" x\r\n        )\r\n        |> List.map (fun (x, s) -> x, s.Replace(\".0\", \"\"))\r\n\r\n    type Patient =\r\n        {\r\n            Age : string option\r\n            Weight : string option\r\n        }\r\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","namespace Fable.MaterialUI\nopen Fable.Core\nopen Fable.Core.JsInterop\n\nmodule Core =\n    open Fable.React\n    open Fable.React.Props\n    open Fable.MaterialUI.Props\n    open Fable.MaterialUI.Themes\n\n    let toObj p = keyValueList CaseRules.LowerFirst p\n\n    let inline appBar (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/AppBar\" (toObj b) c\n    let inline avatar (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Avatar\" (toObj b) c\n    let inline backdrop (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Backdrop\" (toObj b) []\n    let inline badge (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Badge\" (toObj b) c\n    let inline bottomNavigation (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/BottomNavigation\" (toObj b) c\n    let inline bottomNavigationAction (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/BottomNavigationAction\" (toObj b) []\n    let inline button (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Button\" (toObj b) c\n    let inline buttonBase (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ButtonBase\" (toObj b) c\n    let inline card (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Card\" (toObj b) c\n    let inline cardActionArea (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/CardActionArea\" (toObj b) c\n    let inline cardActions (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/CardActions\" (toObj b) c\n    let inline cardContent (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/CardContent\" (toObj b) c\n    let inline cardHeader (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/CardHeader\" (toObj b) c\n    let inline cardMedia (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/CardMedia\" (toObj b) []\n    let inline checkbox (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Checkbox\" (toObj b) []\n    let inline chip (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Chip\" (toObj b) []\n    let inline circularProgress (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/CircularProgress\" (toObj b) []\n    let inline clickAwayListener (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ClickAwayListener\" (toObj b) c\n    let inline collapse (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Collapse\" (toObj b) c\n    let inline cssBaseline (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/CssBaseline\" (toObj b) []\n    let inline dialog (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Dialog\" (toObj b) c\n    let inline dialogActions (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/DialogActions\" (toObj b) c\n    let inline dialogContent (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/DialogContent\" (toObj b) c\n    let inline dialogContentText (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/DialogContentText\" (toObj b) c\n    let inline dialogTitle (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/DialogTitle\" (toObj b) c\n    let inline divider (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Divider\" (toObj b) []\n    let inline drawer (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Drawer\" (toObj b) c\n    let inline expansionPanel (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ExpansionPanel\" (toObj b) c\n    let inline expansionPanelActions (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ExpansionPanelActions\" (toObj b) c\n    let inline expansionPanelDetails (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ExpansionPanelDetails\" (toObj b) c\n    let inline expansionPanelSummary (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ExpansionPanelSummary\" (toObj b) c\n    let inline fab (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Fab\" (toObj b) c\n    let inline fade (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Fade\" (toObj b) c\n    let inline filledInput (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/FilledInput\" (toObj b) c\n    let inline formControl (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/FormControl\" (toObj b) c\n    let inline formControlLabel (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/FormControlLabel\" (toObj b) c\n    let inline formGroup (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/FormGroup\" (toObj b) c\n    let inline formHelperText (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/FormHelperText\" (toObj b) c\n    let inline formLabel (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/FormLabel\" (toObj b) c\n    let inline grid (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Grid\" (toObj b) c\n    let inline gridList (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/GridList\" (toObj b) c\n    let inline gridListTile (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/GridListTile\" (toObj b) c\n    let inline gridListTileBar (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/GridListTileBar\" (toObj b) c\n    let inline grow (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Grow\" (toObj b) c\n    let inline hidden (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Hidden\" (toObj b) c\n    let inline icon (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Icon\" (toObj b) c\n    let inline iconButton (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/IconButton\" (toObj b) c\n    let inline input (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Input\" (toObj b) []\n    let inline inputAdornment (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/InputAdornment\" (toObj b) c\n    let inline inputBase (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/InputBase\" (toObj b) []\n    let inline inputLabel (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/InputLabel\" (toObj b) c\n    let inline linearProgress (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/LinearProgress\" (toObj b) []\n    let inline link (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Link\" (toObj b) c\n    let inline list (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/List\" (toObj b) c\n    let inline listItem (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ListItem\" (toObj b) c\n    let inline listItemAvatar (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ListItemAvatar\" (toObj b) c\n    let inline listItemIcon (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ListItemIcon\" (toObj b) c\n    let inline listItemSecondaryAction (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ListItemSecondaryAction\" (toObj b) c\n    let inline listItemText (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ListItemText\" (toObj b) c\n    let inline listSubheader (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ListSubheader\" (toObj b) c\n    let inline menu (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Menu\" (toObj b) c\n    let inline menuItem (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/MenuItem\" (toObj b) c\n    let inline menuList (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/MenuList\" (toObj b) c\n    let inline mobileStepper (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/MobileStepper\" (toObj b) []\n    let inline modal (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Modal\" (toObj b) c\n    let inline nativeSelect (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/NativeSelect\" (toObj b) c\n    let inline outlinedInput (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/OutlinedInput\" (toObj b) c\n    let inline paper (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Paper\" (toObj b) c\n    let inline popover (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Popover\" (toObj b) c\n    let inline popper (b : IHTMLProp seq) (c : U2<ReactElement list, (PopperProps->ReactElement)>) : ReactElement =\n        ofImport \"default\" \"@material-ui/core/Popper\" (toObj b) (match c with\n                                                                 | U2.Case1 elements -> elements\n                                                                 | U2.Case2 func -> !![func] )\n    let inline portal (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Portal\" (toObj b) c\n    let inline radio (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Radio\" (toObj b) []\n    let inline radioGroup (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/RadioGroup\" (toObj b) c\n    let inline rootRef (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/RootRef\" (toObj b) c\n    let inline select (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Select\" (toObj b) c\n    let inline slide (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Slide\" (toObj b) c\n    let inline snackbar (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Snackbar\" (toObj b) c\n    let inline snackbarContent (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/SnackbarContent\" (toObj b) c\n    let inline step (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Step\" (toObj b) c\n    let inline stepButton (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/StepButton\" (toObj b) c\n    let inline stepConnector (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/StepConnector\" (toObj b) c\n    let inline stepContent (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/StepContent\" (toObj b) c\n    let inline stepIcon (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/StepIcon\" (toObj b) c\n    let inline stepLabel (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/StepLabel\" (toObj b) c\n    let inline stepper (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Stepper\" (toObj b) c\n    let inline svgIcon (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/SvgIcon\" (toObj b) c\n    let inline swipeableDrawer (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/SwipeableDrawer\" (toObj b) c\n    let inline switch (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Switch\" (toObj b) []\n    let inline tab (b : IHTMLProp seq) : ReactElement = ofImport \"default\" \"@material-ui/core/Tab\" (toObj b) []\n    let inline tabs (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Tabs\" (toObj b) c\n    let inline table (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Table\" (toObj b) c\n    let inline tableBody (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TableBody\" (toObj b) c\n    let inline tableCell (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TableCell\" (toObj b) c\n    let inline tableFooter (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TableFooter\" (toObj b) c\n    let inline tableHead (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TableHead\" (toObj b) c\n    let inline tablePagination (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TablePagination\" (toObj b) c\n    let inline tableRow (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TableRow\" (toObj b) c\n    let inline tableSortLabel (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TableSortLabel\" (toObj b) c\n    let inline textField (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/TextField\" (toObj b) c\n    let inline toolbar (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Toolbar\" (toObj b) c\n    let inline tooltip (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Tooltip\" (toObj b) c\n    let inline touchRipple (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/ButtonBase/TouchRipple\" (toObj b) c\n    let inline typography (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Typography\" (toObj b) c\n    let inline zoom (b : IHTMLProp seq) c : ReactElement = ofImport \"default\" \"@material-ui/core/Zoom\" (toObj b) c\n\n    type IClasses = interface end\n    type IClassesProps =\n        abstract member classes: IClasses\n\n    let withStyles'<'P, 'O when 'P :> IClassesProps>\n        styles (options: 'O) (fn : 'P->Fable.React.ReactElement) : Fable.React.ReactElementType<'P> =\n        !!((import \"withStyles\" \"@material-ui/core/styles\") $ (styles, options) $ fn)\n\n    let withStyles<'P when 'P :> IClassesProps>\n        (styles : StyleType)\n        (options: StyleOption seq)\n        (fn : 'P -> Fable.React.ReactElement) =\n        let styles' =\n            match styles with\n            | StyleType.Styles styles -> (keyValueList CaseRules.LowerFirst styles |> unbox)\n            | StyleType.Func func -> func >> keyValueList CaseRules.LowerFirst\n        withStyles' styles' (keyValueList CaseRules.LowerFirst options) fn\n\n    let inline muiThemeProvider (b : IHTMLProp seq) c = ofImport \"MuiThemeProvider\" \"@material-ui/core/styles\" (toObj b) c\n\n    [<Import(\"createMuiTheme\", \"@material-ui/core/styles\")>]\n    let private createMuiTheme'<'O> (options: 'O) : ITheme = jsNative\n\n    let createMuiTheme (options: ThemeProp seq) =\n        options\n        |> keyValueList CaseRules.LowerFirst\n        |> unbox\n        |> createMuiTheme'\n\n    type IThemeProps =\n        abstract member theme : ITheme\n\n    [<Import(\"withTheme\", \"@material-ui/core/styles\")>]\n    let withTheme' : obj = jsNative\n\n    let withTheme<'P when 'P :> IThemeProps>\n        (fn : 'P->Fable.React.ReactElement) : Fable.React.ReactElementType<'P> =\n        !!(withTheme' $ () $ fn)\n\n    let withWidth'<'O, 'P>\n        (options: 'O)\n        (fn : 'P->Fable.React.ReactElement) : Fable.React.ReactElementType<'P> =\n        !!((importDefault \"@material-ui/core/withWidth\") $ options $ fn)\n\n    let withWidth<'P>\n        (options: WithWidthOption seq)\n        (fn: ('P -> Fable.React.ReactElement)) =\n        withWidth' (keyValueList CaseRules.LowerFirst options |> unbox) fn\n\n    type IWidthProps =\n        abstract member width : Breakpoint\n\n    let isWidthUp (breakpoint : Breakpoint) (screenWidth : Breakpoint) (inclusive : bool) =\n        importMember \"@material-ui/core/withWidth\"\n\n    let isWidthDown (breakpoint : Breakpoint) (screenWidth : Breakpoint) (inclusive : bool) =\n        importMember \"@material-ui/core/withWidth\"\n\nmodule ColorManipulator =\n\n    [<StringEnum; RequireQualifiedAccess>]\n    type ColorFormat = Rgb | Rgba | Hsl | Hsla\n\n    type ColorObject =\n        abstract member ``type``: ColorFormat\n        abstract member values: float array\n\n    let recomposeColor (color: ColorObject): string =\n        import \"recomposeColor\" \"@material-ui/core/styles/colorManipulator\"\n\n    let convertHexToRGB (hex: string): string =\n        import \"convertHexToRGB\" \"@material-ui/core/styles/colorManipulator\"\n\n    let rbgToHex (color: string): string =\n        import \"rbgToHex\" \"@material-ui/core/styles/colorManipulator\"\n\n    let decomposeColor (color: string): ColorObject =\n        import \"decomposeColor\" \"@material-ui/core/styles/colorManipulator\"\n\n    let getContrastRatio ((foreground: string), (background: string)): float =\n        import \"getContrastRatio\" \"@material-ui/core/styles/colorManipulator\"\n\n    let getLuminance (color: string) =\n        import \"getLuminance\" \"@material-ui/core/styles/colorManipulator\"\n\n    let emphasize ((color: string), (coefficient: float)): string =\n        import \"emphasize\" \"@material-ui/core/styles/colorManipulator\"\n\n    let fade ((color: string), (value: float)): string =\n        import \"fade\" \"@material-ui/core/styles/colorManipulator\"\n\n    let darken ((color: string), (coefficient: float)): string =\n        import \"darken\" \"@material-ui/core/styles/colorManipulator\"\n\n    let lighten ((color: string), (coefficient: float)): string =\n        import \"lighten\" \"@material-ui/core/styles/colorManipulator\"\n","/// The Fetch API provides a JavaScript interface for accessing and manipulating parts of the HTTP pipeline, such as requests and responses.\n/// It also provides a global fetch() method that provides an easy, logical way to fetch resources asynchronously across the network.\nmodule Fetch\n\n#nowarn \"1182\" // Unused values\n\nopen System\nopen Fable.Core\nopen Fable.Core.JsInterop\nopen Browser.Types\n\n[<AutoOpen>]\nmodule Types =\n\n    type Body =\n        abstract bodyUsed: bool with get, set\n        abstract arrayBuffer: unit -> JS.Promise<JS.ArrayBuffer>\n        abstract blob: unit -> JS.Promise<Blob>\n        abstract formData: unit -> JS.Promise<FormData>\n        abstract json : unit -> JS.Promise<obj>\n        abstract json<'T> : unit -> JS.Promise<'T>\n        abstract text : unit -> JS.Promise<string>\n\n    and Request = //(input: U2<string, Request>, ?init: RequestInit) =\n        inherit Body\n        abstract ``method`` : string with get\n        abstract url: string with get\n        abstract headers: Headers with get\n        abstract referrer: string with get\n        abstract mode: U2<string,RequestMode> with get\n        abstract credentials: U2<string,RequestCredentials> with get\n        abstract cache: U2<string,RequestCache> with get\n        abstract clone: unit -> unit\n\n    and RequestInit =\n        abstract ``method``: string option with get, set\n        abstract headers: HeaderInit option with get, set\n        abstract body: BodyInit option with get, set\n        abstract mode: RequestMode option with get, set\n        abstract credentials: RequestCredentials option with get, set\n        abstract cache: RequestCache option with get, set\n\n    and [<StringEnum; RequireQualifiedAccess>] RequestContext =\n        | Audio | Beacon | Cspreport | Download | Embed | Eventsource | Favicon | Fetch | Font\n        | Form | Frame | Hyperlink | Iframe | Image | Imageset | Import | Internal | Location\n        | Manifest | Object | Ping | Plugin | Prefetch | Script | Serviceworker | Sharedworker\n        | Subresource | Style | Track | Video | Worker | Xmlhttprequest | Xslt\n\n    and [<StringEnum; RequireQualifiedAccess>] RequestMode =\n        | [<CompiledName(\"same-origin\")>]Sameorigin | [<CompiledName(\"no-cors\")>]Nocors | Cors\n\n    and [<StringEnum; RequireQualifiedAccess>] RequestCredentials =\n        Omit | [<CompiledName(\"same-origin\")>]Sameorigin | Include\n\n    and [<StringEnum; RequireQualifiedAccess>] RequestCache =\n        | Default\n        | [<CompiledName(\"no-store\")>]Nostore\n        | Reload\n        | [<CompiledName(\"no-cache\")>]Nocache\n        | [<CompiledName(\"force-cache\")>]Forcecache\n        | [<CompiledName(\"only-if-cached\")>]Onlyifcached\n\n    and Headers =\n        abstract append : string * string -> unit\n        abstract delete : string -> unit\n        abstract get : string -> string\n        abstract getAll : string -> string[]\n        abstract has : string -> bool\n        abstract set : string * string -> unit\n\n        /// Specifying which web sites can participate in cross-origin resource sharing\n        [<Emit(\"$0.get('Access-Control-Allow-Origin')\")>] abstract AccessControlAllowOrigin: string option\n\n        /// Specifies which patch document formats this server supports\n        [<Emit(\"$0.get('Accept-Patch')\")>] abstract AcceptPatch: string option\n\n        /// What partial content range types this server supports via byte serving\n        [<Emit(\"$0.get('Accept-Ranges')\")>] abstract AcceptRanges: string option\n\n        /// The age the object has been in a proxy cache in seconds\n        [<Emit(\"$0.get('Age')\")>] abstract Age: string option\n\n        /// Valid actions for a specified resource. To be used for a 405 Method not allowed\n        [<Emit(\"$0.get('Allow')\")>] abstract Allow: string option\n\n        /// A server uses \"Alt-Svc\" header (meaning Alternative Services) to indicate that its resources can also be accessed at a different network location (host or port) or using a different protocol\n        [<Emit(\"$0.get('Alt-Svc')\")>] abstract AltSvc: string option\n\n        /// Tells all caching mechanisms from server to client whether they may cache this object. It is measured in seconds\n        [<Emit(\"$0.get('Cache-Control')\")>] abstract CacheControl: string option\n\n        /// Control options for the current connection and list of hop-by-hop response fields\n        [<Emit(\"$0.get('Connection')\")>] abstract Connection: string option\n\n        /// An opportunity to raise a \"File Download\" dialogue box for a known MIME type with binary format or suggest a filename for dynamic content. Quotes are necessary with special characters.\n        [<Emit(\"$0.get('Content-Disposition')\")>] abstract ContentDisposition: string option\n\n        /// The type of encoding used on the data\n        [<Emit(\"$0.get('Content-Encoding')\")>] abstract ContentEncoding: string option\n\n        /// The natural language or languages of the intended audience for the enclosed content\n        [<Emit(\"$0.get('Content-Language')\")>] abstract ContentLanguage: string option\n\n        /// The length of the response body in octets (8-bit bytes)\n        [<Emit(\"$0.get('Content-Length')\")>] abstract ContentLength: string option\n\n        /// An alternate location for the returned data\n        [<Emit(\"$0.get('Content-Location')\")>] abstract ContentLocation: string option\n\n        /// A Base64-encoded binary MD5 sum of the content of the response\n        [<Emit(\"$0.get('Content-MD5')\")>] abstract ContentMD5: string option\n\n        /// Where in a full body message this partial message belongs\n        [<Emit(\"$0.get('Content-Range'')\")>] abstract ContentRange: string option\n\n        /// The MIME type of this content\n        [<Emit(\"$0.get('Content-Type')\")>] abstract ContentType: string option\n\n        /// The date and time that the message was sent (in \"HTTP-date\" format as defined by RFC 7231)\n        [<Emit(\"$0.get('Date')\")>] abstract Date: string option\n\n        /// An identifier for a specific version of a resource, often a message digest\n        [<Emit(\"$0.get('ETag')\")>] abstract ETag: string option\n\n        /// Gives the date/time after which the response is considered stale (in \"HTTP-date\" format as defined by RFC 7231)\n        [<Emit(\"$0.get('Expires')\")>] abstract Expires: string option\n\n        /// The last modified date for the requested object (in \"HTTP-date\" format as defined by RFC 7231)\n        [<Emit(\"$0.get('Last-Modified')\")>] abstract LastModified: string option\n\n        /// Used to express a typed relationship with another resource, where the relation type is defined by RFC 5988\n        [<Emit(\"$0.get('Link')\")>] abstract Link: string option\n\n        /// Used in redirection, or when a new resource has been created.\n        [<Emit(\"$0.get('Location')\")>] abstract Location: string option\n\n        /// This field is supposed to set P3P policy, in the form of P3P:CP=\"your_compact_policy\".\n        [<Emit(\"$0.get('P3P')\")>] abstract P3P: string option\n\n        /// Implementation-specific fields that may have various effects anywhere along the request-response chain.\n        [<Emit(\"$0.get('Pragma')\")>] abstract Pragma: string option\n\n        /// Request authentication to access the proxy.\n        [<Emit(\"$0.get('Proxy-Authenticate')\")>] abstract ProxyAuthenticate: string option\n\n        /// HTTP Public Key Pinning, announces hash of website's authentic TLS certificate\n        [<Emit(\"$0.get('Public-Key-Pins')\")>] abstract PublicKeyPins: string option\n\n        /// Used in redirection, or when a new resource has been created. This refresh redirects after 5 seconds.\n        [<Emit(\"$0.get('Refresh')\")>] abstract Refresh: string option\n\n        /// If an entity is temporarily unavailable, this instructs the client to try again later. Value could be a specified period of time (in seconds) or a HTTP-date.\n        [<Emit(\"$0.get('Retry-After')\")>] abstract RetryAfter: string option\n\n        /// A name for the server\n        [<Emit(\"$0.get('Server')\")>] abstract Server: string option\n\n        /// An HTTP cookie\n        [<Emit(\"$0.get('Set-Cookie')\")>] abstract SetCookie: string option\n\n        /// CGI header field specifying the status of the HTTP response. Normal HTTP responses use a separate \"Status-Line\" instead, defined by RFC 7230\n        [<Emit(\"$0.get('Status')\")>] abstract Status: string option\n\n        /// A HSTS Policy informing the HTTP client how long to cache the HTTPS only policy and whether this applies to subdomains.\n        [<Emit(\"$0.get('Strict-Transport-Security')\")>] abstract StrictTransportSecurity: string option\n\n        /// The Trailer general field value indicates that the given set of header fields is present in the trailer of a message encoded with chunked transfer coding.\n        [<Emit(\"$0.get('Trailer')\")>] abstract Trailer: string option\n\n        /// The form of encoding used to safely transfer the entity to the user. Currently defined methods are: chunked, compress, deflate, gzip, identity.\n        [<Emit(\"$0.get('Transfer-Encoding')\")>] abstract TransferEncoding: string option\n\n        /// Tracking Status Value, value suggested to be sent in response to a DNT(do-not-track)\n        [<Emit(\"$0.get('TSV')\")>] abstract TSV: string option\n\n        /// Ask the client to upgrade to another protocol.\n        [<Emit(\"$0.get('Upgrade')\")>] abstract Upgrade: string option\n\n        /// Tells downstream proxies how to match future request headers to decide whether the cached response can be used rather than requesting a fresh one from the origin server.\n        [<Emit(\"$0.get('Vary')\")>] abstract Vary: string option\n\n        /// Informs the client of proxies through which the response was sent.\n        [<Emit(\"$0.get('Via')\")>] abstract Via: string option\n\n        /// A general warning about possible problems with the entity body.\n        [<Emit(\"$0.get('Warning')\")>] abstract Warning: string option\n\n        /// Indicates the authentication scheme that should be used to access the requested entity.\n        [<Emit(\"$0.get('WWW-Authenticate')\")>] abstract WWWAuthenticate: string option\n\n        /// Clickjacking protection: deny - no rendering within a frame, sameorigin - no rendering if origin mismatch, allow-from - allow from specified location, allowall - non-standard, allow from any location\n        [<Emit(\"$0.get('X-Frame-Options')\")>] abstract XFrameOptions: string option\n\n        /// Cross-site scripting (XSS) filter\n        [<Emit(\"$0.get('X-XSS-Protection')\")>] abstract XXSSProtection: string option\n\n        /// Content Security Policy definition.\n        [<Emit(\"$0.get('Content-Security-Policy')\")>] abstract ContentSecurityPolicy: string option\n\n        /// The only defined value, \"nosniff\", prevents Internet Explorer from MIME-sniffing a response away from the declared content-type. This also applies to Google Chrome, when downloading extensions\n        [<Emit(\"$0.get('X-Content-Type-Options')\")>] abstract XContentTypeOptions: string option\n\n        /// Specifies the technology (e.g. ASP.NET, PHP, JBoss) supporting the web application (version details are often in X-Runtime, X-Version, or X-AspNet-Version)\n        [<Emit(\"$0.get('X-Powered-By')\")>] abstract XPoweredBy: string option\n\n        /// Recommends the preferred rendering engine (often a backward-compatibility mode) to use to display the content. Also used to activate Chrome Frame in Internet Explorer.\n        [<Emit(\"$0.get('X-UA-Compatible')\")>] abstract XUACompatible: string option\n\n        /// Provide the duration of the audio or video in seconds; only supported by Gecko browsers\n        [<Emit(\"$0.get('X-Content-Duration')\")>] abstract XContentDuration: string option\n\n        /// Tells a server which (presumably in the middle of a HTTP -> HTTPS migration) hosts mixed content that the client would prefer redirection to HTTPS and can handle Content-Security-Policy: upgrade-insecure-requests\n        [<Emit(\"$0.get('Upgrade-Insecure-Requests')\")>] abstract UpgradeInsecureRequests: string option\n\n        /// Correlates HTTP requests between a client and server.\n        [<Emit(\"$0.get('X-Request-ID')\")>] abstract XRequestID: string option\n\n        /// Correlates HTTP requests between a client and server.\n        [<Emit(\"$0.get('X-Correlation-ID')\")>] abstract XCorrelationID: string option\n\n\n    and Response = //(?body: BodyInit, ?init: ResponseInit) =\n        inherit Body\n\n        /// Verifies that the fetch was successful\n        [<Emit(\"$0.ok\")>] abstract Ok: bool\n\n        /// Returns the HTTP status code\n        [<Emit(\"$0.status\")>] abstract Status: int\n\n        /// Returns the HTTP status message\n        [<Emit(\"$0.statusText\")>] abstract StatusText: string\n\n        /// Returns the response URL\n        [<Emit(\"$0.url\")>] abstract Url: string\n\n        /// Returns the headers objct\n        [<Emit(\"$0.headers\")>] abstract Headers : Headers\n\n    and [<StringEnum; RequireQualifiedAccess>] ResponseType =\n        | Basic | Cors | Default | Error | Opaque\n\n    and ResponseInit =\n        abstract status: float with get, set\n        abstract statusText: string option with get, set\n        abstract headers: HeaderInit option with get, set\n\n    and HeaderInit =\n        U2<Headers, string[]>\n\n    and BodyInit =\n        U3<Blob, FormData, string>\n\n    [<Erase; RequireQualifiedAccess; NoComparison>]\n    type RequestInfo =\n        /// Uses a simple Url as string to create the request info\n        | Url of string\n        /// Uses a Request object as request info\n        | Req of Request\n\n    type [<Erase>] GlobalFetch =\n        [<Global>]static member fetch (req: RequestInfo, ?init: RequestInit) = jsNative :JS.Promise<Response>\n\n    [<StringEnum; RequireQualifiedAccess>]\n    type HttpMethod =\n        | [<CompiledName(\"CONNECT\")>] CONNECT\n        | [<CompiledName(\"DELETE\")>] DELETE\n        | [<CompiledName(\"GET\")>] GET\n        | [<CompiledName(\"HEAD\")>] HEAD\n        | [<CompiledName(\"OPTIONS\")>] OPTIONS\n        | [<CompiledName(\"PATCH\")>] PATCH\n        | [<CompiledName(\"POST\")>] POST\n        | [<CompiledName(\"PUT\")>] PUT\n        | [<CompiledName(\"TRACE\")>] TRACE\n\n    type IHttpRequestHeaders =\n        interface end\n\n    type HttpRequestHeaders =\n        | Accept of string\n        | [<CompiledName(\"Accept-Charset\")>] AcceptCharset of string\n        | [<CompiledName(\"Accept-Encoding\")>] AcceptEncoding of string\n        | [<CompiledName(\"Accept-Language\")>] AcceptLanguage of string\n        | [<CompiledName(\"Accept-Datetime\")>] AcceptDatetime of string\n        | Authorization of string\n        | [<CompiledName(\"Cache-Control\")>] CacheControl of string\n        | Connection of string\n        | Cookie of string\n        | [<CompiledName(\"Content-Length\")>] ContentLength of string\n        | [<CompiledName(\"Content-MD5\")>] ContentMD5 of string\n        | [<CompiledName(\"Content-Type\")>] ContentType of string\n        | Date of string\n        | Expect of string\n        | Forwarded of string\n        | From of string\n        | Host of string\n        | [<CompiledName(\"If-Match\")>] IfMatch of string\n        | [<CompiledName(\"If-Modified-Since\")>] IfModifiedSince of string\n        | [<CompiledName(\"If-None-Match\")>] IfNoneMatch of string\n        | [<CompiledName(\"If-Range\")>] IfRange of string\n        | [<CompiledName(\"If-Unmodified-Since\")>] IfUnmodifiedSince of string\n        | [<CompiledName(\"Max-Forwards\")>] MaxForwards of int\n        | Origin of string\n        | Pragma of string\n        | [<CompiledName(\"Proxy-Authorization\")>] ProxyAuthorization of string\n        | Range of string\n        | Referer of string\n        | [<CompiledName(\"SOAPAction\")>] SOAPAction of string\n        | [<CompiledName(\"TE\")>] TE of string\n        | [<CompiledName(\"User-Agent\")>] UserAgent of string\n        | Upgrade of string\n        | Via of string\n        | Warning of string\n        | [<CompiledName(\"X-Requested-With\")>] XRequestedWith of string\n        | [<CompiledName(\"DNT\")>] DNT of string\n        | [<CompiledName(\"X-Forwarded-For\")>] XForwardedFor of string\n        | [<CompiledName(\"X-Forwarded-Host\")>] XForwardedHost of string\n        | [<CompiledName(\"X-Forwarded-Proto\")>] XForwardedProto of string\n        | [<CompiledName(\"Front-End-Https\")>] FrontEndHttps of string\n        | [<CompiledName(\"X-Http-Method-Override\")>] XHttpMethodOverride of string\n        | [<CompiledName(\"X-ATT-DeviceId\")>] XATTDeviceId of string\n        | [<CompiledName(\"X-Wap-Profile\")>] XWapProfile of string\n        | [<CompiledName(\"Proxy-Connection\")>] ProxyConnection of string\n        | [<CompiledName(\"X-UIDH\")>] XUIDH of string\n        | [<CompiledName(\"X-Csrf-Token\")>] XCsrfToken of string\n        | [<Erase>] Custom of key:string * value:obj\n\n    [<NoComparison>]\n    type RequestProperties =\n        | Method of HttpMethod\n        | Headers of IHttpRequestHeaders\n        | Body of BodyInit\n        | Mode of RequestMode\n        | Credentials of RequestCredentials\n        | Cache of RequestCache\n\n\nlet inline requestHeaders (headers: HttpRequestHeaders list) =\n    RequestProperties.Headers(keyValueList CaseRules.None headers :?> IHttpRequestHeaders)\n\nlet inline requestProps (props: RequestProperties list) =\n    keyValueList CaseRules.LowerFirst props :?> RequestInit\n\nlet private errorString (response: Response) =\n    string response.Status + \" \" + response.StatusText + \" for URL \" + response.Url\n\n/// Retrieves data from the specified resource. Fails if `response.Ok` evals to false.\nlet fetch (url: string) (init: RequestProperties list) : JS.Promise<Response> =\n    GlobalFetch.fetch(RequestInfo.Url url, requestProps init)\n    |> Promise.map (fun response ->\n        if response.Ok\n        then response\n        else errorString response |> failwith)\n\nlet tryFetch (url: string) (init: RequestProperties list) : JS.Promise<Result<Response, Exception>> =\n    fetch url init |> Promise.result\n\n/// Sends a HTTP OPTIONS request.\nlet tryOptionsRequest (url:string) : JS.Promise<Result<Response, Exception>> =\n    fetch url [RequestProperties.Method HttpMethod.OPTIONS] |> Promise.result","namespace Elmish\n\n\n[<RequireQualifiedAccess>]\n[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]\nmodule internal Option =\n\n    let tuple a b =\n        match (a,b) with\n        | Some a, Some b -> Some (a,b)\n        | _ -> None\n\n    let ofFunc f arg =\n        try\n            Some (f arg)\n        with _ ->\n            None","(** UrlParser\n------\nThis port of the Elm library helps you turn URLs into nicely structured data.\nIt is designed to be used with `Navigation` module to help folks create\nsingle-page applications (SPAs) where you manage browser navigation yourself.\n*)\n\nmodule Elmish.UrlParser\n\n\n(**\n#### Types\n*)\n\ntype State<'v> =\n  { visited : string list\n    unvisited : string list\n    args : Map<string,string>\n    value : 'v }\n\n[<RequireQualifiedAccess>]\n[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]\nmodule internal State =\n  let mkState visited unvisited args value =\n        { visited = visited\n          unvisited = unvisited\n          args = args\n          value = value }\n\n  let map f { visited = visited; unvisited = unvisited; args = args; value = value } =\n        { visited = visited\n          unvisited = unvisited\n          args = args\n          value = f value }\n\n\n/// Turn URLs like `/blog/42/cat-herding-techniques` into nice data.\ntype Parser<'a,'b> = State<'a> -> State<'b> list\n\n\n(**\n#### Parse segments\nCreate a custom path segment parser. You can use it to define something like “only CSS files” like this:\n```\n    let css =\n      custom \"CSS_FILE\" <| fun segment ->\n        if String.EndsWith \".css\" then\n          Ok segment\n        else\n          Error \"Does not end with .css\"\n```\n*)\nlet custom tipe (stringToSomething: string->Result<_,_>) : Parser<_,_> =\n    let inner { visited = visited; unvisited = unvisited; args = args; value = value } =\n        match unvisited with\n        | [] -> []\n        | next :: rest ->\n            match stringToSomething next with\n            | Ok nextValue ->\n                [ State.mkState (next :: visited) rest args (value nextValue) ]\n\n            | Error msg ->\n                []\n    inner\n\n\n(** Parse a segment of the path as a `string`.\n```\n    parse str location\n```\n<pre>\n    /alice/  ==>  Some \"alice\"\n    /bob     ==>  Some \"bob\"\n    /42/     ==>  Some \"42\"\n</pre>\n*)\nlet str state =\n    custom \"string\" Ok state\n\n\n(** Parse a segment of the path as an `int`.\n```\n    parse i32 location\n```\n<pre>\n    /alice/  ==>  None\n    /bob     ==>  None\n    /42/     ==>  Some 42\n</pre>\n*)\nlet i32 state =\n    custom \"i32\" (System.Int32.TryParse >> function true, value -> Ok value | _ -> Error \"Can't parse int\" ) state\n\n\n(** Parse a segment of the path if it matches a given string.\n```\n    s \"blog\"  // can parse /blog/\n              // but not /glob/ or /42/ or anything else\n```\n*)\nlet s str : Parser<_,_> =\n    let inner { visited = visited; unvisited = unvisited; args = args; value = value } =\n        match unvisited with\n        | [] -> []\n        | next :: rest ->\n            if next = str then\n                [ State.mkState (next :: visited) rest args value ]\n            else\n                []\n    inner\n\n\n\n(**\n#### Combining parsers\nParse a path with multiple segments.\n\n```\n    parse (s \"blog\" </> i32) location\n```\n<pre>\n    /blog/35/  ==>  Some 35\n    /blog/42   ==>  Some 42\n    /blog/     ==>  None\n    /42/       ==>  None\n</pre>\n```\n    parse (s \"search\" </> str) location\n```\n<pre>\n    /search/cats/  ==>  Some \"cats\"\n    /search/frog   ==>  Some \"frog\"\n    /search/       ==>  None\n    /cats/         ==>  None\n</pre>\n*)\nlet inline (</>) (parseBefore: Parser<_,_>) (parseAfter: Parser<_,_>) =\n  fun state ->\n    List.collect parseAfter (parseBefore state)\n\n\n(** Transform a path parser.\n```\n    type Comment = { author : string; id : int }\n    rawComment =\n      s \"user\" </> str </> s \"comments\" </> i32\n    comment =\n      map (fun a id -> { author = a; id = id }) rawComment\n    parse comment location\n```\n<pre>\n    /user/bob/comments/42  ==>  Some { author = \"bob\"; id = 42 }\n    /user/tom/comments/35  ==>  Some { author = \"tom\"; id = 35 }\n    /user/sam/             ==>  None\n</pre>\n*)\nlet map (subValue: 'a) (parse: Parser<'a,'b>) : Parser<'b->'c,'c> =\n    let inner { visited = visited; unvisited = unvisited; args = args; value = value } =\n        List.map (State.map value)\n        <| parse { visited = visited\n                   unvisited = unvisited\n                   args = args\n                   value = subValue }\n    inner\n\n\n\n(** Try a bunch of different path parsers.\n```\n    type Route\n      = Search of string\n      | Blog of int\n      | User of string\n      | Comment of string*int\n    route =\n      oneOf\n        [ map Search  (s \"search\" </> str)\n          map Blog    (s \"blog\" </> i32)\n          map User    (s \"user\" </> str)\n          map Comment (s \"user\" </> str </> \"comments\" </> i32) ]\n    parse route location\n```\n<pre>\n    /search/cats           ==>  Some (Search \"cats\")\n    /search/               ==>  None\n    /blog/42               ==>  Some (Blog 42)\n    /blog/cats             ==>  None\n    /user/sam/             ==>  Some (User \"sam\")\n    /user/bob/comments/42  ==>  Some (Comment \"bob\" 42)\n    /user/tom/comments/35  ==>  Some (Comment \"tom\" 35)\n    /user/                 ==>  None\n</pre>\n*)\nlet oneOf parsers state =\n    List.collect (fun parser -> parser state) parsers\n\n\n(** A parser that does not consume any path segments.\n```\n    type BlogRoute = Overview | Post of int\n    blogRoute =\n      oneOf\n        [ map Overview top\n          map Post  (s \"post\" </> i32) ]\n    parse (s \"blog\" </> blogRoute) location\n```\n<pre>\n    /blog/         ==>  Some Overview\n    /blog/post/42  ==>  Some (Post 42)\n</pre>\n*)\nlet top state=\n    [state]\n\n\n\n(**\n#### Query parameters\nTurn query parameters like `?name=tom&age=42` into nice data.\n\n*)\n\ntype QueryParser<'a,'b> = State<'a> -> State<'b> list\n\n\n(** Parse some query parameters.\n```\n    type Route = BlogList (Option string) | BlogPost Int\n    route =\n      oneOf\n        [ map BlogList (s \"blog\" <?> stringParam \"search\")\n          map BlogPost (s \"blog\" </> i32) ]\n    parse route location\n```\n<pre>\n    /blog/              ==>  Some (BlogList None)\n    /blog/?search=cats  ==>  Some (BlogList (Some \"cats\"))\n    /blog/42            ==>  Some (BlogPost 42)\n</pre>\n*)\nlet inline (<?>) (parser: Parser<_,_>) (queryParser:QueryParser<_,_>) : Parser<_,_> =\n    fun state ->\n        List.collect queryParser (parser state)\n\n(** Create a custom query parser. You could create parsers like these:\n```\n    val jsonParam : string -> Decoder a -> QueryParser (Option a -> b) b\n    val enumParam : string -> Map<string,a> -> QueryParser (Option a -> b) b\n```\n*)\nlet customParam (key: string) (func: string option -> _) : QueryParser<_,_> =\n    let inner { visited = visited; unvisited = unvisited; args = args; value = value } =\n        [ State.mkState visited unvisited args (value (func (Map.tryFind key args))) ]\n    inner\n\n\n(** Parse a query parameter as a `string`.\n```\n    parse (s \"blog\" <?> stringParam \"search\") location\n```\n<pre>\n    /blog/              ==>  Some (Overview None)\n    /blog/?search=cats  ==>  Some (Overview (Some \"cats\"))\n</pre>\n*)\nlet stringParam name =\n    customParam name id\n\nlet internal intParamHelp =\n    Option.bind\n        (fun (value: string) ->\n            match System.Int32.TryParse value with\n            | (true,x) -> Some x\n            | _ -> None)\n\n(** Parse a query parameter as an `int`. Option you want to show paginated\nsearch results. You could have a `start` query parameter to say which result\nshould appear first.\n```\n    parse (s \"results\" <?> intParam \"start\") location\n```\n<pre>\n    /results           ==>  Some None\n    /results?start=10  ==>  Some (Some 10)\n</pre>\n*)\nlet intParam name =\n    customParam name intParamHelp\n\n\n// PARSER HELPERS\n\nlet rec internal parseHelp states =\n    match states with\n    | [] ->\n        None\n    | state :: rest ->\n        match state.unvisited with\n        | [] ->\n            Some state.value\n        | [\"\"] ->\n            Some state.value\n        | _ ->\n            parseHelp rest\n\nlet internal splitUrl (url: string) =\n    match List.ofArray <| url.Split([|'/'|]) with\n    | \"\" :: segments ->\n        segments\n    | segments ->\n        segments\n\n/// parse a given part of the location\nlet parse (parser: Parser<'a->'a,'a>) url args =\n    { visited = []\n      unvisited = splitUrl url\n      args = args\n      value = id }\n    |> parser\n    |> parseHelp\n\nopen Fable.Core\n\nlet internal toKeyValuePair (segment: string) =\n    match segment.Split('=') with\n    | [| key; value |] ->\n        Option.tuple (Option.ofFunc JS.decodeURI key) (Option.ofFunc JS.decodeURI value)\n    | _ -> None\n\n\nlet internal parseParams (querystring: string) =\n    querystring.Substring(1).Split('&')\n    |> Seq.map toKeyValuePair\n    |> Seq.choose id\n    |> Map.ofSeq\n\nopen Browser.Types\n\n(**\n#### Parsers\nParse based on `location.pathname` and `location.search`. This parser\nignores the hash entirely.\n*)\nlet parsePath (parser: Parser<_,_>) (location: Location) =\n    parse parser location.pathname (parseParams location.search)\n\n(** Parse based on `location.hash`. This parser ignores the normal\npath entirely.\n*)\nlet parseHash (parser: Parser<_,_>) (location: Location) =\n    let hash, search =\n        let hash = location.hash.Substring 1\n        if hash.Contains(\"?\") then\n            let h = hash.Substring(0, hash.IndexOf(\"?\"))\n            h, hash.Substring(h.Length)\n        else\n            hash, \"?\"\n\n    parse parser hash (parseParams search)\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    static get maxTrampolineCallCount() {\n        return 2000;\n    }\n    constructor() {\n        this.callCount = 0;\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 { OperationCanceledError, Trampoline } from \"./AsyncBuilder\";\nimport { CancellationToken } from \"./AsyncBuilder\";\nimport { protectedCont } from \"./AsyncBuilder\";\nimport { protectedBind } from \"./AsyncBuilder\";\nimport { protectedReturn } from \"./AsyncBuilder\";\nimport { choice1, choice2 } from \"./Option\";\nimport { map } from \"./Seq\";\n// Implemented just for type references\nexport default class Async {\n}\nfunction emptyContinuation(x) {\n    // NOP\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 startChild(computation) {\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(choice1(x)),\n            onError: (ex) => ctx.onSuccess(choice2(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 awaitPromise(Promise.all(map((w) => startAsPromise(w), 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 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 = null;\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}\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 (dispatch:Dispatch<'msg>) (cmd:Cmd<'msg>) =\n        cmd |> List.iter (fun sub -> sub dispatch)\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 |> Async.Catch\n                    match r with\n                    | Choice1Of2 x -> dispatch x\n                    | _ -> ()\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.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","(**\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 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        sub @ cmd |> Cmd.exec 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","module Client\r\n\r\nopen System\r\nopen Fable.React\r\nopen Fable.React.Props\r\n\r\nopen Elmish\r\nopen Elmish.React\r\n\r\n\r\nopen Fable.MaterialUI.Core\r\nopen Fable.MaterialUI.Props\r\nopen Fable.MaterialUI.Themes\r\n\r\nopen Extensions.Fable.MaterialUI.Core\r\n\r\nopen Views\r\nopen Fable.Core\r\nopen Fable.Core.JsInterop\r\n\r\nopen Informedica.GenForm.Shared\r\n\r\n\r\n// == HELPER FUNCTIONS ==\r\n\r\nmodule Debounce =\r\n    open Fable.Core\r\n\r\n    [<Import(\"default\", \"debounce\"); Emit(\"$0($1, $2, $3)\")>]\r\n    let debounce<'f> (_f: 'f) (_interval: int) (_immediate: bool)  : 'f = jsNative\r\n\r\n\r\ntype DangerousInnerHtml =\r\n    { __html : string }\r\n\r\n\r\nlet innerHtml s = \r\n    div [ DangerouslySetInnerHTML { __html = s } ] []\r\n\r\n\r\n// === MODEL ===\r\n\r\nlet ages =\r\n    Models.ages |> List.map snd\r\n\r\nlet weights =\r\n    Models.weights |> List.map snd\r\n    \r\n\r\ntype Msg =\r\n    | Reset of NavBar.Msg\r\n    | SwitchView\r\n    | MainGroupsFetched of string list\r\n    | MainGroupSelect of string\r\n    | TherapyGroupsFetched of string list\r\n    | TherapyGroupSelect of string\r\n    | SubGroupsFetched of string list\r\n    | SubGroupSelect of string\r\n    | PharmacoGroupsFetched of string list\r\n    | PharmacoGroupSelect of string\r\n    | GenericsFetched of string list\r\n    | GenericSelect of string\r\n    | RulesFetched of string list\r\n    | Search of string\r\n    | AgeChange of string\r\n    | WeightChange of string\r\n\r\n\r\ntype Model = \r\n    {\r\n        Selected : Selected\r\n        RuleView : RuleView\r\n        Page : Page\r\n    }\r\nand RuleView = | HumanReadable | RawGStandRules\r\nand Page =\r\n    | Loading\r\n    | MainGroups of string list\r\n    | TherapyGroups of string list\r\n    | SubGroups of string list\r\n    | PharmacoGroups of string list\r\n    | Generics of string list\r\n    | Rules of string list\r\nand Selected =\r\n    {\r\n        Generic : string option\r\n        Age : string option\r\n        Weight : string option\r\n    }\r\n\r\n\r\nlet fetchStringList (key, value) =\r\n    let url = sprintf \"/api?%s=%s\" key value\r\n    promise {\r\n        let! response = Fetch.fetch url []\r\n        let! grps = response.json<string[]>()\r\n        return (grps |> Array.toList)\r\n    }\r\n\r\n\r\nmodule Navigation =\r\n\r\n    open Elmish.UrlParser\r\n\r\n    [<RequireQualifiedAccess>]\r\n    type Page =\r\n        | MainGroups\r\n        | TherapyGroups of string\r\n        | SubGroups of string\r\n        | PharmacoGroups of string\r\n        | Generics of string\r\n        | Rules of string\r\n        | Search of string\r\n\r\n    let toHash p = \r\n        match p with\r\n        | Page.MainGroups -> \"main\", \"\"\r\n        | Page.TherapyGroups s -> \"thg\", s\r\n        | Page.SubGroups s -> \"sub\", s\r\n        | Page.PharmacoGroups s -> \"phg\", s\r\n        | Page.Generics s -> \"gen\", s\r\n        | Page.Rules s -> \"rul\", s\r\n        | Page.Search s -> \"qry\", s\r\n        |> fun (s1, s2) ->\r\n            if s2 = \"\" then sprintf \"#%s\" s1\r\n            else \r\n                let s2 = \r\n                    s2.Replace(\"/\", \"%2F\")\r\n                      .Replace(\">\", \"%3E\")\r\n                      .Replace(\"<\", \"%3C\")\r\n                sprintf \"#%s/%s\" s1 s2\r\n\r\n    let pageParser =\r\n        oneOf [\r\n            map Page.MainGroups (s \"main\")\r\n            map Page.TherapyGroups (s \"thg\" </> str)\r\n            map Page.SubGroups (s \"sub\" </> str)\r\n            map Page.PharmacoGroups (s \"phg\" </> str)\r\n            map Page.Generics (s \"gen\" </> str)\r\n            map Page.Rules (s \"rul\" </> str)\r\n            map Page.Search (s \"qry\" </> str)\r\n        ]\r\n\r\n    let urlParser location = \r\n        printfn \"parsing location: %A\" location \r\n        parseHash pageParser location\r\n\r\n    let urlUpdate (result: Page Option) model =\r\n        printfn \"url changed to: %A\" result\r\n\r\n        let fetch k v m =\r\n            printfn \"going to fetch %s %s\" k v\r\n            { model with Page = Loading}, Cmd.OfPromise.perform fetchStringList (k, v) m\r\n\r\n        match result with\r\n        | Some Page.MainGroups ->          fetch \"main\" \"\" MainGroupsFetched\r\n        | Some (Page.TherapyGroups s) ->   fetch \"tgp\" s TherapyGroupsFetched\r\n        | Some (Page.SubGroups s) ->       fetch \"sub\" s SubGroupsFetched\r\n        | Some (Page.PharmacoGroups s)  -> fetch \"phg\" s PharmacoGroupsFetched\r\n        | Some (Page.Generics s) ->        fetch \"gen\" s GenericsFetched\r\n        | Some (Page.Rules s) ->           fetch \"rul\" s RulesFetched\r\n        | Some (Page.Search s) ->          fetch \"qry\" s GenericsFetched\r\n        | None -> model, Cmd.none\r\n\r\n\r\nlet init _ : Model * Cmd<Msg> =\r\n    let model = \r\n        { Selected = { Generic = None; Age = None; Weight = None }\r\n          RuleView = HumanReadable\r\n          Page = Loading }\r\n    model, Cmd.OfPromise.perform fetchStringList (\"main\", \"\") MainGroupsFetched\r\n\r\n\r\nlet update (msg: Msg) (model : Model) : Model * Cmd<Msg> =\r\n    let nav m p = \r\n        m,\r\n        Navigation.toHash p\r\n        |> Elmish.Navigation.Navigation.newUrl\r\n\r\n    let fetched c s gl =\r\n        match gl with\r\n        | [g] -> \r\n            model, g |> s |> Cmd.ofMsg\r\n        | _   -> \r\n            { model with Page = gl |> c }, Cmd.none\r\n        \r\n    match msg with\r\n    | Reset _ -> init ()\r\n    | SwitchView -> \r\n        model.RuleView\r\n        |> function\r\n        | HumanReadable ->  { model with RuleView = RawGStandRules }, Cmd.none\r\n        | RawGStandRules -> { model with RuleView = HumanReadable }, Cmd.none\r\n    | MainGroupsFetched gl ->     gl |> fetched MainGroups MainGroupSelect\r\n    | TherapyGroupsFetched gl ->  gl |> fetched TherapyGroups TherapyGroupSelect\r\n    | SubGroupsFetched gl ->      gl |> fetched SubGroups SubGroupSelect\r\n    | PharmacoGroupsFetched gl -> gl |> fetched  PharmacoGroups PharmacoGroupSelect\r\n    | GenericsFetched gl ->       gl |> fetched Generics GenericSelect\r\n    | RulesFetched rl ->          { model with Page = rl |> Rules }, Cmd.none\r\n    | MainGroupSelect s ->        s |> Navigation.Page.TherapyGroups  |> nav model\r\n    | TherapyGroupSelect s ->     s |> Navigation.Page.SubGroups      |> nav model\r\n    | SubGroupSelect s ->         s |> Navigation.Page.PharmacoGroups |> nav model\r\n    | PharmacoGroupSelect s ->    s |> Navigation.Page.Generics       |> nav model\r\n    | GenericSelect s ->   \r\n        let a = model.Selected.Age    |> Option.defaultValue \" \"\r\n        let w = model.Selected.Weight |> Option.defaultValue \" \"\r\n        let m =\r\n            { model with Selected = { model.Selected with Generic = Some s } }\r\n\r\n        sprintf \"%s_%s_%s\" s a w |> Navigation.Page.Rules |> nav m\r\n\r\n    | AgeChange s -> \r\n        let m = { model with Selected = { model.Selected with Age = Some s  } }\r\n        \r\n        match model.Page with\r\n        | Page.Rules _ ->\r\n            let a = m.Selected.Age     |> Option.defaultValue \" \"\r\n            let w = m.Selected.Weight  |> Option.defaultValue \" \"\r\n            let g = m.Selected.Generic |> Option.defaultValue \" \"\r\n            sprintf \"%s_%s_%s\" g a w |> Navigation.Page.Rules |> nav m\r\n            \r\n        | _ -> m, Cmd.none\r\n\r\n    | WeightChange s -> \r\n        let m = { model with Selected = { model.Selected with Weight = Some s  } }\r\n        \r\n        match model.Page with\r\n        | Page.Rules _ ->\r\n            let a = m.Selected.Age     |> Option.defaultValue \" \"\r\n            let w = m.Selected.Weight  |> Option.defaultValue \" \"\r\n            let g = m.Selected.Generic |> Option.defaultValue \" \"\r\n            sprintf \"%s_%s_%s\" g a w |> Navigation.Page.Rules |> nav m\r\n    \r\n        | _ -> m, Cmd.none\r\n\r\n    | Search s ->\r\n        printfn \"search: %s\" s\r\n        match s with\r\n        | _ when s |> String.IsNullOrEmpty -> init ()\r\n        | _ when s |> String.length < 3 -> \r\n            model, Cmd.none\r\n        | _  ->\r\n            s \r\n            |> Navigation.Page.Search \r\n            |> nav model\r\n\r\n\r\n// === STYLES ===\r\n\r\n\r\n\r\n// === VIEW FUNCIONS ===\r\n\r\nlet filler = \r\n    div [ Style [ (FlexGrow 1) ] ] [ ]\r\n\r\n\r\nlet headerBar dispatch =\r\n    Views.NavBar.view \"GenForm\" dispatch\r\n\r\n\r\nlet patientInput age weight dispatch =\r\n    let aitems = ages |> List.map (fun s -> menuItem [ MaterialProp.Value s] [ str s ])\r\n    let witems = weights |> List.map (fun s -> menuItem [ MaterialProp.Value s ] [ str s ])\r\n\r\n    let ainput =\r\n        formControl [ Style [ ( FlexGrow 1); CSSProp.MarginRight \"10px\" ] ]  \r\n            [\r\n                label [] [ str \"Leeftijd\" ]\r\n                select [ MaterialProp.Value (box age)\r\n                         SelectProp.OnChange (fun e _ -> e?target?value |> string |> AgeChange |> dispatch)] aitems\r\n            ]   \r\n\r\n    let winput =\r\n        formControl [ Style [ FlexGrow 1; CSSProp.MarginLeft \"10px\" ] ]  \r\n            [\r\n                label [] [ str \"Gewicht\" ]\r\n                select [ MaterialProp.Value weight\r\n                         SelectProp.OnChange (fun e _ -> e?target?value |> string |> WeightChange |> dispatch) ] witems\r\n            ]   \r\n\r\n    formGroup [ FormGroupProp.Row true\r\n                Style [ Display DisplayOptions.Flex\r\n                        CSSProp.MarginBottom \"10px\" ] ] [ ainput; winput ]\r\n\r\n\r\nlet searchInput dispatch =\r\n    let lbl = typography [] [ str \"Zoeken...\" ]\r\n    let onInput = \r\n        let f = fun s ->\r\n            s \r\n            |> Search\r\n            |> dispatch\r\n        let f = Debounce.debounce f 500 false\r\n        OnInput (fun e -> e.Value |> f)\r\n\r\n    textField [ onInput \r\n                MaterialProp.Label lbl\r\n                HTMLAttr.Type \"search\"\r\n                Style [ Display DisplayOptions.Flex ] ] [ ]\r\n    \r\n\r\nlet createList dispatch xs =\r\n    let typo s =\r\n        typography [ TypographyProp.Align TypographyAlign.Left\r\n                     TypographyProp.Variant TypographyVariant.Button ] [ str s ]\r\n    xs \r\n    |> List.map (fun x ->\r\n        button [ OnClick (fun _ -> x |> dispatch) ] [ typo x ]\r\n        |> List.singleton\r\n        |> listItem [ ]\r\n    )\r\n    |> list []\r\n \r\n\r\nlet view (model : Model) (dispatch : Msg -> unit) =\r\n    let age =\r\n        model.Selected.Age |> Option.defaultValue \"\"\r\n    let wght =\r\n        model.Selected.Weight |> Option.defaultValue \"\"\r\n        \r\n\r\n    let content =\r\n        match model.Page with\r\n        | MainGroups xs ->     xs |> createList (MainGroupSelect >> dispatch)\r\n        | TherapyGroups xs ->  xs |> createList (TherapyGroupSelect >> dispatch)\r\n        | SubGroups xs ->      xs |> createList (SubGroupSelect >> dispatch)\r\n        | PharmacoGroups xs -> xs |> createList (PharmacoGroupSelect >> dispatch)\r\n        | Generics xs ->       xs |> createList (GenericSelect >> dispatch)\r\n        | Rules xs ->\r\n            match xs with\r\n            | [] -> [ \"# Geen doseer regels gevonden\" ]\r\n            | _ ->\r\n                xs\r\n                |> List.map (fun s ->\r\n                    s.Split([|\"||\"|], StringSplitOptions.None) \r\n                    |> Array.toList \r\n                    |> function\r\n                    | [rd; rw] -> \r\n                        match model.RuleView with\r\n                        | HumanReadable -> rd\r\n                        | RawGStandRules -> rw\r\n                    | _ -> s\r\n                    \r\n                )\r\n            |> List.map innerHtml\r\n            |> div [ Style [ CSSProp.MarginTop \"20px\"; CSSProp.Cursor \"pointer\" ]\r\n                     OnDoubleClick (fun _ -> SwitchView |> dispatch) ]\r\n        | Loading -> div [ Style [ CSSProp.MarginTop \"80px\"] ] [ circularProgress [] ]\r\n        |> fun el -> \r\n            div [ Style [ CSSProp.MarginTop \"100px\"\r\n                          CSSProp.MarginBottom \"20px\" ] \r\n                ]\r\n                [ patientInput age wght  dispatch; searchInput dispatch; el ]\r\n\r\n    div [ ]\r\n        [ \r\n            headerBar dispatch\r\n            content\r\n        ] \r\n    |> (fun el -> container [ MaxWidth ContainerMaxWidth.Sm ] [el])\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//|> Program.withSubscription subscription\r\n|> Elmish.Navigation.Program.toNavigable Navigation.urlParser Navigation.urlUpdate\r\n#if DEBUG\r\n|> Program.withConsoleTrace\r\n#endif\r\n|> Program.withReactBatched \"elmish-app\"\r\n#if DEBUG\r\n|> Program.withDebugger\r\n#endif\r\n|> Program.run\r\n"],"sourceRoot":""}