{"version":3,"file":"app.1aa64e41e3877187c1f5.js","mappings":"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","sources":["webpack:///./output/fable_modules/fable-library.3.6.3/Util.js","webpack:///./output/fable_modules/fable-library.3.6.3/Types.js","webpack:///./output/fable_modules/fable-library.3.6.3/Int32.js","webpack:///./output/fable_modules/fable-library.3.6.3/Numeric.js","webpack:///./output/fable_modules/fable-library.3.6.3/lib/long.js","webpack:///./output/fable_modules/fable-library.3.6.3/Long.js","webpack:///./output/fable_modules/fable-library.3.6.3/Date.js","webpack:///./output/fable_modules/fable-library.3.6.3/RegExp.js","webpack:///./output/fable_modules/fable-library.3.6.3/String.js","webpack:///./output/fable_modules/fable-library.3.6.3/Option.js","webpack:///./output/fable_modules/fable-library.3.6.3/Array.js","webpack:///./output/fable_modules/fable-library.3.6.3/List.js","webpack:///./output/fable_modules/fable-library.3.6.3/AsyncBuilder.js","webpack:///./output/fable_modules/fable-library.3.6.3/Choice.js","webpack:///./output/fable_modules/fable-library.3.6.3/Async.js","webpack:///./output/fable_modules/fable-library.3.6.3/Event.js","webpack:///./output/fable_modules/fable-library.3.6.3/Observable.js","webpack:///./output/fable_modules/Fable.Elmish.3.1.0/prelude.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/Timer.js","webpack:///./output/fable_modules/Fable.Elmish.3.1.0/cmd.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/FSharp.Core.js","webpack:///./output/fable_modules/fable-library.3.6.3/FSharp.Collections.js","webpack:///./output/fable_modules/fable-library.3.6.3/Seq.js","webpack:///./output/fable_modules/fable-library.3.6.3/Range.js","webpack:///./output/fable_modules/Fable.Elmish.3.1.0/ring.fs.js","webpack:///./output/fable_modules/Fable.Elmish.3.1.0/program.fs.js","webpack:///./output/fable_modules/Fable.Elmish.React.3.0.1/common.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/Reflection.js","webpack:///./output/Shared/fs/Shared.js","webpack:///./output/fable_modules/Fable.Remoting.Client.7.18.0/Types.fs.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/TypeInfo.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/MapUtil.js","webpack:///./output/fable_modules/fable-library.3.6.3/MutableMap.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/TypeInfo.Converter.fs.js","webpack:///./output/fable_modules/Fable.Remoting.Client.7.18.0/Extensions.fs.js","webpack:///./output/fable_modules/Fable.Remoting.Client.7.18.0/Http.fs.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/Json.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/Map.js","webpack:///./output/fable_modules/fable-library.3.6.3/Double.js","webpack:///./output/fable_modules/fable-library.3.6.3/lib/big.js","webpack:///./output/fable_modules/fable-library.3.6.3/Decimal.js","webpack:///./output/fable_modules/Fable.Parsimmon.4.1.0/Parsimmon.js","webpack:///./output/fable_modules/Fable.Parsimmon.4.1.0/Parsimmon.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/Global.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/Parser.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/BigInt/n.js","webpack:///./output/fable_modules/fable-library.3.6.3/BigInt/z.js","webpack:///./output/fable_modules/fable-library.3.6.3/BigInt.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/SimpleJson.fs.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/TypeCheck.fs.js","webpack:///./output/fable_modules/fable-library.3.6.3/DateOffset.js","webpack:///./output/fable_modules/fable-library.3.6.3/DateOnly.js","webpack:///./output/fable_modules/fable-library.3.6.3/TimeOnly.js","webpack:///./output/fable_modules/fable-library.3.6.3/Guid.js","webpack:///./output/fable_modules/fable-library.3.6.3/BitConverter.js","webpack:///./output/fable_modules/fable-library.3.6.3/Set.js","webpack:///./output/fable_modules/fable-library.3.6.3/MutableSet.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/Json.Converter.fs.js","webpack:///./output/fable_modules/Fable.SimpleJson.3.22.0/quote.js","webpack:///./output/fable_modules/fable-library.3.6.3/TimeSpan.js","webpack:///./output/fable_modules/Fable.Remoting.Client.7.18.0/Proxy.fs.js","webpack:///./output/fs/Model.js","webpack:///./output/fs/Update.js","webpack:///./output/fable_modules/Fable.Remoting.Client.7.18.0/Remoting.fs.js","webpack:///./output/fable_modules/Feliz.1.57.0/Interop.fs.js","webpack:///./output/fable_modules/Feliz.Bulma.2.18.0/ElementBuilders.fs.js","webpack:///./output/fs/View.js","webpack:///./output/fable_modules/Fable.Elmish.React.3.0.1/react.fs.js","webpack:///./output/fs/App.js"],"sourcesContent":["// tslint:disable:ban-types\nexport function isIterable(x) {\n    return x != null && typeof x === \"object\" && Symbol.iterator in x;\n}\nexport function isArrayLike(x) {\n    return Array.isArray(x) || ArrayBuffer.isView(x);\n}\nfunction isComparer(x) {\n    return typeof x.Compare === \"function\";\n}\nfunction isComparable(x) {\n    return typeof x.CompareTo === \"function\";\n}\nfunction isEquatable(x) {\n    return typeof x.Equals === \"function\";\n}\nfunction isHashable(x) {\n    return typeof x.GetHashCode === \"function\";\n}\nexport function isDisposable(x) {\n    return x != null && typeof x.Dispose === \"function\";\n}\nexport function sameConstructor(x, y) {\n    return Object.getPrototypeOf(x).constructor === Object.getPrototypeOf(y).constructor;\n}\nexport class Enumerator {\n    constructor(iter) {\n        this.iter = iter;\n    }\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\n        const cur = this.iter.next();\n        this.current = cur.value;\n        return !cur.done;\n    }\n    [\"System.Collections.IEnumerator.Reset\"]() {\n        throw new Error(\"JS iterators cannot be reset\");\n    }\n    Dispose() {\n        return;\n    }\n}\nexport function getEnumerator(o) {\n    return typeof o.GetEnumerator === \"function\"\n        ? o.GetEnumerator()\n        : new Enumerator(o[Symbol.iterator]());\n}\nexport function toIterator(en) {\n    return {\n        [Symbol.iterator]() { return this; },\n        next() {\n            const hasNext = en[\"System.Collections.IEnumerator.MoveNext\"]();\n            const current = hasNext ? en[\"System.Collections.IEnumerator.get_Current\"]() : undefined;\n            return { done: !hasNext, value: current };\n        },\n    };\n}\nexport class Comparer {\n    constructor(f) {\n        this.Compare = f || compare;\n    }\n}\nexport function comparerFromEqualityComparer(comparer) {\n    // Sometimes IEqualityComparer also implements IComparer\n    if (isComparer(comparer)) {\n        return new Comparer(comparer.Compare);\n    }\n    else {\n        return new Comparer((x, y) => {\n            const xhash = comparer.GetHashCode(x);\n            const yhash = comparer.GetHashCode(y);\n            if (xhash === yhash) {\n                return comparer.Equals(x, y) ? 0 : -1;\n            }\n            else {\n                return xhash < yhash ? -1 : 1;\n            }\n        });\n    }\n}\nexport function assertEqual(actual, expected, msg) {\n    if (!equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport function assertNotEqual(actual, expected, msg) {\n    if (equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport class Lazy {\n    constructor(factory) {\n        this.factory = factory;\n        this.isValueCreated = false;\n    }\n    get Value() {\n        if (!this.isValueCreated) {\n            this.createdValue = this.factory();\n            this.isValueCreated = true;\n        }\n        return this.createdValue;\n    }\n    get IsValueCreated() {\n        return this.isValueCreated;\n    }\n}\nexport function lazyFromValue(v) {\n    return new Lazy(() => v);\n}\nexport function padWithZeros(i, length) {\n    let str = i.toString(10);\n    while (str.length < length) {\n        str = \"0\" + str;\n    }\n    return str;\n}\nexport function padLeftAndRightWithZeros(i, lengthLeft, lengthRight) {\n    let str = i.toString(10);\n    while (str.length < lengthLeft) {\n        str = \"0\" + str;\n    }\n    while (str.length < lengthRight) {\n        str = str + \"0\";\n    }\n    return str;\n}\nexport function dateOffset(date) {\n    const date1 = date;\n    return typeof date1.offset === \"number\"\n        ? date1.offset\n        : (date.kind === 1 /* UTC */\n            ? 0 : date.getTimezoneOffset() * -60000);\n}\nexport function int16ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport function int32ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFFFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport class ObjectRef {\n    static id(o) {\n        if (!ObjectRef.idMap.has(o)) {\n            ObjectRef.idMap.set(o, ++ObjectRef.count);\n        }\n        return ObjectRef.idMap.get(o);\n    }\n}\nObjectRef.idMap = new WeakMap();\nObjectRef.count = 0;\nexport function stringHash(s) {\n    let i = 0;\n    let h = 5381;\n    const len = s.length;\n    while (i < len) {\n        h = (h * 33) ^ s.charCodeAt(i++);\n    }\n    return h;\n}\nexport function numberHash(x) {\n    return x * 2654435761 | 0;\n}\n// From https://stackoverflow.com/a/37449594\nexport function combineHashCodes(hashes) {\n    if (hashes.length === 0) {\n        return 0;\n    }\n    return hashes.reduce((h1, h2) => {\n        return ((h1 << 5) + h1) ^ h2;\n    });\n}\nexport function physicalHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default:\n            return numberHash(ObjectRef.id(x));\n    }\n}\nexport function identityHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    else if (isHashable(x)) {\n        return x.GetHashCode();\n    }\n    else {\n        return physicalHash(x);\n    }\n}\nexport function dateHash(x) {\n    return x.getTime();\n}\nexport function arrayHash(x) {\n    const len = x.length;\n    const hashes = new Array(len);\n    for (let i = 0; i < len; i++) {\n        hashes[i] = structuralHash(x[i]);\n    }\n    return combineHashCodes(hashes);\n}\nexport function structuralHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default: {\n            if (isHashable(x)) {\n                return x.GetHashCode();\n            }\n            else if (isArrayLike(x)) {\n                return arrayHash(x);\n            }\n            else if (x instanceof Date) {\n                return dateHash(x);\n            }\n            else if (Object.getPrototypeOf(x).constructor === Object) {\n                // TODO: check call-stack to prevent cyclic objects?\n                const hashes = Object.values(x).map((v) => structuralHash(v));\n                return combineHashCodes(hashes);\n            }\n            else {\n                // Classes don't implement GetHashCode by default, but must use identity hashing\n                return numberHash(ObjectRef.id(x));\n                // return stringHash(String(x));\n            }\n        }\n    }\n}\n// Intended for custom numeric types, like long or decimal\nexport function fastStructuralHash(x) {\n    return stringHash(String(x));\n}\n// Intended for declared types that may or may not implement GetHashCode\nexport function safeHash(x) {\n    return x == null ? 0 : isHashable(x) ? x.GetHashCode() : numberHash(ObjectRef.id(x));\n}\nexport function equalArraysWith(x, y, eq) {\n    if (x == null) {\n        return y == null;\n    }\n    if (y == null) {\n        return false;\n    }\n    if (x.length !== y.length) {\n        return false;\n    }\n    for (let i = 0; i < x.length; i++) {\n        if (!eq(x[i], y[i])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equalArrays(x, y) {\n    return equalArraysWith(x, y, equals);\n}\nfunction equalObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return false;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0; i < xKeys.length; i++) {\n        if (xKeys[i] !== yKeys[i] || !equals(x[xKeys[i]], y[yKeys[i]])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equals(x, y) {\n    if (x === y) {\n        return true;\n    }\n    else if (x == null) {\n        return y == null;\n    }\n    else if (y == null) {\n        return false;\n    }\n    else if (typeof x !== \"object\") {\n        return false;\n    }\n    else if (isEquatable(x)) {\n        return x.Equals(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) && equalArrays(x, y);\n    }\n    else if (x instanceof Date) {\n        return (y instanceof Date) && compareDates(x, y) === 0;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object && equalObjects(x, y);\n    }\n}\nexport function compareDates(x, y) {\n    let xtime;\n    let ytime;\n    // DateTimeOffset and DateTime deals with equality differently.\n    if (\"offset\" in x && \"offset\" in y) {\n        xtime = x.getTime();\n        ytime = y.getTime();\n    }\n    else {\n        xtime = x.getTime() + dateOffset(x);\n        ytime = y.getTime() + dateOffset(y);\n    }\n    return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);\n}\nexport function comparePrimitives(x, y) {\n    return x === y ? 0 : (x < y ? -1 : 1);\n}\nexport function compareArraysWith(x, y, comp) {\n    if (x == null) {\n        return y == null ? 0 : 1;\n    }\n    if (y == null) {\n        return -1;\n    }\n    if (x.length !== y.length) {\n        return x.length < y.length ? -1 : 1;\n    }\n    for (let i = 0, j = 0; i < x.length; i++) {\n        j = comp(x[i], y[i]);\n        if (j !== 0) {\n            return j;\n        }\n    }\n    return 0;\n}\nexport function compareArrays(x, y) {\n    return compareArraysWith(x, y, compare);\n}\nfunction compareObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return xKeys.length < yKeys.length ? -1 : 1;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0, j = 0; i < xKeys.length; i++) {\n        const key = xKeys[i];\n        if (key !== yKeys[i]) {\n            return key < yKeys[i] ? -1 : 1;\n        }\n        else {\n            j = compare(x[key], y[key]);\n            if (j !== 0) {\n                return j;\n            }\n        }\n    }\n    return 0;\n}\nexport function compare(x, y) {\n    if (x === y) {\n        return 0;\n    }\n    else if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    else if (y == null) {\n        return 1;\n    }\n    else if (typeof x !== \"object\") {\n        return x < y ? -1 : 1;\n    }\n    else if (isComparable(x)) {\n        return x.CompareTo(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) ? compareArrays(x, y) : -1;\n    }\n    else if (x instanceof Date) {\n        return y instanceof Date ? compareDates(x, y) : -1;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object ? compareObjects(x, y) : -1;\n    }\n}\nexport function min(comparer, x, y) {\n    return comparer(x, y) < 0 ? x : y;\n}\nexport function max(comparer, x, y) {\n    return comparer(x, y) > 0 ? x : y;\n}\nexport function clamp(comparer, value, min, max) {\n    return (comparer(value, min) < 0) ? min : (comparer(value, max) > 0) ? max : value;\n}\nexport function createAtom(value) {\n    let atom = value;\n    return (value, isSetter) => {\n        if (!isSetter) {\n            return atom;\n        }\n        else {\n            atom = value;\n            return void 0;\n        }\n    };\n}\nexport function createObj(fields) {\n    const obj = {};\n    for (const kv of fields) {\n        obj[kv[0]] = kv[1];\n    }\n    return obj;\n}\nexport function jsOptions(mutator) {\n    const opts = {};\n    mutator(opts);\n    return opts;\n}\nexport function round(value, digits = 0) {\n    const m = Math.pow(10, digits);\n    const n = +(digits ? value * m : value).toFixed(8);\n    const i = Math.floor(n);\n    const f = n - i;\n    const e = 1e-8;\n    const r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 === 0) ? i : i + 1) : Math.round(n);\n    return digits ? r / m : r;\n}\nexport function sign(x) {\n    return x > 0 ? 1 : x < 0 ? -1 : 0;\n}\nexport function 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    if (isArrayLike(col)) {\n        return col.length;\n    }\n    else {\n        let count = 0;\n        for (const _ of col) {\n            count++;\n        }\n        return count;\n    }\n}\nexport function clear(col) {\n    if (isArrayLike(col)) {\n        col.splice(0);\n    }\n    else {\n        col.clear();\n    }\n}\nconst CURRIED = Symbol(\"curried\");\nexport function uncurry(arity, f) {\n    // f may be a function option with None value\n    if (f == null || f.length > 1) {\n        return f;\n    }\n    const uncurried = (...args) => {\n        let res = f;\n        for (let i = 0; i < arity; i++) {\n            res = res(args[i]);\n        }\n        return res;\n    };\n    uncurried[CURRIED] = f;\n    return uncurried;\n}\nfunction _curry(args, arity, f) {\n    return (arg) => arity === 1\n        ? f(...args.concat([arg]))\n        // Note it's important to generate a new args array every time\n        // because a partially applied function can be run multiple times\n        : _curry(args.concat([arg]), arity - 1, f);\n}\nexport function curry(arity, f) {\n    if (f == null || f.length === 1) {\n        return f;\n    }\n    else if (CURRIED in f) {\n        return f[CURRIED];\n    }\n    else {\n        return _curry([], arity, f);\n    }\n}\nexport function checkArity(arity, f) {\n    return f.length > arity\n        ? (...args1) => (...args2) => f.apply(undefined, args1.concat(args2))\n        : f;\n}\nexport function partialApply(arity, f, args) {\n    if (f == null) {\n        return undefined;\n    }\n    else if (CURRIED in f) {\n        f = f[CURRIED];\n        for (let i = 0; i < args.length; i++) {\n            f = f(args[i]);\n        }\n        return f;\n    }\n    else {\n        return _curry(args, arity, f);\n    }\n}\nexport function mapCurriedArgs(fn, mappings) {\n    function mapArg(fn, arg, mappings, idx) {\n        const mapping = mappings[idx];\n        if (mapping !== 0) {\n            const expectedArity = mapping[0];\n            const actualArity = mapping[1];\n            if (expectedArity > 1) {\n                arg = curry(expectedArity, arg);\n            }\n            if (actualArity > 1) {\n                arg = uncurry(actualArity, arg);\n            }\n        }\n        const res = fn(arg);\n        if (idx + 1 === mappings.length) {\n            return res;\n        }\n        else {\n            return (arg) => mapArg(res, arg, mappings, idx + 1);\n        }\n    }\n    return (arg) => mapArg(fn, arg, mappings, 0);\n}\n","import { combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from \"./Util.js\";\nexport function seqToString(self) {\n    let count = 0;\n    let str = \"[\";\n    for (const x of self) {\n        if (count === 0) {\n            str += toString(x);\n        }\n        else if (count === 100) {\n            str += \"; ...\";\n            break;\n        }\n        else {\n            str += \"; \" + toString(x);\n        }\n        count++;\n    }\n    return str + \"]\";\n}\nexport function toString(x, callStack = 0) {\n    if (x != null && typeof x === \"object\") {\n        if (typeof x.toString === \"function\") {\n            return x.toString();\n        }\n        else if (Symbol.iterator in x) {\n            return seqToString(x);\n        }\n        else { // TODO: Date?\n            const cons = Object.getPrototypeOf(x).constructor;\n            return cons === Object && callStack < 10\n                // Same format as recordToString\n                ? \"{ \" + Object.entries(x).map(([k, v]) => k + \" = \" + toString(v, callStack + 1)).join(\"\\n  \") + \" }\"\n                : cons.name;\n        }\n    }\n    return String(x);\n}\nexport function unionToString(name, fields) {\n    if (fields.length === 0) {\n        return name;\n    }\n    else {\n        let fieldStr = \"\";\n        let withParens = true;\n        if (fields.length === 1) {\n            fieldStr = toString(fields[0]);\n            withParens = fieldStr.indexOf(\" \") >= 0;\n        }\n        else {\n            fieldStr = fields.map((x) => toString(x)).join(\", \");\n        }\n        return name + (withParens ? \" (\" : \" \") + fieldStr + (withParens ? \")\" : \"\");\n    }\n}\nexport class Union {\n    get name() {\n        return this.cases()[this.tag];\n    }\n    toJSON() {\n        return this.fields.length === 0 ? this.name : [this.name].concat(this.fields);\n    }\n    toString() {\n        return unionToString(this.name, this.fields);\n    }\n    GetHashCode() {\n        const hashes = this.fields.map((x) => structuralHash(x));\n        hashes.splice(0, 0, numberHash(this.tag));\n        return combineHashCodes(hashes);\n    }\n    Equals(other) {\n        if (this === other) {\n            return true;\n        }\n        else if (!sameConstructor(this, other)) {\n            return false;\n        }\n        else if (this.tag === other.tag) {\n            return equalArrays(this.fields, other.fields);\n        }\n        else {\n            return false;\n        }\n    }\n    CompareTo(other) {\n        if (this === other) {\n            return 0;\n        }\n        else if (!sameConstructor(this, other)) {\n            return -1;\n        }\n        else if (this.tag === other.tag) {\n            return compareArrays(this.fields, other.fields);\n        }\n        else {\n            return this.tag < other.tag ? -1 : 1;\n        }\n    }\n}\nfunction recordToJSON(self) {\n    const o = {};\n    const keys = Object.keys(self);\n    for (let i = 0; i < keys.length; i++) {\n        o[keys[i]] = self[keys[i]];\n    }\n    return o;\n}\nfunction recordToString(self) {\n    return \"{ \" + Object.entries(self).map(([k, v]) => k + \" = \" + toString(v)).join(\"\\n  \") + \" }\";\n}\nfunction recordGetHashCode(self) {\n    const hashes = Object.values(self).map((v) => structuralHash(v));\n    return combineHashCodes(hashes);\n}\nfunction recordEquals(self, other) {\n    if (self === other) {\n        return true;\n    }\n    else if (!sameConstructor(self, other)) {\n        return false;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            if (!equals(self[thisNames[i]], other[thisNames[i]])) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\nfunction recordCompareTo(self, other) {\n    if (self === other) {\n        return 0;\n    }\n    else if (!sameConstructor(self, other)) {\n        return -1;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            const result = compare(self[thisNames[i]], other[thisNames[i]]);\n            if (result !== 0) {\n                return result;\n            }\n        }\n        return 0;\n    }\n}\nexport class Record {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class FSharpRef {\n    constructor(contentsOrGetter, setter) {\n        if (typeof setter === \"function\") {\n            this.getter = contentsOrGetter;\n            this.setter = setter;\n        }\n        else {\n            this.getter = () => contentsOrGetter;\n            this.setter = (v) => { contentsOrGetter = v; };\n        }\n    }\n    get contents() {\n        return this.getter();\n    }\n    set contents(v) {\n        this.setter(v);\n    }\n}\n// EXCEPTIONS\n// Exception is intentionally not derived from Error, for performance reasons (see #2160)\nexport class Exception {\n    constructor(message) {\n        this.message = message;\n    }\n}\nexport function isException(x) {\n    return x instanceof Exception || x instanceof Error;\n}\nexport class FSharpException extends Exception {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class MatchFailureException extends FSharpException {\n    constructor(arg1, arg2, arg3) {\n        super();\n        this.arg1 = arg1;\n        this.arg2 = arg2 | 0;\n        this.arg3 = arg3 | 0;\n        this.message = \"The match cases were incomplete\";\n    }\n}\nexport class Attribute {\n}\n","// export type decimal = Decimal;\nexport var NumberStyles;\n(function (NumberStyles) {\n    // None = 0x00000000,\n    // AllowLeadingWhite = 0x00000001,\n    // AllowTrailingWhite = 0x00000002,\n    // AllowLeadingSign = 0x00000004,\n    // AllowTrailingSign = 0x00000008,\n    // AllowParentheses = 0x00000010,\n    // AllowDecimalPoint = 0x00000020,\n    // AllowThousands = 0x00000040,\n    // AllowExponent = 0x00000080,\n    // AllowCurrencySymbol = 0x00000100,\n    NumberStyles[NumberStyles[\"AllowHexSpecifier\"] = 512] = \"AllowHexSpecifier\";\n    // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,\n    // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,\n    // Number = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //          AllowTrailingSign | AllowDecimalPoint | AllowThousands,\n    // Float = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //         AllowDecimalPoint | AllowExponent,\n    // Currency = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,\n    // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,\n})(NumberStyles || (NumberStyles = {}));\nfunction validResponse(regexMatch, radix) {\n    const [/*all*/ , sign, prefix, digits] = regexMatch;\n    return {\n        sign: sign || \"\",\n        prefix: prefix || \"\",\n        digits,\n        radix,\n    };\n}\nfunction getRange(unsigned, bitsize) {\n    switch (bitsize) {\n        case 8: return unsigned ? [0, 255] : [-128, 127];\n        case 16: return unsigned ? [0, 65535] : [-32768, 32767];\n        case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];\n        default: throw new Error(\"Invalid bit size.\");\n    }\n}\nfunction getInvalidDigits(radix) {\n    switch (radix) {\n        case 2: return /[^0-1]/;\n        case 8: return /[^0-7]/;\n        case 10: return /[^0-9]/;\n        case 16: return /[^0-9a-fA-F]/;\n        default:\n            throw new Error(\"Invalid Base.\");\n    }\n}\nfunction getRadix(prefix, style) {\n    if (style & NumberStyles.AllowHexSpecifier) {\n        return 16;\n    }\n    else {\n        switch (prefix) {\n            case \"0b\":\n            case \"0B\": return 2;\n            case \"0o\":\n            case \"0O\": return 8;\n            case \"0x\":\n            case \"0X\": return 16;\n            default: return 10;\n        }\n    }\n}\nexport function isValid(str, style, radix) {\n    const integerRegex = /^\\s*([\\+\\-])?(0[xXoObB])?([0-9a-fA-F]+)\\s*$/;\n    const res = integerRegex.exec(str.replace(/_/g, \"\"));\n    if (res != null) {\n        const [/*all*/ , /*sign*/ , prefix, digits] = res;\n        radix = radix || getRadix(prefix, style);\n        const invalidDigits = getInvalidDigits(radix);\n        if (!invalidDigits.test(digits)) {\n            return validResponse(res, radix);\n        }\n    }\n    return null;\n}\nexport function parse(str, style, unsigned, bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        let v = Number.parseInt(res.sign + res.digits, res.radix);\n        if (!Number.isNaN(v)) {\n            const [umin, umax] = getRange(true, bitsize);\n            if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {\n                v = v << (32 - bitsize) >> (32 - bitsize);\n            }\n            const [min, max] = getRange(unsigned, bitsize);\n            if (v >= min && v <= max) {\n                return v;\n            }\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_UnaryNegation_Int8(x) {\n    return x === -128 ? x : -x;\n}\nexport function op_UnaryNegation_Int16(x) {\n    return x === -32768 ? x : -x;\n}\nexport function op_UnaryNegation_Int32(x) {\n    return x === -2147483648 ? x : -x;\n}\nexport function divRem(x, y, out) {\n    const div = ~~(x / y);\n    const rem = x % y;\n    if (out != null) {\n        out.contents = rem;\n        return div;\n    }\n    else {\n        return [div, rem];\n    }\n}\n","export const symbol = Symbol(\"numeric\");\nexport function isNumeric(x) {\n    return typeof x === \"number\" || (x === null || x === void 0 ? void 0 : x[symbol]);\n}\nexport function compare(x, y) {\n    if (typeof x === \"number\") {\n        return x < y ? -1 : (x > y ? 1 : 0);\n    }\n    else {\n        return x.CompareTo(y);\n    }\n}\nexport function multiply(x, y) {\n    if (typeof x === \"number\") {\n        return x * y;\n    }\n    else {\n        return x[symbol]().multiply(y);\n    }\n}\nexport function toFixed(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toFixed(dp);\n    }\n    else {\n        return x[symbol]().toFixed(dp);\n    }\n}\nexport function toPrecision(x, sd) {\n    if (typeof x === \"number\") {\n        return x.toPrecision(sd);\n    }\n    else {\n        return x[symbol]().toPrecision(sd);\n    }\n}\nexport function toExponential(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toExponential(dp);\n    }\n    else {\n        return x[symbol]().toExponential(dp);\n    }\n}\nexport function toHex(x) {\n    if (typeof x === \"number\") {\n        return (Number(x) >>> 0).toString(16);\n    }\n    else {\n        return x[symbol]().toHex();\n    }\n}\n","// Adapted from: https://github.com/dcodeIO/long.js/blob/master/src/long.js\n// Apache License 2.0: https://github.com/dcodeIO/long.js/blob/master/LICENSE\n/* tslint:disable */\nimport { symbol } from \"../Numeric.js\";\n/**\n * wasm optimizations, to do native i64 multiplication and divide\n */\nvar wasm = null;\ntry {\n    wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11\n    ])), {}).exports;\n}\ncatch (e) {\n    // no wasm support :(\n}\n/**\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n *  See the from* functions below for more convenient ways of constructing Longs.\n * @exports Long\n * @class A Long class for representing a 64 bit two's-complement integer value.\n * @param {number} low The low (signed) 32 bits of the long\n * @param {number} high The high (signed) 32 bits of the long\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @constructor\n */\nexport function Long(low, high, unsigned) {\n    /**\n     * The low 32 bits as a signed value.\n     * @type {number}\n     */\n    this.low = low | 0;\n    /**\n     * The high 32 bits as a signed value.\n     * @type {number}\n     */\n    this.high = high | 0;\n    /**\n     * Whether unsigned or not.\n     * @type {boolean}\n     */\n    this.unsigned = !!unsigned;\n}\nLong.prototype.GetHashCode = function () {\n    let h1 = this.unsigned ? 1 : 0;\n    h1 = ((h1 << 5) + h1) ^ this.high;\n    h1 = ((h1 << 5) + h1) ^ this.low;\n    return h1;\n};\nLong.prototype.Equals = function (x) { return equals(this, x); };\nLong.prototype.CompareTo = function (x) { return compare(this, x); };\nLong.prototype.toString = function (radix) { return toString(this, radix); };\nLong.prototype.toJSON = function () { return toString(this); };\nLong.prototype[symbol] = function () {\n    const x = this;\n    return {\n        multiply: y => multiply(x, y),\n        toPrecision: sd => String(x) + (0).toPrecision(sd).substr(1),\n        toExponential: dp => String(x) + (0).toExponential(dp).substr(1),\n        toFixed: dp => String(x) + (0).toFixed(dp).substr(1),\n        toHex: () => toString(x.unsigned ? x : fromBytes(toBytes(x), true), 16),\n    };\n};\n// The internal representation of a long is the two given signed, 32-bit values.\n// We use 32-bit pieces because these are the size of integers on which\n// Javascript performs bit-operations.  For operations like addition and\n// multiplication, we split each number into 16 bit pieces, which can easily be\n// multiplied within Javascript's floating-point representation without overflow\n// or change in sign.\n//\n// In the algorithms below, we frequently reduce the negative case to the\n// positive case by negating the input(s) and then post-processing the result.\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n// a positive number, it overflows back into a negative).  Not handling this\n// case would often result in infinite recursion.\n//\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\n// methods on which they depend.\n/**\n * An indicator used to reliably determine if an object is a Long or not.\n * @type {boolean}\n * @const\n * @private\n */\nLong.prototype.__isLong__;\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\n/**\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n * @inner\n */\nexport function isLong(obj) {\n    return (obj && obj[\"__isLong__\"]) === true;\n}\n/**\n * Tests if the specified object is a Long.\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n */\n// Long.isLong = isLong;\n/**\n * A cache of the Long representations of small integer values.\n * @type {!Object}\n * @inner\n */\nvar INT_CACHE = {};\n/**\n * A cache of the Long representations of small unsigned integer values.\n * @type {!Object}\n * @inner\n */\nvar UINT_CACHE = {};\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromInt(value, unsigned) {\n    var obj, cachedObj, cache;\n    if (unsigned) {\n        value >>>= 0;\n        if (cache = (0 <= value && value < 256)) {\n            cachedObj = UINT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\n        if (cache)\n            UINT_CACHE[value] = obj;\n        return obj;\n    }\n    else {\n        value |= 0;\n        if (cache = (-128 <= value && value < 128)) {\n            cachedObj = INT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\n        if (cache)\n            INT_CACHE[value] = obj;\n        return obj;\n    }\n}\n/**\n * Returns a Long representing the given 32 bit integer value.\n * @function\n * @param {number} value The 32 bit integer in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromInt = fromInt;\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromNumber(value, unsigned) {\n    if (isNaN(value))\n        return unsigned ? UZERO : ZERO;\n    if (unsigned) {\n        if (value < 0)\n            return UZERO;\n        if (value >= TWO_PWR_64_DBL)\n            return MAX_UNSIGNED_VALUE;\n    }\n    else {\n        if (value <= -TWO_PWR_63_DBL)\n            return MIN_VALUE;\n        if (value + 1 >= TWO_PWR_63_DBL)\n            return MAX_VALUE;\n    }\n    if (value < 0)\n        return negate(fromNumber(-value, unsigned));\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\n}\n/**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @function\n * @param {number} value The number in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromNumber = fromNumber;\n/**\n * @param {number} lowBits\n * @param {number} highBits\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromBits(lowBits, highBits, unsigned) {\n    return new Long(lowBits, highBits, unsigned);\n}\n/**\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\n *  assumed to use 32 bits.\n * @function\n * @param {number} lowBits The low 32 bits\n * @param {number} highBits The high 32 bits\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromBits = fromBits;\n/**\n * @function\n * @param {number} base\n * @param {number} exponent\n * @returns {number}\n * @inner\n */\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\n/**\n * @param {string} str\n * @param {(boolean|number)=} unsigned\n * @param {number=} radix\n * @returns {!Long}\n * @inner\n */\nexport function fromString(str, unsigned, radix) {\n    if (str.length === 0)\n        throw Error('empty string');\n    if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\n        return ZERO;\n    if (typeof unsigned === 'number') {\n        // For goog.math.long compatibility\n        radix = unsigned,\n            unsigned = false;\n    }\n    else {\n        unsigned = !!unsigned;\n    }\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    var p = str.indexOf('-');\n    if (p > 0)\n        throw Error('interior hyphen');\n    else if (p === 0) {\n        return negate(fromString(str.substring(1), unsigned, radix));\n    }\n    // Do several (8) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 8));\n    var result = ZERO;\n    for (var i = 0; i < str.length; i += 8) {\n        var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);\n        if (size < 8) {\n            var power = fromNumber(pow_dbl(radix, size));\n            result = add(multiply(result, power), fromNumber(value));\n        }\n        else {\n            result = multiply(result, radixToPower);\n            result = add(result, fromNumber(value));\n        }\n    }\n    result.unsigned = unsigned;\n    return result;\n}\n/**\n * Returns a Long representation of the given string, written using the specified radix.\n * @function\n * @param {string} str The textual representation of the Long\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromString = fromString;\n/**\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromValue(val, unsigned) {\n    if (typeof val === 'number')\n        return fromNumber(val, unsigned);\n    if (typeof val === 'string')\n        return fromString(val, unsigned);\n    // Throws for non-objects, converts non-instanceof Long:\n    return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);\n}\n/**\n * Converts the specified value to a Long using the appropriate from* function for its type.\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long}\n */\n// Long.fromValue = fromValue;\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\n// no runtime penalty for these.\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_16_DBL = 1 << 16;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_24_DBL = 1 << 24;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n/**\n * @type {!Long}\n * @const\n * @inner\n */\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\n/**\n * @type {!Long}\n * @inner\n */\nexport var ZERO = fromInt(0);\n/**\n * Signed zero.\n * @type {!Long}\n */\n// Long.ZERO = ZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UZERO = fromInt(0, true);\n/**\n * Unsigned zero.\n * @type {!Long}\n */\n// Long.UZERO = UZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var ONE = fromInt(1);\n/**\n * Signed one.\n * @type {!Long}\n */\n// Long.ONE = ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UONE = fromInt(1, true);\n/**\n * Unsigned one.\n * @type {!Long}\n */\n// Long.UONE = UONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var NEG_ONE = fromInt(-1);\n/**\n * Signed negative one.\n * @type {!Long}\n */\n// Long.NEG_ONE = NEG_ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false);\n/**\n * Maximum signed value.\n * @type {!Long}\n */\n// Long.MAX_VALUE = MAX_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true);\n/**\n * Maximum unsigned value.\n * @type {!Long}\n */\n// Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n/**\n * Minimum signed value.\n * @type {!Long}\n */\n// Long.MIN_VALUE = MIN_VALUE;\n/**\n * @alias Long.prototype\n * @inner\n */\n// var LongPrototype = Long.prototype;\n/**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @this {!Long}\n * @returns {number}\n */\nexport function toInt($this) {\n    return $this.unsigned ? $this.low >>> 0 : $this.low;\n}\n;\n/**\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\n * @this {!Long}\n * @returns {number}\n */\nexport function toNumber($this) {\n    if ($this.unsigned)\n        return (($this.high >>> 0) * TWO_PWR_32_DBL) + ($this.low >>> 0);\n    return $this.high * TWO_PWR_32_DBL + ($this.low >>> 0);\n}\n;\n/**\n * Converts the Long to a string written in the specified radix.\n * @this {!Long}\n * @param {number=} radix Radix (2-36), defaults to 10\n * @returns {string}\n * @override\n * @throws {RangeError} If `radix` is out of range\n */\nexport function toString($this, radix) {\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    if (isZero($this))\n        return '0';\n    if (isNegative($this)) { // Unsigned Longs are never negative\n        if (equals($this, MIN_VALUE)) {\n            // We need to change the Long value before it can be negated, so we remove\n            // the bottom-most digit in this base and then recurse to do the rest.\n            var radixLong = fromNumber(radix), div = divide($this, radixLong), rem1 = subtract(multiply(div, radixLong), $this);\n            return toString(div, radix) + toInt(rem1).toString(radix);\n        }\n        else\n            return '-' + toString(negate($this), radix);\n    }\n    // Do several (6) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 6), $this.unsigned), rem = $this;\n    var result = '';\n    while (true) {\n        var remDiv = divide(rem, radixToPower), intval = toInt(subtract(rem, multiply(remDiv, radixToPower))) >>> 0, digits = intval.toString(radix);\n        rem = remDiv;\n        if (isZero(rem))\n            return digits + result;\n        else {\n            while (digits.length < 6)\n                digits = '0' + digits;\n            result = '' + digits + result;\n        }\n    }\n}\n;\n/**\n * Gets the high 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed high bits\n */\nexport function getHighBits($this) {\n    return $this.high;\n}\n;\n/**\n * Gets the high 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned high bits\n */\nexport function getHighBitsUnsigned($this) {\n    return $this.high >>> 0;\n}\n;\n/**\n * Gets the low 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed low bits\n */\nexport function getLowBits($this) {\n    return $this.low;\n}\n;\n/**\n * Gets the low 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned low bits\n */\nexport function getLowBitsUnsigned($this) {\n    return $this.low >>> 0;\n}\n;\n/**\n * Gets the number of bits needed to represent the absolute value of this Long.\n * @this {!Long}\n * @returns {number}\n */\nexport function getNumBitsAbs($this) {\n    if (isNegative($this)) // Unsigned Longs are never negative\n        return equals($this, MIN_VALUE) ? 64 : getNumBitsAbs(negate($this));\n    var val = $this.high != 0 ? $this.high : $this.low;\n    for (var bit = 31; bit > 0; bit--)\n        if ((val & (1 << bit)) != 0)\n            break;\n    return $this.high != 0 ? bit + 33 : bit + 1;\n}\n;\n/**\n * Tests if this Long's value equals zero.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isZero($this) {\n    return $this.high === 0 && $this.low === 0;\n}\n;\n/**\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\n * @returns {boolean}\n */\n// LongPrototype.eqz = LongPrototype.isZero;\n/**\n * Tests if this Long's value is negative.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isNegative($this) {\n    return !$this.unsigned && $this.high < 0;\n}\n;\n/**\n * Tests if this Long's value is positive.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isPositive($this) {\n    return $this.unsigned || $this.high >= 0;\n}\n;\n/**\n * Tests if this Long's value is odd.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isOdd($this) {\n    return ($this.low & 1) === 1;\n}\n;\n/**\n * Tests if this Long's value is even.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isEven($this) {\n    return ($this.low & 1) === 0;\n}\n;\n/**\n * Tests if this Long's value equals the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function equals($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if ($this.unsigned !== other.unsigned && ($this.high >>> 31) === 1 && (other.high >>> 31) === 1)\n        return false;\n    return $this.high === other.high && $this.low === other.low;\n}\n;\n/**\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.eq = LongPrototype.equals;\n/**\n * Tests if this Long's value differs from the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function notEquals($this, other) {\n    return !equals($this, /* validates */ other);\n}\n;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.neq = LongPrototype.notEquals;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ne = LongPrototype.notEquals;\n/**\n * Tests if this Long's value is less than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThan($this, other) {\n    return compare($this, /* validates */ other) < 0;\n}\n;\n/**\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lt = LongPrototype.lessThan;\n/**\n * Tests if this Long's value is less than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) <= 0;\n}\n;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lte = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.le = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is greater than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThan($this, other) {\n    return compare($this, /* validates */ other) > 0;\n}\n;\n/**\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gt = LongPrototype.greaterThan;\n/**\n * Tests if this Long's value is greater than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) >= 0;\n}\n;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gte = LongPrototype.greaterThanOrEqual;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ge = LongPrototype.greaterThanOrEqual;\n/**\n * Compares this Long's value with the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\nexport function compare($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if (equals($this, other))\n        return 0;\n    var thisNeg = isNegative($this), otherNeg = isNegative(other);\n    if (thisNeg && !otherNeg)\n        return -1;\n    if (!thisNeg && otherNeg)\n        return 1;\n    // At this point the sign bits are the same\n    if (!$this.unsigned)\n        return isNegative(subtract($this, other)) ? -1 : 1;\n    // Both are positive if at least one is unsigned\n    return (other.high >>> 0) > ($this.high >>> 0) || (other.high === $this.high && (other.low >>> 0) > ($this.low >>> 0)) ? -1 : 1;\n}\n;\n/**\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\n// LongPrototype.comp = LongPrototype.compare;\n/**\n * Negates this Long's value.\n * @this {!Long}\n * @returns {!Long} Negated Long\n */\nexport function negate($this) {\n    if (!$this.unsigned && equals($this, MIN_VALUE))\n        return MIN_VALUE;\n    return add(not($this), ONE);\n}\n;\n/**\n * Negates this Long's value. This is an alias of {@link Long#negate}.\n * @function\n * @returns {!Long} Negated Long\n */\n// LongPrototype.neg = LongPrototype.negate;\n/**\n * Returns the sum of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} addend Addend\n * @returns {!Long} Sum\n */\nexport function add($this, addend) {\n    if (!isLong(addend))\n        addend = fromValue(addend);\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = addend.high >>> 16;\n    var b32 = addend.high & 0xFFFF;\n    var b16 = addend.low >>> 16;\n    var b00 = addend.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 + b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 + b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 + b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 + b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the difference of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nexport function subtract($this, subtrahend) {\n    if (!isLong(subtrahend))\n        subtrahend = fromValue(subtrahend);\n    return add($this, negate(subtrahend));\n}\n;\n/**\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\n * @function\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\n// LongPrototype.sub = LongPrototype.subtract;\n/**\n * Returns the product of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nexport function multiply($this, multiplier) {\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    if (!isLong(multiplier))\n        multiplier = fromValue(multiplier);\n    // use wasm support if present\n    if (wasm) {\n        var low = wasm.mul($this.low, $this.high, multiplier.low, multiplier.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero(multiplier))\n        return $this.unsigned ? UZERO : ZERO;\n    if (equals($this, MIN_VALUE))\n        return isOdd(multiplier) ? MIN_VALUE : ZERO;\n    if (equals(multiplier, MIN_VALUE))\n        return isOdd($this) ? MIN_VALUE : ZERO;\n    if (isNegative($this)) {\n        if (isNegative(multiplier))\n            return multiply(negate($this), negate(multiplier));\n        else\n            return negate(multiply(negate($this), multiplier));\n    }\n    else if (isNegative(multiplier))\n        return negate(multiply($this, negate(multiplier)));\n    // If both longs are small, use float multiplication\n    if (lessThan($this, TWO_PWR_24) && lessThan(multiplier, TWO_PWR_24))\n        return fromNumber(toNumber($this) * toNumber(multiplier), $this.unsigned);\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n    // We can skip products that would overflow.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = multiplier.high >>> 16;\n    var b32 = multiplier.high & 0xFFFF;\n    var b16 = multiplier.low >>> 16;\n    var b00 = multiplier.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 * b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 * b00;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c16 += a00 * b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 * b00;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a16 * b16;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a00 * b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\n * @function\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\n// LongPrototype.mul = LongPrototype.multiply;\n/**\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\n *  unsigned if this Long is unsigned.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nexport function divide($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    if (isZero(divisor))\n        throw Error('division by zero');\n    // use wasm support if present\n    if (wasm) {\n        // guard against signed division overflow: the largest\n        // negative number / -1 would be 1 larger than the largest\n        // positive number, due to two's complement.\n        if (!$this.unsigned &&\n            $this.high === -0x80000000 &&\n            divisor.low === -1 && divisor.high === -1) {\n            // be consistent with non-wasm code path\n            return $this;\n        }\n        var low = ($this.unsigned ? wasm.div_u : wasm.div_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    var approx, rem, res;\n    if (!$this.unsigned) {\n        // This section is only relevant for signed longs and is derived from the\n        // closure library as a whole.\n        if (equals($this, MIN_VALUE)) {\n            if (equals(divisor, ONE) || equals(divisor, NEG_ONE))\n                return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE\n            else if (equals(divisor, MIN_VALUE))\n                return ONE;\n            else {\n                // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n                var halfThis = shiftRight($this, 1);\n                approx = shiftLeft(divide(halfThis, divisor), 1);\n                if (equals(approx, ZERO)) {\n                    return isNegative(divisor) ? ONE : NEG_ONE;\n                }\n                else {\n                    rem = subtract($this, multiply(divisor, approx));\n                    res = add(approx, divide(rem, divisor));\n                    return res;\n                }\n            }\n        }\n        else if (equals(divisor, MIN_VALUE))\n            return $this.unsigned ? UZERO : ZERO;\n        if (isNegative($this)) {\n            if (isNegative(divisor))\n                return divide(negate($this), negate(divisor));\n            return negate(divide(negate($this), divisor));\n        }\n        else if (isNegative(divisor))\n            return negate(divide($this, negate(divisor)));\n        res = ZERO;\n    }\n    else {\n        // The algorithm below has not been made for unsigned longs. It's therefore\n        // required to take special care of the MSB prior to running it.\n        if (!divisor.unsigned)\n            divisor = toUnsigned(divisor);\n        if (greaterThan(divisor, $this))\n            return UZERO;\n        if (greaterThan(divisor, shiftRightUnsigned($this, 1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\n            return UONE;\n        res = UZERO;\n    }\n    // Repeat the following until the remainder is less than other:  find a\n    // floating-point that approximates remainder / other *from below*, add this\n    // into the result, and subtract it from the remainder.  It is critical that\n    // the approximate value is less than or equal to the real value so that the\n    // remainder never becomes negative.\n    rem = $this;\n    while (greaterThanOrEqual(rem, divisor)) {\n        // Approximate the result of division. This may be a little greater or\n        // smaller than the actual value.\n        approx = Math.max(1, Math.floor(toNumber(rem) / toNumber(divisor)));\n        // We will tweak the approximate result by changing it in the 48-th digit or\n        // the smallest non-fractional digit, whichever is larger.\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), \n        // Decrease the approximation until it is smaller than the remainder.  Note\n        // that if it is too large, the product overflows and is negative.\n        approxRes = fromNumber(approx), approxRem = multiply(approxRes, divisor);\n        while (isNegative(approxRem) || greaterThan(approxRem, rem)) {\n            approx -= delta;\n            approxRes = fromNumber(approx, $this.unsigned);\n            approxRem = multiply(approxRes, divisor);\n        }\n        // We know the answer can't be zero... and actually, zero would cause\n        // infinite recursion since we would make no progress.\n        if (isZero(approxRes))\n            approxRes = ONE;\n        res = add(res, approxRes);\n        rem = subtract(rem, approxRem);\n    }\n    return res;\n}\n;\n/**\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\n// LongPrototype.div = LongPrototype.divide;\n/**\n * Returns this Long modulo the specified.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nexport function modulo($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    // use wasm support if present\n    if (wasm) {\n        var low = ($this.unsigned ? wasm.rem_u : wasm.rem_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    return subtract($this, multiply(divide($this, divisor), divisor));\n}\n;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.mod = LongPrototype.modulo;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.rem = LongPrototype.modulo;\n/**\n * Returns the bitwise NOT of this Long.\n * @this {!Long}\n * @returns {!Long}\n */\nexport function not($this) {\n    return fromBits(~$this.low, ~$this.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise AND of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function and($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low & other.low, $this.high & other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise OR of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function or($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low | other.low, $this.high | other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise XOR of this Long and the given one.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function xor($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low ^ other.low, $this.high ^ other.high, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftLeft($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits($this.low << numBits, ($this.high << numBits) | ($this.low >>> (32 - numBits)), $this.unsigned);\n    else\n        return fromBits(0, $this.low << (numBits - 32), $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shl = LongPrototype.shiftLeft;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRight($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits(($this.low >>> numBits) | ($this.high << (32 - numBits)), $this.high >> numBits, $this.unsigned);\n    else\n        return fromBits($this.high >> (numBits - 32), $this.high >= 0 ? 0 : -1, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr = LongPrototype.shiftRight;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRightUnsigned($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    numBits &= 63;\n    if (numBits === 0)\n        return $this;\n    else {\n        var high = $this.high;\n        if (numBits < 32) {\n            var low = $this.low;\n            return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, $this.unsigned);\n        }\n        else if (numBits === 32)\n            return fromBits(high, 0, $this.unsigned);\n        else\n            return fromBits(high >>> (numBits - 32), 0, $this.unsigned);\n    }\n}\n;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shru = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits rotated to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateLeft = function rotateLeft(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.low << numBits) | (this.high >>> b)), ((this.high << numBits) | (this.low >>> b)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.high << numBits) | (this.low >>> b)), ((this.low << numBits) | (this.high >>> b)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotl = LongPrototype.rotateLeft;\n/**\n * Returns this Long with bits rotated to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateRight = function rotateRight(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.high << b) | (this.low >>> numBits)), ((this.low << b) | (this.high >>> numBits)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.low << b) | (this.high >>> numBits)), ((this.high << b) | (this.low >>> numBits)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotr = LongPrototype.rotateRight;\n/**\n * Converts this Long to signed.\n * @this {!Long}\n * @returns {!Long} Signed long\n */\nexport function toSigned($this) {\n    if (!$this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, false);\n}\n;\n/**\n * Converts this Long to unsigned.\n * @this {!Long}\n * @returns {!Long} Unsigned long\n */\nexport function toUnsigned($this) {\n    if ($this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, true);\n}\n;\n/**\n * Converts this Long to its byte representation.\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @this {!Long}\n * @returns {!Array.<number>} Byte representation\n */\nexport function toBytes($this, le) {\n    return le ? toBytesLE($this) : toBytesBE($this);\n}\n;\n/**\n * Converts this Long to its little endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Little endian byte representation\n */\nexport function toBytesLE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        lo & 0xff,\n        lo >>> 8 & 0xff,\n        lo >>> 16 & 0xff,\n        lo >>> 24,\n        hi & 0xff,\n        hi >>> 8 & 0xff,\n        hi >>> 16 & 0xff,\n        hi >>> 24\n    ];\n}\n;\n/**\n * Converts this Long to its big endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Big endian byte representation\n */\nexport function toBytesBE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        hi >>> 24,\n        hi >>> 16 & 0xff,\n        hi >>> 8 & 0xff,\n        hi & 0xff,\n        lo >>> 24,\n        lo >>> 16 & 0xff,\n        lo >>> 8 & 0xff,\n        lo & 0xff\n    ];\n}\n;\n/**\n * Creates a Long from its byte representation.\n * @param {!Array.<number>} bytes Byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytes(bytes, unsigned, le) {\n    return le ? fromBytesLE(bytes, unsigned) : fromBytesBE(bytes, unsigned);\n}\n;\n/**\n * Creates a Long from its little endian byte representation.\n * @param {!Array.<number>} bytes Little endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesLE(bytes, unsigned) {\n    return new Long(bytes[0] |\n        bytes[1] << 8 |\n        bytes[2] << 16 |\n        bytes[3] << 24, bytes[4] |\n        bytes[5] << 8 |\n        bytes[6] << 16 |\n        bytes[7] << 24, unsigned);\n}\n;\n/**\n * Creates a Long from its big endian byte representation.\n * @param {!Array.<number>} bytes Big endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesBE(bytes, unsigned) {\n    return new Long(bytes[4] << 24 |\n        bytes[5] << 16 |\n        bytes[6] << 8 |\n        bytes[7], bytes[0] << 24 |\n        bytes[1] << 16 |\n        bytes[2] << 8 |\n        bytes[3], unsigned);\n}\n;\n","import { isValid } from \"./Int32.js\";\nimport * as LongLib from \"./lib/long.js\";\nexport default LongLib.Long;\nexport const get_Zero = LongLib.ZERO;\nexport const get_One = LongLib.ONE;\nexport const op_Addition = LongLib.add;\nexport const op_Subtraction = LongLib.subtract;\nexport const op_Multiply = LongLib.multiply;\nexport const op_Division = LongLib.divide;\nexport const op_Modulus = LongLib.modulo;\nexport const op_UnaryNegation = LongLib.negate;\nexport const op_LeftShift = LongLib.shiftLeft;\nexport const op_RightShift = LongLib.shiftRight;\nexport const op_RightShiftUnsigned = LongLib.shiftRightUnsigned;\nexport const op_BitwiseAnd = LongLib.and;\nexport const op_BitwiseOr = LongLib.or;\nexport const op_ExclusiveOr = LongLib.xor;\nexport const op_LogicalNot = LongLib.not;\nexport const op_LessThan = LongLib.lessThan;\nexport const op_LessThanOrEqual = LongLib.lessThanOrEqual;\nexport const op_GreaterThan = LongLib.greaterThan;\nexport const op_GreaterThanOrEqual = LongLib.greaterThanOrEqual;\nexport const op_Equality = LongLib.equals;\nexport const op_Inequality = LongLib.notEquals;\nexport const equals = LongLib.equals;\nexport const compare = LongLib.compare;\nexport const fromInt = LongLib.fromInt;\nexport const fromBits = LongLib.fromBits;\nexport const fromBytes = LongLib.fromBytes;\nexport const fromNumber = LongLib.fromNumber;\nexport const fromString = LongLib.fromString;\nexport const fromValue = LongLib.fromValue;\nexport const toInt = LongLib.toInt;\nexport const toBytes = LongLib.toBytes;\nexport const toNumber = LongLib.toNumber;\nexport const toString = LongLib.toString;\nexport const getLowBits = LongLib.getLowBits;\nexport const getHighBits = LongLib.getHighBits;\nexport const getLowBitsUnsigned = LongLib.getLowBitsUnsigned;\nexport const getHighBitsUnsigned = LongLib.getHighBitsUnsigned;\nfunction getMaxValue(unsigned, radix, isNegative) {\n    switch (radix) {\n        case 2: return unsigned ?\n            \"1111111111111111111111111111111111111111111111111111111111111111\" :\n            (isNegative ? \"1000000000000000000000000000000000000000000000000000000000000000\"\n                : \"111111111111111111111111111111111111111111111111111111111111111\");\n        case 8: return unsigned ?\n            \"1777777777777777777777\" :\n            (isNegative ? \"1000000000000000000000\" : \"777777777777777777777\");\n        case 10: return unsigned ?\n            \"18446744073709551615\" :\n            (isNegative ? \"9223372036854775808\" : \"9223372036854775807\");\n        case 16: return unsigned ?\n            \"FFFFFFFFFFFFFFFF\" :\n            (isNegative ? \"8000000000000000\" : \"7FFFFFFFFFFFFFFF\");\n        default: throw new Error(\"Invalid radix.\");\n    }\n}\nexport function abs(x) {\n    if (!x.unsigned && LongLib.isNegative(x)) {\n        return op_UnaryNegation(x);\n    }\n    else {\n        return x;\n    }\n}\nexport function fromInteger(value, unsigned, kind) {\n    let x = value;\n    let xh = 0;\n    switch (kind) {\n        case 0:\n            x = value << 24 >> 24;\n            xh = x;\n            break;\n        case 4:\n            x = value << 24 >>> 24;\n            break;\n        case 1:\n            x = value << 16 >> 16;\n            xh = x;\n            break;\n        case 5:\n            x = value << 16 >>> 16;\n            break;\n        case 2:\n            x = value >> 0;\n            xh = x;\n            break;\n        case 6:\n            x = value >>> 0;\n            break;\n    }\n    return LongLib.fromBits(x, xh >> 31, unsigned);\n}\nexport function parse(str, style, unsigned, _bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        const lessOrEqual = (x, y) => {\n            const len = Math.max(x.length, y.length);\n            return x.padStart(len, \"0\") <= y.padStart(len, \"0\");\n        };\n        const isNegative = res.sign === \"-\";\n        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);\n        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {\n            str = isNegative ? res.sign + res.digits : res.digits;\n            return LongLib.fromString(str, unsigned, res.radix);\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function unixEpochMillisecondsToTicks(ms, offset) {\n    return op_Multiply(op_Addition(op_Addition(LongLib.fromNumber(ms), 62135596800000), offset), 10000);\n}\nexport function ticksToUnixEpochMilliseconds(ticks) {\n    return LongLib.toNumber(op_Subtraction(op_Division(ticks, 10000), 62135596800000));\n}\n// export function makeRangeStepFunction(step: Long, last: Long, unsigned: boolean) {\n//   const stepComparedWithZero = LongLib.compare(step, unsigned ? LongLib.UZERO : LongLib.ZERO);\n//   if (stepComparedWithZero === 0) {\n//     throw new Error(\"The step of a range cannot be zero\");\n//   }\n//   const stepGreaterThanZero = stepComparedWithZero > 0;\n//   return (x: Long) => {\n//     const comparedWithLast = LongLib.compare(x, last);\n//     if ((stepGreaterThanZero && comparedWithLast <= 0)\n//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n//       return [x, op_Addition(x, step)];\n//     } else {\n//       return undefined;\n//     }\n//   };\n// }\nexport function divRem(x, y, out) {\n    const div = op_Division(x, y);\n    const rem = op_Modulus(x, y);\n    if (out != null) {\n        out.contents = rem;\n        return div;\n    }\n    else {\n        return [div, rem];\n    }\n}\n","/**\n * DateTimeOffset functions.\n *\n * Note: Date instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, dateOffset, padWithZeros } from \"./Util.js\";\nexport function dateOffsetToString(offset) {\n    const isMinus = offset < 0;\n    offset = Math.abs(offset);\n    const hours = ~~(offset / 3600000);\n    const minutes = (offset % 3600000) / 60000;\n    return (isMinus ? \"-\" : \"+\") +\n        padWithZeros(hours, 2) + \":\" +\n        padWithZeros(minutes, 2);\n}\nexport function dateToHalfUTCString(date, half) {\n    const str = date.toISOString();\n    return half === \"first\"\n        ? str.substring(0, str.indexOf(\"T\"))\n        : str.substring(str.indexOf(\"T\") + 1, str.length - 1);\n}\nfunction dateToISOString(d, utc) {\n    if (utc) {\n        return d.toISOString();\n    }\n    else {\n        // JS Date is always local\n        const printOffset = d.kind == null ? true : d.kind === 2 /* Local */;\n        return padWithZeros(d.getFullYear(), 4) + \"-\" +\n            padWithZeros(d.getMonth() + 1, 2) + \"-\" +\n            padWithZeros(d.getDate(), 2) + \"T\" +\n            padWithZeros(d.getHours(), 2) + \":\" +\n            padWithZeros(d.getMinutes(), 2) + \":\" +\n            padWithZeros(d.getSeconds(), 2) + \".\" +\n            padWithZeros(d.getMilliseconds(), 3) +\n            (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -60000) : \"\");\n    }\n}\nfunction dateToISOStringWithOffset(dateWithOffset, offset) {\n    const str = dateWithOffset.toISOString();\n    return str.substring(0, str.length - 1) + dateOffsetToString(offset);\n}\nfunction dateToStringWithCustomFormat(date, format, utc) {\n    return format.replace(/(\\w)\\1*/g, (match) => {\n        let rep = Number.NaN;\n        switch (match.substring(0, 1)) {\n            case \"y\":\n                const y = utc ? date.getUTCFullYear() : date.getFullYear();\n                rep = match.length < 4 ? y % 100 : y;\n                break;\n            case \"M\":\n                rep = (utc ? date.getUTCMonth() : date.getMonth()) + 1;\n                break;\n            case \"d\":\n                rep = utc ? date.getUTCDate() : date.getDate();\n                break;\n            case \"H\":\n                rep = utc ? date.getUTCHours() : date.getHours();\n                break;\n            case \"h\":\n                const h = utc ? date.getUTCHours() : date.getHours();\n                rep = h > 12 ? h % 12 : h;\n                break;\n            case \"m\":\n                rep = utc ? date.getUTCMinutes() : date.getMinutes();\n                break;\n            case \"s\":\n                rep = utc ? date.getUTCSeconds() : date.getSeconds();\n                break;\n            case \"f\":\n                rep = utc ? date.getUTCMilliseconds() : date.getMilliseconds();\n                break;\n        }\n        if (Number.isNaN(rep)) {\n            return match;\n        }\n        else {\n            return (rep < 10 && match.length > 1) ? \"0\" + rep : \"\" + rep;\n        }\n    });\n}\nfunction dateToStringWithOffset(date, format) {\n    var _a, _b, _c;\n    const d = new Date(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0));\n    if (typeof format !== \"string\") {\n        return d.toISOString().replace(/\\.\\d+/, \"\").replace(/[A-Z]|\\.\\d+/g, \" \") + dateOffsetToString(((_b = date.offset) !== null && _b !== void 0 ? _b : 0));\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\": return dateToHalfUTCString(d, \"first\");\n            case \"T\":\n            case \"t\": return dateToHalfUTCString(d, \"second\");\n            case \"O\":\n            case \"o\": return dateToISOStringWithOffset(d, ((_c = date.offset) !== null && _c !== void 0 ? _c : 0));\n            default: throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(d, format, true);\n    }\n}\nfunction dateToStringWithKind(date, format) {\n    const utc = date.kind === 1 /* UTC */;\n    if (typeof format !== \"string\") {\n        return utc ? date.toUTCString() : date.toLocaleString();\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\":\n                return utc ? dateToHalfUTCString(date, \"first\") : date.toLocaleDateString();\n            case \"T\":\n            case \"t\":\n                return utc ? dateToHalfUTCString(date, \"second\") : date.toLocaleTimeString();\n            case \"O\":\n            case \"o\":\n                return dateToISOString(date, utc);\n            default:\n                throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(date, format, utc);\n    }\n}\nexport function toString(date, format, _provider) {\n    return date.offset != null\n        ? dateToStringWithOffset(date, format)\n        : dateToStringWithKind(date, format);\n}\nexport function DateTime(value, kind) {\n    const d = new Date(value);\n    d.kind = (kind == null ? 0 /* Unspecified */ : kind) | 0;\n    return d;\n}\nexport function fromTicks(ticks, kind) {\n    ticks = fromValue(ticks);\n    kind = kind != null ? kind : 2 /* Local */; // better default than Unspecified\n    let date = DateTime(ticksToUnixEpochMilliseconds(ticks), kind);\n    // Ticks are local to offset (in this case, either UTC or Local/Unknown).\n    // If kind is anything but UTC, that means that the tick number was not\n    // in utc, thus getTime() cannot return UTC, and needs to be shifted.\n    if (kind !== 1 /* UTC */) {\n        date = DateTime(date.getTime() - dateOffset(date), kind);\n    }\n    return date;\n}\nexport function fromDateTimeOffset(date, kind) {\n    var _a;\n    switch (kind) {\n        case 1 /* UTC */: return DateTime(date.getTime(), 1 /* UTC */);\n        case 2 /* Local */: return DateTime(date.getTime(), 2 /* Local */);\n        default:\n            const d = DateTime(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0), kind);\n            return DateTime(d.getTime() - dateOffset(d), kind);\n    }\n}\nexport function getTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), dateOffset(date));\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTime(-62135596800000, 0 /* Unspecified */);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTime(253402300799999, 0 /* Unspecified */);\n}\nexport function parseRaw(input) {\n    function fail() {\n        throw new Error(`The string is not a valid Date: ${input}`);\n    }\n    if (input === null || input.trim() === \"\") {\n        fail();\n    }\n    // ISO dates without TZ are parsed as UTC. Adding time without TZ keeps them local.\n    if (input.length === 10 && input[4] === \"-\" && input[7] === \"-\") {\n        input += \"T00:00:00\";\n    }\n    let date = new Date(input);\n    let offset = null;\n    if (isNaN(date.getTime())) {\n        // Try to check strings JS Date cannot parse (see #1045, #1422)\n        // tslint:disable-next-line:max-line-length\n        const m = /^\\s*(\\d+[^\\w\\s:]\\d+[^\\w\\s:]\\d+)?\\s*(\\d+:\\d+(?::\\d+(?:\\.\\d+)?)?)?\\s*([AaPp][Mm])?\\s*(Z|[+-]([01]?\\d):?([0-5]?\\d)?)?\\s*$/.exec(input);\n        if (m != null) {\n            let baseDate;\n            let timeInSeconds = 0;\n            if (m[2] != null) {\n                const timeParts = m[2].split(\":\");\n                timeInSeconds =\n                    parseInt(timeParts[0], 10) * 3600 +\n                        parseInt(timeParts[1] || \"0\", 10) * 60 +\n                        parseFloat(timeParts[2] || \"0\");\n                if (m[3] != null && m[3].toUpperCase() === \"PM\") {\n                    timeInSeconds += 720;\n                }\n            }\n            if (m[4] != null) { // There's an offset, parse as UTC\n                if (m[1] != null) {\n                    baseDate = new Date(m[1] + \" UTC\");\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getUTCFullYear() + \"/\" + (d.getUTCMonth() + 1) + \"/\" + d.getUTCDate());\n                }\n                if (m[4] === \"Z\") {\n                    offset = \"Z\";\n                }\n                else {\n                    let offsetInMinutes = parseInt(m[5], 10) * 60 + parseInt(m[6] || \"0\", 10);\n                    if (m[4][0] === \"-\") {\n                        offsetInMinutes *= -1;\n                    }\n                    offset = offsetInMinutes;\n                    timeInSeconds -= offsetInMinutes * 60;\n                }\n            }\n            else {\n                if (m[1] != null) {\n                    baseDate = new Date(m[1]);\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getFullYear() + \"/\" + (d.getMonth() + 1) + \"/\" + d.getDate());\n                }\n            }\n            date = new Date(baseDate.getTime() + timeInSeconds * 1000);\n            // correct for daylight savings time\n            date = new Date(date.getTime() + (date.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 60000);\n        }\n        else {\n            fail();\n        }\n        // Check again the date is valid after transformations, see #2229\n        if (isNaN(date.getTime())) {\n            fail();\n        }\n    }\n    return [date, offset];\n}\nexport function parse(str, detectUTC = false) {\n    const [date, offset] = parseRaw(str);\n    // .NET always parses DateTime as Local if there's offset info (even \"Z\")\n    // Newtonsoft.Json uses UTC if the offset is \"Z\"\n    const kind = offset != null\n        ? (detectUTC && offset === \"Z\" ? 1 /* UTC */ : 2 /* Local */)\n        : 0 /* Unspecified */;\n    return DateTime(date.getTime(), kind);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {\n    const dateValue = kind === 1 /* UTC */\n        ? Date.UTC(year, month - 1, day, h, m, s, ms)\n        : new Date(year, month - 1, day, h, m, s, ms).getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date.\");\n    }\n    const date = DateTime(dateValue, kind);\n    if (year <= 99) {\n        date.setFullYear(year, month - 1, day);\n    }\n    return date;\n}\nexport function now() {\n    return DateTime(Date.now(), 2 /* Local */);\n}\nexport function utcNow() {\n    return DateTime(Date.now(), 1 /* UTC */);\n}\nexport function today() {\n    return date(now());\n}\nexport function isLeapYear(year) {\n    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n}\nexport function daysInMonth(year, month) {\n    return month === 2\n        ? (isLeapYear(year) ? 29 : 28)\n        : (month >= 8 ? (month % 2 === 0 ? 31 : 30) : (month % 2 === 0 ? 30 : 31));\n}\nexport function toUniversalTime(date) {\n    return date.kind === 1 /* UTC */ ? date : DateTime(date.getTime(), 1 /* UTC */);\n}\nexport function toLocalTime(date) {\n    return date.kind === 2 /* Local */ ? date : DateTime(date.getTime(), 2 /* Local */);\n}\nexport function specifyKind(d, kind) {\n    return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), kind);\n}\nexport function timeOfDay(d) {\n    return hour(d) * 3600000\n        + minute(d) * 60000\n        + second(d) * 1000\n        + millisecond(d);\n}\nexport function date(d) {\n    return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);\n}\nexport function day(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDate() : d.getDate();\n}\nexport function hour(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCHours() : d.getHours();\n}\nexport function millisecond(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMilliseconds() : d.getMilliseconds();\n}\nexport function minute(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMinutes() : d.getMinutes();\n}\nexport function month(d) {\n    return (d.kind === 1 /* UTC */ ? d.getUTCMonth() : d.getMonth()) + 1;\n}\nexport function second(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCSeconds() : d.getSeconds();\n}\nexport function year(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCFullYear() : d.getFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDay() : d.getDay();\n}\nexport function dayOfYear(d) {\n    const _year = year(d);\n    const _month = month(d);\n    let _day = day(d);\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    const newDate = DateTime(d.getTime() + ts, d.kind);\n    if (d.kind === 2 /* Local */) {\n        const oldTzOffset = d.getTimezoneOffset();\n        const newTzOffset = newDate.getTimezoneOffset();\n        return oldTzOffset !== newTzOffset\n            ? DateTime(newDate.getTime() + (newTzOffset - oldTzOffset) * 60000, d.kind)\n            : newDate;\n    }\n    else {\n        return newDate;\n    }\n}\nexport function addDays(d, v) {\n    return add(d, v * 86400000);\n}\nexport function addHours(d, v) {\n    return add(d, v * 3600000);\n}\nexport function addMinutes(d, v) {\n    return add(d, v * 60000);\n}\nexport function addSeconds(d, v) {\n    return add(d, v * 1000);\n}\nexport function addMilliseconds(d, v) {\n    return add(d, v);\n}\nexport function addYears(d, v) {\n    const newMonth = month(d);\n    const newYear = year(d) + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function addMonths(d, v) {\n    let newMonth = month(d) + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = year(d) + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function subtract(d, that) {\n    return typeof that === \"number\"\n        ? add(d, -that)\n        : d.getTime() - that.getTime();\n}\nexport function toLongDateString(d) {\n    return d.toDateString();\n}\nexport function toShortDateString(d) {\n    return d.toLocaleDateString();\n}\nexport function toLongTimeString(d) {\n    return d.toLocaleTimeString();\n}\nexport function toShortTimeString(d) {\n    return d.toLocaleTimeString().replace(/:\\d\\d(?!:)/, \"\");\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport const compare = compareDates;\nexport const compareTo = compareDates;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function isDaylightSavingTime(x) {\n    const jan = new Date(x.getFullYear(), 0, 1);\n    const jul = new Date(x.getFullYear(), 6, 1);\n    return isDST(jan.getTimezoneOffset(), jul.getTimezoneOffset(), x.getTimezoneOffset());\n}\nfunction isDST(janOffset, julOffset, tOffset) {\n    return Math.min(janOffset, julOffset) === tOffset;\n}\nexport default DateTime;\n","export function create(pattern, options = 0) {\n    // Supported RegexOptions\n    // * IgnoreCase:  0x0001\n    // * Multiline:   0x0002\n    // * Singleline:  0x0010\n    // * ECMAScript:  0x0100 (ignored)\n    if ((options & ~(1 ^ 2 ^ 16 ^ 256)) !== 0) {\n        throw new Error(\"RegexOptions only supports: IgnoreCase, Multiline, Singleline and ECMAScript\");\n    }\n    let flags = \"g\";\n    flags += options & 1 ? \"i\" : \"\"; // 0x0001 RegexOptions.IgnoreCase\n    flags += options & 2 ? \"m\" : \"\";\n    flags += options & 16 ? \"s\" : \"\";\n    return new RegExp(pattern, flags);\n}\n// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex\nexport function escape(str) {\n    return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n}\nexport function unescape(str) {\n    return str.replace(/\\\\([\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|])/g, \"$1\");\n}\nexport function isMatch(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    return reg.test(input);\n}\nexport function match(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    return reg.exec(input);\n}\nexport function matches(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    if (!reg.global) {\n        throw new Error(\"Non-global RegExp\"); // Prevent infinite loop\n    }\n    let m = reg.exec(input);\n    const matches = [];\n    while (m !== null) {\n        matches.push(m);\n        m = reg.exec(input);\n    }\n    return matches;\n}\nexport function options(reg) {\n    let options = 256; // ECMAScript\n    options |= reg.ignoreCase ? 1 : 0;\n    options |= reg.multiline ? 2 : 0;\n    return options;\n}\nexport function replace(reg, input, replacement, limit, offset = 0) {\n    function replacer() {\n        let res = arguments[0];\n        if (limit) {\n            limit--;\n            const match = [];\n            const len = arguments.length;\n            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter\n            // * match: matched substring\n            // * p1, p2, ...: nth capture group string\n            // * offset: offset of matched substring\n            // * string: whole string examined\n            // * groups: named capturing groups\n            //           ONLY if regex contains a named capture group AND browser supports named groups\n            // -> last element can be groups OR input string\n            // -> check if last element is string\n            const withGroups = typeof arguments[len - 1] !== \"string\";\n            let pLast = withGroups ? len - 3 : len - 2;\n            for (let i = 0; i < pLast; i++) {\n                match.push(arguments[i]);\n            }\n            match.index = arguments[pLast++];\n            match.input = arguments[pLast++];\n            if (withGroups) {\n                match.groups = arguments[pLast];\n            }\n            res = replacement(match);\n        }\n        return res;\n    }\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    if (typeof replacement === \"function\") {\n        limit = limit == null ? -1 : limit;\n        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);\n    }\n    else {\n        replacement =\n            replacement\n                // $0 doesn't work with JS regex, see #1155\n                .replace(/\\$0/g, (_s) => \"$&\")\n                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)\n                .replace(/\\${([^}]+)}/g, \"\\$<$1>\");\n        if (limit != null) {\n            let m;\n            const sub1 = input.substring(offset);\n            const _matches = matches(reg, sub1);\n            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;\n            return input.substring(0, offset) + sub2.replace(reg, replacement)\n                + input.substring(offset + sub2.length);\n        }\n        else {\n            return input.replace(reg, replacement);\n        }\n    }\n}\nexport function split(reg, input, limit, offset = 0) {\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    input = input.substring(offset);\n    return input.split(reg, limit);\n}\n","import { toString as dateToString } from \"./Date.js\";\nimport { compare as numericCompare, isNumeric, multiply, toExponential, toFixed, toHex, toPrecision } from \"./Numeric.js\";\nimport { escape } from \"./RegExp.js\";\nimport { toString } from \"./Types.js\";\nconst fsFormatRegExp = /(^|[^%])%([0+\\- ]*)(\\*|\\d+)?(?:\\.(\\d+))?(\\w)/g;\nconst interpolateRegExp = /(?:(^|[^%])%([0+\\- ]*)(\\d+)?(?:\\.(\\d+))?(\\w))?%P\\(\\)/g;\nconst formatRegExp = /\\{(\\d+)(,-?\\d+)?(?:\\:([a-zA-Z])(\\d{0,2})|\\:(.+?))?\\}/g;\nfunction isLessThan(x, y) {\n    return numericCompare(x, y) < 0;\n}\nfunction cmp(x, y, ic) {\n    function isIgnoreCase(i) {\n        return i === true ||\n            i === 1 /* CurrentCultureIgnoreCase */ ||\n            i === 3 /* InvariantCultureIgnoreCase */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    function isOrdinal(i) {\n        return i === 4 /* Ordinal */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    if (y == null) {\n        return 1;\n    } // everything is bigger than null\n    if (isOrdinal(ic)) {\n        if (isIgnoreCase(ic)) {\n            x = x.toLowerCase();\n            y = y.toLowerCase();\n        }\n        return (x === y) ? 0 : (x < y ? -1 : 1);\n    }\n    else {\n        if (isIgnoreCase(ic)) {\n            x = x.toLocaleLowerCase();\n            y = y.toLocaleLowerCase();\n        }\n        return x.localeCompare(y);\n    }\n}\nexport function compare(...args) {\n    switch (args.length) {\n        case 2: return cmp(args[0], args[1], false);\n        case 3: return cmp(args[0], args[1], args[2]);\n        case 4: return cmp(args[0], args[1], args[2] === true);\n        case 5: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), false);\n        case 6: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5]);\n        case 7: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5] === true);\n        default: throw new Error(\"String.compare: Unsupported number of parameters\");\n    }\n}\nexport function compareOrdinal(x, y) {\n    return cmp(x, y, 4 /* Ordinal */);\n}\nexport function compareTo(x, y) {\n    return cmp(x, y, 0 /* CurrentCulture */);\n}\nexport function startsWith(str, pattern, ic) {\n    if (str.length >= pattern.length) {\n        return cmp(str.substr(0, pattern.length), pattern, ic) === 0;\n    }\n    return false;\n}\nexport function indexOfAny(str, anyOf, ...args) {\n    if (str == null || str === \"\") {\n        return -1;\n    }\n    const startIndex = (args.length > 0) ? args[0] : 0;\n    if (startIndex < 0) {\n        throw new Error(\"Start index cannot be negative\");\n    }\n    const length = (args.length > 1) ? args[1] : str.length - startIndex;\n    if (length < 0) {\n        throw new Error(\"Length cannot be negative\");\n    }\n    if (length > str.length - startIndex) {\n        throw new Error(\"Invalid startIndex and length\");\n    }\n    str = str.substr(startIndex, length);\n    for (const c of anyOf) {\n        const index = str.indexOf(c);\n        if (index > -1) {\n            return index + startIndex;\n        }\n    }\n    return -1;\n}\nexport function printf(input) {\n    return {\n        input,\n        cont: fsFormat(input),\n    };\n}\nexport function interpolate(str, values) {\n    let valIdx = 0;\n    let strIdx = 0;\n    let result = \"\";\n    interpolateRegExp.lastIndex = 0;\n    let match = interpolateRegExp.exec(str);\n    while (match) {\n        // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char\n        // Note: we don't use negative lookbehind because some browsers don't support it yet\n        const matchIndex = match.index + (match[1] || \"\").length;\n        result += str.substring(strIdx, matchIndex).replace(/%%/g, \"%\");\n        const [, , flags, padLength, precision, format] = match;\n        result += formatReplacement(values[valIdx++], flags, padLength, precision, format);\n        strIdx = interpolateRegExp.lastIndex;\n        // Likewise we need to move interpolateRegExp.lastIndex one char behind to make sure we match the no-escape char next time\n        interpolateRegExp.lastIndex -= 1;\n        match = interpolateRegExp.exec(str);\n    }\n    result += str.substring(strIdx).replace(/%%/g, \"%\");\n    return result;\n}\nfunction continuePrint(cont, arg) {\n    return typeof arg === \"string\" ? cont(arg) : arg.cont(cont);\n}\nexport function toConsole(arg) {\n    // Don't remove the lambda here, see #1357\n    return continuePrint((x) => console.log(x), arg);\n}\nexport function toConsoleError(arg) {\n    return continuePrint((x) => console.error(x), arg);\n}\nexport function toText(arg) {\n    return continuePrint((x) => x, arg);\n}\nexport function toFail(arg) {\n    return continuePrint((x) => {\n        throw new Error(x);\n    }, arg);\n}\nfunction formatReplacement(rep, flags, padLength, precision, format) {\n    let sign = \"\";\n    flags = flags || \"\";\n    format = format || \"\";\n    if (isNumeric(rep)) {\n        if (format.toLowerCase() !== \"x\") {\n            if (isLessThan(rep, 0)) {\n                rep = multiply(rep, -1);\n                sign = \"-\";\n            }\n            else {\n                if (flags.indexOf(\" \") >= 0) {\n                    sign = \" \";\n                }\n                else if (flags.indexOf(\"+\") >= 0) {\n                    sign = \"+\";\n                }\n            }\n        }\n        precision = precision == null ? null : parseInt(precision, 10);\n        switch (format) {\n            case \"f\":\n            case \"F\":\n                precision = precision != null ? precision : 6;\n                rep = toFixed(rep, precision);\n                break;\n            case \"g\":\n            case \"G\":\n                rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                break;\n            case \"e\":\n            case \"E\":\n                rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                break;\n            case \"x\":\n                rep = toHex(rep);\n                break;\n            case \"X\":\n                rep = toHex(rep).toUpperCase();\n                break;\n            default: // AOid\n                rep = String(rep);\n                break;\n        }\n    }\n    else if (rep instanceof Date) {\n        rep = dateToString(rep);\n    }\n    else {\n        rep = toString(rep);\n    }\n    padLength = typeof padLength === \"number\" ? padLength : parseInt(padLength, 10);\n    if (!isNaN(padLength)) {\n        const zeroFlag = flags.indexOf(\"0\") >= 0; // Use '0' for left padding\n        const minusFlag = flags.indexOf(\"-\") >= 0; // Right padding\n        const ch = minusFlag || !zeroFlag ? \" \" : \"0\";\n        if (ch === \"0\") {\n            rep = padLeft(rep, padLength - sign.length, ch, minusFlag);\n            rep = sign + rep;\n        }\n        else {\n            rep = padLeft(sign + rep, padLength, ch, minusFlag);\n        }\n    }\n    else {\n        rep = sign + rep;\n    }\n    return rep;\n}\nfunction createPrinter(cont, _strParts, _matches, _result = \"\", padArg = -1) {\n    return (...args) => {\n        // Make copies of the values passed by reference because the function can be used multiple times\n        let result = _result;\n        const strParts = _strParts.slice();\n        const matches = _matches.slice();\n        for (const arg of args) {\n            const [, , flags, _padLength, precision, format] = matches[0];\n            let padLength = _padLength;\n            if (padArg >= 0) {\n                padLength = padArg;\n                padArg = -1;\n            }\n            else if (padLength === \"*\") {\n                if (arg < 0) {\n                    throw new Error(\"Non-negative number required\");\n                }\n                padArg = arg;\n                continue;\n            }\n            result += strParts[0];\n            result += formatReplacement(arg, flags, padLength, precision, format);\n            strParts.splice(0, 1);\n            matches.splice(0, 1);\n        }\n        if (matches.length === 0) {\n            result += strParts[0];\n            return cont(result);\n        }\n        else {\n            return createPrinter(cont, strParts, matches, result, padArg);\n        }\n    };\n}\nexport function fsFormat(str) {\n    return (cont) => {\n        fsFormatRegExp.lastIndex = 0;\n        const strParts = [];\n        const matches = [];\n        let strIdx = 0;\n        let match = fsFormatRegExp.exec(str);\n        while (match) {\n            // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char\n            // Note: we don't use negative lookbehind because some browsers don't support it yet\n            const matchIndex = match.index + (match[1] || \"\").length;\n            strParts.push(str.substring(strIdx, matchIndex).replace(/%%/g, \"%\"));\n            matches.push(match);\n            strIdx = fsFormatRegExp.lastIndex;\n            // Likewise we need to move fsFormatRegExp.lastIndex one char behind to make sure we match the no-escape char next time\n            fsFormatRegExp.lastIndex -= 1;\n            match = fsFormatRegExp.exec(str);\n        }\n        if (strParts.length === 0) {\n            return cont(str.replace(/%%/g, \"%\"));\n        }\n        else {\n            strParts.push(str.substring(strIdx).replace(/%%/g, \"%\"));\n            return createPrinter(cont, strParts, matches);\n        }\n    };\n}\nexport function format(str, ...args) {\n    if (typeof str === \"object\" && args.length > 0) {\n        // Called with culture info\n        str = args[0];\n        args.shift();\n    }\n    return str.replace(formatRegExp, (_, idx, padLength, format, precision, pattern) => {\n        let rep = args[idx];\n        if (isNumeric(rep)) {\n            precision = precision == null ? null : parseInt(precision, 10);\n            switch (format) {\n                case \"f\":\n                case \"F\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(rep, precision);\n                    break;\n                case \"g\":\n                case \"G\":\n                    rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                    break;\n                case \"e\":\n                case \"E\":\n                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                    break;\n                case \"p\":\n                case \"P\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(multiply(rep, 100), precision) + \" %\";\n                    break;\n                case \"d\":\n                case \"D\":\n                    rep = precision != null ? padLeft(String(rep), precision, \"0\") : String(rep);\n                    break;\n                case \"x\":\n                case \"X\":\n                    rep = precision != null ? padLeft(toHex(rep), precision, \"0\") : toHex(rep);\n                    if (format === \"X\") {\n                        rep = rep.toUpperCase();\n                    }\n                    break;\n                default:\n                    if (pattern) {\n                        let sign = \"\";\n                        rep = pattern.replace(/([0#,]+)(\\.[0#]+)?/, (_, intPart, decimalPart) => {\n                            if (isLessThan(rep, 0)) {\n                                rep = multiply(rep, -1);\n                                sign = \"-\";\n                            }\n                            const decimalPartLength = decimalPart != null ? decimalPart.length : 0;\n                            rep = toFixed(rep, Math.max(decimalPartLength - 1, 0));\n                            // Thousands separator\n                            if (intPart.indexOf(\",\") > 0) {\n                                const [intPart, decimalPart] = rep.split(\".\");\n                                const i = intPart.length % 3;\n                                const thousandGroups = Math.floor(intPart.length / 3);\n                                let thousands = i > 0 ? intPart.substr(0, i) + (thousandGroups > 0 ? \",\" : \"\") : \"\";\n                                for (let j = 0; j < thousandGroups; j++) {\n                                    thousands += intPart.substr(i + j * 3, 3) + (j < thousandGroups - 1 ? \",\" : \"\");\n                                }\n                                rep = decimalPart ? thousands + \".\" + decimalPart : thousands;\n                            }\n                            // In .NET you can mix 0/# placeholders but for simplicity we only check the left most character\n                            intPart = intPart.replace(/,/g, \"\");\n                            const intPartLength = intPart.length > 0 && intPart[0] === \"0\" ? intPart.length : 0;\n                            return padLeft(rep, intPartLength - sign.length + decimalPartLength, \"0\");\n                        });\n                        rep = sign + rep;\n                    }\n            }\n        }\n        else if (rep instanceof Date) {\n            rep = dateToString(rep, pattern || format);\n        }\n        else {\n            rep = toString(rep);\n        }\n        padLength = parseInt((padLength || \" \").substring(1), 10);\n        if (!isNaN(padLength)) {\n            rep = padLeft(String(rep), Math.abs(padLength), \" \", padLength < 0);\n        }\n        return rep;\n    });\n}\nexport function endsWith(str, search) {\n    const idx = str.lastIndexOf(search);\n    return idx >= 0 && idx === str.length - search.length;\n}\nexport function initialize(n, f) {\n    if (n < 0) {\n        throw new Error(\"String length must be non-negative\");\n    }\n    const xs = new Array(n);\n    for (let i = 0; i < n; i++) {\n        xs[i] = f(i);\n    }\n    return xs.join(\"\");\n}\nexport function insert(str, startIndex, value) {\n    if (startIndex < 0 || startIndex > str.length) {\n        throw new Error(\"startIndex is negative or greater than the length of this instance.\");\n    }\n    return str.substring(0, startIndex) + value + str.substring(startIndex);\n}\nexport function isNullOrEmpty(str) {\n    return typeof str !== \"string\" || str.length === 0;\n}\nexport function isNullOrWhiteSpace(str) {\n    return typeof str !== \"string\" || /^\\s*$/.test(str);\n}\nexport function concat(...xs) {\n    return xs.map((x) => String(x)).join(\"\");\n}\nexport function join(delimiter, xs) {\n    if (Array.isArray(xs)) {\n        return xs.join(delimiter);\n    }\n    else {\n        return Array.from(xs).join(delimiter);\n    }\n}\nexport function joinWithIndices(delimiter, xs, startIndex, count) {\n    const endIndexPlusOne = startIndex + count;\n    if (endIndexPlusOne > xs.length) {\n        throw new Error(\"Index and count must refer to a location within the buffer.\");\n    }\n    return xs.slice(startIndex, endIndexPlusOne).join(delimiter);\n}\nfunction notSupported(name) {\n    throw new Error(\"The environment doesn't support '\" + name + \"', please use a polyfill.\");\n}\nexport function toBase64String(inArray) {\n    let str = \"\";\n    for (let i = 0; i < inArray.length; i++) {\n        str += String.fromCharCode(inArray[i]);\n    }\n    return typeof btoa === \"function\" ? btoa(str) : notSupported(\"btoa\");\n}\nexport function fromBase64String(b64Encoded) {\n    const binary = typeof atob === \"function\" ? atob(b64Encoded) : notSupported(\"atob\");\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n        bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n}\nexport function padLeft(str, len, ch, isRight) {\n    ch = ch || \" \";\n    len = len - str.length;\n    for (let i = 0; i < len; i++) {\n        str = isRight ? str + ch : ch + str;\n    }\n    return str;\n}\nexport function padRight(str, len, ch) {\n    return padLeft(str, len, ch, true);\n}\nexport function remove(str, startIndex, count) {\n    if (startIndex >= str.length) {\n        throw new Error(\"startIndex must be less than length of string\");\n    }\n    if (typeof count === \"number\" && (startIndex + count) > str.length) {\n        throw new Error(\"Index and count must refer to a location within the string.\");\n    }\n    return str.slice(0, startIndex) + (typeof count === \"number\" ? str.substr(startIndex + count) : \"\");\n}\nexport function replace(str, search, replace) {\n    return str.replace(new RegExp(escape(search), \"g\"), replace);\n}\nexport function replicate(n, x) {\n    return initialize(n, () => x);\n}\nexport function getCharAtIndex(input, index) {\n    if (index < 0 || index >= input.length) {\n        throw new Error(\"Index was outside the bounds of the array.\");\n    }\n    return input[index];\n}\nexport function split(str, splitters, count, options) {\n    count = typeof count === \"number\" ? count : undefined;\n    options = typeof options === \"number\" ? options : 0;\n    if (count && count < 0) {\n        throw new Error(\"Count cannot be less than zero\");\n    }\n    if (count === 0) {\n        return [];\n    }\n    const removeEmpty = (options & 1) === 1;\n    const trim = (options & 2) === 2;\n    splitters = splitters || [];\n    splitters = splitters.filter(x => x).map(escape);\n    splitters = splitters.length > 0 ? splitters : [\"\\\\s\"];\n    const splits = [];\n    const reg = new RegExp(splitters.join(\"|\"), \"g\");\n    let findSplits = true;\n    let i = 0;\n    do {\n        const match = reg.exec(str);\n        if (match === null) {\n            const candidate = trim ? str.substring(i).trim() : str.substring(i);\n            if (!removeEmpty || candidate.length > 0) {\n                splits.push(candidate);\n            }\n            findSplits = false;\n        }\n        else {\n            const candidate = trim ? str.substring(i, match.index).trim() : str.substring(i, match.index);\n            if (!removeEmpty || candidate.length > 0) {\n                if (count != null && splits.length + 1 === count) {\n                    splits.push(trim ? str.substring(i).trim() : str.substring(i));\n                    findSplits = false;\n                }\n                else {\n                    splits.push(candidate);\n                }\n            }\n            i = reg.lastIndex;\n        }\n    } while (findSplits);\n    return splits;\n}\nexport function trim(str, ...chars) {\n    if (chars.length === 0) {\n        return str.trim();\n    }\n    const pattern = \"[\" + escape(chars.join(\"\")) + \"]+\";\n    return str.replace(new RegExp(\"^\" + pattern), \"\").replace(new RegExp(pattern + \"$\"), \"\");\n}\nexport function trimStart(str, ...chars) {\n    return chars.length === 0\n        ? str.trimStart()\n        : str.replace(new RegExp(\"^[\" + escape(chars.join(\"\")) + \"]+\"), \"\");\n}\nexport function trimEnd(str, ...chars) {\n    return chars.length === 0\n        ? str.trimEnd()\n        : str.replace(new RegExp(\"[\" + escape(chars.join(\"\")) + \"]+$\"), \"\");\n}\nexport function filter(pred, x) {\n    return x.split(\"\").filter((c) => pred(c)).join(\"\");\n}\nexport function substring(str, startIndex, length) {\n    if ((startIndex + (length || 0) > str.length)) {\n        throw new Error(\"Invalid startIndex and/or length\");\n    }\n    return length != null ? str.substr(startIndex, length) : str.substr(startIndex);\n}\nexport function fmt(strs, ...args) {\n    return ({ strs, args });\n}\nexport function fmtWith(fmts) {\n    return (strs, ...args) => ({ strs, args, fmts });\n}\nexport function getFormat(s) {\n    return s.fmts\n        ? s.strs.reduce((acc, newPart, index) => acc + `{${String(index - 1) + s.fmts[index - 1]}}` + newPart)\n        : s.strs.reduce((acc, newPart, index) => acc + `{${index - 1}}` + newPart);\n}\n","import { compare, equals, structuralHash } from \"./Util.js\";\n// Using a class here for better compatibility with TS files importing Some\nexport class Some {\n    constructor(value) {\n        this.value = value;\n    }\n    toJSON() {\n        return this.value;\n    }\n    // Don't add \"Some\" for consistency with erased options\n    toString() {\n        return String(this.value);\n    }\n    GetHashCode() {\n        return structuralHash(this.value);\n    }\n    Equals(other) {\n        if (other == null) {\n            return false;\n        }\n        else {\n            return equals(this.value, other instanceof Some ? other.value : other);\n        }\n    }\n    CompareTo(other) {\n        if (other == null) {\n            return 1;\n        }\n        else {\n            return compare(this.value, other instanceof Some ? other.value : other);\n        }\n    }\n}\nexport function some(x) {\n    return x == null || x instanceof Some ? new Some(x) : x;\n}\nexport function value(x) {\n    if (x == null) {\n        throw new Error(\"Option has no value\");\n    }\n    else {\n        return x instanceof Some ? x.value : x;\n    }\n}\nexport function ofNullable(x) {\n    // This will fail with unit probably, an alternative would be:\n    // return x === null ? undefined : (x === undefined ? new Some(x) : x);\n    return x == null ? undefined : x;\n}\nexport function toNullable(x) {\n    return x == null ? null : value(x);\n}\nexport function flatten(x) {\n    return x == null ? undefined : value(x);\n}\nexport function toArray(opt) {\n    return (opt == null) ? [] : [value(opt)];\n}\nexport function defaultArg(opt, defaultValue) {\n    return (opt != null) ? value(opt) : defaultValue;\n}\nexport function defaultArgWith(opt, defThunk) {\n    return (opt != null) ? value(opt) : defThunk();\n}\nexport function filter(predicate, opt) {\n    return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;\n}\nexport function map(mapping, opt) {\n    return (opt != null) ? some(mapping(value(opt))) : undefined;\n}\nexport function map2(mapping, opt1, opt2) {\n    return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;\n}\nexport function map3(mapping, opt1, opt2, opt3) {\n    return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;\n}\nexport function bind(binder, opt) {\n    return opt != null ? binder(value(opt)) : undefined;\n}\nexport function tryOp(op, arg) {\n    try {\n        return some(op(arg));\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\n","import { value as value_2, defaultArg, some } from \"./Option.js\";\r\nimport { min as min_1, getEnumerator, comparePrimitives, max as max_1 } from \"./Util.js\";\r\nimport { SR_indexOutOfBounds } from \"./Global.js\";\r\n\r\nexport function Helpers_allocateArrayFromCons(cons, len) {\r\n    if ((typeof cons) === \"function\") {\r\n        return new cons(len);\r\n    }\r\n    else {\r\n        return new Array(len);\r\n    }\r\n}\r\n\r\nfunction indexNotFound() {\r\n    throw (new Error(\"An index satisfying the predicate was not found in the collection.\"));\r\n}\r\n\r\nfunction differentLengths() {\r\n    throw (new Error(\"Arrays had different lengths\"));\r\n}\r\n\r\nexport function append(array1, array2, cons) {\r\n    const len1 = array1.length | 0;\r\n    const len2 = array2.length | 0;\r\n    const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);\r\n    for (let i = 0; i <= (len1 - 1); i++) {\r\n        newArray[i] = array1[i];\r\n    }\r\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\r\n        newArray[i_1 + len1] = array2[i_1];\r\n    }\r\n    return newArray;\r\n}\r\n\r\nexport function filter(predicate, array) {\r\n    return array.filter(predicate);\r\n}\r\n\r\nexport function fill(target, targetIndex, count, value) {\r\n    const start = targetIndex | 0;\r\n    return target.fill(value, start, (start + count));\r\n}\r\n\r\nexport function getSubArray(array, start, count) {\r\n    const start_1 = start | 0;\r\n    return array.slice(start_1, (start_1 + count));\r\n}\r\n\r\nexport function last(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    return array[array.length - 1];\r\n}\r\n\r\nexport function tryLast(array) {\r\n    if (array.length === 0) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[array.length - 1]);\r\n    }\r\n}\r\n\r\nexport function mapIndexed(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const target = Helpers_allocateArrayFromCons(cons, len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = f(i, source[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function map(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const target = Helpers_allocateArrayFromCons(cons, len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = f(source[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function mapIndexed2(f, source1, source2, cons) {\r\n    if (source1.length !== source2.length) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(i, source1[i], source2[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function map2(f, source1, source2, cons) {\r\n    if (source1.length !== source2.length) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(source1[i], source2[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function mapIndexed3(f, source1, source2, source3, cons) {\r\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(i, source1[i], source2[i], source3[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function map3(f, source1, source2, source3, cons) {\r\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(source1[i], source2[i], source3[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function mapFold(mapping, state, array, cons) {\r\n    const matchValue = array.length | 0;\r\n    if (matchValue === 0) {\r\n        return [[], state];\r\n    }\r\n    else {\r\n        let acc = state;\r\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\r\n        for (let i = 0; i <= (array.length - 1); i++) {\r\n            const patternInput = mapping(acc, array[i]);\r\n            res[i] = patternInput[0];\r\n            acc = patternInput[1];\r\n        }\r\n        return [res, acc];\r\n    }\r\n}\r\n\r\nexport function mapFoldBack(mapping, array, state, cons) {\r\n    const matchValue = array.length | 0;\r\n    if (matchValue === 0) {\r\n        return [[], state];\r\n    }\r\n    else {\r\n        let acc = state;\r\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\r\n        for (let i = array.length - 1; i >= 0; i--) {\r\n            const patternInput = mapping(array[i], acc);\r\n            res[i] = patternInput[0];\r\n            acc = patternInput[1];\r\n        }\r\n        return [res, acc];\r\n    }\r\n}\r\n\r\nexport function indexed(source) {\r\n    const len = source.length | 0;\r\n    const target = new Array(len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = [i, source[i]];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function truncate(count, array) {\r\n    const count_1 = max_1((x, y) => comparePrimitives(x, y), 0, count) | 0;\r\n    const start = 0;\r\n    return array.slice(start, (start + count_1));\r\n}\r\n\r\nexport function concat(arrays, cons) {\r\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\r\n    const matchValue = arrays_1.length | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return Helpers_allocateArrayFromCons(cons, 0);\r\n        }\r\n        case 1: {\r\n            return arrays_1[0];\r\n        }\r\n        default: {\r\n            let totalIdx = 0;\r\n            let totalLength = 0;\r\n            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {\r\n                const arr_1 = arrays_1[idx];\r\n                totalLength = ((totalLength + arr_1.length) | 0);\r\n            }\r\n            const result = Helpers_allocateArrayFromCons(cons, totalLength);\r\n            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {\r\n                const arr_2 = arrays_1[idx_1];\r\n                for (let j = 0; j <= (arr_2.length - 1); j++) {\r\n                    result[totalIdx] = arr_2[j];\r\n                    totalIdx = ((totalIdx + 1) | 0);\r\n                }\r\n            }\r\n            return result;\r\n        }\r\n    }\r\n}\r\n\r\nexport function collect(mapping, array, cons) {\r\n    return concat(map(mapping, array, null), cons);\r\n}\r\n\r\nexport function where(predicate, array) {\r\n    return array.filter(predicate);\r\n}\r\n\r\nexport function contains(value, array, eq) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return false;\r\n            }\r\n            else if (eq.Equals(value, array[i])) {\r\n                return true;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function empty(cons) {\r\n    return Helpers_allocateArrayFromCons(cons, 0);\r\n}\r\n\r\nexport function singleton(value, cons) {\r\n    const ar = Helpers_allocateArrayFromCons(cons, 1);\r\n    ar[0] = value;\r\n    return ar;\r\n}\r\n\r\nexport function initialize(count, initializer, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, count);\r\n    for (let i = 0; i <= (count - 1); i++) {\r\n        result[i] = initializer(i);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function pairwise(array) {\r\n    if (array.length < 2) {\r\n        return [];\r\n    }\r\n    else {\r\n        const count = (array.length - 1) | 0;\r\n        const result = new Array(count);\r\n        for (let i = 0; i <= (count - 1); i++) {\r\n            result[i] = [array[i], array[i + 1]];\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function replicate(count, initial, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, count);\r\n    for (let i = 0; i <= (result.length - 1); i++) {\r\n        result[i] = initial;\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function copy(array) {\r\n    return array.slice();\r\n}\r\n\r\nexport function reverse(array) {\r\n    const array_2 = array.slice();\r\n    return array_2.reverse();\r\n}\r\n\r\nexport function scan(folder, state, array, cons) {\r\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\r\n    res[0] = state;\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        res[i + 1] = folder(res[i], array[i]);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function scanBack(folder, array, state, cons) {\r\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\r\n    res[array.length] = state;\r\n    for (let i = array.length - 1; i >= 0; i--) {\r\n        res[i] = folder(array[i], res[i + 1]);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function skip(count, array, cons) {\r\n    if (count > array.length) {\r\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\r\n    }\r\n    if (count === array.length) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const count_1 = ((count < 0) ? 0 : count) | 0;\r\n        return array.slice(count_1);\r\n    }\r\n}\r\n\r\nexport function skipWhile(predicate, array, cons) {\r\n    let count = 0;\r\n    while ((count < array.length) && predicate(array[count])) {\r\n        count = ((count + 1) | 0);\r\n    }\r\n    if (count === array.length) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const count_1 = count | 0;\r\n        return array.slice(count_1);\r\n    }\r\n}\r\n\r\nexport function take(count, array, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    if (count > array.length) {\r\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\r\n    }\r\n    if (count === 0) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const start = 0;\r\n        return array.slice(start, (start + count));\r\n    }\r\n}\r\n\r\nexport function takeWhile(predicate, array, cons) {\r\n    let count = 0;\r\n    while ((count < array.length) && predicate(array[count])) {\r\n        count = ((count + 1) | 0);\r\n    }\r\n    if (count === 0) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const start = 0;\r\n        const count_1 = count | 0;\r\n        return array.slice(start, (start + count_1));\r\n    }\r\n}\r\n\r\nexport function addInPlace(x, array) {\r\n    array.push(x);\r\n}\r\n\r\nexport function addRangeInPlace(range, array) {\r\n    const enumerator = getEnumerator(range);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            addInPlace(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), array);\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n}\r\n\r\nexport function insertRangeInPlace(index, range, array) {\r\n    let index_1;\r\n    let i = index;\r\n    const enumerator = getEnumerator(range);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            (index_1 = (i | 0), array.splice(index_1, 0, x));\r\n            i = ((i + 1) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n}\r\n\r\nexport function removeInPlace(item_1, array) {\r\n    const i = array.indexOf(item_1, 0);\r\n    if (i > -1) {\r\n        array.splice(i, 1);\r\n        return true;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function removeAllInPlace(predicate, array) {\r\n    const countRemoveAll = (count) => {\r\n        const i = array.findIndex(predicate);\r\n        if (i > -1) {\r\n            array.splice(i, 1);\r\n            return (countRemoveAll(count) + 1) | 0;\r\n        }\r\n        else {\r\n            return count | 0;\r\n        }\r\n    };\r\n    return countRemoveAll(0) | 0;\r\n}\r\n\r\nexport function copyTo(source, sourceIndex, target, targetIndex, count) {\r\n    const diff = (targetIndex - sourceIndex) | 0;\r\n    for (let i = sourceIndex; i <= ((sourceIndex + count) - 1); i++) {\r\n        target[i + diff] = source[i];\r\n    }\r\n}\r\n\r\nexport function copyToTypedArray(source, sourceIndex, target, targetIndex, count) {\r\n    try {\r\n        target.set(source.subarray(sourceIndex, sourceIndex + count), targetIndex);\r\n    }\r\n    catch (matchValue) {\r\n        copyTo(source, sourceIndex, target, targetIndex, count);\r\n    }\r\n}\r\n\r\nexport function indexOf(array, item_1, start, count) {\r\n    const start_1 = defaultArg(start, 0) | 0;\r\n    const i = array.indexOf(item_1, start_1);\r\n    if ((count != null) && (i >= (start_1 + value_2(count)))) {\r\n        return -1;\r\n    }\r\n    else {\r\n        return i | 0;\r\n    }\r\n}\r\n\r\nexport function partition(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const res1 = Helpers_allocateArrayFromCons(cons, len);\r\n    const res2 = Helpers_allocateArrayFromCons(cons, len);\r\n    let iTrue = 0;\r\n    let iFalse = 0;\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        if (f(source[i])) {\r\n            res1[iTrue] = source[i];\r\n            iTrue = ((iTrue + 1) | 0);\r\n        }\r\n        else {\r\n            res2[iFalse] = source[i];\r\n            iFalse = ((iFalse + 1) | 0);\r\n        }\r\n    }\r\n    return [truncate(iTrue, res1), truncate(iFalse, res2)];\r\n}\r\n\r\nexport function find(predicate, array) {\r\n    const matchValue = array.find(predicate);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_2(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFind(predicate, array) {\r\n    return array.find(predicate);\r\n}\r\n\r\nexport function findIndex(predicate, array) {\r\n    const matchValue = array.findIndex(predicate);\r\n    if (matchValue > -1) {\r\n        return matchValue | 0;\r\n    }\r\n    else {\r\n        return indexNotFound() | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(predicate, array) {\r\n    const matchValue = array.findIndex(predicate);\r\n    if (matchValue > -1) {\r\n        return matchValue;\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function pick(chooser, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return indexNotFound();\r\n            }\r\n            else {\r\n                const matchValue = chooser(array[i]);\r\n                if (matchValue != null) {\r\n                    return value_2(matchValue);\r\n                }\r\n                else {\r\n                    i_mut = (i + 1);\r\n                    continue loop;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function tryPick(chooser, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return void 0;\r\n            }\r\n            else {\r\n                const matchValue = chooser(array[i]);\r\n                if (matchValue == null) {\r\n                    i_mut = (i + 1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function findBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return indexNotFound();\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return array[i];\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function tryFindBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return void 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return some(array[i]);\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function findLastIndex(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return -1;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i | 0;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1) | 0;\r\n}\r\n\r\nexport function findIndexBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return indexNotFound() | 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i | 0;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1) | 0;\r\n}\r\n\r\nexport function tryFindIndexBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return void 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function choose(chooser, array, cons) {\r\n    const res = [];\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        const matchValue = chooser(array[i]);\r\n        if (matchValue != null) {\r\n            const y = value_2(matchValue);\r\n            res.push(y);\r\n        }\r\n    }\r\n    if ((typeof cons) === \"function\") {\r\n        return map((x) => x, res, cons);\r\n    }\r\n    else {\r\n        return res;\r\n    }\r\n}\r\n\r\nexport function foldIndexed(folder, state, array) {\r\n    return array.reduce(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg0, delegateArg1)), state);\r\n}\r\n\r\nexport function fold(folder, state, array) {\r\n    return array.reduce(((delegateArg0, delegateArg1) => folder(delegateArg0, delegateArg1)), state);\r\n}\r\n\r\nexport function iterate(action, array) {\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        action(array[i]);\r\n    }\r\n}\r\n\r\nexport function iterateIndexed(action, array) {\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        action(i, array[i]);\r\n    }\r\n}\r\n\r\nexport function iterate2(action, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        action(array1[i], array2[i]);\r\n    }\r\n}\r\n\r\nexport function iterateIndexed2(action, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        action(i, array1[i], array2[i]);\r\n    }\r\n}\r\n\r\nexport function isEmpty(array) {\r\n    return array.length === 0;\r\n}\r\n\r\nexport function forAll(predicate, array) {\r\n    return array.every(predicate);\r\n}\r\n\r\nexport function permute(f, array) {\r\n    const size = array.length | 0;\r\n    const res = array.slice();\r\n    const checkFlags = new Array(size);\r\n    iterateIndexed((i, x) => {\r\n        const j = f(i) | 0;\r\n        if ((j < 0) ? true : (j >= size)) {\r\n            throw (new Error(\"Not a valid permutation\"));\r\n        }\r\n        res[j] = x;\r\n        checkFlags[j] = 1;\r\n    }, array);\r\n    if (!(checkFlags.every((y) => (1 === y)))) {\r\n        throw (new Error(\"Not a valid permutation\"));\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function setSlice(target, lower, upper, source) {\r\n    const lower_1 = defaultArg(lower, 0) | 0;\r\n    const upper_1 = defaultArg(upper, 0) | 0;\r\n    const length = (((upper_1 > 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;\r\n    for (let i = 0; i <= length; i++) {\r\n        target[i + lower_1] = source[i];\r\n    }\r\n}\r\n\r\nexport function sortInPlaceBy(projection, xs, comparer) {\r\n    xs.sort((x, y) => comparer.Compare(projection(x), projection(y)));\r\n}\r\n\r\nexport function sortInPlace(xs, comparer) {\r\n    xs.sort((x, y) => comparer.Compare(x, y));\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => comparer.Compare(x, y));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => comparer.Compare(projection(x), projection(y)));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => (comparer.Compare(x, y) * -1));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => (comparer.Compare(projection(x), projection(y)) * -1));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    const comparer_1 = comparer;\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort(comparer_1);\r\n    return xs_1;\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const len1 = xs.length | 0;\r\n    const len2 = ys.length | 0;\r\n    const res = new Array(len1 * len2);\r\n    for (let i = 0; i <= (xs.length - 1); i++) {\r\n        for (let j = 0; j <= (ys.length - 1); j++) {\r\n            res[(i * len2) + j] = [xs[i], ys[j]];\r\n        }\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function unfold(generator, state) {\r\n    const res = [];\r\n    const loop = (state_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const state_1 = state_1_mut;\r\n            const matchValue = generator(state_1);\r\n            if (matchValue != null) {\r\n                const x = matchValue[0];\r\n                const s = matchValue[1];\r\n                res.push(x);\r\n                state_1_mut = s;\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    loop(state);\r\n    return res;\r\n}\r\n\r\nexport function unzip(array) {\r\n    const len = array.length | 0;\r\n    const res1 = new Array(len);\r\n    const res2 = new Array(len);\r\n    iterateIndexed((i, tupledArg) => {\r\n        res1[i] = tupledArg[0];\r\n        res2[i] = tupledArg[1];\r\n    }, array);\r\n    return [res1, res2];\r\n}\r\n\r\nexport function unzip3(array) {\r\n    const len = array.length | 0;\r\n    const res1 = new Array(len);\r\n    const res2 = new Array(len);\r\n    const res3 = new Array(len);\r\n    iterateIndexed((i, tupledArg) => {\r\n        res1[i] = tupledArg[0];\r\n        res2[i] = tupledArg[1];\r\n        res3[i] = tupledArg[2];\r\n    }, array);\r\n    return [res1, res2, res3];\r\n}\r\n\r\nexport function zip(array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    const result = new Array(array1.length);\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        result[i] = [array1[i], array2[i]];\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function zip3(array1, array2, array3) {\r\n    if ((array1.length !== array2.length) ? true : (array2.length !== array3.length)) {\r\n        differentLengths();\r\n    }\r\n    const result = new Array(array1.length);\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        result[i] = [array1[i], array2[i], array3[i]];\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function chunkBySize(chunkSize, array) {\r\n    if (chunkSize < 1) {\r\n        throw (new Error(\"The input must be positive.\\\\nParameter name: size\"));\r\n    }\r\n    if (array.length === 0) {\r\n        return [[]];\r\n    }\r\n    else {\r\n        const result = [];\r\n        for (let x = 0; x <= ((~(~Math.ceil(array.length / chunkSize))) - 1); x++) {\r\n            let slice;\r\n            const start_1 = (x * chunkSize) | 0;\r\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\r\n            result.push(slice);\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function splitAt(index, array) {\r\n    let start;\r\n    if ((index < 0) ? true : (index > array.length)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return [(start = 0, array.slice(start, (start + index))), array.slice(index)];\r\n}\r\n\r\nexport function compareWith(comparer, array1, array2) {\r\n    if (array1 == null) {\r\n        if (array2 == null) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n    else if (array2 == null) {\r\n        return 1;\r\n    }\r\n    else {\r\n        let i = 0;\r\n        let result = 0;\r\n        const length1 = array1.length | 0;\r\n        const length2 = array2.length | 0;\r\n        if (length1 > length2) {\r\n            return 1;\r\n        }\r\n        else if (length1 < length2) {\r\n            return -1;\r\n        }\r\n        else {\r\n            while ((i < length1) && (result === 0)) {\r\n                result = (comparer(array1[i], array2[i]) | 0);\r\n                i = ((i + 1) | 0);\r\n            }\r\n            return result | 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function equalsWith(equals, array1, array2) {\r\n    if (array1 == null) {\r\n        if (array2 == null) {\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else if (array2 == null) {\r\n        return false;\r\n    }\r\n    else {\r\n        let i = 0;\r\n        let result = true;\r\n        const length1 = array1.length | 0;\r\n        const length2 = array2.length | 0;\r\n        if (length1 > length2) {\r\n            return false;\r\n        }\r\n        else if (length1 < length2) {\r\n            return false;\r\n        }\r\n        else {\r\n            while ((i < length1) && result) {\r\n                result = equals(array1[i], array2[i]);\r\n                i = ((i + 1) | 0);\r\n            }\r\n            return result;\r\n        }\r\n    }\r\n}\r\n\r\nexport function exactlyOne(array) {\r\n    if (array.length === 1) {\r\n        return array[0];\r\n    }\r\n    else if (array.length === 0) {\r\n        throw (new Error(\"The input sequence was empty\\\\nParameter name: array\"));\r\n    }\r\n    else {\r\n        throw (new Error(\"Input array too long\\\\nParameter name: array\"));\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(array) {\r\n    if (array.length === 1) {\r\n        return some(array[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function head(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    else {\r\n        return array[0];\r\n    }\r\n}\r\n\r\nexport function tryHead(array) {\r\n    if (array.length === 0) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[0]);\r\n    }\r\n}\r\n\r\nexport function tail(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"Not enough elements\\\\nParameter name: array\"));\r\n    }\r\n    return array.slice(1);\r\n}\r\n\r\nexport function item(index, array) {\r\n    return array[index];\r\n}\r\n\r\nexport function tryItem(index, array) {\r\n    if ((index < 0) ? true : (index >= array.length)) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[index]);\r\n    }\r\n}\r\n\r\nexport function foldBackIndexed(folder, array, state) {\r\n    return array.reduceRight(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg1, delegateArg0)), state);\r\n}\r\n\r\nexport function foldBack(folder, array, state) {\r\n    return array.reduceRight(((delegateArg0, delegateArg1) => folder(delegateArg1, delegateArg0)), state);\r\n}\r\n\r\nexport function foldIndexed2(folder, state, array1, array2) {\r\n    let acc = state;\r\n    if (array1.length !== array2.length) {\r\n        throw (new Error(\"Arrays have different lengths\"));\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        acc = folder(i, acc, array1[i], array2[i]);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function fold2(folder, state, array1, array2) {\r\n    return foldIndexed2((_arg1, acc, x, y) => folder(acc, x, y), state, array1, array2);\r\n}\r\n\r\nexport function foldBackIndexed2(folder, array1, array2, state) {\r\n    let acc = state;\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    const size = array1.length | 0;\r\n    for (let i = 1; i <= size; i++) {\r\n        acc = folder(i - 1, array1[size - i], array2[size - i], acc);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function foldBack2(f, array1, array2, state) {\r\n    return foldBackIndexed2((_arg1, x, y, acc) => f(x, y, acc), array1, array2, state);\r\n}\r\n\r\nexport function reduce(reduction, array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\"));\r\n    }\r\n    const reduction_1 = reduction;\r\n    return array.reduce(reduction_1);\r\n}\r\n\r\nexport function reduceBack(reduction, array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\"));\r\n    }\r\n    const reduction_1 = reduction;\r\n    return array.reduceRight(reduction_1);\r\n}\r\n\r\nexport function forAll2(predicate, array1, array2) {\r\n    return fold2((acc, x, y) => (acc && predicate(x, y)), true, array1, array2);\r\n}\r\n\r\nexport function existsOffset(predicate_mut, array_mut, index_mut) {\r\n    existsOffset:\r\n    while (true) {\r\n        const predicate = predicate_mut, array = array_mut, index = index_mut;\r\n        if (index === array.length) {\r\n            return false;\r\n        }\r\n        else if (predicate(array[index])) {\r\n            return true;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            array_mut = array;\r\n            index_mut = (index + 1);\r\n            continue existsOffset;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function exists(predicate, array) {\r\n    return existsOffset(predicate, array, 0);\r\n}\r\n\r\nexport function existsOffset2(predicate_mut, array1_mut, array2_mut, index_mut) {\r\n    existsOffset2:\r\n    while (true) {\r\n        const predicate = predicate_mut, array1 = array1_mut, array2 = array2_mut, index = index_mut;\r\n        if (index === array1.length) {\r\n            return false;\r\n        }\r\n        else if (predicate(array1[index], array2[index])) {\r\n            return true;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            array1_mut = array1;\r\n            array2_mut = array2;\r\n            index_mut = (index + 1);\r\n            continue existsOffset2;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function exists2(predicate, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    return existsOffset2(predicate, array1, array2, 0);\r\n}\r\n\r\nexport function sum(array, adder) {\r\n    let acc = adder.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        acc = adder.Add(acc, array[i]);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function sumBy(projection, array, adder) {\r\n    let acc = adder.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        acc = adder.Add(acc, projection(array[i]));\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(array, averager) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    let total = averager.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        total = averager.Add(total, array[i]);\r\n    }\r\n    return averager.DivideByInt(total, array.length);\r\n}\r\n\r\nexport function averageBy(projection, array, averager) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    let total = averager.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        total = averager.Add(total, projection(array[i]));\r\n    }\r\n    return averager.DivideByInt(total, array.length);\r\n}\r\n\r\nexport function windowed(windowSize, source) {\r\n    if (windowSize <= 0) {\r\n        throw (new Error(\"windowSize must be positive\"));\r\n    }\r\n    let res;\r\n    const len = max_1((x, y) => comparePrimitives(x, y), 0, source.length - windowSize) | 0;\r\n    res = (new Array(len));\r\n    for (let i = windowSize; i <= source.length; i++) {\r\n        res[i - windowSize] = source.slice(i - windowSize, (i - 1) + 1);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function splitInto(chunks, array) {\r\n    if (chunks < 1) {\r\n        throw (new Error(\"The input must be positive.\\\\nParameter name: chunks\"));\r\n    }\r\n    if (array.length === 0) {\r\n        return [[]];\r\n    }\r\n    else {\r\n        const result = [];\r\n        const chunks_1 = min_1((x, y) => comparePrimitives(x, y), chunks, array.length) | 0;\r\n        const minChunkSize = (~(~(array.length / chunks_1))) | 0;\r\n        const chunksWithExtraItem = (array.length % chunks_1) | 0;\r\n        for (let i = 0; i <= (chunks_1 - 1); i++) {\r\n            const chunkSize = ((i < chunksWithExtraItem) ? (minChunkSize + 1) : minChunkSize) | 0;\r\n            let slice;\r\n            const start_1 = ((i * minChunkSize) + min_1((x_1, y_1) => comparePrimitives(x_1, y_1), chunksWithExtraItem, i)) | 0;\r\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\r\n            result.push(slice);\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function transpose(arrays, cons) {\r\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\r\n    const len = arrays_1.length | 0;\r\n    if (len === 0) {\r\n        return new Array(0);\r\n    }\r\n    else {\r\n        const lenInner = arrays_1[0].length | 0;\r\n        if (!forAll((a) => (a.length === lenInner), arrays_1)) {\r\n            differentLengths();\r\n        }\r\n        const result = new Array(lenInner);\r\n        for (let i = 0; i <= (lenInner - 1); i++) {\r\n            result[i] = Helpers_allocateArrayFromCons(cons, len);\r\n            for (let j = 0; j <= (len - 1); j++) {\r\n                result[i][j] = arrays_1[j][i];\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index > len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const target = new xs.constructor(len + 1);\r\n    for (let i = 0; i <= (index - 1); i++) {\r\n        target[i] = xs[i];\r\n    }\r\n    target[index] = y;\r\n    for (let i_1 = index; i_1 <= (len - 1); i_1++) {\r\n        target[i_1 + 1] = xs[i_1];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index > len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const ys_1 = Array.from(ys);\r\n    const len2 = ys_1.length | 0;\r\n    const target = new xs.constructor(len + len2);\r\n    for (let i = 0; i <= (index - 1); i++) {\r\n        target[i] = xs[i];\r\n    }\r\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\r\n        target[index + i_1] = ys_1[i_1];\r\n    }\r\n    for (let i_2 = index; i_2 <= (len - 1); i_2++) {\r\n        target[i_2 + len2] = xs[i_2];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    if ((index < 0) ? true : (index >= xs.length)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    let i = -1;\r\n    return filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        return i !== index;\r\n    }, xs);\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    let i = -1;\r\n    let status = -1;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            status = 0;\r\n            return false;\r\n        }\r\n        else if (i > index) {\r\n            if (i < (index + count)) {\r\n                return false;\r\n            }\r\n            else {\r\n                status = 1;\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;\r\n    if (status_1 < 1) {\r\n        const arg = (status_1 < 0) ? \"index\" : \"count\";\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + arg));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index >= len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const target = new xs.constructor(len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = ((i === index) ? y : xs[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\n","import { join } from \"./String.js\";\r\nimport { uncurry, isArrayLike, getEnumerator, toIterator, compare, structuralHash, equals } from \"./Util.js\";\r\nimport { Record } from \"./Types.js\";\r\nimport { class_type, record_type, option_type } from \"./Reflection.js\";\r\nimport { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from \"./Global.js\";\r\nimport { defaultArg, value as value_1, some } from \"./Option.js\";\r\nimport { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, fill } from \"./Array.js\";\r\nimport { foldBack as foldBack_2 } from \"./Seq.js\";\r\n\r\nexport class FSharpList extends Record {\r\n    constructor(head, tail) {\r\n        super();\r\n        this.head = head;\r\n        this.tail = tail;\r\n    }\r\n    toString() {\r\n        const xs = this;\r\n        return (\"[\" + join(\"; \", xs)) + \"]\";\r\n    }\r\n    Equals(other) {\r\n        const xs = this;\r\n        if (xs === other) {\r\n            return true;\r\n        }\r\n        else {\r\n            const loop = (xs_1_mut, ys_1_mut) => {\r\n                loop:\r\n                while (true) {\r\n                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n                    const matchValue = [xs_1.tail, ys_1.tail];\r\n                    if (matchValue[0] != null) {\r\n                        if (matchValue[1] != null) {\r\n                            const xt = matchValue[0];\r\n                            const yt = matchValue[1];\r\n                            if (equals(xs_1.head, ys_1.head)) {\r\n                                xs_1_mut = xt;\r\n                                ys_1_mut = yt;\r\n                                continue loop;\r\n                            }\r\n                            else {\r\n                                return false;\r\n                            }\r\n                        }\r\n                        else {\r\n                            return false;\r\n                        }\r\n                    }\r\n                    else if (matchValue[1] != null) {\r\n                        return false;\r\n                    }\r\n                    else {\r\n                        return true;\r\n                    }\r\n                    break;\r\n                }\r\n            };\r\n            return loop(xs, other);\r\n        }\r\n    }\r\n    GetHashCode() {\r\n        const xs = this;\r\n        const loop = (i_mut, h_mut, xs_1_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const i = i_mut, h = h_mut, xs_1 = xs_1_mut;\r\n                const matchValue = xs_1.tail;\r\n                if (matchValue != null) {\r\n                    const t = matchValue;\r\n                    if (i > 18) {\r\n                        return h | 0;\r\n                    }\r\n                    else {\r\n                        i_mut = (i + 1);\r\n                        h_mut = (((h << 1) + structuralHash(xs_1.head)) + (631 * i));\r\n                        xs_1_mut = t;\r\n                        continue loop;\r\n                    }\r\n                }\r\n                else {\r\n                    return h | 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(0, 0, xs) | 0;\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    CompareTo(other) {\r\n        const xs = this;\r\n        const loop = (xs_1_mut, ys_1_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n                const matchValue = [xs_1.tail, ys_1.tail];\r\n                if (matchValue[0] != null) {\r\n                    if (matchValue[1] != null) {\r\n                        const xt = matchValue[0];\r\n                        const yt = matchValue[1];\r\n                        const c = compare(xs_1.head, ys_1.head) | 0;\r\n                        if (c === 0) {\r\n                            xs_1_mut = xt;\r\n                            ys_1_mut = yt;\r\n                            continue loop;\r\n                        }\r\n                        else {\r\n                            return c | 0;\r\n                        }\r\n                    }\r\n                    else {\r\n                        return 1;\r\n                    }\r\n                }\r\n                else if (matchValue[1] != null) {\r\n                    return -1;\r\n                }\r\n                else {\r\n                    return 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(xs, other) | 0;\r\n    }\r\n    GetEnumerator() {\r\n        const xs = this;\r\n        return ListEnumerator$1_$ctor_3002E699(xs);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const xs = this;\r\n        return getEnumerator(xs);\r\n    }\r\n}\r\n\r\nexport function FSharpList$reflection(gen0) {\r\n    return record_type(\"ListModule.FSharpList\", [gen0], FSharpList, () => [[\"head\", gen0], [\"tail\", option_type(FSharpList$reflection(gen0))]]);\r\n}\r\n\r\nexport class ListEnumerator$1 {\r\n    constructor(xs) {\r\n        this.xs = xs;\r\n        this.it = this.xs;\r\n        this.current = null;\r\n    }\r\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current;\r\n    }\r\n    [\"System.Collections.IEnumerator.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current;\r\n    }\r\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n        const __ = this;\r\n        const matchValue = __.it.tail;\r\n        if (matchValue != null) {\r\n            const t = matchValue;\r\n            __.current = __.it.head;\r\n            __.it = t;\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.IEnumerator.Reset\"]() {\r\n        const __ = this;\r\n        __.it = __.xs;\r\n        __.current = null;\r\n    }\r\n    Dispose() {\r\n    }\r\n}\r\n\r\nexport function ListEnumerator$1$reflection(gen0) {\r\n    return class_type(\"ListModule.ListEnumerator`1\", [gen0], ListEnumerator$1);\r\n}\r\n\r\nexport function ListEnumerator$1_$ctor_3002E699(xs) {\r\n    return new ListEnumerator$1(xs);\r\n}\r\n\r\nexport function FSharpList_get_Empty() {\r\n    return new FSharpList(null, void 0);\r\n}\r\n\r\nexport function FSharpList_Cons_305B8EAC(x, xs) {\r\n    return new FSharpList(x, xs);\r\n}\r\n\r\nexport function FSharpList__get_IsEmpty(xs) {\r\n    return xs.tail == null;\r\n}\r\n\r\nexport function FSharpList__get_Length(xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            const matchValue = xs_1.tail;\r\n            if (matchValue != null) {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = matchValue;\r\n                continue loop;\r\n            }\r\n            else {\r\n                return i | 0;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs) | 0;\r\n}\r\n\r\nexport function FSharpList__get_Head(xs) {\r\n    const matchValue = xs.tail;\r\n    if (matchValue != null) {\r\n        return xs.head;\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputWasEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function FSharpList__get_Tail(xs) {\r\n    const matchValue = xs.tail;\r\n    if (matchValue != null) {\r\n        return matchValue;\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputWasEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function FSharpList__get_Item_Z524259A4(xs, index) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            const matchValue = xs_1.tail;\r\n            if (matchValue != null) {\r\n                if (i === index) {\r\n                    return xs_1.head;\r\n                }\r\n                else {\r\n                    i_mut = (i + 1);\r\n                    xs_1_mut = matchValue;\r\n                    continue loop;\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function empty() {\r\n    return FSharpList_get_Empty();\r\n}\r\n\r\nexport function cons(x, xs) {\r\n    return FSharpList_Cons_305B8EAC(x, xs);\r\n}\r\n\r\nexport function singleton(x) {\r\n    return FSharpList_Cons_305B8EAC(x, FSharpList_get_Empty());\r\n}\r\n\r\nexport function isEmpty(xs) {\r\n    return FSharpList__get_IsEmpty(xs);\r\n}\r\n\r\nexport function length(xs) {\r\n    return FSharpList__get_Length(xs);\r\n}\r\n\r\nexport function head(xs) {\r\n    return FSharpList__get_Head(xs);\r\n}\r\n\r\nexport function tryHead(xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(FSharpList__get_Head(xs));\r\n    }\r\n}\r\n\r\nexport function tail(xs) {\r\n    return FSharpList__get_Tail(xs);\r\n}\r\n\r\nexport function tryLast(xs_mut) {\r\n    tryLast:\r\n    while (true) {\r\n        const xs = xs_mut;\r\n        if (FSharpList__get_IsEmpty(xs)) {\r\n            return void 0;\r\n        }\r\n        else {\r\n            const t = FSharpList__get_Tail(xs);\r\n            if (FSharpList__get_IsEmpty(t)) {\r\n                return some(FSharpList__get_Head(xs));\r\n            }\r\n            else {\r\n                xs_mut = t;\r\n                continue tryLast;\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function last(xs) {\r\n    const matchValue = tryLast(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function compareWith(comparer, xs, ys) {\r\n    const loop = (xs_1_mut, ys_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n            const matchValue = [FSharpList__get_IsEmpty(xs_1), FSharpList__get_IsEmpty(ys_1)];\r\n            if (matchValue[0]) {\r\n                if (matchValue[1]) {\r\n                    return 0;\r\n                }\r\n                else {\r\n                    return -1;\r\n                }\r\n            }\r\n            else if (matchValue[1]) {\r\n                return 1;\r\n            }\r\n            else {\r\n                const c = comparer(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)) | 0;\r\n                if (c === 0) {\r\n                    xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                    ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return c | 0;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(xs, ys) | 0;\r\n}\r\n\r\nexport function toArray(xs) {\r\n    const len = FSharpList__get_Length(xs) | 0;\r\n    const res = fill(new Array(len), 0, len, null);\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (!FSharpList__get_IsEmpty(xs_1)) {\r\n                res[i] = FSharpList__get_Head(xs_1);\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    loop(0, xs);\r\n    return res;\r\n}\r\n\r\nexport function fold(folder, state, xs) {\r\n    let acc = state;\r\n    let xs_1 = xs;\r\n    while (!FSharpList__get_IsEmpty(xs_1)) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_1));\r\n        xs_1 = FSharpList__get_Tail(xs_1);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function reverse(xs) {\r\n    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), FSharpList_get_Empty(), xs);\r\n}\r\n\r\nexport function foldBack(folder, xs, state) {\r\n    return foldBack_1(folder, toArray(xs), state);\r\n}\r\n\r\nexport function foldIndexed(folder, state, xs) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                acc_mut = folder(i, acc, FSharpList__get_Head(xs_1));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, state, xs);\r\n}\r\n\r\nexport function fold2(folder, state, xs, ys) {\r\n    let acc = state;\r\n    let xs_1 = xs;\r\n    let ys_1 = ys;\r\n    while ((!FSharpList__get_IsEmpty(xs_1)) && (!FSharpList__get_IsEmpty(ys_1))) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1));\r\n        xs_1 = FSharpList__get_Tail(xs_1);\r\n        ys_1 = FSharpList__get_Tail(ys_1);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function foldBack2(folder, xs, ys, state) {\r\n    return foldBack2_1(folder, toArray(xs), toArray(ys), state);\r\n}\r\n\r\nexport function unfold(gen, state) {\r\n    const loop = (acc_mut, node_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, node = node_mut;\r\n            const matchValue = gen(acc);\r\n            if (matchValue != null) {\r\n                acc_mut = matchValue[1];\r\n                node_mut = ((t = (new FSharpList(matchValue[0], void 0)), (node.tail = t, t)));\r\n                continue loop;\r\n            }\r\n            else {\r\n                return node;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(state, root);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function iterate(action, xs) {\r\n    fold((unitVar0, x) => {\r\n        action(x);\r\n    }, void 0, xs);\r\n}\r\n\r\nexport function iterate2(action, xs, ys) {\r\n    fold2((unitVar0, x, y) => {\r\n        action(x, y);\r\n    }, void 0, xs, ys);\r\n}\r\n\r\nexport function iterateIndexed(action, xs) {\r\n    fold((i, x) => {\r\n        action(i, x);\r\n        return (i + 1) | 0;\r\n    }, 0, xs);\r\n}\r\n\r\nexport function iterateIndexed2(action, xs, ys) {\r\n    fold2((i, x, y) => {\r\n        action(i, x, y);\r\n        return (i + 1) | 0;\r\n    }, 0, xs, ys);\r\n}\r\n\r\nexport function toSeq(xs) {\r\n    return xs;\r\n}\r\n\r\nexport function ofArrayWithTail(xs, tail_1) {\r\n    let res = tail_1;\r\n    for (let i = xs.length - 1; i >= 0; i--) {\r\n        res = FSharpList_Cons_305B8EAC(xs[i], res);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function ofArray(xs) {\r\n    return ofArrayWithTail(xs, FSharpList_get_Empty());\r\n}\r\n\r\nexport function ofSeq(xs) {\r\n    let xs_3, t;\r\n    if (isArrayLike(xs)) {\r\n        return ofArray(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return xs;\r\n    }\r\n    else {\r\n        const root = FSharpList_get_Empty();\r\n        let node = root;\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                node = ((xs_3 = node, (t = (new FSharpList(x, void 0)), (xs_3.tail = t, t))));\r\n            }\r\n        }\r\n        finally {\r\n            enumerator.Dispose();\r\n        }\r\n        const xs_5 = node;\r\n        const t_2 = FSharpList_get_Empty();\r\n        xs_5.tail = t_2;\r\n        return FSharpList__get_Tail(root);\r\n    }\r\n}\r\n\r\nexport function concat(lists) {\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    const action = (xs) => {\r\n        node = fold((acc, x) => {\r\n            const t = new FSharpList(x, void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }, node, xs);\r\n    };\r\n    if (isArrayLike(lists)) {\r\n        lists.forEach(action);\r\n    }\r\n    else if (lists instanceof FSharpList) {\r\n        iterate(action, lists);\r\n    }\r\n    else {\r\n        const enumerator = getEnumerator(lists);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                action(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n        }\r\n        finally {\r\n            enumerator.Dispose();\r\n        }\r\n    }\r\n    const xs_6 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_6.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function scan(folder, state, xs) {\r\n    let xs_4, t_2;\r\n    const root = FSharpList_get_Empty();\r\n    let node;\r\n    const t = new FSharpList(state, void 0);\r\n    root.tail = t;\r\n    node = t;\r\n    let acc = state;\r\n    let xs_3 = xs;\r\n    while (!FSharpList__get_IsEmpty(xs_3)) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_3));\r\n        node = ((xs_4 = node, (t_2 = (new FSharpList(acc, void 0)), (xs_4.tail = t_2, t_2))));\r\n        xs_3 = FSharpList__get_Tail(xs_3);\r\n    }\r\n    const xs_6 = node;\r\n    const t_4 = FSharpList_get_Empty();\r\n    xs_6.tail = t_4;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function scanBack(folder, xs, state) {\r\n    return ofArray(scanBack_1(folder, toArray(xs), state));\r\n}\r\n\r\nexport function append(xs, ys) {\r\n    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));\r\n}\r\n\r\nexport function collect(mapping, xs) {\r\n    let xs_1, t;\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    let ys = xs;\r\n    while (!FSharpList__get_IsEmpty(ys)) {\r\n        let zs = mapping(FSharpList__get_Head(ys));\r\n        while (!FSharpList__get_IsEmpty(zs)) {\r\n            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head(zs), void 0)), (xs_1.tail = t, t))));\r\n            zs = FSharpList__get_Tail(zs);\r\n        }\r\n        ys = FSharpList__get_Tail(ys);\r\n    }\r\n    const xs_3 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_3.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapIndexed(mapping, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = foldIndexed((i, acc, x) => {\r\n        const t = new FSharpList(mapping(i, x), void 0);\r\n        acc.tail = t;\r\n        return t;\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function map(mapping, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        const t = new FSharpList(mapping(x), void 0);\r\n        acc.tail = t;\r\n        return t;\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function indexed(xs) {\r\n    return mapIndexed((i, x) => [i, x], xs);\r\n}\r\n\r\nexport function map2(mapping, xs, ys) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold2((acc, x, y) => {\r\n        const t = new FSharpList(mapping(x, y), void 0);\r\n        acc.tail = t;\r\n        return t;\r\n    }, root, xs, ys);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapIndexed2(mapping, xs, ys) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut, ys_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                acc_mut = ((t = (new FSharpList(mapping(i, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(0, root, xs, ys);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function map3(mapping, xs, ys, zs) {\r\n    const loop = (acc_mut, xs_1_mut, ys_1_mut, zs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut, zs_1 = zs_1_mut;\r\n            if ((FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) ? true : FSharpList__get_IsEmpty(zs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = ((t = (new FSharpList(mapping(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1), FSharpList__get_Head(zs_1)), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                zs_1_mut = FSharpList__get_Tail(zs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(root, xs, ys, zs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapFold(mapping, state, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const patternInput_1 = fold((tupledArg, x) => {\r\n        let t;\r\n        const patternInput = mapping(tupledArg[1], x);\r\n        return [(t = (new FSharpList(patternInput[0], void 0)), (tupledArg[0].tail = t, t)), patternInput[1]];\r\n    }, [root, state], xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    patternInput_1[0].tail = t_2;\r\n    return [FSharpList__get_Tail(root), patternInput_1[1]];\r\n}\r\n\r\nexport function mapFoldBack(mapping, xs, state) {\r\n    return mapFold((acc, x) => mapping(x, acc), state, reverse(xs));\r\n}\r\n\r\nexport function tryPick(f, xs) {\r\n    const loop = (xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else {\r\n                const matchValue = f(FSharpList__get_Head(xs_1));\r\n                if (matchValue == null) {\r\n                    xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(xs);\r\n}\r\n\r\nexport function pick(f, xs) {\r\n    const matchValue = tryPick(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFind(f, xs) {\r\n    return tryPick((x) => (f(x) ? some(x) : (void 0)), xs);\r\n}\r\n\r\nexport function find(f, xs) {\r\n    const matchValue = tryFind(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindBack(f, xs) {\r\n    return tryFindBack_1(f, toArray(xs));\r\n}\r\n\r\nexport function findBack(f, xs) {\r\n    const matchValue = tryFindBack(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(f, xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else if (f(FSharpList__get_Head(xs_1))) {\r\n                return i;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function findIndex(f, xs) {\r\n    const matchValue = tryFindIndex(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndexBack(f, xs) {\r\n    return tryFindIndexBack_1(f, toArray(xs));\r\n}\r\n\r\nexport function findIndexBack(f, xs) {\r\n    const matchValue = tryFindIndexBack(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryItem(n, xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else if (i === n) {\r\n                return some(FSharpList__get_Head(xs_1));\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function item(n, xs) {\r\n    return FSharpList__get_Item_Z524259A4(xs, n);\r\n}\r\n\r\nexport function filter(f, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        if (f(x)) {\r\n            const t = new FSharpList(x, void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function partition(f, xs) {\r\n    const patternInput = [FSharpList_get_Empty(), FSharpList_get_Empty()];\r\n    const root2 = patternInput[1];\r\n    const root1 = patternInput[0];\r\n    const patternInput_1 = fold(uncurry(2, (tupledArg) => {\r\n        const lacc = tupledArg[0];\r\n        const racc = tupledArg[1];\r\n        return (x) => {\r\n            let t, t_2;\r\n            return f(x) ? [(t = (new FSharpList(x, void 0)), (lacc.tail = t, t)), racc] : [lacc, (t_2 = (new FSharpList(x, void 0)), (racc.tail = t_2, t_2))];\r\n        };\r\n    }), [root1, root2], xs);\r\n    const t_4 = FSharpList_get_Empty();\r\n    patternInput_1[0].tail = t_4;\r\n    const t_5 = FSharpList_get_Empty();\r\n    patternInput_1[1].tail = t_5;\r\n    return [FSharpList__get_Tail(root1), FSharpList__get_Tail(root2)];\r\n}\r\n\r\nexport function choose(f, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        const matchValue = f(x);\r\n        if (matchValue == null) {\r\n            return acc;\r\n        }\r\n        else {\r\n            const t = new FSharpList(value_1(matchValue), void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function contains(value, xs, eq) {\r\n    return tryFindIndex((v) => eq.Equals(value, v), xs) != null;\r\n}\r\n\r\nexport function initialize(n, f) {\r\n    let xs, t;\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    for (let i = 0; i <= (n - 1); i++) {\r\n        node = ((xs = node, (t = (new FSharpList(f(i), void 0)), (xs.tail = t, t))));\r\n    }\r\n    const xs_2 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_2.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function replicate(n, x) {\r\n    return initialize(n, (_arg1) => x);\r\n}\r\n\r\nexport function reduce(f, xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return fold(f, head(xs), tail(xs));\r\n    }\r\n}\r\n\r\nexport function reduceBack(f, xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return foldBack(f, tail(xs), head(xs));\r\n    }\r\n}\r\n\r\nexport function forAll(f, xs) {\r\n    return fold((acc, x) => (acc && f(x)), true, xs);\r\n}\r\n\r\nexport function forAll2(f, xs, ys) {\r\n    return fold2((acc, x, y) => (acc && f(x, y)), true, xs, ys);\r\n}\r\n\r\nexport function exists(f, xs) {\r\n    return tryFindIndex(f, xs) != null;\r\n}\r\n\r\nexport function exists2(f_mut, xs_mut, ys_mut) {\r\n    exists2:\r\n    while (true) {\r\n        const f = f_mut, xs = xs_mut, ys = ys_mut;\r\n        const matchValue = [FSharpList__get_IsEmpty(xs), FSharpList__get_IsEmpty(ys)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0]) {\r\n            if (matchValue[1]) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 2;\r\n            }\r\n        }\r\n        else if (matchValue[1]) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return false;\r\n            }\r\n            case 1: {\r\n                if (f(FSharpList__get_Head(xs), FSharpList__get_Head(ys))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    xs_mut = FSharpList__get_Tail(xs);\r\n                    ys_mut = FSharpList__get_Tail(ys);\r\n                    continue exists2;\r\n                }\r\n            }\r\n            case 2: {\r\n                throw (new Error((SR_differentLengths + \"\\\\nParameter name: \") + \"list2\"));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function unzip(xs) {\r\n    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty()]);\r\n}\r\n\r\nexport function unzip3(xs) {\r\n    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1]), FSharpList_Cons_305B8EAC(tupledArg[2], tupledArg_1[2])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty(), FSharpList_get_Empty()]);\r\n}\r\n\r\nexport function zip(xs, ys) {\r\n    return map2((x, y) => [x, y], xs, ys);\r\n}\r\n\r\nexport function zip3(xs, ys, zs) {\r\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    const arr = toArray(xs);\r\n    arr.sort(comparer);\r\n    return ofArray(arr);\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(x, y), xs);\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);\r\n}\r\n\r\nexport function sum(xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\r\n}\r\n\r\nexport function sumBy(f, xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(xs, averager) {\r\n    let count = 0;\r\n    return averager.DivideByInt(fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, x);\r\n    }, averager.GetZero(), xs), count);\r\n}\r\n\r\nexport function averageBy(f, xs, averager) {\r\n    let count = 0;\r\n    return averager.DivideByInt(fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, f(x));\r\n    }, averager.GetZero(), xs), count);\r\n}\r\n\r\nexport function permute(f, xs) {\r\n    return ofArray(permute_1(f, toArray(xs)));\r\n}\r\n\r\nexport function chunkBySize(chunkSize, xs) {\r\n    return ofArray(map_1((xs_1) => ofArray(xs_1), chunkBySize_1(chunkSize, toArray(xs))));\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    iterate((x) => {\r\n        iterate((y) => {\r\n            let xs_1, t;\r\n            node = ((xs_1 = node, (t = (new FSharpList([x, y], void 0)), (xs_1.tail = t, t))));\r\n        }, ys);\r\n    }, xs);\r\n    const xs_3 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_3.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function skip(count_mut, xs_mut) {\r\n    skip:\r\n    while (true) {\r\n        const count = count_mut, xs = xs_mut;\r\n        if (count <= 0) {\r\n            return xs;\r\n        }\r\n        else if (FSharpList__get_IsEmpty(xs)) {\r\n            throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"list\"));\r\n        }\r\n        else {\r\n            count_mut = (count - 1);\r\n            xs_mut = FSharpList__get_Tail(xs);\r\n            continue skip;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function skipWhile(predicate_mut, xs_mut) {\r\n    skipWhile:\r\n    while (true) {\r\n        const predicate = predicate_mut, xs = xs_mut;\r\n        if (FSharpList__get_IsEmpty(xs)) {\r\n            return xs;\r\n        }\r\n        else if (!predicate(FSharpList__get_Head(xs))) {\r\n            return xs;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            xs_mut = FSharpList__get_Tail(xs);\r\n            continue skipWhile;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function take(count, xs) {\r\n    if (count < 0) {\r\n        throw (new Error((SR_inputMustBeNonNegative + \"\\\\nParameter name: \") + \"count\"));\r\n    }\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (i <= 0) {\r\n                return acc;\r\n            }\r\n            else if (FSharpList__get_IsEmpty(xs_1)) {\r\n                throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"list\"));\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(count, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function takeWhile(predicate, xs) {\r\n    const loop = (acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else if (!predicate(FSharpList__get_Head(xs_1))) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function truncate(count, xs) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (i <= 0) {\r\n                return acc;\r\n            }\r\n            else if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(count, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function getSlice(startIndex, endIndex, xs) {\r\n    const len = length(xs) | 0;\r\n    const startIndex_1 = defaultArg(startIndex, 0) | 0;\r\n    const endIndex_1 = defaultArg(endIndex, len - 1) | 0;\r\n    if (startIndex_1 < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"startIndex\"));\r\n    }\r\n    else if (endIndex_1 >= len) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"endIndex\"));\r\n    }\r\n    else if (endIndex_1 < startIndex_1) {\r\n        return FSharpList_get_Empty();\r\n    }\r\n    else {\r\n        return take((endIndex_1 - startIndex_1) + 1, skip(startIndex_1, xs));\r\n    }\r\n}\r\n\r\nexport function splitAt(index, xs) {\r\n    if (index < 0) {\r\n        throw (new Error((SR_inputMustBeNonNegative + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    if (index > FSharpList__get_Length(xs)) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return [take(index, xs), skip(index, xs)];\r\n}\r\n\r\nexport function exactlyOne(xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n    else if (FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {\r\n        return FSharpList__get_Head(xs);\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputSequenceTooLong + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(xs) {\r\n    if ((!FSharpList__get_IsEmpty(xs)) && FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {\r\n        return some(FSharpList__get_Head(xs));\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function where(predicate, xs) {\r\n    return filter(predicate, xs);\r\n}\r\n\r\nexport function pairwise(xs) {\r\n    return ofArray(pairwise_1(toArray(xs)));\r\n}\r\n\r\nexport function windowed(windowSize, xs) {\r\n    return ofArray(map_1((xs_1) => ofArray(xs_1), windowed_1(windowSize, toArray(xs))));\r\n}\r\n\r\nexport function splitInto(chunks, xs) {\r\n    return ofArray(map_1((xs_1) => ofArray(xs_1), splitInto_1(chunks, toArray(xs))));\r\n}\r\n\r\nexport function transpose(lists) {\r\n    return ofArray(map_1((xs_1) => ofArray(xs_1), transpose_1(map_1((xs) => toArray(xs), Array.from(lists)))));\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const result = fold((acc, x) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return FSharpList_Cons_305B8EAC(x, FSharpList_Cons_305B8EAC(y, acc));\r\n        }\r\n        else {\r\n            return FSharpList_Cons_305B8EAC(x, acc);\r\n        }\r\n    }, FSharpList_get_Empty(), xs);\r\n    return reverse(isDone ? result : (((i + 1) === index) ? FSharpList_Cons_305B8EAC(y, result) : (() => {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    })()));\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const ys_1 = foldBack_2((y, acc) => FSharpList_Cons_305B8EAC(y, acc), ys, FSharpList_get_Empty());\r\n    const result = fold((acc_1, x) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return FSharpList_Cons_305B8EAC(x, append(ys_1, acc_1));\r\n        }\r\n        else {\r\n            return FSharpList_Cons_305B8EAC(x, acc_1);\r\n        }\r\n    }, FSharpList_get_Empty(), xs);\r\n    return reverse(isDone ? result : (((i + 1) === index) ? append(ys_1, result) : (() => {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    })()));\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return false;\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    if (!isDone) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    let i = -1;\r\n    let status = -1;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            status = 0;\r\n            return false;\r\n        }\r\n        else if (i > index) {\r\n            if (i < (index + count)) {\r\n                return false;\r\n            }\r\n            else {\r\n                status = 1;\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;\r\n    if (status_1 < 1) {\r\n        const arg = (status_1 < 0) ? \"index\" : \"count\";\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + arg));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    let isDone = false;\r\n    const ys = mapIndexed((i, x) => {\r\n        if (i === index) {\r\n            isDone = true;\r\n            return y;\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n    }, xs);\r\n    if (!isDone) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return ys;\r\n}\r\n\r\n","export class CancellationToken {\n    constructor(cancelled = false) {\n        this._id = 0;\n        this._cancelled = cancelled;\n        this._listeners = new Map();\n    }\n    get isCancelled() {\n        return this._cancelled;\n    }\n    cancel() {\n        if (!this._cancelled) {\n            this._cancelled = true;\n            for (const [, listener] of this._listeners) {\n                listener();\n            }\n        }\n    }\n    addListener(f) {\n        const id = this._id;\n        this._listeners.set(this._id++, f);\n        return id;\n    }\n    removeListener(id) {\n        return this._listeners.delete(id);\n    }\n    register(f, state) {\n        const $ = this;\n        const id = this.addListener(state == null ? f : () => f(state));\n        return { Dispose() { $.removeListener(id); } };\n    }\n}\nexport class OperationCanceledError extends Error {\n    constructor() {\n        super(\"The operation was canceled\");\n        Object.setPrototypeOf(this, OperationCanceledError.prototype);\n    }\n}\nexport class Trampoline {\n    constructor() {\n        this.callCount = 0;\n    }\n    static get maxTrampolineCallCount() {\n        return 2000;\n    }\n    incrementAndCheck() {\n        return this.callCount++ > Trampoline.maxTrampolineCallCount;\n    }\n    hijack(f) {\n        this.callCount = 0;\n        setTimeout(f, 0);\n    }\n}\nexport function protectedCont(f) {\n    return (ctx) => {\n        if (ctx.cancelToken.isCancelled) {\n            ctx.onCancel(new OperationCanceledError());\n        }\n        else if (ctx.trampoline.incrementAndCheck()) {\n            ctx.trampoline.hijack(() => {\n                try {\n                    f(ctx);\n                }\n                catch (err) {\n                    ctx.onError(err);\n                }\n            });\n        }\n        else {\n            try {\n                f(ctx);\n            }\n            catch (err) {\n                ctx.onError(err);\n            }\n        }\n    };\n}\nexport function protectedBind(computation, binder) {\n    return protectedCont((ctx) => {\n        computation({\n            onSuccess: (x) => {\n                try {\n                    binder(x)(ctx);\n                }\n                catch (ex) {\n                    ctx.onError(ex);\n                }\n            },\n            onError: ctx.onError,\n            onCancel: ctx.onCancel,\n            cancelToken: ctx.cancelToken,\n            trampoline: ctx.trampoline,\n        });\n    });\n}\nexport function protectedReturn(value) {\n    return protectedCont((ctx) => ctx.onSuccess(value));\n}\nexport class AsyncBuilder {\n    Bind(computation, binder) {\n        return protectedBind(computation, binder);\n    }\n    Combine(computation1, computation2) {\n        return this.Bind(computation1, () => computation2);\n    }\n    Delay(generator) {\n        return protectedCont((ctx) => generator()(ctx));\n    }\n    For(sequence, body) {\n        const iter = sequence[Symbol.iterator]();\n        let cur = iter.next();\n        return this.While(() => !cur.done, this.Delay(() => {\n            const res = body(cur.value);\n            cur = iter.next();\n            return res;\n        }));\n    }\n    Return(value) {\n        return protectedReturn(value);\n    }\n    ReturnFrom(computation) {\n        return computation;\n    }\n    TryFinally(computation, compensation) {\n        return protectedCont((ctx) => {\n            computation({\n                onSuccess: (x) => {\n                    compensation();\n                    ctx.onSuccess(x);\n                },\n                onError: (x) => {\n                    compensation();\n                    ctx.onError(x);\n                },\n                onCancel: (x) => {\n                    compensation();\n                    ctx.onCancel(x);\n                },\n                cancelToken: ctx.cancelToken,\n                trampoline: ctx.trampoline,\n            });\n        });\n    }\n    TryWith(computation, catchHandler) {\n        return protectedCont((ctx) => {\n            computation({\n                onSuccess: ctx.onSuccess,\n                onCancel: ctx.onCancel,\n                cancelToken: ctx.cancelToken,\n                trampoline: ctx.trampoline,\n                onError: (ex) => {\n                    try {\n                        catchHandler(ex)(ctx);\n                    }\n                    catch (ex2) {\n                        ctx.onError(ex2);\n                    }\n                },\n            });\n        });\n    }\n    Using(resource, binder) {\n        return this.TryFinally(binder(resource), () => resource.Dispose());\n    }\n    While(guard, computation) {\n        if (guard()) {\n            return this.Bind(computation, () => this.While(guard, computation));\n        }\n        else {\n            return this.Return(void 0);\n        }\n    }\n    Zero() {\n        return protectedCont((ctx) => ctx.onSuccess(void 0));\n    }\n}\nexport const singleton = new AsyncBuilder();\n","import { Union } from \"./Types.js\";\r\nimport { union_type } from \"./Reflection.js\";\r\nimport { some } from \"./Option.js\";\r\n\r\nexport class FSharpResult$2 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Ok\", \"Error\"];\r\n    }\r\n}\r\n\r\nexport function FSharpResult$2$reflection(gen0, gen1) {\r\n    return union_type(\"FSharp.Core.FSharpResult`2\", [gen0, gen1], FSharpResult$2, () => [[[\"ResultValue\", gen0]], [[\"ErrorValue\", gen1]]]);\r\n}\r\n\r\nexport function Result_Map(mapping, result) {\r\n    if (result.tag === 0) {\r\n        return new FSharpResult$2(0, mapping(result.fields[0]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, result.fields[0]);\r\n    }\r\n}\r\n\r\nexport function Result_MapError(mapping, result) {\r\n    if (result.tag === 0) {\r\n        return new FSharpResult$2(0, result.fields[0]);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, mapping(result.fields[0]));\r\n    }\r\n}\r\n\r\nexport function Result_Bind(binder, result) {\r\n    if (result.tag === 0) {\r\n        return binder(result.fields[0]);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, result.fields[0]);\r\n    }\r\n}\r\n\r\nexport class FSharpChoice$2 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of2\", \"Choice2Of2\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$2$reflection(gen0, gen1) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`2\", [gen0, gen1], FSharpChoice$2, () => [[[\"Item\", gen0]], [[\"Item\", gen1]]]);\r\n}\r\n\r\nexport class FSharpChoice$3 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of3\", \"Choice2Of3\", \"Choice3Of3\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$3$reflection(gen0, gen1, gen2) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`3\", [gen0, gen1, gen2], FSharpChoice$3, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]]]);\r\n}\r\n\r\nexport class FSharpChoice$4 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of4\", \"Choice2Of4\", \"Choice3Of4\", \"Choice4Of4\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$4$reflection(gen0, gen1, gen2, gen3) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`4\", [gen0, gen1, gen2, gen3], FSharpChoice$4, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]]]);\r\n}\r\n\r\nexport class FSharpChoice$5 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of5\", \"Choice2Of5\", \"Choice3Of5\", \"Choice4Of5\", \"Choice5Of5\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$5$reflection(gen0, gen1, gen2, gen3, gen4) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`5\", [gen0, gen1, gen2, gen3, gen4], FSharpChoice$5, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]]]);\r\n}\r\n\r\nexport class FSharpChoice$6 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of6\", \"Choice2Of6\", \"Choice3Of6\", \"Choice4Of6\", \"Choice5Of6\", \"Choice6Of6\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$6$reflection(gen0, gen1, gen2, gen3, gen4, gen5) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`6\", [gen0, gen1, gen2, gen3, gen4, gen5], FSharpChoice$6, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]], [[\"Item\", gen5]]]);\r\n}\r\n\r\nexport class FSharpChoice$7 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Choice1Of7\", \"Choice2Of7\", \"Choice3Of7\", \"Choice4Of7\", \"Choice5Of7\", \"Choice6Of7\", \"Choice7Of7\"];\r\n    }\r\n}\r\n\r\nexport function FSharpChoice$7$reflection(gen0, gen1, gen2, gen3, gen4, gen5, gen6) {\r\n    return union_type(\"FSharp.Core.FSharpChoice`7\", [gen0, gen1, gen2, gen3, gen4, gen5, gen6], FSharpChoice$7, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]], [[\"Item\", gen5]], [[\"Item\", gen6]]]);\r\n}\r\n\r\nexport function Choice_makeChoice1Of2(x) {\r\n    return new FSharpChoice$2(0, x);\r\n}\r\n\r\nexport function Choice_makeChoice2Of2(x) {\r\n    return new FSharpChoice$2(1, x);\r\n}\r\n\r\nexport function Choice_tryValueIfChoice1Of2(x) {\r\n    if (x.tag === 0) {\r\n        return some(x.fields[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function Choice_tryValueIfChoice2Of2(x) {\r\n    if (x.tag === 1) {\r\n        return some(x.fields[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\n","import { OperationCanceledError, Trampoline } from \"./AsyncBuilder.js\";\nimport { CancellationToken } from \"./AsyncBuilder.js\";\nimport { protectedCont } from \"./AsyncBuilder.js\";\nimport { protectedBind } from \"./AsyncBuilder.js\";\nimport { protectedReturn } from \"./AsyncBuilder.js\";\nimport { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from \"./Choice.js\";\nimport { TimeoutException } from \"./SystemException.js\";\n// Implemented just for type references\nexport class Async {\n}\nfunction emptyContinuation(_x) {\n    // NOP\n}\n// see AsyncBuilder.Delay\nfunction delay(generator) {\n    return protectedCont((ctx) => generator()(ctx));\n}\n// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>\nexport function makeAsync(body) {\n    return body;\n}\n// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn\nexport function invoke(computation, ctx) {\n    return computation(ctx);\n}\n// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn\nexport function callThenInvoke(ctx, result1, part2) {\n    return part2(result1)(ctx);\n}\n// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn\nexport function bind(ctx, part1, part2) {\n    return protectedBind(part1, part2)(ctx);\n}\nexport function createCancellationToken(arg) {\n    const token = new CancellationToken(typeof arg === \"boolean\" ? arg : false);\n    if (typeof arg === \"number\") {\n        setTimeout(() => { token.cancel(); }, arg);\n    }\n    return token;\n}\nexport function cancel(token) {\n    token.cancel();\n}\nexport function cancelAfter(token, ms) {\n    setTimeout(() => { token.cancel(); }, ms);\n}\nexport function isCancellationRequested(token) {\n    return token != null && token.isCancelled;\n}\nexport function throwIfCancellationRequested(token) {\n    if (token != null && token.isCancelled) {\n        throw new Error(\"Operation is cancelled\");\n    }\n}\nfunction throwAfter(millisecondsDueTime) {\n    return protectedCont((ctx) => {\n        let tokenId;\n        const timeoutId = setTimeout(() => {\n            ctx.cancelToken.removeListener(tokenId);\n            ctx.onError(new TimeoutException());\n        }, millisecondsDueTime);\n        tokenId = ctx.cancelToken.addListener(() => {\n            clearTimeout(timeoutId);\n            ctx.onCancel(new OperationCanceledError());\n        });\n    });\n}\nexport function startChild(computation, ms) {\n    if (ms) {\n        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));\n        return startChild(computationWithTimeout);\n    }\n    const promise = startAsPromise(computation);\n    // JS Promises are hot, computation has already started\n    // but we delay returning the result\n    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));\n}\nexport function awaitPromise(p) {\n    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError\n        ? conts[2] : conts[1])(err)));\n}\nexport function cancellationToken() {\n    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));\n}\nexport const defaultCancellationToken = new CancellationToken();\nexport function catchAsync(work) {\n    return protectedCont((ctx) => {\n        work({\n            onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),\n            onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),\n            onCancel: ctx.onCancel,\n            cancelToken: ctx.cancelToken,\n            trampoline: ctx.trampoline,\n        });\n    });\n}\nexport function fromContinuations(f) {\n    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));\n}\nexport function ignore(computation) {\n    return protectedBind(computation, (_x) => protectedReturn(void 0));\n}\nexport function parallel(computations) {\n    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));\n}\nfunction parallel2(a, b) {\n    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));\n}\nexport function sequential(computations) {\n    function _sequential(computations) {\n        let pr = Promise.resolve([]);\n        for (const c of computations) {\n            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));\n        }\n        return pr;\n    }\n    return delay(() => awaitPromise(_sequential(computations)));\n}\nexport function sleep(millisecondsDueTime) {\n    return protectedCont((ctx) => {\n        let tokenId;\n        const timeoutId = setTimeout(() => {\n            ctx.cancelToken.removeListener(tokenId);\n            ctx.onSuccess(void 0);\n        }, millisecondsDueTime);\n        tokenId = ctx.cancelToken.addListener(() => {\n            clearTimeout(timeoutId);\n            ctx.onCancel(new OperationCanceledError());\n        });\n    });\n}\nexport function runSynchronously() {\n    throw new Error(\"Asynchronous code cannot be run synchronously in JS\");\n}\nexport function start(computation, cancellationToken) {\n    return startWithContinuations(computation, cancellationToken);\n}\nexport function startImmediate(computation, cancellationToken) {\n    return start(computation, cancellationToken);\n}\nexport function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {\n    if (typeof continuation !== \"function\") {\n        cancelToken = continuation;\n        continuation = undefined;\n    }\n    const trampoline = new Trampoline();\n    computation({\n        onSuccess: continuation ? continuation : emptyContinuation,\n        onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,\n        onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,\n        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,\n        trampoline,\n    });\n}\nexport function startAsPromise(computation, cancellationToken) {\n    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));\n}\nexport default Async;\n","import { Observer } from \"./Observable.js\";\nimport { some, value } from \"./Option.js\";\nimport { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from \"./Choice.js\";\nexport class Event {\n    constructor() {\n        this.delegates = [];\n    }\n    Add(f) {\n        this._addHandler(f);\n    }\n    get Publish() {\n        return this;\n    }\n    Trigger(senderOrValue, valueOrUndefined) {\n        let sender;\n        let value;\n        if (valueOrUndefined === undefined) {\n            sender = null;\n            value = senderOrValue;\n        }\n        else {\n            sender = senderOrValue;\n            value = valueOrUndefined;\n        }\n        this.delegates.forEach((f) => f.length === 1 ? f(value) : f(sender, value));\n    }\n    // IDelegateEvent<T> methods\n    AddHandler(handler) {\n        this._addHandler(handler);\n    }\n    RemoveHandler(handler) {\n        this._removeHandler(handler);\n    }\n    // IObservable<T> methods\n    Subscribe(arg) {\n        const callback = typeof arg === \"function\"\n            ? arg\n            : arg.OnNext;\n        this._addHandler(callback);\n        return { Dispose: () => { this._removeHandler(callback); } };\n    }\n    _addHandler(f) {\n        this.delegates.push(f);\n    }\n    _removeHandler(f) {\n        const index = this.delegates.indexOf(f);\n        if (index > -1) {\n            this.delegates.splice(index, 1);\n        }\n    }\n}\nexport function add(callback, sourceEvent) {\n    if (sourceEvent instanceof Event) {\n        sourceEvent.Add(callback);\n    }\n    else {\n        sourceEvent.Subscribe(new Observer(callback));\n    }\n}\nexport function choose(chooser, sourceEvent) {\n    const ev = new Event();\n    add((t) => {\n        const u = chooser(t);\n        if (u != null) {\n            ev.Trigger(value(u));\n        }\n    }, sourceEvent);\n    return ev;\n}\nexport function filter(predicate, sourceEvent) {\n    return choose((x) => predicate(x) ? some(x) : undefined, sourceEvent);\n}\nexport function map(mapping, sourceEvent) {\n    const ev = new Event();\n    add((t) => ev.Trigger(mapping(t)), sourceEvent);\n    return ev;\n}\nexport function merge(event1, event2) {\n    const ev = new Event();\n    const fn = (x) => ev.Trigger(x);\n    add(fn, event1);\n    add(fn, event2);\n    return ev;\n}\nexport function pairwise(sourceEvent) {\n    const ev = new Event();\n    let last;\n    let haveLast = false;\n    add((next) => {\n        if (haveLast) {\n            ev.Trigger([last, next]);\n        }\n        last = next;\n        haveLast = true;\n    }, sourceEvent);\n    return ev;\n}\nexport function partition(predicate, sourceEvent) {\n    return [filter(predicate, sourceEvent), filter((x) => !predicate(x), sourceEvent)];\n}\nexport function scan(collector, state, sourceEvent) {\n    return map((t) => state = collector(state, t), sourceEvent);\n}\nexport function split(splitter, sourceEvent) {\n    return [\n        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), sourceEvent),\n        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), sourceEvent),\n    ];\n}\nexport function createEvent(addHandler, removeHandler) {\n    return {\n        AddHandler(h) { addHandler(h); },\n        RemoveHandler(h) { removeHandler(h); },\n        Subscribe(r) {\n            const h = (_, args) => r.OnNext(args);\n            addHandler(h);\n            return {\n                Dispose() { removeHandler(h); }\n            };\n        }\n    };\n}\nexport default Event;\n","import { Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from \"./Choice.js\";\nimport { value } from \"./Option.js\";\nexport class Observer {\n    constructor(onNext, onError, onCompleted) {\n        this.OnNext = onNext;\n        this.OnError = onError || ((_e) => { return; });\n        this.OnCompleted = onCompleted || (() => { return; });\n    }\n}\nclass Observable {\n    constructor(subscribe) {\n        this.Subscribe = subscribe;\n    }\n}\nexport function protect(f, succeed, fail) {\n    try {\n        return succeed(f());\n    }\n    catch (e) {\n        fail(e);\n    }\n}\nexport function add(callback, source) {\n    source.Subscribe(new Observer(callback));\n}\nexport function choose(chooser, source) {\n    return new Observable((observer) => source.Subscribe(new Observer((t) => protect(() => chooser(t), (u) => { if (u != null) {\n        observer.OnNext(value(u));\n    } }, observer.OnError), observer.OnError, observer.OnCompleted)));\n}\nexport function filter(predicate, source) {\n    return choose((x) => predicate(x) ? x : null, source);\n}\nexport function map(mapping, source) {\n    return new Observable((observer) => source.Subscribe(new Observer((t) => {\n        protect(() => mapping(t), observer.OnNext, observer.OnError);\n    }, observer.OnError, observer.OnCompleted)));\n}\nexport function merge(source1, source2) {\n    return new Observable((observer) => {\n        let stopped = false;\n        let completed1 = false;\n        let completed2 = false;\n        const h1 = source1.Subscribe(new Observer((v) => { if (!stopped) {\n            observer.OnNext(v);\n        } }, (e) => {\n            if (!stopped) {\n                stopped = true;\n                observer.OnError(e);\n            }\n        }, () => {\n            if (!stopped) {\n                completed1 = true;\n                if (completed2) {\n                    stopped = true;\n                    observer.OnCompleted();\n                }\n            }\n        }));\n        const h2 = source2.Subscribe(new Observer((v) => { if (!stopped) {\n            observer.OnNext(v);\n        } }, (e) => {\n            if (!stopped) {\n                stopped = true;\n                observer.OnError(e);\n            }\n        }, () => {\n            if (!stopped) {\n                completed2 = true;\n                if (completed1) {\n                    stopped = true;\n                    observer.OnCompleted();\n                }\n            }\n        }));\n        return {\n            Dispose() {\n                h1.Dispose();\n                h2.Dispose();\n            },\n        };\n    });\n}\nexport function pairwise(source) {\n    return new Observable((observer) => {\n        let last;\n        return source.Subscribe(new Observer((next) => {\n            if (last != null) {\n                observer.OnNext([last, next]);\n            }\n            last = next;\n        }, observer.OnError, observer.OnCompleted));\n    });\n}\nexport function partition(predicate, source) {\n    return [filter(predicate, source), filter((x) => !predicate(x), source)];\n}\nexport function scan(collector, state, source) {\n    return new Observable((observer) => {\n        return source.Subscribe(new Observer((t) => {\n            protect(() => collector(state, t), (u) => { state = u; observer.OnNext(u); }, observer.OnError);\n        }, observer.OnError, observer.OnCompleted));\n    });\n}\nexport function split(splitter, source) {\n    return [\n        choose((v) => Choice_tryValueIfChoice1Of2(splitter(v)), source),\n        choose((v) => Choice_tryValueIfChoice2Of2(splitter(v)), source)\n    ];\n}\nexport function subscribe(callback, source) {\n    return source.Subscribe(new Observer(callback));\n}\n","import Timer from \"../fable-library.3.6.3/Timer.js\";\nimport { add } from \"../fable-library.3.6.3/Observable.js\";\n\nexport function Log_onError(text, ex) {\n    console.error(text, ex);\n}\n\nexport function Log_toConsole(text, o) {\n    console.log(text, o);\n}\n\nexport function Timer_delay(interval, callback) {\n    let t;\n    let returnVal = new Timer(interval);\n    returnVal.AutoReset = false;\n    t = returnVal;\n    add(callback, t.Elapsed());\n    t.Enabled = true;\n    t.Start();\n}\n\n","import Event from \"./Event.js\";\nexport class Timer {\n    constructor(interval) {\n        this._enabled = false;\n        this._isDisposed = false;\n        this._intervalId = 0;\n        this._timeoutId = 0;\n        this.Interval = interval && interval > 0 ? interval : 100;\n        this.AutoReset = true;\n        this._elapsed = new Event();\n    }\n    Elapsed() {\n        return this._elapsed;\n    }\n    get Enabled() {\n        return this._enabled;\n    }\n    set Enabled(x) {\n        if (!this._isDisposed && this._enabled !== x) {\n            this._enabled = x;\n            if (this._enabled) {\n                if (this.AutoReset) {\n                    this._intervalId = setInterval(() => {\n                        if (!this.AutoReset) {\n                            this.Enabled = false;\n                        }\n                        this._elapsed.Trigger(new Date());\n                    }, this.Interval);\n                }\n                else {\n                    this._timeoutId = setTimeout(() => {\n                        this.Enabled = false;\n                        this._timeoutId = 0;\n                        if (this.AutoReset) {\n                            this.Enabled = true;\n                        }\n                        this._elapsed.Trigger(new Date());\n                    }, this.Interval);\n                }\n            }\n            else {\n                if (this._timeoutId) {\n                    clearTimeout(this._timeoutId);\n                    this._timeoutId = 0;\n                }\n                if (this._intervalId) {\n                    clearInterval(this._intervalId);\n                    this._intervalId = 0;\n                }\n            }\n        }\n    }\n    Dispose() {\n        this.Enabled = false;\n        this._isDisposed = true;\n    }\n    Close() {\n        this.Dispose();\n    }\n    Start() {\n        this.Enabled = true;\n    }\n    Stop() {\n        this.Enabled = false;\n    }\n}\nexport default Timer;\n","import { singleton, concat, map, empty, iterate } from \"../fable-library.3.6.3/List.js\";\nimport { singleton as singleton_1 } from \"../fable-library.3.6.3/AsyncBuilder.js\";\nimport { startImmediate, catchAsync } from \"../fable-library.3.6.3/Async.js\";\nimport { Timer_delay } from \"./prelude.fs.js\";\n\nexport function Cmd_exec(onError, dispatch, cmd) {\n    iterate((call) => {\n        try {\n            call(dispatch);\n        }\n        catch (ex) {\n            onError(ex);\n        }\n    }, cmd);\n}\n\nexport function Cmd_none() {\n    return empty();\n}\n\nexport function Cmd_map(f, cmd) {\n    return map((g) => ((arg_1) => {\n        g((arg) => {\n            arg_1(f(arg));\n        });\n    }), cmd);\n}\n\nexport function Cmd_batch(cmds) {\n    return concat(cmds);\n}\n\nexport function Cmd_ofSub(sub) {\n    return singleton(sub);\n}\n\nexport function Cmd_OfFunc_either(task, arg, ofSuccess, ofError) {\n    return singleton((dispatch) => {\n        try {\n            return dispatch(ofSuccess(task(arg)));\n        }\n        catch (x) {\n            return dispatch(ofError(x));\n        }\n    });\n}\n\nexport function Cmd_OfFunc_perform(task, arg, ofSuccess) {\n    return singleton((dispatch) => {\n        try {\n            dispatch(ofSuccess(task(arg)));\n        }\n        catch (x) {\n        }\n    });\n}\n\nexport function Cmd_OfFunc_attempt(task, arg, ofError) {\n    return singleton((dispatch) => {\n        try {\n            task(arg);\n        }\n        catch (x) {\n            dispatch(ofError(x));\n        }\n    });\n}\n\nexport function Cmd_OfFunc_result(msg) {\n    return singleton((dispatch) => {\n        dispatch(msg);\n    });\n}\n\nexport function Cmd_OfAsyncWith_either(start, task, arg, ofSuccess, ofError) {\n    return singleton((arg_1) => {\n        start(singleton_1.Delay(() => singleton_1.Bind(catchAsync(task(arg)), (_arg1) => {\n            const r = _arg1;\n            arg_1((r.tag === 1) ? ofError(r.fields[0]) : ofSuccess(r.fields[0]));\n            return singleton_1.Zero();\n        })));\n    });\n}\n\nexport function Cmd_OfAsyncWith_perform(start, task, arg, ofSuccess) {\n    return singleton((arg_1) => {\n        start(singleton_1.Delay(() => singleton_1.Bind(catchAsync(task(arg)), (_arg1) => {\n            const r = _arg1;\n            if (r.tag === 0) {\n                arg_1(ofSuccess(r.fields[0]));\n                return singleton_1.Zero();\n            }\n            else {\n                return singleton_1.Zero();\n            }\n        })));\n    });\n}\n\nexport function Cmd_OfAsyncWith_attempt(start, task, arg, ofError) {\n    return singleton((arg_1) => {\n        start(singleton_1.Delay(() => singleton_1.Bind(catchAsync(task(arg)), (_arg1) => {\n            const r = _arg1;\n            if (r.tag === 1) {\n                arg_1(ofError(r.fields[0]));\n                return singleton_1.Zero();\n            }\n            else {\n                return singleton_1.Zero();\n            }\n        })));\n    });\n}\n\nexport function Cmd_OfAsyncWith_result(start, task) {\n    return singleton((arg) => {\n        start(singleton_1.Delay(() => singleton_1.Bind(task, (_arg1) => {\n            arg(_arg1);\n            return singleton_1.Zero();\n        })));\n    });\n}\n\nexport function Cmd_OfAsync_start(x) {\n    Timer_delay(0, (_arg1) => {\n        startImmediate(x);\n    });\n}\n\nexport function Cmd_OfPromise_either(task, arg, ofSuccess, ofError) {\n    return singleton((dispatch) => {\n        task(arg).then((arg_1) => dispatch(ofSuccess(arg_1))).catch((arg_3) => dispatch(ofError(arg_3)));\n    });\n}\n\nexport function Cmd_OfPromise_perform(task, arg, ofSuccess) {\n    return singleton((dispatch) => {\n        task(arg).then((arg_1) => dispatch(ofSuccess(arg_1)));\n    });\n}\n\nexport function Cmd_OfPromise_attempt(task, arg, ofError) {\n    return singleton((dispatch) => {\n        task(arg).catch((arg_2) => {\n            dispatch(ofError(arg_2));\n        });\n    });\n}\n\nexport function Cmd_OfPromise_result(task) {\n    return singleton((dispatch) => {\n        task.then(dispatch);\n    });\n}\n\nexport function Cmd_attemptFunc(task, arg, ofError) {\n    return Cmd_OfFunc_attempt(task, arg, ofError);\n}\n\n","import { structuralHash, equals } from \"./Util.js\";\r\nimport { HashIdentity_Structural, ComparisonIdentity_Structural } from \"./FSharp.Collections.js\";\r\nimport { StringBuilder__Append_Z721C83C5 } from \"./System.Text.js\";\r\n\r\nexport const LanguagePrimitives_GenericEqualityComparer = {\r\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\r\n        return equals(x, y);\r\n    },\r\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\r\n        return structuralHash(x_1);\r\n    },\r\n};\r\n\r\nexport const LanguagePrimitives_GenericEqualityERComparer = {\r\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\r\n        return equals(x, y);\r\n    },\r\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\r\n        return structuralHash(x_1);\r\n    },\r\n};\r\n\r\nexport function LanguagePrimitives_FastGenericComparer() {\r\n    return ComparisonIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericComparerFromTable() {\r\n    return ComparisonIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericEqualityComparer() {\r\n    return HashIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericEqualityComparerFromTable() {\r\n    return HashIdentity_Structural();\r\n}\r\n\r\nexport function Operators_Failure(message) {\r\n    return new Error(message);\r\n}\r\n\r\nexport function Operators_FailurePattern(exn) {\r\n    return exn.message;\r\n}\r\n\r\nexport function Operators_NullArg(x) {\r\n    throw (new Error(x));\r\n}\r\n\r\nexport function Operators_Using(resource, action) {\r\n    try {\r\n        return action(resource);\r\n    }\r\n    finally {\r\n        if (equals(resource, null)) {\r\n        }\r\n        else {\r\n            resource.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport function Operators_Lock(_lockObj, action) {\r\n    return action();\r\n}\r\n\r\nexport function ExtraTopLevelOperators_LazyPattern(input) {\r\n    return input.Value;\r\n}\r\n\r\nexport function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {\r\n    return format.cont((s) => {\r\n        StringBuilder__Append_Z721C83C5(builder, s);\r\n        return continuation();\r\n    });\r\n}\r\n\r\nexport function PrintfModule_PrintFormatToStringBuilder(builder, format) {\r\n    return PrintfModule_PrintFormatToStringBuilderThen(() => {\r\n    }, builder, format);\r\n}\r\n\r\n","import { compare, physicalHash, equals, structuralHash } from \"./Util.js\";\r\n\r\nexport function HashIdentity_FromFunctions(hash, eq) {\r\n    return {\r\n        Equals(x, y) {\r\n            return eq(x, y);\r\n        },\r\n        GetHashCode(x_1) {\r\n            return hash(x_1);\r\n        },\r\n    };\r\n}\r\n\r\nexport function HashIdentity_Structural() {\r\n    return HashIdentity_FromFunctions((obj) => structuralHash(obj), (e1, e2) => equals(e1, e2));\r\n}\r\n\r\nexport function HashIdentity_Reference() {\r\n    return HashIdentity_FromFunctions((obj) => physicalHash(obj), (e1, e2) => (e1 === e2));\r\n}\r\n\r\nexport function ComparisonIdentity_FromFunction(comparer) {\r\n    return {\r\n        Compare(x, y) {\r\n            return comparer(x, y);\r\n        },\r\n    };\r\n}\r\n\r\nexport function ComparisonIdentity_Structural() {\r\n    return ComparisonIdentity_FromFunction((e1, e2) => compare(e1, e2));\r\n}\r\n\r\n","import { clear, equals, isArrayLike, isDisposable, toIterator, getEnumerator } from \"./Util.js\";\r\nimport { toString } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { Operators_NullArg } from \"./FSharp.Core.js\";\r\nimport { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, windowed as windowed_1, splitInto as splitInto_1, map as map_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from \"./Array.js\";\r\nimport { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from \"./List.js\";\r\nimport { SR_indexOutOfBounds } from \"./Global.js\";\r\n\r\nexport const SR_enumerationAlreadyFinished = \"Enumeration already finished.\";\r\n\r\nexport const SR_enumerationNotStarted = \"Enumeration has not started. Call MoveNext.\";\r\n\r\nexport const SR_inputSequenceEmpty = \"The input sequence was empty.\";\r\n\r\nexport const SR_inputSequenceTooLong = \"The input sequence contains more than one element.\";\r\n\r\nexport const SR_keyNotFoundAlt = \"An index satisfying the predicate was not found in the collection.\";\r\n\r\nexport const SR_notEnoughElements = \"The input sequence has an insufficient number of elements.\";\r\n\r\nexport const SR_resetNotSupported = \"Reset is not supported on this enumerator.\";\r\n\r\nexport function Enumerator_noReset() {\r\n    throw (new Error(SR_resetNotSupported));\r\n}\r\n\r\nexport function Enumerator_notStarted() {\r\n    throw (new Error(SR_enumerationNotStarted));\r\n}\r\n\r\nexport function Enumerator_alreadyFinished() {\r\n    throw (new Error(SR_enumerationAlreadyFinished));\r\n}\r\n\r\nexport class Enumerator_Seq {\r\n    constructor(f) {\r\n        this.f = f;\r\n    }\r\n    toString() {\r\n        const xs = this;\r\n        const maxCount = 4;\r\n        let i = 0;\r\n        let str = \"seq [\";\r\n        const e = getEnumerator(xs);\r\n        try {\r\n            while ((i < maxCount) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                if (i > 0) {\r\n                    str = (str + \"; \");\r\n                }\r\n                str = (str + toString(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()));\r\n                i = ((i + 1) | 0);\r\n            }\r\n            if (i === maxCount) {\r\n                str = (str + \"; ...\");\r\n            }\r\n            return str + \"]\";\r\n        }\r\n        finally {\r\n            e.Dispose();\r\n        }\r\n    }\r\n    GetEnumerator() {\r\n        const x = this;\r\n        return x.f();\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const x = this;\r\n        return x.f();\r\n    }\r\n}\r\n\r\nexport function Enumerator_Seq$reflection(gen0) {\r\n    return class_type(\"SeqModule.Enumerator.Seq\", [gen0], Enumerator_Seq);\r\n}\r\n\r\nexport function Enumerator_Seq_$ctor_673A07F2(f) {\r\n    return new Enumerator_Seq(f);\r\n}\r\n\r\nexport class Enumerator_FromFunctions$1 {\r\n    constructor(current, next, dispose) {\r\n        this.current = current;\r\n        this.next = next;\r\n        this.dispose = dispose;\r\n    }\r\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current();\r\n    }\r\n    [\"System.Collections.IEnumerator.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current();\r\n    }\r\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n        const __ = this;\r\n        return __.next();\r\n    }\r\n    [\"System.Collections.IEnumerator.Reset\"]() {\r\n        Enumerator_noReset();\r\n    }\r\n    Dispose() {\r\n        const __ = this;\r\n        __.dispose();\r\n    }\r\n}\r\n\r\nexport function Enumerator_FromFunctions$1$reflection(gen0) {\r\n    return class_type(\"SeqModule.Enumerator.FromFunctions`1\", [gen0], Enumerator_FromFunctions$1);\r\n}\r\n\r\nexport function Enumerator_FromFunctions$1_$ctor_58C54629(current, next, dispose) {\r\n    return new Enumerator_FromFunctions$1(current, next, dispose);\r\n}\r\n\r\nexport function Enumerator_cast(e) {\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e[\"System.Collections.IEnumerator.get_Current\"](), () => e[\"System.Collections.IEnumerator.MoveNext\"](), () => {\r\n        if (isDisposable(e)) {\r\n            e.Dispose();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_concat(sources) {\r\n    let outerOpt = void 0;\r\n    let innerOpt = void 0;\r\n    let started = false;\r\n    let finished = false;\r\n    let curr = void 0;\r\n    const finish = () => {\r\n        finished = true;\r\n        if (innerOpt != null) {\r\n            const inner = innerOpt;\r\n            try {\r\n                inner.Dispose();\r\n            }\r\n            finally {\r\n                innerOpt = (void 0);\r\n            }\r\n        }\r\n        if (outerOpt != null) {\r\n            const outer = outerOpt;\r\n            try {\r\n                outer.Dispose();\r\n            }\r\n            finally {\r\n                outerOpt = (void 0);\r\n            }\r\n        }\r\n    };\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (!started) {\r\n            Enumerator_notStarted();\r\n        }\r\n        else if (finished) {\r\n            Enumerator_alreadyFinished();\r\n        }\r\n        if (curr != null) {\r\n            return value_1(curr);\r\n        }\r\n        else {\r\n            return Enumerator_alreadyFinished();\r\n        }\r\n    }, () => {\r\n        let copyOfStruct;\r\n        if (!started) {\r\n            started = true;\r\n        }\r\n        if (finished) {\r\n            return false;\r\n        }\r\n        else {\r\n            let res = void 0;\r\n            while (res == null) {\r\n                const matchValue = [outerOpt, innerOpt];\r\n                if (matchValue[0] != null) {\r\n                    if (matchValue[1] != null) {\r\n                        const inner_1 = matchValue[1];\r\n                        if (inner_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            curr = some(inner_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                            res = true;\r\n                        }\r\n                        else {\r\n                            try {\r\n                                inner_1.Dispose();\r\n                            }\r\n                            finally {\r\n                                innerOpt = (void 0);\r\n                            }\r\n                        }\r\n                    }\r\n                    else {\r\n                        const outer_1 = matchValue[0];\r\n                        if (outer_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            const ie = outer_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                            innerOpt = ((copyOfStruct = ie, getEnumerator(copyOfStruct)));\r\n                        }\r\n                        else {\r\n                            finish();\r\n                            res = false;\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    outerOpt = getEnumerator(sources);\r\n                }\r\n            }\r\n            return value_1(res);\r\n        }\r\n    }, () => {\r\n        if (!finished) {\r\n            finish();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_enumerateThenFinally(f, e) {\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), () => e[\"System.Collections.IEnumerator.MoveNext\"](), () => {\r\n        try {\r\n            e.Dispose();\r\n        }\r\n        finally {\r\n            f();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_generateWhileSome(openf, compute, closef) {\r\n    let started = false;\r\n    let curr = void 0;\r\n    let state = some(openf());\r\n    const dispose = () => {\r\n        if (state != null) {\r\n            const x_1 = value_1(state);\r\n            try {\r\n                closef(x_1);\r\n            }\r\n            finally {\r\n                state = (void 0);\r\n            }\r\n        }\r\n    };\r\n    const finish = () => {\r\n        try {\r\n            dispose();\r\n        }\r\n        finally {\r\n            curr = (void 0);\r\n        }\r\n    };\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (!started) {\r\n            Enumerator_notStarted();\r\n        }\r\n        if (curr != null) {\r\n            return value_1(curr);\r\n        }\r\n        else {\r\n            return Enumerator_alreadyFinished();\r\n        }\r\n    }, () => {\r\n        if (!started) {\r\n            started = true;\r\n        }\r\n        if (state != null) {\r\n            const s = value_1(state);\r\n            let matchValue_1;\r\n            try {\r\n                matchValue_1 = compute(s);\r\n            }\r\n            catch (matchValue) {\r\n                finish();\r\n                throw matchValue;\r\n            }\r\n            if (matchValue_1 != null) {\r\n                curr = matchValue_1;\r\n                return true;\r\n            }\r\n            else {\r\n                finish();\r\n                return false;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, dispose);\r\n}\r\n\r\nexport function Enumerator_unfold(f, state) {\r\n    let curr = void 0;\r\n    let acc = state;\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (curr != null) {\r\n            const x = curr[0];\r\n            const st = curr[1];\r\n            return x;\r\n        }\r\n        else {\r\n            return Enumerator_notStarted();\r\n        }\r\n    }, () => {\r\n        curr = f(acc);\r\n        if (curr != null) {\r\n            const x_1 = curr[0];\r\n            const st_1 = curr[1];\r\n            acc = st_1;\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, () => {\r\n    });\r\n}\r\n\r\nexport function indexNotFound() {\r\n    throw (new Error(SR_keyNotFoundAlt));\r\n}\r\n\r\nexport function checkNonNull(argName, arg) {\r\n    if (arg == null) {\r\n        Operators_NullArg(argName);\r\n    }\r\n}\r\n\r\nexport function mkSeq(f) {\r\n    return Enumerator_Seq_$ctor_673A07F2(f);\r\n}\r\n\r\nexport function ofSeq(xs) {\r\n    checkNonNull(\"source\", xs);\r\n    return getEnumerator(xs);\r\n}\r\n\r\nexport function delay(generator) {\r\n    return mkSeq(() => getEnumerator(generator()));\r\n}\r\n\r\nexport function concat(sources) {\r\n    return mkSeq(() => Enumerator_concat(sources));\r\n}\r\n\r\nexport function unfold(generator, state) {\r\n    return mkSeq(() => Enumerator_unfold(generator, state));\r\n}\r\n\r\nexport function empty() {\r\n    return delay(() => (new Array(0)));\r\n}\r\n\r\nexport function singleton(x) {\r\n    return delay(() => singleton_1(x));\r\n}\r\n\r\nexport function ofArray(arr) {\r\n    return arr;\r\n}\r\n\r\nexport function toArray(xs) {\r\n    if (xs instanceof FSharpList) {\r\n        return toArray_1(xs);\r\n    }\r\n    else {\r\n        return Array.from(xs);\r\n    }\r\n}\r\n\r\nexport function ofList(xs) {\r\n    return xs;\r\n}\r\n\r\nexport function toList(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return ofArray_1(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return xs;\r\n    }\r\n    else {\r\n        return ofSeq_1(xs);\r\n    }\r\n}\r\n\r\nexport function generate(create, compute, dispose) {\r\n    return mkSeq(() => Enumerator_generateWhileSome(create, compute, dispose));\r\n}\r\n\r\nexport function generateIndexed(create, compute, dispose) {\r\n    return mkSeq(() => {\r\n        let i = -1;\r\n        return Enumerator_generateWhileSome(create, (x) => {\r\n            i = ((i + 1) | 0);\r\n            return compute(i, x);\r\n        }, dispose);\r\n    });\r\n}\r\n\r\nexport function append(xs, ys) {\r\n    return concat([xs, ys]);\r\n}\r\n\r\nexport function cast(xs) {\r\n    return mkSeq(() => {\r\n        checkNonNull(\"source\", xs);\r\n        return Enumerator_cast(getEnumerator(xs));\r\n    });\r\n}\r\n\r\nexport function choose(chooser, xs) {\r\n    return generate(() => ofSeq(xs), (e) => {\r\n        let curr = void 0;\r\n        while ((curr == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            curr = chooser(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return curr;\r\n    }, (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function compareWith(comparer, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let c = 0;\r\n            let b1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n            let b2 = e2[\"System.Collections.IEnumerator.MoveNext\"]();\r\n            while (((c === 0) && b1) && b2) {\r\n                c = (comparer(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) | 0);\r\n                if (c === 0) {\r\n                    b1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                    b2 = e2[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                }\r\n            }\r\n            return ((c !== 0) ? c : (b1 ? 1 : (b2 ? -1 : 0))) | 0;\r\n        }\r\n        finally {\r\n            e2.Dispose();\r\n        }\r\n    }\r\n    finally {\r\n        e1.Dispose();\r\n    }\r\n}\r\n\r\nexport function contains(value, xs, comparer) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let found = false;\r\n        while ((!found) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            found = comparer.Equals(value, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return found;\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function enumerateFromFunctions(create, moveNext, current) {\r\n    return generate(create, (x) => (moveNext(x) ? some(current(x)) : (void 0)), (x_1) => {\r\n        const matchValue = x_1;\r\n        if (isDisposable(matchValue)) {\r\n            matchValue.Dispose();\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateThenFinally(source, compensation) {\r\n    const compensation_1 = compensation;\r\n    return mkSeq(() => {\r\n        try {\r\n            return Enumerator_enumerateThenFinally(compensation_1, ofSeq(source));\r\n        }\r\n        catch (matchValue) {\r\n            compensation_1();\r\n            throw matchValue;\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateUsing(resource, source) {\r\n    const compensation = () => {\r\n        if (equals(resource, null)) {\r\n        }\r\n        else {\r\n            let copyOfStruct = resource;\r\n            copyOfStruct.Dispose();\r\n        }\r\n    };\r\n    return mkSeq(() => {\r\n        try {\r\n            return Enumerator_enumerateThenFinally(compensation, ofSeq(source(resource)));\r\n        }\r\n        catch (matchValue_1) {\r\n            compensation();\r\n            throw matchValue_1;\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateWhile(guard, xs) {\r\n    return concat(unfold((i) => (guard() ? [xs, i + 1] : (void 0)), 0));\r\n}\r\n\r\nexport function filter(f, xs) {\r\n    return choose((x) => {\r\n        if (f(x)) {\r\n            return some(x);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, xs);\r\n}\r\n\r\nexport function exists(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let found = false;\r\n        while ((!found) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            found = predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return found;\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function exists2(predicate, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let found = false;\r\n            while (((!found) && e1[\"System.Collections.IEnumerator.MoveNext\"]()) && e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                found = predicate(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            return found;\r\n        }\r\n        finally {\r\n            e2.Dispose();\r\n        }\r\n    }\r\n    finally {\r\n        e1.Dispose();\r\n    }\r\n}\r\n\r\nexport function exactlyOne(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const v = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                throw (new Error((SR_inputSequenceTooLong + \"\\\\nParameter name: \") + \"source\"));\r\n            }\r\n            else {\r\n                return v;\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n        }\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const v = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? (void 0) : some(v);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function tryFind(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let res = void 0;\r\n        while ((res == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const c = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            if (predicate(c)) {\r\n                res = some(c);\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function find(predicate, xs) {\r\n    const matchValue = tryFind(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindBack(predicate, xs) {\r\n    return tryFindBack_1(predicate, toArray(xs));\r\n}\r\n\r\nexport function findBack(predicate, xs) {\r\n    const matchValue = tryFindBack(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (i_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const i = i_mut;\r\n                if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    if (predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) {\r\n                        return i;\r\n                    }\r\n                    else {\r\n                        i_mut = (i + 1);\r\n                        continue loop;\r\n                    }\r\n                }\r\n                else {\r\n                    return void 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(0);\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function findIndex(predicate, xs) {\r\n    const matchValue = tryFindIndex(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound() | 0;\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndexBack(predicate, xs) {\r\n    return tryFindIndexBack_1(predicate, toArray(xs));\r\n}\r\n\r\nexport function findIndexBack(predicate, xs) {\r\n    const matchValue = tryFindIndexBack(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound() | 0;\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function fold(folder, state, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let acc = state;\r\n        while (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            acc = folder(acc, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return acc;\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function foldBack(folder, xs, state) {\r\n    return foldBack_1(folder, toArray(xs), state);\r\n}\r\n\r\nexport function fold2(folder, state, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let acc = state;\r\n            while (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                acc = folder(acc, e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            return acc;\r\n        }\r\n        finally {\r\n            e2.Dispose();\r\n        }\r\n    }\r\n    finally {\r\n        e1.Dispose();\r\n    }\r\n}\r\n\r\nexport function foldBack2(folder, xs, ys, state) {\r\n    return foldBack2_1(folder, toArray(xs), toArray(ys), state);\r\n}\r\n\r\nexport function forAll(predicate, xs) {\r\n    return !exists((x) => (!predicate(x)), xs);\r\n}\r\n\r\nexport function forAll2(predicate, xs, ys) {\r\n    return !exists2((x, y) => (!predicate(x, y)), xs, ys);\r\n}\r\n\r\nexport function tryHead(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return tryHead_1(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return tryHead_2(xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n        finally {\r\n            e.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport function head(xs) {\r\n    const matchValue = tryHead(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function initialize(count, f) {\r\n    return unfold((i) => ((i < count) ? [f(i), i + 1] : (void 0)), 0);\r\n}\r\n\r\nexport function initializeInfinite(f) {\r\n    return initialize(2147483647, f);\r\n}\r\n\r\nexport function isEmpty(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return xs.length === 0;\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return isEmpty_1(xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            return !e[\"System.Collections.IEnumerator.MoveNext\"]();\r\n        }\r\n        finally {\r\n            e.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport function tryItem(index, xs) {\r\n    if (isArrayLike(xs)) {\r\n        return tryItem_1(index, xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return tryItem_2(index, xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            const loop = (index_1_mut) => {\r\n                loop:\r\n                while (true) {\r\n                    const index_1 = index_1_mut;\r\n                    if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        return void 0;\r\n                    }\r\n                    else if (index_1 === 0) {\r\n                        return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                    }\r\n                    else {\r\n                        index_1_mut = (index_1 - 1);\r\n                        continue loop;\r\n                    }\r\n                    break;\r\n                }\r\n            };\r\n            return loop(index);\r\n        }\r\n        finally {\r\n            e.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport function item(index, xs) {\r\n    const matchValue = tryItem(index, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function iterate(action, xs) {\r\n    fold((unitVar0, x) => {\r\n        action(x);\r\n    }, void 0, xs);\r\n}\r\n\r\nexport function iterate2(action, xs, ys) {\r\n    fold2((unitVar0, x, y) => {\r\n        action(x, y);\r\n    }, void 0, xs, ys);\r\n}\r\n\r\nexport function iterateIndexed(action, xs) {\r\n    fold((i, x) => {\r\n        action(i, x);\r\n        return (i + 1) | 0;\r\n    }, 0, xs);\r\n}\r\n\r\nexport function iterateIndexed2(action, xs, ys) {\r\n    fold2((i, x, y) => {\r\n        action(i, x, y);\r\n        return (i + 1) | 0;\r\n    }, 0, xs, ys);\r\n}\r\n\r\nexport function tryLast(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (acc_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const acc = acc_mut;\r\n                if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    return acc;\r\n                }\r\n                else {\r\n                    acc_mut = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                    continue loop;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(loop(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function last(xs) {\r\n    const matchValue = tryLast(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function length(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return xs.length | 0;\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return length_1(xs) | 0;\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            let count = 0;\r\n            while (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                count = ((count + 1) | 0);\r\n            }\r\n            return count | 0;\r\n        }\r\n        finally {\r\n            e.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport function map(mapping, xs) {\r\n    return generate(() => ofSeq(xs), (e) => (e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(mapping(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0)), (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function mapIndexed(mapping, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => (e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(mapping(i, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0)), (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function indexed(xs) {\r\n    return mapIndexed((i, x) => [i, x], xs);\r\n}\r\n\r\nexport function map2(mapping, xs, ys) {\r\n    return generate(() => [ofSeq(xs), ofSeq(ys)], (tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        return (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            tupledArg_1[0].Dispose();\r\n        }\r\n        finally {\r\n            tupledArg_1[1].Dispose();\r\n        }\r\n    });\r\n}\r\n\r\nexport function mapIndexed2(mapping, xs, ys) {\r\n    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        return (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(i, e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            tupledArg_1[0].Dispose();\r\n        }\r\n        finally {\r\n            tupledArg_1[1].Dispose();\r\n        }\r\n    });\r\n}\r\n\r\nexport function map3(mapping, xs, ys, zs) {\r\n    return generate(() => [ofSeq(xs), ofSeq(ys), ofSeq(zs)], (tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        const e3 = tupledArg[2];\r\n        return ((e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) && e3[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e3[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            tupledArg_1[0].Dispose();\r\n        }\r\n        finally {\r\n            try {\r\n                tupledArg_1[1].Dispose();\r\n            }\r\n            finally {\r\n                tupledArg_1[2].Dispose();\r\n            }\r\n        }\r\n    });\r\n}\r\n\r\nexport function readOnly(xs) {\r\n    checkNonNull(\"source\", xs);\r\n    return map((x) => x, xs);\r\n}\r\n\r\nexport class CachedSeq$1 {\r\n    constructor(cleanup, res) {\r\n        this.cleanup = cleanup;\r\n        this.res = res;\r\n    }\r\n    Dispose() {\r\n        const _ = this;\r\n        _.cleanup();\r\n    }\r\n    GetEnumerator() {\r\n        const _ = this;\r\n        return getEnumerator(_.res);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const _ = this;\r\n        return getEnumerator(_.res);\r\n    }\r\n}\r\n\r\nexport function CachedSeq$1$reflection(gen0) {\r\n    return class_type(\"SeqModule.CachedSeq`1\", [gen0], CachedSeq$1);\r\n}\r\n\r\nexport function CachedSeq$1_$ctor_Z7A8347D4(cleanup, res) {\r\n    return new CachedSeq$1(cleanup, res);\r\n}\r\n\r\nexport function CachedSeq$1__Clear(_) {\r\n    _.cleanup();\r\n}\r\n\r\nexport function cache(source) {\r\n    checkNonNull(\"source\", source);\r\n    const prefix = [];\r\n    let enumeratorR = void 0;\r\n    return CachedSeq$1_$ctor_Z7A8347D4(() => {\r\n        clear(prefix);\r\n        let pattern_matching_result, e;\r\n        if (enumeratorR != null) {\r\n            if (value_1(enumeratorR) != null) {\r\n                pattern_matching_result = 0;\r\n                e = value_1(enumeratorR);\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                e.Dispose();\r\n                break;\r\n            }\r\n        }\r\n        enumeratorR = (void 0);\r\n    }, unfold((i_1) => {\r\n        if (i_1 < prefix.length) {\r\n            return [prefix[i_1], i_1 + 1];\r\n        }\r\n        else {\r\n            if (i_1 >= prefix.length) {\r\n                let optEnumerator_2;\r\n                if (enumeratorR != null) {\r\n                    optEnumerator_2 = value_1(enumeratorR);\r\n                }\r\n                else {\r\n                    const optEnumerator = getEnumerator(source);\r\n                    enumeratorR = some(optEnumerator);\r\n                    optEnumerator_2 = optEnumerator;\r\n                }\r\n                if (optEnumerator_2 == null) {\r\n                }\r\n                else {\r\n                    const enumerator = optEnumerator_2;\r\n                    if (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        void (prefix.push(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()));\r\n                    }\r\n                    else {\r\n                        enumerator.Dispose();\r\n                        enumeratorR = some(void 0);\r\n                    }\r\n                }\r\n            }\r\n            return (i_1 < prefix.length) ? [prefix[i_1], i_1 + 1] : (void 0);\r\n        }\r\n    }, 0));\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const ysCache = cache(ys);\r\n    return delay(() => concat(map((x) => map((y) => [x, y], ysCache), xs)));\r\n}\r\n\r\nexport function mapFold(mapping, state, xs) {\r\n    const patternInput = mapFold_1(mapping, state, toArray(xs));\r\n    return [readOnly(patternInput[0]), patternInput[1]];\r\n}\r\n\r\nexport function mapFoldBack(mapping, xs, state) {\r\n    const patternInput = mapFoldBack_1(mapping, toArray(xs), state);\r\n    return [readOnly(patternInput[0]), patternInput[1]];\r\n}\r\n\r\nexport function tryPick(chooser, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let res = void 0;\r\n        while ((res == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            res = chooser(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return res;\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function pick(chooser, xs) {\r\n    const matchValue = tryPick(chooser, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function reduce(folder, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (acc_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const acc = acc_mut;\r\n                if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    acc_mut = folder(acc, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return acc;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return loop(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else {\r\n            throw (new Error(SR_inputSequenceEmpty));\r\n        }\r\n    }\r\n    finally {\r\n        e.Dispose();\r\n    }\r\n}\r\n\r\nexport function reduceBack(folder, xs) {\r\n    const arr = toArray(xs);\r\n    if (arr.length > 0) {\r\n        return arr.reduceRight(folder);\r\n    }\r\n    else {\r\n        throw (new Error(SR_inputSequenceEmpty));\r\n    }\r\n}\r\n\r\nexport function replicate(n, x) {\r\n    return initialize(n, (_arg1) => x);\r\n}\r\n\r\nexport function reverse(xs) {\r\n    return delay(() => ofArray(reverse_1(toArray(xs))));\r\n}\r\n\r\nexport function scan(folder, state, xs) {\r\n    return delay(() => {\r\n        let acc = state;\r\n        return concat([singleton(state), map((x) => {\r\n            acc = folder(acc, x);\r\n            return acc;\r\n        }, xs)]);\r\n    });\r\n}\r\n\r\nexport function scanBack(folder, xs, state) {\r\n    return delay(() => ofArray(scanBack_1(folder, toArray(xs), state)));\r\n}\r\n\r\nexport function skip(count, source) {\r\n    return mkSeq(() => {\r\n        const e = ofSeq(source);\r\n        try {\r\n            for (let _ = 1; _ <= count; _++) {\r\n                if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n                }\r\n            }\r\n            return Enumerator_enumerateThenFinally(() => {\r\n            }, e);\r\n        }\r\n        catch (matchValue) {\r\n            e.Dispose();\r\n            throw matchValue;\r\n        }\r\n    });\r\n}\r\n\r\nexport function skipWhile(predicate, xs) {\r\n    return delay(() => {\r\n        let skipped = true;\r\n        return filter((x) => {\r\n            if (skipped) {\r\n                skipped = predicate(x);\r\n            }\r\n            return !skipped;\r\n        }, xs);\r\n    });\r\n}\r\n\r\nexport function tail(xs) {\r\n    return skip(1, xs);\r\n}\r\n\r\nexport function take(count, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if (i < count) {\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function takeWhile(predicate, xs) {\r\n    return generate(() => ofSeq(xs), (e) => ((e[\"System.Collections.IEnumerator.MoveNext\"]() && predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0)), (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function truncate(count, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => (((i < count) && e[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0)), (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function zip(xs, ys) {\r\n    return map2((x, y) => [x, y], xs, ys);\r\n}\r\n\r\nexport function zip3(xs, ys, zs) {\r\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\r\n}\r\n\r\nexport function collect(mapping, xs) {\r\n    return delay(() => concat(map(mapping, xs)));\r\n}\r\n\r\nexport function where(predicate, xs) {\r\n    return filter(predicate, xs);\r\n}\r\n\r\nexport function pairwise(xs) {\r\n    return delay(() => ofArray(pairwise_1(toArray(xs))));\r\n}\r\n\r\nexport function splitInto(chunks, xs) {\r\n    return delay(() => ofArray(map_1((arr) => ofArray(arr), splitInto_1(chunks, toArray(xs)))));\r\n}\r\n\r\nexport function windowed(windowSize, xs) {\r\n    return delay(() => ofArray(map_1((arr) => ofArray(arr), windowed_1(windowSize, toArray(xs)))));\r\n}\r\n\r\nexport function transpose(xss) {\r\n    return delay(() => ofArray(map_1((arr) => ofArray(arr), transpose_1(map_1((xs_1) => toArray(xs_1), toArray(xss))))));\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    return delay(() => {\r\n        const arr = toArray(xs);\r\n        arr.sort(comparer);\r\n        return ofArray(arr);\r\n    });\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(x, y), xs);\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);\r\n}\r\n\r\nexport function sum(xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\r\n}\r\n\r\nexport function sumBy(f, xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, x);\r\n    }, averager.GetZero(), xs);\r\n    if (count === 0) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return averager.DivideByInt(total, count);\r\n    }\r\n}\r\n\r\nexport function averageBy(f, xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, f(x));\r\n    }, averager.GetZero(), xs);\r\n    if (count === 0) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return averager.DivideByInt(total, count);\r\n    }\r\n}\r\n\r\nexport function permute(f, xs) {\r\n    return delay(() => ofArray(permute_1(f, toArray(xs))));\r\n}\r\n\r\nexport function chunkBySize(chunkSize, xs) {\r\n    return delay(() => ofArray(map_1((arr) => ofArray(arr), chunkBySize_1(chunkSize, toArray(xs)))));\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if (i === index) {\r\n            isDone = true;\r\n            return some(y);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    let status = -1;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        if (i === index) {\r\n            status = 0;\r\n        }\r\n        let inserted;\r\n        if (status === 0) {\r\n            if (e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                inserted = some(e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                status = 1;\r\n                inserted = (void 0);\r\n            }\r\n        }\r\n        else {\r\n            inserted = (void 0);\r\n        }\r\n        if (inserted == null) {\r\n            if (e1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                if (status < 1) {\r\n                    throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n                }\r\n                return void 0;\r\n            }\r\n        }\r\n        else {\r\n            return some(value_1(inserted));\r\n        }\r\n    }, (tupledArg_1) => {\r\n        tupledArg_1[0].Dispose();\r\n        tupledArg_1[1].Dispose();\r\n    });\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if ((i === index) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            isDone = true;\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if (i < index) {\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n        }\r\n        else {\r\n            if (i === index) {\r\n                for (let _ = 1; _ <= count; _++) {\r\n                    if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"count\"));\r\n                    }\r\n                }\r\n            }\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n    }, (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if ((i === index) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            isDone = true;\r\n            return some(y);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        e_1.Dispose();\r\n    });\r\n}\r\n\r\n","import { compare } from \"./Util.js\";\r\nimport { unfold, delay } from \"./Seq.js\";\r\nimport { op_Addition, fromZero } from \"./BigInt.js\";\r\nimport { op_Addition as op_Addition_1, fromParts } from \"./Decimal.js\";\r\nimport { op_Addition as op_Addition_2, fromBits } from \"./Long.js\";\r\n\r\nexport function makeRangeStepFunction(step, stop, zero, add) {\r\n    const stepComparedWithZero = compare(step, zero) | 0;\r\n    if (stepComparedWithZero === 0) {\r\n        throw (new Error(\"The step of a range cannot be zero\"));\r\n    }\r\n    const stepGreaterThanZero = stepComparedWithZero > 0;\r\n    return (x) => {\r\n        const comparedWithLast = compare(x, stop) | 0;\r\n        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : ((!stepGreaterThanZero) && (comparedWithLast >= 0))) ? [x, add(x, step)] : (void 0);\r\n    };\r\n}\r\n\r\nexport function integralRangeStep(start, step, stop, zero, add) {\r\n    const stepFn = makeRangeStepFunction(step, stop, zero, add);\r\n    return delay(() => unfold(stepFn, start));\r\n}\r\n\r\nexport function rangeBigInt(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromZero(), (x, y) => op_Addition(x, y));\r\n}\r\n\r\nexport function rangeDecimal(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), (x, y) => op_Addition_1(x, y));\r\n}\r\n\r\nexport function rangeDouble(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));\r\n}\r\n\r\nexport function rangeInt64(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromBits(0, 0, false), (x, y) => op_Addition_2(x, y));\r\n}\r\n\r\nexport function rangeUInt64(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromBits(0, 0, true), (x, y) => op_Addition_2(x, y));\r\n}\r\n\r\nexport function rangeChar(start, stop) {\r\n    const intStop = stop.charCodeAt(0) | 0;\r\n    return delay(() => unfold((c) => {\r\n        if (c <= intStop) {\r\n            return [String.fromCharCode(c), c + 1];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, start.charCodeAt(0)));\r\n}\r\n\r\n","import { Union } from \"../fable-library.3.6.3/Types.js\";\nimport { class_type, union_type, int32_type, array_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { fill } from \"../fable-library.3.6.3/Array.js\";\nimport { comparePrimitives, max } from \"../fable-library.3.6.3/Util.js\";\nimport { some } from \"../fable-library.3.6.3/Option.js\";\nimport { singleton, collect, take, skip, append, delay } from \"../fable-library.3.6.3/Seq.js\";\nimport { rangeDouble } from \"../fable-library.3.6.3/Range.js\";\n\nexport class RingState$1 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Writable\", \"ReadWritable\"];\n    }\n}\n\nexport function RingState$1$reflection(gen0) {\n    return union_type(\"Elmish.RingState`1\", [gen0], RingState$1, () => [[[\"wx\", array_type(gen0)], [\"ix\", int32_type]], [[\"rw\", array_type(gen0)], [\"wix\", int32_type], [\"rix\", int32_type]]]);\n}\n\nexport class RingBuffer$1 {\n    constructor(size) {\n        this.state = (new RingState$1(0, fill(new Array(max((x, y) => comparePrimitives(x, y), size, 10)), 0, max((x, y) => comparePrimitives(x, y), size, 10), null), 0));\n    }\n}\n\nexport function RingBuffer$1$reflection(gen0) {\n    return class_type(\"Elmish.RingBuffer`1\", [gen0], RingBuffer$1);\n}\n\nexport function RingBuffer$1_$ctor_Z524259A4(size) {\n    return new RingBuffer$1(size);\n}\n\nexport function RingBuffer$1__Pop(__) {\n    const matchValue = __.state;\n    if (matchValue.tag === 1) {\n        const wix = matchValue.fields[1] | 0;\n        const rix = matchValue.fields[2] | 0;\n        const items = matchValue.fields[0];\n        const rix$0027 = ((rix + 1) % items.length) | 0;\n        if (rix$0027 === wix) {\n            __.state = (new RingState$1(0, items, wix));\n        }\n        else {\n            __.state = (new RingState$1(1, items, wix, rix$0027));\n        }\n        return some(items[rix]);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function RingBuffer$1__Push_2B595(__, item) {\n    const matchValue = __.state;\n    if (matchValue.tag === 1) {\n        const wix_1 = matchValue.fields[1] | 0;\n        const rix = matchValue.fields[2] | 0;\n        const items_1 = matchValue.fields[0];\n        items_1[wix_1] = item;\n        const wix$0027 = ((wix_1 + 1) % items_1.length) | 0;\n        if (wix$0027 === rix) {\n            __.state = (new RingState$1(1, RingBuffer$1__doubleSize(__, rix, items_1), items_1.length, 0));\n        }\n        else {\n            __.state = (new RingState$1(1, items_1, wix$0027, rix));\n        }\n    }\n    else {\n        const ix = matchValue.fields[1] | 0;\n        const items = matchValue.fields[0];\n        items[ix] = item;\n        const wix = ((ix + 1) % items.length) | 0;\n        __.state = (new RingState$1(1, items, wix, ix));\n    }\n}\n\nfunction RingBuffer$1__doubleSize(this$, ix, items) {\n    return Array.from(delay(() => append(skip(ix, items), delay(() => append(take(ix, items), delay(() => collect((matchValue) => singleton(null), rangeDouble(0, 1, items.length))))))));\n}\n\n","import { Record } from \"../fable-library.3.6.3/Types.js\";\nimport { record_type, class_type, string_type, tuple_type, list_type, lambda_type, unit_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { Cmd_exec, Cmd_batch, Cmd_none } from \"./cmd.fs.js\";\nimport { Log_toConsole, Log_onError } from \"./prelude.fs.js\";\nimport { curry, partialApply, uncurry } from \"../fable-library.3.6.3/Util.js\";\nimport { ofArray } from \"../fable-library.3.6.3/List.js\";\nimport { RingBuffer$1__Pop, RingBuffer$1__Push_2B595, RingBuffer$1_$ctor_Z524259A4 } from \"./ring.fs.js\";\nimport { value as value_1, some } from \"../fable-library.3.6.3/Option.js\";\nimport { printf, toText } from \"../fable-library.3.6.3/String.js\";\n\nexport class Program$4 extends Record {\n    constructor(init, update, subscribe, view, setState, onError, syncDispatch) {\n        super();\n        this.init = init;\n        this.update = update;\n        this.subscribe = subscribe;\n        this.view = view;\n        this.setState = setState;\n        this.onError = onError;\n        this.syncDispatch = syncDispatch;\n    }\n}\n\nexport function Program$4$reflection(gen0, gen1, gen2, gen3) {\n    return record_type(\"Elmish.Program`4\", [gen0, gen1, gen2, gen3], Program$4, () => [[\"init\", lambda_type(gen0, tuple_type(gen1, list_type(lambda_type(lambda_type(gen2, unit_type), unit_type))))], [\"update\", lambda_type(gen2, lambda_type(gen1, tuple_type(gen1, list_type(lambda_type(lambda_type(gen2, unit_type), unit_type)))))], [\"subscribe\", lambda_type(gen1, list_type(lambda_type(lambda_type(gen2, unit_type), unit_type)))], [\"view\", lambda_type(gen1, lambda_type(lambda_type(gen2, unit_type), gen3))], [\"setState\", lambda_type(gen1, lambda_type(lambda_type(gen2, unit_type), unit_type))], [\"onError\", lambda_type(tuple_type(string_type, class_type(\"System.Exception\")), unit_type)], [\"syncDispatch\", lambda_type(lambda_type(gen2, unit_type), lambda_type(gen2, unit_type))]]);\n}\n\nexport function ProgramModule_mkProgram(init, update, view) {\n    return new Program$4(init, update, (_arg1) => Cmd_none(), view, (model, arg) => {\n        view(model, arg);\n    }, (tupledArg) => {\n        Log_onError(tupledArg[0], tupledArg[1]);\n    }, uncurry(2, (x) => x));\n}\n\nexport function ProgramModule_mkSimple(init, update, view) {\n    return new Program$4((arg) => [init(arg), Cmd_none()], (msg, arg_1) => [update(msg, arg_1), Cmd_none()], (_arg1) => Cmd_none(), view, (model, arg_2) => {\n        view(model, arg_2);\n    }, (tupledArg) => {\n        Log_onError(tupledArg[0], tupledArg[1]);\n    }, uncurry(2, (x) => x));\n}\n\nexport function ProgramModule_withSubscription(subscribe, program) {\n    return new Program$4(program.init, program.update, (model) => Cmd_batch(ofArray([program.subscribe(model), subscribe(model)])), program.view, program.setState, program.onError, program.syncDispatch);\n}\n\nexport function ProgramModule_withConsoleTrace(program) {\n    return new Program$4((arg) => {\n        const patternInput = program.init(arg);\n        const initModel = patternInput[0];\n        Log_toConsole(\"Initial state:\", initModel);\n        return [initModel, patternInput[1]];\n    }, (msg, model) => {\n        Log_toConsole(\"New message:\", msg);\n        const patternInput_1 = program.update(msg, model);\n        const newModel = patternInput_1[0];\n        Log_toConsole(\"Updated state:\", newModel);\n        return [newModel, patternInput_1[1]];\n    }, program.subscribe, program.view, program.setState, program.onError, program.syncDispatch);\n}\n\nexport function ProgramModule_withTrace(trace, program) {\n    return new Program$4(program.init, (msg, model) => {\n        const patternInput = program.update(msg, model);\n        const state = patternInput[0];\n        trace(msg, state);\n        return [state, patternInput[1]];\n    }, program.subscribe, program.view, program.setState, program.onError, program.syncDispatch);\n}\n\nexport function ProgramModule_withErrorHandler(onError, program) {\n    return new Program$4(program.init, program.update, program.subscribe, program.view, program.setState, onError, program.syncDispatch);\n}\n\nexport function ProgramModule_mapErrorHandler(map, program) {\n    return new Program$4(program.init, program.update, program.subscribe, program.view, program.setState, partialApply(1, map, [program.onError]), program.syncDispatch);\n}\n\nexport function ProgramModule_onError(program) {\n    return program.onError;\n}\n\nexport function ProgramModule_withSetState(setState, program) {\n    return new Program$4(program.init, program.update, program.subscribe, program.view, setState, program.onError, program.syncDispatch);\n}\n\nexport function ProgramModule_setState(program) {\n    return curry(2, program.setState);\n}\n\nexport function ProgramModule_view(program) {\n    return curry(2, program.view);\n}\n\nexport function ProgramModule_withSyncDispatch(syncDispatch, program) {\n    return new Program$4(program.init, program.update, program.subscribe, program.view, program.setState, program.onError, syncDispatch);\n}\n\nexport function ProgramModule_map(mapInit, mapUpdate, mapView, mapSetState, mapSubscribe, program) {\n    const init = partialApply(1, mapInit, [program.init]);\n    const update = partialApply(2, mapUpdate, [program.update]);\n    const view = partialApply(2, mapView, [program.view]);\n    const setState = partialApply(2, mapSetState, [program.setState]);\n    return new Program$4(init, uncurry(2, update), partialApply(1, mapSubscribe, [program.subscribe]), uncurry(2, view), uncurry(2, setState), program.onError, uncurry(2, (x) => x));\n}\n\nexport function ProgramModule_runWith(arg, program) {\n    const patternInput = program.init(arg);\n    const model = patternInput[0];\n    const rb = RingBuffer$1_$ctor_Z524259A4(10);\n    let reentered = false;\n    let state = model;\n    const dispatch = (msg) => {\n        if (reentered) {\n            RingBuffer$1__Push_2B595(rb, msg);\n        }\n        else {\n            reentered = true;\n            let nextMsg = some(msg);\n            while (nextMsg != null) {\n                const msg_1 = value_1(nextMsg);\n                try {\n                    const patternInput_1 = program.update(msg_1, state);\n                    const model$0027 = patternInput_1[0];\n                    program.setState(model$0027, syncDispatch);\n                    Cmd_exec((ex) => {\n                        program.onError([toText(printf(\"Error in command while handling: %A\"))(msg_1), ex]);\n                    }, syncDispatch, patternInput_1[1]);\n                    state = model$0027;\n                }\n                catch (ex_1) {\n                    program.onError([toText(printf(\"Unable to process the message: %A\"))(msg_1), ex_1]);\n                }\n                nextMsg = RingBuffer$1__Pop(rb);\n            }\n            reentered = false;\n        }\n    };\n    const syncDispatch = partialApply(1, program.syncDispatch, [dispatch]);\n    program.setState(model, syncDispatch);\n    Cmd_exec((ex_3) => {\n        program.onError([\"Error intitializing:\", ex_3]);\n    }, syncDispatch, Cmd_batch(ofArray([(() => {\n        try {\n            return program.subscribe(model);\n        }\n        catch (ex_2) {\n            program.onError([\"Unable to subscribe:\", ex_2]);\n            return Cmd_none();\n        }\n    })(), patternInput[1]])));\n}\n\nexport function ProgramModule_run(program) {\n    ProgramModule_runWith(void 0, program);\n}\n\n","import { Record } from \"../fable-library.3.6.3/Types.js\";\nimport { obj_type, record_type, bool_type, lambda_type, class_type, unit_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { Component } from \"react\";\nimport * as react from \"react\";\nimport { equalArrays, equals } from \"../fable-library.3.6.3/Util.js\";\n\nexport class LazyProps$1 extends Record {\n    constructor(model, render, equal) {\n        super();\n        this.model = model;\n        this.render = render;\n        this.equal = equal;\n    }\n}\n\nexport function LazyProps$1$reflection(gen0) {\n    return record_type(\"Elmish.React.LazyProps`1\", [gen0], LazyProps$1, () => [[\"model\", gen0], [\"render\", lambda_type(unit_type, class_type(\"Fable.React.ReactElement\"))], [\"equal\", lambda_type(gen0, lambda_type(gen0, bool_type))]]);\n}\n\nexport class Components_LazyView$1 extends Component {\n    constructor(props) {\n        super(props);\n    }\n    shouldComponentUpdate(nextProps, _nextState) {\n        const this$ = this;\n        return !(this$.props).equal((this$.props).model, nextProps.model);\n    }\n    render() {\n        const this$ = this;\n        return (this$.props).render();\n    }\n}\n\nexport function Components_LazyView$1$reflection(gen0) {\n    return class_type(\"Elmish.React.Components.LazyView`1\", [gen0], Components_LazyView$1, class_type(\"Fable.React.Component`2\", [LazyProps$1$reflection(gen0), obj_type]));\n}\n\nexport function Components_LazyView$1_$ctor_Z7829D94B(props) {\n    return new Components_LazyView$1(props);\n}\n\nexport function Common_lazyViewWith(equal, view, state) {\n    return react.createElement(Components_LazyView$1, new LazyProps$1(state, () => view(state), equal));\n}\n\nexport function Common_lazyView2With(equal, view, state, dispatch) {\n    return react.createElement(Components_LazyView$1, new LazyProps$1(state, () => view(state, dispatch), equal));\n}\n\nexport function Common_lazyView3With(equal, view, state1, state2, dispatch) {\n    return react.createElement(Components_LazyView$1, new LazyProps$1([state1, state2], () => view(state1, state2, dispatch), equal));\n}\n\nexport function Common_lazyView(view) {\n    return (state) => Common_lazyViewWith((x, y) => equals(x, y), view, state);\n}\n\nexport function Common_lazyView2(view) {\n    return (state) => ((dispatch) => Common_lazyView2With((x, y) => equals(x, y), view, state, dispatch));\n}\n\nexport function Common_lazyView3(view) {\n    return (state1) => ((state2) => ((dispatch) => Common_lazyView3With((x, y) => equalArrays(x, y), view, state1, state2, dispatch)));\n}\n\n","import { Record, Union } from \"./Types.js\";\nimport { combineHashCodes, equalArraysWith, stringHash } from \"./Util.js\";\nimport Decimal from \"./Decimal.js\";\nimport { fromInt as int64FromInt } from \"./Long.js\";\nexport class CaseInfo {\n    constructor(declaringType, tag, name, fields) {\n        this.declaringType = declaringType;\n        this.tag = tag;\n        this.name = name;\n        this.fields = fields;\n    }\n}\nexport class MethodInfo {\n    constructor(name, parameters, returnType) {\n        this.name = name;\n        this.parameters = parameters;\n        this.returnType = returnType;\n    }\n}\nexport class TypeInfo {\n    constructor(fullname, generics, construct, parent, fields, cases, enumCases) {\n        this.fullname = fullname;\n        this.generics = generics;\n        this.construct = construct;\n        this.parent = parent;\n        this.fields = fields;\n        this.cases = cases;\n        this.enumCases = enumCases;\n    }\n    toString() {\n        return fullName(this);\n    }\n    GetHashCode() {\n        return getHashCode(this);\n    }\n    Equals(other) {\n        return equals(this, other);\n    }\n}\nexport class GenericParameter extends TypeInfo {\n    constructor(name) {\n        super(name);\n    }\n}\nexport function getGenerics(t) {\n    return t.generics != null ? t.generics : [];\n}\nexport function getHashCode(t) {\n    const fullnameHash = stringHash(t.fullname);\n    const genHashes = getGenerics(t).map(getHashCode);\n    return combineHashCodes([fullnameHash, ...genHashes]);\n}\nexport function equals(t1, t2) {\n    if (t1.fullname === \"\") { // Anonymous records\n        return t2.fullname === \"\"\n            && equalArraysWith(getRecordElements(t1), getRecordElements(t2), ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2));\n    }\n    else {\n        return t1.fullname === t2.fullname\n            && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);\n    }\n}\nexport function class_type(fullname, generics, construct, parent) {\n    return new TypeInfo(fullname, generics, construct, parent);\n}\nexport function record_type(fullname, generics, construct, fields) {\n    return new TypeInfo(fullname, generics, construct, undefined, fields);\n}\nexport function anonRecord_type(...fields) {\n    return new TypeInfo(\"\", undefined, undefined, undefined, () => fields);\n}\nexport function union_type(fullname, generics, construct, cases) {\n    const t = new TypeInfo(fullname, generics, construct, undefined, undefined, () => {\n        const caseNames = construct.prototype.cases();\n        return cases().map((fields, i) => new CaseInfo(t, i, caseNames[i], fields));\n    });\n    return t;\n}\nexport function tuple_type(...generics) {\n    return new TypeInfo(\"System.Tuple`\" + generics.length, generics);\n}\nexport function delegate_type(...generics) {\n    return new TypeInfo(\"System.Func`\" + generics.length, generics);\n}\nexport function lambda_type(argType, returnType) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpFunc`2\", [argType, returnType]);\n}\nexport function option_type(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpOption`1\", [generic]);\n}\nexport function list_type(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Collections.FSharpList`1\", [generic]);\n}\nexport function array_type(generic) {\n    return new TypeInfo(\"[]\", [generic]);\n}\nexport function enum_type(fullname, underlyingType, enumCases) {\n    return new TypeInfo(fullname, [underlyingType], undefined, undefined, undefined, undefined, enumCases);\n}\nexport function measure_type(fullname) {\n    return new TypeInfo(fullname);\n}\nexport function generic_type(name) {\n    return new GenericParameter(name);\n}\nexport const obj_type = new TypeInfo(\"System.Object\");\nexport const unit_type = new TypeInfo(\"Microsoft.FSharp.Core.Unit\");\nexport const char_type = new TypeInfo(\"System.Char\");\nexport const string_type = new TypeInfo(\"System.String\");\nexport const bool_type = new TypeInfo(\"System.Boolean\");\nexport const int8_type = new TypeInfo(\"System.SByte\");\nexport const uint8_type = new TypeInfo(\"System.Byte\");\nexport const int16_type = new TypeInfo(\"System.Int16\");\nexport const uint16_type = new TypeInfo(\"System.UInt16\");\nexport const int32_type = new TypeInfo(\"System.Int32\");\nexport const uint32_type = new TypeInfo(\"System.UInt32\");\nexport const float32_type = new TypeInfo(\"System.Single\");\nexport const float64_type = new TypeInfo(\"System.Double\");\nexport const decimal_type = new TypeInfo(\"System.Decimal\");\nexport function name(info) {\n    if (Array.isArray(info)) {\n        return info[0];\n    }\n    else if (info instanceof TypeInfo) {\n        const elemType = getElementType(info);\n        if (elemType != null) {\n            return name(elemType) + \"[]\";\n        }\n        else {\n            const i = info.fullname.lastIndexOf(\".\");\n            return i === -1 ? info.fullname : info.fullname.substr(i + 1);\n        }\n    }\n    else {\n        return info.name;\n    }\n}\nexport function fullName(t) {\n    const elemType = getElementType(t);\n    if (elemType != null) {\n        return fullName(elemType) + \"[]\";\n    }\n    else if (t.generics == null || t.generics.length === 0) {\n        return t.fullname;\n    }\n    else {\n        return t.fullname + \"[\" + t.generics.map((x) => fullName(x)).join(\",\") + \"]\";\n    }\n}\nexport function namespace(t) {\n    const elemType = getElementType(t);\n    if (elemType != null) {\n        return namespace(elemType);\n    }\n    else {\n        const i = t.fullname.lastIndexOf(\".\");\n        return i === -1 ? \"\" : t.fullname.substr(0, i);\n    }\n}\nexport function isArray(t) {\n    return getElementType(t) != null;\n}\nexport function getElementType(t) {\n    var _a;\n    return t.fullname === \"[]\" && ((_a = t.generics) === null || _a === void 0 ? void 0 : _a.length) === 1 ? t.generics[0] : undefined;\n}\nexport function isGenericType(t) {\n    return t.generics != null && t.generics.length > 0;\n}\nexport function isGenericParameter(t) {\n    return t instanceof GenericParameter;\n}\nexport function isEnum(t) {\n    return t.enumCases != null && t.enumCases.length > 0;\n}\nexport function isSubclassOf(t1, t2) {\n    return t1.parent != null && (t1.parent.Equals(t2) || isSubclassOf(t1.parent, t2));\n}\nfunction isErasedToNumber(t) {\n    return isEnum(t) || [\n        int8_type.fullname,\n        uint8_type.fullname,\n        int16_type.fullname,\n        uint16_type.fullname,\n        int32_type.fullname,\n        uint32_type.fullname,\n        float32_type.fullname,\n        float64_type.fullname,\n    ].includes(t.fullname);\n}\nexport function isInstanceOfType(t, o) {\n    switch (typeof o) {\n        case \"boolean\":\n            return t.fullname === bool_type.fullname;\n        case \"string\":\n            return t.fullname === string_type.fullname;\n        case \"function\":\n            return isFunction(t);\n        case \"number\":\n            return isErasedToNumber(t);\n        default:\n            return t.construct != null && o instanceof t.construct;\n    }\n}\n/**\n * This doesn't replace types for fields (records) or cases (unions)\n * but it should be enough for type comparison purposes\n */\nexport function getGenericTypeDefinition(t) {\n    return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));\n}\nexport function getEnumUnderlyingType(t) {\n    var _a;\n    return (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0];\n}\nexport function getEnumValues(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[1]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function getEnumNames(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[0]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nfunction getEnumCase(t, v) {\n    if (t.enumCases != null) {\n        if (typeof v === \"string\") {\n            for (const kv of t.enumCases) {\n                if (kv[0] === v) {\n                    return kv;\n                }\n            }\n            throw new Error(`'${v}' was not found in ${t.fullname}`);\n        }\n        else {\n            for (const kv of t.enumCases) {\n                if (kv[1] === v) {\n                    return kv;\n                }\n            }\n            // .NET returns the number even if it doesn't match any of the cases\n            return [\"\", v];\n        }\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function parseEnum(t, str) {\n    // TODO: better int parsing here, parseInt ceils floats: \"4.8\" -> 4\n    const value = parseInt(str, 10);\n    return getEnumCase(t, isNaN(value) ? str : value)[1];\n}\nexport function tryParseEnum(t, str, defValue) {\n    try {\n        defValue.contents = parseEnum(t, str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getEnumName(t, v) {\n    return getEnumCase(t, v)[0];\n}\nexport function isEnumDefined(t, v) {\n    try {\n        const kv = getEnumCase(t, v);\n        return kv[0] != null && kv[0] !== \"\";\n    }\n    catch (_a) {\n        // supress error\n    }\n    return false;\n}\n// FSharpType\nexport function getUnionCases(t) {\n    if (t.cases != null) {\n        return t.cases();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# union type`);\n    }\n}\nexport function getRecordElements(t) {\n    if (t.fields != null) {\n        return t.fields();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# record type`);\n    }\n}\nexport function getTupleElements(t) {\n    if (isTuple(t) && t.generics != null) {\n        return t.generics;\n    }\n    else {\n        throw new Error(`${t.fullname} is not a tuple type`);\n    }\n}\nexport function getFunctionElements(t) {\n    if (isFunction(t) && t.generics != null) {\n        const gen = t.generics;\n        return [gen[0], gen[1]];\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# function type`);\n    }\n}\nexport function isUnion(t) {\n    return t instanceof TypeInfo ? t.cases != null : t instanceof Union;\n}\nexport function isRecord(t) {\n    return t instanceof TypeInfo ? t.fields != null : t instanceof Record;\n}\nexport function isTuple(t) {\n    return t.fullname.startsWith(\"System.Tuple\");\n}\n// In .NET this is false for delegates\nexport function isFunction(t) {\n    return t.fullname === \"Microsoft.FSharp.Core.FSharpFunc`2\";\n}\n// FSharpValue\nexport function getUnionFields(v, t) {\n    const cases = getUnionCases(t);\n    const case_ = cases[v.tag];\n    if (case_ == null) {\n        throw new Error(`Cannot find case ${v.name} in union type`);\n    }\n    return [case_, v.fields];\n}\nexport function getUnionCaseFields(uci) {\n    return uci.fields == null ? [] : uci.fields;\n}\n// This is used as replacement of `FSharpValue.GetRecordFields`\n// For `FSharpTypes.GetRecordFields` see `getRecordElements`\n// Object.keys returns keys in the order they were added to the object\nexport function getRecordFields(v) {\n    return Object.keys(v).map((k) => v[k]);\n}\nexport function getRecordField(v, field) {\n    return v[field[0]];\n}\nexport function getTupleFields(v) {\n    return v;\n}\nexport function getTupleField(v, i) {\n    return v[i];\n}\nexport function makeUnion(uci, values) {\n    const expectedLength = (uci.fields || []).length;\n    if (values.length !== expectedLength) {\n        throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);\n    }\n    return uci.declaringType.construct != null\n        ? new uci.declaringType.construct(uci.tag, ...values)\n        : {};\n}\nexport function makeRecord(t, values) {\n    const fields = getRecordElements(t);\n    if (fields.length !== values.length) {\n        throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);\n    }\n    return t.construct != null\n        ? new t.construct(...values)\n        : fields.reduce((obj, [key, _t], i) => {\n            obj[key] = values[i];\n            return obj;\n        }, {});\n}\nexport function makeTuple(values, _t) {\n    return values;\n}\nexport function makeGenericType(t, generics) {\n    return new TypeInfo(t.fullname, generics, t.construct, t.parent, t.fields, t.cases);\n}\nexport function createInstance(t, consArgs) {\n    // TODO: Check if consArgs length is same as t.construct?\n    // (Arg types can still be different)\n    if (typeof t.construct === \"function\") {\n        return new t.construct(...(consArgs !== null && consArgs !== void 0 ? consArgs : []));\n    }\n    else if (isErasedToNumber(t)) {\n        return 0;\n    }\n    else {\n        switch (t.fullname) {\n            case obj_type.fullname:\n                return {};\n            case bool_type.fullname:\n                return false;\n            case \"System.Int64\":\n            case \"System.UInt64\":\n                // typeof<int64> and typeof<uint64> get transformed to class_type(\"System.Int64\")\n                // and class_type(\"System.UInt64\") respectively. Test for the name of the primitive type.\n                return int64FromInt(0);\n            case decimal_type.fullname:\n                return new Decimal(0);\n            case char_type.fullname:\n                // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null\n                return null;\n            default:\n                throw new Error(`Cannot access constructor of ${t.fullname}`);\n        }\n    }\n}\nexport function getValue(propertyInfo, v) {\n    return v[propertyInfo[0]];\n}\n// Fable.Core.Reflection\nfunction assertUnion(x) {\n    if (!(x instanceof Union)) {\n        throw new Error(`Value is not an F# union type`);\n    }\n}\nexport function getCaseTag(x) {\n    assertUnion(x);\n    return x.tag;\n}\nexport function getCaseName(x) {\n    assertUnion(x);\n    return x.cases()[x.tag];\n}\nexport function getCaseFields(x) {\n    assertUnion(x);\n    return x.fields;\n}\n","import { Record, Union } from \"../../fable_modules/fable-library.3.6.3/Types.js\";\nimport { tuple_type, lambda_type, class_type, record_type, float64_type, int32_type, bool_type, string_type, union_type, array_type, uint8_type } from \"../../fable_modules/fable-library.3.6.3/Reflection.js\";\n\nexport function Route_builder(typeName, methodName) {\n    return `/obt_nett/api/${typeName}/${methodName}`;\n}\n\nexport class FileByteArray extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"FileByteArray\"];\n    }\n}\n\nexport function FileByteArray$reflection() {\n    return union_type(\"Shared.FileByteArray\", [], FileByteArray, () => [[[\"Item\", array_type(uint8_type)]]]);\n}\n\nexport class ContentHash extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"ContentHash\"];\n    }\n}\n\nexport function ContentHash$reflection() {\n    return union_type(\"Shared.ContentHash\", [], ContentHash, () => [[[\"Item\", string_type]]]);\n}\n\nexport class IncludePos extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"IncludePos\"];\n    }\n}\n\nexport function IncludePos$reflection() {\n    return union_type(\"Shared.IncludePos\", [], IncludePos, () => [[[\"Item\", bool_type]]]);\n}\n\nexport class TaggedTextInfo extends Record {\n    constructor(ContentHash, NumAllTokens, NumWordTokens, NumWordTypes, NumWordLemmaTypes, AvgWordLength, AvgSentenceLength) {\n        super();\n        this.ContentHash = ContentHash;\n        this.NumAllTokens = (NumAllTokens | 0);\n        this.NumWordTokens = (NumWordTokens | 0);\n        this.NumWordTypes = (NumWordTypes | 0);\n        this.NumWordLemmaTypes = (NumWordLemmaTypes | 0);\n        this.AvgWordLength = AvgWordLength;\n        this.AvgSentenceLength = AvgSentenceLength;\n    }\n}\n\nexport function TaggedTextInfo$reflection() {\n    return record_type(\"Shared.TaggedTextInfo\", [], TaggedTextInfo, () => [[\"ContentHash\", ContentHash$reflection()], [\"NumAllTokens\", int32_type], [\"NumWordTokens\", int32_type], [\"NumWordTypes\", int32_type], [\"NumWordLemmaTypes\", int32_type], [\"AvgWordLength\", float64_type], [\"AvgSentenceLength\", float64_type]]);\n}\n\nexport class DownloadFormat extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Excel\", \"Tsv\", \"Csv\"];\n    }\n}\n\nexport function DownloadFormat$reflection() {\n    return union_type(\"Shared.DownloadFormat\", [], DownloadFormat, () => [[], [], []]);\n}\n\nexport class IServerApi extends Record {\n    constructor(TagText, DownloadTaggedText, GetLemmas, DownloadLemmas, DownloadLemmatizedText) {\n        super();\n        this.TagText = TagText;\n        this.DownloadTaggedText = DownloadTaggedText;\n        this.GetLemmas = GetLemmas;\n        this.DownloadLemmas = DownloadLemmas;\n        this.DownloadLemmatizedText = DownloadLemmatizedText;\n    }\n}\n\nexport function IServerApi$reflection() {\n    return record_type(\"Shared.IServerApi\", [], IServerApi, () => [[\"TagText\", lambda_type(FileByteArray$reflection(), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [TaggedTextInfo$reflection()]))], [\"DownloadTaggedText\", lambda_type(ContentHash$reflection(), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [FileByteArray$reflection()]))], [\"GetLemmas\", lambda_type(ContentHash$reflection(), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [array_type(tuple_type(tuple_type(string_type, string_type), int32_type))]))], [\"DownloadLemmas\", lambda_type(tuple_type(ContentHash$reflection(), DownloadFormat$reflection()), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [FileByteArray$reflection()]))], [\"DownloadLemmatizedText\", lambda_type(tuple_type(ContentHash$reflection(), IncludePos$reflection()), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [FileByteArray$reflection()]))]]);\n}\n\n","import { Exception, Record, Union } from \"../fable-library.3.6.3/Types.js\";\nimport { obj_type, class_type, lambda_type, option_type, int32_type, record_type, bool_type, list_type, tuple_type, array_type, uint8_type, string_type, union_type } from \"../fable-library.3.6.3/Reflection.js\";\n\nexport class HttpMethod extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"GET\", \"POST\"];\n    }\n}\n\nexport function HttpMethod$reflection() {\n    return union_type(\"Fable.Remoting.Client.HttpMethod\", [], HttpMethod, () => [[], []]);\n}\n\nexport class RequestBody extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Empty\", \"Json\", \"Binary\"];\n    }\n}\n\nexport function RequestBody$reflection() {\n    return union_type(\"Fable.Remoting.Client.RequestBody\", [], RequestBody, () => [[], [[\"Item\", string_type]], [[\"Item\", array_type(uint8_type)]]]);\n}\n\nexport class HttpRequest extends Record {\n    constructor(HttpMethod, Url, Headers, RequestBody, WithCredentials) {\n        super();\n        this.HttpMethod = HttpMethod;\n        this.Url = Url;\n        this.Headers = Headers;\n        this.RequestBody = RequestBody;\n        this.WithCredentials = WithCredentials;\n    }\n}\n\nexport function HttpRequest$reflection() {\n    return record_type(\"Fable.Remoting.Client.HttpRequest\", [], HttpRequest, () => [[\"HttpMethod\", HttpMethod$reflection()], [\"Url\", string_type], [\"Headers\", list_type(tuple_type(string_type, string_type))], [\"RequestBody\", RequestBody$reflection()], [\"WithCredentials\", bool_type]]);\n}\n\nexport class HttpResponse extends Record {\n    constructor(StatusCode, ResponseBody) {\n        super();\n        this.StatusCode = (StatusCode | 0);\n        this.ResponseBody = ResponseBody;\n    }\n}\n\nexport function HttpResponse$reflection() {\n    return record_type(\"Fable.Remoting.Client.HttpResponse\", [], HttpResponse, () => [[\"StatusCode\", int32_type], [\"ResponseBody\", string_type]]);\n}\n\nexport class RemoteBuilderOptions extends Record {\n    constructor(CustomHeaders, BaseUrl, Authorization, WithCredentials, RouteBuilder, CustomResponseSerialization) {\n        super();\n        this.CustomHeaders = CustomHeaders;\n        this.BaseUrl = BaseUrl;\n        this.Authorization = Authorization;\n        this.WithCredentials = WithCredentials;\n        this.RouteBuilder = RouteBuilder;\n        this.CustomResponseSerialization = CustomResponseSerialization;\n    }\n}\n\nexport function RemoteBuilderOptions$reflection() {\n    return record_type(\"Fable.Remoting.Client.RemoteBuilderOptions\", [], RemoteBuilderOptions, () => [[\"CustomHeaders\", list_type(tuple_type(string_type, string_type))], [\"BaseUrl\", option_type(string_type)], [\"Authorization\", option_type(string_type)], [\"WithCredentials\", bool_type], [\"RouteBuilder\", lambda_type(string_type, lambda_type(string_type, string_type))], [\"CustomResponseSerialization\", option_type(lambda_type(array_type(uint8_type), lambda_type(class_type(\"System.Type\"), obj_type)))]]);\n}\n\nexport class ProxyRequestException extends Exception {\n    constructor(response, errorMsg, reponseText) {\n        super(errorMsg);\n        this.response = response;\n        this.reponseText = reponseText;\n    }\n}\n\nexport function ProxyRequestException$reflection() {\n    return class_type(\"Fable.Remoting.Client.ProxyRequestException\", void 0, ProxyRequestException, class_type(\"System.Exception\"));\n}\n\nexport function ProxyRequestException_$ctor_76BC5104(response, errorMsg, reponseText) {\n    return new ProxyRequestException(response, errorMsg, reponseText);\n}\n\nexport function ProxyRequestException__get_Response(this$) {\n    return this$.response;\n}\n\nexport function ProxyRequestException__get_StatusCode(this$) {\n    return this$.response.StatusCode;\n}\n\nexport function ProxyRequestException__get_ResponseText(this$) {\n    return this$.reponseText;\n}\n\n","import { Union, Record } from \"../fable-library.3.6.3/Types.js\";\nimport { union_type, tuple_type, lambda_type, unit_type, array_type, record_type, class_type, string_type } from \"../fable-library.3.6.3/Reflection.js\";\n\nexport class RecordField extends Record {\n    constructor(FieldName, FieldType, PropertyInfo) {\n        super();\n        this.FieldName = FieldName;\n        this.FieldType = FieldType;\n        this.PropertyInfo = PropertyInfo;\n    }\n}\n\nexport function RecordField$reflection() {\n    return record_type(\"Fable.SimpleJson.RecordField\", [], RecordField, () => [[\"FieldName\", string_type], [\"FieldType\", TypeInfo$reflection()], [\"PropertyInfo\", class_type(\"System.Reflection.PropertyInfo\")]]);\n}\n\nexport class UnionCase extends Record {\n    constructor(CaseName, CaseTypes, Info) {\n        super();\n        this.CaseName = CaseName;\n        this.CaseTypes = CaseTypes;\n        this.Info = Info;\n    }\n}\n\nexport function UnionCase$reflection() {\n    return record_type(\"Fable.SimpleJson.UnionCase\", [], UnionCase, () => [[\"CaseName\", string_type], [\"CaseTypes\", array_type(TypeInfo$reflection())], [\"Info\", class_type(\"Microsoft.FSharp.Reflection.UnionCaseInfo\")]]);\n}\n\nexport class TypeInfo extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Unit\", \"Char\", \"String\", \"UInt16\", \"UInt32\", \"UInt64\", \"Int32\", \"Bool\", \"Float32\", \"Float\", \"Decimal\", \"Short\", \"Long\", \"Byte\", \"SByte\", \"DateTime\", \"DateTimeOffset\", \"DateOnly\", \"TimeOnly\", \"BigInt\", \"TimeSpan\", \"Guid\", \"Object\", \"Any\", \"Async\", \"Promise\", \"Option\", \"List\", \"Set\", \"Array\", \"Seq\", \"Tuple\", \"Map\", \"Dictionary\", \"ResizeArray\", \"HashSet\", \"Func\", \"Enum\", \"Record\", \"Union\"];\n    }\n}\n\nexport function TypeInfo$reflection() {\n    return union_type(\"Fable.SimpleJson.TypeInfo\", [], TypeInfo, () => [[], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [[\"Item\", lambda_type(unit_type, class_type(\"System.Type\"))]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, array_type(TypeInfo$reflection()))]], [[\"Item\", lambda_type(unit_type, tuple_type(TypeInfo$reflection(), TypeInfo$reflection()))]], [[\"Item\", lambda_type(unit_type, tuple_type(TypeInfo$reflection(), TypeInfo$reflection(), class_type(\"System.Type\")))]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, TypeInfo$reflection())]], [[\"Item\", lambda_type(unit_type, array_type(TypeInfo$reflection()))]], [[\"Item\", lambda_type(unit_type, tuple_type(TypeInfo$reflection(), class_type(\"System.Type\")))]], [[\"Item\", lambda_type(unit_type, tuple_type(array_type(RecordField$reflection()), class_type(\"System.Type\")))]], [[\"Item\", lambda_type(unit_type, tuple_type(array_type(UnionCase$reflection()), class_type(\"System.Type\")))]]]);\n}\n\n","import { equals } from \"./Util.js\";\nimport { Union } from \"./Types.js\";\nconst CaseRules = {\n    None: 0,\n    LowerFirst: 1,\n    SnakeCase: 2,\n    SnakeCaseAllCaps: 3,\n    KebabCase: 4,\n};\nfunction dashify(str, separator) {\n    return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1\n        ? m.toLowerCase()\n        : m.charAt(0) + separator + m.charAt(1).toLowerCase());\n}\nfunction changeCase(str, caseRule) {\n    switch (caseRule) {\n        case CaseRules.LowerFirst:\n            return str.charAt(0).toLowerCase() + str.slice(1);\n        case CaseRules.SnakeCase:\n            return dashify(str, \"_\");\n        case CaseRules.SnakeCaseAllCaps:\n            return dashify(str, \"_\").toUpperCase();\n        case CaseRules.KebabCase:\n            return dashify(str, \"-\");\n        case CaseRules.None:\n        default:\n            return str;\n    }\n}\nexport function keyValueList(fields, caseRule = CaseRules.None) {\n    const obj = {};\n    const definedCaseRule = caseRule;\n    function fail(kvPair) {\n        throw new Error(\"Cannot infer key and value of \" + String(kvPair));\n    }\n    function assign(key, caseRule, value) {\n        key = changeCase(key, caseRule);\n        obj[key] = value;\n    }\n    for (let kvPair of fields) {\n        let caseRule = CaseRules.None;\n        if (kvPair == null) {\n            fail(kvPair);\n        }\n        // Deflate unions and use the defined case rule\n        if (kvPair instanceof Union) {\n            const name = kvPair.cases()[kvPair.tag];\n            kvPair = kvPair.fields.length === 0 ? name : [name].concat(kvPair.fields);\n            caseRule = definedCaseRule;\n        }\n        if (Array.isArray(kvPair)) {\n            switch (kvPair.length) {\n                case 0:\n                    fail(kvPair);\n                    break;\n                case 1:\n                    assign(kvPair[0], caseRule, true);\n                    break;\n                case 2:\n                    const value = kvPair[1];\n                    assign(kvPair[0], caseRule, value);\n                    break;\n                default:\n                    assign(kvPair[0], caseRule, kvPair.slice(1));\n            }\n        }\n        else if (typeof kvPair === \"string\") {\n            assign(kvPair, caseRule, true);\n        }\n        else {\n            fail(kvPair);\n        }\n    }\n    return obj;\n}\n// TODO: Move these methods to Map and Set modules\nexport function containsValue(v, map) {\n    for (const kv of map) {\n        if (equals(v, kv[1])) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function tryGetValue(map, key, defaultValue) {\n    if (map.has(key)) {\n        defaultValue.contents = map.get(key);\n        return true;\n    }\n    return false;\n}\nexport function addToSet(v, set) {\n    if (set.has(v)) {\n        return false;\n    }\n    set.add(v);\n    return true;\n}\nexport function addToDict(dict, k, v) {\n    if (dict.has(k)) {\n        throw new Error(\"An item with the same key has already been added. Key: \" + k);\n    }\n    dict.set(k, v);\n}\nexport function getItemFromDict(map, key) {\n    if (map.has(key)) {\n        return map.get(key);\n    }\n    else {\n        throw new Error(`The given key '${key}' was not present in the dictionary.`);\n    }\n}\n","import { equals, toIterator, getEnumerator } from \"./Util.js\";\r\nimport { iterate, map, delay, toArray, iterateIndexed, concat } from \"./Seq.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\r\nimport { format } from \"./String.js\";\r\n\r\nexport class Dictionary {\r\n    constructor(pairs, comparer) {\r\n        const this$ = new FSharpRef(null);\r\n        this.comparer = comparer;\r\n        this$.contents = this;\r\n        this.hashMap = (new Map([]));\r\n        this[\"init@8-1\"] = 1;\r\n        const enumerator = getEnumerator(pairs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const pair = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                Dictionary__Add_5BDDA1(this$.contents, pair[0], pair[1]);\r\n            }\r\n        }\r\n        finally {\r\n            enumerator.Dispose();\r\n        }\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"Dictionary\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const this$ = this;\r\n        return getEnumerator(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const this$ = this;\r\n        return getEnumerator(concat(this$.hashMap.values()));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\r\n        const this$ = this;\r\n        Dictionary__Add_5BDDA1(this$, item[0], item[1]);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        const this$ = this;\r\n        Dictionary__Clear(this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\r\n        let pattern_matching_result;\r\n        if (matchValue != null) {\r\n            if (equals(matchValue[1], item[1])) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return true;\r\n            }\r\n            case 1: {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\r\n        const this$ = this;\r\n        iterateIndexed((i, e) => {\r\n            array[arrayIndex + i] = e;\r\n        }, this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const this$ = this;\r\n        return Dictionary__get_Count(this$) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return false;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\r\n        if (matchValue != null) {\r\n            if (equals(matchValue[1], item[1])) {\r\n                Dictionary__Remove_2B595(this$, item[0]);\r\n            }\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.Add5BDDA1\"](key, value) {\r\n        const this$ = this;\r\n        Dictionary__Add_5BDDA1(this$, key, value);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.ContainsKey2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__ContainsKey_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Item2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__get_Item_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.set_Item5BDDA1\"](key, v) {\r\n        const this$ = this;\r\n        Dictionary__set_Item_5BDDA1(this$, key, v);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Keys\"]() {\r\n        const this$ = this;\r\n        return toArray(delay(() => map((pair) => pair[0], this$)));\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.Remove2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__Remove_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.TryGetValue23A0B95A\"](key, value) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, key);\r\n        if (matchValue != null) {\r\n            const pair = matchValue;\r\n            value.contents = pair[1];\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Values\"]() {\r\n        const this$ = this;\r\n        return toArray(delay(() => map((pair) => pair[1], this$)));\r\n    }\r\n    get size() {\r\n        const this$ = this;\r\n        return Dictionary__get_Count(this$) | 0;\r\n    }\r\n    clear() {\r\n        const this$ = this;\r\n        Dictionary__Clear(this$);\r\n    }\r\n    delete(k) {\r\n        const this$ = this;\r\n        return Dictionary__Remove_2B595(this$, k);\r\n    }\r\n    entries() {\r\n        const this$ = this;\r\n        return map((p) => [p[0], p[1]], this$);\r\n    }\r\n    get(k) {\r\n        const this$ = this;\r\n        return Dictionary__get_Item_2B595(this$, k);\r\n    }\r\n    has(k) {\r\n        const this$ = this;\r\n        return Dictionary__ContainsKey_2B595(this$, k);\r\n    }\r\n    keys() {\r\n        const this$ = this;\r\n        return map((p) => p[0], this$);\r\n    }\r\n    set(k, v) {\r\n        const this$ = this;\r\n        Dictionary__set_Item_5BDDA1(this$, k, v);\r\n        return this$;\r\n    }\r\n    values() {\r\n        const this$ = this;\r\n        return map((p) => p[1], this$);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const this$ = this;\r\n        iterate((p) => {\r\n            f(p[1], p[0], this$);\r\n        }, this$);\r\n    }\r\n}\r\n\r\nexport function Dictionary$reflection(gen0, gen1) {\r\n    return class_type(\"Fable.Collections.Dictionary\", [gen0, gen1], Dictionary);\r\n}\r\n\r\nexport function Dictionary_$ctor_6623D9B3(pairs, comparer) {\r\n    return new Dictionary(pairs, comparer);\r\n}\r\n\r\nfunction Dictionary__TryFindIndex_2B595(this$, k) {\r\n    const h = this$.comparer.GetHashCode(k) | 0;\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return [true, h, matchValue[1].findIndex((pair) => this$.comparer.Equals(k, pair[0]))];\r\n    }\r\n    else {\r\n        return [false, h, -1];\r\n    }\r\n}\r\n\r\nexport function Dictionary__TryFind_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__get_Comparer(this$) {\r\n    return this$.comparer;\r\n}\r\n\r\nexport function Dictionary__Clear(this$) {\r\n    this$.hashMap.clear();\r\n}\r\n\r\nexport function Dictionary__get_Count(this$) {\r\n    let count = 0;\r\n    let enumerator = getEnumerator(this$.hashMap.values());\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const pairs = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            count = ((count + pairs.length) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n    return count | 0;\r\n}\r\n\r\nexport function Dictionary__get_Item_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFind_2B595(this$, k);\r\n    if (matchValue != null) {\r\n        return matchValue[1];\r\n    }\r\n    else {\r\n        throw (new Error(\"The item was not found in collection\"));\r\n    }\r\n}\r\n\r\nexport function Dictionary__set_Item_5BDDA1(this$, k, v) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];\r\n            break;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [[k, v]]);\r\n            }\r\n            break;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__Add_5BDDA1(this$, k, v) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            const msg = format(\"An item with the same key has already been added. Key: {0}\", k);\r\n            throw (new Error(msg));\r\n            break;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [[k, v]]);\r\n            }\r\n            break;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__ContainsKey_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__Remove_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\n","import { equals, getEnumUnderlyingType, isEnum, getTupleElements, isTuple, getElementType, isArray, getFunctionElements, isFunction, getUnionCases, getUnionCaseFields, isUnion, getGenerics, getRecordElements, name, isRecord, fullName } from \"../fable-library.3.6.3/Reflection.js\";\nimport { UnionCase, RecordField, TypeInfo } from \"./TypeInfo.fs.js\";\nimport { map } from \"../fable-library.3.6.3/Array.js\";\nimport { collect, singleton, append, delay, toArray } from \"../fable-library.3.6.3/Seq.js\";\nimport { structuralHash, Lazy } from \"../fable-library.3.6.3/Util.js\";\nimport { Dictionary } from \"../fable-library.3.6.3/MutableMap.js\";\nimport { tryGetValue } from \"../fable-library.3.6.3/MapUtil.js\";\nimport { FSharpRef } from \"../fable-library.3.6.3/Types.js\";\nimport { endsWith, isNullOrEmpty } from \"../fable-library.3.6.3/String.js\";\n\nexport function $007CPrimitiveType$007C_$007C(primType) {\n    const matchValue = fullName(primType);\n    switch (matchValue) {\n        case \"System.String\": {\n            return new TypeInfo(2);\n        }\n        case \"System.Char\": {\n            return new TypeInfo(1);\n        }\n        case \"System.Int16\": {\n            return new TypeInfo(11);\n        }\n        case \"System.Int32\": {\n            return new TypeInfo(6);\n        }\n        case \"Microsoft.FSharp.Core.int64`1\":\n        case \"System.Int64\": {\n            return new TypeInfo(12);\n        }\n        case \"System.UInt16\": {\n            return new TypeInfo(3);\n        }\n        case \"System.UInt32\": {\n            return new TypeInfo(4);\n        }\n        case \"System.UInt64\": {\n            return new TypeInfo(5);\n        }\n        case \"System.DateTime\": {\n            return new TypeInfo(15);\n        }\n        case \"System.DateOnly\": {\n            return new TypeInfo(17);\n        }\n        case \"System.TimeOnly\": {\n            return new TypeInfo(18);\n        }\n        case \"System.TimeSpan\": {\n            return new TypeInfo(20);\n        }\n        case \"System.DateTimeOffset\": {\n            return new TypeInfo(16);\n        }\n        case \"System.Boolean\": {\n            return new TypeInfo(7);\n        }\n        case \"System.Single\": {\n            return new TypeInfo(8);\n        }\n        case \"System.Double\": {\n            return new TypeInfo(9);\n        }\n        case \"Microsoft.FSharp.Core.decimal`1\":\n        case \"System.Decimal\": {\n            return new TypeInfo(10);\n        }\n        case \"System.Numerics.BigInteger\": {\n            return new TypeInfo(19);\n        }\n        case \"Microsoft.FSharp.Core.Unit\": {\n            return new TypeInfo(0);\n        }\n        case \"System.Guid\": {\n            return new TypeInfo(21);\n        }\n        case \"System.Byte\": {\n            return new TypeInfo(13);\n        }\n        case \"System.SByte\": {\n            return new TypeInfo(14);\n        }\n        case \"System.Object\": {\n            return new TypeInfo(22);\n        }\n        default: {\n            return void 0;\n        }\n    }\n}\n\nexport function $007CRecordType$007C_$007C(t) {\n    if (isRecord(t)) {\n        return map((field) => [field, name(field), field[1]], getRecordElements(t));\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CSetType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"Microsoft.FSharp.Collections.FSharpSet`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CNullable$007C_$007C(t) {\n    if (fullName(t).indexOf(\"System.Nullable`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CUnionType$007C_$007C(t) {\n    if (isUnion(t)) {\n        return map((info) => [name(info), info, map((prop) => prop[1], getUnionCaseFields(info))], getUnionCases(t));\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CMapType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"Microsoft.FSharp.Collections.FSharpMap`2\") === 0) {\n        const genArgs = getGenerics(t);\n        return [genArgs[0], genArgs[1]];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CListType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"Microsoft.FSharp.Collections.FSharpList`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function flattenFuncTypes(typeDef) {\n    return toArray(delay(() => {\n        if (isFunction(typeDef)) {\n            const patternInput = getFunctionElements(typeDef);\n            return append(flattenFuncTypes(patternInput[0]), delay(() => flattenFuncTypes(patternInput[1])));\n        }\n        else {\n            return singleton(typeDef);\n        }\n    }));\n}\n\nexport function $007CFuncType$007C_$007C(t) {\n    if (isFunction(t)) {\n        return flattenFuncTypes(t);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CArrayType$007C_$007C(t) {\n    if (isArray(t)) {\n        return getElementType(t);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007COptionType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"Microsoft.FSharp.Core.FSharpOption`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CTupleType$007C_$007C(t) {\n    if (isTuple(t)) {\n        return getTupleElements(t);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CSeqType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"System.Collections.Generic.IEnumerable`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CDictionaryType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"System.Collections.Generic.Dictionary\") === 0) {\n        const genArgs = getGenerics(t);\n        return [genArgs[0], genArgs[1]];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CResizeArrayType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"System.Collections.Generic.List\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CHashSetType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"System.Collections.Generic.HashSet\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CAsyncType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"Microsoft.FSharp.Control.FSharpAsync`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CPromiseType$007C_$007C(t) {\n    if (fullName(t).indexOf(\"Fable.Core.JS.Promise`1\") === 0) {\n        return getGenerics(t)[0];\n    }\n    else {\n        return void 0;\n    }\n}\n\nfunction lazyToDelayed(l, unitVar0) {\n    return l.Value;\n}\n\nexport function $007CEnumType$007C_$007C(t) {\n    if (isEnum(t)) {\n        return getEnumUnderlyingType(t);\n    }\n    else {\n        return void 0;\n    }\n}\n\nfunction _createTypeInfo(resolvedType) {\n    let l, l_3, l_4, l_5, l_6, l_7, l_8, l_9, l_10, l_11, l_12, l_13, l_14, l_15, l_16, l_17;\n    const activePatternResult2709 = $007CPrimitiveType$007C_$007C(resolvedType);\n    if (activePatternResult2709 != null) {\n        const typeInfo = activePatternResult2709;\n        return typeInfo;\n    }\n    else {\n        const activePatternResult2708 = $007CFuncType$007C_$007C(resolvedType);\n        if (activePatternResult2708 != null) {\n            const types = activePatternResult2708;\n            return new TypeInfo(36, (l = (new Lazy(() => map((resolvedType_1) => createTypeInfo(resolvedType_1), types))), () => lazyToDelayed(l, void 0)));\n        }\n        else {\n            const activePatternResult2707 = $007CRecordType$007C_$007C(resolvedType);\n            if (activePatternResult2707 != null) {\n                const fields = activePatternResult2707;\n                const l_1 = new Lazy(() => [toArray(delay(() => collect((matchValue) => singleton(new RecordField(matchValue[1], createTypeInfo(matchValue[2]), matchValue[0])), fields))), resolvedType]);\n                return new TypeInfo(38, () => lazyToDelayed(l_1, void 0));\n            }\n            else {\n                const activePatternResult2706 = $007CUnionType$007C_$007C(resolvedType);\n                if (activePatternResult2706 != null) {\n                    const cases = activePatternResult2706;\n                    const l_2 = new Lazy(() => [toArray(delay(() => collect((matchValue_1) => singleton(new UnionCase(matchValue_1[0], map((resolvedType_2) => createTypeInfo(resolvedType_2), matchValue_1[2]), matchValue_1[1])), cases))), resolvedType]);\n                    return new TypeInfo(39, () => lazyToDelayed(l_2, void 0));\n                }\n                else {\n                    const activePatternResult2705 = $007CEnumType$007C_$007C(resolvedType);\n                    if (activePatternResult2705 != null) {\n                        const elemType = activePatternResult2705;\n                        return new TypeInfo(37, (l_3 = (new Lazy(() => [createTypeInfo(elemType), resolvedType])), () => lazyToDelayed(l_3, void 0)));\n                    }\n                    else {\n                        const activePatternResult2704 = $007CListType$007C_$007C(resolvedType);\n                        if (activePatternResult2704 != null) {\n                            const elemType_1 = activePatternResult2704;\n                            return new TypeInfo(27, (l_4 = (new Lazy(() => createTypeInfo(elemType_1))), () => lazyToDelayed(l_4, void 0)));\n                        }\n                        else {\n                            const activePatternResult2703 = $007CResizeArrayType$007C_$007C(resolvedType);\n                            if (activePatternResult2703 != null) {\n                                const elemType_2 = activePatternResult2703;\n                                return new TypeInfo(34, (l_5 = (new Lazy(() => createTypeInfo(elemType_2))), () => lazyToDelayed(l_5, void 0)));\n                            }\n                            else {\n                                const activePatternResult2702 = $007CHashSetType$007C_$007C(resolvedType);\n                                if (activePatternResult2702 != null) {\n                                    const elemType_3 = activePatternResult2702;\n                                    return new TypeInfo(35, (l_6 = (new Lazy(() => createTypeInfo(elemType_3))), () => lazyToDelayed(l_6, void 0)));\n                                }\n                                else {\n                                    const activePatternResult2701 = $007CArrayType$007C_$007C(resolvedType);\n                                    if (activePatternResult2701 != null) {\n                                        const elemType_4 = activePatternResult2701;\n                                        return new TypeInfo(29, (l_7 = (new Lazy(() => createTypeInfo(elemType_4))), () => lazyToDelayed(l_7, void 0)));\n                                    }\n                                    else {\n                                        const activePatternResult2700 = $007CTupleType$007C_$007C(resolvedType);\n                                        if (activePatternResult2700 != null) {\n                                            const types_1 = activePatternResult2700;\n                                            return new TypeInfo(31, (l_8 = (new Lazy(() => map((resolvedType_3) => createTypeInfo(resolvedType_3), types_1))), () => lazyToDelayed(l_8, void 0)));\n                                        }\n                                        else {\n                                            const activePatternResult2699 = $007COptionType$007C_$007C(resolvedType);\n                                            if (activePatternResult2699 != null) {\n                                                const elemType_5 = activePatternResult2699;\n                                                return new TypeInfo(26, (l_9 = (new Lazy(() => createTypeInfo(elemType_5))), () => lazyToDelayed(l_9, void 0)));\n                                            }\n                                            else {\n                                                const activePatternResult2698 = $007CNullable$007C_$007C(resolvedType);\n                                                if (activePatternResult2698 != null) {\n                                                    const elemType_6 = activePatternResult2698;\n                                                    return new TypeInfo(26, (l_10 = (new Lazy(() => createTypeInfo(elemType_6))), () => lazyToDelayed(l_10, void 0)));\n                                                }\n                                                else {\n                                                    const activePatternResult2697 = $007CSetType$007C_$007C(resolvedType);\n                                                    if (activePatternResult2697 != null) {\n                                                        const elemType_7 = activePatternResult2697;\n                                                        return new TypeInfo(28, (l_11 = (new Lazy(() => createTypeInfo(elemType_7))), () => lazyToDelayed(l_11, void 0)));\n                                                    }\n                                                    else {\n                                                        const activePatternResult2696 = $007CMapType$007C_$007C(resolvedType);\n                                                        if (activePatternResult2696 != null) {\n                                                            const keyType = activePatternResult2696[0];\n                                                            const valueType = activePatternResult2696[1];\n                                                            return new TypeInfo(32, (l_12 = (new Lazy(() => [createTypeInfo(keyType), createTypeInfo(valueType)])), () => lazyToDelayed(l_12, void 0)));\n                                                        }\n                                                        else {\n                                                            const activePatternResult2695 = $007CDictionaryType$007C_$007C(resolvedType);\n                                                            if (activePatternResult2695 != null) {\n                                                                const keyType_1 = activePatternResult2695[0];\n                                                                const valueType_1 = activePatternResult2695[1];\n                                                                return new TypeInfo(33, (l_13 = (new Lazy(() => [createTypeInfo(keyType_1), createTypeInfo(valueType_1), valueType_1])), () => lazyToDelayed(l_13, void 0)));\n                                                            }\n                                                            else {\n                                                                const activePatternResult2694 = $007CSeqType$007C_$007C(resolvedType);\n                                                                if (activePatternResult2694 != null) {\n                                                                    const elemType_8 = activePatternResult2694;\n                                                                    return new TypeInfo(30, (l_14 = (new Lazy(() => createTypeInfo(elemType_8))), () => lazyToDelayed(l_14, void 0)));\n                                                                }\n                                                                else {\n                                                                    const activePatternResult2693 = $007CAsyncType$007C_$007C(resolvedType);\n                                                                    if (activePatternResult2693 != null) {\n                                                                        const elemType_9 = activePatternResult2693;\n                                                                        return new TypeInfo(24, (l_15 = (new Lazy(() => createTypeInfo(elemType_9))), () => lazyToDelayed(l_15, void 0)));\n                                                                    }\n                                                                    else {\n                                                                        const activePatternResult2692 = $007CPromiseType$007C_$007C(resolvedType);\n                                                                        if (activePatternResult2692 != null) {\n                                                                            const elemType_10 = activePatternResult2692;\n                                                                            return new TypeInfo(25, (l_16 = (new Lazy(() => createTypeInfo(elemType_10))), () => lazyToDelayed(l_16, void 0)));\n                                                                        }\n                                                                        else {\n                                                                            return new TypeInfo(23, (l_17 = (new Lazy(() => resolvedType)), () => lazyToDelayed(l_17, void 0)));\n                                                                        }\n                                                                    }\n                                                                }\n                                                            }\n                                                        }\n                                                    }\n                                                }\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n}\n\nconst typeInfoCache = new Dictionary([], {\n    Equals: (x, y) => equals(x, y),\n    GetHashCode: (x) => structuralHash(x),\n});\n\nexport function createTypeInfo(resolvedType) {\n    let matchValue;\n    let outArg = null;\n    matchValue = [tryGetValue(typeInfoCache, resolvedType, new FSharpRef(() => outArg, (v) => {\n        outArg = v;\n    })), outArg];\n    if (matchValue[0]) {\n        return matchValue[1];\n    }\n    else {\n        const ti_1 = _createTypeInfo(resolvedType);\n        if (((!isNullOrEmpty(fullName(resolvedType))) && (!endsWith(fullName(resolvedType), \"`1[]\"))) && (!endsWith(fullName(resolvedType), \"`2[]\"))) {\n            typeInfoCache.set(resolvedType, ti_1);\n            return ti_1;\n        }\n        else {\n            return ti_1;\n        }\n    }\n}\n\nexport function isPrimitive(_arg1) {\n    switch (_arg1.tag) {\n        case 0:\n        case 2:\n        case 3:\n        case 4:\n        case 5:\n        case 6:\n        case 7:\n        case 8:\n        case 9:\n        case 10:\n        case 11:\n        case 12:\n        case 13:\n        case 15:\n        case 16:\n        case 17:\n        case 18:\n        case 19:\n        case 21:\n        case 26: {\n            return true;\n        }\n        default: {\n            return false;\n        }\n    }\n}\n\nexport function enumUnion(_arg1) {\n    if (_arg1.tag === 39) {\n        return _arg1.fields[0]()[0].every((case$) => (case$.CaseTypes.length === 0));\n    }\n    else {\n        return false;\n    }\n}\n\n","import { fromContinuations } from \"../fable-library.3.6.3/Async.js\";\nimport { class_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { isNullOrWhiteSpace } from \"../fable-library.3.6.3/String.js\";\n\nexport function InternalUtilities_toUInt8Array(data) {\n    if (data instanceof Uint8Array) {\n        return data;\n    }\n    else {\n        return new Uint8Array(data);\n    }\n}\n\nexport function Browser_Types_File__File_ReadAsByteArray(instance) {\n    return fromContinuations((tupledArg) => {\n        const reader = new FileReader();\n        reader.onload = ((_arg1) => {\n            if (reader.readyState === 2) {\n                tupledArg[0](new Uint8Array(reader.result));\n            }\n        });\n        reader.readAsArrayBuffer(instance);\n    });\n}\n\nexport function Browser_Types_File__File_ReadAsDataUrl(instance) {\n    return fromContinuations((tupledArg) => {\n        const reader = new FileReader();\n        reader.onload = ((_arg4) => {\n            if (reader.readyState === 2) {\n                tupledArg[0](reader.result);\n            }\n        });\n        reader.readAsDataURL(instance);\n    });\n}\n\nexport function Browser_Types_File__File_ReadAsText(instance) {\n    return fromContinuations((tupledArg) => {\n        const reader = new FileReader();\n        reader.onload = ((_arg7) => {\n            if (reader.readyState === 2) {\n                tupledArg[0](reader.result);\n            }\n        });\n        reader.readAsText(instance);\n    });\n}\n\nexport class ByteArrayExtensions {\n    constructor() {\n    }\n}\n\nexport function ByteArrayExtensions$reflection() {\n    return class_type(\"Fable.Remoting.Client.ByteArrayExtensions\", void 0, ByteArrayExtensions);\n}\n\nexport function ByteArrayExtensions_SaveFileAs_72B26259(content, fileName) {\n    if (isNullOrWhiteSpace(fileName)) {\n    }\n    else {\n        const binaryData = InternalUtilities_toUInt8Array(content);\n        const blob = new Blob([binaryData.buffer], { type: \"application/octet-stream\" });\n        const dataUrl = window.URL.createObjectURL(blob);\n        const anchor = document.createElement(\"a\");\n        anchor.style = \"display: none\";\n        anchor.href = dataUrl;\n        anchor.download = fileName;\n        anchor.rel = \"noopener\";\n        anchor.click();\n        anchor.remove();\n        window.setTimeout(() => {\n            URL.revokeObjectURL(dataUrl);\n        }, 40 * 1000);\n    }\n}\n\nexport function ByteArrayExtensions_SaveFileAs_451DD142(content, fileName, mimeType) {\n    if (isNullOrWhiteSpace(fileName)) {\n    }\n    else {\n        const binaryData = InternalUtilities_toUInt8Array(content);\n        const blob = new Blob([binaryData.buffer], { type: mimeType });\n        const dataUrl = window.URL.createObjectURL(blob);\n        const anchor = document.createElement(\"a\");\n        anchor.style = \"display: none\";\n        anchor.href = dataUrl;\n        anchor.download = fileName;\n        anchor.rel = \"noopener\";\n        anchor.click();\n        anchor.remove();\n        window.setTimeout(() => {\n            URL.revokeObjectURL(dataUrl);\n        }, 40 * 1000);\n    }\n}\n\nexport function ByteArrayExtensions_AsDataUrl_6C95DA22(content) {\n    const binaryData = InternalUtilities_toUInt8Array(content);\n    const blob = new Blob([binaryData.buffer], { type: \"application/octet-stream\" });\n    return window.URL.createObjectURL(blob);\n}\n\nexport function ByteArrayExtensions_AsDataUrl_72B26259(content, mimeType) {\n    const binaryData = InternalUtilities_toUInt8Array(content);\n    const blob = new Blob([binaryData.buffer], { type: mimeType });\n    return window.URL.createObjectURL(blob);\n}\n\n","import { HttpResponse, HttpRequest, RequestBody, HttpMethod as HttpMethod_1 } from \"./Types.fs.js\";\nimport { empty } from \"../fable-library.3.6.3/List.js\";\nimport { singleton } from \"../fable-library.3.6.3/AsyncBuilder.js\";\nimport { isCancellationRequested, fromContinuations, cancellationToken } from \"../fable-library.3.6.3/Async.js\";\nimport { getEnumerator } from \"../fable-library.3.6.3/Util.js\";\nimport { some } from \"../fable-library.3.6.3/Option.js\";\nimport { InternalUtilities_toUInt8Array } from \"./Extensions.fs.js\";\n\nconst defaultRequestConfig = new HttpRequest(new HttpMethod_1(0), \"/\", empty(), new RequestBody(0), false);\n\nexport function get$(url) {\n    return new HttpRequest(new HttpMethod_1(0), url, defaultRequestConfig.Headers, defaultRequestConfig.RequestBody, defaultRequestConfig.WithCredentials);\n}\n\nexport function post(url) {\n    return new HttpRequest(new HttpMethod_1(1), url, defaultRequestConfig.Headers, defaultRequestConfig.RequestBody, defaultRequestConfig.WithCredentials);\n}\n\nexport function request(method, url) {\n    return new HttpRequest(method, url, defaultRequestConfig.Headers, defaultRequestConfig.RequestBody, defaultRequestConfig.WithCredentials);\n}\n\nexport function withHeaders(headers, req) {\n    return new HttpRequest(req.HttpMethod, req.Url, headers, req.RequestBody, req.WithCredentials);\n}\n\nexport function withCredentials(withCredentials_1, req) {\n    return new HttpRequest(req.HttpMethod, req.Url, req.Headers, req.RequestBody, withCredentials_1);\n}\n\nexport function withBody(body, req) {\n    return new HttpRequest(req.HttpMethod, req.Url, req.Headers, body, req.WithCredentials);\n}\n\nfunction sendAndRead(preparation, resultMapper, req) {\n    return singleton.Delay(() => singleton.Bind(cancellationToken(), (_arg1) => {\n        const token = _arg1;\n        return singleton.ReturnFrom(fromContinuations((tupledArg) => {\n            const xhr = new XMLHttpRequest();\n            if (req.HttpMethod.tag === 1) {\n                xhr.open(\"POST\", req.Url);\n            }\n            else {\n                xhr.open(\"GET\", req.Url);\n            }\n            if (preparation != null) {\n                preparation(xhr);\n            }\n            token.register(() => {\n                xhr.abort();\n                tupledArg[2](new Error(token));\n            });\n            const enumerator = getEnumerator(req.Headers);\n            try {\n                while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                    const forLoopVar = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                    xhr.setRequestHeader(forLoopVar[0], forLoopVar[1]);\n                }\n            }\n            finally {\n                enumerator.Dispose();\n            }\n            xhr.withCredentials = req.WithCredentials;\n            xhr.onreadystatechange = (() => {\n                const matchValue_1 = xhr.readyState | 0;\n                let pattern_matching_result;\n                if (matchValue_1 === 4) {\n                    if (!isCancellationRequested(token)) {\n                        pattern_matching_result = 0;\n                    }\n                    else {\n                        pattern_matching_result = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n                switch (pattern_matching_result) {\n                    case 0: {\n                        tupledArg[0](resultMapper(xhr));\n                        break;\n                    }\n                    case 1: {\n                        break;\n                    }\n                }\n            });\n            const matchValue_2 = req.RequestBody;\n            switch (matchValue_2.tag) {\n                case 1: {\n                    xhr.send(some(matchValue_2.fields[0]));\n                    break;\n                }\n                case 2: {\n                    xhr.send(some(InternalUtilities_toUInt8Array(matchValue_2.fields[0])));\n                    break;\n                }\n                default: {\n                    xhr.send();\n                }\n            }\n        }));\n    }));\n}\n\nexport const send = (req) => sendAndRead(void 0, (xhr) => (new HttpResponse(xhr.status, xhr.responseText)), req);\n\nexport const sendAndReadBinary = (req) => sendAndRead((xhr) => {\n    xhr.responseType = \"arraybuffer\";\n}, (xhr_1) => [new Uint8Array(xhr_1.response), xhr_1.status], req);\n\n","import { Union } from \"../fable-library.3.6.3/Types.js\";\nimport { union_type, class_type, list_type, bool_type, string_type, float64_type } from \"../fable-library.3.6.3/Reflection.js\";\n\nexport class Json extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"JNumber\", \"JString\", \"JBool\", \"JNull\", \"JArray\", \"JObject\"];\n    }\n}\n\nexport function Json$reflection() {\n    return union_type(\"Fable.SimpleJson.Json\", [], Json, () => [[[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [], [[\"Item\", list_type(Json$reflection())]], [[\"Item\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, Json$reflection()])]]]);\n}\n\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { singleton, ofArrayWithTail, head, tail, isEmpty as isEmpty_1, FSharpList, fold as fold_1, empty as empty_1, cons } from \"./List.js\";\r\nimport { fill } from \"./Array.js\";\r\nimport { structuralHash, compare, toIterator, equals, getEnumerator, isArrayLike } from \"./Util.js\";\r\nimport { Record } from \"./Types.js\";\r\nimport { tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, map as map_1, unfold } from \"./Seq.js\";\r\nimport { format, join } from \"./String.js\";\r\nimport { LanguagePrimitives_FastGenericComparer } from \"./FSharp.Core.js\";\r\n\r\nexport class MapTreeLeaf$2 {\r\n    constructor(k, v) {\r\n        this.k = k;\r\n        this.v = v;\r\n    }\r\n}\r\n\r\nexport function MapTreeLeaf$2$reflection(gen0, gen1) {\r\n    return class_type(\"Map.MapTreeLeaf`2\", [gen0, gen1], MapTreeLeaf$2);\r\n}\r\n\r\nexport function MapTreeLeaf$2_$ctor_5BDDA1(k, v) {\r\n    return new MapTreeLeaf$2(k, v);\r\n}\r\n\r\nexport function MapTreeLeaf$2__get_Key(_) {\r\n    return _.k;\r\n}\r\n\r\nexport function MapTreeLeaf$2__get_Value(_) {\r\n    return _.v;\r\n}\r\n\r\nexport class MapTreeNode$2 extends MapTreeLeaf$2 {\r\n    constructor(k, v, left, right, h) {\r\n        super(k, v);\r\n        this.left = left;\r\n        this.right = right;\r\n        this.h = (h | 0);\r\n    }\r\n}\r\n\r\nexport function MapTreeNode$2$reflection(gen0, gen1) {\r\n    return class_type(\"Map.MapTreeNode`2\", [gen0, gen1], MapTreeNode$2, MapTreeLeaf$2$reflection(gen0, gen1));\r\n}\r\n\r\nexport function MapTreeNode$2_$ctor_499A11FD(k, v, left, right, h) {\r\n    return new MapTreeNode$2(k, v, left, right, h);\r\n}\r\n\r\nexport function MapTreeNode$2__get_Left(_) {\r\n    return _.left;\r\n}\r\n\r\nexport function MapTreeNode$2__get_Right(_) {\r\n    return _.right;\r\n}\r\n\r\nexport function MapTreeNode$2__get_Height(_) {\r\n    return _.h;\r\n}\r\n\r\nexport function MapTreeModule_empty() {\r\n    return void 0;\r\n}\r\n\r\nexport function MapTreeModule_sizeAux(acc_mut, m_mut) {\r\n    MapTreeModule_sizeAux:\r\n    while (true) {\r\n        const acc = acc_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                acc_mut = MapTreeModule_sizeAux(acc + 1, MapTreeNode$2__get_Left(m2));\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_sizeAux;\r\n            }\r\n            else {\r\n                return (acc + 1) | 0;\r\n            }\r\n        }\r\n        else {\r\n            return acc | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_size(x) {\r\n    return MapTreeModule_sizeAux(0, x);\r\n}\r\n\r\nexport function MapTreeModule_mk(l, k, v, r) {\r\n    let hl;\r\n    const m = l;\r\n    if (m != null) {\r\n        const m2 = m;\r\n        hl = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\r\n    }\r\n    else {\r\n        hl = 0;\r\n    }\r\n    let hr;\r\n    const m_1 = r;\r\n    if (m_1 != null) {\r\n        const m2_1 = m_1;\r\n        hr = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\r\n    }\r\n    else {\r\n        hr = 0;\r\n    }\r\n    const m_2 = ((hl < hr) ? hr : hl) | 0;\r\n    if (m_2 === 0) {\r\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n    }\r\n    else {\r\n        return MapTreeNode$2_$ctor_499A11FD(k, v, l, r, m_2 + 1);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_rebalance(t1, k, v, t2) {\r\n    let m_2, m2_2, m_3, m2_3;\r\n    let t1h;\r\n    const m = t1;\r\n    if (m != null) {\r\n        const m2 = m;\r\n        t1h = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\r\n    }\r\n    else {\r\n        t1h = 0;\r\n    }\r\n    let t2h;\r\n    const m_1 = t2;\r\n    if (m_1 != null) {\r\n        const m2_1 = m_1;\r\n        t2h = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\r\n    }\r\n    else {\r\n        t2h = 0;\r\n    }\r\n    if (t2h > (t1h + 2)) {\r\n        const matchValue = value_1(t2);\r\n        if (matchValue instanceof MapTreeNode$2) {\r\n            if (((m_2 = MapTreeNode$2__get_Left(matchValue), (m_2 != null) ? ((m2_2 = m_2, (m2_2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_2) : 1)) : 0)) > (t1h + 1)) {\r\n                const matchValue_1 = value_1(MapTreeNode$2__get_Left(matchValue));\r\n                if (matchValue_1 instanceof MapTreeNode$2) {\r\n                    return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue_1)), MapTreeLeaf$2__get_Key(matchValue_1), MapTreeLeaf$2__get_Value(matchValue_1), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_1), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue)));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Map.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue)), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Map.rebalance\"));\r\n        }\r\n    }\r\n    else if (t1h > (t2h + 2)) {\r\n        const matchValue_2 = value_1(t1);\r\n        if (matchValue_2 instanceof MapTreeNode$2) {\r\n            if (((m_3 = MapTreeNode$2__get_Right(matchValue_2), (m_3 != null) ? ((m2_3 = m_3, (m2_3 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_3) : 1)) : 0)) > (t2h + 1)) {\r\n                const matchValue_3 = value_1(MapTreeNode$2__get_Right(matchValue_2));\r\n                if (matchValue_3 instanceof MapTreeNode$2) {\r\n                    return MapTreeModule_mk(MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeNode$2__get_Left(matchValue_3)), MapTreeLeaf$2__get_Key(matchValue_3), MapTreeLeaf$2__get_Value(matchValue_3), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_3), k, v, t2));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Map.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_2), k, v, t2));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Map.rebalance\"));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_mk(t1, k, v, t2);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_add(comparer, k, v, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else if (c < 0) {\r\n            return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeModule_empty(), m, 2);\r\n        }\r\n        else if (c === 0) {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n        }\r\n        else {\r\n            return MapTreeNode$2_$ctor_499A11FD(k, v, m, MapTreeModule_empty(), 2);\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_tryFind(comparer_mut, k_mut, m_mut) {\r\n    MapTreeModule_tryFind:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c === 0) {\r\n                return some(MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n            else if (m2 instanceof MapTreeNode$2) {\r\n                comparer_mut = comparer;\r\n                k_mut = k;\r\n                m_mut = ((c < 0) ? MapTreeNode$2__get_Left(m2) : MapTreeNode$2__get_Right(m2));\r\n                continue MapTreeModule_tryFind;\r\n            }\r\n            else {\r\n                return void 0;\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_find(comparer, k, m) {\r\n    const matchValue = MapTreeModule_tryFind(comparer, k, m);\r\n    if (matchValue == null) {\r\n        throw (new Error());\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partition1(comparer, f, k, v, acc1, acc2) {\r\n    if (f(k, v)) {\r\n        return [MapTreeModule_add(comparer, k, v, acc1), acc2];\r\n    }\r\n    else {\r\n        return [acc1, MapTreeModule_add(comparer, k, v, acc2)];\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partitionAux(comparer_mut, f_mut, m_mut, acc_0_mut, acc_1_mut) {\r\n    MapTreeModule_partitionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\r\n        const acc = [acc_0, acc_1];\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const acc_2 = MapTreeModule_partitionAux(comparer, f, MapTreeNode$2__get_Right(m2), acc[0], acc[1]);\r\n                const acc_3 = MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_2[0], acc_2[1]);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Left(m2);\r\n                acc_0_mut = acc_3[0];\r\n                acc_1_mut = acc_3[1];\r\n                continue MapTreeModule_partitionAux;\r\n            }\r\n            else {\r\n                return MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc[0], acc[1]);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partition(comparer, f, m) {\r\n    return MapTreeModule_partitionAux(comparer, f, m, MapTreeModule_empty(), MapTreeModule_empty());\r\n}\r\n\r\nexport function MapTreeModule_filter1(comparer, f, k, v, acc) {\r\n    if (f(k, v)) {\r\n        return MapTreeModule_add(comparer, k, v, acc);\r\n    }\r\n    else {\r\n        return acc;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_filterAux(comparer_mut, f_mut, m_mut, acc_mut) {\r\n    MapTreeModule_filterAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc = acc_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const acc_1 = MapTreeModule_filterAux(comparer, f, MapTreeNode$2__get_Left(m2), acc);\r\n                const acc_2 = MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_1);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                acc_mut = acc_2;\r\n                continue MapTreeModule_filterAux;\r\n            }\r\n            else {\r\n                return MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_filter(comparer, f, m) {\r\n    return MapTreeModule_filterAux(comparer, f, m, MapTreeModule_empty());\r\n}\r\n\r\nexport function MapTreeModule_spliceOutSuccessor(m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (MapTreeNode$2__get_Left(m2) == null) {\r\n                return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2)];\r\n            }\r\n            else {\r\n                const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Left(m2));\r\n                return [patternInput[0], patternInput[1], MapTreeModule_mk(patternInput[2], MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2))];\r\n            }\r\n        }\r\n        else {\r\n            return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_empty()];\r\n        }\r\n    }\r\n    else {\r\n        throw (new Error(\"internal error: Map.spliceOutSuccessor\"));\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_remove(comparer, k, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                if (MapTreeNode$2__get_Left(m2) == null) {\r\n                    return MapTreeNode$2__get_Right(m2);\r\n                }\r\n                else if (MapTreeNode$2__get_Right(m2) == null) {\r\n                    return MapTreeNode$2__get_Left(m2);\r\n                }\r\n                else {\r\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\r\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else if (c === 0) {\r\n            return MapTreeModule_empty();\r\n        }\r\n        else {\r\n            return m;\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_change(comparer, k, u, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                const matchValue_1 = u(some(MapTreeLeaf$2__get_Value(m2)));\r\n                if (matchValue_1 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_1), MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\r\n                }\r\n                else if (MapTreeNode$2__get_Left(m2) == null) {\r\n                    return MapTreeNode$2__get_Right(m2);\r\n                }\r\n                else if (MapTreeNode$2__get_Right(m2) == null) {\r\n                    return MapTreeNode$2__get_Left(m2);\r\n                }\r\n                else {\r\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\r\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c_1 < 0) {\r\n                const matchValue_2 = u(void 0);\r\n                if (matchValue_2 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_2), MapTreeModule_empty(), m, 2);\r\n                }\r\n                else {\r\n                    return m;\r\n                }\r\n            }\r\n            else if (c_1 === 0) {\r\n                const matchValue_3 = u(some(MapTreeLeaf$2__get_Value(m2)));\r\n                if (matchValue_3 != null) {\r\n                    return MapTreeLeaf$2_$ctor_5BDDA1(k, value_1(matchValue_3));\r\n                }\r\n                else {\r\n                    return MapTreeModule_empty();\r\n                }\r\n            }\r\n            else {\r\n                const matchValue_4 = u(void 0);\r\n                if (matchValue_4 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_4), m, MapTreeModule_empty(), 2);\r\n                }\r\n                else {\r\n                    return m;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        const matchValue = u(void 0);\r\n        if (matchValue != null) {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, value_1(matchValue));\r\n        }\r\n        else {\r\n            return m;\r\n        }\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {\r\n    MapTreeModule_mem:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (c < 0) {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    m_mut = MapTreeNode$2__get_Left(m2);\r\n                    continue MapTreeModule_mem;\r\n                }\r\n                else if (c === 0) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_mem;\r\n                }\r\n            }\r\n            else {\r\n                return c === 0;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_iterOpt(f_mut, m_mut) {\r\n    MapTreeModule_iterOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                MapTreeModule_iterOpt(f, MapTreeNode$2__get_Left(m2));\r\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_iterOpt;\r\n            }\r\n            else {\r\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_iter(f, m) {\r\n    MapTreeModule_iterOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_tryPickOpt(f_mut, m_mut) {\r\n    MapTreeModule_tryPickOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const matchValue = MapTreeModule_tryPickOpt(f, MapTreeNode$2__get_Left(m2));\r\n                if (matchValue == null) {\r\n                    const matchValue_1 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                    if (matchValue_1 == null) {\r\n                        f_mut = f;\r\n                        m_mut = MapTreeNode$2__get_Right(m2);\r\n                        continue MapTreeModule_tryPickOpt;\r\n                    }\r\n                    else {\r\n                        return matchValue_1;\r\n                    }\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_tryPick(f, m) {\r\n    return MapTreeModule_tryPickOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_existsOpt(f_mut, m_mut) {\r\n    MapTreeModule_existsOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (MapTreeModule_existsOpt(f, MapTreeNode$2__get_Left(m2)) ? true : f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_existsOpt;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_exists(f, m) {\r\n    return MapTreeModule_existsOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_forallOpt(f_mut, m_mut) {\r\n    MapTreeModule_forallOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (MapTreeModule_forallOpt(f, MapTreeNode$2__get_Left(m2)) && f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\r\n                    f_mut = f;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_forallOpt;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_forall(f, m) {\r\n    return MapTreeModule_forallOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_map(f, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const l2 = MapTreeModule_map(f, MapTreeNode$2__get_Left(m2));\r\n            const v2 = f(MapTreeLeaf$2__get_Value(m2));\r\n            const r2 = MapTreeModule_map(f, MapTreeNode$2__get_Right(m2));\r\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\r\n        }\r\n        else {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Value(m2)));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mapiOpt(f, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const l2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Left(m2));\r\n            const v2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            const r2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Right(m2));\r\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\r\n        }\r\n        else {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mapi(f, m) {\r\n    return MapTreeModule_mapiOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_foldBackOpt(f_mut, m_mut, x_mut) {\r\n    MapTreeModule_foldBackOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut, x = x_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const x_1 = MapTreeModule_foldBackOpt(f, MapTreeNode$2__get_Right(m2), x);\r\n                const x_2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Left(m2);\r\n                x_mut = x_2;\r\n                continue MapTreeModule_foldBackOpt;\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x);\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_foldBack(f, m, x) {\r\n    return MapTreeModule_foldBackOpt(f, m, x);\r\n}\r\n\r\nexport function MapTreeModule_foldOpt(f_mut, x_mut, m_mut) {\r\n    MapTreeModule_foldOpt:\r\n    while (true) {\r\n        const f = f_mut, x = x_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                f_mut = f;\r\n                x_mut = f(MapTreeModule_foldOpt(f, x, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_foldOpt;\r\n            }\r\n            else {\r\n                return f(x, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_fold(f, x, m) {\r\n    return MapTreeModule_foldOpt(f, x, m);\r\n}\r\n\r\nexport function MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x) {\r\n    const foldFromTo = (f_1_mut, m_1_mut, x_1_mut) => {\r\n        foldFromTo:\r\n        while (true) {\r\n            const f_1 = f_1_mut, m_1 = m_1_mut, x_1 = x_1_mut;\r\n            if (m_1 != null) {\r\n                const m2 = m_1;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    const cLoKey = comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n                    const cKeyHi = comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) | 0;\r\n                    const x_2 = (cLoKey < 0) ? foldFromTo(f_1, MapTreeNode$2__get_Left(m2), x_1) : x_1;\r\n                    const x_3 = ((cLoKey <= 0) && (cKeyHi <= 0)) ? f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_2) : x_2;\r\n                    if (cKeyHi < 0) {\r\n                        f_1_mut = f_1;\r\n                        m_1_mut = MapTreeNode$2__get_Right(m2);\r\n                        x_1_mut = x_3;\r\n                        continue foldFromTo;\r\n                    }\r\n                    else {\r\n                        return x_3;\r\n                    }\r\n                }\r\n                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) <= 0) && (comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) <= 0)) {\r\n                    return f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\r\n                }\r\n                else {\r\n                    return x_1;\r\n                }\r\n            }\r\n            else {\r\n                return x_1;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (comparer.Compare(lo, hi) === 1) {\r\n        return x;\r\n    }\r\n    else {\r\n        return foldFromTo(f, m, x);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_foldSection(comparer, lo, hi, f, m, x) {\r\n    return MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x);\r\n}\r\n\r\nexport function MapTreeModule_toList(m) {\r\n    const loop = (m_1_mut, acc_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const m_1 = m_1_mut, acc = acc_mut;\r\n            if (m_1 != null) {\r\n                const m2 = m_1;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    m_1_mut = MapTreeNode$2__get_Left(m2);\r\n                    acc_mut = cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], loop(MapTreeNode$2__get_Right(m2), acc));\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], acc);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(m, empty_1());\r\n}\r\n\r\nexport function MapTreeModule_copyToArray(m, arr, i) {\r\n    let j = i;\r\n    MapTreeModule_iter((x, y) => {\r\n        arr[j] = [x, y];\r\n        j = ((j + 1) | 0);\r\n    }, m);\r\n}\r\n\r\nexport function MapTreeModule_toArray(m) {\r\n    const n = MapTreeModule_size(m) | 0;\r\n    const res = fill(new Array(n), 0, n, [null, null]);\r\n    MapTreeModule_copyToArray(m, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function MapTreeModule_ofList(comparer, l) {\r\n    return fold_1((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);\r\n}\r\n\r\nexport function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\r\n    MapTreeModule_mkFromEnumerator:\r\n    while (true) {\r\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const patternInput = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            comparer_mut = comparer;\r\n            acc_mut = MapTreeModule_add(comparer, patternInput[0], patternInput[1], acc);\r\n            e_mut = e;\r\n            continue MapTreeModule_mkFromEnumerator;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_ofArray(comparer, arr) {\r\n    let res = MapTreeModule_empty();\r\n    for (let idx = 0; idx <= (arr.length - 1); idx++) {\r\n        const forLoopVar = arr[idx];\r\n        res = MapTreeModule_add(comparer, forLoopVar[0], forLoopVar[1], res);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function MapTreeModule_ofSeq(comparer, c) {\r\n    if (isArrayLike(c)) {\r\n        return MapTreeModule_ofArray(comparer, c);\r\n    }\r\n    else if (c instanceof FSharpList) {\r\n        return MapTreeModule_ofList(comparer, c);\r\n    }\r\n    else {\r\n        const ie = getEnumerator(c);\r\n        try {\r\n            return MapTreeModule_mkFromEnumerator(comparer, MapTreeModule_empty(), ie);\r\n        }\r\n        finally {\r\n            ie.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport class MapTreeModule_MapIterator$2 extends Record {\r\n    constructor(stack, started) {\r\n        super();\r\n        this.stack = stack;\r\n        this.started = started;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_MapIterator$2$reflection(gen0, gen1) {\r\n    return record_type(\"Map.MapTreeModule.MapIterator`2\", [gen0, gen1], MapTreeModule_MapIterator$2, () => [[\"stack\", list_type(option_type(MapTreeLeaf$2$reflection(gen0, gen1)))], [\"started\", bool_type]]);\r\n}\r\n\r\nexport function MapTreeModule_collapseLHS(stack_mut) {\r\n    MapTreeModule_collapseLHS:\r\n    while (true) {\r\n        const stack = stack_mut;\r\n        if (!isEmpty_1(stack)) {\r\n            const rest = tail(stack);\r\n            const m = head(stack);\r\n            if (m != null) {\r\n                const m2 = m;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    stack_mut = ofArrayWithTail([MapTreeNode$2__get_Left(m2), MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)), MapTreeNode$2__get_Right(m2)], rest);\r\n                    continue MapTreeModule_collapseLHS;\r\n                }\r\n                else {\r\n                    return stack;\r\n                }\r\n            }\r\n            else {\r\n                stack_mut = rest;\r\n                continue MapTreeModule_collapseLHS;\r\n            }\r\n        }\r\n        else {\r\n            return empty_1();\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mkIterator(m) {\r\n    return new MapTreeModule_MapIterator$2(MapTreeModule_collapseLHS(singleton(m)), false);\r\n}\r\n\r\nexport function MapTreeModule_notStarted() {\r\n    throw (new Error(\"enumeration not started\"));\r\n}\r\n\r\nexport function MapTreeModule_alreadyFinished() {\r\n    throw (new Error(\"enumeration already finished\"));\r\n}\r\n\r\nexport function MapTreeModule_current(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const m = head(matchValue);\r\n                if (m instanceof MapTreeNode$2) {\r\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\r\n                }\r\n                else {\r\n                    return [MapTreeLeaf$2__get_Key(m), MapTreeLeaf$2__get_Value(m)];\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\r\n            }\r\n        }\r\n        else {\r\n            return MapTreeModule_alreadyFinished();\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_notStarted();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_moveNext(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const m = head(matchValue);\r\n                if (m instanceof MapTreeNode$2) {\r\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\r\n                }\r\n                else {\r\n                    i.stack = MapTreeModule_collapseLHS(tail(matchValue));\r\n                    return !isEmpty_1(i.stack);\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else {\r\n        i.started = true;\r\n        return !isEmpty_1(i.stack);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mkIEnumerator(m) {\r\n    let i = MapTreeModule_mkIterator(m);\r\n    return {\r\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n            return MapTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.get_Current\"]() {\r\n            return MapTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n            return MapTreeModule_moveNext(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.Reset\"]() {\r\n            i = MapTreeModule_mkIterator(m);\r\n        },\r\n        Dispose() {\r\n        },\r\n    };\r\n}\r\n\r\nexport function MapTreeModule_toSeq(s) {\r\n    return unfold((en_1) => {\r\n        if (en_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return [en_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), en_1];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, MapTreeModule_mkIEnumerator(s));\r\n}\r\n\r\nexport class FSharpMap {\r\n    constructor(comparer, tree) {\r\n        this.comparer = comparer;\r\n        this.tree = tree;\r\n    }\r\n    GetHashCode() {\r\n        const this$ = this;\r\n        return FSharpMap__ComputeHashCode(this$) | 0;\r\n    }\r\n    Equals(that) {\r\n        const this$ = this;\r\n        if (that instanceof FSharpMap) {\r\n            const e1 = getEnumerator(this$);\r\n            try {\r\n                const e2 = getEnumerator(that);\r\n                try {\r\n                    const loop = () => {\r\n                        const m1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                        if (m1 === e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            if (!m1) {\r\n                                return true;\r\n                            }\r\n                            else {\r\n                                const e1c = e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                                const e2c = e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                                if (equals(e1c[0], e2c[0]) && equals(e1c[1], e2c[1])) {\r\n                                    return loop();\r\n                                }\r\n                                else {\r\n                                    return false;\r\n                                }\r\n                            }\r\n                        }\r\n                        else {\r\n                            return false;\r\n                        }\r\n                    };\r\n                    return loop();\r\n                }\r\n                finally {\r\n                    e2.Dispose();\r\n                }\r\n            }\r\n            finally {\r\n                e1.Dispose();\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    toString() {\r\n        const this$ = this;\r\n        return (\"map [\" + join(\"; \", map_1((kv) => format(\"({0}, {1})\", kv[0], kv[1]), this$))) + \"]\";\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"FSharpMap\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const __ = this;\r\n        return MapTreeModule_mkIEnumerator(__.tree);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const __ = this;\r\n        return MapTreeModule_mkIEnumerator(__.tree);\r\n    }\r\n    CompareTo(obj) {\r\n        const m = this;\r\n        if (obj instanceof FSharpMap) {\r\n            return compareWith((kvp1, kvp2) => {\r\n                const c = m.comparer.Compare(kvp1[0], kvp2[0]) | 0;\r\n                return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;\r\n            }, m, obj) | 0;\r\n        }\r\n        else {\r\n            throw (new Error(\"not comparable\\\\nParameter name: obj\"));\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\r\n        const m = this;\r\n        return FSharpMap__ContainsKey(m, x[0]) && equals(FSharpMap__get_Item(m, x[0]), x[1]);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\r\n        const m = this;\r\n        MapTreeModule_copyToArray(m.tree, arr, i);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return true;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    get size() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    clear() {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    delete(_arg1) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n        return false;\r\n    }\r\n    entries() {\r\n        const m = this;\r\n        return map_1((p) => [p[0], p[1]], m);\r\n    }\r\n    get(k) {\r\n        const m = this;\r\n        return FSharpMap__get_Item(m, k);\r\n    }\r\n    has(k) {\r\n        const m = this;\r\n        return FSharpMap__ContainsKey(m, k);\r\n    }\r\n    keys() {\r\n        const m = this;\r\n        return map_1((p) => p[0], m);\r\n    }\r\n    set(k, v) {\r\n        const m = this;\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n        return m;\r\n    }\r\n    values() {\r\n        const m = this;\r\n        return map_1((p) => p[1], m);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const m = this;\r\n        iterate_1((p) => {\r\n            f(p[1], p[0], m);\r\n        }, m);\r\n    }\r\n}\r\n\r\nexport function FSharpMap$reflection(gen0, gen1) {\r\n    return class_type(\"Map.FSharpMap\", [gen0, gen1], FSharpMap);\r\n}\r\n\r\nexport function FSharpMap_$ctor(comparer, tree) {\r\n    return new FSharpMap(comparer, tree);\r\n}\r\n\r\n(() => {\r\n    FSharpMap.empty = FSharpMap_$ctor(LanguagePrimitives_FastGenericComparer(), MapTreeModule_empty());\r\n})();\r\n\r\nexport function FSharpMap_get_Empty() {\r\n    return FSharpMap.empty;\r\n}\r\n\r\nexport function FSharpMap_Create(ie) {\r\n    const comparer = LanguagePrimitives_FastGenericComparer();\r\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, ie));\r\n}\r\n\r\nexport function FSharpMap__get_Comparer(m) {\r\n    return m.comparer;\r\n}\r\n\r\nexport function FSharpMap__get_Tree(m) {\r\n    return m.tree;\r\n}\r\n\r\nexport function FSharpMap__Add(m, key, value) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_add(m.comparer, key, value, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Change(m, key, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_change(m.comparer, key, f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__get_IsEmpty(m) {\r\n    return m.tree == null;\r\n}\r\n\r\nexport function FSharpMap__get_Item(m, key) {\r\n    return MapTreeModule_find(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__TryPick(m, f) {\r\n    return MapTreeModule_tryPick(f, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Exists(m, predicate) {\r\n    return MapTreeModule_exists(predicate, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Filter(m, predicate) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_filter(m.comparer, predicate, m.tree));\r\n}\r\n\r\nexport function FSharpMap__ForAll(m, predicate) {\r\n    return MapTreeModule_forall(predicate, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Fold(m, f, acc) {\r\n    return MapTreeModule_foldBack(f, m.tree, acc);\r\n}\r\n\r\nexport function FSharpMap__FoldSection(m, lo, hi, f, acc) {\r\n    return MapTreeModule_foldSection(m.comparer, lo, hi, f, m.tree, acc);\r\n}\r\n\r\nexport function FSharpMap__Iterate(m, f) {\r\n    MapTreeModule_iter(f, m.tree);\r\n}\r\n\r\nexport function FSharpMap__MapRange(m, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_map(f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Map(m, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_mapi(f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Partition(m, predicate) {\r\n    const patternInput = MapTreeModule_partition(m.comparer, predicate, m.tree);\r\n    return [FSharpMap_$ctor(m.comparer, patternInput[0]), FSharpMap_$ctor(m.comparer, patternInput[1])];\r\n}\r\n\r\nexport function FSharpMap__get_Count(m) {\r\n    return MapTreeModule_size(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ContainsKey(m, key) {\r\n    return MapTreeModule_mem(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Remove(m, key) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_remove(m.comparer, key, m.tree));\r\n}\r\n\r\nexport function FSharpMap__TryGetValue(__, key, value) {\r\n    const matchValue = MapTreeModule_tryFind(__.comparer, key, __.tree);\r\n    if (matchValue == null) {\r\n        return false;\r\n    }\r\n    else {\r\n        const v = value_1(matchValue);\r\n        value.contents = v;\r\n        return true;\r\n    }\r\n}\r\n\r\nexport function FSharpMap__get_Keys(__) {\r\n    return Array.from(map_1((kvp) => kvp[0], MapTreeModule_toSeq(__.tree)));\r\n}\r\n\r\nexport function FSharpMap__get_Values(__) {\r\n    return Array.from(map_1((kvp) => kvp[1], MapTreeModule_toSeq(__.tree)));\r\n}\r\n\r\nexport function FSharpMap__TryFind(m, key) {\r\n    return MapTreeModule_tryFind(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__ToList(m) {\r\n    return MapTreeModule_toList(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ToArray(m) {\r\n    return MapTreeModule_toArray(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ComputeHashCode(this$) {\r\n    const combineHash = (x, y) => (((x << 1) + y) + 631);\r\n    let res = 0;\r\n    const enumerator = getEnumerator(this$);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const activePatternResult5790 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            res = (combineHash(res, structuralHash(activePatternResult5790[0])) | 0);\r\n            res = (combineHash(res, structuralHash(activePatternResult5790[1])) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n    return res | 0;\r\n}\r\n\r\nexport function isEmpty(table) {\r\n    return FSharpMap__get_IsEmpty(table);\r\n}\r\n\r\nexport function add(key, value, table) {\r\n    return FSharpMap__Add(table, key, value);\r\n}\r\n\r\nexport function change(key, f, table) {\r\n    return FSharpMap__Change(table, key, f);\r\n}\r\n\r\nexport function find(key, table) {\r\n    return FSharpMap__get_Item(table, key);\r\n}\r\n\r\nexport function tryFind(key, table) {\r\n    return FSharpMap__TryFind(table, key);\r\n}\r\n\r\nexport function remove(key, table) {\r\n    return FSharpMap__Remove(table, key);\r\n}\r\n\r\nexport function containsKey(key, table) {\r\n    return FSharpMap__ContainsKey(table, key);\r\n}\r\n\r\nexport function iterate(action, table) {\r\n    FSharpMap__Iterate(table, action);\r\n}\r\n\r\nexport function tryPick(chooser, table) {\r\n    return FSharpMap__TryPick(table, chooser);\r\n}\r\n\r\nexport function pick(chooser, table) {\r\n    const matchValue = tryPick(chooser, table);\r\n    if (matchValue != null) {\r\n        return value_1(matchValue);\r\n    }\r\n    else {\r\n        throw (new Error());\r\n    }\r\n}\r\n\r\nexport function exists(predicate, table) {\r\n    return FSharpMap__Exists(table, predicate);\r\n}\r\n\r\nexport function filter(predicate, table) {\r\n    return FSharpMap__Filter(table, predicate);\r\n}\r\n\r\nexport function partition(predicate, table) {\r\n    return FSharpMap__Partition(table, predicate);\r\n}\r\n\r\nexport function forAll(predicate, table) {\r\n    return FSharpMap__ForAll(table, predicate);\r\n}\r\n\r\nexport function map(mapping, table) {\r\n    return FSharpMap__Map(table, mapping);\r\n}\r\n\r\nexport function fold(folder, state, table) {\r\n    return MapTreeModule_fold(folder, state, FSharpMap__get_Tree(table));\r\n}\r\n\r\nexport function foldBack(folder, table, state) {\r\n    return MapTreeModule_foldBack(folder, FSharpMap__get_Tree(table), state);\r\n}\r\n\r\nexport function toSeq(table) {\r\n    return map_1((kvp) => [kvp[0], kvp[1]], table);\r\n}\r\n\r\nexport function findKey(predicate, table) {\r\n    return pick_1((kvp) => {\r\n        const k = kvp[0];\r\n        if (predicate(k, kvp[1])) {\r\n            return some(k);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, table);\r\n}\r\n\r\nexport function tryFindKey(predicate, table) {\r\n    return tryPick_1((kvp) => {\r\n        const k = kvp[0];\r\n        if (predicate(k, kvp[1])) {\r\n            return some(k);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, table);\r\n}\r\n\r\nexport function ofList(elements) {\r\n    return FSharpMap_Create(elements);\r\n}\r\n\r\nexport function ofSeq(elements) {\r\n    return FSharpMap_Create(elements);\r\n}\r\n\r\nexport function ofArray(elements) {\r\n    const comparer = LanguagePrimitives_FastGenericComparer();\r\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofArray(comparer, elements));\r\n}\r\n\r\nexport function toList(table) {\r\n    return FSharpMap__ToList(table);\r\n}\r\n\r\nexport function toArray(table) {\r\n    return FSharpMap__ToArray(table);\r\n}\r\n\r\nexport function empty() {\r\n    return FSharpMap_get_Empty();\r\n}\r\n\r\nexport function count(table) {\r\n    return FSharpMap__get_Count(table);\r\n}\r\n\r\n","import { FSharpRef } from \"./Types.js\";\nexport function tryParse(str, defValue) {\n    // TODO: test if value is valid and in range\n    if (str != null && /\\S/.test(str)) {\n        const v = +str.replace(\"_\", \"\");\n        if (!Number.isNaN(v)) {\n            defValue.contents = v;\n            return true;\n        }\n    }\n    return false;\n}\nexport function parse(str) {\n    const defValue = new FSharpRef(0);\n    if (tryParse(str, defValue)) {\n        return defValue.contents;\n    }\n    else {\n        throw new Error(\"Input string was not in a correct format.\");\n    }\n}\n// JS Number.isFinite function evals false for NaN\nexport function isInfinity(x) {\n    return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;\n}\n","// Adapted from https://github.com/MikeMcl/big.js/blob/0f94dc9110d55c4f324a47ba6a2e832ce23ac589/big.mjs\n/* tslint:disable */\nimport { combineHashCodes } from \"../Util.js\";\nimport { symbol } from \"../Numeric.js\";\n// The shared prototype object.\nvar P = {\n    GetHashCode() { return combineHashCodes([this.s, this.e].concat(this.c)); },\n    Equals(x) { return !this.cmp(x); },\n    CompareTo(x) { return this.cmp(x); },\n    [symbol]() {\n        const _this = this;\n        return {\n            multiply: y => _this.mul(y),\n            toPrecision: sd => _this.toPrecision(sd),\n            toExponential: dp => _this.toExponential(dp),\n            toFixed: dp => _this.toFixed(dp),\n            toHex: () => (Number(_this) >>> 0).toString(16),\n        };\n    }\n};\n/*\n *  big.js v6.0.3\n *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.\n *  Copyright (c) 2020 Michael Mclaughlin\n *  https://github.com/MikeMcl/big.js/LICENCE.md\n */\n/************************************** EDITABLE DEFAULTS *****************************************/\n// The default values below must be integers within the stated ranges.\n/*\n * The maximum number of decimal places (DP) of the results of operations involving division:\n * div and sqrt, and pow with negative exponents.\n */\nvar DP = 28, // 0 to MAX_DP\n/*\n * The rounding mode (RM) used when rounding to the above decimal places.\n *\n *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)\n *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)\n *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)\n *  3  Away from zero.                                  (ROUND_UP)\n */\nRM = 1, // 0, 1, 2 or 3\n// The maximum value of DP and Big.DP.\nMAX_DP = 1E6, // 0 to 1000000\n// The maximum magnitude of the exponent argument to the pow method.\nMAX_POWER = 1E6, // 1 to 1000000\n/*\n * The negative exponent (NE) at and beneath which toString returns exponential notation.\n * (JavaScript numbers: -7)\n * -1000000 is the minimum recommended exponent value of a Big.\n */\nNE = -29, // 0 to -1000000\n/*\n * The positive exponent (PE) at and above which toString returns exponential notation.\n * (JavaScript numbers: 21)\n * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.\n */\nPE = 29, // 0 to 1000000\n/*\n * When true, an error will be thrown if a primitive number is passed to the Big constructor,\n * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a\n * primitive number without a loss of precision.\n */\nSTRICT = false, // true or false\n/**************************************************************************************************/\n// Error messages.\nNAME = '[big.js] ', INVALID = NAME + 'Invalid ', INVALID_DP = INVALID + 'decimal places', INVALID_RM = INVALID + 'rounding mode', DIV_BY_ZERO = NAME + 'Division by zero', UNDEFINED = void 0, NUMERIC = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i;\n/*\n * Create and return a Big constructor.\n */\nfunction _Big_() {\n    /*\n     * The Big constructor and exported function.\n     * Create and return a new instance of a Big number object.\n     *\n     * n {number|string|Big} A numeric value.\n     */\n    function Big(n) {\n        var x = this;\n        // Enable constructor usage without new.\n        if (!(x instanceof Big))\n            return n === UNDEFINED ? _Big_() : new Big(n);\n        // Duplicate.\n        if (n instanceof Big) {\n            x.s = n.s;\n            x.e = n.e;\n            x.c = n.c.slice();\n            normalize(x);\n        }\n        else {\n            if (typeof n !== 'string') {\n                if (Big.strict === true) {\n                    throw TypeError(INVALID + 'number');\n                }\n                // Minus zero?\n                n = n === 0 && 1 / n < 0 ? '-0' : String(n);\n            }\n            parse(x, n);\n        }\n        // Retain a reference to this Big constructor.\n        // Shadow Big.prototype.constructor which points to Object.\n        x.constructor = Big;\n    }\n    Big.prototype = P;\n    Big.DP = DP;\n    Big.RM = RM;\n    Big.NE = NE;\n    Big.PE = PE;\n    Big.strict = STRICT;\n    return Big;\n}\nfunction normalize(x) {\n    // x = round(x, DP, 0);\n    if (x.c.length > 1 && !x.c[0]) {\n        let i = x.c.findIndex(x => x);\n        x.c = x.c.slice(i);\n        x.e = x.e - i;\n    }\n}\n/*\n * Parse the number or string value passed to a Big constructor.\n *\n * x {Big} A Big number instance.\n * n {number|string} A numeric value.\n */\nfunction parse(x, n) {\n    var e, i, nl;\n    if (!NUMERIC.test(n)) {\n        throw Error(INVALID + 'number');\n    }\n    // Determine sign.\n    x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;\n    // Decimal point?\n    if ((e = n.indexOf('.')) > -1)\n        n = n.replace('.', '');\n    // Exponential form?\n    if ((i = n.search(/e/i)) > 0) {\n        // Determine exponent.\n        if (e < 0)\n            e = i;\n        e += +n.slice(i + 1);\n        n = n.substring(0, i);\n    }\n    else if (e < 0) {\n        // Integer.\n        e = n.length;\n    }\n    nl = n.length;\n    // Determine leading zeros before decimal point.\n    for (i = 0; i < e && i < nl && n.charAt(i) == '0';)\n        ++i;\n    // original version (ignores decimal point).\n    // // Determine leading zeros.\n    // for (i = 0; i < nl && n.charAt(i) == '0';) ++i;\n    if (i == nl) {\n        // Zero.\n        x.c = [x.e = 0];\n    }\n    else {\n        x.e = e - i - 1;\n        x.c = [];\n        // Convert string to array of digits without leading zeros\n        for (e = 0; i < nl;)\n            x.c[e++] = +n.charAt(i++);\n        // older version (doesn't keep trailing zeroes).\n        // // Determine trailing zeros.\n        // for (; nl > 0 && n.charAt(--nl) == '0';);\n        // // Convert string to array of digits without leading/trailing zeros.\n        // for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);\n    }\n    x = round(x, Big.DP + 1, Big.RM);\n    return x;\n}\n/*\n * Round Big x to a maximum of sd significant digits using rounding mode rm.\n *\n * x {Big} The Big to round.\n * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.\n * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n * [more] {boolean} Whether the result of division was truncated.\n */\nfunction round(x, sd, rm, more) {\n    var xc = x.c;\n    if (rm === UNDEFINED)\n        rm = Big.RM;\n    if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {\n        throw Error(INVALID_RM);\n    }\n    if (sd < 1) {\n        more =\n            rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 ||\n                rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));\n        xc.length = 1;\n        if (more) {\n            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\n            x.e = x.e - sd + 1;\n            xc[0] = 1;\n        }\n        else {\n            // Zero.\n            xc[0] = x.e = 0;\n        }\n    }\n    else if (sd < xc.length) {\n        // xc[sd] is the digit after the digit that may be rounded up.\n        const isZero = xc.findIndex((xci, idx) => idx >= sd && xci > 0) < 0;\n        more =\n            rm === 1 && xc[sd] >= 5 ||\n                rm === 2 && (xc[sd] > 5 || xc[sd] === 5 &&\n                    (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) ||\n                rm === 3 && (more || !isZero);\n        // Remove any digits after the required precision.\n        xc.length = sd--;\n        // Round up?\n        if (more) {\n            // Rounding up may mean the previous digit has to be rounded up.\n            for (; ++xc[sd] > 9;) {\n                xc[sd] = 0;\n                if (!sd--) {\n                    ++x.e;\n                    xc.unshift(1);\n                }\n            }\n        }\n        // Remove trailing zeros.\n        for (sd = xc.length; !xc[--sd];)\n            xc.pop();\n    }\n    return x;\n}\n/*\n * Return a string representing the value of Big x in normal or exponential notation.\n * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.\n */\nfunction stringify(x, doExponential, isNonzero) {\n    var e = x.e, s = x.c.join(''), n = s.length;\n    // Exponential notation?\n    if (doExponential) {\n        s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;\n        // Normal notation.\n    }\n    else if (e < 0) {\n        for (; ++e;)\n            s = '0' + s;\n        s = '0.' + s;\n    }\n    else if (e > 0) {\n        if (++e > n) {\n            for (e -= n; e--;)\n                s += '0';\n        }\n        else if (e < n) {\n            s = s.slice(0, e) + '.' + s.slice(e);\n        }\n    }\n    else if (n > 1) {\n        s = s.charAt(0) + '.' + s.slice(1);\n    }\n    return x.s < 0 && isNonzero ? '-' + s : s;\n}\n// Prototype/instance methods\n/*\n * Return a new Big whose value is the absolute value of this Big.\n */\nP.abs = function () {\n    var x = new this.constructor(this);\n    x.s = 1;\n    return x;\n};\n/*\n * Return 1 if the value of this Big is greater than the value of Big y,\n *       -1 if the value of this Big is less than the value of Big y, or\n *        0 if they have the same value.\n */\nP.cmp = function (y) {\n    var isneg, Big = this.constructor, x = new Big(this), y = new Big(y), xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;\n    // Either zero?\n    if (!xc[0] || !yc[0])\n        return !xc[0] ? !yc[0] ? 0 : -j : i;\n    // Signs differ?\n    if (i != j)\n        return i;\n    isneg = i < 0;\n    // Compare exponents.\n    if (k != l)\n        return k > l ^ isneg ? 1 : -1;\n    // Compare digit by digit.\n    j = Math.max(xc.length, yc.length);\n    for (i = 0; i < j; i++) {\n        k = i < xc.length ? xc[i] : 0;\n        l = i < yc.length ? yc[i] : 0;\n        if (k != l)\n            return k > l ^ isneg ? 1 : -1;\n    }\n    return 0;\n    // original version (doesn't compare well trailing zeroes, e.g. 1.0 with 1.00)\n    // j = (k = xc.length) < (l = yc.length) ? k : l;\n    // // Compare digit by digit.\n    // for (i = -1; ++i < j;) {\n    //   if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;\n    // }\n    // // Compare lengths.\n    // return k == l ? 0 : k > l ^ isneg ? 1 : -1;\n};\n/*\n * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,\n * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\n */\nP.div = function (y) {\n    var Big = this.constructor, x = new Big(this), y = new Big(y), a = x.c, // dividend\n    b = y.c, // divisor\n    k = x.s == y.s ? 1 : -1, dp = Big.DP;\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\n        throw Error(INVALID_DP);\n    }\n    // Divisor is zero?\n    if (!b[0]) {\n        throw Error(DIV_BY_ZERO);\n    }\n    // Dividend is 0? Return +-0.\n    if (!a[0]) {\n        y.s = k;\n        y.c = [y.e = 0];\n        return y;\n    }\n    var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), // remainder\n    rl = r.length, q = y, // quotient\n    qc = q.c = [], qi = 0, p = dp + (q.e = x.e - y.e) + 1; // precision of the result\n    q.s = k;\n    k = p < 0 ? 0 : p;\n    // Create version of divisor with leading zero.\n    bz.unshift(0);\n    // Add zeros to make remainder as long as divisor.\n    for (; rl++ < bl;)\n        r.push(0);\n    do {\n        // n is how many times the divisor goes into current remainder.\n        for (n = 0; n < 10; n++) {\n            // Compare divisor and remainder.\n            if (bl != (rl = r.length)) {\n                cmp = bl > rl ? 1 : -1;\n            }\n            else {\n                for (ri = -1, cmp = 0; ++ri < bl;) {\n                    if (b[ri] != r[ri]) {\n                        cmp = b[ri] > r[ri] ? 1 : -1;\n                        break;\n                    }\n                }\n            }\n            // If divisor < remainder, subtract divisor from remainder.\n            if (cmp < 0) {\n                // Remainder can't be more than 1 digit longer than divisor.\n                // Equalise lengths using divisor with extra leading zero?\n                for (bt = rl == bl ? b : bz; rl;) {\n                    if (r[--rl] < bt[rl]) {\n                        ri = rl;\n                        for (; ri && !r[--ri];)\n                            r[ri] = 9;\n                        --r[ri];\n                        r[rl] += 10;\n                    }\n                    r[rl] -= bt[rl];\n                }\n                for (; !r[0];)\n                    r.shift();\n            }\n            else {\n                break;\n            }\n        }\n        // Add the digit n to the result array.\n        qc[qi++] = cmp ? n : ++n;\n        // Update the remainder.\n        if (r[0] && cmp)\n            r[rl] = a[ai] || 0;\n        else\n            r = [a[ai]];\n    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);\n    // Leading zero? Do not remove if result is simply zero (qi == 1).\n    if (!qc[0] && qi != 1) {\n        // There can't be more than one zero.\n        qc.shift();\n        q.e--;\n        p--;\n    }\n    // Round?\n    if (qi > p)\n        round(q, p, Big.RM, r[0] !== UNDEFINED);\n    return q;\n};\n/*\n * Return true if the value of this Big is equal to the value of Big y, otherwise return false.\n */\nP.eq = function (y) {\n    return this.cmp(y) === 0;\n};\n/*\n * Return true if the value of this Big is greater than the value of Big y, otherwise return\n * false.\n */\nP.gt = function (y) {\n    return this.cmp(y) > 0;\n};\n/*\n * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise\n * return false.\n */\nP.gte = function (y) {\n    return this.cmp(y) > -1;\n};\n/*\n * Return true if the value of this Big is less than the value of Big y, otherwise return false.\n */\nP.lt = function (y) {\n    return this.cmp(y) < 0;\n};\n/*\n * Return true if the value of this Big is less than or equal to the value of Big y, otherwise\n * return false.\n */\nP.lte = function (y) {\n    return this.cmp(y) < 1;\n};\n/*\n * Return a new Big whose value is the value of this Big minus the value of Big y.\n */\nP.minus = P.sub = function (y) {\n    var i, j, t, xlty, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    // Signs differ?\n    if (a != b) {\n        y.s = -b;\n        return x.plus(y);\n    }\n    var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;\n    // Either zero?\n    if (!xc[0] || !yc[0]) {\n        if (yc[0]) {\n            y.s = -b;\n        }\n        else if (xc[0]) {\n            y = new Big(x);\n        }\n        else {\n            y.s = 1;\n        }\n        return y;\n    }\n    // Determine which is the bigger number. Prepend zeros to equalise exponents.\n    if (a = xe - ye) {\n        if (xlty = a < 0) {\n            a = -a;\n            t = xc;\n        }\n        else {\n            ye = xe;\n            t = yc;\n        }\n        t.reverse();\n        for (b = a; b--;)\n            t.push(0);\n        t.reverse();\n    }\n    else {\n        // Exponents equal. Check digit by digit.\n        j = ((xlty = xc.length < yc.length) ? xc : yc).length;\n        for (a = b = 0; b < j; b++) {\n            if (xc[b] != yc[b]) {\n                xlty = xc[b] < yc[b];\n                break;\n            }\n        }\n    }\n    // x < y? Point xc to the array of the bigger number.\n    if (xlty) {\n        t = xc;\n        xc = yc;\n        yc = t;\n        y.s = -y.s;\n    }\n    /*\n     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only\n     * needs to start at yc.length.\n     */\n    if ((b = (j = yc.length) - (i = xc.length)) > 0)\n        for (; b--;)\n            xc[i++] = 0;\n    // Subtract yc from xc.\n    for (b = i; j > a;) {\n        if (xc[--j] < yc[j]) {\n            for (i = j; i && !xc[--i];)\n                xc[i] = 9;\n            --xc[i];\n            xc[j] += 10;\n        }\n        xc[j] -= yc[j];\n    }\n    // Remove trailing zeros.\n    for (; xc[--b] === 0;)\n        xc.pop();\n    // Remove leading zeros and adjust exponent accordingly.\n    for (; xc[0] === 0;) {\n        xc.shift();\n        --ye;\n    }\n    if (!xc[0]) {\n        // n - n = +0\n        y.s = 1;\n        // Result must be zero.\n        xc = [ye = 0];\n    }\n    y.c = xc;\n    y.e = ye;\n    return y;\n};\n/*\n * Return a new Big whose value is the value of this Big modulo the value of Big y.\n */\nP.mod = function (y) {\n    var ygtx, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    if (!y.c[0]) {\n        throw Error(DIV_BY_ZERO);\n    }\n    x.s = y.s = 1;\n    ygtx = y.cmp(x) == 1;\n    x.s = a;\n    y.s = b;\n    if (ygtx)\n        return new Big(x);\n    a = Big.DP;\n    b = Big.RM;\n    Big.DP = Big.RM = 0;\n    x = x.div(y);\n    Big.DP = a;\n    Big.RM = b;\n    return this.minus(x.times(y));\n};\n/*\n * Return a new Big whose value is the value of this Big plus the value of Big y.\n */\nP.plus = P.add = function (y) {\n    var e, k, t, Big = this.constructor, x = new Big(this), y = new Big(y);\n    // Signs differ?\n    if (x.s != y.s) {\n        y.s = -y.s;\n        return x.minus(y);\n    }\n    var xe = x.e, xc = x.c, ye = y.e, yc = y.c;\n    // Either zero?\n    if (!xc[0] || !yc[0]) {\n        if (!yc[0]) {\n            if (xc[0]) {\n                y = new Big(x);\n            }\n            else {\n                y.s = x.s;\n            }\n        }\n        return y;\n    }\n    xc = xc.slice();\n    // Prepend zeros to equalise exponents.\n    // Note: reverse faster than unshifts.\n    if (e = xe - ye) {\n        if (e > 0) {\n            ye = xe;\n            t = yc;\n        }\n        else {\n            e = -e;\n            t = xc;\n        }\n        t.reverse();\n        for (; e--;)\n            t.push(0);\n        t.reverse();\n    }\n    // Point xc to the longer array.\n    if (xc.length - yc.length < 0) {\n        t = yc;\n        yc = xc;\n        xc = t;\n    }\n    e = yc.length;\n    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.\n    for (k = 0; e; xc[e] %= 10)\n        k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\n    if (k) {\n        xc.unshift(k);\n        ++ye;\n    }\n    // Remove trailing zeros.\n    for (e = xc.length; xc[--e] === 0;)\n        xc.pop();\n    y.c = xc;\n    y.e = ye;\n    return y;\n};\n/*\n * Return a Big whose value is the value of this Big raised to the power n.\n * If n is negative, round to a maximum of Big.DP decimal places using rounding\n * mode Big.RM.\n *\n * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.\n */\nP.pow = function (n) {\n    var Big = this.constructor, x = new Big(this), y = new Big('1'), one = new Big('1'), isneg = n < 0;\n    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {\n        throw Error(INVALID + 'exponent');\n    }\n    if (isneg)\n        n = -n;\n    for (;;) {\n        if (n & 1)\n            y = y.times(x);\n        n >>= 1;\n        if (!n)\n            break;\n        x = x.times(x);\n    }\n    return isneg ? one.div(y) : y;\n};\n/*\n * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd\n * significant digits using rounding mode rm, or Big.RM if rm is not specified.\n *\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.prec = function (sd, rm) {\n    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\n        throw Error(INVALID + 'precision');\n    }\n    return round(new this.constructor(this), sd, rm);\n};\n/*\n * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places\n * using rounding mode rm, or Big.RM if rm is not specified.\n * If dp is negative, round to an integer which is a multiple of 10**-dp.\n * If dp is not specified, round to 0 decimal places.\n *\n * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.round = function (dp, rm) {\n    if (dp === UNDEFINED)\n        dp = 0;\n    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {\n        throw Error(INVALID_DP);\n    }\n    return round(new this.constructor(this), dp + this.e + 1, rm);\n};\n/*\n * Return a new Big whose value is the square root of the value of this Big, rounded, if\n * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\n */\nP.sqrt = function () {\n    var r, c, t, Big = this.constructor, x = new Big(this), s = x.s, e = x.e, half = new Big('0.5');\n    // Zero?\n    if (!x.c[0])\n        return new Big(x);\n    // Negative?\n    if (s < 0) {\n        throw Error(NAME + 'No square root');\n    }\n    // Estimate.\n    s = Math.sqrt(x + '');\n    // Math.sqrt underflow/overflow?\n    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.\n    if (s === 0 || s === 1 / 0) {\n        c = x.c.join('');\n        if (!(c.length + e & 1))\n            c += '0';\n        s = Math.sqrt(c);\n        e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);\n        r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);\n    }\n    else {\n        r = new Big(s + '');\n    }\n    e = r.e + (Big.DP += 4);\n    // Newton-Raphson iteration.\n    do {\n        t = r;\n        r = half.times(t.plus(x.div(t)));\n    } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));\n    return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);\n};\n/*\n * Return a new Big whose value is the value of this Big times the value of Big y.\n */\nP.times = P.mul = function (y) {\n    var c, Big = this.constructor, x = new Big(this), y = new Big(y), xc = x.c, yc = y.c, a = xc.length, b = yc.length, i = x.e, j = y.e;\n    // Determine sign of result.\n    y.s = x.s == y.s ? 1 : -1;\n    // Return signed 0 if either 0.\n    if (!xc[0] || !yc[0]) {\n        y.c = [y.e = 0];\n        return y;\n    }\n    // Initialise exponent of result as x.e + y.e.\n    y.e = i + j;\n    // If array xc has fewer digits than yc, swap xc and yc, and lengths.\n    if (a < b) {\n        c = xc;\n        xc = yc;\n        yc = c;\n        j = a;\n        a = b;\n        b = j;\n    }\n    // Initialise coefficient array of result with zeros.\n    for (c = new Array(j = a + b); j--;)\n        c[j] = 0;\n    // Multiply.\n    // i is initially xc.length.\n    for (i = b; i--;) {\n        b = 0;\n        // a is yc.length.\n        for (j = a + i; j > i;) {\n            // Current sum of products at this digit position, plus carry.\n            b = c[j] + yc[i] * xc[j - i - 1] + b;\n            c[j--] = b % 10;\n            // carry\n            b = b / 10 | 0;\n        }\n        c[j] = b;\n    }\n    // Increment result exponent if there is a final carry, otherwise remove leading zero.\n    if (b)\n        ++y.e;\n    else\n        c.shift();\n    // Remove trailing zeros.\n    for (i = c.length; !c[--i];)\n        c.pop();\n    y.c = c;\n    return y;\n};\n/*\n * Return a string representing the value of this Big in exponential notation rounded to dp fixed\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\n *\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.toExponential = function (dp, rm) {\n    var x = this, n = x.c[0];\n    if (dp !== UNDEFINED) {\n        if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\n            throw Error(INVALID_DP);\n        }\n        x = round(new x.constructor(x), ++dp, rm);\n        for (; x.c.length < dp;)\n            x.c.push(0);\n    }\n    return stringify(x, true, !!n);\n};\n/*\n * Return a string representing the value of this Big in normal notation rounded to dp fixed\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\n *\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n *\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\n */\nP.toFixed = function (dp, rm) {\n    var x = this, n = x.c[0];\n    if (dp !== UNDEFINED) {\n        if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\n            throw Error(INVALID_DP);\n        }\n        x = round(new x.constructor(x), dp + x.e + 1, rm);\n        // x.e may have changed if the value is rounded up.\n        for (dp = dp + x.e + 1; x.c.length < dp;)\n            x.c.push(0);\n    }\n    return stringify(x, false, !!n);\n};\n/*\n * Return a string representing the value of this Big.\n * Return exponential notation if this Big has a positive exponent equal to or greater than\n * Big.PE, or a negative exponent equal to or less than Big.NE.\n * Omit the sign for negative zero.\n */\nP.toJSON = P.toString = function () {\n    var x = this, Big = x.constructor;\n    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);\n};\n/*\n * Return the value of this Big as a primitve number.\n */\nP.toNumber = function () {\n    var n = Number(stringify(this, true, true));\n    if (this.constructor.strict === true && !this.eq(n.toString())) {\n        throw Error(NAME + 'Imprecise conversion');\n    }\n    return n;\n};\n/*\n * Return a string representing the value of this Big rounded to sd significant digits using\n * rounding mode rm, or Big.RM if rm is not specified.\n * Use exponential notation if sd is less than the number of digits necessary to represent\n * the integer part of the value in normal notation.\n *\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\n */\nP.toPrecision = function (sd, rm) {\n    var x = this, Big = x.constructor, n = x.c[0];\n    if (sd !== UNDEFINED) {\n        if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\n            throw Error(INVALID + 'precision');\n        }\n        x = round(new Big(x), sd, rm);\n        for (; x.c.length < sd;)\n            x.c.push(0);\n    }\n    return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);\n};\n/*\n * Return a string representing the value of this Big.\n * Return exponential notation if this Big has a positive exponent equal to or greater than\n * Big.PE, or a negative exponent equal to or less than Big.NE.\n * Include the sign for negative zero.\n */\nP.valueOf = function () {\n    var x = this, Big = x.constructor;\n    if (Big.strict === true) {\n        throw Error(NAME + 'valueOf disallowed');\n    }\n    return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);\n};\n// Export\nexport var Big = _Big_();\n/// <reference types=\"https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/master/types/big.js/index.d.ts\" />\nexport default Big;\n","import Decimal from \"./lib/big.js\";\nimport { FSharpRef } from \"./Types.js\";\nexport default Decimal;\nexport const get_Zero = new Decimal(0);\nexport const get_One = new Decimal(1);\nexport const get_MinusOne = new Decimal(-1);\nexport const get_MaxValue = new Decimal(\"79228162514264337593543950335\");\nexport const get_MinValue = new Decimal(\"-79228162514264337593543950335\");\nexport function compare(x, y) {\n    return x.cmp(y);\n}\nexport function equals(x, y) {\n    return !x.cmp(y);\n}\nexport function abs(x) {\n    return x.abs();\n}\nexport function round(x, digits = 0) {\n    return x.round(digits, 2 /* ROUND_HALF_EVEN */);\n}\nexport function truncate(x) {\n    return x.round(0, 0 /* ROUND_DOWN */);\n}\nexport function ceiling(x) {\n    return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);\n}\nexport function floor(x) {\n    return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);\n}\nexport function pow(x, n) {\n    return x.pow(n);\n}\nexport function sqrt(x) {\n    return x.sqrt();\n}\nexport function op_Addition(x, y) {\n    return x.add(y);\n}\nexport function op_Subtraction(x, y) {\n    return x.sub(y);\n}\nexport function op_Multiply(x, y) {\n    return x.mul(y);\n}\nexport function op_Division(x, y) {\n    return x.div(y);\n}\nexport function op_Modulus(x, y) {\n    return x.mod(y);\n}\nexport function op_UnaryNegation(x) {\n    const x2 = new Decimal(x);\n    x2.s = -x2.s || 0;\n    return x2;\n}\nexport const add = op_Addition;\nexport const subtract = op_Subtraction;\nexport const multiply = op_Multiply;\nexport const divide = op_Division;\nexport const remainder = op_Modulus;\nexport const negate = op_UnaryNegation;\nexport function toString(x) {\n    return x.toString();\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = new Decimal(str.trim());\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function parse(str) {\n    const defValue = new FSharpRef(get_Zero);\n    if (tryParse(str, defValue)) {\n        return defValue.contents;\n    }\n    else {\n        throw new Error(\"Input string was not in a correct format.\");\n    }\n}\nexport function toNumber(x) {\n    return +x;\n}\nfunction decimalToHex(dec, bitSize) {\n    const hex = new Uint8Array(bitSize / 4 | 0);\n    let hexCount = 1;\n    for (let d = 0; d < dec.length; d++) {\n        let value = dec[d];\n        for (let i = 0; i < hexCount; i++) {\n            const digit = hex[i] * 10 + value | 0;\n            hex[i] = digit & 0xF;\n            value = digit >> 4;\n        }\n        if (value !== 0) {\n            hex[hexCount++] = value;\n        }\n    }\n    return hex.slice(0, hexCount); // digits in reverse order\n}\nfunction hexToDecimal(hex, bitSize) {\n    const dec = new Uint8Array(bitSize * 301 / 1000 + 1 | 0);\n    let decCount = 1;\n    for (let d = hex.length - 1; d >= 0; d--) {\n        let carry = hex[d];\n        for (let i = 0; i < decCount; i++) {\n            const val = dec[i] * 16 + carry | 0;\n            dec[i] = (val % 10) | 0;\n            carry = (val / 10) | 0;\n        }\n        while (carry > 0) {\n            dec[decCount++] = (carry % 10) | 0;\n            carry = (carry / 10) | 0;\n        }\n    }\n    return dec.slice(0, decCount); // digits in reverse order\n}\nfunction setInt32Bits(hexDigits, bits, offset) {\n    for (let i = 0; i < 8; i++) {\n        hexDigits[offset + i] = (bits >> (i * 4)) & 0xF;\n    }\n}\nfunction getInt32Bits(hexDigits, offset) {\n    let bits = 0;\n    for (let i = 0; i < 8; i++) {\n        bits = bits | (hexDigits[offset + i] << (i * 4));\n    }\n    return bits;\n}\nexport function fromIntArray(bits) {\n    return fromInts(bits[0], bits[1], bits[2], bits[3]);\n}\nexport function fromInts(low, mid, high, signExp) {\n    const isNegative = signExp < 0;\n    const scale = (signExp >> 16) & 0x7F;\n    return fromParts(low, mid, high, isNegative, scale);\n}\nexport function fromParts(low, mid, high, isNegative, scale) {\n    const bitSize = 96;\n    const hexDigits = new Uint8Array(bitSize / 4);\n    setInt32Bits(hexDigits, low, 0);\n    setInt32Bits(hexDigits, mid, 8);\n    setInt32Bits(hexDigits, high, 16);\n    const decDigits = hexToDecimal(hexDigits, bitSize);\n    scale = scale & 0x7F;\n    const big = new Decimal(0);\n    big.c = Array.from(decDigits.reverse());\n    big.e = decDigits.length - scale - 1;\n    big.s = isNegative ? -1 : 1;\n    const d = new Decimal(big);\n    return d;\n}\nexport function getBits(d) {\n    const bitSize = 96;\n    const decDigits = Uint8Array.from(d.c);\n    const hexDigits = decimalToHex(decDigits, bitSize);\n    const low = getInt32Bits(hexDigits, 0);\n    const mid = getInt32Bits(hexDigits, 8);\n    const high = getInt32Bits(hexDigits, 16);\n    const decStr = d.toString();\n    const dotPos = decStr.indexOf(\".\");\n    const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;\n    const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);\n    return [low, mid, high, signExp];\n}\n// export function makeRangeStepFunction(step: Decimal, last: Decimal) {\n//   const stepComparedWithZero = step.cmp(get_Zero);\n//   if (stepComparedWithZero === 0) {\n//     throw new Error(\"The step of a range cannot be zero\");\n//   }\n//   const stepGreaterThanZero = stepComparedWithZero > 0;\n//   return (x: Decimal) => {\n//     const comparedWithLast = x.cmp(last);\n//     if ((stepGreaterThanZero && comparedWithLast <= 0)\n//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n//       return [x, op_Addition(x, step)];\n//     } else {\n//       return undefined;\n//     }\n//   };\n// }\n","\"use strict\";\r\n\r\nexport function Parsimmon(action) {\r\n  if (!(this instanceof Parsimmon)) {\r\n    return new Parsimmon(action);\r\n  }\r\n  this._ = action;\r\n}\r\n\r\nvar _ = Parsimmon.prototype;\r\n\r\nexport function times(n, f) {\r\n  var i = 0;\r\n  for (i; i < n; i++) {\r\n    f(i);\r\n  }\r\n}\r\n\r\nexport function forEach(f, arr) {\r\n  times(arr.length, function(i) {\r\n    f(arr[i], i, arr);\r\n  });\r\n}\r\n\r\nexport function reduce(f, seed, arr) {\r\n  forEach(function(elem, i, arr) {\r\n    seed = f(seed, elem, i, arr);\r\n  }, arr);\r\n  return seed;\r\n}\r\n\r\nexport function map(f, arr) {\r\n  return reduce(\r\n    function(acc, elem, i, a) {\r\n      return acc.concat([f(elem, i, a)]);\r\n    },\r\n    [],\r\n    arr\r\n  );\r\n}\r\n\r\nexport function lshiftBuffer(input) {\r\n  var asTwoBytes = reduce(\r\n    function(a, v, i, b) {\r\n      return a.concat(\r\n        i === b.length - 1\r\n          ? Buffer.from([v, 0]).readUInt16BE(0)\r\n          : b.readUInt16BE(i)\r\n      );\r\n    },\r\n    [],\r\n    input\r\n  );\r\n  return Buffer.from(\r\n    map(function(x) {\r\n      return ((x << 1) & 0xffff) >> 8;\r\n    }, asTwoBytes)\r\n  );\r\n}\r\n\r\nfunction consumeBitsFromBuffer(n, input) {\r\n  var state = { v: 0, buf: input };\r\n  times(n, function() {\r\n    state = {\r\n      v: (state.v << 1) | bitPeekBuffer(state.buf),\r\n      buf: lshiftBuffer(state.buf)\r\n    };\r\n  });\r\n  return state;\r\n}\r\n\r\nfunction bitPeekBuffer(input) {\r\n  return input[0] >> 7;\r\n}\r\n\r\nexport function sum(numArr) {\r\n  return reduce(\r\n    function(x, y) {\r\n      return x + y;\r\n    },\r\n    0,\r\n    numArr\r\n  );\r\n}\r\n\r\nexport function find(pred, arr) {\r\n  return reduce(\r\n    function(found, elem) {\r\n      return found || (pred(elem) ? elem : found);\r\n    },\r\n    null,\r\n    arr\r\n  );\r\n}\r\n\r\nfunction bufferExists() {\r\n  return typeof Buffer !== \"undefined\";\r\n}\r\n\r\nfunction ensureBuffer() {\r\n  if (!bufferExists()) {\r\n    throw new Error(\r\n      \"Buffer global does not exist; please consider using https://github.com/feross/buffer if you are running Parsimmon in a browser.\"\r\n    );\r\n  }\r\n}\r\n\r\nfunction bitSeq(alignments) {\r\n  ensureBuffer();\r\n  var totalBits = sum(alignments);\r\n  if (totalBits % 8 !== 0) {\r\n    throw new Error(\r\n      \"The bits [\" +\r\n        alignments.join(\", \") +\r\n        \"] add up to \" +\r\n        totalBits +\r\n        \" which is not an even number of bytes; the total should be divisible by 8\"\r\n    );\r\n  }\r\n  var bytes = totalBits / 8;\r\n\r\n  var tooBigRange = find(function(x) {\r\n    return x > 48;\r\n  }, alignments);\r\n  if (tooBigRange) {\r\n    throw new Error(\r\n      tooBigRange + \" bit range requested exceeds 48 bit (6 byte) Number max.\"\r\n    );\r\n  }\r\n\r\n  return new Parsimmon(function(input, i) {\r\n    var newPos = bytes + i;\r\n    if (newPos > input.length) {\r\n      return makeFailure(i, bytes.toString() + \" bytes\");\r\n    }\r\n    return makeSuccess(\r\n      newPos,\r\n      reduce(\r\n        function(acc, bits) {\r\n          var state = consumeBitsFromBuffer(bits, acc.buf);\r\n          return {\r\n            coll: acc.coll.concat(state.v),\r\n            buf: state.buf\r\n          };\r\n        },\r\n        { coll: [], buf: input.slice(i, newPos) },\r\n        alignments\r\n      ).coll\r\n    );\r\n  });\r\n}\r\n\r\nfunction bitSeqObj(namedAlignments) {\r\n  ensureBuffer();\r\n  var seenKeys = {};\r\n  var totalKeys = 0;\r\n  var fullAlignments = map(function(item) {\r\n    if (isArray(item)) {\r\n      var pair = item;\r\n      if (pair.length !== 2) {\r\n        throw new Error(\r\n          \"[\" +\r\n            pair.join(\", \") +\r\n            \"] should be length 2, got length \" +\r\n            pair.length\r\n        );\r\n      }\r\n      assertString(pair[0]);\r\n      assertNumber(pair[1]);\r\n      if (Object.prototype.hasOwnProperty.call(seenKeys, pair[0])) {\r\n        throw new Error(\"duplicate key in bitSeqObj: \" + pair[0]);\r\n      }\r\n      seenKeys[pair[0]] = true;\r\n      totalKeys++;\r\n      return pair;\r\n    } else {\r\n      assertNumber(item);\r\n      return [null, item];\r\n    }\r\n  }, namedAlignments);\r\n  if (totalKeys < 1) {\r\n    throw new Error(\r\n      \"bitSeqObj expects at least one named pair, got [\" +\r\n        namedAlignments.join(\", \") +\r\n        \"]\"\r\n    );\r\n  }\r\n  var namesOnly = map(function(pair) {\r\n    return pair[0];\r\n  }, fullAlignments);\r\n  var alignmentsOnly = map(function(pair) {\r\n    return pair[1];\r\n  }, fullAlignments);\r\n\r\n  return bitSeq(alignmentsOnly).map(function(parsed) {\r\n    var namedParsed = map(function(name, i) {\r\n      return [name, parsed[i]];\r\n    }, namesOnly);\r\n\r\n    return reduce(\r\n      function(obj, kv) {\r\n        if (kv[0] !== null) {\r\n          obj[kv[0]] = kv[1];\r\n        }\r\n        return obj;\r\n      },\r\n      {},\r\n      namedParsed\r\n    );\r\n  });\r\n}\r\n\r\nfunction parseBufferFor(other, length) {\r\n  ensureBuffer();\r\n  return new Parsimmon(function(input, i) {\r\n    if (i + length > input.length) {\r\n      return makeFailure(i, length + \" bytes for \" + other);\r\n    }\r\n    return makeSuccess(i + length, input.slice(i, i + length));\r\n  });\r\n}\r\n\r\nfunction parseBuffer(length) {\r\n  return parseBufferFor(\"buffer\", length).map(function(unsafe) {\r\n    return Buffer.from(unsafe);\r\n  });\r\n}\r\n\r\nfunction encodedString(encoding, length) {\r\n  return parseBufferFor(\"string\", length).map(function(buff) {\r\n    return buff.toString(encoding);\r\n  });\r\n}\r\n\r\nfunction isInteger(value) {\r\n  return typeof value === \"number\" && Math.floor(value) === value;\r\n}\r\n\r\nfunction assertValidIntegerByteLengthFor(who, length) {\r\n  if (!isInteger(length) || length < 0 || length > 6) {\r\n    throw new Error(who + \" requires integer length in range [0, 6].\");\r\n  }\r\n}\r\n\r\nfunction uintBE(length) {\r\n  assertValidIntegerByteLengthFor(\"uintBE\", length);\r\n  return parseBufferFor(\"uintBE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readUIntBE(0, length);\r\n  });\r\n}\r\n\r\nfunction uintLE(length) {\r\n  assertValidIntegerByteLengthFor(\"uintLE\", length);\r\n  return parseBufferFor(\"uintLE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readUIntLE(0, length);\r\n  });\r\n}\r\n\r\nfunction intBE(length) {\r\n  assertValidIntegerByteLengthFor(\"intBE\", length);\r\n  return parseBufferFor(\"intBE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readIntBE(0, length);\r\n  });\r\n}\r\n\r\nfunction intLE(length) {\r\n  assertValidIntegerByteLengthFor(\"intLE\", length);\r\n  return parseBufferFor(\"intLE(\" + length + \")\", length).map(function(buff) {\r\n    return buff.readIntLE(0, length);\r\n  });\r\n}\r\n\r\nfunction floatBE() {\r\n  return parseBufferFor(\"floatBE\", 4).map(function(buff) {\r\n    return buff.readFloatBE(0);\r\n  });\r\n}\r\n\r\nfunction floatLE() {\r\n  return parseBufferFor(\"floatLE\", 4).map(function(buff) {\r\n    return buff.readFloatLE(0);\r\n  });\r\n}\r\n\r\nfunction doubleBE() {\r\n  return parseBufferFor(\"doubleBE\", 8).map(function(buff) {\r\n    return buff.readDoubleBE(0);\r\n  });\r\n}\r\n\r\nfunction doubleLE() {\r\n  return parseBufferFor(\"doubleLE\", 8).map(function(buff) {\r\n    return buff.readDoubleLE(0);\r\n  });\r\n}\r\n\r\nfunction toArray(arrLike) {\r\n  return Array.prototype.slice.call(arrLike);\r\n}\r\n// -*- Helpers -*-\r\n\r\nfunction isParser(obj) {\r\n  return obj instanceof Parsimmon;\r\n}\r\n\r\nfunction isArray(x) {\r\n  return {}.toString.call(x) === \"[object Array]\";\r\n}\r\n\r\nfunction isBuffer(x) {\r\n  /* global Buffer */\r\n  return bufferExists() && Buffer.isBuffer(x);\r\n}\r\n\r\nexport function makeSuccess(index, value) {\r\n  return {\r\n    status: true,\r\n    index: index,\r\n    value: value,\r\n    furthest: -1,\r\n    expected: []\r\n  };\r\n}\r\n\r\nexport function makeFailure(index, expected) {\r\n  if (!isArray(expected)) {\r\n    expected = [expected];\r\n  }\r\n  return {\r\n    status: false,\r\n    index: -1,\r\n    value: null,\r\n    furthest: index,\r\n    expected: expected\r\n  };\r\n}\r\n\r\nfunction mergeReplies(result, last) {\r\n  if (!last) {\r\n    return result;\r\n  }\r\n  if (result.furthest > last.furthest) {\r\n    return result;\r\n  }\r\n  var expected =\r\n    result.furthest === last.furthest\r\n      ? union(result.expected, last.expected)\r\n      : last.expected;\r\n  return {\r\n    status: result.status,\r\n    index: result.index,\r\n    value: result.value,\r\n    furthest: last.furthest,\r\n    expected: expected\r\n  };\r\n}\r\n\r\nfunction makeLineColumnIndex(input, i) {\r\n  if (isBuffer(input)) {\r\n    return {\r\n      offset: i,\r\n      line: -1,\r\n      column: -1\r\n    };\r\n  }\r\n  var lines = input.slice(0, i).split(\"\\n\");\r\n  // Note that unlike the character offset, the line and column offsets are\r\n  // 1-based.\r\n  var lineWeAreUpTo = lines.length;\r\n  var columnWeAreUpTo = lines[lines.length - 1].length + 1;\r\n  return {\r\n    offset: i,\r\n    line: lineWeAreUpTo,\r\n    column: columnWeAreUpTo\r\n  };\r\n}\r\n\r\n// Returns the sorted set union of two arrays of strings\r\nfunction union(xs, ys) {\r\n  var obj = {};\r\n  for (var i = 0; i < xs.length; i++) {\r\n    obj[xs[i]] = true;\r\n  }\r\n  for (var j = 0; j < ys.length; j++) {\r\n    obj[ys[j]] = true;\r\n  }\r\n  var keys = [];\r\n  for (var k in obj) {\r\n    if ({}.hasOwnProperty.call(obj, k)) {\r\n      keys.push(k);\r\n    }\r\n  }\r\n  keys.sort();\r\n  return keys;\r\n}\r\n\r\nfunction assertParser(p) {\r\n  if (!isParser(p)) {\r\n    throw new Error(\"not a parser: \" + p);\r\n  }\r\n}\r\n\r\nfunction get(input, i) {\r\n  if (typeof input === \"string\") {\r\n    return input.charAt(i);\r\n  }\r\n  return input[i];\r\n}\r\n\r\n// TODO[ES5]: Switch to Array.isArray eventually.\r\nfunction assertArray(x) {\r\n  if (!isArray(x)) {\r\n    throw new Error(\"not an array: \" + x);\r\n  }\r\n}\r\n\r\nfunction assertNumber(x) {\r\n  if (typeof x !== \"number\") {\r\n    throw new Error(\"not a number: \" + x);\r\n  }\r\n}\r\n\r\nfunction assertRegexp(x) {\r\n  if (!(x instanceof RegExp)) {\r\n    throw new Error(\"not a regexp: \" + x);\r\n  }\r\n  var f = flags(x);\r\n  for (var i = 0; i < f.length; i++) {\r\n    var c = f.charAt(i);\r\n    // Only allow regexp flags [imu] for now, since [g] and [y] specifically\r\n    // mess up Parsimmon. If more non-stateful regexp flags are added in the\r\n    // future, this will need to be revisited.\r\n    if (c !== \"i\" && c !== \"m\" && c !== \"u\") {\r\n      throw new Error('unsupported regexp flag \"' + c + '\": ' + x);\r\n    }\r\n  }\r\n}\r\n\r\nfunction assertFunction(x) {\r\n  if (typeof x !== \"function\") {\r\n    throw new Error(\"not a function: \" + x);\r\n  }\r\n}\r\n\r\nfunction assertString(x) {\r\n  if (typeof x !== \"string\") {\r\n    throw new Error(\"not a string: \" + x);\r\n  }\r\n}\r\n\r\n// -*- Error Formatting -*-\r\n\r\nvar linesBeforeStringError = 2;\r\nvar linesAfterStringError = 3;\r\nvar bytesPerLine = 8;\r\nvar bytesBefore = bytesPerLine * 5;\r\nvar bytesAfter = bytesPerLine * 4;\r\nvar defaultLinePrefix = \"  \";\r\n\r\nexport function repeat(string, amount) {\r\n  return new Array(amount + 1).join(string);\r\n}\r\n\r\nexport function formatExpected(expected) {\r\n  if (expected.length === 1) {\r\n    return \"Expected:\\n\\n\" + expected[0];\r\n  }\r\n  return \"Expected one of the following: \\n\\n\" + expected.join(\", \");\r\n}\r\n\r\nexport function leftPad(str, pad, char) {\r\n  var add = pad - str.length;\r\n  if (add <= 0) {\r\n    return str;\r\n  }\r\n  return repeat(char, add) + str;\r\n}\r\n\r\nfunction toChunks(arr, chunkSize) {\r\n  var length = arr.length;\r\n  var chunks = [];\r\n  var chunkIndex = 0;\r\n\r\n  if (length <= chunkSize) {\r\n    return [arr.slice()];\r\n  }\r\n\r\n  for (var i = 0; i < length; i++) {\r\n    if (!chunks[chunkIndex]) {\r\n      chunks.push([]);\r\n    }\r\n\r\n    chunks[chunkIndex].push(arr[i]);\r\n\r\n    if ((i + 1) % chunkSize === 0) {\r\n      chunkIndex++;\r\n    }\r\n  }\r\n\r\n  return chunks;\r\n}\r\n\r\n// Get a range of indexes including `i`-th element and `before` and `after` amount of elements from `arr`.\r\nexport function rangeFromIndexAndOffsets(i, before, after, length) {\r\n  return {\r\n    // Guard against the negative upper bound for lines included in the output.\r\n    from: i - before > 0 ? i - before : 0,\r\n    to: i + after > length ? length : i + after\r\n  };\r\n}\r\n\r\nexport function byteRangeToRange(byteRange) {\r\n  // Exception for inputs smaller than `bytesPerLine`\r\n  if (byteRange.from === 0 && byteRange.to === 1) {\r\n    return {\r\n      from: byteRange.from,\r\n      to: byteRange.to\r\n    };\r\n  }\r\n\r\n  return {\r\n    from: byteRange.from / bytesPerLine,\r\n    // Round `to`, so we don't get float if the amount of bytes is not divisible by `bytesPerLine`\r\n    to: Math.floor(byteRange.to / bytesPerLine)\r\n  };\r\n}\r\n\r\nexport function formatGot(input, error) {\r\n  var index = error.index;\r\n  var i = index.offset;\r\n\r\n  var verticalMarkerLength = 1;\r\n  var column;\r\n  var lineWithErrorIndex;\r\n  var lines;\r\n  var lineRange;\r\n  var lastLineNumberLabelLength;\r\n\r\n  if (i === input.length) {\r\n    return \"Got the end of the input\";\r\n  }\r\n\r\n  if (isBuffer(input)) {\r\n    var byteLineWithErrorIndex = i - (i % bytesPerLine);\r\n    var columnByteIndex = i - byteLineWithErrorIndex;\r\n    var byteRange = rangeFromIndexAndOffsets(\r\n      byteLineWithErrorIndex,\r\n      bytesBefore,\r\n      bytesAfter + bytesPerLine,\r\n      input.length\r\n    );\r\n    var bytes = input.slice(byteRange.from, byteRange.to);\r\n    var bytesInChunks = toChunks(bytes.toJSON().data, bytesPerLine);\r\n\r\n    var byteLines = map(function(byteRow) {\r\n      return map(function(byteValue) {\r\n        // Prefix byte values with a `0` if they are shorter than 2 characters.\r\n        return leftPad(byteValue.toString(16), 2, \"0\");\r\n      }, byteRow);\r\n    }, bytesInChunks);\r\n\r\n    lineRange = byteRangeToRange(byteRange);\r\n    lineWithErrorIndex = byteLineWithErrorIndex / bytesPerLine;\r\n    column = columnByteIndex * 3;\r\n\r\n    // Account for an extra space.\r\n    if (columnByteIndex >= 4) {\r\n      column += 1;\r\n    }\r\n\r\n    verticalMarkerLength = 2;\r\n    lines = map(function(byteLine) {\r\n      return byteLine.length <= 4\r\n        ? byteLine.join(\" \")\r\n        : byteLine.slice(0, 4).join(\" \") + \"  \" + byteLine.slice(4).join(\" \");\r\n    }, byteLines);\r\n    lastLineNumberLabelLength = (\r\n      (lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8\r\n    ).toString(16).length;\r\n\r\n    if (lastLineNumberLabelLength < 2) {\r\n      lastLineNumberLabelLength = 2;\r\n    }\r\n  } else {\r\n    var inputLines = input.split(/\\r\\n|[\\n\\r\\u2028\\u2029]/);\r\n    column = index.column - 1;\r\n    lineWithErrorIndex = index.line - 1;\r\n    lineRange = rangeFromIndexAndOffsets(\r\n      lineWithErrorIndex,\r\n      linesBeforeStringError,\r\n      linesAfterStringError,\r\n      inputLines.length\r\n    );\r\n\r\n    lines = inputLines.slice(lineRange.from, lineRange.to);\r\n    lastLineNumberLabelLength = lineRange.to.toString().length;\r\n  }\r\n\r\n  var lineWithErrorCurrentIndex = lineWithErrorIndex - lineRange.from;\r\n\r\n  if (isBuffer(input)) {\r\n    lastLineNumberLabelLength = (\r\n      (lineRange.to > 0 ? lineRange.to - 1 : lineRange.to) * 8\r\n    ).toString(16).length;\r\n\r\n    if (lastLineNumberLabelLength < 2) {\r\n      lastLineNumberLabelLength = 2;\r\n    }\r\n  }\r\n\r\n  var linesWithLineNumbers = reduce(\r\n    function(acc, lineSource, index) {\r\n      var isLineWithError = index === lineWithErrorCurrentIndex;\r\n      var prefix = isLineWithError ? \"> \" : defaultLinePrefix;\r\n      var lineNumberLabel;\r\n\r\n      if (isBuffer(input)) {\r\n        lineNumberLabel = leftPad(\r\n          ((lineRange.from + index) * 8).toString(16),\r\n          lastLineNumberLabelLength,\r\n          \"0\"\r\n        );\r\n      } else {\r\n        lineNumberLabel = leftPad(\r\n          (lineRange.from + index + 1).toString(),\r\n          lastLineNumberLabelLength,\r\n          \" \"\r\n        );\r\n      }\r\n\r\n      return [].concat(\r\n        acc,\r\n        [prefix + lineNumberLabel + \" | \" + lineSource],\r\n        isLineWithError\r\n          ? [\r\n              defaultLinePrefix +\r\n                repeat(\" \", lastLineNumberLabelLength) +\r\n                \" | \" +\r\n                leftPad(\"\", column, \" \") +\r\n                repeat(\"^\", verticalMarkerLength)\r\n            ]\r\n          : []\r\n      );\r\n    },\r\n    [],\r\n    lines\r\n  );\r\n\r\n  return linesWithLineNumbers.join(\"\\n\");\r\n}\r\n\r\nexport function formatError(input, error) {\r\n  return [\r\n    \"\\n\",\r\n    \"-- PARSING FAILED \" + repeat(\"-\", 50),\r\n    \"\\n\\n\",\r\n    formatGot(input, error),\r\n    \"\\n\\n\",\r\n    formatExpected(error.expected),\r\n    \"\\n\"\r\n  ].join(\"\");\r\n}\r\n\r\nexport function flags(re) {\r\n  var s = \"\" + re;\r\n  return s.slice(s.lastIndexOf(\"/\") + 1);\r\n}\r\n\r\nexport function anchoredRegexp(re) {\r\n  return RegExp(\"^(?:\" + re.source + \")\", flags(re));\r\n}\r\n\r\n// -*- Combinators -*-\r\n\r\nexport function seq() {\r\n  var parsers = [].slice.call(arguments);\r\n  var numParsers = parsers.length;\r\n  for (var j = 0; j < numParsers; j += 1) {\r\n    assertParser(parsers[j]);\r\n  }\r\n  return Parsimmon(function(input, i) {\r\n    var result;\r\n    var accum = new Array(numParsers);\r\n    for (var j = 0; j < numParsers; j += 1) {\r\n      result = mergeReplies(parsers[j]._(input, i), result);\r\n      if (!result.status) {\r\n        return result;\r\n      }\r\n      accum[j] = result.value;\r\n      i = result.index;\r\n    }\r\n    return mergeReplies(makeSuccess(i, accum), result);\r\n  });\r\n}\r\n\r\nexport function seqObj() {\r\n  var seenKeys = {};\r\n  var totalKeys = 0;\r\n  var parsers = toArray(arguments);\r\n  var numParsers = parsers.length;\r\n  for (var j = 0; j < numParsers; j += 1) {\r\n    var p = parsers[j];\r\n    if (isParser(p)) {\r\n      continue;\r\n    }\r\n    if (isArray(p)) {\r\n      var isWellFormed =\r\n        p.length === 2 && typeof p[0] === \"string\" && isParser(p[1]);\r\n      if (isWellFormed) {\r\n        var key = p[0];\r\n        if (Object.prototype.hasOwnProperty.call(seenKeys, key)) {\r\n          throw new Error(\"seqObj: duplicate key \" + key);\r\n        }\r\n        seenKeys[key] = true;\r\n        totalKeys++;\r\n        continue;\r\n      }\r\n    }\r\n    throw new Error(\r\n      \"seqObj arguments must be parsers or [string, parser] array pairs.\"\r\n    );\r\n  }\r\n  if (totalKeys === 0) {\r\n    throw new Error(\"seqObj expects at least one named parser, found zero\");\r\n  }\r\n  return Parsimmon(function(input, i) {\r\n    var result;\r\n    var accum = {};\r\n    for (var j = 0; j < numParsers; j += 1) {\r\n      var name;\r\n      var parser;\r\n      if (isArray(parsers[j])) {\r\n        name = parsers[j][0];\r\n        parser = parsers[j][1];\r\n      } else {\r\n        name = null;\r\n        parser = parsers[j];\r\n      }\r\n      result = mergeReplies(parser._(input, i), result);\r\n      if (!result.status) {\r\n        return result;\r\n      }\r\n      if (name) {\r\n        accum[name] = result.value;\r\n      }\r\n      i = result.index;\r\n    }\r\n    return mergeReplies(makeSuccess(i, accum), result);\r\n  });\r\n}\r\n\r\nexport function seqMap() {\r\n  var args = [].slice.call(arguments);\r\n  if (args.length === 0) {\r\n    throw new Error(\"seqMap needs at least one argument\");\r\n  }\r\n  var mapper = args.pop();\r\n  assertFunction(mapper);\r\n  return seq.apply(null, args).map(function(results) {\r\n    return mapper.apply(null, results);\r\n  });\r\n}\r\n\r\n// TODO[ES5]: Revisit this with Object.keys and .bind.\r\nexport function createLanguage(parsers) {\r\n  var language = {};\r\n  for (var key in parsers) {\r\n    if ({}.hasOwnProperty.call(parsers, key)) {\r\n      (function(key) {\r\n        var func = function() {\r\n          return parsers[key](language);\r\n        };\r\n        language[key] = lazy(func);\r\n      })(key);\r\n    }\r\n  }\r\n  return language;\r\n}\r\n\r\nexport function alt() {\r\n  var parsers = [].slice.call(arguments);\r\n  var numParsers = parsers.length;\r\n  if (numParsers === 0) {\r\n    return fail(\"zero alternates\");\r\n  }\r\n  for (var j = 0; j < numParsers; j += 1) {\r\n    assertParser(parsers[j]);\r\n  }\r\n  return Parsimmon(function(input, i) {\r\n    var result;\r\n    for (var j = 0; j < parsers.length; j += 1) {\r\n      result = mergeReplies(parsers[j]._(input, i), result);\r\n      if (result.status) {\r\n        return result;\r\n      }\r\n    }\r\n    return result;\r\n  });\r\n}\r\n\r\nexport function sepBy(parser, separator) {\r\n  // Argument asserted by sepBy1\r\n  return sepBy1(parser, separator).or(succeed([]));\r\n}\r\n\r\nexport function sepBy1(parser, separator) {\r\n  assertParser(parser);\r\n  assertParser(separator);\r\n  var pairs = separator.then(parser).many();\r\n  return seqMap(parser, pairs, function(r, rs) {\r\n    return [r].concat(rs);\r\n  });\r\n}\r\n\r\n// -*- Core Parsing Methods -*-\r\n\r\n_.parse = function(input) {\r\n  if (typeof input !== \"string\" && !isBuffer(input)) {\r\n    throw new Error(\r\n      \".parse must be called with a string or Buffer as its argument\"\r\n    );\r\n  }\r\n  var result = this.skip(eof)._(input, 0);\r\n  if (result.status) {\r\n    return {\r\n      status: true,\r\n      value: result.value\r\n    };\r\n  }\r\n  return {\r\n    status: false,\r\n    index: makeLineColumnIndex(input, result.furthest),\r\n    expected: result.expected\r\n  };\r\n};\r\n\r\n// -*- Other Methods -*-\r\n\r\n_.tryParse = function(str) {\r\n  var result = this.parse(str);\r\n  if (result.status) {\r\n    return result.value;\r\n  } else {\r\n    var msg = formatError(str, result);\r\n    var err = new Error(msg);\r\n    err.type = \"ParsimmonError\";\r\n    err.result = result;\r\n    throw err;\r\n  }\r\n};\r\n\r\n_.or = function(alternative) {\r\n  return alt(this, alternative);\r\n};\r\n\r\n_.trim = function(parser) {\r\n  return this.wrap(parser, parser);\r\n};\r\n\r\n_.wrap = function(leftParser, rightParser) {\r\n  return seqMap(leftParser, this, rightParser, function(left, middle) {\r\n    return middle;\r\n  });\r\n};\r\n\r\n_.thru = function(wrapper) {\r\n  return wrapper(this);\r\n};\r\n\r\n_.then = function(next) {\r\n  assertParser(next);\r\n  return seq(this, next).map(function(results) {\r\n    return results[1];\r\n  });\r\n};\r\n\r\n_.many = function() {\r\n  var self = this;\r\n\r\n  return Parsimmon(function(input, i) {\r\n    var accum = [];\r\n    var result = undefined;\r\n\r\n    for (;;) {\r\n      result = mergeReplies(self._(input, i), result);\r\n      if (result.status) {\r\n        if (i === result.index) {\r\n          throw new Error(\r\n            \"infinite loop detected in .many() parser --- calling .many() on \" +\r\n              \"a parser which can accept zero characters is usually the cause\"\r\n          );\r\n        }\r\n        i = result.index;\r\n        accum.push(result.value);\r\n      } else {\r\n        return mergeReplies(makeSuccess(i, accum), result);\r\n      }\r\n    }\r\n  });\r\n};\r\n\r\n_.tieWith = function(separator) {\r\n  assertString(separator);\r\n  return this.map(function(args) {\r\n    assertArray(args);\r\n    if (args.length) {\r\n      assertString(args[0]);\r\n      var s = args[0];\r\n      for (var i = 1; i < args.length; i++) {\r\n        assertString(args[i]);\r\n        s += separator + args[i];\r\n      }\r\n      return s;\r\n    } else {\r\n      return \"\";\r\n    }\r\n  });\r\n};\r\n\r\n_.tie = function() {\r\n  return this.tieWith(\"\");\r\n};\r\n\r\n_.times = function(min, max) {\r\n  var self = this;\r\n  if (arguments.length < 2) {\r\n    max = min;\r\n  }\r\n  assertNumber(min);\r\n  assertNumber(max);\r\n  return Parsimmon(function(input, i) {\r\n    var accum = [];\r\n    var result = undefined;\r\n    var prevResult = undefined;\r\n    for (var times = 0; times < min; times += 1) {\r\n      result = self._(input, i);\r\n      prevResult = mergeReplies(result, prevResult);\r\n      if (result.status) {\r\n        i = result.index;\r\n        accum.push(result.value);\r\n      } else {\r\n        return prevResult;\r\n      }\r\n    }\r\n    for (; times < max; times += 1) {\r\n      result = self._(input, i);\r\n      prevResult = mergeReplies(result, prevResult);\r\n      if (result.status) {\r\n        i = result.index;\r\n        accum.push(result.value);\r\n      } else {\r\n        break;\r\n      }\r\n    }\r\n    return mergeReplies(makeSuccess(i, accum), prevResult);\r\n  });\r\n};\r\n\r\n_.result = function(res) {\r\n  return this.map(function() {\r\n    return res;\r\n  });\r\n};\r\n\r\n_.atMost = function(n) {\r\n  return this.times(0, n);\r\n};\r\n\r\n_.atLeast = function(n) {\r\n  return seqMap(this.times(n), this.many(), function(init, rest) {\r\n    return init.concat(rest);\r\n  });\r\n};\r\n\r\n_.map = function(fn) {\r\n  assertFunction(fn);\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var result = self._(input, i);\r\n    if (!result.status) {\r\n      return result;\r\n    }\r\n    return mergeReplies(makeSuccess(result.index, fn(result.value)), result);\r\n  });\r\n};\r\n\r\n_.contramap = function(fn) {\r\n  assertFunction(fn);\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var result = self.parse(fn(input.slice(i)));\r\n    if (!result.status) {\r\n      return result;\r\n    }\r\n    return makeSuccess(i + input.length, result.value);\r\n  });\r\n};\r\n\r\n_.promap = function(f, g) {\r\n  assertFunction(f);\r\n  assertFunction(g);\r\n  return this.contramap(f).map(g);\r\n};\r\n\r\n_.skip = function(next) {\r\n  return seq(this, next).map(function(results) {\r\n    return results[0];\r\n  });\r\n};\r\n\r\n_.mark = function() {\r\n  return seqMap(index, this, index, function(start, value, end) {\r\n    return {\r\n      start: start,\r\n      value: value,\r\n      end: end\r\n    };\r\n  });\r\n};\r\n\r\n_.node = function(name) {\r\n  return seqMap(index, this, index, function(start, value, end) {\r\n    return {\r\n      name: name,\r\n      value: value,\r\n      start: start,\r\n      end: end\r\n    };\r\n  });\r\n};\r\n\r\n_.sepBy = function(separator) {\r\n  return sepBy(this, separator);\r\n};\r\n\r\n_.sepBy1 = function(separator) {\r\n  return sepBy1(this, separator);\r\n};\r\n\r\n_.lookahead = function(x) {\r\n  return this.skip(lookahead(x));\r\n};\r\n\r\n_.notFollowedBy = function(x) {\r\n  return this.skip(notFollowedBy(x));\r\n};\r\n\r\n_.desc = function(expected) {\r\n  if (!isArray(expected)) {\r\n    expected = [expected];\r\n  }\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var reply = self._(input, i);\r\n    if (!reply.status) {\r\n      reply.expected = expected;\r\n    }\r\n    return reply;\r\n  });\r\n};\r\n\r\n_.fallback = function(result) {\r\n  return this.or(succeed(result));\r\n};\r\n\r\n_.ap = function(other) {\r\n  return seqMap(other, this, function(f, x) {\r\n    return f(x);\r\n  });\r\n};\r\n\r\n_.chain = function(f) {\r\n  var self = this;\r\n  return Parsimmon(function(input, i) {\r\n    var result = self._(input, i);\r\n    if (!result.status) {\r\n      return result;\r\n    }\r\n    var nextParser = f(result.value);\r\n    return mergeReplies(nextParser._(input, result.index), result);\r\n  });\r\n};\r\n\r\n// -*- Constructors -*-\r\n\r\nexport function string(str) {\r\n  assertString(str);\r\n  var expected = \"'\" + str + \"'\";\r\n  return Parsimmon(function(input, i) {\r\n    var j = i + str.length;\r\n    var head = input.slice(i, j);\r\n    if (head === str) {\r\n      return makeSuccess(j, head);\r\n    } else {\r\n      return makeFailure(i, expected);\r\n    }\r\n  });\r\n}\r\n\r\nexport function byte(b) {\r\n  ensureBuffer();\r\n  assertNumber(b);\r\n  if (b > 0xff) {\r\n    throw new Error(\r\n      \"Value specified to byte constructor (\" +\r\n        b +\r\n        \"=0x\" +\r\n        b.toString(16) +\r\n        \") is larger in value than a single byte.\"\r\n    );\r\n  }\r\n  var expected = (b > 0xf ? \"0x\" : \"0x0\") + b.toString(16);\r\n  return Parsimmon(function(input, i) {\r\n    var head = get(input, i);\r\n    if (head === b) {\r\n      return makeSuccess(i + 1, head);\r\n    } else {\r\n      return makeFailure(i, expected);\r\n    }\r\n  });\r\n}\r\n\r\nexport function regexp(re, group) {\r\n  assertRegexp(re);\r\n  if (arguments.length >= 2) {\r\n    assertNumber(group);\r\n  } else {\r\n    group = 0;\r\n  }\r\n  var anchored = anchoredRegexp(re);\r\n  var expected = \"\" + re;\r\n  return Parsimmon(function(input, i) {\r\n    var match = anchored.exec(input.slice(i));\r\n    if (match) {\r\n      if (0 <= group && group <= match.length) {\r\n        var fullMatch = match[0];\r\n        var groupMatch = match[group];\r\n        return makeSuccess(i + fullMatch.length, groupMatch);\r\n      }\r\n      var message =\r\n        \"valid match group (0 to \" + match.length + \") in \" + expected;\r\n      return makeFailure(i, message);\r\n    }\r\n    return makeFailure(i, expected);\r\n  });\r\n}\r\n\r\nexport function succeed(value) {\r\n  return Parsimmon(function(input, i) {\r\n    return makeSuccess(i, value);\r\n  });\r\n}\r\n\r\nexport function fail(expected) {\r\n  return Parsimmon(function(input, i) {\r\n    return makeFailure(i, expected);\r\n  });\r\n}\r\n\r\nexport function lookahead(x) {\r\n  if (isParser(x)) {\r\n    return Parsimmon(function(input, i) {\r\n      var result = x._(input, i);\r\n      result.index = i;\r\n      result.value = \"\";\r\n      return result;\r\n    });\r\n  } else if (typeof x === \"string\") {\r\n    return lookahead(string(x));\r\n  } else if (x instanceof RegExp) {\r\n    return lookahead(regexp(x));\r\n  }\r\n  throw new Error(\"not a string, regexp, or parser: \" + x);\r\n}\r\n\r\nexport function notFollowedBy(parser) {\r\n  assertParser(parser);\r\n  return Parsimmon(function(input, i) {\r\n    var result = parser._(input, i);\r\n    var text = input.slice(i, result.index);\r\n    return result.status\r\n      ? makeFailure(i, 'not \"' + text + '\"')\r\n      : makeSuccess(i, null);\r\n  });\r\n}\r\n\r\nexport function test(predicate) {\r\n  assertFunction(predicate);\r\n  return Parsimmon(function(input, i) {\r\n    var char = get(input, i);\r\n    if (i < input.length && predicate(char)) {\r\n      return makeSuccess(i + 1, char);\r\n    } else {\r\n      return makeFailure(i, \"a character/byte matching \" + predicate);\r\n    }\r\n  });\r\n}\r\n\r\nexport function oneOf(str) {\r\n  var expected = str.split(\"\");\r\n  for (var idx = 0; idx < expected.length; idx++) {\r\n    expected[idx] = \"'\" + expected[idx] + \"'\";\r\n  }\r\n  return test(function(ch) {\r\n    return str.indexOf(ch) >= 0;\r\n  }).desc(expected);\r\n}\r\n\r\nexport function noneOf(str) {\r\n  return test(function(ch) {\r\n    return str.indexOf(ch) < 0;\r\n  }).desc(\"none of '\" + str + \"'\");\r\n}\r\n\r\nexport function custom(parsingFunction) {\r\n  return Parsimmon(parsingFunction(makeSuccess, makeFailure));\r\n}\r\n\r\n// TODO[ES5]: Improve error message using JSON.stringify eventually.\r\nexport function range(begin, end) {\r\n  return test(function(ch) {\r\n    return begin <= ch && ch <= end;\r\n  }).desc(begin + \"-\" + end);\r\n}\r\n\r\nexport function takeWhile(predicate) {\r\n  assertFunction(predicate);\r\n\r\n  return Parsimmon(function(input, i) {\r\n    var j = i;\r\n    while (j < input.length && predicate(get(input, j))) {\r\n      j++;\r\n    }\r\n    return makeSuccess(j, input.slice(i, j));\r\n  });\r\n}\r\n\r\nexport function lazy(desc, f) {\r\n  if (arguments.length < 2) {\r\n    f = desc;\r\n    desc = undefined;\r\n  }\r\n\r\n  var parser = Parsimmon(function(input, i) {\r\n    parser._ = f()._;\r\n    return parser._(input, i);\r\n  });\r\n\r\n  if (desc) {\r\n    return parser.desc(desc);\r\n  } else {\r\n    return parser;\r\n  }\r\n}\r\n\r\n// -*- Fantasy Land Extras -*-\r\n\r\nfunction empty() {\r\n  return fail(\"fantasy-land/empty\");\r\n}\r\n\r\n_.concat = _.or;\r\n_.empty = empty;\r\n_.of = succeed;\r\n_[\"fantasy-land/ap\"] = _.ap;\r\n_[\"fantasy-land/chain\"] = _.chain;\r\n_[\"fantasy-land/concat\"] = _.concat;\r\n_[\"fantasy-land/empty\"] = _.empty;\r\n_[\"fantasy-land/of\"] = _.of;\r\n_[\"fantasy-land/map\"] = _.map;\r\n\r\n// -*- Base Parsers -*-\r\n\r\nexport const index = Parsimmon(function(input, i) {\r\n  return makeSuccess(i, makeLineColumnIndex(input, i));\r\n});\r\n\r\nexport const any = Parsimmon(function(input, i) {\r\n  if (i >= input.length) {\r\n    return makeFailure(i, \"any character/byte\");\r\n  }\r\n  return makeSuccess(i + 1, get(input, i));\r\n});\r\n\r\nexport const all = Parsimmon(function(input, i) {\r\n  return makeSuccess(input.length, input.slice(i));\r\n});\r\n\r\nexport const eof = Parsimmon(function(input, i) {\r\n  if (i < input.length) {\r\n    return makeFailure(i, \"EOF\");\r\n  }\r\n  return makeSuccess(i, null);\r\n});\r\n\r\nexport const digit = regexp(/[0-9]/).desc(\"a digit\");\r\nexport const digits = regexp(/[0-9]*/).desc(\"optional digits\");\r\nexport const letter = regexp(/[a-z]/i).desc(\"a letter\");\r\nexport const letters = regexp(/[a-z]*/i).desc(\"optional letters\");\r\nexport const optWhitespace = regexp(/\\s*/).desc(\"optional whitespace\");\r\nexport const whitespace = regexp(/\\s+/).desc(\"whitespace\");\r\nexport const cr = string(\"\\r\");\r\nexport const lf = string(\"\\n\");\r\nexport const crlf = string(\"\\r\\n\");\r\nexport const newline = alt(crlf, lf, cr).desc(\"newline\");\r\nexport const end = alt(newline, eof);","import { Record } from \"../fable-library.3.6.3/Types.js\";\nimport { string_type, record_type, int32_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { some } from \"../fable-library.3.6.3/Option.js\";\nimport { seq, noneOf, optWhitespace, whitespace, oneOf, string, takeWhile, test, fail, all, any, digit, lookahead, succeed, eof, letters, letter, lazy, index } from \"./Parsimmon.js\";\nimport { join } from \"../fable-library.3.6.3/String.js\";\nimport { reduce } from \"../fable-library.3.6.3/List.js\";\n\nexport class TokenPosition extends Record {\n    constructor(offset, line, column) {\n        super();\n        this.offset = (offset | 0);\n        this.line = (line | 0);\n        this.column = (column | 0);\n    }\n}\n\nexport function TokenPosition$reflection() {\n    return record_type(\"Fable.Parsimmon.TokenPosition\", [], TokenPosition, () => [[\"offset\", int32_type], [\"line\", int32_type], [\"column\", int32_type]]);\n}\n\nexport class NodeResult$1 extends Record {\n    constructor(name, value, start, end) {\n        super();\n        this.name = name;\n        this.value = value;\n        this.start = start;\n        this.end = end;\n    }\n}\n\nexport function NodeResult$1$reflection(gen0) {\n    return record_type(\"Fable.Parsimmon.NodeResult`1\", [gen0], NodeResult$1, () => [[\"name\", string_type], [\"value\", gen0], [\"start\", TokenPosition$reflection()], [\"end\", TokenPosition$reflection()]]);\n}\n\nexport function Parsimmon_parseRaw(input, parser) {\n    return parser.parse(input);\n}\n\nexport function Parsimmon_parse(input, parser) {\n    const result = parser.parse(input);\n    if (result.status) {\n        return some(result.value);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport const Parsimmon_index = index;\n\nexport function Parsimmon_orTry(otherParser, parser) {\n    return parser.or(otherParser);\n}\n\nexport function Parsimmon_times(n, parser) {\n    return parser.times(n);\n}\n\nexport function Parsimmon_atLeast(n, parser) {\n    return parser.atLeast(n);\n}\n\nexport function Parsimmon_atMost(n, parser) {\n    return parser.atMost(n);\n}\n\nexport function Parsimmon_skip(skipped, keep) {\n    return keep.skip(skipped);\n}\n\nexport function Parsimmon_many(parser) {\n    return parser.many();\n}\n\nexport const Parsimmon_ofLazy = lazy;\n\nexport function Parsimmon_seperateByAtLeastOne(seperator, parser) {\n    return parser.sepBy1(seperator);\n}\n\nexport function Parsimmon_chain(after, before) {\n    return before.then(after);\n}\n\nexport function Parsimmon_bind(f, p) {\n    return p.chain(f);\n}\n\nexport const Parsimmon_letter = letter;\n\nexport function Parsimmon_timesBetween(min, max, parser) {\n    return parser.times(min, max);\n}\n\nexport const Parsimmon_letters = letters;\n\nexport const Parsimmon_endOfFile = eof;\n\nexport function Parsimmon_notFollowedBy(p, before) {\n    return before.notFollowedBy(p);\n}\n\nexport const Parsimmon_succeed = succeed;\n\nexport const Parsimmon_lookahead = lookahead;\n\nexport const Parsimmon_digit = digit;\n\nexport const Parsimmon_digits = Parsimmon_many(Parsimmon_digit);\n\nexport function Parsimmon_fallback(value, parser) {\n    return parser.fallback(value);\n}\n\nexport function Parsimmon_seperateBy(content, others) {\n    return others.sepBy(content);\n}\n\nexport function Parsimmon_between(left, right, middle) {\n    return Parsimmon_skip(right, Parsimmon_chain(middle, left));\n}\n\nexport function Parsimmon_map(f, parser) {\n    return parser.map(f);\n}\n\nexport function Parsimmon_tie(parser) {\n    return Parsimmon_map((strings) => join(\"\", strings), parser);\n}\n\nexport const Parsimmon_any = any;\n\nexport function Parsimmon_choose(ps) {\n    return reduce((acc, parser) => (acc.or(parser)), ps);\n}\n\nexport const Parsimmon_all = all;\n\nexport const Parsimmon_fail = fail;\n\nexport const Parsimmon_satisfy = test;\n\nexport const Parsimmon_takeWhile = takeWhile;\n\nexport const Parsimmon_str = string;\n\nexport const Parsimmon_oneOf = oneOf;\n\nexport const Parsimmon_whitespace = whitespace;\n\nexport const Parsimmon_optionalWhitespace = optWhitespace;\n\nexport function Parsimmon_atLeastOneOrMany(parser) {\n    return Parsimmon_atLeast(1, parser);\n}\n\nexport function Parsimmon_stringReturn(input, value) {\n    return Parsimmon_map((_arg1) => value, Parsimmon_str(input));\n}\n\nexport const Parsimmon_noneOf = noneOf;\n\nexport const Parsimmon_seq2 = seq;\n\nexport function Parsimmon_trim(trimmed, p) {\n    return p.trim(trimmed);\n}\n\nexport function Parsimmon_concat(parser) {\n    return parser.map((strings) => join(\"\", strings));\n}\n\nexport const Parsimmon_seq3 = seq;\n\nexport const Parsimmon_seq4 = seq;\n\nexport const Parsimmon_seq5 = seq;\n\nexport function Parsimmon_node(description, p) {\n    return p.node(description);\n}\n\n","\r\nexport const SR_indexOutOfBounds = \"The index was outside the range of elements in the collection.\";\r\n\r\nexport const SR_inputWasEmpty = \"Collection was empty.\";\r\n\r\nexport const SR_inputMustBeNonNegative = \"The input must be non-negative.\";\r\n\r\nexport const SR_inputSequenceEmpty = \"The input sequence was empty.\";\r\n\r\nexport const SR_inputSequenceTooLong = \"The input sequence contains more than one element.\";\r\n\r\nexport const SR_keyNotFoundAlt = \"An index satisfying the predicate was not found in the collection.\";\r\n\r\nexport const SR_differentLengths = \"The collections had different lengths.\";\r\n\r\nexport const SR_notEnoughElements = \"The input sequence has an insufficient number of elements.\";\r\n\r\n","import { Parsimmon_seperateBy, Parsimmon_ofLazy, Parsimmon_optionalWhitespace, Parsimmon_between, Parsimmon_satisfy, Parsimmon_orTry, Parsimmon_oneOf, Parsimmon_stringReturn, Parsimmon_choose, Parsimmon_many, Parsimmon_seq3, Parsimmon_str, Parsimmon_seq2, Parsimmon_map, Parsimmon_digit, Parsimmon_atLeastOneOrMany, Parsimmon_concat } from \"../Fable.Parsimmon.4.1.0/Parsimmon.fs.js\";\nimport { parse } from \"../fable-library.3.6.3/Double.js\";\nimport { join } from \"../fable-library.3.6.3/String.js\";\nimport { Json } from \"./Json.fs.js\";\nimport { map, ofArray } from \"../fable-library.3.6.3/List.js\";\nimport { ofList } from \"../fable-library.3.6.3/Map.js\";\nimport { Lazy } from \"../fable-library.3.6.3/Util.js\";\n\nexport const digits = Parsimmon_concat(Parsimmon_atLeastOneOrMany(Parsimmon_digit));\n\nexport const jint = Parsimmon_map((value) => parse(value), digits);\n\nexport const negJint = Parsimmon_map((tupledArg) => (-tupledArg[1]), Parsimmon_seq2(Parsimmon_str(\"-\"), jint));\n\nexport const jfloat = Parsimmon_map((tupledArg) => {\n    const digitsLeft = tupledArg[0];\n    return parse(join(\"\", [(digitsLeft === \"\") ? \"0\" : digitsLeft, tupledArg[1], tupledArg[2]]));\n}, Parsimmon_seq3(Parsimmon_concat(Parsimmon_many(Parsimmon_digit)), Parsimmon_str(\".\"), Parsimmon_concat(Parsimmon_atLeastOneOrMany(Parsimmon_digit))));\n\nexport const negativeJFloat = Parsimmon_map((tupledArg) => (-tupledArg[1]), Parsimmon_seq2(Parsimmon_str(\"-\"), jfloat));\n\nexport const jnumber = Parsimmon_map((arg0) => (new Json(0, arg0)), Parsimmon_choose(ofArray([jfloat, negativeJFloat, jint, negJint])));\n\nexport const jbool = Parsimmon_choose(ofArray([Parsimmon_stringReturn(\"true\", new Json(2, true)), Parsimmon_stringReturn(\"false\", new Json(2, false))]));\n\nexport const jnull = Parsimmon_stringReturn(\"null\", new Json(3));\n\nexport const stringLiteral = (() => {\n    const escape = Parsimmon_map((_arg1) => {\n        switch (_arg1) {\n            case \"b\": {\n                return \"\\b\";\n            }\n            case \"f\": {\n                return \"\\f\";\n            }\n            case \"n\": {\n                return \"\\n\";\n            }\n            case \"r\": {\n                return \"\\r\";\n            }\n            case \"t\": {\n                return \"\\t\";\n            }\n            default: {\n                return _arg1;\n            }\n        }\n    }, Parsimmon_oneOf(\"\\\"\\\\/bfnrt\"));\n    const anyCharSnippet = Parsimmon_concat(Parsimmon_many(Parsimmon_orTry(Parsimmon_map((tuple) => tuple[1], Parsimmon_seq2(Parsimmon_str(\"\\\\\"), escape)), Parsimmon_satisfy((c_1) => ((c_1 !== \"\\\"\") && (c_1 !== \"\\\\\"))))));\n    return Parsimmon_between(Parsimmon_str(\"\\\"\"), Parsimmon_str(\"\\\"\"), anyCharSnippet);\n})();\n\nexport const jstring = stringLiteral.map((arg0) => (new Json(1, arg0)));\n\nexport function withWhitespace(p) {\n    return Parsimmon_between(Parsimmon_optionalWhitespace, Parsimmon_optionalWhitespace, p);\n}\n\nexport const jvalue = Parsimmon_choose(map((p) => withWhitespace(p), ofArray([jnull, jbool, jnumber, jstring])));\n\nexport const comma = withWhitespace(Parsimmon_str(\",\"));\n\nfunction json$004099() {\n    return Parsimmon_ofLazy(() => Parsimmon_choose(ofArray([jvalue, Parsimmon_map((arg) => (new Json(4, ofArray(arg))), Parsimmon_between(withWhitespace(Parsimmon_str(\"[\")), withWhitespace(Parsimmon_str(\"]\")), Parsimmon_seperateBy(comma, json$004099$002D1.Value))), Parsimmon_map((arg_2) => (new Json(5, ofList(ofArray(arg_2)))), Parsimmon_between(withWhitespace(Parsimmon_str(\"{\")), withWhitespace(Parsimmon_str(\"}\")), Parsimmon_seperateBy(comma, Parsimmon_map((tupledArg) => [tupledArg[0], tupledArg[2]], Parsimmon_seq3(withWhitespace(stringLiteral), withWhitespace(Parsimmon_str(\":\")), withWhitespace(json$004099$002D1.Value))))))])));\n}\n\nconst json$004099$002D1 = new Lazy(json$004099);\n\nexport const json = json$004099$002D1.Value;\n\nexport const jsonParser = withWhitespace(json);\n\n","import { Record } from \"../Types.js\";\r\nimport { record_type, array_type, int32_type } from \"../Reflection.js\";\r\nimport { op_LeftShift, op_BitwiseAnd, op_Addition, compare, op_Subtraction, op_Division, equals, fromInteger, op_Multiply, op_Modulus, toInt, fromBits } from \"../Long.js\";\r\nimport { copy, initialize, map, fill } from \"../Array.js\";\r\nimport { toArray, empty, head, tail, isEmpty, cons } from \"../List.js\";\r\nimport { int32ToString } from \"../Util.js\";\r\nimport { isNullOrEmpty, join } from \"../String.js\";\r\n\r\nexport class BigNat extends Record {\r\n    constructor(bound, digits) {\r\n        super();\r\n        this.bound = (bound | 0);\r\n        this.digits = digits;\r\n    }\r\n}\r\n\r\nexport function BigNat$reflection() {\r\n    return record_type(\"BigInt.BigNat\", [], BigNat, () => [[\"bound\", int32_type], [\"digits\", array_type(int32_type)]]);\r\n}\r\n\r\nexport function BigNatModule_FFT_pow32(x_mut, n_mut) {\r\n    BigNatModule_FFT_pow32:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return 1;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (x * x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_FFT_pow32;\r\n        }\r\n        else {\r\n            return (x * BigNatModule_FFT_pow32(x * x, ~(~(n / 2)))) | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_leastBounding2Power(b) {\r\n    const findBounding2Power = (b_1_mut, tp_mut, i_mut) => {\r\n        findBounding2Power:\r\n        while (true) {\r\n            const b_1 = b_1_mut, tp = tp_mut, i = i_mut;\r\n            if (b_1 <= tp) {\r\n                return [tp, i];\r\n            }\r\n            else {\r\n                b_1_mut = b_1;\r\n                tp_mut = (tp * 2);\r\n                i_mut = (i + 1);\r\n                continue findBounding2Power;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return findBounding2Power(b, 1, 0);\r\n}\r\n\r\nexport const BigNatModule_FFT_p = fromBits(2013265921, 0, false);\r\n\r\nconst BigNatModule_FFT_patternInput$004075 = [27, 15, 31, 440564289];\r\n\r\nexport const BigNatModule_FFT_w = BigNatModule_FFT_patternInput$004075[3];\r\n\r\nexport const BigNatModule_FFT_m = BigNatModule_FFT_patternInput$004075[1];\r\n\r\nexport const BigNatModule_FFT_k = BigNatModule_FFT_patternInput$004075[0];\r\n\r\nexport const BigNatModule_FFT_g = BigNatModule_FFT_patternInput$004075[2];\r\n\r\nexport const BigNatModule_FFT_primeP = BigNatModule_FFT_p;\r\n\r\nexport const BigNatModule_FFT_maxBitsInsideFp = 30;\r\n\r\nexport const BigNatModule_FFT_Fp_p = 2013265921;\r\n\r\nexport const BigNatModule_FFT_Fp_p64 = fromBits(2013265921, 0, true);\r\n\r\nexport function BigNatModule_FFT_Fp_toInt(x) {\r\n    return ~(~x);\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_ofInt32(x) {\r\n    return x >>> 0;\r\n}\r\n\r\nexport const BigNatModule_FFT_Fp_mzero = 0;\r\n\r\nexport const BigNatModule_FFT_Fp_mone = 1;\r\n\r\nexport const BigNatModule_FFT_Fp_mtwo = 2;\r\n\r\nexport function BigNatModule_FFT_Fp_mpow(x_mut, n_mut) {\r\n    BigNatModule_FFT_Fp_mpow:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return BigNatModule_FFT_Fp_mone;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_FFT_Fp_mpow;\r\n        }\r\n        else {\r\n            const y_2 = BigNatModule_FFT_Fp_mpow(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, ~(~(n / 2)));\r\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_mpowL(x_mut, n_mut) {\r\n    BigNatModule_FFT_Fp_mpowL:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (equals(n, fromBits(0, 0, false))) {\r\n            return BigNatModule_FFT_Fp_mone;\r\n        }\r\n        else if (equals(op_Modulus(n, fromBits(2, 0, false)), fromBits(0, 0, false))) {\r\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\r\n            n_mut = op_Division(n, fromBits(2, 0, false));\r\n            continue BigNatModule_FFT_Fp_mpowL;\r\n        }\r\n        else {\r\n            const y_2 = BigNatModule_FFT_Fp_mpowL(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, op_Division(n, fromBits(2, 0, false)));\r\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_m2PowNthRoot(n) {\r\n    return BigNatModule_FFT_Fp_mpow(BigNatModule_FFT_w >>> 0, BigNatModule_FFT_pow32(2, BigNatModule_FFT_k - n));\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_minv(x) {\r\n    return BigNatModule_FFT_Fp_mpowL(x, op_Subtraction(BigNatModule_FFT_primeP, fromBits(2, 0, false)));\r\n}\r\n\r\nexport function BigNatModule_FFT_computeFFT(lambda, mu, n, w, u, res, offset) {\r\n    let x_1, x_3, y_5;\r\n    if (n === 1) {\r\n        res[offset] = u[mu];\r\n    }\r\n    else {\r\n        const halfN = (~(~(n / 2))) | 0;\r\n        const ww = toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(w, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        const offsetHalfN = (offset + halfN) | 0;\r\n        BigNatModule_FFT_computeFFT(lambda * 2, mu, halfN, ww, u, res, offset);\r\n        BigNatModule_FFT_computeFFT(lambda * 2, lambda + mu, halfN, ww, u, res, offsetHalfN);\r\n        let wj = BigNatModule_FFT_Fp_mone;\r\n        for (let j = 0; j <= (halfN - 1); j++) {\r\n            const even = res[offset + j];\r\n            const odd = res[offsetHalfN + j];\r\n            res[offset + j] = ((even + ((x_1 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_1, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0))) % BigNatModule_FFT_Fp_p);\r\n            res[offsetHalfN + j] = (((even + BigNatModule_FFT_Fp_p) - ((x_3 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_3, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0))) % BigNatModule_FFT_Fp_p);\r\n            wj = ((y_5 = wj, toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(y_5, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_computFftInPlace(n, w, u) {\r\n    const res = fill(new Uint32Array(n), 0, n, BigNatModule_FFT_Fp_mzero);\r\n    BigNatModule_FFT_computeFFT(1, 0, n, w, u, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function BigNatModule_FFT_computeInverseFftInPlace(n, w, uT) {\r\n    const bigKInv = BigNatModule_FFT_Fp_minv(n >>> 0);\r\n    return map((y) => (toInt(op_Modulus(op_Multiply(fromInteger(bigKInv, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0), BigNatModule_FFT_computFftInPlace(n, BigNatModule_FFT_Fp_minv(w), uT), Uint32Array);\r\n}\r\n\r\nexport const BigNatModule_FFT_maxTwoPower = 29;\r\n\r\nexport const BigNatModule_FFT_twoPowerTable = initialize(BigNatModule_FFT_maxTwoPower - 1, (i) => BigNatModule_FFT_pow32(2, i), Int32Array);\r\n\r\nexport function BigNatModule_FFT_computeFftPaddedPolynomialProduct(bigK, k, u, v) {\r\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(k);\r\n    const n = bigK | 0;\r\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u);\r\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v);\r\n    return BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\r\n        const x = uT[i];\r\n        const y = vT[i];\r\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n    }, Uint32Array));\r\n}\r\n\r\nexport function BigNatModule_FFT_padTo(n, u) {\r\n    const uBound = u.length | 0;\r\n    return initialize(n, (i) => ((i < uBound) ? BigNatModule_FFT_Fp_ofInt32(u[i]) : BigNatModule_FFT_Fp_mzero), Uint32Array);\r\n}\r\n\r\nexport function BigNatModule_FFT_computeFftPolynomialProduct(degu, u, degv, v) {\r\n    const patternInput = BigNatModule_FFT_leastBounding2Power((degu + degv) + 1);\r\n    const bigK = patternInput[0] | 0;\r\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(patternInput[1]);\r\n    const u_1 = BigNatModule_FFT_padTo(bigK, u);\r\n    const v_1 = BigNatModule_FFT_padTo(bigK, v);\r\n    const n = bigK | 0;\r\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u_1);\r\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v_1);\r\n    return map((x_1) => BigNatModule_FFT_Fp_toInt(x_1), BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\r\n        const x = uT[i];\r\n        const y = vT[i];\r\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n    }, Uint32Array)), Int32Array);\r\n}\r\n\r\nexport const BigNatModule_FFT_mzero = BigNatModule_FFT_Fp_mzero;\r\n\r\nexport const BigNatModule_FFT_mone = BigNatModule_FFT_Fp_mone;\r\n\r\nexport const BigNatModule_FFT_maxFp = ((BigNatModule_FFT_Fp_p + BigNatModule_FFT_Fp_p) - BigNatModule_FFT_mone) % BigNatModule_FFT_Fp_p;\r\n\r\nexport function BigNatModule_bound(n) {\r\n    return n.bound;\r\n}\r\n\r\nexport function BigNatModule_setBound(n, v) {\r\n    n.bound = (v | 0);\r\n}\r\n\r\nexport function BigNatModule_coeff(n, i) {\r\n    return n.digits[i];\r\n}\r\n\r\nexport function BigNatModule_coeff64(n, i) {\r\n    return fromInteger(BigNatModule_coeff(n, i), false, 2);\r\n}\r\n\r\nexport function BigNatModule_setCoeff(n, i, v) {\r\n    n.digits[i] = (v | 0);\r\n}\r\n\r\nexport function BigNatModule_pow64(x_mut, n_mut) {\r\n    BigNatModule_pow64:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return fromBits(1, 0, false);\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = op_Multiply(x, x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_pow64;\r\n        }\r\n        else {\r\n            return op_Multiply(x, BigNatModule_pow64(op_Multiply(x, x), ~(~(n / 2))));\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_pow32(x_mut, n_mut) {\r\n    BigNatModule_pow32:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return 1;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (x * x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_pow32;\r\n        }\r\n        else {\r\n            return (x * BigNatModule_pow32(x * x, ~(~(n / 2)))) | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_hash(n) {\r\n    let res = 0;\r\n    for (let i = 0; i <= (n.bound - 1); i++) {\r\n        res = ((n.digits[i] + (res << 3)) | 0);\r\n    }\r\n    return res | 0;\r\n}\r\n\r\nexport function BigNatModule_maxInt(a, b) {\r\n    if (a < b) {\r\n        return b | 0;\r\n    }\r\n    else {\r\n        return a | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_minInt(a, b) {\r\n    if (a < b) {\r\n        return a | 0;\r\n    }\r\n    else {\r\n        return b | 0;\r\n    }\r\n}\r\n\r\nexport const BigNatModule_baseBits = 24;\r\n\r\nexport const BigNatModule_baseN = 16777216;\r\n\r\nexport const BigNatModule_baseMask = 16777215;\r\n\r\nexport const BigNatModule_baseNi64 = fromBits(16777216, 0, false);\r\n\r\nexport const BigNatModule_baseMaski64 = fromBits(16777215, 0, false);\r\n\r\nexport const BigNatModule_baseMaskU = fromBits(16777215, 0, true);\r\n\r\nexport const BigNatModule_baseMask32A = 16777215;\r\n\r\nexport const BigNatModule_baseMask32B = 255;\r\n\r\nexport const BigNatModule_baseShift32B = 24;\r\n\r\nexport const BigNatModule_baseMask64A = 16777215;\r\n\r\nexport const BigNatModule_baseMask64B = 16777215;\r\n\r\nexport const BigNatModule_baseMask64C = 65535;\r\n\r\nexport const BigNatModule_baseShift64B = 24;\r\n\r\nexport const BigNatModule_baseShift64C = 48;\r\n\r\nexport function BigNatModule_divbase(x) {\r\n    return ~(~((x >>> 0) >>> BigNatModule_baseBits));\r\n}\r\n\r\nexport function BigNatModule_modbase(x) {\r\n    return x & BigNatModule_baseMask;\r\n}\r\n\r\nexport function BigNatModule_createN(b) {\r\n    return new BigNat(b, new Int32Array(b));\r\n}\r\n\r\nexport function BigNatModule_copyN(x) {\r\n    return new BigNat(x.bound, copy(x.digits));\r\n}\r\n\r\nexport function BigNatModule_normN(n) {\r\n    const findLeastBound = (na_mut, i_mut) => {\r\n        findLeastBound:\r\n        while (true) {\r\n            const na = na_mut, i = i_mut;\r\n            if ((i === -1) ? true : (na[i] !== 0)) {\r\n                return (i + 1) | 0;\r\n            }\r\n            else {\r\n                na_mut = na;\r\n                i_mut = (i - 1);\r\n                continue findLeastBound;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const bound = findLeastBound(n.digits, n.bound - 1) | 0;\r\n    n.bound = (bound | 0);\r\n    return n;\r\n}\r\n\r\nexport const BigNatModule_boundInt = 2;\r\n\r\nexport const BigNatModule_boundInt64 = 3;\r\n\r\nexport const BigNatModule_boundBase = 1;\r\n\r\nexport function BigNatModule_embed(x) {\r\n    const x_1 = ((x < 0) ? 0 : x) | 0;\r\n    if (x_1 < BigNatModule_baseN) {\r\n        const r = BigNatModule_createN(1);\r\n        r.digits[0] = (x_1 | 0);\r\n        return BigNatModule_normN(r);\r\n    }\r\n    else {\r\n        const r_1 = BigNatModule_createN(BigNatModule_boundInt);\r\n        for (let i = 0; i <= (BigNatModule_boundInt - 1); i++) {\r\n            r_1.digits[i] = (((~(~(x_1 / BigNatModule_pow32(BigNatModule_baseN, i)))) % BigNatModule_baseN) | 0);\r\n        }\r\n        return BigNatModule_normN(r_1);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_embed64(x) {\r\n    const x_1 = (compare(x, fromBits(0, 0, false)) < 0) ? fromBits(0, 0, false) : x;\r\n    const r = BigNatModule_createN(BigNatModule_boundInt64);\r\n    for (let i = 0; i <= (BigNatModule_boundInt64 - 1); i++) {\r\n        r.digits[i] = ((~(~toInt(op_Modulus(op_Division(x_1, BigNatModule_pow64(BigNatModule_baseNi64, i)), BigNatModule_baseNi64)))) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_eval32(n) {\r\n    if (n.bound === 1) {\r\n        return n.digits[0] | 0;\r\n    }\r\n    else {\r\n        let acc = 0;\r\n        for (let i = n.bound - 1; i >= 0; i--) {\r\n            acc = ((n.digits[i] + (BigNatModule_baseN * acc)) | 0);\r\n        }\r\n        return acc | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_eval64(n) {\r\n    if (n.bound === 1) {\r\n        return fromInteger(n.digits[0], false, 2);\r\n    }\r\n    else {\r\n        let acc = fromBits(0, 0, false);\r\n        for (let i = n.bound - 1; i >= 0; i--) {\r\n            acc = op_Addition(fromInteger(n.digits[i], false, 2), op_Multiply(BigNatModule_baseNi64, acc));\r\n        }\r\n        return acc;\r\n    }\r\n}\r\n\r\nexport const BigNatModule_one = BigNatModule_embed(1);\r\n\r\nexport const BigNatModule_zero = BigNatModule_embed(0);\r\n\r\nexport function BigNatModule_restrictTo(d, n) {\r\n    return new BigNat(BigNatModule_minInt(d, n.bound), n.digits);\r\n}\r\n\r\nexport function BigNatModule_shiftUp(d, n) {\r\n    const m = BigNatModule_createN(n.bound + d);\r\n    for (let i = 0; i <= (n.bound - 1); i++) {\r\n        m.digits[i + d] = (n.digits[i] | 0);\r\n    }\r\n    return m;\r\n}\r\n\r\nexport function BigNatModule_shiftDown(d, n) {\r\n    if ((n.bound - d) <= 0) {\r\n        return BigNatModule_zero;\r\n    }\r\n    else {\r\n        const m = BigNatModule_createN(n.bound - d);\r\n        for (let i = 0; i <= (m.bound - 1); i++) {\r\n            m.digits[i] = (n.digits[i + d] | 0);\r\n        }\r\n        return m;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_degree(n) {\r\n    return n.bound - 1;\r\n}\r\n\r\nexport function BigNatModule_addP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\r\n    let z, i_1, z_1, i_2;\r\n    BigNatModule_addP:\r\n    while (true) {\r\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\r\n        if (i < n) {\r\n            const x = ((((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0))) + ((z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0)))) + c) | 0;\r\n            r.digits[i] = (BigNatModule_modbase(x) | 0);\r\n            i_mut = (i + 1);\r\n            n_mut = n;\r\n            c_mut = BigNatModule_divbase(x);\r\n            p_mut = p;\r\n            q_mut = q;\r\n            r_mut = r;\r\n            continue BigNatModule_addP;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_add(p, q) {\r\n    const rbound = (1 + BigNatModule_maxInt(p.bound, q.bound)) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    BigNatModule_addP(0, rbound, 0, p, q, r);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_subP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\r\n    let z, i_1, z_1, i_2;\r\n    BigNatModule_subP:\r\n    while (true) {\r\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\r\n        if (i < n) {\r\n            const x = ((((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0))) - ((z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0)))) + c) | 0;\r\n            if (x > 0) {\r\n                r.digits[i] = (BigNatModule_modbase(x) | 0);\r\n                i_mut = (i + 1);\r\n                n_mut = n;\r\n                c_mut = BigNatModule_divbase(x);\r\n                p_mut = p;\r\n                q_mut = q;\r\n                r_mut = r;\r\n                continue BigNatModule_subP;\r\n            }\r\n            else {\r\n                const x_1 = (x + BigNatModule_baseN) | 0;\r\n                r.digits[i] = (BigNatModule_modbase(x_1) | 0);\r\n                i_mut = (i + 1);\r\n                n_mut = n;\r\n                c_mut = (BigNatModule_divbase(x_1) - 1);\r\n                p_mut = p;\r\n                q_mut = q;\r\n                r_mut = r;\r\n                continue BigNatModule_subP;\r\n            }\r\n        }\r\n        else {\r\n            return c !== 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_sub(p, q) {\r\n    const rbound = BigNatModule_maxInt(p.bound, q.bound) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    if (BigNatModule_subP(0, rbound, 0, p, q, r)) {\r\n        return BigNatModule_embed(0);\r\n    }\r\n    else {\r\n        return BigNatModule_normN(r);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_isZero(p) {\r\n    return p.bound === 0;\r\n}\r\n\r\nexport function BigNatModule_IsZero(p) {\r\n    return BigNatModule_isZero(p);\r\n}\r\n\r\nexport function BigNatModule_isOne(p) {\r\n    if (p.bound === 1) {\r\n        return p.digits[0] === 1;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_equal(p, q) {\r\n    if (p.bound === q.bound) {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return true;\r\n                }\r\n                else if (pa[i] === qa[i]) {\r\n                    pa_mut = pa;\r\n                    qa_mut = qa;\r\n                    i_mut = (i - 1);\r\n                    continue check;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, p.bound - 1);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_shiftCompare(p, pn, q, qn) {\r\n    if ((p.bound + pn) < (q.bound + qn)) {\r\n        return -1;\r\n    }\r\n    else if ((p.bound + pn) > (q.bound + pn)) {\r\n        return 1;\r\n    }\r\n    else {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return 0;\r\n                }\r\n                else {\r\n                    const pai = ((i < pn) ? 0 : pa[i - pn]) | 0;\r\n                    const qai = ((i < qn) ? 0 : qa[i - qn]) | 0;\r\n                    if (pai === qai) {\r\n                        pa_mut = pa;\r\n                        qa_mut = qa;\r\n                        i_mut = (i - 1);\r\n                        continue check;\r\n                    }\r\n                    else if (pai < qai) {\r\n                        return -1;\r\n                    }\r\n                    else {\r\n                        return 1;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, (p.bound + pn) - 1) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_compare(p, q) {\r\n    if (p.bound < q.bound) {\r\n        return -1;\r\n    }\r\n    else if (p.bound > q.bound) {\r\n        return 1;\r\n    }\r\n    else {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return 0;\r\n                }\r\n                else if (pa[i] === qa[i]) {\r\n                    pa_mut = pa;\r\n                    qa_mut = qa;\r\n                    i_mut = (i - 1);\r\n                    continue check;\r\n                }\r\n                else if (pa[i] < qa[i]) {\r\n                    return -1;\r\n                }\r\n                else {\r\n                    return 1;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, p.bound - 1) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_lt(p, q) {\r\n    return BigNatModule_compare(p, q) === -1;\r\n}\r\n\r\nexport function BigNatModule_gt(p, q) {\r\n    return BigNatModule_compare(p, q) === 1;\r\n}\r\n\r\nexport function BigNatModule_lte(p, q) {\r\n    return BigNatModule_compare(p, q) !== 1;\r\n}\r\n\r\nexport function BigNatModule_gte(p, q) {\r\n    return BigNatModule_compare(p, q) !== -1;\r\n}\r\n\r\nexport function BigNatModule_min(a, b) {\r\n    if (BigNatModule_lt(a, b)) {\r\n        return a;\r\n    }\r\n    else {\r\n        return b;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_max(a, b) {\r\n    if (BigNatModule_lt(a, b)) {\r\n        return b;\r\n    }\r\n    else {\r\n        return a;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_contributeArr(a_mut, i_mut, c_mut) {\r\n    BigNatModule_contributeArr:\r\n    while (true) {\r\n        const a = a_mut, i = i_mut, c = c_mut;\r\n        const x = op_Addition(fromInteger(a[i], false, 2), c);\r\n        const c_1 = op_Division(x, BigNatModule_baseNi64);\r\n        const x_3 = (~(~toInt(op_BitwiseAnd(x, BigNatModule_baseMaski64)))) | 0;\r\n        a[i] = (x_3 | 0);\r\n        if (compare(c_1, fromBits(0, 0, false)) > 0) {\r\n            a_mut = a;\r\n            i_mut = (i + 1);\r\n            c_mut = c_1;\r\n            continue BigNatModule_contributeArr;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_scale(k, p) {\r\n    const r = BigNatModule_createN(p.bound + BigNatModule_boundInt);\r\n    const k_1 = fromInteger(k, false, 2);\r\n    for (let i = 0; i <= (p.bound - 1); i++) {\r\n        BigNatModule_contributeArr(r.digits, i, op_Multiply(k_1, fromInteger(p.digits[i], false, 2)));\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookBothSmall(p, q) {\r\n    const r = BigNatModule_createN(2);\r\n    const rak = op_Multiply(fromInteger(p, false, 2), fromInteger(q, false, 2));\r\n    BigNatModule_setCoeff(r, 0, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n    BigNatModule_setCoeff(r, 1, ~(~toInt(op_Division(rak, BigNatModule_baseNi64))));\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookCarry(r_mut, c_mut, k_mut) {\r\n    BigNatModule_mulSchoolBookCarry:\r\n    while (true) {\r\n        const r = r_mut, c = c_mut, k = k_mut;\r\n        if (compare(c, fromBits(0, 0, false)) > 0) {\r\n            const rak = op_Addition(BigNatModule_coeff64(r, k), c);\r\n            BigNatModule_setCoeff(r, k, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n            r_mut = r;\r\n            c_mut = op_Division(rak, BigNatModule_baseNi64);\r\n            k_mut = (k + 1);\r\n            continue BigNatModule_mulSchoolBookCarry;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookOneSmall(p, q) {\r\n    const bp = BigNatModule_bound(p) | 0;\r\n    const r = BigNatModule_createN(bp + 1);\r\n    const q_1 = fromInteger(q, false, 2);\r\n    let c = fromBits(0, 0, false);\r\n    for (let i = 0; i <= (bp - 1); i++) {\r\n        const rak = op_Addition(op_Addition(c, BigNatModule_coeff64(r, i)), op_Multiply(BigNatModule_coeff64(p, i), q_1));\r\n        BigNatModule_setCoeff(r, i, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n        c = op_Division(rak, BigNatModule_baseNi64);\r\n    }\r\n    BigNatModule_mulSchoolBookCarry(r, c, bp);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookNeitherSmall(p, q) {\r\n    const r = BigNatModule_createN(p.bound + q.bound);\r\n    const ra = r.digits;\r\n    for (let i = 0; i <= (p.bound - 1); i++) {\r\n        const pai = fromInteger(p.digits[i], false, 2);\r\n        let c = fromBits(0, 0, false);\r\n        let k = i;\r\n        for (let j = 0; j <= (q.bound - 1); j++) {\r\n            const qaj = fromInteger(q.digits[j], false, 2);\r\n            const rak = op_Addition(op_Addition(fromInteger(ra[k], false, 2), c), op_Multiply(pai, qaj));\r\n            ra[k] = ((~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64)))) | 0);\r\n            c = op_Division(rak, BigNatModule_baseNi64);\r\n            k = ((k + 1) | 0);\r\n        }\r\n        BigNatModule_mulSchoolBookCarry(r, c, k);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBook(p, q) {\r\n    const pSmall = BigNatModule_bound(p) === 1;\r\n    const qSmall = BigNatModule_bound(q) === 1;\r\n    if (pSmall && qSmall) {\r\n        return BigNatModule_mulSchoolBookBothSmall(BigNatModule_coeff(p, 0), BigNatModule_coeff(q, 0));\r\n    }\r\n    else if (pSmall) {\r\n        return BigNatModule_mulSchoolBookOneSmall(q, BigNatModule_coeff(p, 0));\r\n    }\r\n    else if (qSmall) {\r\n        return BigNatModule_mulSchoolBookOneSmall(p, BigNatModule_coeff(q, 0));\r\n    }\r\n    else {\r\n        return BigNatModule_mulSchoolBookNeitherSmall(p, q);\r\n    }\r\n}\r\n\r\nexport class BigNatModule_encoding extends Record {\r\n    constructor(bigL, twoToBigL, k, bigK, bigN, split, splits) {\r\n        super();\r\n        this.bigL = (bigL | 0);\r\n        this.twoToBigL = (twoToBigL | 0);\r\n        this.k = (k | 0);\r\n        this.bigK = (bigK | 0);\r\n        this.bigN = (bigN | 0);\r\n        this.split = (split | 0);\r\n        this.splits = splits;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_encoding$reflection() {\r\n    return record_type(\"BigInt.BigNatModule.encoding\", [], BigNatModule_encoding, () => [[\"bigL\", int32_type], [\"twoToBigL\", int32_type], [\"k\", int32_type], [\"bigK\", int32_type], [\"bigN\", int32_type], [\"split\", int32_type], [\"splits\", array_type(int32_type)]]);\r\n}\r\n\r\nexport function BigNatModule_mkEncoding(bigL, k, bigK, bigN) {\r\n    return new BigNatModule_encoding(bigL, BigNatModule_pow32(2, bigL), k, bigK, bigN, ~(~(BigNatModule_baseBits / bigL)), initialize(~(~(BigNatModule_baseBits / bigL)), (i) => BigNatModule_pow32(2, bigL * i), Int32Array));\r\n}\r\n\r\nexport const BigNatModule_table = [BigNatModule_mkEncoding(1, 28, 268435456, 268435456), BigNatModule_mkEncoding(2, 26, 67108864, 134217728), BigNatModule_mkEncoding(3, 24, 16777216, 50331648), BigNatModule_mkEncoding(4, 22, 4194304, 16777216), BigNatModule_mkEncoding(5, 20, 1048576, 5242880), BigNatModule_mkEncoding(6, 18, 262144, 1572864), BigNatModule_mkEncoding(7, 16, 65536, 458752), BigNatModule_mkEncoding(8, 14, 16384, 131072), BigNatModule_mkEncoding(9, 12, 4096, 36864), BigNatModule_mkEncoding(10, 10, 1024, 10240), BigNatModule_mkEncoding(11, 8, 256, 2816), BigNatModule_mkEncoding(12, 6, 64, 768), BigNatModule_mkEncoding(13, 4, 16, 208)];\r\n\r\nexport function BigNatModule_calculateTableTow(bigL) {\r\n    const k = (BigNatModule_FFT_maxBitsInsideFp - (2 * bigL)) | 0;\r\n    const bigK = BigNatModule_pow64(fromBits(2, 0, false), k);\r\n    return [bigL, k, bigK, op_Multiply(bigK, fromInteger(bigL, false, 2))];\r\n}\r\n\r\nexport function BigNatModule_encodingGivenResultBits(bitsRes) {\r\n    const selectFrom = (i_mut) => {\r\n        selectFrom:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (((i + 1) < BigNatModule_table.length) && (bitsRes < BigNatModule_table[i + 1].bigN)) {\r\n                i_mut = (i + 1);\r\n                continue selectFrom;\r\n            }\r\n            else {\r\n                return BigNatModule_table[i];\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (bitsRes >= BigNatModule_table[0].bigN) {\r\n        throw (new Error(\"Product is huge, around 268435456 bits, beyond quickmul\"));\r\n    }\r\n    else {\r\n        return selectFrom(0);\r\n    }\r\n}\r\n\r\nexport const BigNatModule_bitmask = initialize(BigNatModule_baseBits, (i) => (BigNatModule_pow32(2, i) - 1), Int32Array);\r\n\r\nexport const BigNatModule_twopowers = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow32(2, i), Int32Array);\r\n\r\nexport const BigNatModule_twopowersI64 = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow64(fromBits(2, 0, false), i));\r\n\r\nexport function BigNatModule_wordBits(word) {\r\n    const hi = (k_mut) => {\r\n        hi:\r\n        while (true) {\r\n            const k = k_mut;\r\n            if (k === 0) {\r\n                return 0;\r\n            }\r\n            else if ((word & BigNatModule_twopowers[k - 1]) !== 0) {\r\n                return k | 0;\r\n            }\r\n            else {\r\n                k_mut = (k - 1);\r\n                continue hi;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return hi(BigNatModule_baseBits) | 0;\r\n}\r\n\r\nexport function BigNatModule_bits(u) {\r\n    if (u.bound === 0) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return ((BigNatModule_degree(u) * BigNatModule_baseBits) + BigNatModule_wordBits(u.digits[BigNatModule_degree(u)])) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_extractBits(n, enc, bi) {\r\n    let z, i, z_1, i_1, z_2, i_2;\r\n    const biw = (~(~(bi / BigNatModule_baseBits))) | 0;\r\n    const bjw = (~(~(((bi + enc.bigL) - 1) / BigNatModule_baseBits))) | 0;\r\n    if (biw !== bjw) {\r\n        const xbit = (bi % BigNatModule_baseBits) | 0;\r\n        return (((((z = n, (i = (biw | 0), (i < z.bound) ? z.digits[i] : 0))) >> xbit) | (((z_1 = n, (i_1 = (bjw | 0), (i_1 < z_1.bound) ? z_1.digits[i_1] : 0))) << (BigNatModule_baseBits - xbit))) & BigNatModule_bitmask[enc.bigL]) | 0;\r\n    }\r\n    else {\r\n        return ((((z_2 = n, (i_2 = (biw | 0), (i_2 < z_2.bound) ? z_2.digits[i_2] : 0))) >> (bi % BigNatModule_baseBits)) & BigNatModule_bitmask[enc.bigL]) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_encodePoly(enc, n) {\r\n    const poly = fill(new Uint32Array(enc.bigK), 0, enc.bigK, BigNatModule_FFT_Fp_ofInt32(0));\r\n    const biMax = (n.bound * BigNatModule_baseBits) | 0;\r\n    const encoder = (i_mut, bi_mut) => {\r\n        encoder:\r\n        while (true) {\r\n            const i = i_mut, bi = bi_mut;\r\n            if ((i === enc.bigK) ? true : (bi > biMax)) {\r\n            }\r\n            else {\r\n                const pi = BigNatModule_extractBits(n, enc, bi) | 0;\r\n                poly[i] = BigNatModule_FFT_Fp_ofInt32(pi);\r\n                i_mut = (i + 1);\r\n                bi_mut = (bi + enc.bigL);\r\n                continue encoder;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    encoder(0, 0);\r\n    return poly;\r\n}\r\n\r\nexport function BigNatModule_decodeResultBits(enc, poly) {\r\n    let n = 0;\r\n    for (let i = 0; i <= (poly.length - 1); i++) {\r\n        if (poly[i] !== BigNatModule_FFT_mzero) {\r\n            n = (i | 0);\r\n        }\r\n    }\r\n    return (((BigNatModule_FFT_maxBitsInsideFp + (enc.bigL * n)) + 1) + 1) | 0;\r\n}\r\n\r\nexport function BigNatModule_decodePoly(enc, poly) {\r\n    const rbound = ((~(~(BigNatModule_decodeResultBits(enc, poly) / BigNatModule_baseBits))) + 1) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    const evaluate = (i_mut, j_mut, d_mut) => {\r\n        evaluate:\r\n        while (true) {\r\n            const i = i_mut, j = j_mut, d = d_mut;\r\n            if (i === enc.bigK) {\r\n            }\r\n            else {\r\n                if (j >= rbound) {\r\n                }\r\n                else {\r\n                    BigNatModule_contributeArr(r.digits, j, op_Multiply(fromInteger(BigNatModule_FFT_Fp_toInt(poly[i]), false, 2), BigNatModule_twopowersI64[d]));\r\n                }\r\n                const d_1 = (d + enc.bigL) | 0;\r\n                const patternInput = (d_1 >= BigNatModule_baseBits) ? [j + 1, d_1 - BigNatModule_baseBits] : [j, d_1];\r\n                i_mut = (i + 1);\r\n                j_mut = patternInput[0];\r\n                d_mut = patternInput[1];\r\n                continue evaluate;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    evaluate(0, 0, 0);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_quickMulUsingFft(u, v) {\r\n    const enc = BigNatModule_encodingGivenResultBits(BigNatModule_bits(u) + BigNatModule_bits(v));\r\n    return BigNatModule_normN(BigNatModule_decodePoly(enc, BigNatModule_FFT_computeFftPaddedPolynomialProduct(enc.bigK, enc.k, BigNatModule_encodePoly(enc, u), BigNatModule_encodePoly(enc, v))));\r\n}\r\n\r\nexport const BigNatModule_minDigitsKaratsuba = 16;\r\n\r\nexport function BigNatModule_recMulKaratsuba(mul, p, q) {\r\n    const bmax = BigNatModule_maxInt(p.bound, q.bound) | 0;\r\n    if (bmax > BigNatModule_minDigitsKaratsuba) {\r\n        const k = (~(~(bmax / 2))) | 0;\r\n        const a0 = BigNatModule_restrictTo(k, p);\r\n        const a1 = BigNatModule_shiftDown(k, p);\r\n        const b0 = BigNatModule_restrictTo(k, q);\r\n        const b1 = BigNatModule_shiftDown(k, q);\r\n        const q0 = mul(a0, b0);\r\n        const q1 = mul(BigNatModule_add(a0, a1), BigNatModule_add(b0, b1));\r\n        const q2 = mul(a1, b1);\r\n        return BigNatModule_add(q0, BigNatModule_shiftUp(k, BigNatModule_add(BigNatModule_sub(q1, BigNatModule_add(q0, q2)), BigNatModule_shiftUp(k, q2))));\r\n    }\r\n    else {\r\n        return BigNatModule_mulSchoolBook(p, q);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_mulKaratsuba(x, y) {\r\n    return BigNatModule_recMulKaratsuba((x_1, y_1) => BigNatModule_mulKaratsuba(x_1, y_1), x, y);\r\n}\r\n\r\nexport const BigNatModule_productDigitsUpperSchoolBook = ~(~(64000 / BigNatModule_baseBits));\r\n\r\nexport const BigNatModule_singleDigitForceSchoolBook = ~(~(32000 / BigNatModule_baseBits));\r\n\r\nexport const BigNatModule_productDigitsUpperFft = ~(~(BigNatModule_table[0].bigN / BigNatModule_baseBits));\r\n\r\nexport function BigNatModule_mul(p, q) {\r\n    return BigNatModule_mulSchoolBook(p, q);\r\n}\r\n\r\nexport function BigNatModule_scaleSubInPlace(x, f, a, n) {\r\n    const patternInput = [x.digits, BigNatModule_degree(x)];\r\n    const x_1 = patternInput[0];\r\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\r\n    const ad = patternInput_1[1] | 0;\r\n    const a_1 = patternInput_1[0];\r\n    const f_1 = fromInteger(f, false, 2);\r\n    let j = 0;\r\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\r\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\r\n        if (j > patternInput[1]) {\r\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\r\n        }\r\n        let zLo = ~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)));\r\n        let zHi = op_Division(z, BigNatModule_baseNi64);\r\n        if (zLo <= x_1[j + n]) {\r\n            x_1[j + n] = ((x_1[j + n] - zLo) | 0);\r\n        }\r\n        else {\r\n            x_1[j + n] = ((x_1[j + n] + (BigNatModule_baseN - zLo)) | 0);\r\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\r\n        }\r\n        if (j < ad) {\r\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\r\n        }\r\n        else {\r\n            z = zHi;\r\n        }\r\n        j = ((j + 1) | 0);\r\n    }\r\n    BigNatModule_normN(x);\r\n}\r\n\r\nexport function BigNatModule_scaleSub(x, f, a, n) {\r\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\r\n    BigNatModule_scaleSubInPlace(freshx, f, a, n);\r\n    return BigNatModule_normN(freshx);\r\n}\r\n\r\nexport function BigNatModule_scaleAddInPlace(x, f, a, n) {\r\n    const patternInput = [x.digits, BigNatModule_degree(x)];\r\n    const x_1 = patternInput[0];\r\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\r\n    const ad = patternInput_1[1] | 0;\r\n    const a_1 = patternInput_1[0];\r\n    const f_1 = fromInteger(f, false, 2);\r\n    let j = 0;\r\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\r\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\r\n        if (j > patternInput[1]) {\r\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\r\n        }\r\n        let zLo = ~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)));\r\n        let zHi = op_Division(z, BigNatModule_baseNi64);\r\n        if (zLo < (BigNatModule_baseN - x_1[j + n])) {\r\n            x_1[j + n] = ((x_1[j + n] + zLo) | 0);\r\n        }\r\n        else {\r\n            x_1[j + n] = ((zLo - (BigNatModule_baseN - x_1[j + n])) | 0);\r\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\r\n        }\r\n        if (j < ad) {\r\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\r\n        }\r\n        else {\r\n            z = zHi;\r\n        }\r\n        j = ((j + 1) | 0);\r\n    }\r\n    BigNatModule_normN(x);\r\n}\r\n\r\nexport function BigNatModule_scaleAdd(x, f, a, n) {\r\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\r\n    BigNatModule_scaleAddInPlace(freshx, f, a, n);\r\n    return BigNatModule_normN(freshx);\r\n}\r\n\r\nexport function BigNatModule_removeFactor(x, a, n) {\r\n    const patternInput = [BigNatModule_degree(a), BigNatModule_degree(x)];\r\n    const degx = patternInput[1] | 0;\r\n    const dega = patternInput[0] | 0;\r\n    if (degx < (dega + n)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        const patternInput_1 = [a.digits, x.digits];\r\n        const xa = patternInput_1[1];\r\n        const aa = patternInput_1[0];\r\n        const f = ((dega === 0) ? ((degx === n) ? (~(~(xa[n] / aa[0]))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), fromInteger(aa[0], false, 2)))))) : ((degx === (dega + n)) ? (~(~(xa[degx] / (aa[dega] + 1)))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), op_Addition(fromInteger(aa[dega], false, 2), fromBits(1, 0, false)))))))) | 0;\r\n        if (f === 0) {\r\n            if (BigNatModule_shiftCompare(a, n, x, 0) !== 1) {\r\n                return 1;\r\n            }\r\n            else {\r\n                return 0;\r\n            }\r\n        }\r\n        else {\r\n            return f | 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_divmod(b, a) {\r\n    if (BigNatModule_isZero(a)) {\r\n        throw (new Error());\r\n    }\r\n    else if (BigNatModule_degree(b) < BigNatModule_degree(a)) {\r\n        return [BigNatModule_zero, b];\r\n    }\r\n    else {\r\n        const x = BigNatModule_copyN(b);\r\n        const d = BigNatModule_createN(((BigNatModule_degree(b) - BigNatModule_degree(a)) + 1) + 1);\r\n        let p = BigNatModule_degree(b);\r\n        const m = BigNatModule_degree(a) | 0;\r\n        let n = p - m;\r\n        const Invariant = (tupledArg) => {\r\n        };\r\n        let finished = false;\r\n        while (!finished) {\r\n            Invariant([d, x, n, p]);\r\n            const f = BigNatModule_removeFactor(x, a, n) | 0;\r\n            if (f > 0) {\r\n                BigNatModule_scaleSubInPlace(x, f, a, n);\r\n                BigNatModule_scaleAddInPlace(d, f, BigNatModule_one, n);\r\n                Invariant([d, x, n, p]);\r\n            }\r\n            else {\r\n                finished = ((f === 0) && (n === 0));\r\n                if (!finished) {\r\n                    if (p === (m + n)) {\r\n                        Invariant([d, x, n - 1, p]);\r\n                        n = ((n - 1) | 0);\r\n                    }\r\n                    else {\r\n                        Invariant([d, x, n - 1, p - 1]);\r\n                        n = ((n - 1) | 0);\r\n                        p = ((p - 1) | 0);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return [BigNatModule_normN(d), BigNatModule_normN(x)];\r\n    }\r\n}\r\n\r\nexport function BigNatModule_div(b, a) {\r\n    return BigNatModule_divmod(b, a)[0];\r\n}\r\n\r\nexport function BigNatModule_rem(b, a) {\r\n    return BigNatModule_divmod(b, a)[1];\r\n}\r\n\r\nexport function BigNatModule_bitAnd(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_minInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (r.bound - 1); i++) {\r\n        r.digits[i] = ((a.digits[i] & b.digits[i]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_bitOr(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (a.bound - 1); i++) {\r\n        r.digits[i] = ((r.digits[i] | a.digits[i]) | 0);\r\n    }\r\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\r\n        r.digits[i_1] = ((r.digits[i_1] | b.digits[i_1]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_bitXor(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (a.bound - 1); i++) {\r\n        r.digits[i] = ((r.digits[i] ^ a.digits[i]) | 0);\r\n    }\r\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\r\n        r.digits[i_1] = ((r.digits[i_1] ^ b.digits[i_1]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_hcf(a, b) {\r\n    const hcfloop = (a_1_mut, b_1_mut) => {\r\n        hcfloop:\r\n        while (true) {\r\n            const a_1 = a_1_mut, b_1 = b_1_mut;\r\n            if (BigNatModule_equal(BigNatModule_zero, a_1)) {\r\n                return b_1;\r\n            }\r\n            else {\r\n                a_1_mut = BigNatModule_divmod(b_1, a_1)[1];\r\n                b_1_mut = a_1;\r\n                continue hcfloop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (BigNatModule_lt(a, b)) {\r\n        return hcfloop(a, b);\r\n    }\r\n    else {\r\n        return hcfloop(b, a);\r\n    }\r\n}\r\n\r\nexport const BigNatModule_two = BigNatModule_embed(2);\r\n\r\nexport function BigNatModule_powi(x, n) {\r\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\r\n        power:\r\n        while (true) {\r\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\r\n            if (n_1 === 0) {\r\n                return acc;\r\n            }\r\n            else if ((n_1 % 2) === 0) {\r\n                acc_mut = acc;\r\n                x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                n_1_mut = (~(~(n_1 / 2)));\r\n                continue power;\r\n            }\r\n            else {\r\n                acc_mut = BigNatModule_mul(x_1, acc);\r\n                x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                n_1_mut = (~(~(n_1 / 2)));\r\n                continue power;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return power(BigNatModule_one, x, n);\r\n}\r\n\r\nexport function BigNatModule_pow(x, n) {\r\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\r\n        power:\r\n        while (true) {\r\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\r\n            if (BigNatModule_isZero(n_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                const patternInput = BigNatModule_divmod(n_1, BigNatModule_two);\r\n                const ndiv2 = patternInput[0];\r\n                if (BigNatModule_isZero(patternInput[1])) {\r\n                    acc_mut = acc;\r\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                    n_1_mut = ndiv2;\r\n                    continue power;\r\n                }\r\n                else {\r\n                    acc_mut = BigNatModule_mul(x_1, acc);\r\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                    n_1_mut = ndiv2;\r\n                    continue power;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return power(BigNatModule_one, x, n);\r\n}\r\n\r\nexport function BigNatModule_toFloat(n) {\r\n    const evalFloat = (acc_mut, k_mut, i_mut) => {\r\n        evalFloat:\r\n        while (true) {\r\n            const acc = acc_mut, k = k_mut, i = i_mut;\r\n            if (i === n.bound) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = (acc + (k * n.digits[i]));\r\n                k_mut = (k * BigNatModule_baseN);\r\n                i_mut = (i + 1);\r\n                continue evalFloat;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return evalFloat(0, 1, 0);\r\n}\r\n\r\nexport function BigNatModule_ofInt32(n) {\r\n    return BigNatModule_embed(n);\r\n}\r\n\r\nexport function BigNatModule_ofInt64(n) {\r\n    return BigNatModule_embed64(n);\r\n}\r\n\r\nexport function BigNatModule_toUInt32(n) {\r\n    const matchValue = n.bound | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return 0;\r\n        }\r\n        case 1: {\r\n            const value = n.digits[0] | 0;\r\n            return value >>> 0;\r\n        }\r\n        case 2: {\r\n            const patternInput = [n.digits[0], n.digits[1]];\r\n            const xB = patternInput[1] | 0;\r\n            if (xB > BigNatModule_baseMask32B) {\r\n                throw (new Error());\r\n            }\r\n            return ((patternInput[0] & BigNatModule_baseMask32A) >>> 0) + ((((xB & BigNatModule_baseMask32B) >>> 0) << BigNatModule_baseShift32B) >>> 0);\r\n        }\r\n        default: {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_toUInt64(n) {\r\n    const matchValue = n.bound | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return fromBits(0, 0, true);\r\n        }\r\n        case 1: {\r\n            return fromInteger(n.digits[0], true, 2);\r\n        }\r\n        case 2: {\r\n            const patternInput = [n.digits[0], n.digits[1]];\r\n            return op_Addition(fromInteger(patternInput[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B));\r\n        }\r\n        case 3: {\r\n            const patternInput_1 = [n.digits[0], n.digits[1], n.digits[2]];\r\n            const xC = patternInput_1[2] | 0;\r\n            if (xC > BigNatModule_baseMask64C) {\r\n                throw (new Error());\r\n            }\r\n            return op_Addition(op_Addition(fromInteger(patternInput_1[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput_1[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B)), op_LeftShift(fromInteger(xC & BigNatModule_baseMask64C, true, 2), BigNatModule_baseShift64C));\r\n        }\r\n        default: {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_toString(n) {\r\n    const degn = BigNatModule_degree(n) | 0;\r\n    const route = (prior_mut, k_mut, ten2k_mut) => {\r\n        route:\r\n        while (true) {\r\n            const prior = prior_mut, k = k_mut, ten2k = ten2k_mut;\r\n            if (BigNatModule_degree(ten2k) > degn) {\r\n                return cons([k, ten2k], prior);\r\n            }\r\n            else {\r\n                prior_mut = cons([k, ten2k], prior);\r\n                k_mut = (k + 1);\r\n                ten2k_mut = BigNatModule_mul(ten2k, ten2k);\r\n                continue route;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const collect = (isLeading_mut, digits_mut, n_1_mut, _arg1_mut) => {\r\n        collect:\r\n        while (true) {\r\n            const isLeading = isLeading_mut, digits = digits_mut, n_1 = n_1_mut, _arg1 = _arg1_mut;\r\n            if (!isEmpty(_arg1)) {\r\n                const prior_1 = tail(_arg1);\r\n                const patternInput = BigNatModule_divmod(n_1, head(_arg1)[1]);\r\n                const nL = patternInput[1];\r\n                const nH = patternInput[0];\r\n                if (isLeading && BigNatModule_isZero(nH)) {\r\n                    isLeading_mut = isLeading;\r\n                    digits_mut = digits;\r\n                    n_1_mut = nL;\r\n                    _arg1_mut = prior_1;\r\n                    continue collect;\r\n                }\r\n                else {\r\n                    isLeading_mut = isLeading;\r\n                    digits_mut = collect(false, digits, nL, prior_1);\r\n                    n_1_mut = nH;\r\n                    _arg1_mut = prior_1;\r\n                    continue collect;\r\n                }\r\n            }\r\n            else {\r\n                const n_2 = BigNatModule_eval32(n_1) | 0;\r\n                if (isLeading && (n_2 === 0)) {\r\n                    return digits;\r\n                }\r\n                else {\r\n                    return cons(int32ToString(n_2), digits);\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const digits_4 = collect(true, empty(), n, route(empty(), 0, BigNatModule_embed(10)));\r\n    if (isEmpty(digits_4)) {\r\n        return \"0\";\r\n    }\r\n    else {\r\n        return join(\"\", toArray(digits_4));\r\n    }\r\n}\r\n\r\nexport function BigNatModule_ofString(str) {\r\n    const len = str.length | 0;\r\n    if (isNullOrEmpty(str)) {\r\n        throw (new Error(\"empty string\\\\nParameter name: str\"));\r\n    }\r\n    const ten = BigNatModule_embed(10);\r\n    const build = (acc_mut, i_mut) => {\r\n        build:\r\n        while (true) {\r\n            const acc = acc_mut, i = i_mut;\r\n            if (i === len) {\r\n                return acc;\r\n            }\r\n            else {\r\n                const d = (str[i].charCodeAt(0) - 48) | 0;\r\n                if ((0 <= d) && (d <= 9)) {\r\n                    acc_mut = BigNatModule_add(BigNatModule_mul(ten, acc), BigNatModule_embed(d));\r\n                    i_mut = (i + 1);\r\n                    continue build;\r\n                }\r\n                else {\r\n                    throw (new Error());\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return build(BigNatModule_embed(0), 0);\r\n}\r\n\r\nexport function BigNatModule_isSmall(n) {\r\n    return n.bound <= 1;\r\n}\r\n\r\nexport function BigNatModule_getSmall(n) {\r\n    const z = n;\r\n    const i = 0;\r\n    if (i < z.bound) {\r\n        return z.digits[i] | 0;\r\n    }\r\n    else {\r\n        return 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_factorial(n) {\r\n    const productR = (a, b) => {\r\n        if (BigNatModule_equal(a, b)) {\r\n            return a;\r\n        }\r\n        else {\r\n            const m = BigNatModule_div(BigNatModule_add(a, b), BigNatModule_ofInt32(2));\r\n            return BigNatModule_mul(productR(a, m), productR(BigNatModule_add(m, BigNatModule_one), b));\r\n        }\r\n    };\r\n    return productR(BigNatModule_one, n);\r\n}\r\n\r\n","import { BigNatModule_factorial, BigNatModule_ofString, BigNatModule_toFloat, BigNatModule_toUInt64, BigNatModule_toUInt32, BigNatModule_pow, BigNatModule_two, BigNatModule_rem, BigNatModule_lte, BigNatModule_hcf, BigNatModule_bitXor, BigNatModule_bitOr, BigNatModule_bitAnd, BigNatModule_divmod, BigNatModule_mul, BigNatModule_isOne, BigNatModule_sub, BigNatModule_gte, BigNatModule_scale, BigNatModule_one, BigNatModule_add, BigNatModule_ofInt64, BigNatModule_hash, BigNatModule_gt, BigNatModule_lt, BigNatModule_equal, BigNatModule_getSmall, BigNatModule_isSmall, BigNatModule_ofInt32, BigNatModule_toString, BigNatModule_isZero } from \"./n.js\";\r\nimport { Record, toString } from \"../Types.js\";\r\nimport { class_type } from \"../Reflection.js\";\r\nimport { initialize } from \"../Array.js\";\r\nimport { op_Addition, op_Multiply, fromValue, equals, fromBits, compare, fromInteger, op_UnaryNegation } from \"../Long.js\";\r\nimport { op_UnaryNegation_Int32 } from \"../Int32.js\";\r\nimport Decimal from \"../Decimal.js\";\r\n\r\nexport class BigInteger extends Record {\r\n    constructor(signInt, v) {\r\n        super();\r\n        this.signInt = (signInt | 0);\r\n        this.v = v;\r\n    }\r\n    toString() {\r\n        const x = this;\r\n        const matchValue = BigInteger__get_SignInt(x) | 0;\r\n        switch (matchValue) {\r\n            case -1: {\r\n                return BigNatModule_isZero(BigInteger__get_V(x)) ? \"0\" : (\"-\" + BigNatModule_toString(BigInteger__get_V(x)));\r\n            }\r\n            case 0: {\r\n                return \"0\";\r\n            }\r\n            case 1: {\r\n                return BigNatModule_toString(BigInteger__get_V(x));\r\n            }\r\n            default: {\r\n                throw (new Error(\"signs should be +/- 1 or 0\"));\r\n            }\r\n        }\r\n    }\r\n    Equals(obj) {\r\n        const this$ = this;\r\n        return (obj instanceof BigInteger) && BigInteger_op_Equality_56F059C0(this$, obj);\r\n    }\r\n    GetHashCode() {\r\n        const x = this;\r\n        return BigInteger_hash_Z665282C2(x) | 0;\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return toString(this$);\r\n    }\r\n    CompareTo(obj) {\r\n        const this$ = this;\r\n        if (obj instanceof BigInteger) {\r\n            return BigInteger_compare_56F059C0(this$, obj) | 0;\r\n        }\r\n        else {\r\n            throw (new Error(\"the objects are not comparable\\\\nParameter name: obj\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger$reflection() {\r\n    return class_type(\"BigInt.BigInteger\", void 0, BigInteger, class_type(\"System.ValueType\"));\r\n}\r\n\r\nexport function BigInteger_$ctor_Z2BE94A1(signInt, v) {\r\n    return new BigInteger(signInt, v);\r\n}\r\n\r\n(() => {\r\n    BigInteger.smallLim = 4096;\r\n    BigInteger.smallPosTab = initialize(BigInteger.smallLim, (n) => BigNatModule_ofInt32(n));\r\n    BigInteger.one = BigInteger_$ctor_Z524259A4(1);\r\n    BigInteger.two = BigInteger_$ctor_Z524259A4(2);\r\n    BigInteger.zero = BigInteger_$ctor_Z524259A4(0);\r\n})();\r\n\r\nexport function BigInteger_nat_Z67CCE57D(n) {\r\n    if (BigNatModule_isSmall(n) && (BigNatModule_getSmall(n) < BigInteger.smallLim)) {\r\n        return BigInteger.smallPosTab[BigNatModule_getSmall(n)];\r\n    }\r\n    else {\r\n        return n;\r\n    }\r\n}\r\n\r\nexport function BigInteger_create_Z2BE94A1(s, n) {\r\n    return BigInteger_$ctor_Z2BE94A1(s, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger_posn_Z67CCE57D(n) {\r\n    return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger_negn_Z67CCE57D(n) {\r\n    return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger__get_Sign(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return x.signInt | 0;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_SignInt(x) {\r\n    return x.signInt;\r\n}\r\n\r\nexport function BigInteger__get_V(x) {\r\n    return x.v;\r\n}\r\n\r\nexport function BigInteger_op_Equality_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 2: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 3: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 6: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 7: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 8: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Inequality_56F059C0(x, y) {\r\n    return !BigInteger_op_Equality_56F059C0(x, y);\r\n}\r\n\r\nexport function BigInteger_op_LessThan_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_lt(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_lt(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            return false;\r\n        }\r\n        case 3: {\r\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return true;\r\n            }\r\n            else {\r\n                return !BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n        }\r\n        case 4: {\r\n            return false;\r\n        }\r\n        case 5: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 6: {\r\n            return false;\r\n        }\r\n        case 7: {\r\n            return false;\r\n        }\r\n        case 8: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_GreaterThan_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_gt(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_gt(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return true;\r\n            }\r\n            else {\r\n                return !BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n        }\r\n        case 3: {\r\n            return false;\r\n        }\r\n        case 4: {\r\n            return false;\r\n        }\r\n        case 5: {\r\n            return false;\r\n        }\r\n        case 6: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 7: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 8: {\r\n            return false;\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_compare_56F059C0(n, nn) {\r\n    if (BigInteger_op_LessThan_56F059C0(n, nn)) {\r\n        return -1;\r\n    }\r\n    else if (BigInteger_op_Equality_56F059C0(n, nn)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return 1;\r\n    }\r\n}\r\n\r\nexport function BigInteger_hash_Z665282C2(z) {\r\n    if (BigInteger__get_SignInt(z) === 0) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return (BigInteger__get_SignInt(z) + BigNatModule_hash(BigInteger__get_V(z))) | 0;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_StructuredDisplayString(x) {\r\n    return toString(x);\r\n}\r\n\r\nexport function BigInteger_$ctor_Z524259A4(n) {\r\n    if (n >= 0) {\r\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(n)));\r\n    }\r\n    else if (n === -2147483648) {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(fromInteger(n, false, 2)))));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(op_UnaryNegation_Int32(n))));\r\n    }\r\n}\r\n\r\nexport function BigInteger_$ctor_Z524259C1(n) {\r\n    if (compare(n, fromBits(0, 0, false)) >= 0) {\r\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(n)));\r\n    }\r\n    else if (equals(n, fromBits(0, 2147483648, false))) {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_add(BigNatModule_ofInt64(fromBits(4294967295, 2147483647, false)), BigNatModule_one)));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(n))));\r\n    }\r\n}\r\n\r\nexport function BigInteger_get_One() {\r\n    return BigInteger.one;\r\n}\r\n\r\nexport function BigInteger_get_Two() {\r\n    return BigInteger.two;\r\n}\r\n\r\nexport function BigInteger_get_Zero() {\r\n    return BigInteger.zero;\r\n}\r\n\r\nexport function BigInteger_op_UnaryNegation_Z665282C2(z) {\r\n    const matchValue = BigInteger__get_SignInt(z) | 0;\r\n    if (matchValue === 0) {\r\n        return BigInteger_get_Zero();\r\n    }\r\n    else {\r\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(matchValue), BigInteger__get_V(z));\r\n    }\r\n}\r\n\r\nexport function BigInteger_Scale_Z320F31E(k, z) {\r\n    if (BigInteger__get_SignInt(z) === 0) {\r\n        return BigInteger_get_Zero();\r\n    }\r\n    else if (k < 0) {\r\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(BigInteger__get_SignInt(z)), BigNatModule_scale(op_UnaryNegation_Int32(k), BigInteger__get_V(z)));\r\n    }\r\n    else {\r\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(z), BigNatModule_scale(k, BigInteger__get_V(z)));\r\n    }\r\n}\r\n\r\nexport function BigInteger_subnn_6A57060(nx, ny) {\r\n    if (BigNatModule_gte(nx, ny)) {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_sub(nx, ny));\r\n    }\r\n    else {\r\n        return BigInteger_negn_Z67CCE57D(BigNatModule_sub(ny, nx));\r\n    }\r\n}\r\n\r\nexport function BigInteger_addnn_6A57060(nx, ny) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_add(nx, ny));\r\n}\r\n\r\nexport function BigInteger__get_IsZero(x) {\r\n    if (BigInteger__get_SignInt(x) === 0) {\r\n        return true;\r\n    }\r\n    else {\r\n        return BigNatModule_isZero(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsOne(x) {\r\n    if (BigInteger__get_SignInt(x) === 1) {\r\n        return BigNatModule_isOne(BigInteger__get_V(x));\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Addition_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(x)) {\r\n        return y;\r\n    }\r\n    else {\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 1: {\r\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n            }\r\n            case 2: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 3: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Subtraction_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(x)) {\r\n        return BigInteger_op_UnaryNegation_Z665282C2(y);\r\n    }\r\n    else {\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 1: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\r\n            }\r\n            case 2: {\r\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 3: {\r\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Multiply_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(y)) {\r\n        return y;\r\n    }\r\n    else if (BigInteger__get_IsOne(x)) {\r\n        return y;\r\n    }\r\n    else if (BigInteger__get_IsOne(y)) {\r\n        return x;\r\n    }\r\n    else {\r\n        const m = BigNatModule_mul(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(x) * BigInteger__get_SignInt(y), m);\r\n    }\r\n}\r\n\r\nexport function BigInteger_DivRem_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        throw (new Error());\r\n    }\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return [BigInteger_get_Zero(), BigInteger_get_Zero()];\r\n    }\r\n    else {\r\n        const patternInput = BigNatModule_divmod(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        const r = patternInput[1];\r\n        const d = patternInput[0];\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\r\n            }\r\n            case 1: {\r\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\r\n            }\r\n            case 2: {\r\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\r\n            }\r\n            case 3: {\r\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Division_56F059C0(x, y) {\r\n    return BigInteger_DivRem_56F059C0(x, y)[0];\r\n}\r\n\r\nexport function BigInteger_op_Modulus_56F059C0(x, y) {\r\n    return BigInteger_DivRem_56F059C0(x, y)[1];\r\n}\r\n\r\nexport function BigInteger_op_RightShift_62E082A2(x, y) {\r\n    return BigInteger_op_Division_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\r\n}\r\n\r\nexport function BigInteger_op_LeftShift_62E082A2(x, y) {\r\n    return BigInteger_op_Multiply_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\r\n}\r\n\r\nexport function BigInteger_op_BitwiseAnd_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitAnd(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_op_BitwiseOr_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitOr(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_op_ExclusiveOr_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitXor(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_GreatestCommonDivisor_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    if (matchValue[0] === 0) {\r\n        if (matchValue[1] === 0) {\r\n            return BigInteger_get_Zero();\r\n        }\r\n        else {\r\n            return BigInteger_posn_Z67CCE57D(BigInteger__get_V(y));\r\n        }\r\n    }\r\n    else if (matchValue[1] === 0) {\r\n        return BigInteger_posn_Z67CCE57D(BigInteger__get_V(x));\r\n    }\r\n    else {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_hcf(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsNegative(x) {\r\n    if (BigInteger__get_SignInt(x) === -1) {\r\n        return !BigInteger__get_IsZero(x);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsPositive(x) {\r\n    if (BigInteger__get_SignInt(x) === 1) {\r\n        return !BigInteger__get_IsZero(x);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger_Abs_Z665282C2(x) {\r\n    if (BigInteger__get_SignInt(x) === -1) {\r\n        return BigInteger_op_UnaryNegation_Z665282C2(x);\r\n    }\r\n    else {\r\n        return x;\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_LessThanOrEqual_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_lte(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_lte(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 3: {\r\n            return true;\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 6: {\r\n            return true;\r\n        }\r\n        case 7: {\r\n            return true;\r\n        }\r\n        case 8: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_GreaterThanOrEqual_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_gte(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_gte(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            return true;\r\n        }\r\n        case 3: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return true;\r\n        }\r\n        case 6: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 7: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 8: {\r\n            return true;\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_Pow_62E082A2(x, y) {\r\n    if (y < 0) {\r\n        throw (new Error(\"y\"));\r\n    }\r\n    const matchValue = [BigInteger__get_IsZero(x), y];\r\n    if (matchValue[0]) {\r\n        if (matchValue[1] === 0) {\r\n            return BigInteger_get_One();\r\n        }\r\n        else {\r\n            return BigInteger_get_Zero();\r\n        }\r\n    }\r\n    else {\r\n        const yval = BigInteger_$ctor_Z524259A4(y);\r\n        return BigInteger_create_Z2BE94A1(BigNatModule_isZero(BigNatModule_rem(BigInteger__get_V(yval), BigNatModule_two)) ? 1 : BigInteger__get_SignInt(x), BigNatModule_pow(BigInteger__get_V(x), BigInteger__get_V(yval)));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToInt32(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        const u = BigNatModule_toUInt32(BigInteger__get_V(x));\r\n        if (u <= (2147483647 >>> 0)) {\r\n            return (BigInteger__get_SignInt(x) * (~(~u))) | 0;\r\n        }\r\n        else if ((BigInteger__get_SignInt(x) === -1) && (u === ((2147483647 + 1) >>> 0))) {\r\n            return -2147483648;\r\n        }\r\n        else {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToUInt32(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return BigNatModule_toUInt32(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToInt64(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return fromBits(0, 0, false);\r\n    }\r\n    else {\r\n        const u = BigNatModule_toUInt64(BigInteger__get_V(x));\r\n        if (compare(u, fromValue(fromBits(4294967295, 2147483647, false), true)) <= 0) {\r\n            return op_Multiply(fromInteger(BigInteger__get_SignInt(x), false, 2), fromValue(u, false));\r\n        }\r\n        else if ((BigInteger__get_SignInt(x) === -1) && equals(u, fromValue(op_Addition(fromBits(4294967295, 2147483647, false), fromBits(1, 0, false)), true))) {\r\n            return fromBits(0, 2147483648, false);\r\n        }\r\n        else {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToUInt64(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return fromBits(0, 0, true);\r\n    }\r\n    else {\r\n        return BigNatModule_toUInt64(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToDouble(x) {\r\n    const matchValue = BigInteger__get_SignInt(x) | 0;\r\n    switch (matchValue) {\r\n        case -1: {\r\n            return -BigNatModule_toFloat(BigInteger__get_V(x));\r\n        }\r\n        case 0: {\r\n            return 0;\r\n        }\r\n        case 1: {\r\n            return BigNatModule_toFloat(BigInteger__get_V(x));\r\n        }\r\n        default: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToSByte(x) {\r\n    return (BigInteger__get_ToInt32(x) + 0x80 & 0xFF) - 0x80;\r\n}\r\n\r\nexport function BigInteger__get_ToByte(x) {\r\n    return BigInteger__get_ToUInt32(x) & 0xFF;\r\n}\r\n\r\nexport function BigInteger__get_ToInt16(x) {\r\n    return (BigInteger__get_ToInt32(x) + 0x8000 & 0xFFFF) - 0x8000;\r\n}\r\n\r\nexport function BigInteger__get_ToUInt16(x) {\r\n    return BigInteger__get_ToUInt32(x) & 0xFFFF;\r\n}\r\n\r\nexport function BigInteger__get_ToSingle(x) {\r\n    return BigInteger__get_ToDouble(x);\r\n}\r\n\r\nexport function BigInteger__get_ToDecimal(x) {\r\n    return new Decimal(BigInteger__get_ToDouble(x));\r\n}\r\n\r\nexport function BigInteger_Parse_Z721C83C5(text) {\r\n    if (text == null) {\r\n        throw (new Error(\"text\"));\r\n    }\r\n    const text_1 = text.trim();\r\n    const len = text_1.length | 0;\r\n    if (len === 0) {\r\n        throw (new Error());\r\n    }\r\n    const matchValue = [text_1[0], len];\r\n    if (matchValue[0] === \"+\") {\r\n        if (matchValue[1] === 1) {\r\n            throw (new Error());\r\n        }\r\n        else {\r\n            return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\r\n        }\r\n    }\r\n    else if (matchValue[0] === \"-\") {\r\n        if (matchValue[1] === 1) {\r\n            throw (new Error());\r\n        }\r\n        else {\r\n            return BigInteger_negn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\r\n        }\r\n    }\r\n    else {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsSmall(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return true;\r\n    }\r\n    else {\r\n        return BigNatModule_isSmall(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger_Factorial_Z665282C2(x) {\r\n    if (BigInteger__get_IsNegative(x)) {\r\n        throw (new Error(\"mustBeNonNegative\\\\nParameter name: x\"));\r\n    }\r\n    if (BigInteger__get_IsPositive(x)) {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_factorial(BigInteger__get_V(x)));\r\n    }\r\n    else {\r\n        return BigInteger_get_One();\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_UnaryPlus_Z665282C2(n1) {\r\n    return n1;\r\n}\r\n\r\nexport function BigInteger_FromInt64_Z524259C1(x) {\r\n    return BigInteger_$ctor_Z524259C1(x);\r\n}\r\n\r\nexport function BigInteger_FromInt32_Z524259A4(x) {\r\n    return BigInteger_$ctor_Z524259A4(x);\r\n}\r\n\r\n","import { BigInteger_op_Inequality_56F059C0, BigInteger_op_Equality_56F059C0, BigInteger_op_GreaterThanOrEqual_56F059C0, BigInteger_op_GreaterThan_56F059C0, BigInteger_op_LessThanOrEqual_56F059C0, BigInteger_op_LessThan_56F059C0, BigInteger_op_ExclusiveOr_56F059C0, BigInteger_op_BitwiseOr_56F059C0, BigInteger_op_BitwiseAnd_56F059C0, BigInteger_op_LeftShift_62E082A2, BigInteger_op_RightShift_62E082A2, BigInteger_op_UnaryPlus_Z665282C2, BigInteger_op_UnaryNegation_Z665282C2, BigInteger_op_Modulus_56F059C0, BigInteger_op_Division_56F059C0, BigInteger_op_Multiply_56F059C0, BigInteger_op_Subtraction_56F059C0, BigInteger_op_Addition_56F059C0, BigInteger__get_IsOne, BigInteger__get_IsZero, BigInteger__get_Sign, BigInteger__get_ToDecimal, BigInteger__get_ToDouble, BigInteger__get_ToSingle, BigInteger__get_ToUInt64, BigInteger__get_ToInt64, BigInteger__get_ToUInt32, BigInteger__get_ToInt32, BigInteger__get_ToUInt16, BigInteger__get_ToInt16, BigInteger__get_ToByte, BigInteger__get_ToSByte, BigInteger_$ctor_Z524259A4, BigInteger_$ctor_Z524259C1, BigInteger_get_Two, BigInteger_get_One, BigInteger_get_Zero, BigInteger_Abs_Z665282C2, BigInteger_Pow_62E082A2, BigInteger_GreatestCommonDivisor_56F059C0, BigInteger_DivRem_56F059C0, BigInteger_Parse_Z721C83C5, BigInteger } from \"./BigInt/z.js\";\r\nimport { fromInteger } from \"./Long.js\";\r\nimport { comparePrimitives, min, compare as compare_1, equals as equals_1, safeHash } from \"./Util.js\";\r\nimport { toString as toString_1 } from \"./Types.js\";\r\nimport { fold, empty, ofArrayWithTail, cons, toArray, head, skipWhile } from \"./List.js\";\r\nimport { fill, reverse } from \"./Array.js\";\r\n\r\nexport function isBigInt(x) {\r\n    return x instanceof BigInteger;\r\n}\r\n\r\nexport function tryParse(str, res) {\r\n    try {\r\n        res.contents = BigInteger_Parse_Z721C83C5(str);\r\n        return true;\r\n    }\r\n    catch (matchValue) {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function divRem(x, y, remainder) {\r\n    const patternInput = BigInteger_DivRem_56F059C0(x, y);\r\n    remainder.contents = patternInput[1];\r\n    return patternInput[0];\r\n}\r\n\r\nexport function parse(arg00) {\r\n    return BigInteger_Parse_Z721C83C5(arg00);\r\n}\r\n\r\nexport function greatestCommonDivisor(arg00, arg01) {\r\n    return BigInteger_GreatestCommonDivisor_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function pow(arg00, arg01) {\r\n    return BigInteger_Pow_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function abs(arg00) {\r\n    return BigInteger_Abs_Z665282C2(arg00);\r\n}\r\n\r\nexport const zero = BigInteger_get_Zero();\r\n\r\nexport const one = BigInteger_get_One();\r\n\r\nexport const two = BigInteger_get_Two();\r\n\r\nexport function fromString(s) {\r\n    return BigInteger_Parse_Z721C83C5(s);\r\n}\r\n\r\nexport function fromZero() {\r\n    return BigInteger_get_Zero();\r\n}\r\n\r\nexport function fromOne() {\r\n    return BigInteger_get_One();\r\n}\r\n\r\nexport function fromInt64(i) {\r\n    return BigInteger_$ctor_Z524259C1(i);\r\n}\r\n\r\nexport function fromInt32(i) {\r\n    if (i > 2147483647) {\r\n        return BigInteger_$ctor_Z524259C1(fromInteger(i, false, 6));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z524259A4(i);\r\n    }\r\n}\r\n\r\nexport function toSByte(x) {\r\n    return BigInteger__get_ToSByte(x);\r\n}\r\n\r\nexport function toByte(x) {\r\n    return BigInteger__get_ToByte(x);\r\n}\r\n\r\nexport function toInt16(x) {\r\n    return BigInteger__get_ToInt16(x);\r\n}\r\n\r\nexport function toUInt16(x) {\r\n    return BigInteger__get_ToUInt16(x);\r\n}\r\n\r\nexport function toInt32(x) {\r\n    return BigInteger__get_ToInt32(x);\r\n}\r\n\r\nexport function toUInt32(x) {\r\n    return BigInteger__get_ToUInt32(x);\r\n}\r\n\r\nexport function toInt64(x) {\r\n    return BigInteger__get_ToInt64(x);\r\n}\r\n\r\nexport function toUInt64(x) {\r\n    return BigInteger__get_ToUInt64(x);\r\n}\r\n\r\nexport function toSingle(x) {\r\n    return BigInteger__get_ToSingle(x);\r\n}\r\n\r\nexport function toDouble(x) {\r\n    return BigInteger__get_ToDouble(x);\r\n}\r\n\r\nexport function toDecimal(x) {\r\n    return BigInteger__get_ToDecimal(x);\r\n}\r\n\r\nexport function sign(x) {\r\n    return BigInteger__get_Sign(x);\r\n}\r\n\r\nexport function isZero(x) {\r\n    return BigInteger__get_IsZero(x);\r\n}\r\n\r\nexport function isOne(x) {\r\n    return BigInteger__get_IsOne(x);\r\n}\r\n\r\nexport function hash(x) {\r\n    return safeHash(x);\r\n}\r\n\r\nexport function compare(x, y) {\r\n    return x.CompareTo(y);\r\n}\r\n\r\nexport function equals(x, y) {\r\n    return equals_1(x, y);\r\n}\r\n\r\nexport function toString(x) {\r\n    return toString_1(x);\r\n}\r\n\r\nexport const get_Zero = BigInteger_get_Zero();\r\n\r\nexport const get_One = BigInteger_get_One();\r\n\r\nexport function op_Addition(arg00, arg01) {\r\n    return BigInteger_op_Addition_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Subtraction(arg00, arg01) {\r\n    return BigInteger_op_Subtraction_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Multiply(arg00, arg01) {\r\n    return BigInteger_op_Multiply_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Division(arg00, arg01) {\r\n    return BigInteger_op_Division_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Modulus(arg00, arg01) {\r\n    return BigInteger_op_Modulus_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_UnaryNegation(arg00) {\r\n    return BigInteger_op_UnaryNegation_Z665282C2(arg00);\r\n}\r\n\r\nexport function op_UnaryPlus(arg00) {\r\n    return BigInteger_op_UnaryPlus_Z665282C2(arg00);\r\n}\r\n\r\nexport function op_RightShift(arg00, arg01) {\r\n    return BigInteger_op_RightShift_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function op_LeftShift(arg00, arg01) {\r\n    return BigInteger_op_LeftShift_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function op_BitwiseAnd(arg00, arg01) {\r\n    return BigInteger_op_BitwiseAnd_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_BitwiseOr(arg00, arg01) {\r\n    return BigInteger_op_BitwiseOr_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_ExclusiveOr(arg00, arg01) {\r\n    return BigInteger_op_ExclusiveOr_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_LessThan(arg00, arg01) {\r\n    return BigInteger_op_LessThan_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_LessThanOrEqual(arg00, arg01) {\r\n    return BigInteger_op_LessThanOrEqual_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_GreaterThan(arg00, arg01) {\r\n    return BigInteger_op_GreaterThan_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_GreaterThanOrEqual(arg00, arg01) {\r\n    return BigInteger_op_GreaterThanOrEqual_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Equality(arg00, arg01) {\r\n    return BigInteger_op_Equality_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Inequality(arg00, arg01) {\r\n    return BigInteger_op_Inequality_56F059C0(arg00, arg01);\r\n}\r\n\r\nfunction flipTwosComplement(currByte, lowBitFound) {\r\n    const matchValue = [currByte, lowBitFound];\r\n    if (matchValue[1]) {\r\n        return [(currByte ^ 255) & 255, true];\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        return [0, false];\r\n    }\r\n    else {\r\n        return [(currByte ^ (254 << (new Int32Array([0, 1, 2, 3, 4, 5, 6, 7])).find((i) => ((currByte & (1 << i)) > 0)))) & 255, true];\r\n    }\r\n}\r\n\r\nexport function toByteArray(value) {\r\n    if (equals_1(value, zero)) {\r\n        return new Uint8Array([0]);\r\n    }\r\n    else {\r\n        const isPositive = compare_1(value, zero) > 0;\r\n        const value_1 = isPositive ? value : BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value);\r\n        const mask32 = fromInt64(fromInteger(4294967295, false, 6));\r\n        const loop = (accumBytes_mut, consumeValue_mut, lowBitFound_mut) => {\r\n            let value_6, value_8, value_9, value_10;\r\n            loop:\r\n            while (true) {\r\n                const accumBytes = accumBytes_mut, consumeValue = consumeValue_mut, lowBitFound = lowBitFound_mut;\r\n                if (compare_1(consumeValue, zero) <= 0) {\r\n                    const accumBytes_1 = isPositive ? skipWhile((b) => (b === 0), accumBytes) : skipWhile((b_1) => (b_1 === 255), accumBytes);\r\n                    const isHighBitOne = (head(accumBytes_1) & 128) !== 0;\r\n                    return reverse(toArray((isPositive && isHighBitOne) ? cons(0, accumBytes_1) : (((!isPositive) && (!isHighBitOne)) ? cons(255, accumBytes_1) : accumBytes_1)));\r\n                }\r\n                else {\r\n                    const currValue = toUInt32(BigInteger_op_BitwiseAnd_56F059C0(consumeValue, mask32));\r\n                    if (isPositive) {\r\n                        const b0 = currValue & 0xFF;\r\n                        let b1;\r\n                        const value_4 = currValue >>> 8;\r\n                        b1 = (value_4 & 0xFF);\r\n                        let b2;\r\n                        const value_5 = currValue >>> 16;\r\n                        b2 = (value_5 & 0xFF);\r\n                        accumBytes_mut = ofArrayWithTail([(value_6 = (currValue >>> 24), value_6 & 0xFF), b2, b1, b0], accumBytes);\r\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\r\n                        lowBitFound_mut = false;\r\n                        continue loop;\r\n                    }\r\n                    else {\r\n                        const patternInput = flipTwosComplement(currValue & 0xFF, lowBitFound);\r\n                        const patternInput_1 = flipTwosComplement((value_8 = (currValue >>> 8), value_8 & 0xFF), patternInput[1]);\r\n                        const patternInput_2 = flipTwosComplement((value_9 = (currValue >>> 16), value_9 & 0xFF), patternInput_1[1]);\r\n                        const patternInput_3 = flipTwosComplement((value_10 = (currValue >>> 24), value_10 & 0xFF), patternInput_2[1]);\r\n                        accumBytes_mut = ofArrayWithTail([patternInput_3[0], patternInput_2[0], patternInput_1[0], patternInput[0]], accumBytes);\r\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\r\n                        lowBitFound_mut = patternInput_3[1];\r\n                        continue loop;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(empty(), value_1, false);\r\n    }\r\n}\r\n\r\nexport function fromByteArray(bytes) {\r\n    if (bytes == null) {\r\n        throw (new Error(\"bytes\"));\r\n    }\r\n    if (bytes.length === 0) {\r\n        return zero;\r\n    }\r\n    else {\r\n        const isPositive = (bytes[bytes.length - 1] & 128) === 0;\r\n        const buffer = fill(new Uint8Array(4), 0, 4, 0);\r\n        const loop = (accumUInt32_mut, currIndex_mut, bytesRemaining_mut, lowBitFound_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const accumUInt32 = accumUInt32_mut, currIndex = currIndex_mut, bytesRemaining = bytesRemaining_mut, lowBitFound = lowBitFound_mut;\r\n                if (bytesRemaining === 0) {\r\n                    const value_2 = fold((acc, value) => BigInteger_op_Addition_56F059C0(BigInteger_op_LeftShift_62E082A2(acc, 32), fromInt64(fromInteger(value, false, 6))), zero, accumUInt32);\r\n                    if (isPositive) {\r\n                        return value_2;\r\n                    }\r\n                    else {\r\n                        return BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value_2);\r\n                    }\r\n                }\r\n                else {\r\n                    const bytesToProcess = min((x, y) => comparePrimitives(x, y), bytesRemaining, 4) | 0;\r\n                    for (let i_1 = 0; i_1 <= (bytesToProcess - 1); i_1++) {\r\n                        buffer[i_1] = bytes[currIndex + i_1];\r\n                    }\r\n                    if (isPositive) {\r\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 0);\r\n                        accumUInt32_mut = cons((((((buffer[0] | ((buffer[1] << 8) >>> 0)) >>> 0) | ((buffer[2] << 16) >>> 0)) >>> 0) | ((buffer[3] << 24) >>> 0)) >>> 0, accumUInt32);\r\n                        currIndex_mut = (currIndex + bytesToProcess);\r\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\r\n                        lowBitFound_mut = false;\r\n                        continue loop;\r\n                    }\r\n                    else {\r\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 255);\r\n                        const patternInput = flipTwosComplement(buffer[0], lowBitFound);\r\n                        const patternInput_1 = flipTwosComplement(buffer[1], patternInput[1]);\r\n                        const patternInput_2 = flipTwosComplement(buffer[2], patternInput_1[1]);\r\n                        const patternInput_3 = flipTwosComplement(buffer[3], patternInput_2[1]);\r\n                        accumUInt32_mut = cons((((((patternInput[0] | ((patternInput_1[0] << 8) >>> 0)) >>> 0) | ((patternInput_2[0] << 16) >>> 0)) >>> 0) | ((patternInput_3[0] << 24) >>> 0)) >>> 0, accumUInt32);\r\n                        currIndex_mut = (currIndex + bytesToProcess);\r\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\r\n                        lowBitFound_mut = patternInput_3[1];\r\n                        continue loop;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(empty(), 0, bytes.length, false);\r\n    }\r\n}\r\n\r\n","import { Parsimmon_parse } from \"../Fable.Parsimmon.4.1.0/Parsimmon.fs.js\";\nimport { jsonParser } from \"./Parser.fs.js\";\nimport { join, toText, printf, toFail } from \"../fable-library.3.6.3/String.js\";\nimport { head, tail, isEmpty, empty, singleton, concat, ofArray, map as map_1 } from \"../fable-library.3.6.3/List.js\";\nimport { tryFind, ofList, toList } from \"../fable-library.3.6.3/Map.js\";\nimport { partialApply, isIterable, getEnumerator } from \"../fable-library.3.6.3/Util.js\";\nimport { toString } from \"../fable-library.3.6.3/Decimal.js\";\nimport { toDecimal } from \"../fable-library.3.6.3/BigInt.js\";\nimport { toString as toString_1 } from \"../fable-library.3.6.3/Date.js\";\nimport { value as value_5, some } from \"../fable-library.3.6.3/Option.js\";\nimport { $007CNativeObject$007C_$007C, $007CNativeArray$007C_$007C, $007CNull$007C_$007C, $007CNativeBool$007C_$007C, $007CNativeNumber$007C_$007C, $007CNativeString$007C_$007C } from \"./TypeCheck.fs.js\";\nimport { Json } from \"./Json.fs.js\";\nimport { map as map_2 } from \"../fable-library.3.6.3/Array.js\";\nimport { map as map_3, delay, toList as toList_1 } from \"../fable-library.3.6.3/Seq.js\";\n\nexport function InteropUtil_isDateOffset(x) {\n    if (x instanceof Date) {\n        return \"offset\" in x;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function InteropUtil_isObjectLiteral(x) {\n    return (typeof x) === \"object\";\n}\n\nexport function InteropUtil_isBigInt(x) {\n    if (((((!(x == null)) && InteropUtil_isObjectLiteral(x)) && (\"signInt\" in x)) && (\"v\" in x)) && (\"digits\" in (x[\"v\"]))) {\n        return \"bound\" in (x[\"v\"]);\n    }\n    else {\n        return false;\n    }\n}\n\nexport function SimpleJson_tryParse(input) {\n    return Parsimmon_parse(input, jsonParser);\n}\n\nexport function SimpleJson_parse(input) {\n    const matchValue = SimpleJson_tryParse(input);\n    if (matchValue == null) {\n        return toFail(printf(\"Could not parse the JSON input: %s\"))(input);\n    }\n    else {\n        return matchValue;\n    }\n}\n\nexport function SimpleJson_toString(_arg1) {\n    if (_arg1.tag === 2) {\n        if (_arg1.fields[0]) {\n            return \"true\";\n        }\n        else {\n            return \"false\";\n        }\n    }\n    else if (_arg1.tag === 0) {\n        return _arg1.fields[0].toString();\n    }\n    else if (_arg1.tag === 1) {\n        return toText(printf(\"\\\"%s\\\"\"))(_arg1.fields[0]);\n    }\n    else if (_arg1.tag === 4) {\n        const arg10_1 = join(\",\", map_1((_arg1_1) => SimpleJson_toString(_arg1_1), _arg1.fields[0]));\n        return toText(printf(\"[%s]\"))(arg10_1);\n    }\n    else if (_arg1.tag === 5) {\n        const arg10_3 = join(\",\", map_1((tupledArg) => {\n            const arg20 = SimpleJson_toString(tupledArg[1]);\n            return toText(printf(\"\\\"%s\\\":%s\"))(tupledArg[0])(arg20);\n        }, toList(_arg1.fields[0])));\n        return toText(printf(\"{%s}\"))(arg10_3);\n    }\n    else {\n        return \"null\";\n    }\n}\n\nexport function SimpleJson_toPlainObject(input) {\n    switch (input.tag) {\n        case 2: {\n            return input.fields[0];\n        }\n        case 0: {\n            return input.fields[0];\n        }\n        case 1: {\n            return input.fields[0];\n        }\n        case 4: {\n            const array = [];\n            const enumerator = getEnumerator(input.fields[0]);\n            try {\n                while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                    const value_3 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                    void (array.push(SimpleJson_toPlainObject(value_3)));\n                }\n            }\n            finally {\n                enumerator.Dispose();\n            }\n            return array;\n        }\n        case 5: {\n            const jsObject = ({});\n            const enumerator_1 = getEnumerator(toList(input.fields[0]));\n            try {\n                while (enumerator_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                    const forLoopVar = enumerator_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                    jsObject[forLoopVar[0]] = SimpleJson_toPlainObject(forLoopVar[1]);\n                }\n            }\n            finally {\n                enumerator_1.Dispose();\n            }\n            return jsObject;\n        }\n        default: {\n            return null;\n        }\n    }\n}\n\nexport function SimpleJson_stringify(value) {\n    if (value == null) {\n        return JSON.stringify(null);\n    }\n    else {\n        return JSON.stringify(value, (key, jsonValue) => {\n            let copyOfStruct;\n            return InteropUtil_isBigInt(jsonValue) ? toString(toDecimal(jsonValue)) : ((jsonValue instanceof Date) ? toString_1(jsonValue, \"o\") : (((typeof jsonValue) === \"string\") ? jsonValue : (isIterable(jsonValue) ? (Array.isArray(jsonValue) ? jsonValue : (Array.from(jsonValue))) : (InteropUtil_isBigInt(jsonValue) ? toString(toDecimal(jsonValue)) : (InteropUtil_isDateOffset(jsonValue) ? ((copyOfStruct = jsonValue, toString_1(copyOfStruct, \"O\"))) : jsonValue)))));\n        }, some(0));\n    }\n}\n\nexport function SimpleJson_parseNative$0027(x) {\n    const activePatternResult2794 = $007CNativeString$007C_$007C(x);\n    if (activePatternResult2794 != null) {\n        const str = activePatternResult2794;\n        return new Json(1, str);\n    }\n    else {\n        const activePatternResult2793 = $007CNativeNumber$007C_$007C(x);\n        if (activePatternResult2793 != null) {\n            const number = activePatternResult2793;\n            return new Json(0, number);\n        }\n        else {\n            const activePatternResult2792 = $007CNativeBool$007C_$007C(x);\n            if (activePatternResult2792 != null) {\n                const value = activePatternResult2792;\n                return new Json(2, value);\n            }\n            else if ($007CNull$007C_$007C(x) != null) {\n                return new Json(3);\n            }\n            else {\n                const activePatternResult2790 = $007CNativeArray$007C_$007C(x);\n                if (activePatternResult2790 != null) {\n                    const arr = activePatternResult2790;\n                    return new Json(4, ofArray(map_2((x_1) => SimpleJson_parseNative$0027(x_1), arr)));\n                }\n                else {\n                    const activePatternResult2789 = $007CNativeObject$007C_$007C(x);\n                    if (activePatternResult2789 != null) {\n                        const object = value_5(activePatternResult2789);\n                        return new Json(5, ofList(toList_1(delay(() => map_3((key) => [key, SimpleJson_parseNative$0027(object[key])], Object.keys(object))))));\n                    }\n                    else {\n                        return new Json(3);\n                    }\n                }\n            }\n        }\n    }\n}\n\nexport function SimpleJson_parseNative(input) {\n    return SimpleJson_parseNative$0027(JSON.parse(input));\n}\n\nexport function SimpleJson_tryParseNative(input) {\n    try {\n        return SimpleJson_parseNative(input);\n    }\n    catch (ex) {\n        return void 0;\n    }\n}\n\nexport function SimpleJson_fromObjectLiteral(x) {\n    try {\n        return SimpleJson_parseNative$0027(x);\n    }\n    catch (matchValue) {\n        return void 0;\n    }\n}\n\nexport function SimpleJson_mapKeys(f, _arg1) {\n    switch (_arg1.tag) {\n        case 5: {\n            return new Json(5, ofList(map_1((tupledArg) => [f(tupledArg[0]), SimpleJson_mapKeys(f, tupledArg[1])], toList(_arg1.fields[0]))));\n        }\n        case 4: {\n            return new Json(4, map_1((_arg1_1) => SimpleJson_mapKeys(f, _arg1_1), _arg1.fields[0]));\n        }\n        default: {\n            return _arg1;\n        }\n    }\n}\n\nexport function SimpleJson_mapbyKey(f, _arg1) {\n    switch (_arg1.tag) {\n        case 5: {\n            return new Json(5, ofList(map_1((tupledArg) => {\n                const key = tupledArg[0];\n                return [key, f(key, tupledArg[1])];\n            }, toList(_arg1.fields[0]))));\n        }\n        case 4: {\n            return new Json(4, map_1((_arg1_1) => SimpleJson_mapbyKey(f, _arg1_1), _arg1.fields[0]));\n        }\n        default: {\n            return _arg1;\n        }\n    }\n}\n\nexport function SimpleJson_mapKeysByPath(f, json) {\n    const mapKey = (xs, _arg1) => {\n        switch (_arg1.tag) {\n            case 5: {\n                return new Json(5, ofList(map_1((tupledArg) => {\n                    const key = tupledArg[0];\n                    const value = tupledArg[1];\n                    const keyPath = concat([xs, singleton(key)]);\n                    const matchValue = f(keyPath);\n                    if (matchValue == null) {\n                        return [key, mapKey(keyPath, value)];\n                    }\n                    else {\n                        return [matchValue, mapKey(keyPath, value)];\n                    }\n                }, toList(_arg1.fields[0]))));\n            }\n            case 4: {\n                return new Json(4, map_1(partialApply(1, mapKey, [xs]), _arg1.fields[0]));\n            }\n            default: {\n                return _arg1;\n            }\n        }\n    };\n    return mapKey(empty(), json);\n}\n\nexport function SimpleJson_readPath(keys_mut, input_mut) {\n    SimpleJson_readPath:\n    while (true) {\n        const keys = keys_mut, input = input_mut;\n        const matchValue = [keys, input];\n        let pattern_matching_result, dict, key, dict_1, firstKey, rest;\n        if (!isEmpty(matchValue[0])) {\n            if (isEmpty(tail(matchValue[0]))) {\n                if (matchValue[1].tag === 5) {\n                    pattern_matching_result = 1;\n                    dict = matchValue[1].fields[0];\n                    key = head(matchValue[0]);\n                }\n                else {\n                    pattern_matching_result = 3;\n                }\n            }\n            else if (matchValue[1].tag === 5) {\n                pattern_matching_result = 2;\n                dict_1 = matchValue[1].fields[0];\n                firstKey = head(matchValue[0]);\n                rest = tail(matchValue[0]);\n            }\n            else {\n                pattern_matching_result = 3;\n            }\n        }\n        else {\n            pattern_matching_result = 0;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return void 0;\n            }\n            case 1: {\n                return tryFind(key, dict);\n            }\n            case 2: {\n                const matchValue_1 = tryFind(firstKey, dict_1);\n                let pattern_matching_result_1, nextDict;\n                if (matchValue_1 != null) {\n                    if (matchValue_1.tag === 5) {\n                        pattern_matching_result_1 = 0;\n                        nextDict = matchValue_1.fields[0];\n                    }\n                    else {\n                        pattern_matching_result_1 = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result_1 = 1;\n                }\n                switch (pattern_matching_result_1) {\n                    case 0: {\n                        keys_mut = rest;\n                        input_mut = (new Json(5, nextDict));\n                        continue SimpleJson_readPath;\n                    }\n                    case 1: {\n                        return void 0;\n                    }\n                }\n            }\n            case 3: {\n                return void 0;\n            }\n        }\n        break;\n    }\n}\n\n","import { some } from \"../fable-library.3.6.3/Option.js\";\n\nexport function $007CNativeString$007C_$007C(x) {\n    if (typeof (x) === 'string') {\n        return x;\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CNativeBool$007C_$007C(x) {\n    if (typeof (x) === 'boolean') {\n        return x;\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CNativeNumber$007C_$007C(x) {\n    if (typeof (x) === 'number') {\n        return x;\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CNativeObject$007C_$007C(x) {\n    if (typeof (x) === 'object') {\n        return some(x);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CNull$007C_$007C(x) {\n    if (x == null) {\n        return some(x);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function $007CNativeArray$007C_$007C(x) {\n    if (Array.isArray(x)) {\n        return x;\n    }\n    else {\n        return void 0;\n    }\n}\n\n","/**\n * DateTimeOffset functions.\n *\n * Note: DateOffset instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * However, this means that in order to construct an UTC date\n * from a DateOffset with offset of +5 hours, you first need\n * to subtract those 5 hours, than add the \"local\" offset.\n * As said, all kinds of messed up.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { create as createDate, dateOffsetToString, daysInMonth, parseRaw } from \"./Date.js\";\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, padWithZeros } from \"./Util.js\";\nexport default function DateTimeOffset(value, offset) {\n    checkOffsetInRange(offset);\n    const d = new Date(value);\n    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;\n    return d;\n}\nfunction checkOffsetInRange(offset) {\n    if (offset != null && offset !== 0) {\n        if (offset % 60000 !== 0) {\n            throw new Error(\"Offset must be specified in whole minutes.\");\n        }\n        if (Math.abs(offset / 3600000) > 14) {\n            throw new Error(\"Offset must be within plus or minus 14 hours.\");\n        }\n    }\n}\nexport function fromDate(date, offset) {\n    let offset2 = 0;\n    switch (date.kind) {\n        case 1 /* UTC */:\n            if (offset != null && offset !== 0) {\n                throw new Error(\"The UTC Offset for Utc DateTime instances must be 0.\");\n            }\n            offset2 = 0;\n            break;\n        case 2 /* Local */:\n            offset2 = date.getTimezoneOffset() * -60000;\n            if (offset != null && offset !== offset2) {\n                throw new Error(\"The UTC Offset of the local dateTime parameter does not match the offset argument.\");\n            }\n            break;\n        case 0 /* Unspecified */:\n        default:\n            if (offset == null) {\n                offset2 = date.getTimezoneOffset() * -60000;\n            }\n            else {\n                offset2 = offset;\n            }\n            break;\n    }\n    return DateTimeOffset(date.getTime(), offset2);\n}\nexport function fromTicks(ticks, offset) {\n    ticks = fromValue(ticks);\n    const epoc = ticksToUnixEpochMilliseconds(ticks) - offset;\n    return DateTimeOffset(epoc, offset);\n}\nexport function getUtcTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), 0);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTimeOffset(-62135596800000, 0);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTimeOffset(253402300799999, 0);\n}\nexport function parse(str) {\n    const [date, offsetMatch] = parseRaw(str);\n    const offset = offsetMatch == null\n        ? date.getTimezoneOffset() * -60000\n        : (offsetMatch === \"Z\" ? 0 : offsetMatch * 60000);\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h, m, s, ms, offset) {\n    if (offset == null) {\n        offset = ms;\n        ms = 0;\n    }\n    checkOffsetInRange(offset);\n    let date;\n    if (offset === 0) {\n        date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));\n        if (year <= 99) {\n            date.setFullYear(year, month - 1, day);\n        }\n    }\n    else {\n        const str = padWithZeros(year, 4) + \"-\" +\n            padWithZeros(month, 2) + \"-\" +\n            padWithZeros(day, 2) + \"T\" +\n            padWithZeros(h, 2) + \":\" +\n            padWithZeros(m, 2) + \":\" +\n            padWithZeros(s, 2) + \".\" +\n            padWithZeros(ms, 3) +\n            dateOffsetToString(offset);\n        date = new Date(str);\n    }\n    const dateValue = date.getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date\");\n    }\n    return DateTimeOffset(dateValue, offset);\n}\nexport function now() {\n    const date = new Date();\n    const offset = date.getTimezoneOffset() * -60000;\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function utcNow() {\n    const date = now();\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toUniversalTime(date) {\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toLocalTime(date) {\n    return DateTimeOffset(date.getTime(), date.getTimezoneOffset() * -60000);\n}\nexport function timeOfDay(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return d2.getUTCHours() * 3600000\n        + d2.getUTCMinutes() * 60000\n        + d2.getUTCSeconds() * 1000\n        + d2.getUTCMilliseconds();\n}\nexport function date(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);\n}\nexport function day(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDate();\n}\nexport function hour(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCHours();\n}\nexport function millisecond(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMilliseconds();\n}\nexport function minute(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMinutes();\n}\nexport function month(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMonth() + 1;\n}\nexport function second(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCSeconds();\n}\nexport function year(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDay();\n}\nexport function dayOfYear(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    const _year = d2.getUTCFullYear();\n    const _month = d2.getUTCMonth() + 1;\n    let _day = d2.getUTCDate();\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    var _a;\n    return DateTimeOffset(d.getTime() + ts, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addDays(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 86400000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addHours(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 3600000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMinutes(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 60000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addSeconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 1000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMilliseconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addYears(d, v) {\n    var _a;\n    const newMonth = d.getUTCMonth() + 1;\n    const newYear = d.getUTCFullYear() + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d.getUTCDate());\n    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMonths(d, v) {\n    var _a, _b;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    let newMonth = d2.getUTCMonth() + 1 + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = d2.getUTCFullYear() + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d2.getUTCDate());\n    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), ((_b = d.offset) !== null && _b !== void 0 ? _b : 0));\n}\nexport function subtract(d, that) {\n    var _a;\n    return typeof that === \"number\"\n        ? DateTimeOffset(d.getTime() - that, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0))\n        : d.getTime() - that.getTime();\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport function equalsExact(d1, d2) {\n    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;\n}\nexport function compare(d1, d2) {\n    return compareDates(d1, d2);\n}\nexport const compareTo = compare;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function toOffset(d, offset) {\n    return DateTimeOffset(d.getTime(), offset);\n}\n","import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth } from \"./Date.js\";\nimport { padWithZeros } from \"./Util.js\";\nimport { toInt, fromNumber, op_Division as Long_op_Division, op_Multiply as Long_op_Multiply, ticksToUnixEpochMilliseconds } from \"./Long.js\";\nexport function fromUnixMilliseconds(value) {\n    return DateTime(value, 1 /* UTC */);\n}\nexport function create(year, month, day) {\n    const d = fromUnixMilliseconds(Date.UTC(year, month - 1, day));\n    if (year <= 99) {\n        d.setUTCFullYear(year);\n    }\n    return d;\n}\nexport function maxValue() {\n    // This is \"9999-12-31T00:00:00.000Z\"\n    return fromUnixMilliseconds(253402214400000);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\"\n    return fromUnixMilliseconds(-62135596800000);\n}\nexport function dayNumber(d) {\n    return toInt(Long_op_Division(getTicks(d), 864000000000));\n}\nexport function fromDayNumber(dayNumber) {\n    const ticks = Long_op_Multiply(fromNumber(864000000000), dayNumber);\n    return fromUnixMilliseconds(ticksToUnixEpochMilliseconds(ticks));\n}\nexport function fromDateTime(d) {\n    return create(Date_year(d), Date_month(d), Date_day(d));\n}\nexport function day(d) {\n    return d.getUTCDate();\n}\nexport function month(d) {\n    return d.getUTCMonth() + 1;\n}\nexport function year(d) {\n    return d.getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.getUTCDay();\n}\nexport function dayOfYear(d) {\n    return Date_dayOfYear(d);\n}\nexport function toDateTime(d, time, kind = 0 /* Unspecified */) {\n    return DateTime(d.getTime() + time + (kind !== 1 /* UTC */ ? d.getTimezoneOffset() : 0) * 60000, kind);\n}\nexport function toString(d, format = \"d\", _provider) {\n    if ([\"d\", \"o\", \"O\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const y = padWithZeros(year(d), 4);\n    const m = padWithZeros(month(d), 2);\n    const dd = padWithZeros(day(d), 2);\n    return format === \"d\" ? `${m}/${dd}/${y}` : `${y}-${m}-${dd}`;\n}\nexport function parse(str) {\n    function fail() {\n        throw new Error(`String '${str}' was not recognized as a valid DateOnly.`);\n    }\n    // Allowed separators: . , / -\n    // TODO whitespace alone as the separator\n    //\n    // Whitespace around separators\n    //\n    // Allowed format types:\n    // yyyy/mm/dd\n    // mm/dd/yyyy\n    // mm/dd\n    // mm/yyyy\n    // yyyy/mm\n    const r = /^\\s*(\\d{1,4})(?:\\s*[.,-\\/]\\s*(\\d{1,2}))?\\s*[.,-\\/]\\s*(\\d{1,4})\\s*$/.exec(str);\n    if (r != null) {\n        let y = 0;\n        let m = 0;\n        let d = 1;\n        if (r[2] == null) {\n            if (r[1].length < 3) {\n                if (r[3].length < 3) {\n                    // 12/30 = December 30, {CurrentYear}\n                    y = new Date().getFullYear();\n                    m = +r[1];\n                    d = +r[3];\n                }\n                else {\n                    // 12/2000 = December 1, 2000\n                    m = +r[1];\n                    y = +r[3];\n                }\n            }\n            else {\n                if (r[3].length > 2)\n                    fail();\n                // 2000/12 = December 1, 2000\n                y = +r[1];\n                m = +r[3];\n            }\n        }\n        else {\n            // 2000/1/30 or 1/30/2000\n            const yearFirst = r[1].length > 2;\n            const yTmp = r[yearFirst ? 1 : 3];\n            y = +yTmp;\n            // year 0-29 is 2000-2029, 30-99 is 1930-1999\n            if (yTmp.length < 3)\n                y += y >= 30 ? 1900 : 2000;\n            m = +r[yearFirst ? 2 : 1];\n            d = +r[yearFirst ? 3 : 2];\n        }\n        if (y > 0 && m > 0 && m < 13 && d > 0 && d <= Date_daysInMonth(y, m))\n            return create(y, m, d);\n    }\n    return fail();\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n","import { op_Division as Long_op_Division, toNumber as Long_toNumber } from \"./Long.js\";\nimport { hours, minutes, seconds, milliseconds } from \"./TimeSpan.js\";\nimport { padWithZeros } from \"./Util.js\";\nconst millisecondsPerDay = 86400000;\nexport function create(h = 0, m = 0, s = 0, ms = 0) {\n    if (h < 0 || m < 0 || s < 0 || ms < 0)\n        throw new Error(\"The parameters describe an unrepresentable TimeOnly.\");\n    if (arguments.length === 1)\n        // ticks\n        return fromTicks(arguments[0]);\n    else\n        return h * 3600000 + m * 60000 + s * 1000 + ms;\n}\nexport function fromTicks(ticks) {\n    return Long_toNumber(Long_op_Division(ticks, 10000));\n}\nexport function fromTimeSpan(timeSpan) {\n    if (timeSpan < 0 || timeSpan >= millisecondsPerDay)\n        throw new Error(\"The TimeSpan describes an unrepresentable TimeOnly.\");\n    return timeSpan;\n}\nexport function fromDateTime(d) {\n    return d.kind === 1 /* UTC */\n        ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())\n        : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());\n}\nexport function maxValue() {\n    // This is \"23:59:59.999\"\n    return millisecondsPerDay - 1;\n}\nexport function add(t, ts, wrappedDays) {\n    if (wrappedDays === undefined) {\n        const t2 = (t + ts) % millisecondsPerDay;\n        return t2 < 0 ? millisecondsPerDay + t2 : t2;\n    }\n    wrappedDays.contents = ts / millisecondsPerDay;\n    let newMs = t + ts % millisecondsPerDay;\n    if (newMs < 0) {\n        wrappedDays.contents--;\n        newMs += millisecondsPerDay;\n    }\n    else {\n        if (newMs >= millisecondsPerDay) {\n            wrappedDays.contents++;\n            newMs -= millisecondsPerDay;\n        }\n    }\n    return newMs;\n}\nexport function addHours(t, h) {\n    return add(t, h * 3600000);\n}\nexport function addMinutes(t, m) {\n    return add(t, m * 60000);\n}\nexport function isBetween(t, start, end) {\n    return start <= end\n        ? (start <= t && end > t)\n        : (start <= t || end > t);\n}\nexport function toString(t, format = \"t\", _provider) {\n    if ([\"r\", \"R\", \"o\", \"O\", \"t\", \"T\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`;\n    if (format === \"t\")\n        return base;\n    const s = padWithZeros(seconds(t), 2);\n    // We're limited to millisecond precision, so the last 4 digits will always be 0\n    return `${base}${format === \"o\" || format === \"O\" ? `:${s}.${padWithZeros(milliseconds(t), 3)}0000` : `:${s}`}`;\n}\nexport function parse(str) {\n    // Allowed format types:\n    // hh:mm\n    // hh:mm:ss\n    // hh:mm:ss.fffffff\n    const r = /^\\s*([0-1]?\\d|2[0-3])\\s*:\\s*([0-5]?\\d)(\\s*:\\s*([0-5]?\\d)(\\.(\\d+))?)?\\s*$/.exec(str);\n    if (r != null && r[1] != null && r[2] != null) {\n        let ms = 0;\n        let s = 0;\n        const h = +r[1];\n        const m = +r[2];\n        if (r[4] != null) {\n            s = +r[4];\n        }\n        if (r[6] != null) {\n            // Depending on the number of decimals passed, we need to adapt the numbers\n            switch (r[6].length) {\n                case 1:\n                    ms = +r[6] * 100;\n                    break;\n                case 2:\n                    ms = +r[6] * 10;\n                    break;\n                case 3:\n                    ms = +r[6];\n                    break;\n                case 4:\n                    ms = +r[6] / 10;\n                    break;\n                case 5:\n                    ms = +r[6] / 100;\n                    break;\n                case 6:\n                    ms = +r[6] / 1000;\n                    break;\n                default:\n                    ms = +r[6].substring(0, 7) / 10000;\n                    break;\n            }\n        }\n        return create(h, m, s, Math.trunc(ms));\n    }\n    throw new Error(`String '${str}' was not recognized as a valid TimeOnly.`);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_Subtraction(left, right) {\n    return add(left, -right);\n}\n","import { trim } from \"./String.js\";\n// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220\n// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;\n// Relax GUID parsing, see #1637\nconst guidRegex = /^[\\(\\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\\)\\}]{0,2}$/;\nconst guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;\nconst guidRegexHex = /^\\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\\}\\}$/;\nconst guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;\nexport function toString(str, format, _provider) {\n    if (format && (format === null || format === void 0 ? void 0 : format.length) > 0) {\n        switch (format) {\n            case \"N\":\n                return str.replace(/-/g, '');\n            case \"D\":\n                return str;\n            case \"B\":\n                return \"{\" + str + \"}\";\n            case \"P\":\n                return \"(\" + str + \")\";\n            case \"X\":\n                return str.replace(guidHexCaptures, \"{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}\");\n            default:\n                throw new Error(\"Unrecognized Guid print format\");\n        }\n    }\n    else {\n        return str;\n    }\n}\n/** Validates UUID as specified in RFC4122 (versions 1-5). */\nexport function parse(str) {\n    function hyphenateGuid(str) {\n        return str.replace(guidRegexNoHyphen, \"$1-$2-$3-$4-$5\");\n    }\n    const wsTrimAndLowered = str.trim().toLowerCase();\n    if (guidRegex.test(wsTrimAndLowered)) {\n        return trim(wsTrimAndLowered, \"{\", \"}\", \"(\", \")\");\n    }\n    else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered);\n    }\n    else if (guidRegexHex.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered.replace(/[\\{\\},]|0x/g, ''));\n    }\n    else {\n        throw new Error(\"Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\");\n    }\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = parse(str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n// From https://gist.github.com/LeverOne/1308368\nexport function newGuid() {\n    let b = \"\";\n    for (let a = 0; a++ < 36;) {\n        b += a * 51 & 52\n            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)\n            : \"-\";\n    }\n    return b;\n}\n// Maps for number <-> hex string conversion\nlet _convertMapsInitialized = false;\nlet _byteToHex;\nlet _hexToByte;\nfunction initConvertMaps() {\n    _byteToHex = new Array(256);\n    _hexToByte = {};\n    for (let i = 0; i < 256; i++) {\n        _byteToHex[i] = (i + 0x100).toString(16).substr(1);\n        _hexToByte[_byteToHex[i]] = i;\n    }\n    _convertMapsInitialized = true;\n}\n/** Parse a UUID into it's component bytes */\n// Adapted from https://github.com/zefferus/uuid-parse\nexport function guidToArray(s) {\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    let i = 0;\n    const buf = new Uint8Array(16);\n    s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct) => {\n        switch (i) {\n            // .NET saves first three byte groups with different endianness\n            // See https://stackoverflow.com/a/16722909/3922220\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n                buf[3 - i++] = _hexToByte[oct];\n                break;\n            case 4:\n            case 5:\n                buf[9 - i++] = _hexToByte[oct];\n                break;\n            case 6:\n            case 7:\n                buf[13 - i++] = _hexToByte[oct];\n                break;\n            case 8:\n            case 9:\n            case 10:\n            case 11:\n            case 12:\n            case 13:\n            case 14:\n            case 15:\n                buf[i++] = _hexToByte[oct];\n                break;\n        }\n    }));\n    // Zero out remaining bytes if string was short\n    while (i < 16) {\n        buf[i++] = 0;\n    }\n    return buf;\n}\n/** Convert UUID byte array into a string */\nexport function arrayToGuid(buf) {\n    if (buf.length !== 16) {\n        throw new Error(\"Byte array for GUID must be exactly 16 bytes long\");\n    }\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    const guid = _byteToHex[buf[3]] + _byteToHex[buf[2]] +\n        _byteToHex[buf[1]] + _byteToHex[buf[0]] + \"-\" +\n        _byteToHex[buf[5]] + _byteToHex[buf[4]] + \"-\" +\n        _byteToHex[buf[7]] + _byteToHex[buf[6]] + \"-\" +\n        _byteToHex[buf[8]] + _byteToHex[buf[9]] + \"-\" +\n        _byteToHex[buf[10]] + _byteToHex[buf[11]] +\n        _byteToHex[buf[12]] + _byteToHex[buf[13]] +\n        _byteToHex[buf[14]] + _byteToHex[buf[15]];\n    return guid;\n}\n","import { fromBits, getHighBits, getHighBitsUnsigned, getLowBits, getLowBitsUnsigned } from \"./Long.js\";\nconst littleEndian = true;\nexport function isLittleEndian() {\n    return littleEndian;\n}\nexport function getBytesBoolean(value) {\n    const bytes = new Uint8Array(1);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint8(0, value ? 1 : 0);\n    return bytes;\n}\nexport function getBytesChar(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint16(0, value.charCodeAt(0), littleEndian);\n    return bytes;\n}\nexport function getBytesInt16(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt16(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesInt32(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesInt64(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt32(littleEndian ? 0 : 4, getLowBits(value), littleEndian);\n    view.setInt32(littleEndian ? 4 : 0, getHighBits(value), littleEndian);\n    return bytes;\n}\nexport function getBytesUInt16(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint16(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesUInt32(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesUInt64(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint32(littleEndian ? 0 : 4, getLowBitsUnsigned(value), littleEndian);\n    view.setUint32(littleEndian ? 4 : 0, getHighBitsUnsigned(value), littleEndian);\n    return bytes;\n}\nexport function getBytesSingle(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setFloat32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesDouble(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setFloat64(0, value, littleEndian);\n    return bytes;\n}\nexport function int64BitsToDouble(value) {\n    const buffer = new ArrayBuffer(8);\n    const view = new DataView(buffer);\n    view.setInt32(littleEndian ? 0 : 4, getLowBits(value), littleEndian);\n    view.setInt32(littleEndian ? 4 : 0, getHighBits(value), littleEndian);\n    return view.getFloat64(0, littleEndian);\n}\nexport function doubleToInt64Bits(value) {\n    const buffer = new ArrayBuffer(8);\n    const view = new DataView(buffer);\n    view.setFloat64(0, value, littleEndian);\n    const lowBits = view.getInt32(littleEndian ? 0 : 4, littleEndian);\n    const highBits = view.getInt32(littleEndian ? 4 : 0, littleEndian);\n    return fromBits(lowBits, highBits, false);\n}\nexport function toBoolean(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint8(offset) === 1 ? true : false;\n}\nexport function toChar(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const code = view.getUint16(offset, littleEndian);\n    return String.fromCharCode(code);\n}\nexport function toInt16(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getInt16(offset, littleEndian);\n}\nexport function toInt32(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getInt32(offset, littleEndian);\n}\nexport function toInt64(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const lowBits = view.getInt32(offset + (littleEndian ? 0 : 4), littleEndian);\n    const highBits = view.getInt32(offset + (littleEndian ? 4 : 0), littleEndian);\n    return fromBits(lowBits, highBits, false);\n}\nexport function toUInt16(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint16(offset, littleEndian);\n}\nexport function toUInt32(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint32(offset, littleEndian);\n}\nexport function toUInt64(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const lowBits = view.getUint32(offset + (littleEndian ? 0 : 4), littleEndian);\n    const highBits = view.getUint32(offset + (littleEndian ? 4 : 0), littleEndian);\n    return fromBits(lowBits, highBits, true);\n}\nexport function toSingle(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getFloat32(offset, littleEndian);\n}\nexport function toDouble(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getFloat64(offset, littleEndian);\n}\nexport function toString(bytes, offset, count) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);\n    if (offset != null && count != null) {\n        buffer = buffer.subarray(offset, offset + count);\n    }\n    else if (offset != null) {\n        buffer = buffer.subarray(offset);\n    }\n    return Array.from(buffer).map((b) => (\"0\" + b.toString(16)).slice(-2)).join(\"-\");\n}\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { toString, Record } from \"./Types.js\";\r\nimport { FSharpList, fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1 } from \"./List.js\";\r\nimport { fold as fold_1, fill } from \"./Array.js\";\r\nimport { structuralHash, toIterator, getEnumerator, isArrayLike } from \"./Util.js\";\r\nimport { join } from \"./String.js\";\r\nimport { exists as exists_1, cache, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from \"./Seq.js\";\r\nimport { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from \"./MutableSet.js\";\r\n\r\nexport class SetTreeLeaf$1 {\r\n    constructor(k) {\r\n        this.k = k;\r\n    }\r\n}\r\n\r\nexport function SetTreeLeaf$1$reflection(gen0) {\r\n    return class_type(\"Set.SetTreeLeaf`1\", [gen0], SetTreeLeaf$1);\r\n}\r\n\r\nexport function SetTreeLeaf$1_$ctor_2B595(k) {\r\n    return new SetTreeLeaf$1(k);\r\n}\r\n\r\nexport function SetTreeLeaf$1__get_Key(_) {\r\n    return _.k;\r\n}\r\n\r\nexport class SetTreeNode$1 extends SetTreeLeaf$1 {\r\n    constructor(v, left, right, h) {\r\n        super(v);\r\n        this.left = left;\r\n        this.right = right;\r\n        this.h = (h | 0);\r\n    }\r\n}\r\n\r\nexport function SetTreeNode$1$reflection(gen0) {\r\n    return class_type(\"Set.SetTreeNode`1\", [gen0], SetTreeNode$1, SetTreeLeaf$1$reflection(gen0));\r\n}\r\n\r\nexport function SetTreeNode$1_$ctor_Z6E7BE5F7(v, left, right, h) {\r\n    return new SetTreeNode$1(v, left, right, h);\r\n}\r\n\r\nexport function SetTreeNode$1__get_Left(_) {\r\n    return _.left;\r\n}\r\n\r\nexport function SetTreeNode$1__get_Right(_) {\r\n    return _.right;\r\n}\r\n\r\nexport function SetTreeNode$1__get_Height(_) {\r\n    return _.h;\r\n}\r\n\r\nexport function SetTreeModule_empty() {\r\n    return void 0;\r\n}\r\n\r\nexport function SetTreeModule_countAux(t_mut, acc_mut) {\r\n    SetTreeModule_countAux:\r\n    while (true) {\r\n        const t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_countAux(SetTreeNode$1__get_Right(t2), acc + 1);\r\n                continue SetTreeModule_countAux;\r\n            }\r\n            else {\r\n                return (acc + 1) | 0;\r\n            }\r\n        }\r\n        else {\r\n            return acc | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_count(s) {\r\n    return SetTreeModule_countAux(s, 0);\r\n}\r\n\r\nexport function SetTreeModule_mk(l, k, r) {\r\n    let hl;\r\n    const t = l;\r\n    if (t != null) {\r\n        const t2 = t;\r\n        hl = ((t2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2) : 1);\r\n    }\r\n    else {\r\n        hl = 0;\r\n    }\r\n    let hr;\r\n    const t_1 = r;\r\n    if (t_1 != null) {\r\n        const t2_1 = t_1;\r\n        hr = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\r\n    }\r\n    else {\r\n        hr = 0;\r\n    }\r\n    const m = ((hl < hr) ? hr : hl) | 0;\r\n    if (m === 0) {\r\n        return SetTreeLeaf$1_$ctor_2B595(k);\r\n    }\r\n    else {\r\n        return SetTreeNode$1_$ctor_Z6E7BE5F7(k, l, r, m + 1);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_rebalance(t1, v, t2) {\r\n    let t_2, t2_3, t_3, t2_4;\r\n    let t1h;\r\n    const t = t1;\r\n    if (t != null) {\r\n        const t2_1 = t;\r\n        t1h = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\r\n    }\r\n    else {\r\n        t1h = 0;\r\n    }\r\n    let t2h;\r\n    const t_1 = t2;\r\n    if (t_1 != null) {\r\n        const t2_2 = t_1;\r\n        t2h = ((t2_2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_2) : 1);\r\n    }\r\n    else {\r\n        t2h = 0;\r\n    }\r\n    if (t2h > (t1h + 2)) {\r\n        const matchValue = value_1(t2);\r\n        if (matchValue instanceof SetTreeNode$1) {\r\n            if (((t_2 = SetTreeNode$1__get_Left(matchValue), (t_2 != null) ? ((t2_3 = t_2, (t2_3 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_3) : 1)) : 0)) > (t1h + 1)) {\r\n                const matchValue_1 = value_1(SetTreeNode$1__get_Left(matchValue));\r\n                if (matchValue_1 instanceof SetTreeNode$1) {\r\n                    return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue_1)), SetTreeLeaf$1__get_Key(matchValue_1), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_1), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue)));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Set.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue)), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Set.rebalance\"));\r\n        }\r\n    }\r\n    else if (t1h > (t2h + 2)) {\r\n        const matchValue_2 = value_1(t1);\r\n        if (matchValue_2 instanceof SetTreeNode$1) {\r\n            if (((t_3 = SetTreeNode$1__get_Right(matchValue_2), (t_3 != null) ? ((t2_4 = t_3, (t2_4 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_4) : 1)) : 0)) > (t2h + 1)) {\r\n                const matchValue_3 = value_1(SetTreeNode$1__get_Right(matchValue_2));\r\n                if (matchValue_3 instanceof SetTreeNode$1) {\r\n                    return SetTreeModule_mk(SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeNode$1__get_Left(matchValue_3)), SetTreeLeaf$1__get_Key(matchValue_3), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_3), v, t2));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Set.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_2), v, t2));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Set.rebalance\"));\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_mk(t1, v, t2);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_add(comparer, k, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (c < 0) {\r\n                return SetTreeModule_rebalance(SetTreeModule_add(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\r\n            }\r\n            else if (c === 0) {\r\n                return t;\r\n            }\r\n            else {\r\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_add(comparer, k, SetTreeNode$1__get_Right(t2)));\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (c_1 < 0) {\r\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, SetTreeModule_empty(), t, 2);\r\n            }\r\n            else if (c_1 === 0) {\r\n                return t;\r\n            }\r\n            else {\r\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, t, SetTreeModule_empty(), 2);\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeLeaf$1_$ctor_2B595(k);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_balance(comparer, t1, k, t2) {\r\n    if (t1 != null) {\r\n        const t1$0027 = t1;\r\n        if (t2 != null) {\r\n            const t2$0027 = t2;\r\n            if (t1$0027 instanceof SetTreeNode$1) {\r\n                if (t2$0027 instanceof SetTreeNode$1) {\r\n                    if ((SetTreeNode$1__get_Height(t1$0027) + 2) < SetTreeNode$1__get_Height(t2$0027)) {\r\n                        return SetTreeModule_rebalance(SetTreeModule_balance(comparer, t1, k, SetTreeNode$1__get_Left(t2$0027)), SetTreeLeaf$1__get_Key(t2$0027), SetTreeNode$1__get_Right(t2$0027));\r\n                    }\r\n                    else if ((SetTreeNode$1__get_Height(t2$0027) + 2) < SetTreeNode$1__get_Height(t1$0027)) {\r\n                        return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t1$0027), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_balance(comparer, SetTreeNode$1__get_Right(t1$0027), k, t2));\r\n                    }\r\n                    else {\r\n                        return SetTreeModule_mk(t1, k, t2);\r\n                    }\r\n                }\r\n                else {\r\n                    return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2));\r\n            }\r\n        }\r\n        else {\r\n            return SetTreeModule_add(comparer, k, t1);\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_add(comparer, k, t2);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_split(comparer, pivot, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            const c = comparer.Compare(pivot, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (c < 0) {\r\n                const patternInput = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Left(t2));\r\n                return [patternInput[0], patternInput[1], SetTreeModule_balance(comparer, patternInput[2], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\r\n            }\r\n            else if (c === 0) {\r\n                return [SetTreeNode$1__get_Left(t2), true, SetTreeNode$1__get_Right(t2)];\r\n            }\r\n            else {\r\n                const patternInput_1 = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Right(t2));\r\n                return [SetTreeModule_balance(comparer, SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), patternInput_1[0]), patternInput_1[1], patternInput_1[2]];\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(t2), pivot) | 0;\r\n            if (c_1 < 0) {\r\n                return [t, false, SetTreeModule_empty()];\r\n            }\r\n            else if (c_1 === 0) {\r\n                return [SetTreeModule_empty(), true, SetTreeModule_empty()];\r\n            }\r\n            else {\r\n                return [SetTreeModule_empty(), false, t];\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        return [SetTreeModule_empty(), false, SetTreeModule_empty()];\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_spliceOutSuccessor(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (SetTreeNode$1__get_Left(t2) == null) {\r\n                return [SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2)];\r\n            }\r\n            else {\r\n                const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Left(t2));\r\n                return [patternInput[0], SetTreeModule_mk(patternInput[1], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\r\n            }\r\n        }\r\n        else {\r\n            return [SetTreeLeaf$1__get_Key(t2), SetTreeModule_empty()];\r\n        }\r\n    }\r\n    else {\r\n        throw (new Error(\"internal error: Set.spliceOutSuccessor\"));\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_remove(comparer, k, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (c < 0) {\r\n                return SetTreeModule_rebalance(SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\r\n            }\r\n            else if (c === 0) {\r\n                if (SetTreeNode$1__get_Left(t2) == null) {\r\n                    return SetTreeNode$1__get_Right(t2);\r\n                }\r\n                else if (SetTreeNode$1__get_Right(t2) == null) {\r\n                    return SetTreeNode$1__get_Left(t2);\r\n                }\r\n                else {\r\n                    const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Right(t2));\r\n                    return SetTreeModule_mk(SetTreeNode$1__get_Left(t2), patternInput[0], patternInput[1]);\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Right(t2)));\r\n            }\r\n        }\r\n        else if (c === 0) {\r\n            return SetTreeModule_empty();\r\n        }\r\n        else {\r\n            return t;\r\n        }\r\n    }\r\n    else {\r\n        return t;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {\r\n    SetTreeModule_mem:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (c < 0) {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    t_mut = SetTreeNode$1__get_Left(t2);\r\n                    continue SetTreeModule_mem;\r\n                }\r\n                else if (c === 0) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_mem;\r\n                }\r\n            }\r\n            else {\r\n                return c === 0;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_iter(f_mut, t_mut) {\r\n    SetTreeModule_iter:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                SetTreeModule_iter(f, SetTreeNode$1__get_Left(t2));\r\n                f(SetTreeLeaf$1__get_Key(t2));\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                continue SetTreeModule_iter;\r\n            }\r\n            else {\r\n                f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_foldBackOpt(f_mut, t_mut, x_mut) {\r\n    SetTreeModule_foldBackOpt:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut, x = x_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                x_mut = f(SetTreeLeaf$1__get_Key(t2), SetTreeModule_foldBackOpt(f, SetTreeNode$1__get_Right(t2), x));\r\n                continue SetTreeModule_foldBackOpt;\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2), x);\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_foldBack(f, m, x) {\r\n    return SetTreeModule_foldBackOpt(f, m, x);\r\n}\r\n\r\nexport function SetTreeModule_foldOpt(f_mut, x_mut, t_mut) {\r\n    SetTreeModule_foldOpt:\r\n    while (true) {\r\n        const f = f_mut, x = x_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                f_mut = f;\r\n                x_mut = f(SetTreeModule_foldOpt(f, x, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2));\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                continue SetTreeModule_foldOpt;\r\n            }\r\n            else {\r\n                return f(x, SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_fold(f, x, m) {\r\n    return SetTreeModule_foldOpt(f, x, m);\r\n}\r\n\r\nexport function SetTreeModule_forall(f_mut, t_mut) {\r\n    SetTreeModule_forall:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (f(SetTreeLeaf$1__get_Key(t2)) && SetTreeModule_forall(f, SetTreeNode$1__get_Left(t2))) {\r\n                    f_mut = f;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_forall;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_exists(f_mut, t_mut) {\r\n    SetTreeModule_exists:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (f(SetTreeLeaf$1__get_Key(t2)) ? true : SetTreeModule_exists(f, SetTreeNode$1__get_Left(t2))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_exists;\r\n                }\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_subset(comparer, a, b) {\r\n    return SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a);\r\n}\r\n\r\nexport function SetTreeModule_properSubset(comparer, a, b) {\r\n    if (SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a)) {\r\n        return SetTreeModule_exists((x_1) => (!SetTreeModule_mem(comparer, x_1, a)), b);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_filterAux(comparer_mut, f_mut, t_mut, acc_mut) {\r\n    SetTreeModule_filterAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_1 = f(SetTreeLeaf$1__get_Key(t2)) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc) : acc;\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_filterAux(comparer, f, SetTreeNode$1__get_Right(t2), acc_1);\r\n                continue SetTreeModule_filterAux;\r\n            }\r\n            else if (f(SetTreeLeaf$1__get_Key(t2))) {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_filter(comparer, f, s) {\r\n    return SetTreeModule_filterAux(comparer, f, s, SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_diffAux(comparer_mut, t_mut, acc_mut) {\r\n    SetTreeModule_diffAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, t = t_mut, acc = acc_mut;\r\n        if (acc == null) {\r\n            return acc;\r\n        }\r\n        else if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                comparer_mut = comparer;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_diffAux(comparer, SetTreeNode$1__get_Right(t2), SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc));\r\n                continue SetTreeModule_diffAux;\r\n            }\r\n            else {\r\n                return SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_diff(comparer, a, b) {\r\n    return SetTreeModule_diffAux(comparer, b, a);\r\n}\r\n\r\nexport function SetTreeModule_union(comparer, t1, t2) {\r\n    if (t1 != null) {\r\n        const t1$0027 = t1;\r\n        if (t2 != null) {\r\n            const t2$0027 = t2;\r\n            if (t1$0027 instanceof SetTreeNode$1) {\r\n                if (t2$0027 instanceof SetTreeNode$1) {\r\n                    if (SetTreeNode$1__get_Height(t1$0027) > SetTreeNode$1__get_Height(t2$0027)) {\r\n                        const patternInput = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\r\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t1$0027), patternInput[0]), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t1$0027), patternInput[2]));\r\n                    }\r\n                    else {\r\n                        const patternInput_1 = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\r\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t2$0027), patternInput_1[0]), SetTreeLeaf$1__get_Key(t2$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t2$0027), patternInput_1[2]));\r\n                    }\r\n                }\r\n                else {\r\n                    return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\r\n            }\r\n        }\r\n        else {\r\n            return t1;\r\n        }\r\n    }\r\n    else {\r\n        return t2;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_intersectionAux(comparer_mut, b_mut, t_mut, acc_mut) {\r\n    SetTreeModule_intersectionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, b = b_mut, t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_1 = SetTreeModule_intersectionAux(comparer, b, SetTreeNode$1__get_Right(t2), acc);\r\n                const acc_2 = SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc_1) : acc_1;\r\n                comparer_mut = comparer;\r\n                b_mut = b;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = acc_2;\r\n                continue SetTreeModule_intersectionAux;\r\n            }\r\n            else if (SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b)) {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_intersection(comparer, a, b) {\r\n    return SetTreeModule_intersectionAux(comparer, b, a, SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_partition1(comparer, f, k, acc1, acc2) {\r\n    if (f(k)) {\r\n        return [SetTreeModule_add(comparer, k, acc1), acc2];\r\n    }\r\n    else {\r\n        return [acc1, SetTreeModule_add(comparer, k, acc2)];\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_partitionAux(comparer_mut, f_mut, t_mut, acc_0_mut, acc_1_mut) {\r\n    SetTreeModule_partitionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\r\n        const acc = [acc_0, acc_1];\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_2 = SetTreeModule_partitionAux(comparer, f, SetTreeNode$1__get_Right(t2), acc[0], acc[1]);\r\n                const acc_3 = SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc_2[0], acc_2[1]);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_0_mut = acc_3[0];\r\n                acc_1_mut = acc_3[1];\r\n                continue SetTreeModule_partitionAux;\r\n            }\r\n            else {\r\n                return SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc[0], acc[1]);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_partition(comparer, f, s) {\r\n    return SetTreeModule_partitionAux(comparer, f, s, SetTreeModule_empty(), SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_minimumElementAux(t_mut, n_mut) {\r\n    SetTreeModule_minimumElementAux:\r\n    while (true) {\r\n        const t = t_mut, n = n_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                n_mut = SetTreeLeaf$1__get_Key(t2);\r\n                continue SetTreeModule_minimumElementAux;\r\n            }\r\n            else {\r\n                return SetTreeLeaf$1__get_Key(t2);\r\n            }\r\n        }\r\n        else {\r\n            return n;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_minimumElementOpt(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            return some(SetTreeModule_minimumElementAux(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2)));\r\n        }\r\n        else {\r\n            return some(SetTreeLeaf$1__get_Key(t2));\r\n        }\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElementAux(t_mut, n_mut) {\r\n    SetTreeModule_maximumElementAux:\r\n    while (true) {\r\n        const t = t_mut, n = n_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                n_mut = SetTreeLeaf$1__get_Key(t2);\r\n                continue SetTreeModule_maximumElementAux;\r\n            }\r\n            else {\r\n                return SetTreeLeaf$1__get_Key(t2);\r\n            }\r\n        }\r\n        else {\r\n            return n;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElementOpt(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            return some(SetTreeModule_maximumElementAux(SetTreeNode$1__get_Right(t2), SetTreeLeaf$1__get_Key(t2)));\r\n        }\r\n        else {\r\n            return some(SetTreeLeaf$1__get_Key(t2));\r\n        }\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_minimumElement(s) {\r\n    const matchValue = SetTreeModule_minimumElementOpt(s);\r\n    if (matchValue == null) {\r\n        throw (new Error(\"Set contains no elements\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElement(s) {\r\n    const matchValue = SetTreeModule_maximumElementOpt(s);\r\n    if (matchValue == null) {\r\n        throw (new Error(\"Set contains no elements\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport class SetTreeModule_SetIterator$1 extends Record {\r\n    constructor(stack, started) {\r\n        super();\r\n        this.stack = stack;\r\n        this.started = started;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_SetIterator$1$reflection(gen0) {\r\n    return record_type(\"Set.SetTreeModule.SetIterator`1\", [gen0], SetTreeModule_SetIterator$1, () => [[\"stack\", list_type(option_type(SetTreeLeaf$1$reflection(gen0)))], [\"started\", bool_type]]);\r\n}\r\n\r\nexport function SetTreeModule_collapseLHS(stack_mut) {\r\n    SetTreeModule_collapseLHS:\r\n    while (true) {\r\n        const stack = stack_mut;\r\n        if (!isEmpty_1(stack)) {\r\n            const x = head(stack);\r\n            const rest = tail(stack);\r\n            if (x != null) {\r\n                const x2 = x;\r\n                if (x2 instanceof SetTreeNode$1) {\r\n                    stack_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2)), SetTreeNode$1__get_Right(x2)], rest);\r\n                    continue SetTreeModule_collapseLHS;\r\n                }\r\n                else {\r\n                    return stack;\r\n                }\r\n            }\r\n            else {\r\n                stack_mut = rest;\r\n                continue SetTreeModule_collapseLHS;\r\n            }\r\n        }\r\n        else {\r\n            return empty_1();\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mkIterator(s) {\r\n    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(singleton_1(s)), false);\r\n}\r\n\r\nexport function SetTreeModule_notStarted() {\r\n    throw (new Error(\"Enumeration not started\"));\r\n}\r\n\r\nexport function SetTreeModule_alreadyFinished() {\r\n    throw (new Error(\"Enumeration already started\"));\r\n}\r\n\r\nexport function SetTreeModule_current(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (isEmpty_1(matchValue)) {\r\n            return SetTreeModule_alreadyFinished();\r\n        }\r\n        else if (head(matchValue) != null) {\r\n            const t = head(matchValue);\r\n            return SetTreeLeaf$1__get_Key(t);\r\n        }\r\n        else {\r\n            throw (new Error(\"Please report error: Set iterator, unexpected stack for current\"));\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_notStarted();\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_moveNext(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const t = head(matchValue);\r\n                if (t instanceof SetTreeNode$1) {\r\n                    throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\r\n                }\r\n                else {\r\n                    i.stack = SetTreeModule_collapseLHS(tail(matchValue));\r\n                    return !isEmpty_1(i.stack);\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else {\r\n        i.started = true;\r\n        return !isEmpty_1(i.stack);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mkIEnumerator(s) {\r\n    let i = SetTreeModule_mkIterator(s);\r\n    return {\r\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n            return SetTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.get_Current\"]() {\r\n            return SetTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n            return SetTreeModule_moveNext(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.Reset\"]() {\r\n            i = SetTreeModule_mkIterator(s);\r\n        },\r\n        Dispose() {\r\n        },\r\n    };\r\n}\r\n\r\nexport function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {\r\n    SetTreeModule_compareStacks:\r\n    while (true) {\r\n        const comparer = comparer_mut, l1 = l1_mut, l2 = l2_mut;\r\n        const matchValue = [l1, l2];\r\n        if (!isEmpty_1(matchValue[0])) {\r\n            if (!isEmpty_1(matchValue[1])) {\r\n                if (head(matchValue[1]) != null) {\r\n                    if (head(matchValue[0]) != null) {\r\n                        const x1_3 = head(matchValue[0]);\r\n                        const x2_3 = head(matchValue[1]);\r\n                        if (x1_3 instanceof SetTreeNode$1) {\r\n                            if (SetTreeNode$1__get_Left(x1_3) == null) {\r\n                                if (x2_3 instanceof SetTreeNode$1) {\r\n                                    if (SetTreeNode$1__get_Left(x2_3) == null) {\r\n                                        const c = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                        if (c !== 0) {\r\n                                            return c | 0;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = cons(SetTreeNode$1__get_Right(x1_3), tail(matchValue[0]));\r\n                                            l2_mut = cons(SetTreeNode$1__get_Right(x2_3), tail(matchValue[1]));\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        const matchValue_3 = [l1, l2];\r\n                                        let pattern_matching_result, t1_6, x1_4, t2_6, x2_4;\r\n                                        if (!isEmpty_1(matchValue_3[0])) {\r\n                                            if (head(matchValue_3[0]) != null) {\r\n                                                pattern_matching_result = 0;\r\n                                                t1_6 = tail(matchValue_3[0]);\r\n                                                x1_4 = head(matchValue_3[0]);\r\n                                            }\r\n                                            else if (!isEmpty_1(matchValue_3[1])) {\r\n                                                if (head(matchValue_3[1]) != null) {\r\n                                                    pattern_matching_result = 1;\r\n                                                    t2_6 = tail(matchValue_3[1]);\r\n                                                    x2_4 = head(matchValue_3[1]);\r\n                                                }\r\n                                                else {\r\n                                                    pattern_matching_result = 2;\r\n                                                }\r\n                                            }\r\n                                            else {\r\n                                                pattern_matching_result = 2;\r\n                                            }\r\n                                        }\r\n                                        else if (!isEmpty_1(matchValue_3[1])) {\r\n                                            if (head(matchValue_3[1]) != null) {\r\n                                                pattern_matching_result = 1;\r\n                                                t2_6 = tail(matchValue_3[1]);\r\n                                                x2_4 = head(matchValue_3[1]);\r\n                                            }\r\n                                            else {\r\n                                                pattern_matching_result = 2;\r\n                                            }\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result = 2;\r\n                                        }\r\n                                        switch (pattern_matching_result) {\r\n                                            case 0: {\r\n                                                if (x1_4 instanceof SetTreeNode$1) {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_4), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_4), 0)], t1_6);\r\n                                                    l2_mut = l2;\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                                else {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_4))], t1_6);\r\n                                                    l2_mut = l2;\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                            }\r\n                                            case 1: {\r\n                                                if (x2_4 instanceof SetTreeNode$1) {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = l1;\r\n                                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_4), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_4), 0)], t2_6);\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                                else {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = l1;\r\n                                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_4))], t2_6);\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                            }\r\n                                            case 2: {\r\n                                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                            }\r\n                                        }\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                    if (c_1 !== 0) {\r\n                                        return c_1 | 0;\r\n                                    }\r\n                                    else {\r\n                                        comparer_mut = comparer;\r\n                                        l1_mut = cons(SetTreeNode$1__get_Right(x1_3), tail(matchValue[0]));\r\n                                        l2_mut = cons(SetTreeModule_empty(), tail(matchValue[1]));\r\n                                        continue SetTreeModule_compareStacks;\r\n                                    }\r\n                                }\r\n                            }\r\n                            else {\r\n                                const matchValue_4 = [l1, l2];\r\n                                let pattern_matching_result_1, t1_7, x1_5, t2_7, x2_5;\r\n                                if (!isEmpty_1(matchValue_4[0])) {\r\n                                    if (head(matchValue_4[0]) != null) {\r\n                                        pattern_matching_result_1 = 0;\r\n                                        t1_7 = tail(matchValue_4[0]);\r\n                                        x1_5 = head(matchValue_4[0]);\r\n                                    }\r\n                                    else if (!isEmpty_1(matchValue_4[1])) {\r\n                                        if (head(matchValue_4[1]) != null) {\r\n                                            pattern_matching_result_1 = 1;\r\n                                            t2_7 = tail(matchValue_4[1]);\r\n                                            x2_5 = head(matchValue_4[1]);\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result_1 = 2;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_1 = 2;\r\n                                    }\r\n                                }\r\n                                else if (!isEmpty_1(matchValue_4[1])) {\r\n                                    if (head(matchValue_4[1]) != null) {\r\n                                        pattern_matching_result_1 = 1;\r\n                                        t2_7 = tail(matchValue_4[1]);\r\n                                        x2_5 = head(matchValue_4[1]);\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_1 = 2;\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_1 = 2;\r\n                                }\r\n                                switch (pattern_matching_result_1) {\r\n                                    case 0: {\r\n                                        if (x1_5 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_5), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_5), 0)], t1_7);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_5))], t1_7);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 1: {\r\n                                        if (x2_5 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_5), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_5), 0)], t2_7);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_5))], t2_7);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 2: {\r\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        else if (x2_3 instanceof SetTreeNode$1) {\r\n                            if (SetTreeNode$1__get_Left(x2_3) == null) {\r\n                                const c_2 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                if (c_2 !== 0) {\r\n                                    return c_2 | 0;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = cons(SetTreeModule_empty(), tail(matchValue[0]));\r\n                                    l2_mut = cons(SetTreeNode$1__get_Right(x2_3), tail(matchValue[1]));\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            else {\r\n                                const matchValue_5 = [l1, l2];\r\n                                let pattern_matching_result_2, t1_8, x1_6, t2_8, x2_6;\r\n                                if (!isEmpty_1(matchValue_5[0])) {\r\n                                    if (head(matchValue_5[0]) != null) {\r\n                                        pattern_matching_result_2 = 0;\r\n                                        t1_8 = tail(matchValue_5[0]);\r\n                                        x1_6 = head(matchValue_5[0]);\r\n                                    }\r\n                                    else if (!isEmpty_1(matchValue_5[1])) {\r\n                                        if (head(matchValue_5[1]) != null) {\r\n                                            pattern_matching_result_2 = 1;\r\n                                            t2_8 = tail(matchValue_5[1]);\r\n                                            x2_6 = head(matchValue_5[1]);\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result_2 = 2;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_2 = 2;\r\n                                    }\r\n                                }\r\n                                else if (!isEmpty_1(matchValue_5[1])) {\r\n                                    if (head(matchValue_5[1]) != null) {\r\n                                        pattern_matching_result_2 = 1;\r\n                                        t2_8 = tail(matchValue_5[1]);\r\n                                        x2_6 = head(matchValue_5[1]);\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_2 = 2;\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_2 = 2;\r\n                                }\r\n                                switch (pattern_matching_result_2) {\r\n                                    case 0: {\r\n                                        if (x1_6 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_6), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_6), 0)], t1_8);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_6))], t1_8);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 1: {\r\n                                        if (x2_6 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_6), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_6), 0)], t2_8);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_6))], t2_8);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 2: {\r\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        else {\r\n                            const c_3 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                            if (c_3 !== 0) {\r\n                                return c_3 | 0;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = tail(matchValue[0]);\r\n                                l2_mut = tail(matchValue[1]);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                    }\r\n                    else {\r\n                        const x2 = head(matchValue[1]);\r\n                        const matchValue_1 = [l1, l2];\r\n                        let pattern_matching_result_3, t1_2, x1, t2_2, x2_1;\r\n                        if (!isEmpty_1(matchValue_1[0])) {\r\n                            if (head(matchValue_1[0]) != null) {\r\n                                pattern_matching_result_3 = 0;\r\n                                t1_2 = tail(matchValue_1[0]);\r\n                                x1 = head(matchValue_1[0]);\r\n                            }\r\n                            else if (!isEmpty_1(matchValue_1[1])) {\r\n                                if (head(matchValue_1[1]) != null) {\r\n                                    pattern_matching_result_3 = 1;\r\n                                    t2_2 = tail(matchValue_1[1]);\r\n                                    x2_1 = head(matchValue_1[1]);\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_3 = 2;\r\n                                }\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_3 = 2;\r\n                            }\r\n                        }\r\n                        else if (!isEmpty_1(matchValue_1[1])) {\r\n                            if (head(matchValue_1[1]) != null) {\r\n                                pattern_matching_result_3 = 1;\r\n                                t2_2 = tail(matchValue_1[1]);\r\n                                x2_1 = head(matchValue_1[1]);\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_3 = 2;\r\n                            }\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_3 = 2;\r\n                        }\r\n                        switch (pattern_matching_result_3) {\r\n                            case 0: {\r\n                                if (x1 instanceof SetTreeNode$1) {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1), 0)], t1_2);\r\n                                    l2_mut = l2;\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1))], t1_2);\r\n                                    l2_mut = l2;\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            case 1: {\r\n                                if (x2_1 instanceof SetTreeNode$1) {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = l1;\r\n                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_1), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_1), 0)], t2_2);\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = l1;\r\n                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_1))], t2_2);\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            case 2: {\r\n                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                else if (head(matchValue[0]) != null) {\r\n                    const x1_1 = head(matchValue[0]);\r\n                    const matchValue_2 = [l1, l2];\r\n                    let pattern_matching_result_4, t1_4, x1_2, t2_4, x2_2;\r\n                    if (!isEmpty_1(matchValue_2[0])) {\r\n                        if (head(matchValue_2[0]) != null) {\r\n                            pattern_matching_result_4 = 0;\r\n                            t1_4 = tail(matchValue_2[0]);\r\n                            x1_2 = head(matchValue_2[0]);\r\n                        }\r\n                        else if (!isEmpty_1(matchValue_2[1])) {\r\n                            if (head(matchValue_2[1]) != null) {\r\n                                pattern_matching_result_4 = 1;\r\n                                t2_4 = tail(matchValue_2[1]);\r\n                                x2_2 = head(matchValue_2[1]);\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_4 = 2;\r\n                            }\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_4 = 2;\r\n                        }\r\n                    }\r\n                    else if (!isEmpty_1(matchValue_2[1])) {\r\n                        if (head(matchValue_2[1]) != null) {\r\n                            pattern_matching_result_4 = 1;\r\n                            t2_4 = tail(matchValue_2[1]);\r\n                            x2_2 = head(matchValue_2[1]);\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_4 = 2;\r\n                        }\r\n                    }\r\n                    else {\r\n                        pattern_matching_result_4 = 2;\r\n                    }\r\n                    switch (pattern_matching_result_4) {\r\n                        case 0: {\r\n                            if (x1_2 instanceof SetTreeNode$1) {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_2), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_2), 0)], t1_4);\r\n                                l2_mut = l2;\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_2))], t1_4);\r\n                                l2_mut = l2;\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                        case 1: {\r\n                            if (x2_2 instanceof SetTreeNode$1) {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = l1;\r\n                                l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_2), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_2), 0)], t2_4);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = l1;\r\n                                l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_2))], t2_4);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                        case 2: {\r\n                            throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    l1_mut = tail(matchValue[0]);\r\n                    l2_mut = tail(matchValue[1]);\r\n                    continue SetTreeModule_compareStacks;\r\n                }\r\n            }\r\n            else {\r\n                return 1;\r\n            }\r\n        }\r\n        else if (isEmpty_1(matchValue[1])) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_compare(comparer, t1, t2) {\r\n    if (t1 == null) {\r\n        if (t2 == null) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n    else if (t2 == null) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return SetTreeModule_compareStacks(comparer, singleton_1(t1), singleton_1(t2)) | 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_choose(s) {\r\n    return SetTreeModule_minimumElement(s);\r\n}\r\n\r\nexport function SetTreeModule_toList(t) {\r\n    const loop = (t$0027_mut, acc_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const t$0027 = t$0027_mut, acc = acc_mut;\r\n            if (t$0027 != null) {\r\n                const t2 = t$0027;\r\n                if (t2 instanceof SetTreeNode$1) {\r\n                    t$0027_mut = SetTreeNode$1__get_Left(t2);\r\n                    acc_mut = cons(SetTreeLeaf$1__get_Key(t2), loop(SetTreeNode$1__get_Right(t2), acc));\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return cons(SetTreeLeaf$1__get_Key(t2), acc);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(t, empty_1());\r\n}\r\n\r\nexport function SetTreeModule_copyToArray(s, arr, i) {\r\n    let j = i;\r\n    SetTreeModule_iter((x) => {\r\n        arr[j] = x;\r\n        j = ((j + 1) | 0);\r\n    }, s);\r\n}\r\n\r\nexport function SetTreeModule_toArray(s) {\r\n    const n = SetTreeModule_count(s) | 0;\r\n    const res = fill(new Array(n), 0, n, null);\r\n    SetTreeModule_copyToArray(s, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\r\n    SetTreeModule_mkFromEnumerator:\r\n    while (true) {\r\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            comparer_mut = comparer;\r\n            acc_mut = SetTreeModule_add(comparer, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), acc);\r\n            e_mut = e;\r\n            continue SetTreeModule_mkFromEnumerator;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_ofArray(comparer, l) {\r\n    return fold_1((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\r\n}\r\n\r\nexport function SetTreeModule_ofList(comparer, l) {\r\n    return fold_2((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\r\n}\r\n\r\nexport function SetTreeModule_ofSeq(comparer, c) {\r\n    if (isArrayLike(c)) {\r\n        return SetTreeModule_ofArray(comparer, c);\r\n    }\r\n    else if (c instanceof FSharpList) {\r\n        return SetTreeModule_ofList(comparer, c);\r\n    }\r\n    else {\r\n        const ie = getEnumerator(c);\r\n        try {\r\n            return SetTreeModule_mkFromEnumerator(comparer, SetTreeModule_empty(), ie);\r\n        }\r\n        finally {\r\n            ie.Dispose();\r\n        }\r\n    }\r\n}\r\n\r\nexport class FSharpSet {\r\n    constructor(comparer, tree) {\r\n        this.comparer = comparer;\r\n        this.tree = tree;\r\n    }\r\n    GetHashCode() {\r\n        const this$ = this;\r\n        return FSharpSet__ComputeHashCode(this$) | 0;\r\n    }\r\n    Equals(that) {\r\n        const this$ = this;\r\n        return (that instanceof FSharpSet) && (SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that)) === 0);\r\n    }\r\n    toString() {\r\n        const this$ = this;\r\n        return (\"set [\" + join(\"; \", map_1((x) => {\r\n            let copyOfStruct = x;\r\n            return toString(copyOfStruct);\r\n        }, this$))) + \"]\";\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"FSharpSet\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    CompareTo(that) {\r\n        const s = this;\r\n        return SetTreeModule_compare(FSharpSet__get_Comparer(s), FSharpSet__get_Tree(s), FSharpSet__get_Tree(that)) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\r\n        const s = this;\r\n        return SetTreeModule_mem(FSharpSet__get_Comparer(s), x, FSharpSet__get_Tree(s));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\r\n        const s = this;\r\n        SetTreeModule_copyToArray(FSharpSet__get_Tree(s), arr, i);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return true;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    GetEnumerator() {\r\n        const s = this;\r\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const s = this;\r\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\r\n    }\r\n    get size() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    add(k) {\r\n        const s = this;\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n        return s;\r\n    }\r\n    clear() {\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n    }\r\n    delete(k) {\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n        return false;\r\n    }\r\n    has(k) {\r\n        const s = this;\r\n        return FSharpSet__Contains(s, k);\r\n    }\r\n    keys() {\r\n        const s = this;\r\n        return map_1((x) => x, s);\r\n    }\r\n    values() {\r\n        const s = this;\r\n        return map_1((x) => x, s);\r\n    }\r\n    entries() {\r\n        const s = this;\r\n        return map_1((v) => [v, v], s);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const s = this;\r\n        iterate_1((x) => {\r\n            f(x, x, s);\r\n        }, s);\r\n    }\r\n}\r\n\r\nexport function FSharpSet$reflection(gen0) {\r\n    return class_type(\"Set.FSharpSet\", [gen0], FSharpSet);\r\n}\r\n\r\nexport function FSharpSet_$ctor(comparer, tree) {\r\n    return new FSharpSet(comparer, tree);\r\n}\r\n\r\nexport function FSharpSet__get_Comparer(set$) {\r\n    return set$.comparer;\r\n}\r\n\r\nexport function FSharpSet__get_Tree(set$) {\r\n    return set$.tree;\r\n}\r\n\r\nexport function FSharpSet_Empty(comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_empty());\r\n}\r\n\r\nexport function FSharpSet__Add(s, value) {\r\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_add(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__Remove(s, value) {\r\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_remove(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__get_Count(s) {\r\n    return SetTreeModule_count(FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Contains(s, value) {\r\n    return SetTreeModule_mem(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Iterate(s, x) {\r\n    SetTreeModule_iter(x, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Fold(s, f, z) {\r\n    const f_1 = f;\r\n    return SetTreeModule_fold((x, z_1) => f_1(z_1, x), z, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__get_IsEmpty(s) {\r\n    return FSharpSet__get_Tree(s) == null;\r\n}\r\n\r\nexport function FSharpSet__Partition(s, f) {\r\n    if (FSharpSet__get_Tree(s) == null) {\r\n        return [s, s];\r\n    }\r\n    else {\r\n        const patternInput = SetTreeModule_partition(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s));\r\n        return [FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[0]), FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[1])];\r\n    }\r\n}\r\n\r\nexport function FSharpSet__Filter(s, f) {\r\n    if (FSharpSet__get_Tree(s) == null) {\r\n        return s;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_filter(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet__Map(s, f, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_fold((acc, k) => SetTreeModule_add(comparer, f(k), acc), SetTreeModule_empty(), FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__Exists(s, f) {\r\n    return SetTreeModule_exists(f, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__ForAll(s, f) {\r\n    return SetTreeModule_forall(f, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet_op_Subtraction(set1, set2) {\r\n    if (FSharpSet__get_Tree(set1) == null) {\r\n        return set1;\r\n    }\r\n    else if (FSharpSet__get_Tree(set2) == null) {\r\n        return set1;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_diff(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_op_Addition(set1, set2) {\r\n    if (FSharpSet__get_Tree(set2) == null) {\r\n        return set1;\r\n    }\r\n    else if (FSharpSet__get_Tree(set1) == null) {\r\n        return set2;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_union(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_Intersection(a, b) {\r\n    if (FSharpSet__get_Tree(b) == null) {\r\n        return b;\r\n    }\r\n    else if (FSharpSet__get_Tree(a) == null) {\r\n        return a;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(a), SetTreeModule_intersection(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_IntersectionMany(sets) {\r\n    return reduce((s1, s2) => FSharpSet_Intersection(s1, s2), sets);\r\n}\r\n\r\nexport function FSharpSet_Equality(a, b) {\r\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) === 0;\r\n}\r\n\r\nexport function FSharpSet_Compare(a, b) {\r\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b));\r\n}\r\n\r\nexport function FSharpSet__get_Choose(x) {\r\n    return SetTreeModule_choose(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__get_MinimumElement(x) {\r\n    return SetTreeModule_minimumElement(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__get_MaximumElement(x) {\r\n    return SetTreeModule_maximumElement(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__IsSubsetOf(x, otherSet) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\r\n}\r\n\r\nexport function FSharpSet__IsSupersetOf(x, otherSet) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__IsProperSubsetOf(x, otherSet) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\r\n}\r\n\r\nexport function FSharpSet__IsProperSupersetOf(x, otherSet) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ToList(x) {\r\n    return SetTreeModule_toList(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ToArray(x) {\r\n    return SetTreeModule_toArray(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ComputeHashCode(this$) {\r\n    let y;\r\n    let res = 0;\r\n    const enumerator = getEnumerator(this$);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const x_1 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            res = (((y = (structuralHash(x_1) | 0), ((res << 1) + y) + 631)) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n    return Math.abs(res) | 0;\r\n}\r\n\r\nexport function isEmpty(set$) {\r\n    return FSharpSet__get_IsEmpty(set$);\r\n}\r\n\r\nexport function contains(element, set$) {\r\n    return FSharpSet__Contains(set$, element);\r\n}\r\n\r\nexport function add(value, set$) {\r\n    return FSharpSet__Add(set$, value);\r\n}\r\n\r\nexport function singleton(value, comparer) {\r\n    return FSharpSet__Add(FSharpSet_Empty(comparer), value);\r\n}\r\n\r\nexport function remove(value, set$) {\r\n    return FSharpSet__Remove(set$, value);\r\n}\r\n\r\nexport function union(set1, set2) {\r\n    return FSharpSet_op_Addition(set1, set2);\r\n}\r\n\r\nexport function unionMany(sets, comparer) {\r\n    return fold_3((s1, s2) => FSharpSet_op_Addition(s1, s2), FSharpSet_Empty(comparer), sets);\r\n}\r\n\r\nexport function intersect(set1, set2) {\r\n    return FSharpSet_Intersection(set1, set2);\r\n}\r\n\r\nexport function intersectMany(sets) {\r\n    return FSharpSet_IntersectionMany(sets);\r\n}\r\n\r\nexport function iterate(action, set$) {\r\n    FSharpSet__Iterate(set$, action);\r\n}\r\n\r\nexport function empty(comparer) {\r\n    return FSharpSet_Empty(comparer);\r\n}\r\n\r\nexport function forAll(predicate, set$) {\r\n    return FSharpSet__ForAll(set$, predicate);\r\n}\r\n\r\nexport function exists(predicate, set$) {\r\n    return FSharpSet__Exists(set$, predicate);\r\n}\r\n\r\nexport function filter(predicate, set$) {\r\n    return FSharpSet__Filter(set$, predicate);\r\n}\r\n\r\nexport function partition(predicate, set$) {\r\n    return FSharpSet__Partition(set$, predicate);\r\n}\r\n\r\nexport function fold(folder, state, set$) {\r\n    return SetTreeModule_fold(folder, state, FSharpSet__get_Tree(set$));\r\n}\r\n\r\nexport function foldBack(folder, set$, state) {\r\n    return SetTreeModule_foldBack(folder, FSharpSet__get_Tree(set$), state);\r\n}\r\n\r\nexport function map(mapping, set$, comparer) {\r\n    return FSharpSet__Map(set$, mapping, comparer);\r\n}\r\n\r\nexport function count(set$) {\r\n    return FSharpSet__get_Count(set$);\r\n}\r\n\r\nexport function ofList(elements, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\r\n}\r\n\r\nexport function ofArray(array, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofArray(comparer, array));\r\n}\r\n\r\nexport function toList(set$) {\r\n    return FSharpSet__ToList(set$);\r\n}\r\n\r\nexport function toArray(set$) {\r\n    return FSharpSet__ToArray(set$);\r\n}\r\n\r\nexport function toSeq(set$) {\r\n    return map_1((x) => x, set$);\r\n}\r\n\r\nexport function ofSeq(elements, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\r\n}\r\n\r\nexport function difference(set1, set2) {\r\n    return FSharpSet_op_Subtraction(set1, set2);\r\n}\r\n\r\nexport function isSubset(set1, set2) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\r\n}\r\n\r\nexport function isSuperset(set1, set2) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\r\n}\r\n\r\nexport function isProperSubset(set1, set2) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\r\n}\r\n\r\nexport function isProperSuperset(set1, set2) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\r\n}\r\n\r\nexport function minElement(set$) {\r\n    return FSharpSet__get_MinimumElement(set$);\r\n}\r\n\r\nexport function maxElement(set$) {\r\n    return FSharpSet__get_MaximumElement(set$);\r\n}\r\n\r\nexport function unionWith(s1, s2) {\r\n    return fold_3((acc, x) => acc.add(x), s1, s2);\r\n}\r\n\r\nexport function newMutableSetWith(s1, s2) {\r\n    if (s1 instanceof HashSet) {\r\n        return HashSet_$ctor_Z6150332D(s2, HashSet__get_Comparer(s1));\r\n    }\r\n    else {\r\n        return new Set(s2);\r\n    }\r\n}\r\n\r\nexport function intersectWith(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    iterate_1((x) => {\r\n        if (!s2_1.has(x)) {\r\n            s1.delete(x);\r\n        }\r\n    }, s1.values());\r\n}\r\n\r\nexport function exceptWith(s1, s2) {\r\n    iterate_1((x) => {\r\n        s1.delete(x);\r\n    }, s2);\r\n}\r\n\r\nexport function isSubsetOf(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    return forAll_1((arg00) => s2_1.has(arg00), s1.values());\r\n}\r\n\r\nexport function isSupersetOf(s1, s2) {\r\n    return forAll_1((arg00) => s1.has(arg00), s2);\r\n}\r\n\r\nexport function isProperSubsetOf(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    if (s2_1.size > s1.size) {\r\n        return forAll_1((arg00) => s2_1.has(arg00), s1.values());\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function isProperSupersetOf(s1, s2) {\r\n    const s2_1 = cache(s2);\r\n    if (exists_1((arg) => (!s1.has(arg)), s2_1)) {\r\n        return forAll_1((arg00_1) => s1.has(arg00_1), s2_1);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\n","import { toIterator, getEnumerator } from \"./Util.js\";\r\nimport { iterate, map, iterateIndexed, concat } from \"./Seq.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\r\nimport { some } from \"./Option.js\";\r\n\r\nexport class HashSet {\r\n    constructor(items, comparer) {\r\n        const this$ = new FSharpRef(null);\r\n        this.comparer = comparer;\r\n        this$.contents = this;\r\n        this.hashMap = (new Map([]));\r\n        this[\"init@8-2\"] = 1;\r\n        const enumerator = getEnumerator(items);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                HashSet__Add_2B595(this$.contents, enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n        }\r\n        finally {\r\n            enumerator.Dispose();\r\n        }\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"HashSet\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const this$ = this;\r\n        return getEnumerator(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const this$ = this;\r\n        return getEnumerator(concat(this$.hashMap.values()));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\r\n        const this$ = this;\r\n        HashSet__Add_2B595(this$, item);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        const this$ = this;\r\n        HashSet__Clear(this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\r\n        const this$ = this;\r\n        return HashSet__Contains_2B595(this$, item);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\r\n        const this$ = this;\r\n        iterateIndexed((i, e) => {\r\n            array[arrayIndex + i] = e;\r\n        }, this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const this$ = this;\r\n        return HashSet__get_Count(this$) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return false;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\r\n        const this$ = this;\r\n        return HashSet__Remove_2B595(this$, item);\r\n    }\r\n    get size() {\r\n        const this$ = this;\r\n        return HashSet__get_Count(this$) | 0;\r\n    }\r\n    add(k) {\r\n        const this$ = this;\r\n        HashSet__Add_2B595(this$, k);\r\n        return this$;\r\n    }\r\n    clear() {\r\n        const this$ = this;\r\n        HashSet__Clear(this$);\r\n    }\r\n    delete(k) {\r\n        const this$ = this;\r\n        return HashSet__Remove_2B595(this$, k);\r\n    }\r\n    has(k) {\r\n        const this$ = this;\r\n        return HashSet__Contains_2B595(this$, k);\r\n    }\r\n    keys() {\r\n        const this$ = this;\r\n        return map((x) => x, this$);\r\n    }\r\n    values() {\r\n        const this$ = this;\r\n        return map((x) => x, this$);\r\n    }\r\n    entries() {\r\n        const this$ = this;\r\n        return map((v) => [v, v], this$);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const this$ = this;\r\n        iterate((x) => {\r\n            f(x, x, this$);\r\n        }, this$);\r\n    }\r\n}\r\n\r\nexport function HashSet$reflection(gen0) {\r\n    return class_type(\"Fable.Collections.HashSet\", [gen0], HashSet);\r\n}\r\n\r\nexport function HashSet_$ctor_Z6150332D(items, comparer) {\r\n    return new HashSet(items, comparer);\r\n}\r\n\r\nfunction HashSet__TryFindIndex_2B595(this$, k) {\r\n    const h = this$.comparer.GetHashCode(k) | 0;\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return [true, h, matchValue[1].findIndex((v_1) => this$.comparer.Equals(k, v_1))];\r\n    }\r\n    else {\r\n        return [false, h, -1];\r\n    }\r\n}\r\n\r\nfunction HashSet__TryFind_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__get_Comparer(this$) {\r\n    return this$.comparer;\r\n}\r\n\r\nexport function HashSet__Clear(this$) {\r\n    this$.hashMap.clear();\r\n}\r\n\r\nexport function HashSet__get_Count(this$) {\r\n    let count = 0;\r\n    let enumerator = getEnumerator(this$.hashMap.values());\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const items = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            count = ((count + items.length) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n    return count | 0;\r\n}\r\n\r\nexport function HashSet__Add_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return false;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));\r\n                return true;\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [k]);\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__Contains_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__Remove_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\n","import { FSharpRef, Union } from \"../fable-library.3.6.3/Types.js\";\nimport { getUnionFields, getRecordField, makeRecord, fullName, makeUnion, name as name_2, union_type, string_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { Json, Json$reflection } from \"./Json.fs.js\";\nimport { map as map_3, choose, ofArray, tryFind as tryFind_2, toArray, length, tail as tail_1, head, isEmpty, empty, singleton } from \"../fable-library.3.6.3/List.js\";\nimport { toArray as toArray_1, map as map_4, collect, tryFind as tryFind_3, forAll, empty as empty_1, singleton as singleton_1, append, delay, toList } from \"../fable-library.3.6.3/Seq.js\";\nimport { value as value_89, some, map as map_1 } from \"../fable-library.3.6.3/Option.js\";\nimport { toArray as toArray_2, isEmpty as isEmpty_1, ofList as ofList_1, find, count, containsKey, toList as toList_1, tryFind, remove } from \"../fable-library.3.6.3/Map.js\";\nimport { toText, join, fromBase64String, printf, toFail, substring, endsWith } from \"../fable-library.3.6.3/String.js\";\nimport { parse } from \"../fable-library.3.6.3/Double.js\";\nimport { tryParse, parse as parse_1 } from \"../fable-library.3.6.3/Int32.js\";\nimport { toString as toString_2 } from \"../fable-library.3.6.3/Decimal.js\";\nimport Decimal from \"../fable-library.3.6.3/Decimal.js\";\nimport { toString, fromInteger, toNumber, tryParse as tryParse_1, fromInt, parse as parse_2, fromNumber } from \"../fable-library.3.6.3/Long.js\";\nimport { SimpleJson_stringify, SimpleJson_parseNative, SimpleJson_parse, SimpleJson_toString, SimpleJson_toPlainObject } from \"./SimpleJson.fs.js\";\nimport { toString as toString_1, fromInt32, parse as parse_3 } from \"../fable-library.3.6.3/BigInt.js\";\nimport { toString as toString_3, parse as parse_4 } from \"../fable-library.3.6.3/Date.js\";\nimport { parse as parse_5 } from \"../fable-library.3.6.3/DateOffset.js\";\nimport DateOffset from \"../fable-library.3.6.3/DateOffset.js\";\nimport { dayNumber, fromDayNumber } from \"../fable-library.3.6.3/DateOnly.js\";\nimport { create } from \"../fable-library.3.6.3/TimeOnly.js\";\nimport { concat, mapIndexed, equalsWith, zip, map as map_2, tryFind as tryFind_1 } from \"../fable-library.3.6.3/Array.js\";\nimport { int32ToString, getEnumerator, structuralHash, safeHash, compare, equals } from \"../fable-library.3.6.3/Util.js\";\nimport { parse as parse_6 } from \"../fable-library.3.6.3/Guid.js\";\nimport { getBytesInt32, toInt64 } from \"../fable-library.3.6.3/BitConverter.js\";\nimport { ofList } from \"../fable-library.3.6.3/Set.js\";\nimport { TypeInfo } from \"./TypeInfo.fs.js\";\nimport { Dictionary } from \"../fable-library.3.6.3/MutableMap.js\";\nimport { addToSet, addToDict } from \"../fable-library.3.6.3/MapUtil.js\";\nimport { HashSet } from \"../fable-library.3.6.3/MutableSet.js\";\nimport { enumUnion, isPrimitive } from \"./TypeInfo.Converter.fs.js\";\nimport quote from \"./quote.js\";\nimport { ticks } from \"../fable-library.3.6.3/TimeSpan.js\";\n\nexport const Convert_insideBrowser = (new Function(\"try {return this===window;}catch(e){ return false;}\"))();\n\nfunction Convert_isDefined(value) {\n    return !((value === undefined));\n}\n\nexport function Convert_usingFable3() {\n    return true;\n}\n\nexport const Convert_isUsingFable3 = Convert_usingFable3();\n\nexport class Convert_InternalMap extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"MapEmpty\", \"MapOne\", \"MapNode\"];\n    }\n}\n\nexport function Convert_InternalMap$reflection() {\n    return union_type(\"Fable.SimpleJson.Convert.InternalMap\", [], Convert_InternalMap, () => [[], [[\"Item1\", string_type], [\"Item2\", Json$reflection()]], [[\"Item1\", string_type], [\"Item2\", Json$reflection()], [\"Item3\", Convert_InternalMap$reflection()], [\"Item4\", Convert_InternalMap$reflection()]]]);\n}\n\nexport function Convert_flattenMap(_arg1) {\n    switch (_arg1.tag) {\n        case 1: {\n            return singleton([_arg1.fields[0], _arg1.fields[1]]);\n        }\n        case 2: {\n            return toList(delay(() => append(Convert_flattenMap(_arg1.fields[2]), delay(() => append(Convert_flattenMap(_arg1.fields[3]), delay(() => singleton_1([_arg1.fields[0], _arg1.fields[1]])))))));\n        }\n        default: {\n            return empty();\n        }\n    }\n}\n\nexport function Convert_$007CKeyValue$007C_$007C(key, map) {\n    return map_1((value) => [key, value, remove(key, map)], tryFind(key, map));\n}\n\nexport function Convert_$007CNonArray$007C_$007C(_arg1) {\n    if (_arg1.tag === 4) {\n        return void 0;\n    }\n    else {\n        return _arg1;\n    }\n}\n\nexport function Convert_$007CMapEmpty$007C_$007C(json) {\n    let pattern_matching_result;\n    if (json.tag === 1) {\n        if (json.fields[0] === \"MapEmpty\") {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return json;\n        }\n        case 1: {\n            return void 0;\n        }\n    }\n}\n\nexport function Convert_$007CMapKey$007C_$007C(_arg1) {\n    switch (_arg1.tag) {\n        case 0: {\n            return _arg1.fields[0].toString();\n        }\n        case 1: {\n            return _arg1.fields[0];\n        }\n        default: {\n            return void 0;\n        }\n    }\n}\n\nexport function Convert_$007CMapOne$007C_$007C(_arg1) {\n    let pattern_matching_result, key, value;\n    if (_arg1.tag === 4) {\n        if (!isEmpty(_arg1.fields[0])) {\n            if (head(_arg1.fields[0]).tag === 1) {\n                if (head(_arg1.fields[0]).fields[0] === \"MapOne\") {\n                    if (!isEmpty(tail_1(_arg1.fields[0]))) {\n                        const activePatternResult2867 = Convert_$007CMapKey$007C_$007C(head(tail_1(_arg1.fields[0])));\n                        if (activePatternResult2867 != null) {\n                            if (!isEmpty(tail_1(tail_1(_arg1.fields[0])))) {\n                                if (isEmpty(tail_1(tail_1(tail_1(_arg1.fields[0]))))) {\n                                    pattern_matching_result = 0;\n                                    key = activePatternResult2867;\n                                    value = head(tail_1(tail_1(_arg1.fields[0])));\n                                }\n                                else {\n                                    pattern_matching_result = 1;\n                                }\n                            }\n                            else {\n                                pattern_matching_result = 1;\n                            }\n                        }\n                        else {\n                            pattern_matching_result = 1;\n                        }\n                    }\n                    else {\n                        pattern_matching_result = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n            }\n            else {\n                pattern_matching_result = 1;\n            }\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return [key, value];\n        }\n        case 1: {\n            return void 0;\n        }\n    }\n}\n\nexport function Convert_$007CMapNode$007C_$007C(_arg1) {\n    let pattern_matching_result, key, left, right, value;\n    if (_arg1.tag === 4) {\n        if (!isEmpty(_arg1.fields[0])) {\n            if (head(_arg1.fields[0]).tag === 1) {\n                if (head(_arg1.fields[0]).fields[0] === \"MapNode\") {\n                    if (!isEmpty(tail_1(_arg1.fields[0]))) {\n                        const activePatternResult2869 = Convert_$007CMapKey$007C_$007C(head(tail_1(_arg1.fields[0])));\n                        if (activePatternResult2869 != null) {\n                            if (!isEmpty(tail_1(tail_1(_arg1.fields[0])))) {\n                                if (!isEmpty(tail_1(tail_1(tail_1(_arg1.fields[0]))))) {\n                                    if (!isEmpty(tail_1(tail_1(tail_1(tail_1(_arg1.fields[0])))))) {\n                                        if (!isEmpty(tail_1(tail_1(tail_1(tail_1(tail_1(_arg1.fields[0]))))))) {\n                                            if (head(tail_1(tail_1(tail_1(tail_1(tail_1(_arg1.fields[0])))))).tag === 0) {\n                                                if (isEmpty(tail_1(tail_1(tail_1(tail_1(tail_1(tail_1(_arg1.fields[0])))))))) {\n                                                    pattern_matching_result = 0;\n                                                    key = activePatternResult2869;\n                                                    left = head(tail_1(tail_1(tail_1(_arg1.fields[0]))));\n                                                    right = head(tail_1(tail_1(tail_1(tail_1(_arg1.fields[0])))));\n                                                    value = head(tail_1(tail_1(_arg1.fields[0])));\n                                                }\n                                                else {\n                                                    pattern_matching_result = 1;\n                                                }\n                                            }\n                                            else {\n                                                pattern_matching_result = 1;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result = 1;\n                                        }\n                                    }\n                                    else {\n                                        pattern_matching_result = 1;\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result = 1;\n                                }\n                            }\n                            else {\n                                pattern_matching_result = 1;\n                            }\n                        }\n                        else {\n                            pattern_matching_result = 1;\n                        }\n                    }\n                    else {\n                        pattern_matching_result = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n            }\n            else {\n                pattern_matching_result = 1;\n            }\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return [key, value, left, right];\n        }\n        case 1: {\n            return void 0;\n        }\n    }\n}\n\nexport function Convert_generateMap(json) {\n    if (Convert_$007CMapEmpty$007C_$007C(json) != null) {\n        return new Convert_InternalMap(0);\n    }\n    else {\n        const activePatternResult2872 = Convert_$007CMapOne$007C_$007C(json);\n        if (activePatternResult2872 != null) {\n            const key = activePatternResult2872[0];\n            const value = activePatternResult2872[1];\n            return new Convert_InternalMap(1, key, value);\n        }\n        else {\n            const activePatternResult2871 = Convert_$007CMapNode$007C_$007C(json);\n            if (activePatternResult2871 != null) {\n                const key_1 = activePatternResult2871[0];\n                const left = activePatternResult2871[2];\n                const right = activePatternResult2871[3];\n                const value_1 = activePatternResult2871[1];\n                const matchValue = [Convert_generateMap(left), Convert_generateMap(right)];\n                let pattern_matching_result, leftMap, rightMap;\n                if (matchValue[0] != null) {\n                    if (matchValue[1] != null) {\n                        pattern_matching_result = 0;\n                        leftMap = matchValue[0];\n                        rightMap = matchValue[1];\n                    }\n                    else {\n                        pattern_matching_result = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n                switch (pattern_matching_result) {\n                    case 0: {\n                        return new Convert_InternalMap(2, key_1, value_1, leftMap, rightMap);\n                    }\n                    case 1: {\n                        return void 0;\n                    }\n                }\n            }\n            else {\n                return void 0;\n            }\n        }\n    }\n}\n\nexport function Convert_flatteFable3Map(tree) {\n    return toList(delay(() => {\n        let matchValue, key, value;\n        return append((matchValue = [tryFind(\"k\", tree), tryFind(\"v\", tree)], (matchValue[0] != null) ? ((matchValue[0].tag === 1) ? ((matchValue[1] != null) ? ((key = matchValue[0].fields[0], (value = matchValue[1], singleton_1([key, value])))) : ((empty_1()))) : ((empty_1()))) : ((empty_1()))), delay(() => {\n            let matchValue_1, left;\n            return append((matchValue_1 = tryFind(\"left\", tree), (matchValue_1 != null) ? ((matchValue_1.tag === 5) ? ((left = matchValue_1.fields[0], Convert_flatteFable3Map(left))) : ((empty_1()))) : ((empty_1()))), delay(() => {\n                const matchValue_2 = tryFind(\"right\", tree);\n                let pattern_matching_result, right;\n                if (matchValue_2 != null) {\n                    if (matchValue_2.tag === 5) {\n                        pattern_matching_result = 0;\n                        right = matchValue_2.fields[0];\n                    }\n                    else {\n                        pattern_matching_result = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n                switch (pattern_matching_result) {\n                    case 0: {\n                        return Convert_flatteFable3Map(right);\n                    }\n                    case 1: {\n                        return empty_1();\n                    }\n                }\n            }));\n        }));\n    }));\n}\n\nexport function Convert_flattenFable3Lists(linkedList) {\n    return toList(delay(() => {\n        let matchValue;\n        return append((matchValue = tryFind(\"head\", linkedList), (matchValue == null) ? ((empty_1())) : singleton_1(matchValue)), delay(() => {\n            const matchValue_1 = tryFind(\"tail\", linkedList);\n            let pattern_matching_result, tail;\n            if (matchValue_1 != null) {\n                if (matchValue_1.tag === 5) {\n                    pattern_matching_result = 0;\n                    tail = matchValue_1.fields[0];\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n            }\n            else {\n                pattern_matching_result = 1;\n            }\n            switch (pattern_matching_result) {\n                case 0: {\n                    return Convert_flattenFable3Lists(tail);\n                }\n                case 1: {\n                    return empty_1();\n                }\n            }\n        }));\n    }));\n}\n\nexport function Convert_arrayLike(_arg1) {\n    switch (_arg1.tag) {\n        case 29: {\n            return true;\n        }\n        case 27: {\n            return true;\n        }\n        case 30: {\n            return true;\n        }\n        case 31: {\n            return true;\n        }\n        case 28: {\n            return true;\n        }\n        case 34: {\n            return true;\n        }\n        case 35: {\n            return true;\n        }\n        default: {\n            return false;\n        }\n    }\n}\n\nexport function Convert_isRecord(_arg1) {\n    if (_arg1.tag === 38) {\n        return true;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Convert_unionOfRecords(_arg1) {\n    if (_arg1.tag === 39) {\n        return forAll((case$) => {\n            if (case$.CaseTypes.length === 1) {\n                return Convert_isRecord(case$.CaseTypes[0]);\n            }\n            else {\n                return false;\n            }\n        }, _arg1.fields[0]()[0]);\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Convert_optional(_arg1) {\n    if (_arg1.tag === 26) {\n        return true;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Convert_isQuoted(input) {\n    if (input.indexOf(\"\\\"\") === 0) {\n        return endsWith(input, \"\\\"\");\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Convert_betweenQuotes(input) {\n    return (\"\\\"\" + input) + \"\\\"\";\n}\n\nexport function Convert_removeQuotes(input) {\n    return substring(input, 1, input.length - 2);\n}\n\nexport function Convert_fromJsonAs(input_mut, typeInfo_mut) {\n    let foundCase, foundCase_2, testExpr, values_8, tree_2, tree;\n    Convert_fromJsonAs:\n    while (true) {\n        const input = input_mut, typeInfo = typeInfo_mut;\n        const matchValue = [input, typeInfo];\n        let pattern_matching_result, value_1;\n        if (matchValue[0].tag === 0) {\n            if (matchValue[1].tag === 9) {\n                pattern_matching_result = 0;\n                value_1 = matchValue[0].fields[0];\n            }\n            else {\n                pattern_matching_result = 2;\n            }\n        }\n        else if (matchValue[0].tag === 1) {\n            if (matchValue[1].tag === 9) {\n                if (matchValue[0].fields[0].toLocaleLowerCase() === \"nan\") {\n                    pattern_matching_result = 1;\n                }\n                else {\n                    pattern_matching_result = 2;\n                }\n            }\n            else {\n                pattern_matching_result = 2;\n            }\n        }\n        else {\n            pattern_matching_result = 2;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return value_1;\n            }\n            case 1: {\n                return NaN;\n            }\n            case 2: {\n                let pattern_matching_result_1, value_4, value_5;\n                if (matchValue[0].tag === 1) {\n                    if (matchValue[1].tag === 9) {\n                        pattern_matching_result_1 = 0;\n                        value_4 = matchValue[0].fields[0];\n                    }\n                    else if (matchValue[1].tag === 8) {\n                        if (matchValue[0].fields[0].toLocaleLowerCase() === \"nan\") {\n                            pattern_matching_result_1 = 2;\n                        }\n                        else {\n                            pattern_matching_result_1 = 3;\n                        }\n                    }\n                    else {\n                        pattern_matching_result_1 = 3;\n                    }\n                }\n                else if (matchValue[0].tag === 0) {\n                    if (matchValue[1].tag === 8) {\n                        pattern_matching_result_1 = 1;\n                        value_5 = matchValue[0].fields[0];\n                    }\n                    else {\n                        pattern_matching_result_1 = 3;\n                    }\n                }\n                else {\n                    pattern_matching_result_1 = 3;\n                }\n                switch (pattern_matching_result_1) {\n                    case 0: {\n                        return parse(value_4);\n                    }\n                    case 1: {\n                        return value_5;\n                    }\n                    case 2: {\n                        return NaN;\n                    }\n                    case 3: {\n                        let pattern_matching_result_2, value_7, value_8, value_9, value_10, value_11, value_12, value_13, value_14, value_15, value_16, value_17, value_18, value_19, value_20, value_21, value_22, value_23, value_24, value_25, getlElemType, value_26, getElemType, value_27, getElemType_1, value_28, genericJson, value_29, value_30, value_31, value_32, value_33, value_34, value_35, value_36, value_37, value_38, value_39, value_40, getTypes, values, jsonValue_5, optionalTypeDelayed_5;\n                        if (matchValue[0].tag === 1) {\n                            if (matchValue[1].tag === 8) {\n                                pattern_matching_result_2 = 0;\n                                value_7 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 6) {\n                                pattern_matching_result_2 = 3;\n                                value_10 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 1) {\n                                pattern_matching_result_2 = 4;\n                                value_11 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 2) {\n                                pattern_matching_result_2 = 6;\n                                value_13 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 10) {\n                                pattern_matching_result_2 = 8;\n                                value_15 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 11) {\n                                pattern_matching_result_2 = 10;\n                                value_17 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 3) {\n                                pattern_matching_result_2 = 13;\n                                value_20 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 4) {\n                                pattern_matching_result_2 = 15;\n                                value_22 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 5) {\n                                pattern_matching_result_2 = 17;\n                                value_24 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 37) {\n                                pattern_matching_result_2 = 19;\n                                getlElemType = matchValue[1].fields[0];\n                                value_26 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 29) {\n                                pattern_matching_result_2 = 21;\n                                getElemType_1 = matchValue[1].fields[0];\n                                value_28 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 22) {\n                                pattern_matching_result_2 = 24;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 12) {\n                                pattern_matching_result_2 = 25;\n                                value_29 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 13) {\n                                pattern_matching_result_2 = 26;\n                                value_30 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 14) {\n                                pattern_matching_result_2 = 29;\n                                value_33 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 19) {\n                                pattern_matching_result_2 = 30;\n                                value_34 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 15) {\n                                pattern_matching_result_2 = 32;\n                                value_36 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 16) {\n                                pattern_matching_result_2 = 33;\n                                value_37 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 18) {\n                                pattern_matching_result_2 = 36;\n                                value_40 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 26) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 39;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 40;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 40;\n                            }\n                        }\n                        else if (matchValue[0].tag === 0) {\n                            if (matchValue[1].tag === 6) {\n                                pattern_matching_result_2 = 1;\n                                value_8 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 1) {\n                                pattern_matching_result_2 = 5;\n                                value_12 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 2) {\n                                pattern_matching_result_2 = 7;\n                                value_14 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 10) {\n                                pattern_matching_result_2 = 9;\n                                value_16 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 11) {\n                                pattern_matching_result_2 = 11;\n                                value_18 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 3) {\n                                pattern_matching_result_2 = 12;\n                                value_19 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 4) {\n                                pattern_matching_result_2 = 14;\n                                value_21 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 5) {\n                                pattern_matching_result_2 = 16;\n                                value_23 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 20) {\n                                pattern_matching_result_2 = 18;\n                                value_25 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 37) {\n                                pattern_matching_result_2 = 20;\n                                getElemType = matchValue[1].fields[0];\n                                value_27 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 22) {\n                                pattern_matching_result_2 = 24;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 13) {\n                                pattern_matching_result_2 = 27;\n                                value_31 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 14) {\n                                pattern_matching_result_2 = 28;\n                                value_32 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 19) {\n                                pattern_matching_result_2 = 31;\n                                value_35 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 16) {\n                                pattern_matching_result_2 = 34;\n                                value_38 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 17) {\n                                pattern_matching_result_2 = 35;\n                                value_39 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 26) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 39;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 40;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 40;\n                            }\n                        }\n                        else if (matchValue[0].tag === 2) {\n                            if (matchValue[1].tag === 7) {\n                                pattern_matching_result_2 = 2;\n                                value_9 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 22) {\n                                pattern_matching_result_2 = 24;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 26) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 39;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 40;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 40;\n                            }\n                        }\n                        else if (matchValue[0].tag === 3) {\n                            if (matchValue[1].tag === 2) {\n                                pattern_matching_result_2 = 22;\n                            }\n                            else if (matchValue[1].tag === 0) {\n                                pattern_matching_result_2 = 23;\n                            }\n                            else if (matchValue[1].tag === 22) {\n                                pattern_matching_result_2 = 24;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 26) {\n                                pattern_matching_result_2 = 38;\n                            }\n                            else {\n                                pattern_matching_result_2 = 40;\n                            }\n                        }\n                        else if (matchValue[0].tag === 5) {\n                            if (matchValue[1].tag === 22) {\n                                pattern_matching_result_2 = 24;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 39) {\n                                pattern_matching_result_2 = 37;\n                                getTypes = matchValue[1].fields[0];\n                                values = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 26) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 39;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 40;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 40;\n                            }\n                        }\n                        else if (matchValue[1].tag === 22) {\n                            pattern_matching_result_2 = 24;\n                            genericJson = matchValue[0];\n                        }\n                        else if (matchValue[1].tag === 26) {\n                            if (!equals(matchValue[0], new Json(3))) {\n                                pattern_matching_result_2 = 39;\n                                jsonValue_5 = matchValue[0];\n                                optionalTypeDelayed_5 = matchValue[1].fields[0];\n                            }\n                            else {\n                                pattern_matching_result_2 = 40;\n                            }\n                        }\n                        else {\n                            pattern_matching_result_2 = 40;\n                        }\n                        switch (pattern_matching_result_2) {\n                            case 0: {\n                                return parse(value_7);\n                            }\n                            case 1: {\n                                return Math.floor(value_8);\n                            }\n                            case 2: {\n                                return value_9;\n                            }\n                            case 3: {\n                                return parse_1(value_10, 511, false, 32);\n                            }\n                            case 4: {\n                                return value_11;\n                            }\n                            case 5: {\n                                return String.fromCharCode(value_12);\n                            }\n                            case 6: {\n                                return value_13;\n                            }\n                            case 7: {\n                                return value_14.toString();\n                            }\n                            case 8: {\n                                return new Decimal(value_15);\n                            }\n                            case 9: {\n                                return new Decimal(value_16);\n                            }\n                            case 10: {\n                                return parse_1(value_17, 511, false, 16);\n                            }\n                            case 11: {\n                                return (value_18 + 0x8000 & 0xFFFF) - 0x8000;\n                            }\n                            case 12: {\n                                return value_19 & 0xFFFF;\n                            }\n                            case 13: {\n                                return parse_1(value_20, 511, true, 16);\n                            }\n                            case 14: {\n                                return value_21 >>> 0;\n                            }\n                            case 15: {\n                                return parse_1(value_22, 511, true, 32);\n                            }\n                            case 16: {\n                                return fromNumber(value_23, true);\n                            }\n                            case 17: {\n                                return parse_2(value_24, 511, true, 64);\n                            }\n                            case 18: {\n                                return Math.floor(value_25);\n                            }\n                            case 19: {\n                                const patternInput = getlElemType();\n                                const underlyingType = patternInput[0];\n                                const originalType = patternInput[1];\n                                switch (underlyingType.tag) {\n                                    case 6: {\n                                        let matchValue_1;\n                                        let outArg = 0;\n                                        matchValue_1 = [tryParse(value_26, 511, false, 32, new FSharpRef(() => outArg, (v) => {\n                                            outArg = (v | 0);\n                                        })), outArg];\n                                        if (matchValue_1[0]) {\n                                            return matchValue_1[1];\n                                        }\n                                        else {\n                                            const arg20 = name_2(originalType);\n                                            return toFail(printf(\"The value \\u0027%s\\u0027 is not valid for enum of type \\u0027%s\\u0027\"))(value_26)(arg20);\n                                        }\n                                    }\n                                    case 12: {\n                                        let matchValue_2;\n                                        let outArg_1 = fromInt(0);\n                                        matchValue_2 = [tryParse_1(value_26, 511, false, 64, new FSharpRef(() => outArg_1, (v_1) => {\n                                            outArg_1 = v_1;\n                                        })), outArg_1];\n                                        if (matchValue_2[0]) {\n                                            return matchValue_2[1];\n                                        }\n                                        else {\n                                            const arg20_1 = name_2(originalType);\n                                            return toFail(printf(\"The value \\u0027%s\\u0027 is not valid for enum of type \\u0027%s\\u0027\"))(value_26)(arg20_1);\n                                        }\n                                    }\n                                    default: {\n                                        const arg20_2 = name_2(originalType);\n                                        return toFail(printf(\"The value \\u0027%s\\u0027 cannot be converted to enum of type \\u0027%s\\u0027\"))(value_26)(arg20_2);\n                                    }\n                                }\n                            }\n                            case 20: {\n                                const patternInput_1 = getElemType();\n                                return value_27;\n                            }\n                            case 21: {\n                                const elemType = getElemType_1();\n                                if (elemType.tag === 13) {\n                                    if ((typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope) ? true : Convert_insideBrowser) {\n                                        return fromBase64String(value_28);\n                                    }\n                                    else {\n                                        return Array.prototype.slice.call(Buffer.from(value_28, 'base64'));\n                                    }\n                                }\n                                else {\n                                    return toFail(printf(\"Cannot convert arbitrary string \\u0027%s\\u0027 to %A\"))(value_28)(elemType);\n                                }\n                            }\n                            case 22: {\n                                return null;\n                            }\n                            case 23: {\n                                return void 0;\n                            }\n                            case 24: {\n                                return SimpleJson_toPlainObject(genericJson);\n                            }\n                            case 25: {\n                                return parse_2(value_29, 511, false, 64);\n                            }\n                            case 26: {\n                                return parse_1(value_30, 511, true, 8);\n                            }\n                            case 27: {\n                                return value_31 & 0xFF;\n                            }\n                            case 28: {\n                                return (value_32 + 0x80 & 0xFF) - 0x80;\n                            }\n                            case 29: {\n                                return parse_1(value_33, 511, false, 8);\n                            }\n                            case 30: {\n                                return parse_3(value_34);\n                            }\n                            case 31: {\n                                return fromInt32(Math.floor(value_35));\n                            }\n                            case 32: {\n                                return parse_4(value_36);\n                            }\n                            case 33: {\n                                return parse_5(value_37);\n                            }\n                            case 34: {\n                                return DateOffset(toNumber(fromNumber(Math.floor(value_38), false)) * 1000, 0);\n                            }\n                            case 35: {\n                                return fromDayNumber(~(~value_39));\n                            }\n                            case 36: {\n                                return create(parse_2(value_40, 511, false, 64));\n                            }\n                            case 37: {\n                                const patternInput_2 = getTypes();\n                                const unionType = patternInput_2[1];\n                                const cases = patternInput_2[0];\n                                const matchValue_3 = toList_1(values);\n                                let pattern_matching_result_3, caseName, values_1, caseName_1, json;\n                                if (!isEmpty(matchValue_3)) {\n                                    if (head(matchValue_3)[1].tag === 4) {\n                                        if (isEmpty(tail_1(matchValue_3))) {\n                                            pattern_matching_result_3 = 0;\n                                            caseName = head(matchValue_3)[0];\n                                            values_1 = head(matchValue_3)[1].fields[0];\n                                        }\n                                        else {\n                                            pattern_matching_result_3 = 2;\n                                        }\n                                    }\n                                    else {\n                                        const activePatternResult2901 = Convert_$007CNonArray$007C_$007C(head(matchValue_3)[1]);\n                                        if (activePatternResult2901 != null) {\n                                            if (isEmpty(tail_1(matchValue_3))) {\n                                                pattern_matching_result_3 = 1;\n                                                caseName_1 = head(matchValue_3)[0];\n                                                json = activePatternResult2901;\n                                            }\n                                            else {\n                                                pattern_matching_result_3 = 2;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result_3 = 2;\n                                        }\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result_3 = 2;\n                                }\n                                switch (pattern_matching_result_3) {\n                                    case 0: {\n                                        const _arg1 = tryFind_1((case$) => (case$.CaseName === caseName), cases);\n                                        if (_arg1 != null) {\n                                            if ((foundCase = _arg1, (foundCase.CaseTypes.length === 1) && Convert_arrayLike(foundCase.CaseTypes[0]))) {\n                                                const foundCase_1 = _arg1;\n                                                return makeUnion(foundCase_1.Info, [Convert_fromJsonAs(new Json(4, values_1), foundCase_1.CaseTypes[0])]);\n                                            }\n                                            else {\n                                                let pattern_matching_result_4, foundCase_3;\n                                                if (_arg1 != null) {\n                                                    if ((foundCase_2 = _arg1, (foundCase_2.CaseTypes.length === 1) && Convert_optional(foundCase_2.CaseTypes[0]))) {\n                                                        pattern_matching_result_4 = 0;\n                                                        foundCase_3 = _arg1;\n                                                    }\n                                                    else {\n                                                        pattern_matching_result_4 = 1;\n                                                    }\n                                                }\n                                                else {\n                                                    pattern_matching_result_4 = 1;\n                                                }\n                                                switch (pattern_matching_result_4) {\n                                                    case 0: {\n                                                        return makeUnion(foundCase_3.Info, [Convert_fromJsonAs(new Json(4, values_1), foundCase_3.CaseTypes[0])]);\n                                                    }\n                                                    case 1: {\n                                                        if (_arg1 != null) {\n                                                            const foundCase_4 = _arg1;\n                                                            if (((foundCase_4.CaseTypes.length === 1) && (!Convert_arrayLike(foundCase_4.CaseTypes[0]))) && (foundCase_4.CaseTypes.length !== length(values_1))) {\n                                                                const arg30_1 = length(values_1) | 0;\n                                                                const arg20_5 = foundCase_4.CaseTypes.length | 0;\n                                                                toFail(printf(\"Expected case \\u0027%s\\u0027 to have %d argument types but the JSON data only contained %d values\"))(foundCase_4.CaseName)(arg20_5)(arg30_1);\n                                                            }\n                                                            return makeUnion(foundCase_4.Info, map_2((tupledArg) => Convert_fromJsonAs(tupledArg[1], tupledArg[0]), zip(foundCase_4.CaseTypes, toArray(values_1))));\n                                                        }\n                                                        else {\n                                                            throw (new Error(\"Match failure\"));\n                                                        }\n                                                    }\n                                                }\n                                            }\n                                        }\n                                        else {\n                                            const expectedCases = join(\", \", map_2((case$_1) => toText(printf(\" \\u0027%s\\u0027 \"))(case$_1.CaseName), cases));\n                                            const arg20_4 = name_2(unionType);\n                                            return toFail(printf(\"Case %s was not valid for type \\u0027%s\\u0027, expected one of the cases [%s]\"))(caseName)(arg20_4)(expectedCases);\n                                        }\n                                    }\n                                    case 1: {\n                                        const _arg2 = tryFind_1((case$_2) => (case$_2.CaseName === caseName_1), cases);\n                                        let pattern_matching_result_5, caseInfo, caseName_2, caseType;\n                                        if (_arg2 != null) {\n                                            if ((testExpr = _arg2.CaseTypes, (!equalsWith((x, y) => equals(x, y), testExpr, null)) && (testExpr.length === 1))) {\n                                                pattern_matching_result_5 = 0;\n                                                caseInfo = _arg2.Info;\n                                                caseName_2 = _arg2.CaseName;\n                                                caseType = _arg2.CaseTypes[0];\n                                            }\n                                            else {\n                                                pattern_matching_result_5 = 1;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result_5 = 1;\n                                        }\n                                        switch (pattern_matching_result_5) {\n                                            case 0: {\n                                                return makeUnion(caseInfo, [((input_1) => ((typeInfo_1) => Convert_fromJsonAs(input_1, typeInfo_1)))(json)(caseType)]);\n                                            }\n                                            case 1: {\n                                                const expectedCases_1 = join(\", \", map_2((case$_3) => toText(printf(\" \\u0027%s\\u0027 \"))(case$_3.CaseName), cases));\n                                                const arg20_7 = name_2(unionType);\n                                                return toFail(printf(\"Case %s was not valid for type \\u0027%s\\u0027, expected one of the cases [%s]\"))(caseName_1)(arg20_7)(expectedCases_1);\n                                            }\n                                        }\n                                    }\n                                    case 2: {\n                                        if ((containsKey(\"tag\", values) && containsKey(\"fields\", values)) && (count(values) === 2)) {\n                                            const matchValue_4 = [tryFind(\"tag\", values), tryFind(\"fields\", values)];\n                                            let pattern_matching_result_6, caseIndex, fieldValues;\n                                            if (matchValue_4[0] != null) {\n                                                if (matchValue_4[0].tag === 0) {\n                                                    if (matchValue_4[1] != null) {\n                                                        if (matchValue_4[1].tag === 4) {\n                                                            pattern_matching_result_6 = 0;\n                                                            caseIndex = matchValue_4[0].fields[0];\n                                                            fieldValues = matchValue_4[1].fields[0];\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_6 = 1;\n                                                        }\n                                                    }\n                                                    else {\n                                                        pattern_matching_result_6 = 1;\n                                                    }\n                                                }\n                                                else {\n                                                    pattern_matching_result_6 = 1;\n                                                }\n                                            }\n                                            else {\n                                                pattern_matching_result_6 = 1;\n                                            }\n                                            switch (pattern_matching_result_6) {\n                                                case 0: {\n                                                    const foundCase_5 = cases[~(~caseIndex)];\n                                                    return makeUnion(foundCase_5.Info, mapIndexed((index, value_46) => Convert_fromJsonAs(value_46, foundCase_5.CaseTypes[index]), toArray(fieldValues)));\n                                                }\n                                                case 1: {\n                                                    const arg20_8 = fullName(unionType);\n                                                    const arg10_10 = SimpleJson_toString(new Json(5, values));\n                                                    return toFail(printf(\"Could not deserialize JSON(%s) into type %s\"))(arg10_10)(arg20_8);\n                                                }\n                                            }\n                                        }\n                                        else if (Convert_unionOfRecords(typeInfo)) {\n                                            const foundDiscriminatorKey = tryFind_2((keyword) => containsKey(keyword, values), ofArray([\"__typename\", \"$typename\", \"$type\"]));\n                                            if (foundDiscriminatorKey != null) {\n                                                const discriminatorValueJson = find(foundDiscriminatorKey, values);\n                                                if (discriminatorValueJson.tag === 1) {\n                                                    const discriminatorValue = discriminatorValueJson.fields[0];\n                                                    const foundUnionCase = tryFind_3((case$_4) => (case$_4.CaseName.toUpperCase() === discriminatorValue.toUpperCase()), cases);\n                                                    if (foundUnionCase != null) {\n                                                        const case$_5 = foundUnionCase;\n                                                        return makeUnion(case$_5.Info, [Convert_fromJsonAs(new Json(5, values), case$_5.CaseTypes[0])]);\n                                                    }\n                                                    else {\n                                                        const arg10_12 = name_2(unionType);\n                                                        return toFail(printf(\"Union of records of type \\u0027%s\\u0027 does not have a matching case \\u0027%s\\u0027\"))(arg10_12)(discriminatorValue);\n                                                    }\n                                                }\n                                                else {\n                                                    const arg10_13 = name_2(unionType);\n                                                    return toFail(printf(\"Union of records of type \\u0027%s\\u0027 cannot be deserialized with the value of the discriminator key is not a string to match against a specific union case\"))(arg10_13);\n                                                }\n                                            }\n                                            else {\n                                                const arg10_11 = name_2(unionType);\n                                                return toFail(printf(\"Could not serialize the JSON object into the union of records of type %s because the JSON did not contain a known discriminator. Expected \\u0027__typename\\u0027, \\u0027$typeName\\u0027 or \\u0027$type\\u0027\"))(arg10_11);\n                                            }\n                                        }\n                                        else {\n                                            const unexpectedJson = JSON.stringify(matchValue_3);\n                                            const expectedType = JSON.stringify(cases);\n                                            return toFail(printf(\"Expected JSON:\\n%s\\nto match the type\\n%s\"))(unexpectedJson)(expectedType);\n                                        }\n                                    }\n                                }\n                            }\n                            case 38: {\n                                return void 0;\n                            }\n                            case 39: {\n                                return ((arg0) => some(arg0))(Convert_fromJsonAs(jsonValue_5, optionalTypeDelayed_5()));\n                            }\n                            case 40: {\n                                let pattern_matching_result_7, value_47, value_48, dict, caseName_4, getTypes_2;\n                                if (matchValue[0].tag === 1) {\n                                    if (matchValue[1].tag === 21) {\n                                        pattern_matching_result_7 = 0;\n                                        value_47 = matchValue[0].fields[0];\n                                    }\n                                    else if (matchValue[1].tag === 39) {\n                                        if (Convert_isQuoted(matchValue[0].fields[0])) {\n                                            pattern_matching_result_7 = 3;\n                                            caseName_4 = matchValue[0].fields[0];\n                                            getTypes_2 = matchValue[1].fields[0];\n                                        }\n                                        else {\n                                            pattern_matching_result_7 = 4;\n                                        }\n                                    }\n                                    else {\n                                        pattern_matching_result_7 = 4;\n                                    }\n                                }\n                                else if (matchValue[0].tag === 0) {\n                                    if (matchValue[1].tag === 12) {\n                                        pattern_matching_result_7 = 1;\n                                        value_48 = matchValue[0].fields[0];\n                                    }\n                                    else {\n                                        pattern_matching_result_7 = 4;\n                                    }\n                                }\n                                else if (matchValue[0].tag === 5) {\n                                    if (matchValue[1].tag === 12) {\n                                        pattern_matching_result_7 = 2;\n                                        dict = matchValue[0].fields[0];\n                                    }\n                                    else {\n                                        pattern_matching_result_7 = 4;\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result_7 = 4;\n                                }\n                                switch (pattern_matching_result_7) {\n                                    case 0: {\n                                        return parse_6(value_47);\n                                    }\n                                    case 1: {\n                                        return ((value_49) => fromInteger(value_49, false, 2))(~(~value_48));\n                                    }\n                                    case 2: {\n                                        const get$ = (key) => tryFind(key, dict);\n                                        const _arg3 = choose((x_1) => x_1, ofArray([get$(\"low\"), get$(\"high\"), get$(\"unsigned\")]));\n                                        let pattern_matching_result_8, high, low;\n                                        if (!isEmpty(_arg3)) {\n                                            if (head(_arg3).tag === 0) {\n                                                if (!isEmpty(tail_1(_arg3))) {\n                                                    if (head(tail_1(_arg3)).tag === 0) {\n                                                        if (!isEmpty(tail_1(tail_1(_arg3)))) {\n                                                            if (head(tail_1(tail_1(_arg3))).tag === 2) {\n                                                                if (isEmpty(tail_1(tail_1(tail_1(_arg3))))) {\n                                                                    pattern_matching_result_8 = 0;\n                                                                    high = head(tail_1(_arg3)).fields[0];\n                                                                    low = head(_arg3).fields[0];\n                                                                }\n                                                                else {\n                                                                    pattern_matching_result_8 = 1;\n                                                                }\n                                                            }\n                                                            else {\n                                                                pattern_matching_result_8 = 1;\n                                                            }\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_8 = 1;\n                                                        }\n                                                    }\n                                                    else {\n                                                        pattern_matching_result_8 = 1;\n                                                    }\n                                                }\n                                                else {\n                                                    pattern_matching_result_8 = 1;\n                                                }\n                                            }\n                                            else {\n                                                pattern_matching_result_8 = 1;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result_8 = 1;\n                                        }\n                                        switch (pattern_matching_result_8) {\n                                            case 0: {\n                                                return toInt64(concat([getBytesInt32(~(~low)), getBytesInt32(~(~high))], Uint8Array), 0);\n                                            }\n                                            case 1: {\n                                                return toFail(printf(\"Unable to construct int64 from object literal { low: int, high: int, unsigned: bool }\"));\n                                            }\n                                        }\n                                    }\n                                    case 3: {\n                                        const patternInput_3 = getTypes_2();\n                                        const caseTypes = patternInput_3[0];\n                                        const _arg4 = tryFind_1((case$_6) => (case$_6.CaseName === Convert_removeQuotes(caseName_4)), caseTypes);\n                                        if (_arg4 == null) {\n                                            const expectedCases_2 = join(\", \", map_2((case$_7) => toText(printf(\" \\u0027%s\\u0027 \"))(case$_7.CaseName), caseTypes));\n                                            const arg20_11 = name_2(patternInput_3[1]);\n                                            return toFail(printf(\"Case %s was not valid for type \\u0027%s\\u0027, expected one of the cases [%s]\"))(caseName_4)(arg20_11)(expectedCases_2);\n                                        }\n                                        else {\n                                            return makeUnion(_arg4.Info, []);\n                                        }\n                                    }\n                                    case 4: {\n                                        let pattern_matching_result_9, caseName_5, getTypes_3, getFields, serializedRecord, caseValue, getTypes_4, elementTypeDelayed, values_4, elementTypeDelayed_1, values_5, elementTypeDelayed_2, linkedList, elementTypeDelayed_3, values_6, elementTypeDelayed_4, values_7, array_9, tupleTypesDelayed, dict_1, getTypes_5, getTypes_6, tuples, getTypes_7, tuples_1, dict_2, getTypes_8, getType, items, getTypes_9, map, getType_1;\n                                        if (matchValue[0].tag === 1) {\n                                            if (matchValue[1].tag === 39) {\n                                                pattern_matching_result_9 = 0;\n                                                caseName_5 = matchValue[0].fields[0];\n                                                getTypes_3 = matchValue[1].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 38) {\n                                                pattern_matching_result_9 = 1;\n                                                getFields = matchValue[1].fields[0];\n                                                serializedRecord = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 23) {\n                                                pattern_matching_result_9 = 15;\n                                                getType_1 = matchValue[1].fields[0];\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 16;\n                                            }\n                                        }\n                                        else if (matchValue[0].tag === 4) {\n                                            if (matchValue[1].tag === 39) {\n                                                pattern_matching_result_9 = 2;\n                                                caseValue = matchValue[0].fields[0];\n                                                getTypes_4 = matchValue[1].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 29) {\n                                                pattern_matching_result_9 = 3;\n                                                elementTypeDelayed = matchValue[1].fields[0];\n                                                values_4 = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 27) {\n                                                pattern_matching_result_9 = 4;\n                                                elementTypeDelayed_1 = matchValue[1].fields[0];\n                                                values_5 = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 28) {\n                                                pattern_matching_result_9 = 6;\n                                                elementTypeDelayed_3 = matchValue[1].fields[0];\n                                                values_6 = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 30) {\n                                                pattern_matching_result_9 = 7;\n                                                elementTypeDelayed_4 = matchValue[1].fields[0];\n                                                values_7 = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 31) {\n                                                pattern_matching_result_9 = 8;\n                                                array_9 = matchValue[0].fields[0];\n                                                tupleTypesDelayed = matchValue[1].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 32) {\n                                                pattern_matching_result_9 = 10;\n                                                getTypes_6 = matchValue[1].fields[0];\n                                                tuples = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 33) {\n                                                pattern_matching_result_9 = 11;\n                                                getTypes_7 = matchValue[1].fields[0];\n                                                tuples_1 = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 35) {\n                                                pattern_matching_result_9 = 13;\n                                                getType = matchValue[1].fields[0];\n                                                items = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 23) {\n                                                pattern_matching_result_9 = 15;\n                                                getType_1 = matchValue[1].fields[0];\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 16;\n                                            }\n                                        }\n                                        else if (matchValue[0].tag === 5) {\n                                            if (matchValue[1].tag === 27) {\n                                                pattern_matching_result_9 = 5;\n                                                elementTypeDelayed_2 = matchValue[1].fields[0];\n                                                linkedList = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 38) {\n                                                pattern_matching_result_9 = 9;\n                                                dict_1 = matchValue[0].fields[0];\n                                                getTypes_5 = matchValue[1].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 33) {\n                                                pattern_matching_result_9 = 12;\n                                                dict_2 = matchValue[0].fields[0];\n                                                getTypes_8 = matchValue[1].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 32) {\n                                                pattern_matching_result_9 = 14;\n                                                getTypes_9 = matchValue[1].fields[0];\n                                                map = matchValue[0].fields[0];\n                                            }\n                                            else if (matchValue[1].tag === 23) {\n                                                pattern_matching_result_9 = 15;\n                                                getType_1 = matchValue[1].fields[0];\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 16;\n                                            }\n                                        }\n                                        else if (matchValue[1].tag === 23) {\n                                            pattern_matching_result_9 = 15;\n                                            getType_1 = matchValue[1].fields[0];\n                                        }\n                                        else {\n                                            pattern_matching_result_9 = 16;\n                                        }\n                                        switch (pattern_matching_result_9) {\n                                            case 0: {\n                                                const patternInput_4 = getTypes_3();\n                                                const caseTypes_1 = patternInput_4[0];\n                                                const _arg5 = tryFind_1((case$_8) => (case$_8.CaseName === caseName_5), caseTypes_1);\n                                                if (_arg5 == null) {\n                                                    const expectedCases_3 = join(\", \", map_2((case$_9) => toText(printf(\" \\u0027%s\\u0027 \"))(case$_9.CaseName), caseTypes_1));\n                                                    const arg20_12 = name_2(patternInput_4[1]);\n                                                    return toFail(printf(\"Case %s was not valid for type \\u0027%s\\u0027, expected one of the cases [%s]\"))(caseName_5)(arg20_12)(expectedCases_3);\n                                                }\n                                                else {\n                                                    return makeUnion(_arg5.Info, []);\n                                                }\n                                            }\n                                            case 1: {\n                                                input_mut = SimpleJson_parse(serializedRecord);\n                                                typeInfo_mut = typeInfo;\n                                                continue Convert_fromJsonAs;\n                                            }\n                                            case 2: {\n                                                const patternInput_5 = getTypes_4();\n                                                const cases_1 = patternInput_5[0];\n                                                let pattern_matching_result_10, caseName_6, caseName_8, values_3, otherwise_6;\n                                                if (!isEmpty(caseValue)) {\n                                                    if (head(caseValue).tag === 1) {\n                                                        if (isEmpty(tail_1(caseValue))) {\n                                                            pattern_matching_result_10 = 0;\n                                                            caseName_6 = head(caseValue).fields[0];\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_10 = 1;\n                                                            caseName_8 = head(caseValue).fields[0];\n                                                            values_3 = tail_1(caseValue);\n                                                        }\n                                                    }\n                                                    else {\n                                                        pattern_matching_result_10 = 2;\n                                                        otherwise_6 = caseValue;\n                                                    }\n                                                }\n                                                else {\n                                                    pattern_matching_result_10 = 2;\n                                                    otherwise_6 = caseValue;\n                                                }\n                                                switch (pattern_matching_result_10) {\n                                                    case 0: {\n                                                        const _arg6 = tryFind_1((case$_10) => (case$_10.CaseName === caseName_6), cases_1);\n                                                        if (_arg6 == null) {\n                                                            const expectedCases_4 = join(\", \", map_2((case$_11) => toText(printf(\" \\u0027%s\\u0027 \"))(case$_11.CaseName), cases_1));\n                                                            const arg20_13 = name_2(patternInput_5[1]);\n                                                            return toFail(printf(\"Case \\u0027%s\\u0027 was not valid for type \\u0027%s\\u0027, expected one of the cases [%s]\"))(caseName_6)(arg20_13)(expectedCases_4);\n                                                        }\n                                                        else {\n                                                            const caseName_7 = _arg6.CaseName;\n                                                            const caseInfoTypes = _arg6.CaseTypes;\n                                                            return makeUnion(_arg6.Info, []);\n                                                        }\n                                                    }\n                                                    case 1: {\n                                                        const _arg7 = tryFind_1((case$_12) => (case$_12.CaseName === caseName_8), cases_1);\n                                                        if (_arg7 != null) {\n                                                            const types = _arg7.CaseTypes;\n                                                            const foundCaseName = _arg7.CaseName;\n                                                            const caseInfo_4 = _arg7.Info;\n                                                            if (types.length !== length(values_3)) {\n                                                                toFail(printf(\"The number of union case parameters for \\u0027%s\\u0027 is different\"))(foundCaseName);\n                                                            }\n                                                            return makeUnion(caseInfo_4, map_2((tupledArg_1) => Convert_fromJsonAs(tupledArg_1[1], tupledArg_1[0]), zip(types, toArray(values_3))));\n                                                        }\n                                                        else {\n                                                            const expectedCases_5 = join(\", \", map_2((_arg1_1) => _arg1_1.CaseName, cases_1));\n                                                            return toFail(printf(\"Case %s was not valid, expected one of [%s]\"))(caseName_8)(expectedCases_5);\n                                                        }\n                                                    }\n                                                    case 2: {\n                                                        const unexpectedJson_1 = JSON.stringify(otherwise_6);\n                                                        const expectedType_1 = JSON.stringify(cases_1);\n                                                        return toFail(printf(\"Expected JSON:\\n%s\\nto match the type\\n%s\"))(unexpectedJson_1)(expectedType_1);\n                                                    }\n                                                }\n                                            }\n                                            case 3: {\n                                                const elementType = elementTypeDelayed();\n                                                return toArray(map_3((value_53) => Convert_fromJsonAs(value_53, elementType), values_4));\n                                            }\n                                            case 4: {\n                                                const elementType_1 = elementTypeDelayed_1();\n                                                return map_3((value_55) => Convert_fromJsonAs(value_55, elementType_1), values_5);\n                                            }\n                                            case 5: {\n                                                const elementType_2 = elementTypeDelayed_2();\n                                                return map_3((value_57) => Convert_fromJsonAs(value_57, elementType_2), Convert_flattenFable3Lists(linkedList));\n                                            }\n                                            case 6: {\n                                                const elementType_3 = elementTypeDelayed_3();\n                                                return ofList(map_3((value_59) => Convert_fromJsonAs(value_59, elementType_3), values_6), {\n                                                    Compare: (x_2, y_1) => compare(x_2, y_1),\n                                                });\n                                            }\n                                            case 7: {\n                                                const elementType_4 = elementTypeDelayed_4();\n                                                return map_3((value_61) => Convert_fromJsonAs(value_61, elementType_4), values_7);\n                                            }\n                                            case 8: {\n                                                return map_2((tupledArg_2) => Convert_fromJsonAs(tupledArg_2[1], tupledArg_2[0]), zip(tupleTypesDelayed(), toArray(array_9)));\n                                            }\n                                            case 9: {\n                                                const patternInput_6 = getTypes_5();\n                                                const recordType = patternInput_6[1];\n                                                const fields = patternInput_6[0];\n                                                return makeRecord(recordType, (values_8 = toList_1(dict_1), map_2((_arg3_1) => {\n                                                    const fieldType = _arg3_1.FieldType;\n                                                    const fieldName = _arg3_1.FieldName;\n                                                    const _arg8 = tryFind_2((tupledArg_3) => (fieldName === tupledArg_3[0]), values_8);\n                                                    if (_arg8 == null) {\n                                                        if (fieldType.tag === 26) {\n                                                            return void 0;\n                                                        }\n                                                        else {\n                                                            let dictKeys;\n                                                            const arg10_27 = join(\", \", map_3((arg) => toText(printf(\"\\u0027%s\\u0027\"))(arg[0]), toList_1(dict_1)));\n                                                            dictKeys = toText(printf(\"[ %s ]\"))(arg10_27);\n                                                            let recordFields;\n                                                            const arg10_30 = join(\", \", map_2((_arg2_1) => {\n                                                                const name_1 = _arg2_1.FieldName;\n                                                                if (_arg2_1.FieldType.tag === 26) {\n                                                                    return toText(printf(\"optional(\\u0027%s\\u0027)\"))(name_1);\n                                                                }\n                                                                else {\n                                                                    return toText(printf(\"required(\\u0027%s\\u0027)\"))(name_1);\n                                                                }\n                                                            }, fields));\n                                                            recordFields = toText(printf(\"[ %s ]\"))(arg10_30);\n                                                            const arg30_6 = name_2(recordType);\n                                                            return toFail(printf(\"Could not find the required key \\u0027%s\\u0027 in the JSON object literal with keys %s to match with record type \\u0027%s\\u0027 that has fields %s\"))(fieldName)(dictKeys)(arg30_6)(recordFields);\n                                                        }\n                                                    }\n                                                    else {\n                                                        const key_2 = _arg8[0];\n                                                        return Convert_fromJsonAs(_arg8[1], fieldType);\n                                                    }\n                                                }, fields)));\n                                            }\n                                            case 10: {\n                                                const patternInput_7 = getTypes_6();\n                                                const keyType = patternInput_7[0];\n                                                const pairs = toList(delay(() => collect((keyValuePair) => {\n                                                    let a;\n                                                    return singleton_1(Convert_fromJsonAs(keyValuePair, new TypeInfo(31, (a = [keyType, patternInput_7[1]], () => a))));\n                                                }, tuples)));\n                                                switch (keyType.tag) {\n                                                    case 6:\n                                                    case 2:\n                                                    case 7: {\n                                                        return ofList_1(pairs);\n                                                    }\n                                                    default: {\n                                                        return ofList_1(pairs);\n                                                    }\n                                                }\n                                            }\n                                            case 11: {\n                                                const patternInput_8 = getTypes_7();\n                                                const keyType_1 = patternInput_8[0];\n                                                const pairs_1 = toList(delay(() => collect((keyValuePair_1) => singleton_1(Convert_fromJsonAs(keyValuePair_1, new TypeInfo(31, () => [keyType_1, patternInput_8[1]]))), tuples_1)));\n                                                const output = (keyType_1.tag === 39) ? (new Dictionary([], {\n                                                    Equals: (x_3, y_2) => equals(x_3, y_2),\n                                                    GetHashCode: (x_3) => safeHash(x_3),\n                                                })) : ((keyType_1.tag === 38) ? (new Dictionary([], {\n                                                    Equals: (x_4, y_3) => equals(x_4, y_3),\n                                                    GetHashCode: (x_4) => structuralHash(x_4),\n                                                })) : (new Dictionary([], {\n                                                    Equals: (x_5, y_4) => equals(x_5, y_4),\n                                                    GetHashCode: (x_5) => structuralHash(x_5),\n                                                })));\n                                                const enumerator = getEnumerator(pairs_1);\n                                                try {\n                                                    while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                                                        const forLoopVar = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                                                        addToDict(output, forLoopVar[0], forLoopVar[1]);\n                                                    }\n                                                }\n                                                finally {\n                                                    enumerator.Dispose();\n                                                }\n                                                return output;\n                                            }\n                                            case 12: {\n                                                const patternInput_9 = getTypes_8();\n                                                const keyType_2 = patternInput_9[0];\n                                                const pairs_2 = map_3((tupledArg_4) => [Convert_fromJsonAs(new Json(1, tupledArg_4[0]), keyType_2), Convert_fromJsonAs(tupledArg_4[1], patternInput_9[1])], toList_1(dict_2));\n                                                const output_1 = (keyType_2.tag === 39) ? (new Dictionary([], {\n                                                    Equals: (x_6, y_5) => equals(x_6, y_5),\n                                                    GetHashCode: (x_6) => safeHash(x_6),\n                                                })) : ((keyType_2.tag === 38) ? (new Dictionary([], {\n                                                    Equals: (x_7, y_6) => equals(x_7, y_6),\n                                                    GetHashCode: (x_7) => structuralHash(x_7),\n                                                })) : (new Dictionary([], {\n                                                    Equals: (x_8, y_7) => equals(x_8, y_7),\n                                                    GetHashCode: (x_8) => structuralHash(x_8),\n                                                })));\n                                                const enumerator_1 = getEnumerator(pairs_2);\n                                                try {\n                                                    while (enumerator_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                                                        const forLoopVar_1 = enumerator_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                                                        addToDict(output_1, forLoopVar_1[0], forLoopVar_1[1]);\n                                                    }\n                                                }\n                                                finally {\n                                                    enumerator_1.Dispose();\n                                                }\n                                                return output_1;\n                                            }\n                                            case 13: {\n                                                const elemType_1 = getType();\n                                                const hashset = (elemType_1.tag === 39) ? (new HashSet([], {\n                                                    Equals: (x_9, y_8) => equals(x_9, y_8),\n                                                    GetHashCode: (x_9) => safeHash(x_9),\n                                                })) : ((elemType_1.tag === 38) ? (new HashSet([], {\n                                                    Equals: (x_10, y_9) => equals(x_10, y_9),\n                                                    GetHashCode: (x_10) => structuralHash(x_10),\n                                                })) : (new HashSet([], {\n                                                    Equals: (x_11, y_10) => equals(x_11, y_10),\n                                                    GetHashCode: (x_11) => structuralHash(x_11),\n                                                })));\n                                                const enumerator_2 = getEnumerator(items);\n                                                try {\n                                                    while (enumerator_2[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                                                        addToSet(Convert_fromJsonAs(enumerator_2[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), elemType_1), hashset);\n                                                    }\n                                                }\n                                                finally {\n                                                    enumerator_2.Dispose();\n                                                }\n                                                return hashset;\n                                            }\n                                            case 14: {\n                                                const patternInput_10 = getTypes_9();\n                                                const valueType_5 = patternInput_10[1];\n                                                const keyType_3 = patternInput_10[0];\n                                                const matchValue_5 = [tryFind(\"comparer\", map), tryFind(\"tree\", map)];\n                                                let pattern_matching_result_11, comparer_1, tree_1;\n                                                if (matchValue_5[0] != null) {\n                                                    if (matchValue_5[0].tag === 5) {\n                                                        if (matchValue_5[1] != null) {\n                                                            if (matchValue_5[1].tag === 4) {\n                                                                if ((tree = matchValue_5[1].fields[0], isEmpty_1(matchValue_5[0].fields[0]))) {\n                                                                    pattern_matching_result_11 = 0;\n                                                                    comparer_1 = matchValue_5[0].fields[0];\n                                                                    tree_1 = matchValue_5[1].fields[0];\n                                                                }\n                                                                else {\n                                                                    pattern_matching_result_11 = 1;\n                                                                }\n                                                            }\n                                                            else {\n                                                                pattern_matching_result_11 = 1;\n                                                            }\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_11 = 1;\n                                                        }\n                                                    }\n                                                    else {\n                                                        pattern_matching_result_11 = 1;\n                                                    }\n                                                }\n                                                else {\n                                                    pattern_matching_result_11 = 1;\n                                                }\n                                                switch (pattern_matching_result_11) {\n                                                    case 0: {\n                                                        const matchValue_6 = Convert_generateMap(new Json(4, tree_1));\n                                                        if (matchValue_6 == null) {\n                                                            const inputJson = SimpleJson_toString(new Json(4, tree_1));\n                                                            return toFail(printf(\"Could not generate map from JSON\\n %s\"))(inputJson);\n                                                        }\n                                                        else {\n                                                            const pairs_3 = map_3((tupledArg_5) => {\n                                                                const key_6 = tupledArg_5[0];\n                                                                return [(!Convert_isQuoted(key_6)) ? Convert_fromJsonAs(new Json(1, key_6), keyType_3) : Convert_fromJsonAs(SimpleJson_parseNative(key_6), keyType_3), Convert_fromJsonAs(tupledArg_5[1], valueType_5)];\n                                                            }, Convert_flattenMap(matchValue_6));\n                                                            switch (keyType_3.tag) {\n                                                                case 6:\n                                                                case 2:\n                                                                case 7: {\n                                                                    return ofList_1(pairs_3);\n                                                                }\n                                                                default: {\n                                                                    return ofList_1(pairs_3);\n                                                                }\n                                                            }\n                                                        }\n                                                    }\n                                                    case 1: {\n                                                        let pattern_matching_result_12, comparer_3, tree_3;\n                                                        if (matchValue_5[0] != null) {\n                                                            if (matchValue_5[0].tag === 5) {\n                                                                if (matchValue_5[1] != null) {\n                                                                    if (matchValue_5[1].tag === 5) {\n                                                                        if ((tree_2 = matchValue_5[1].fields[0], isEmpty_1(matchValue_5[0].fields[0]))) {\n                                                                            pattern_matching_result_12 = 0;\n                                                                            comparer_3 = matchValue_5[0].fields[0];\n                                                                            tree_3 = matchValue_5[1].fields[0];\n                                                                        }\n                                                                        else {\n                                                                            pattern_matching_result_12 = 1;\n                                                                        }\n                                                                    }\n                                                                    else {\n                                                                        pattern_matching_result_12 = 1;\n                                                                    }\n                                                                }\n                                                                else {\n                                                                    pattern_matching_result_12 = 1;\n                                                                }\n                                                            }\n                                                            else {\n                                                                pattern_matching_result_12 = 1;\n                                                            }\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_12 = 1;\n                                                        }\n                                                        switch (pattern_matching_result_12) {\n                                                            case 0: {\n                                                                input_mut = (new Json(5, ofList_1(Convert_flatteFable3Map(tree_3))));\n                                                                typeInfo_mut = typeInfo;\n                                                                continue Convert_fromJsonAs;\n                                                            }\n                                                            case 1: {\n                                                                const pairs_4 = map_3((tupledArg_6) => {\n                                                                    const key_7 = tupledArg_6[0];\n                                                                    return [(!Convert_isQuoted(key_7)) ? ((isPrimitive(keyType_3) ? true : enumUnion(keyType_3)) ? Convert_fromJsonAs(new Json(1, key_7), keyType_3) : Convert_fromJsonAs(SimpleJson_parseNative(key_7), keyType_3)) : Convert_fromJsonAs(SimpleJson_parseNative(key_7), keyType_3), Convert_fromJsonAs(tupledArg_6[1], valueType_5)];\n                                                                }, toList_1(map));\n                                                                switch (keyType_3.tag) {\n                                                                    case 6:\n                                                                    case 2:\n                                                                    case 7: {\n                                                                        return ofList_1(pairs_4);\n                                                                    }\n                                                                    default: {\n                                                                        return ofList_1(pairs_4);\n                                                                    }\n                                                                }\n                                                            }\n                                                        }\n                                                    }\n                                                }\n                                            }\n                                            case 15: {\n                                                const arg20_17 = fullName(getType_1());\n                                                const arg10_33 = SimpleJson_toString(input);\n                                                return toFail(printf(\"Cannot convert %s to %s\"))(arg10_33)(arg20_17);\n                                            }\n                                            case 16: {\n                                                const arg20_18 = JSON.stringify(typeInfo);\n                                                const arg10_34 = SimpleJson_toString(input);\n                                                return toFail(printf(\"Cannot convert %s to %s\"))(arg10_34)(arg20_18);\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        break;\n    }\n}\n\nexport function Convert_fromJson(json, typeInfo) {\n    return Convert_fromJsonAs(json, typeInfo);\n}\n\nexport const Convert_quoteText = quote;\n\nexport function Convert_serialize(value_mut, typeInfo_mut) {\n    let copyOfStruct, copyOfStruct_1, copyOfStruct_2, copyOfStruct_3, copyOfStruct_4;\n    Convert_serialize:\n    while (true) {\n        const value = value_mut, typeInfo = typeInfo_mut;\n        switch (typeInfo.tag) {\n            case 2: {\n                const content = value;\n                if (content == null) {\n                    return \"null\";\n                }\n                else {\n                    return Convert_quoteText(content);\n                }\n            }\n            case 0: {\n                return \"null\";\n            }\n            case 9:\n            case 8: {\n                if (Number.isNaN(value)) {\n                    return Convert_quoteText(\"NaN\");\n                }\n                else {\n                    return value.toString();\n                }\n            }\n            case 1: {\n                return Convert_quoteText(value);\n            }\n            case 13:\n            case 14:\n            case 3:\n            case 4:\n            case 11:\n            case 37:\n            case 20:\n            case 6: {\n                return int32ToString(value);\n            }\n            case 5:\n            case 12: {\n                return Convert_betweenQuotes(toString(value));\n            }\n            case 19: {\n                return Convert_betweenQuotes(toString_1(value));\n            }\n            case 10: {\n                return Convert_betweenQuotes(toString_2(value));\n            }\n            case 7: {\n                if (value) {\n                    return \"true\";\n                }\n                else {\n                    return \"false\";\n                }\n            }\n            case 21: {\n                return Convert_betweenQuotes((copyOfStruct = value, copyOfStruct));\n            }\n            case 15: {\n                return Convert_betweenQuotes((copyOfStruct_1 = value, toString_3(copyOfStruct_1, \"O\")));\n            }\n            case 16: {\n                return Convert_betweenQuotes((copyOfStruct_2 = value, toString_3(copyOfStruct_2, \"O\")));\n            }\n            case 17: {\n                return int32ToString((copyOfStruct_3 = value, dayNumber(copyOfStruct_3)));\n            }\n            case 18: {\n                return Convert_betweenQuotes(toString((copyOfStruct_4 = value, ticks(copyOfStruct_4))));\n            }\n            case 38: {\n                return (\"{\" + join(\", \", map_2((field) => {\n                    const arg20 = Convert_serialize(getRecordField(value, field.PropertyInfo), field.FieldType);\n                    return toText(printf(\"\\\"%s\\\": %s\"))(field.FieldName)(arg20);\n                }, typeInfo.fields[0]()[0]))) + \"}\";\n            }\n            case 34: {\n                const elementType = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_4((element) => Convert_serialize(element, elementType), value))) + \"]\";\n            }\n            case 35: {\n                const elementType_1 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_4((element_1) => Convert_serialize(element_1, elementType_1), value))) + \"]\";\n            }\n            case 28: {\n                const elementType_2 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_4((element_2) => Convert_serialize(element_2, elementType_2), value))) + \"]\";\n            }\n            case 29: {\n                const elementType_3 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_2((element_3) => Convert_serialize(element_3, elementType_3), value))) + \"]\";\n            }\n            case 27: {\n                const elementType_4 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_3((element_4) => Convert_serialize(element_4, elementType_4), value))) + \"]\";\n            }\n            case 30: {\n                const elementType_5 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_2((element_5) => Convert_serialize(element_5, elementType_5), toArray_1(value)))) + \"]\";\n            }\n            case 26: {\n                const matchValue = value;\n                if (matchValue != null) {\n                    value_mut = value_89(matchValue);\n                    typeInfo_mut = typeInfo.fields[0]();\n                    continue Convert_serialize;\n                }\n                else {\n                    return \"null\";\n                }\n            }\n            case 39: {\n                const patternInput_1 = typeInfo.fields[0]();\n                const patternInput_2 = getUnionFields(value, patternInput_1[1]);\n                const usedCase = patternInput_2[0];\n                const fields = patternInput_2[1];\n                const caseTypes = patternInput_1[0].find((case$) => (case$.CaseName === name_2(usedCase))).CaseTypes;\n                if (enumUnion(typeInfo) ? true : (caseTypes.length === 0)) {\n                    return Convert_betweenQuotes(name_2(usedCase));\n                }\n                else if (caseTypes.length === 1) {\n                    return (((\"{\" + Convert_betweenQuotes(name_2(usedCase))) + \": \") + Convert_serialize(fields[0], caseTypes[0])) + \"}\";\n                }\n                else {\n                    const serializedFields_1 = join(\", \", mapIndexed((index, caseType) => Convert_serialize(fields[index], caseType), caseTypes));\n                    return ((((\"{\" + Convert_betweenQuotes(name_2(usedCase))) + \": \") + \"[\") + serializedFields_1) + \"] }\";\n                }\n            }\n            case 32: {\n                const patternInput_3 = typeInfo.fields[0]();\n                const keyType = patternInput_3[0];\n                const serializedValues = join(\", \", map_2((tupledArg) => {\n                    const serializedKey = Convert_serialize(tupledArg[0], keyType);\n                    const serializedValue = Convert_serialize(tupledArg[1], patternInput_3[1]);\n                    if (isPrimitive(keyType) ? true : enumUnion(keyType)) {\n                        if (!Convert_isQuoted(serializedKey)) {\n                            return (Convert_quoteText(serializedKey) + \": \") + serializedValue;\n                        }\n                        else {\n                            return (serializedKey + \": \") + serializedValue;\n                        }\n                    }\n                    else {\n                        return (((\"[\" + serializedKey) + \", \") + serializedValue) + \"]\";\n                    }\n                }, toArray_2(value)));\n                if (isPrimitive(keyType) ? true : enumUnion(keyType)) {\n                    return (\"{\" + serializedValues) + \"}\";\n                }\n                else {\n                    return (\"[\" + serializedValues) + \"]\";\n                }\n            }\n            case 33: {\n                const patternInput_4 = typeInfo.fields[0]();\n                const keyType_1 = patternInput_4[0];\n                const serializedValues_1 = join(\", \", map_4((pair) => {\n                    const patternInput_5 = [pair[0], pair[1]];\n                    const serializedKey_1 = Convert_serialize(patternInput_5[0], keyType_1);\n                    const serializedValue_1 = Convert_serialize(patternInput_5[1], patternInput_4[1]);\n                    if (isPrimitive(keyType_1) ? true : enumUnion(keyType_1)) {\n                        if (!Convert_isQuoted(serializedKey_1)) {\n                            return (Convert_betweenQuotes(serializedKey_1) + \": \") + serializedValue_1;\n                        }\n                        else {\n                            return (serializedKey_1 + \": \") + serializedValue_1;\n                        }\n                    }\n                    else {\n                        return (((\"[\" + serializedKey_1) + \", \") + serializedValue_1) + \"]\";\n                    }\n                }, value));\n                if (isPrimitive(keyType_1) ? true : enumUnion(keyType_1)) {\n                    return (\"{\" + serializedValues_1) + \"}\";\n                }\n                else {\n                    return (\"[\" + serializedValues_1) + \"]\";\n                }\n            }\n            case 31: {\n                const tupleTypes = typeInfo.fields[0]();\n                if (tupleTypes.length === 1) {\n                    return (\"[\" + Convert_serialize(value, tupleTypes[0])) + \"]\";\n                }\n                else {\n                    return (\"[\" + join(\", \", mapIndexed((index_1, element_6) => Convert_serialize(element_6, tupleTypes[index_1]), value))) + \"]\";\n                }\n            }\n            case 22: {\n                return SimpleJson_stringify(value);\n            }\n            case 23: {\n                return SimpleJson_stringify(value);\n            }\n            default: {\n                return \"null\";\n            }\n        }\n        break;\n    }\n}\n\nexport function Fable_SimpleJson_Json__Json_stringify_Static_4E60E31B(value) {\n    if (Convert_isUsingFable3) {\n        console.warn(\"It looks like you using the function Json.stringify from Fable.SimpleJson while also using Fable 3 (nagareyama). Please use Json.serialize instead which supports both Fable 3 and Fable 2.x\");\n    }\n    return SimpleJson_stringify(value);\n}\n\n","export default function quote(inputText) {\r\n    var escapable = /[\\\\\\\"\\x00-\\x1f\\x7f-\\x9f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g;\r\n    var meta = {\r\n        '\\b': '\\\\b',\r\n        '\\t': '\\\\t',\r\n        '\\n': '\\\\n',\r\n        '\\f': '\\\\f',\r\n        '\\r': '\\\\r',\r\n        '\"': '\\\\\"',\r\n        '\\\\': '\\\\\\\\'\r\n    }\r\n\r\n    escapable.lastIndex = 0;\r\n    return escapable.test(inputText) ?\r\n        '\"' + inputText.replace(escapable, function (a) {\r\n            var c = meta[a];\r\n            return typeof c === 'string' ? c :\r\n                '\\\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);\r\n        }) + '\"' :\r\n        '\"' + inputText + '\"';\r\n}","// tslint:disable:max-line-length\nimport { fromNumber as Long_fromNumber, op_Division as Long_op_Division, op_Multiply as Long_op_Multiply, toNumber as Long_toNumber } from \"./Long.js\";\nimport { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from \"./Util.js\";\n// TimeSpan in runtime just becomes a number representing milliseconds\n/**\n * Calls:\n * - `Math.ceil` if the `value` is **negative**\n * - `Math.floor` if the `value` is **positive**\n * @param value Value to round\n */\nfunction signedRound(value) {\n    return value < 0 ? Math.ceil(value) : Math.floor(value);\n}\nexport function create(d = 0, h = 0, m = 0, s = 0, ms = 0) {\n    switch (arguments.length) {\n        case 1:\n            // ticks\n            return fromTicks(arguments[0]);\n        case 3:\n            // h,m,s\n            d = 0, h = arguments[0], m = arguments[1], s = arguments[2], ms = 0;\n            break;\n        default:\n            // d,h,m,s,ms\n            break;\n    }\n    return d * 86400000 + h * 3600000 + m * 60000 + s * 1000 + ms;\n}\nexport function fromTicks(ticks) {\n    return Long_toNumber(Long_op_Division(ticks, 10000));\n}\nexport function fromDays(d) {\n    return create(d, 0, 0, 0);\n}\nexport function fromHours(h) {\n    return create(h, 0, 0);\n}\nexport function fromMinutes(m) {\n    return create(0, m, 0);\n}\nexport function fromSeconds(s) {\n    return create(0, 0, s);\n}\nexport function days(ts) {\n    return signedRound(ts / 86400000);\n}\nexport function hours(ts) {\n    return signedRound(ts % 86400000 / 3600000);\n}\nexport function minutes(ts) {\n    return signedRound(ts % 3600000 / 60000);\n}\nexport function seconds(ts) {\n    return signedRound(ts % 60000 / 1000);\n}\nexport function milliseconds(ts) {\n    return signedRound(ts % 1000);\n}\nexport function ticks(ts) {\n    return Long_op_Multiply(Long_fromNumber(ts), 10000);\n}\nexport function totalDays(ts) {\n    return ts / 86400000;\n}\nexport function totalHours(ts) {\n    return ts / 3600000;\n}\nexport function totalMinutes(ts) {\n    return ts / 60000;\n}\nexport function totalSeconds(ts) {\n    return ts / 1000;\n}\nexport function negate(ts) {\n    return ts * -1;\n}\nexport function add(ts1, ts2) {\n    return ts1 + ts2;\n}\nexport function subtract(ts1, ts2) {\n    return ts1 - ts2;\n}\nexport function multiply(ts, factor) {\n    return ts * factor;\n}\nexport function divide(ts, b) {\n    return ts / b;\n}\nexport const op_Addition = add;\nexport const op_Subtraction = subtract;\nexport const op_Multiply = multiply;\nexport const op_Division = divide;\nexport const compare = comparePrimitives;\nexport const compareTo = comparePrimitives;\nexport function duration(x) {\n    return Math.abs(x);\n}\nexport function toString(ts, format = \"c\", _provider) {\n    if ([\"c\", \"g\", \"G\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const d = Math.abs(days(ts));\n    const h = Math.abs(hours(ts));\n    const m = Math.abs(minutes(ts));\n    const s = Math.abs(seconds(ts));\n    const ms = Math.abs(milliseconds(ts));\n    const sign = ts < 0 ? \"-\" : \"\";\n    return `${sign}${d === 0 && (format === \"c\" || format === \"g\") ? \"\" : format === \"c\" ? d + \".\" : d + \":\"}${format === \"g\" ? h : padWithZeros(h, 2)}:${padWithZeros(m, 2)}:${padWithZeros(s, 2)}${ms === 0 && (format === \"c\" || format === \"g\") ? \"\" : format === \"g\" ? \".\" + padWithZeros(ms, 3) : \".\" + padLeftAndRightWithZeros(ms, 3, 7)}`;\n}\nexport function parse(str) {\n    const firstDot = str.search(\"\\\\.\");\n    const firstColon = str.search(\"\\\\:\");\n    if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4\n        const d = parseInt(str, 0);\n        if (isNaN(d)) {\n            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n        }\n        else {\n            return create(d, 0, 0, 0, 0);\n        }\n    }\n    if (firstColon > 0) { // process time part\n        // WIP: (-?)(((\\d+)\\.)?([0-9]|0[0-9]|1[0-9]|2[0-3]):(\\d+)(:\\d+(\\.\\d{1,7})?)?|\\d+(?:(?!\\.)))\n        const r = /^(-?)((\\d+)\\.)?(?:0*)([0-9]|0[0-9]|1[0-9]|2[0-3]):(?:0*)([0-5][0-9]|[0-9])(:(?:0*)([0-5][0-9]|[0-9]))?\\.?(\\d+)?$/.exec(str);\n        if (r != null && r[4] != null && r[5] != null) {\n            let d = 0;\n            let ms = 0;\n            let s = 0;\n            const sign = r[1] != null && r[1] === \"-\" ? -1 : 1;\n            const h = +r[4];\n            const m = +r[5];\n            if (r[3] != null) {\n                d = +r[3];\n            }\n            if (r[7] != null) {\n                s = +r[7];\n            }\n            if (r[8] != null) {\n                // Depending on the number of decimals passed, we need to adapt the numbers\n                switch (r[8].length) {\n                    case 1:\n                        ms = +r[8] * 100;\n                        break;\n                    case 2:\n                        ms = +r[8] * 10;\n                        break;\n                    case 3:\n                        ms = +r[8];\n                        break;\n                    case 4:\n                        ms = +r[8] / 10;\n                        break;\n                    case 5:\n                        ms = +r[8] / 100;\n                        break;\n                    case 6:\n                        ms = +r[8] / 1000;\n                        break;\n                    case 7:\n                        ms = +r[8] / 10000;\n                        break;\n                    default:\n                        throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n                }\n            }\n            return sign * create(d, h, m, s, ms);\n        }\n    }\n    throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n","import { fromContinuations } from \"../fable-library.3.6.3/Async.js\";\nimport { toFail, printf, toText, trimEnd } from \"../fable-library.3.6.3/String.js\";\nimport { getGenerics, isGenericType, getFunctionElements, isFunction } from \"../fable-library.3.6.3/Reflection.js\";\nimport { take, equalsWith, last, head } from \"../fable-library.3.6.3/Array.js\";\nimport { curry, equals } from \"../fable-library.3.6.3/Util.js\";\nimport { empty, singleton, append, delay, toList } from \"../fable-library.3.6.3/Seq.js\";\nimport { singleton as singleton_1 } from \"../fable-library.3.6.3/AsyncBuilder.js\";\nimport { send, get$, post, withBody, withHeaders, sendAndReadBinary } from \"./Http.fs.js\";\nimport { RequestBody, ProxyRequestException_$ctor_76BC5104, HttpResponse } from \"./Types.fs.js\";\nimport { Convert_serialize, Convert_arrayLike, Convert_fromJsonAs } from \"../Fable.SimpleJson.3.22.0/Json.Converter.fs.js\";\nimport { SimpleJson_parseNative } from \"../Fable.SimpleJson.3.22.0/SimpleJson.fs.js\";\nimport { TypeInfo } from \"../Fable.SimpleJson.3.22.0/TypeInfo.fs.js\";\n\nexport function Blob_readBlobAsText(blob) {\n    return fromContinuations((tupledArg) => {\n        const reader = new FileReader();\n        reader.onload = ((_arg1) => {\n            if (reader.readyState === 2) {\n                tupledArg[0](reader.result);\n            }\n        });\n        reader.readAsText(blob);\n    });\n}\n\nexport function Proxy_combineRouteWithBaseUrl(route, baseUrl) {\n    if (baseUrl != null) {\n        const arg10 = trimEnd(baseUrl, \"/\");\n        return toText(printf(\"%s%s\"))(arg10)(route);\n    }\n    else {\n        return route;\n    }\n}\n\nexport function Proxy_isByteArray(_arg1) {\n    if (_arg1.tag === 29) {\n        if (_arg1.fields[0]().tag === 13) {\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Proxy_isAsyncOfByteArray(_arg1) {\n    if (_arg1.tag === 24) {\n        const matchValue = _arg1.fields[0]();\n        if (matchValue.tag === 29) {\n            if (matchValue.fields[0]().tag === 13) {\n                return true;\n            }\n            else {\n                return false;\n            }\n        }\n        else {\n            return false;\n        }\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Proxy_getReturnType(typ_mut) {\n    Proxy_getReturnType:\n    while (true) {\n        const typ = typ_mut;\n        if (isFunction(typ)) {\n            typ_mut = getFunctionElements(typ)[1];\n            continue Proxy_getReturnType;\n        }\n        else if (isGenericType(typ)) {\n            return head(getGenerics(typ));\n        }\n        else {\n            return typ;\n        }\n        break;\n    }\n}\n\nexport function Proxy_proxyFetch(options, typeName, func, fieldType) {\n    let funcArgs;\n    const matchValue = func.FieldType;\n    switch (matchValue.tag) {\n        case 24: {\n            funcArgs = [func.FieldType];\n            break;\n        }\n        case 25: {\n            funcArgs = [func.FieldType];\n            break;\n        }\n        case 36: {\n            funcArgs = matchValue.fields[0]();\n            break;\n        }\n        default: {\n            funcArgs = toFail(printf(\"Field %s does not have a valid definiton\"))(func.FieldName);\n        }\n    }\n    const argumentCount = (funcArgs.length - 1) | 0;\n    const returnTypeAsync = last(funcArgs);\n    let binaryInput;\n    const matchValue_1 = func.FieldType;\n    if (matchValue_1.tag === 36) {\n        const matchValue_2 = matchValue_1.fields[0]();\n        if ((!equalsWith((x, y) => equals(x, y), matchValue_2, null)) && (matchValue_2.length === 2)) {\n            const output = matchValue_2[1];\n            binaryInput = Proxy_isByteArray(matchValue_2[0]);\n        }\n        else {\n            binaryInput = false;\n        }\n    }\n    else {\n        binaryInput = false;\n    }\n    const url = Proxy_combineRouteWithBaseUrl(options.RouteBuilder(typeName, func.FieldName), options.BaseUrl);\n    const funcNeedParameters = ((!equalsWith((x_1, y_1) => equals(x_1, y_1), funcArgs, null)) && (funcArgs.length === 1)) ? ((funcArgs[0].tag === 24) ? false : (!(funcArgs[0].tag === 25))) : (((!equalsWith((x_2, y_2) => equals(x_2, y_2), funcArgs, null)) && (funcArgs.length === 2)) ? ((funcArgs[0].tag === 0) ? (!(funcArgs[1].tag === 24)) : true) : true);\n    const contentType = binaryInput ? \"application/octet-stream\" : \"application/json; charset=utf-8\";\n    const inputArgumentTypes = take(argumentCount, funcArgs);\n    const headers = toList(delay(() => append(singleton([\"Content-Type\", contentType]), delay(() => append(singleton([\"x-remoting-proxy\", \"true\"]), delay(() => append(options.CustomHeaders, delay(() => {\n        const matchValue_3 = options.Authorization;\n        if (matchValue_3 == null) {\n            return empty();\n        }\n        else {\n            return singleton([\"Authorization\", matchValue_3]);\n        }\n    }))))))));\n    let executeRequest;\n    if ((curry(2, options.CustomResponseSerialization) != null) ? true : Proxy_isAsyncOfByteArray(returnTypeAsync)) {\n        let onOk;\n        const matchValue_4 = options.CustomResponseSerialization;\n        if (curry(2, matchValue_4) != null) {\n            const serializer = curry(2, matchValue_4);\n            const returnType = Proxy_getReturnType(fieldType);\n            onOk = ((response) => serializer(response)(returnType));\n        }\n        else {\n            onOk = ((value) => value);\n        }\n        executeRequest = ((requestBody) => singleton_1.Delay(() => singleton_1.Bind(funcNeedParameters ? sendAndReadBinary(withHeaders(headers, withBody(requestBody, post(url)))) : sendAndReadBinary(withHeaders(headers, get$(url))), (_arg1) => {\n            const statusCode = _arg1[1] | 0;\n            const response_1 = _arg1[0];\n            if (statusCode === 200) {\n                return singleton_1.Return(onOk(response_1));\n            }\n            else {\n                const n = statusCode | 0;\n                return singleton_1.Bind(Blob_readBlobAsText(new Blob([response_1.buffer], { type: 'text/plain' })), (_arg2) => {\n                    const response_2 = new HttpResponse(statusCode, _arg2);\n                    const errorMsg = (n === 500) ? toText(printf(\"Internal server error (500) while making request to %s\"))(url) : toText(printf(\"Http error (%d) while making request to %s\"))(n)(url);\n                    return singleton_1.ReturnFrom((() => {\n                        throw ProxyRequestException_$ctor_76BC5104(response_2, errorMsg, response_2.ResponseBody);\n                    })());\n                });\n            }\n        })));\n    }\n    else {\n        const returnType_1 = (returnTypeAsync.tag === 24) ? returnTypeAsync.fields[0]() : ((returnTypeAsync.tag === 25) ? returnTypeAsync.fields[0]() : toFail(printf(\"Expected field %s to have a return type of Async\\u003c\\u0027t\\u003e\"))(func.FieldName));\n        executeRequest = ((requestBody_1) => singleton_1.Delay(() => singleton_1.Bind(funcNeedParameters ? send(withHeaders(headers, withBody(requestBody_1, post(url)))) : send(withHeaders(headers, get$(url))), (_arg3) => {\n            const response_3 = _arg3;\n            const matchValue_5 = response_3.StatusCode | 0;\n            switch (matchValue_5) {\n                case 200: {\n                    return singleton_1.Return(Convert_fromJsonAs(SimpleJson_parseNative(response_3.ResponseBody), returnType_1));\n                }\n                case 500: {\n                    return singleton_1.ReturnFrom((() => {\n                        throw ProxyRequestException_$ctor_76BC5104(response_3, toText(printf(\"Internal server error (500) while making request to %s\"))(url), response_3.ResponseBody);\n                    })());\n                }\n                default: {\n                    return singleton_1.ReturnFrom((() => {\n                        throw ProxyRequestException_$ctor_76BC5104(response_3, toText(printf(\"Http error (%d) from server occured while making request to %s\"))(matchValue_5)(url), response_3.ResponseBody);\n                    })());\n                }\n            }\n        })));\n    }\n    return (arg0) => ((arg1) => ((arg2) => ((arg3) => ((arg4) => ((arg5) => ((arg6) => ((arg7) => {\n        let matchValue_6;\n        const inputArguments = funcNeedParameters ? take(argumentCount, [arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7]) : [];\n        return executeRequest(binaryInput ? (new RequestBody(2, arg0)) : ((matchValue_6 = (inputArgumentTypes.length | 0), (matchValue_6 === 1) ? ((!Convert_arrayLike(inputArgumentTypes[0])) ? (new RequestBody(1, Convert_serialize(inputArguments[0], new TypeInfo(31, () => inputArgumentTypes)))) : ((matchValue_6 === 1) ? (new RequestBody(1, Convert_serialize([inputArguments[0]], new TypeInfo(29, () => inputArgumentTypes[0])))) : (new RequestBody(1, Convert_serialize(inputArguments, new TypeInfo(31, () => inputArgumentTypes)))))) : ((matchValue_6 === 1) ? (new RequestBody(1, Convert_serialize([inputArguments[0]], new TypeInfo(29, () => inputArgumentTypes[0])))) : (new RequestBody(1, Convert_serialize(inputArguments, new TypeInfo(31, () => inputArgumentTypes))))))));\n    })))))));\n}\n\n","import { Record, Union } from \"../fable_modules/fable-library.3.6.3/Types.js\";\nimport { array_type, option_type, record_type, string_type, int32_type, union_type } from \"../fable_modules/fable-library.3.6.3/Reflection.js\";\nimport { DownloadFormat$reflection, TaggedTextInfo$reflection } from \"../Shared/fs/Shared.js\";\n\nexport class TaggingStatus extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"NotTagged\", \"Tagging\", \"Tagged\"];\n    }\n}\n\nexport function TaggingStatus$reflection() {\n    return union_type(\"Model.TaggingStatus\", [], TaggingStatus, () => [[], [], []]);\n}\n\nexport class Lemma extends Record {\n    constructor(Frequency, Form, Pos) {\n        super();\n        this.Frequency = (Frequency | 0);\n        this.Form = Form;\n        this.Pos = Pos;\n    }\n}\n\nexport function Lemma$reflection() {\n    return record_type(\"Model.Lemma\", [], Lemma, () => [[\"Frequency\", int32_type], [\"Form\", string_type], [\"Pos\", string_type]]);\n}\n\nexport class Model extends Record {\n    constructor(Filename, TaggingStatus, TaggedTextInfo, Lemmas, DownloadFormat) {\n        super();\n        this.Filename = Filename;\n        this.TaggingStatus = TaggingStatus;\n        this.TaggedTextInfo = TaggedTextInfo;\n        this.Lemmas = Lemmas;\n        this.DownloadFormat = DownloadFormat;\n    }\n}\n\nexport function Model$reflection() {\n    return record_type(\"Model.Model\", [], Model, () => [[\"Filename\", option_type(string_type)], [\"TaggingStatus\", TaggingStatus$reflection()], [\"TaggedTextInfo\", option_type(TaggedTextInfo$reflection())], [\"Lemmas\", option_type(array_type(Lemma$reflection()))], [\"DownloadFormat\", option_type(DownloadFormat$reflection())]]);\n}\n\n","import { Union } from \"../fable_modules/fable-library.3.6.3/Types.js\";\nimport { union_type, array_type, int32_type, tuple_type, string_type, class_type } from \"../fable_modules/fable-library.3.6.3/Reflection.js\";\nimport { FileByteArray, IServerApi$reflection, Route_builder, IncludePos$reflection, DownloadFormat$reflection, FileByteArray$reflection, TaggedTextInfo$reflection } from \"../Shared/fs/Shared.js\";\nimport { RemotingModule_createApi, RemotingModule_withRouteBuilder, Remoting_buildProxy_Z15584635 } from \"../fable_modules/Fable.Remoting.Client.7.18.0/Remoting.fs.js\";\nimport { Lemma, Model, TaggingStatus as TaggingStatus_1 } from \"./Model.js\";\nimport { Cmd_OfAsync_start, Cmd_OfAsyncWith_perform, Cmd_none } from \"../fable_modules/Fable.Elmish.3.1.0/cmd.fs.js\";\nimport { Browser_Types_File__File_ReadAsByteArray, ByteArrayExtensions_SaveFileAs_72B26259 } from \"../fable_modules/Fable.Remoting.Client.7.18.0/Extensions.fs.js\";\nimport { singleton, collect, delay, toArray } from \"../fable_modules/fable-library.3.6.3/Seq.js\";\nimport { singleton as singleton_1 } from \"../fable_modules/fable-library.3.6.3/AsyncBuilder.js\";\nimport { some } from \"../fable_modules/fable-library.3.6.3/Option.js\";\n\nexport class Msg extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"TagText\", \"TaggedText\", \"DownloadTaggedText\", \"DownloadedTaggedText\", \"FetchLemmas\", \"FetchedLemmas\", \"DownloadLemmas\", \"DownloadedLemmas\", \"DownloadLemmatizedText\", \"DownloadedLemmatizedText\"];\n    }\n}\n\nexport function Msg$reflection() {\n    return union_type(\"Update.Msg\", [], Msg, () => [[[\"Item\", class_type(\"Browser.Types.File\")]], [[\"Item\", TaggedTextInfo$reflection()]], [], [[\"Item\", FileByteArray$reflection()]], [], [[\"Item\", array_type(tuple_type(tuple_type(string_type, string_type), int32_type))]], [[\"Item\", DownloadFormat$reflection()]], [[\"Item\", FileByteArray$reflection()]], [[\"Item\", IncludePos$reflection()]], [[\"Item\", FileByteArray$reflection()]]]);\n}\n\nexport const serverApi = Remoting_buildProxy_Z15584635(RemotingModule_withRouteBuilder((typeName, methodName) => Route_builder(typeName, methodName), RemotingModule_createApi()), {\n    ResolveType: IServerApi$reflection,\n});\n\nexport function init() {\n    return [new Model(void 0, new TaggingStatus_1(0), void 0, void 0, void 0), Cmd_none()];\n}\n\nexport function update(msg, model) {\n    let matchValue, matchValue_1, matchValue_3, matchValue_5;\n    switch (msg.tag) {\n        case 1: {\n            return [new Model(model.Filename, new TaggingStatus_1(2), msg.fields[0], model.Lemmas, model.DownloadFormat), Cmd_none()];\n        }\n        case 2: {\n            return [model, (matchValue = model.TaggedTextInfo, (matchValue == null) ? (() => {\n                throw (new Error(\"Content hash missing!\"));\n            })() : Cmd_OfAsyncWith_perform((x_1) => {\n                Cmd_OfAsync_start(x_1);\n            }, serverApi.DownloadTaggedText, matchValue.ContentHash, (arg0_1) => (new Msg(3, arg0_1))))];\n        }\n        case 3: {\n            ByteArrayExtensions_SaveFileAs_72B26259(msg.fields[0].fields[0], `${model.Filename}.tag.txt`);\n            return [model, Cmd_none()];\n        }\n        case 4: {\n            return [model, (matchValue_1 = model.TaggedTextInfo, (matchValue_1 == null) ? (() => {\n                throw (new Error(\"Content hash missing!\"));\n            })() : Cmd_OfAsyncWith_perform((x_2) => {\n                Cmd_OfAsync_start(x_2);\n            }, serverApi.GetLemmas, matchValue_1.ContentHash, (arg0_2) => (new Msg(5, arg0_2))))];\n        }\n        case 5: {\n            return [new Model(model.Filename, model.TaggingStatus, model.TaggedTextInfo, toArray(delay(() => collect((matchValue_2) => singleton(new Lemma(matchValue_2[1], matchValue_2[0][0], matchValue_2[0][1])), msg.fields[0]))), model.DownloadFormat), Cmd_none()];\n        }\n        case 6: {\n            const format = msg.fields[0];\n            return [new Model(model.Filename, model.TaggingStatus, model.TaggedTextInfo, model.Lemmas, format), (matchValue_3 = model.TaggedTextInfo, (matchValue_3 == null) ? (() => {\n                throw (new Error(\"Content hash missing!\"));\n            })() : Cmd_OfAsyncWith_perform((x_3) => {\n                Cmd_OfAsync_start(x_3);\n            }, serverApi.DownloadLemmas, [matchValue_3.ContentHash, format], (arg0_4) => (new Msg(7, arg0_4))))];\n        }\n        case 7: {\n            let extension;\n            const matchValue_4 = model.DownloadFormat;\n            if (matchValue_4 == null) {\n                throw (new Error(\"Download format not set!\"));\n            }\n            else {\n                extension = ((matchValue_4.tag === 1) ? \"tsv\" : ((matchValue_4.tag === 2) ? \"csv\" : \"xlsx\"));\n            }\n            ByteArrayExtensions_SaveFileAs_72B26259(msg.fields[0].fields[0], `${model.Filename}.lemmas.${extension}`);\n            return [model, Cmd_none()];\n        }\n        case 8: {\n            return [model, (matchValue_5 = model.TaggedTextInfo, (matchValue_5 == null) ? (() => {\n                throw (new Error(\"Content hash missing!\"));\n            })() : Cmd_OfAsyncWith_perform((x_4) => {\n                Cmd_OfAsync_start(x_4);\n            }, serverApi.DownloadLemmatizedText, [matchValue_5.ContentHash, msg.fields[0]], (arg0_5) => (new Msg(9, arg0_5))))];\n        }\n        case 9: {\n            ByteArrayExtensions_SaveFileAs_72B26259(msg.fields[0].fields[0], `${model.Filename}.lemmatized.txt`);\n            return [model, Cmd_none()];\n        }\n        default: {\n            const file = msg.fields[0];\n            return [(file.size <= 1048576) ? (new Model(file.name, new TaggingStatus_1(1), void 0, void 0, model.DownloadFormat)) : model, (file.size <= 1048576) ? Cmd_OfAsyncWith_perform((x) => {\n                Cmd_OfAsync_start(x);\n            }, () => singleton_1.Delay(() => singleton_1.Bind(Browser_Types_File__File_ReadAsByteArray(file), (_arg1) => singleton_1.ReturnFrom(serverApi.TagText(new FileByteArray(0, _arg1))))), void 0, (arg0) => (new Msg(1, arg0))) : ((window.alert(some(\"Filstørrelsen overstiger maksimum på 1 MB!\")), Cmd_none()))];\n        }\n    }\n}\n\n","import { empty } from \"../fable-library.3.6.3/List.js\";\nimport { uncurry } from \"../fable-library.3.6.3/Util.js\";\nimport { toFail, printf, toText } from \"../fable-library.3.6.3/String.js\";\nimport { RemoteBuilderOptions } from \"./Types.fs.js\";\nimport { Reader_$ctor_6C95DA22, Reader__Read_24524716 } from \"../Fable.Remoting.MsgPack.1.15.0/Read.fs.js\";\nimport { fullName, makeRecord, getRecordElements, name as name_1, class_type } from \"../fable-library.3.6.3/Reflection.js\";\nimport { value } from \"../fable-library.3.6.3/Option.js\";\nimport { createTypeInfo } from \"../Fable.SimpleJson.3.22.0/TypeInfo.Converter.fs.js\";\nimport { pick, map } from \"../fable-library.3.6.3/Array.js\";\nimport { singleton, collect, delay, toArray } from \"../fable-library.3.6.3/Seq.js\";\nimport { Proxy_proxyFetch } from \"./Proxy.fs.js\";\n\nexport function RemotingModule_createApi() {\n    let clo1;\n    return new RemoteBuilderOptions(empty(), void 0, void 0, false, uncurry(2, (clo1 = toText(printf(\"/%s/%s\")), (arg10) => {\n        const clo2 = clo1(arg10);\n        return (arg20) => clo2(arg20);\n    })), uncurry(2, void 0));\n}\n\nexport function RemotingModule_withRouteBuilder(builder, options) {\n    return new RemoteBuilderOptions(options.CustomHeaders, options.BaseUrl, options.Authorization, options.WithCredentials, builder, options.CustomResponseSerialization);\n}\n\nexport function RemotingModule_withBaseUrl(url, options) {\n    return new RemoteBuilderOptions(options.CustomHeaders, url, options.Authorization, options.WithCredentials, options.RouteBuilder, options.CustomResponseSerialization);\n}\n\nexport function RemotingModule_withCustomHeader(headers, options) {\n    return new RemoteBuilderOptions(headers, options.BaseUrl, options.Authorization, options.WithCredentials, options.RouteBuilder, options.CustomResponseSerialization);\n}\n\nexport function RemotingModule_withAuthorizationHeader(token, options) {\n    return new RemoteBuilderOptions(options.CustomHeaders, options.BaseUrl, token, options.WithCredentials, options.RouteBuilder, options.CustomResponseSerialization);\n}\n\nexport function RemotingModule_withCredentials(withCredentials, options) {\n    return new RemoteBuilderOptions(options.CustomHeaders, options.BaseUrl, options.Authorization, withCredentials, options.RouteBuilder, options.CustomResponseSerialization);\n}\n\nexport function RemotingModule_withBinarySerialization(options) {\n    return new RemoteBuilderOptions(options.CustomHeaders, options.BaseUrl, options.Authorization, options.WithCredentials, options.RouteBuilder, (response, returnType) => Reader__Read_24524716(Reader_$ctor_6C95DA22(response), returnType));\n}\n\nexport class Remoting {\n    constructor() {\n    }\n}\n\nexport function Remoting$reflection() {\n    return class_type(\"Fable.Remoting.Client.Remoting\", void 0, Remoting);\n}\n\nexport function Remoting_$ctor() {\n    return new Remoting();\n}\n\nexport function Remoting_buildProxy_Z15584635(options, resolver) {\n    const resolvedType = value(resolver).ResolveType();\n    const schemaType = createTypeInfo(resolvedType);\n    if (schemaType.tag === 38) {\n        const patternInput = schemaType.fields[0]();\n        const recordType = patternInput[1];\n        const fieldTypes = map((prop) => [name_1(prop), prop[1]], getRecordElements(recordType));\n        return makeRecord(recordType, toArray(delay(() => collect((field) => {\n            let n, matchValue, fieldType, fn;\n            return singleton((n = (((matchValue = field.FieldType, (matchValue.tag === 24) ? 0 : ((matchValue.tag === 25) ? 0 : ((matchValue.tag === 36) ? (matchValue.fields[0]().length - 1) : 0)))) | 0), (fieldType = pick((tupledArg) => {\n                if (tupledArg[0] === field.FieldName) {\n                    return tupledArg[1];\n                }\n                else {\n                    return void 0;\n                }\n            }, fieldTypes), (fn = Proxy_proxyFetch(options, name_1(recordType), field, fieldType), (n === 0) ? fn(null)(null)(null)(null)(null)(null)(null)(null) : ((n === 1) ? ((a) => fn(a)(null)(null)(null)(null)(null)(null)(null)) : ((n === 2) ? ((delegateArg0, delegateArg1) => fn(delegateArg0)(delegateArg1)(null)(null)(null)(null)(null)(null)) : ((n === 3) ? ((delegateArg0_1, delegateArg1_1, delegateArg2) => fn(delegateArg0_1)(delegateArg1_1)(delegateArg2)(null)(null)(null)(null)(null)) : ((n === 4) ? ((delegateArg0_2, delegateArg1_2, delegateArg2_1, delegateArg3) => fn(delegateArg0_2)(delegateArg1_2)(delegateArg2_1)(delegateArg3)(null)(null)(null)(null)) : ((n === 5) ? ((delegateArg0_3, delegateArg1_3, delegateArg2_2, delegateArg3_1, delegateArg4) => fn(delegateArg0_3)(delegateArg1_3)(delegateArg2_2)(delegateArg3_1)(delegateArg4)(null)(null)(null)) : ((n === 6) ? ((delegateArg0_4, delegateArg1_4, delegateArg2_3, delegateArg3_2, delegateArg4_1, delegateArg5) => fn(delegateArg0_4)(delegateArg1_4)(delegateArg2_3)(delegateArg3_2)(delegateArg4_1)(delegateArg5)(null)(null)) : ((n === 7) ? ((delegateArg0_5, delegateArg1_5, delegateArg2_4, delegateArg3_3, delegateArg4_2, delegateArg5_1, delegateArg6) => fn(delegateArg0_5)(delegateArg1_5)(delegateArg2_4)(delegateArg3_3)(delegateArg4_2)(delegateArg5_1)(delegateArg6)(null)) : ((n === 8) ? ((delegateArg0_6, delegateArg1_6, delegateArg2_5, delegateArg3_4, delegateArg4_3, delegateArg5_2, delegateArg6_1, delegateArg7) => fn(delegateArg0_6)(delegateArg1_6)(delegateArg2_5)(delegateArg3_4)(delegateArg4_3)(delegateArg5_2)(delegateArg6_1)(delegateArg7)) : toFail(printf(\"Cannot generate proxy function for %s. Only up to 8 arguments are supported. Consider using a record type as input\"))(field.FieldName)))))))))))));\n        }, patternInput[0]))));\n    }\n    else {\n        const arg10_1 = fullName(resolvedType);\n        return toFail(printf(\"Cannot build proxy. Exepected type %s to be a valid protocol definition which is a record of functions\"))(arg10_1);\n    }\n}\n\n","import { some } from \"../fable-library.3.6.3/Option.js\";\nimport { create, isLeapYear } from \"../fable-library.3.6.3/Date.js\";\nimport { parse } from \"../fable-library.3.6.3/Int32.js\";\nimport { split, isNullOrWhiteSpace } from \"../fable-library.3.6.3/String.js\";\nimport { equalsWith } from \"../fable-library.3.6.3/Array.js\";\nimport react from \"react\";\n\nexport function DateParsing_$007CBetween$007C_$007C(x, y, input) {\n    if ((input >= x) && (input <= y)) {\n        return some(void 0);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function DateParsing_isLeapYear(year) {\n    return isLeapYear(year);\n}\n\nexport function DateParsing_$007CInt$007C_$007C(input) {\n    try {\n        return parse(input, 511, false, 32);\n    }\n    catch (matchValue) {\n        return void 0;\n    }\n}\n\nexport function DateParsing_parse(input) {\n    try {\n        if (isNullOrWhiteSpace(input)) {\n            return void 0;\n        }\n        else {\n            const parts = split(input, [\"-\"], null, 0);\n            let patternInput;\n            let pattern_matching_result, month, year;\n            if ((!equalsWith((x, y) => (x === y), parts, null)) && (parts.length === 2)) {\n                const activePatternResult3496 = DateParsing_$007CInt$007C_$007C(parts[0]);\n                if (activePatternResult3496 != null) {\n                    const activePatternResult3497 = DateParsing_$007CInt$007C_$007C(parts[1]);\n                    if (activePatternResult3497 != null) {\n                        pattern_matching_result = 0;\n                        month = activePatternResult3497;\n                        year = activePatternResult3496;\n                    }\n                    else {\n                        pattern_matching_result = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result = 1;\n                }\n            }\n            else {\n                pattern_matching_result = 1;\n            }\n            switch (pattern_matching_result) {\n                case 0: {\n                    patternInput = [year, month, 1, 0, 0];\n                    break;\n                }\n                case 1: {\n                    let pattern_matching_result_1, day, month_1, year_1;\n                    if ((!equalsWith((x_1, y_1) => (x_1 === y_1), parts, null)) && (parts.length === 3)) {\n                        const activePatternResult3493 = DateParsing_$007CInt$007C_$007C(parts[0]);\n                        if (activePatternResult3493 != null) {\n                            const activePatternResult3494 = DateParsing_$007CInt$007C_$007C(parts[1]);\n                            if (activePatternResult3494 != null) {\n                                const activePatternResult3495 = DateParsing_$007CInt$007C_$007C(parts[2]);\n                                if (activePatternResult3495 != null) {\n                                    pattern_matching_result_1 = 0;\n                                    day = activePatternResult3495;\n                                    month_1 = activePatternResult3494;\n                                    year_1 = activePatternResult3493;\n                                }\n                                else {\n                                    pattern_matching_result_1 = 1;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_1 = 1;\n                            }\n                        }\n                        else {\n                            pattern_matching_result_1 = 1;\n                        }\n                    }\n                    else {\n                        pattern_matching_result_1 = 1;\n                    }\n                    switch (pattern_matching_result_1) {\n                        case 0: {\n                            patternInput = [year_1, month_1, day, 0, 0];\n                            break;\n                        }\n                        case 1: {\n                            let pattern_matching_result_2, day_1, month_2, year_2;\n                            if ((!equalsWith((x_2, y_2) => (x_2 === y_2), parts, null)) && (parts.length === 3)) {\n                                const activePatternResult3491 = DateParsing_$007CInt$007C_$007C(parts[0]);\n                                if (activePatternResult3491 != null) {\n                                    const activePatternResult3492 = DateParsing_$007CInt$007C_$007C(parts[1]);\n                                    if (activePatternResult3492 != null) {\n                                        pattern_matching_result_2 = 0;\n                                        day_1 = parts[2];\n                                        month_2 = activePatternResult3492;\n                                        year_2 = activePatternResult3491;\n                                    }\n                                    else {\n                                        pattern_matching_result_2 = 1;\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result_2 = 1;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 1;\n                            }\n                            switch (pattern_matching_result_2) {\n                                case 0: {\n                                    if (day_1.indexOf(\"T\") >= 0) {\n                                        const matchValue = split(day_1, [\"T\"], null, 0);\n                                        let pattern_matching_result_3, parsedDay, time;\n                                        if ((!equalsWith((x_3, y_3) => (x_3 === y_3), matchValue, null)) && (matchValue.length === 2)) {\n                                            const activePatternResult3490 = DateParsing_$007CInt$007C_$007C(matchValue[0]);\n                                            if (activePatternResult3490 != null) {\n                                                pattern_matching_result_3 = 0;\n                                                parsedDay = activePatternResult3490;\n                                                time = matchValue[1];\n                                            }\n                                            else {\n                                                pattern_matching_result_3 = 1;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result_3 = 1;\n                                        }\n                                        switch (pattern_matching_result_3) {\n                                            case 0: {\n                                                const matchValue_1 = split(time, [\":\"], null, 0);\n                                                let pattern_matching_result_4, hour, minute;\n                                                if ((!equalsWith((x_4, y_4) => (x_4 === y_4), matchValue_1, null)) && (matchValue_1.length === 2)) {\n                                                    const activePatternResult3488 = DateParsing_$007CInt$007C_$007C(matchValue_1[0]);\n                                                    if (activePatternResult3488 != null) {\n                                                        const activePatternResult3489 = DateParsing_$007CInt$007C_$007C(matchValue_1[1]);\n                                                        if (activePatternResult3489 != null) {\n                                                            pattern_matching_result_4 = 0;\n                                                            hour = activePatternResult3488;\n                                                            minute = activePatternResult3489;\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_4 = 1;\n                                                        }\n                                                    }\n                                                    else {\n                                                        pattern_matching_result_4 = 1;\n                                                    }\n                                                }\n                                                else {\n                                                    pattern_matching_result_4 = 1;\n                                                }\n                                                switch (pattern_matching_result_4) {\n                                                    case 0: {\n                                                        const matchValue_2 = [hour, minute];\n                                                        let pattern_matching_result_5;\n                                                        if (DateParsing_$007CBetween$007C_$007C(0, 59, matchValue_2[0]) != null) {\n                                                            if (DateParsing_$007CBetween$007C_$007C(0, 59, matchValue_2[1]) != null) {\n                                                                pattern_matching_result_5 = 0;\n                                                            }\n                                                            else {\n                                                                pattern_matching_result_5 = 1;\n                                                            }\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_5 = 1;\n                                                        }\n                                                        switch (pattern_matching_result_5) {\n                                                            case 0: {\n                                                                patternInput = [year_2, month_2, parsedDay, hour, minute];\n                                                                break;\n                                                            }\n                                                            case 1: {\n                                                                patternInput = [-1, 1, 1, 0, 0];\n                                                                break;\n                                                            }\n                                                        }\n                                                        break;\n                                                    }\n                                                    case 1: {\n                                                        patternInput = [-1, 1, 1, 0, 0];\n                                                        break;\n                                                    }\n                                                }\n                                                break;\n                                            }\n                                            case 1: {\n                                                patternInput = [-1, 1, 1, 0, 0];\n                                                break;\n                                            }\n                                        }\n                                    }\n                                    else {\n                                        patternInput = [-1, 1, 1, 0, 0];\n                                    }\n                                    break;\n                                }\n                                case 1: {\n                                    patternInput = [-1, 1, 1, 0, 0];\n                                    break;\n                                }\n                            }\n                            break;\n                        }\n                    }\n                    break;\n                }\n            }\n            const year_3 = patternInput[0] | 0;\n            const month_3 = patternInput[1] | 0;\n            const minute_1 = patternInput[4] | 0;\n            const hour_1 = patternInput[3] | 0;\n            const day_2 = patternInput[2] | 0;\n            if (year_3 <= 0) {\n                return void 0;\n            }\n            else {\n                const matchValue_3 = [month_3, day_2];\n                let pattern_matching_result_6;\n                if (matchValue_3[0] === 2) {\n                    if (DateParsing_$007CBetween$007C_$007C(1, 29, matchValue_3[1]) != null) {\n                        if (DateParsing_isLeapYear(year_3)) {\n                            pattern_matching_result_6 = 0;\n                        }\n                        else {\n                            pattern_matching_result_6 = 1;\n                        }\n                    }\n                    else {\n                        pattern_matching_result_6 = 1;\n                    }\n                }\n                else {\n                    pattern_matching_result_6 = 1;\n                }\n                switch (pattern_matching_result_6) {\n                    case 0: {\n                        return create(year_3, month_3, day_2, hour_1, minute_1, 0);\n                    }\n                    case 1: {\n                        let pattern_matching_result_7;\n                        if (matchValue_3[0] === 2) {\n                            if (DateParsing_$007CBetween$007C_$007C(1, 28, matchValue_3[1]) != null) {\n                                if (!DateParsing_isLeapYear(year_3)) {\n                                    pattern_matching_result_7 = 0;\n                                }\n                                else {\n                                    pattern_matching_result_7 = 1;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_7 = 1;\n                            }\n                        }\n                        else {\n                            pattern_matching_result_7 = 1;\n                        }\n                        switch (pattern_matching_result_7) {\n                            case 0: {\n                                return create(year_3, month_3, day_2, hour_1, minute_1, 0);\n                            }\n                            case 1: {\n                                let pattern_matching_result_8;\n                                if (matchValue_3[0] === 1) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else if (matchValue_3[0] === 3) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else if (matchValue_3[0] === 5) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else if (matchValue_3[0] === 7) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else if (matchValue_3[0] === 8) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else if (matchValue_3[0] === 10) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else if (matchValue_3[0] === 12) {\n                                    if (DateParsing_$007CBetween$007C_$007C(1, 31, matchValue_3[1]) != null) {\n                                        pattern_matching_result_8 = 0;\n                                    }\n                                    else {\n                                        pattern_matching_result_8 = 1;\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result_8 = 1;\n                                }\n                                switch (pattern_matching_result_8) {\n                                    case 0: {\n                                        return create(year_3, month_3, day_2, hour_1, minute_1, 0);\n                                    }\n                                    case 1: {\n                                        let pattern_matching_result_9;\n                                        if (matchValue_3[0] === 4) {\n                                            if (DateParsing_$007CBetween$007C_$007C(1, 30, matchValue_3[1]) != null) {\n                                                pattern_matching_result_9 = 0;\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 1;\n                                            }\n                                        }\n                                        else if (matchValue_3[0] === 6) {\n                                            if (DateParsing_$007CBetween$007C_$007C(1, 30, matchValue_3[1]) != null) {\n                                                pattern_matching_result_9 = 0;\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 1;\n                                            }\n                                        }\n                                        else if (matchValue_3[0] === 9) {\n                                            if (DateParsing_$007CBetween$007C_$007C(1, 30, matchValue_3[1]) != null) {\n                                                pattern_matching_result_9 = 0;\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 1;\n                                            }\n                                        }\n                                        else if (matchValue_3[0] === 11) {\n                                            if (DateParsing_$007CBetween$007C_$007C(1, 30, matchValue_3[1]) != null) {\n                                                pattern_matching_result_9 = 0;\n                                            }\n                                            else {\n                                                pattern_matching_result_9 = 1;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result_9 = 1;\n                                        }\n                                        switch (pattern_matching_result_9) {\n                                            case 0: {\n                                                return create(year_3, month_3, day_2, hour_1, minute_1, 0);\n                                            }\n                                            case 1: {\n                                                return void 0;\n                                            }\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n    catch (matchValue_4) {\n        return void 0;\n    }\n}\n\nexport const Interop_reactApi = react;\n\n","import { reverse, empty, cons, fold } from \"../fable-library.3.6.3/List.js\";\nimport { uncurry } from \"../fable-library.3.6.3/Util.js\";\nimport { toString } from \"../fable-library.3.6.3/Types.js\";\nimport { join } from \"../fable-library.3.6.3/String.js\";\n\nexport function Helpers_extractClasses(xs) {\n    return fold(uncurry(2, (tupledArg) => {\n        const classes = tupledArg[0];\n        const props = tupledArg[1];\n        return (x) => {\n            const matchValue = x;\n            return (matchValue[0] === \"className\") ? [cons(toString(matchValue[1]), classes), props] : [classes, cons(x, props)];\n        };\n    }), [empty(), empty()], reverse(xs));\n}\n\nexport function Helpers_combineClasses(cn, xs) {\n    const tupledArg = Helpers_extractClasses(xs);\n    return cons([\"className\", join(\" \", cons(cn, tupledArg[0]))], tupledArg[1]);\n}\n\n","import { Interop_reactApi } from \"../fable_modules/Feliz.1.57.0/Interop.fs.js\";\nimport { empty, cons, singleton, ofArray } from \"../fable_modules/fable-library.3.6.3/List.js\";\nimport { createElement } from \"react\";\nimport { createObj } from \"../fable_modules/fable-library.3.6.3/Util.js\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.18.0/ElementBuilders.fs.js\";\nimport { Msg } from \"./Update.js\";\nimport { IncludePos, DownloadFormat } from \"../Shared/fs/Shared.js\";\nimport { interpolate, toText } from \"../fable_modules/fable-library.3.6.3/String.js\";\nimport { empty as empty_1, map, toArray, singleton as singleton_1, append, delay, toList } from \"../fable_modules/fable-library.3.6.3/Seq.js\";\nimport { value as value_251 } from \"../fable_modules/fable-library.3.6.3/Option.js\";\n\nexport function navbar(_model, _dispatch) {\n    let elms, props, children_2, elms_1, props_4, props_7;\n    const props_11 = ofArray([[\"className\", \"is-fixed-top\"], [\"className\", \"has-shadow\"], [\"className\", \"is-info\"], [\"children\", Interop_reactApi.Children.toArray([(elms = singleton((props = ofArray([[\"style\", {\n        fontSize: 20 + \"px\",\n    }], [\"children\", \"Oslo-Bergen-taggeren på nett\"]]), createElement(\"div\", createObj(Helpers_combineClasses(\"navbar-item\", props))))), createElement(\"div\", {\n        className: \"navbar-brand\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), (children_2 = singleton((elms_1 = ofArray([(props_4 = ofArray([[\"href\", \"https://www.hf.uio.no/iln/tjenester/kunnskap/sprak/ob-tagger/index.html\"], [\"target\", \"_blank\"], [\"children\", Interop_reactApi.Children.toArray([createElement(\"img\", {\n        src: \"obt5-liten.png\",\n    })])]]), createElement(\"a\", createObj(Helpers_combineClasses(\"navbar-item\", props_4)))), (props_7 = ofArray([[\"href\", \"https://www.hf.uio.no/iln/om/organisasjon/tekstlab/\"], [\"target\", \"_blank\"], [\"children\", Interop_reactApi.Children.toArray([createElement(\"img\", {\n        src: \"logo.png\",\n    })])]]), createElement(\"a\", createObj(Helpers_combineClasses(\"navbar-item\", props_7))))]), createElement(\"div\", {\n        className: \"navbar-end\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    }))), createElement(\"div\", {\n        className: \"navbar-menu\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_2)),\n    }))])]]);\n    return createElement(\"nav\", createObj(Helpers_combineClasses(\"navbar\", props_11)));\n}\n\nexport function view(model, dispatch) {\n    let elms_2, elms_1, elms, matchValue_1, elms_5, elms_3, elms_4, elms_6, s_2, elms_7, children_7, children_9, children_11, value_203, value_204, value_205, value_206, value_207, value_208, value_209, value_210, elms_17, elms_15, elms_16, props_90, matchValue_3, contentHash, children_39, elms_10, elm_6, elms_11, children_26, props_49, children_28, elm_9, elms_13, elms_12, children_33, props_60, children_35, props_63, props_92;\n    let displayedFilename;\n    const matchValue = model.Filename;\n    displayedFilename = ((matchValue == null) ? \"Ingen fil valgt\" : matchValue);\n    let textSelector;\n    const props_8 = ofArray([[\"className\", \"has-name\"], [\"children\", Interop_reactApi.Children.toArray([(elms_2 = ofArray([createElement(\"input\", createObj(cons([\"type\", \"file\"], Helpers_combineClasses(\"file-input\", ofArray([[\"onChange\", (ev) => {\n        const files = ev.target.files;\n        if ((!(files == null)) && (files.length > 0)) {\n            dispatch(new Msg(0, files.item(0)));\n        }\n    }], [\"accept\", \"text/plain\"]]))))), (elms_1 = ofArray([(elms = singleton(createElement(\"i\", {\n        className: \"fas fa-upload\",\n    })), createElement(\"span\", {\n        className: \"file-icon\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), createElement(\"div\", {\n        className: \"field-label\",\n        children: \"Velg tekstfil...\",\n    })]), createElement(\"span\", {\n        className: \"file-cta\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    })), createElement(\"span\", {\n        className: \"file-name\",\n        children: displayedFilename,\n    })]), createElement(\"label\", {\n        className: \"file-label\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    }))])]]);\n    textSelector = createElement(\"div\", createObj(Helpers_combineClasses(\"file\", props_8)));\n    let taggingIndicator;\n    const props_17 = ofArray([[\"style\", {\n        marginTop: 20,\n    }], [\"children\", Interop_reactApi.Children.toArray(Array.from((matchValue_1 = model.TaggingStatus, (matchValue_1.tag === 1) ? singleton((elms_5 = ofArray([(elms_3 = singleton(createElement(\"div\", {\n        className: \"loader\",\n        style: {\n            fontSize: 3 + \"px\",\n            margin: 0,\n        },\n        children: \"Tagger tekst...\",\n    })), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_3)),\n    })), (elms_4 = singleton(createElement(\"div\", {\n        children: [\"Tagger tekst...\"],\n    })), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_4)),\n    }))]), createElement(\"div\", {\n        className: \"level-left\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_5)),\n    }))) : ((matchValue_1.tag === 2) ? singleton((elms_6 = singleton((s_2 = (`Ferdig med å tagge ${model.Filename}`), createElement(\"div\", {\n        className: \"level-item\",\n        children: s_2,\n    }))), createElement(\"div\", {\n        className: \"level-left\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_6)),\n    }))) : empty()))))]]);\n    taggingIndicator = createElement(\"nav\", createObj(Helpers_combineClasses(\"level\", props_17)));\n    let lemmaDownloadButtons;\n    const elm_3 = [(elms_7 = ofArray([createElement(\"div\", {\n        className: \"level-item\",\n        children: \"Last ned:\",\n    }), (children_7 = singleton(createElement(\"button\", createObj(Helpers_combineClasses(\"button\", ofArray([[\"className\", \"is-info\"], [\"onClick\", (_arg1) => {\n        dispatch(new Msg(6, new DownloadFormat(0)));\n    }], [\"children\", \"Excel\"]]))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_7)),\n    })), (children_9 = singleton(createElement(\"button\", createObj(Helpers_combineClasses(\"button\", ofArray([[\"className\", \"is-info\"], [\"onClick\", (_arg2) => {\n        dispatch(new Msg(6, new DownloadFormat(1)));\n    }], [\"children\", \"Tabseparert\"]]))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_9)),\n    })), (children_11 = singleton(createElement(\"button\", createObj(Helpers_combineClasses(\"button\", ofArray([[\"className\", \"is-info\"], [\"onClick\", (_arg3) => {\n        dispatch(new Msg(6, new DownloadFormat(2)));\n    }], [\"children\", \"Kommaseparert\"]]))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_11)),\n    }))]), createElement(\"div\", {\n        className: \"level-left\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_7)),\n    }))];\n    lemmaDownloadButtons = createElement(\"nav\", {\n        className: \"level\",\n        children: Interop_reactApi.Children.toArray(Array.from(elm_3)),\n    });\n    let textInfo;\n    const matchValue_2 = model.TaggedTextInfo;\n    if (matchValue_2 == null) {\n        textInfo = null;\n    }\n    else {\n        const ti = matchValue_2;\n        const elms_14 = ofArray([(value_203 = (`Alle tokens: ${ti.NumAllTokens}`), createElement(\"div\", {\n            children: [value_203],\n        })), (value_204 = (`Ordformer (alle tokens - tegnsetting): ${ti.NumWordTokens}`), createElement(\"div\", {\n            children: [value_204],\n        })), (value_205 = (`Ordtyper (forskjellige ordformer): ${ti.NumWordTypes}`), createElement(\"div\", {\n            children: [value_205],\n        })), (value_206 = toText(interpolate(\"Ordtyper/ordformer: %.2f%P()\", [ti.NumWordTypes / ti.NumWordTokens])), createElement(\"div\", {\n            children: [value_206],\n        })), (value_207 = (`Ordlemmatyper (forskjellige ordlemmaer): ${ti.NumWordLemmaTypes}`), createElement(\"div\", {\n            children: [value_207],\n        })), (value_208 = toText(interpolate(\"Ordlemmatyper/ordlemmaer: %.2f%P()\", [ti.NumWordLemmaTypes / ti.NumWordTokens])), createElement(\"div\", {\n            children: [value_208],\n        })), (value_209 = toText(interpolate(\"Gjennomsnittlig ordlengde: %.2f%P()\", [ti.AvgWordLength])), createElement(\"div\", {\n            children: [value_209],\n        })), (value_210 = toText(interpolate(\"Gjennomsnittlig setningslengde: %.2f%P()\", [ti.AvgSentenceLength])), createElement(\"div\", {\n            children: [value_210],\n        }))]);\n        textInfo = createElement(\"div\", {\n            className: \"box\",\n            children: Interop_reactApi.Children.toArray(Array.from(elms_14)),\n        });\n    }\n    const children_45 = ofArray([navbar(model, dispatch), (elms_17 = ofArray([(elms_15 = ofArray([createElement(\"span\", {\n        children: [\"Last opp en fil i txt-format (utf-8) og få den morfologisk tagga med \"],\n    }), createElement(\"a\", {\n        href: \"https://www.hf.uio.no/iln/tjenester/kunnskap/sprak/ob-tagger/index.html\",\n        target: \"_blank\",\n        style: {\n            color: \"#485fc7\",\n            textDecoration: \"none\",\n        },\n        children: \"Oslo-Bergen-taggeren for bokmål\",\n    }), createElement(\"span\", {\n        children: [\".\"],\n    }), createElement(\"span\", {\n        children: [\" Resultatet kan lastes ned eller vises i \"],\n    }), createElement(\"a\", {\n        href: \"https://voyant-tools.org/\",\n        target: \"_blank\",\n        style: {\n            color: \"#485fc7\",\n            textDecoration: \"none\",\n        },\n        children: \"Voyant\",\n    }), createElement(\"span\", {\n        children: [\".\"],\n    }), createElement(\"br\", {}), createElement(\"span\", {\n        children: [\" Du kan også få en oversikt over alle lemmaer i teksten, få gjennomsnittlig ordlengde og setningslengde mm.\"],\n    }), createElement(\"br\", {}), createElement(\"b\", {\n        children: [\"NB!\"],\n    }), createElement(\"span\", {\n        children: [\" Teksten kan være på maks 1MB, og store tekster kan ta opptil tre minutter å tagge.\"],\n    })]), createElement(\"div\", {\n        className: \"notification\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_15)),\n    })), (elms_16 = ofArray([(props_90 = singleton([\"children\", Interop_reactApi.Children.toArray([textSelector, taggingIndicator, textInfo, (matchValue_3 = model.TaggedTextInfo, (matchValue_3 == null) ? null : ((contentHash = matchValue_3.ContentHash.fields[0], (children_39 = ofArray([(elms_10 = ofArray([createElement(\"button\", createObj(Helpers_combineClasses(\"button\", ofArray([[\"className\", \"is-info\"], [\"onClick\", (_arg4) => {\n        dispatch(new Msg(2));\n    }], [\"children\", \"Last ned tagga tekst\"]])))), createElement(\"button\", createObj(Helpers_combineClasses(\"button\", ofArray([[\"className\", \"is-info\"], [\"onClick\", (_arg5) => {\n        dispatch(new Msg(4));\n    }], [\"children\", \"Vis lemmaer\"]]))))]), createElement(\"div\", {\n        className: \"buttons\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_10)),\n    })), (elm_6 = [(elms_11 = ofArray([createElement(\"div\", {\n        className: \"level-item\",\n        children: \"Last ned lemmatisert tekst:\",\n    }), (children_26 = singleton((props_49 = ofArray([[\"className\", \"is-info\"], [\"style\", {\n        marginLeft: 38,\n    }], [\"onClick\", (_arg6) => {\n        dispatch(new Msg(8, new IncludePos(0, true)));\n    }], [\"children\", \"Med ordklasser\"]]), createElement(\"button\", createObj(Helpers_combineClasses(\"button\", props_49))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_26)),\n    })), (children_28 = singleton(createElement(\"button\", createObj(Helpers_combineClasses(\"button\", ofArray([[\"className\", \"is-info\"], [\"onClick\", (_arg7) => {\n        dispatch(new Msg(8, new IncludePos(0, false)));\n    }], [\"children\", \"Uten ordklasser\"]]))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_28)),\n    }))]), createElement(\"div\", {\n        className: \"level-left\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_11)),\n    }))], createElement(\"nav\", {\n        className: \"level\",\n        children: Interop_reactApi.Children.toArray(Array.from(elm_6)),\n    })), (elm_9 = [(elms_13 = ofArray([(elms_12 = ofArray([createElement(\"span\", {\n        children: [\"Åpne lemmatisert tekst i\"],\n    }), createElement(\"a\", {\n        style: {\n            marginLeft: 5,\n        },\n        href: \"https://voyant-tools.org/\",\n        target: \"_blank\",\n        children: \"Voyant:\",\n    })]), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_12)),\n    })), (children_33 = singleton((props_60 = ofArray([[\"className\", \"is-info\"], [\"href\", `https://voyant.lincsproject.ca/?input=https://tekstlab.uio.no/obt_nett/rest/lemmatized_text/1/${contentHash}`], [\"target\", \"_blank\"], [\"children\", \"Med ordklasser\"]]), createElement(\"a\", createObj(Helpers_combineClasses(\"button\", props_60))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_33)),\n    })), (children_35 = singleton((props_63 = ofArray([[\"className\", \"is-info\"], [\"href\", `https://voyant.lincsproject.ca/?input=https://tekstlab.uio.no/obt_nett/rest/lemmatized_text/0/${contentHash}`], [\"target\", \"_blank\"], [\"children\", \"Uten ordklasser\"]]), createElement(\"a\", createObj(Helpers_combineClasses(\"button\", props_63))))), createElement(\"div\", {\n        className: \"level-item\",\n        children: Interop_reactApi.Children.toArray(Array.from(children_35)),\n    }))]), createElement(\"div\", {\n        className: \"level-left\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_13)),\n    }))], createElement(\"nav\", {\n        className: \"level\",\n        children: Interop_reactApi.Children.toArray(Array.from(elm_9)),\n    }))]), createElement(\"span\", {\n        children: Interop_reactApi.Children.toArray(Array.from(children_39)),\n    })))))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"column\", props_90)))), (props_92 = ofArray([[\"style\", {\n        marginLeft: 20,\n    }], [\"children\", Interop_reactApi.Children.toArray(Array.from(toList(delay(() => ((model.Lemmas != null) ? append(singleton_1(lemmaDownloadButtons), delay(() => {\n        let lemmas, header, children_17, children_15, body, children_21, elms_9;\n        return singleton_1((lemmas = value_251(model.Lemmas), (header = ((children_17 = singleton((children_15 = ofArray([createElement(\"td\", {\n            children: [\"Frekvens\"],\n        }), createElement(\"td\", {\n            children: [\"Lemma\"],\n        }), createElement(\"td\", {\n            children: [\"Ordklasse\"],\n        })]), createElement(\"tr\", {\n            children: Interop_reactApi.Children.toArray(Array.from(children_15)),\n        }))), createElement(\"thead\", {\n            children: Interop_reactApi.Children.toArray(Array.from(children_17)),\n        }))), (body = ((children_21 = toArray(delay(() => map((lemma) => {\n            const children_19 = ofArray([createElement(\"td\", {\n                style: {\n                    textAlign: \"right\",\n                },\n                children: lemma.Frequency,\n            }), createElement(\"td\", {\n                children: [lemma.Form],\n            }), createElement(\"td\", {\n                children: [lemma.Pos],\n            })]);\n            return createElement(\"tr\", {\n                children: Interop_reactApi.Children.toArray(Array.from(children_19)),\n            });\n        }, lemmas))), createElement(\"tbody\", {\n            children: Interop_reactApi.Children.toArray(Array.from(children_21)),\n        }))), (elms_9 = singleton(createElement(\"table\", {\n            className: \"table\",\n            children: Interop_reactApi.Children.toArray([header, body]),\n        })), createElement(\"div\", {\n            className: \"table-container\",\n            children: Interop_reactApi.Children.toArray(Array.from(elms_9)),\n        }))))));\n    })) : empty_1())))))]]), createElement(\"div\", createObj(Helpers_combineClasses(\"column\", props_92))))]), createElement(\"div\", {\n        className: \"columns\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_16)),\n    }))]), createElement(\"section\", {\n        className: \"section\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_17)),\n    }))]);\n    return createElement(\"span\", {\n        children: Interop_reactApi.Children.toArray(Array.from(children_45)),\n    });\n}\n\n","import { ProgramModule_view, ProgramModule_withSetState } from \"../Fable.Elmish.3.1.0/program.fs.js\";\nimport * as react_dom from \"react-dom\";\nimport { uncurry } from \"../fable-library.3.6.3/Util.js\";\nimport { Common_lazyView2With } from \"./common.fs.js\";\n\nexport function Program_Internal_withReactBatchedUsing(lazyView2With, placeholderId, program) {\n    let lastRequest = void 0;\n    return ProgramModule_withSetState((model, dispatch) => {\n        if (lastRequest != null) {\n            window.cancelAnimationFrame(lastRequest);\n        }\n        lastRequest = window.requestAnimationFrame((_arg1) => {\n            react_dom.render(lazyView2With((x, y) => (x === y), uncurry(2, ProgramModule_view(program)), model, dispatch), document.getElementById(placeholderId));\n        });\n    }, program);\n}\n\nexport function Program_Internal_withReactSynchronousUsing(lazyView2With, placeholderId, program) {\n    return ProgramModule_withSetState((model, dispatch) => {\n        react_dom.render(lazyView2With((x, y) => (x === y), uncurry(2, ProgramModule_view(program)), model, dispatch), document.getElementById(placeholderId));\n    }, program);\n}\n\nexport function Program_Internal_withReactHydrateUsing(lazyView2With, placeholderId, program) {\n    return ProgramModule_withSetState((model, dispatch) => {\n        react_dom.hydrate(lazyView2With((x, y) => (x === y), uncurry(2, ProgramModule_view(program)), model, dispatch), document.getElementById(placeholderId));\n    }, program);\n}\n\nexport function Program_withReactBatched(placeholderId, program) {\n    return Program_Internal_withReactBatchedUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReactSynchronous(placeholderId, program) {\n    return Program_Internal_withReactSynchronousUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReact(placeholderId, program) {\n    return Program_Internal_withReactBatchedUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReactUnoptimized(placeholderId, program) {\n    return Program_Internal_withReactSynchronousUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReactHydrate(placeholderId, program) {\n    return Program_Internal_withReactHydrateUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\n}\n\n","import { ProgramModule_mkProgram, ProgramModule_run } from \"../fable_modules/Fable.Elmish.3.1.0/program.fs.js\";\nimport { Program_withReactSynchronous } from \"../fable_modules/Fable.Elmish.React.3.0.1/react.fs.js\";\nimport { update, init } from \"./Update.js\";\nimport { view } from \"./View.js\";\n\nProgramModule_run(Program_withReactSynchronous(\"elmish-app\", ProgramModule_mkProgram(init, (msg, model) => update(msg, model), (model_1, dispatch) => view(model_1, dispatch))));\n\n"],"names":["x","Array","isArray","ArrayBuffer","isView","isHashable","GetHashCode","sameConstructor","y","Object","getPrototypeOf","constructor","Enumerator","iter","this","current","cur","next","value","done","Error","Dispose","o","GetEnumerator","Symbol","iterator","en","hasNext","undefined","Lazy","factory","isValueCreated","Value","createdValue","IsValueCreated","i","length","str","toString","date","date1","offset","kind","getTimezoneOffset","int32ToString","radix","ObjectRef","static","idMap","has","set","count","get","stringHash","s","h","len","charCodeAt","numberHash","combineHashCodes","hashes","reduce","h1","h2","arrayHash","Date","getTime","dateHash","values","map","v","id","equalArraysWith","eq","Equals","isEquatable","xKeys","keys","yKeys","sort","equalObjects","xtime","ytime","compareArrays","comp","j","compareArraysWith","CompareTo","isComparable","key","compareObjects","max","comparer","createObj","fields","obj","kv","WeakMap","CURRIED","arity","f","uncurried","args","res","_curry","arg","concat","callStack","self","seqToString","cons","entries","k","join","name","String","cases","tag","toJSON","fieldStr","withParens","indexOf","unionToString","splice","other","recordToJSON","recordToString","recordGetHashCode","thisNames","recordEquals","result","recordCompareTo","contentsOrGetter","setter","getter","contents","NumberStyles","getRange","unsigned","bitsize","isValid","style","exec","replace","prefix","digits","AllowHexSpecifier","getRadix","invalidDigits","getInvalidDigits","test","regexMatch","sign","validResponse","Number","parseInt","isNaN","umin","umax","min","tryParse","defValue","_a","symbol","isNumeric","multiply","toFixed","dp","toPrecision","sd","toExponential","toHex","wasm","WebAssembly","Instance","Module","Uint8Array","exports","e","Long","low","high","isLong","prototype","substr","bytes","le","fromBytesLE","fromBytesBE","fromBytes","$this","hi","lo","toBytesLE","toBytesBE","__isLong__","defineProperty","INT_CACHE","UINT_CACHE","fromInt","cachedObj","cache","fromNumber","UZERO","ZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","negate","TWO_PWR_32_DBL","lowBits","highBits","pow_dbl","Math","pow","fromString","RangeError","p","substring","radixToPower","size","add","val","TWO_PWR_16_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","toNumber","isZero","isNegative","radixLong","div","divide","rem1","subtract","rem","remDiv","isOdd","lessThan","greaterThan","greaterThanOrEqual","thisNeg","otherNeg","not","addend","a48","a32","a16","a00","b48","b32","b16","c48","c32","c16","c00","subtrahend","multiplier","mul","get_high","b00","divisor","approx","div_u","div_s","toUnsigned","numBits","shiftRightUnsigned","shiftLeft","shiftRight","floor","log2","ceil","log","LN2","delta","approxRes","approxRem","op_UnaryNegation","xh","_bitsize","lessOrEqual","padStart","maxValue","getMaxValue","toUpperCase","isMinus","minutes","abs","dateToHalfUTCString","half","toISOString","dateToStringWithCustomFormat","format","utc","match","rep","NaN","getUTCFullYear","getFullYear","getUTCMonth","getMonth","getUTCDate","getDate","getUTCHours","getHours","getUTCMinutes","getMinutes","getUTCSeconds","getSeconds","getUTCMilliseconds","getMilliseconds","_provider","_b","_c","d","dateWithOffset","dateToISOStringWithOffset","dateToStringWithOffset","toUTCString","toLocaleString","toLocaleDateString","toLocaleTimeString","printOffset","dateToISOString","dateToStringWithKind","parseRaw","input","fail","trim","m","baseDate","timeInSeconds","timeParts","split","parseFloat","offsetInMinutes","detectUTC","fsFormatRegExp","interpolateRegExp","formatRegExp","isLessThan","printf","cont","lastIndex","strParts","matches","strIdx","matchIndex","index","push","createPrinter","interpolate","valIdx","flags","padLength","precision","formatReplacement","continuePrint","toText","toFail","toLowerCase","zeroFlag","minusFlag","ch","padLeft","_strParts","_matches","_result","padArg","slice","_padLength","shift","_","idx","pattern","intPart","decimalPart","decimalPartLength","thousandGroups","thousands","intPartLength","endsWith","search","lastIndexOf","isNullOrEmpty","delimiter","xs","from","fromBase64String","b64Encoded","binary","atob","notSupported","isRight","Some","Helpers_allocateArrayFromCons","indexNotFound","target","targetIndex","start","fill","mapIndexed","source","arrays","arrays_1","totalIdx","totalLength","idx_1","arr_2","initializer","take","array","predicate","find","zip","array1","array2","differentLengths","equals","length1","length2","head","tail","super","xs_1_mut","ys_1_mut","loop","xs_1","ys_1","matchValue","xt","yt","i_mut","h_mut","t","_key","c","ListEnumerator$1","it","__","FSharpList_get_Empty","FSharpList_Cons_305B8EAC","FSharpList__get_IsEmpty","FSharpList__get_Length","FSharpList__get_Head","FSharpList__get_Tail","folder","state","acc","action","unitVar0","tail_1","mapping","root","node","t_2","setPrototypeOf","Trampoline","callCount","maxTrampolineCallCount","incrementAndCheck","hijack","setTimeout","ctx","cancelToken","isCancelled","onCancel","trampoline","err","onError","Bind","computation","binder","onSuccess","ex","Combine","computation1","computation2","Delay","generator","For","sequence","body","While","Return","ReturnFrom","TryFinally","compensation","TryWith","catchHandler","ex2","Using","resource","guard","Zero","FSharpChoice$2","emptyContinuation","_x","defaultCancellationToken","cancelled","_id","_cancelled","_listeners","Map","cancel","listener","addListener","removeListener","delete","register","$","startImmediate","cancellationToken","continuation","exceptionContinuation","cancellationContinuation","startWithContinuations","delegates","Add","_addHandler","Publish","Trigger","senderOrValue","valueOrUndefined","sender","forEach","AddHandler","handler","RemoveHandler","_removeHandler","Subscribe","callback","OnNext","onNext","onCompleted","OnError","_e","OnCompleted","Timer_delay","interval","returnVal","_enabled","_isDisposed","_intervalId","_timeoutId","Interval","AutoReset","_elapsed","Elapsed","Enabled","setInterval","clearTimeout","clearInterval","Close","Start","Stop","Cmd_exec","dispatch","cmd","call","Cmd_OfAsyncWith_perform","task","ofSuccess","arg_1","work","Choice_makeChoice1Of2","_arg1","r","Cmd_OfAsync_start","e1","e2","Compare","Enumerator_notStarted","Enumerator_alreadyFinished","Enumerator_Seq","Enumerator_FromFunctions$1","dispose","Enumerator_noReset","Enumerator_FromFunctions$1_$ctor_58C54629","Enumerator_generateWhileSome","openf","compute","closef","curr","started","x_1","finish","matchValue_1","mkSeq","Enumerator_Seq_$ctor_673A07F2","argName","Operators_NullArg","sources","outerOpt","innerOpt","finished","inner","outer","copyOfStruct","inner_1","outer_1","Enumerator_concat","ar","xs_3","enumerator","xs_5","ofSeq","ys","create","e_1","Enumerator_enumerateThenFinally","integralRangeStep","step","stop","zero","stepFn","stepComparedWithZero","stepGreaterThanZero","comparedWithLast","makeRangeStepFunction","st_1","Enumerator_unfold","RingState$1","RingBuffer$1","RingBuffer$1__Pop","wix","rix","items","rix$0027","RingBuffer$1__Push_2B595","item","wix_1","items_1","wix$0027","ix","Program$4","init","update","subscribe","view","setState","syncDispatch","ProgramModule_runWith","program","patternInput","model","rb","reentered","msg","nextMsg","msg_1","patternInput_1","model$0027","ex_1","ex_3","lists","xs_6","ex_2","LazyProps$1","render","equal","Components_LazyView$1","Component","props","shouldComponentUpdate","nextProps","_nextState","CaseInfo","declaringType","TypeInfo","fullname","generics","construct","parent","enumCases","fullName","getHashCode","getGenerics","t1","t2","getRecordElements","k1","v1","k2","v2","caseNames","argType","returnType","generic","info","elemType","getElementType","getUnionCases","getFunctionElements","isFunction","gen","isTuple","startsWith","getUnionFields","case_","getRecordField","field","makeUnion","uci","expectedLength","makeRecord","_t","FileByteArray","ContentHash","ContentHash$reflection","IncludePos","TaggedTextInfo","NumAllTokens","NumWordTokens","NumWordTypes","NumWordLemmaTypes","AvgWordLength","AvgSentenceLength","DownloadFormat","IServerApi","TagText","DownloadTaggedText","GetLemmas","DownloadLemmas","DownloadLemmatizedText","HttpMethod","RequestBody","Url","Headers","WithCredentials","HttpResponse","StatusCode","ResponseBody","CustomHeaders","BaseUrl","Authorization","RouteBuilder","CustomResponseSerialization","ProxyRequestException","message","response","errorMsg","reponseText","ProxyRequestException_$ctor_76BC5104","RecordField","FieldName","FieldType","PropertyInfo","UnionCase","CaseName","CaseTypes","Info","tryGetValue","defaultValue","addToDict","dict","Dictionary","pairs","this$","hashMap","pair","Dictionary__Add_5BDDA1","toStringTag","Dictionary__Clear","Dictionary__TryFind_2B595","pattern_matching_result","arrayIndex","Dictionary__get_Count","Dictionary__Remove_2B595","Dictionary__ContainsKey_2B595","Dictionary__get_Item_2B595","Dictionary__set_Item_5BDDA1","clear","thisArg","Dictionary__TryFindIndex_2B595","outArg","findIndex","flattenFuncTypes","typeDef","$007CFuncType$007C_$007C","lazyToDelayed","l","_createTypeInfo","resolvedType","l_3","l_4","l_5","l_6","l_7","l_8","l_9","l_10","l_11","l_12","l_13","l_14","l_15","l_16","l_17","activePatternResult2709","primType","$007CPrimitiveType$007C_$007C","activePatternResult2708","types","resolvedType_1","createTypeInfo","activePatternResult2707","isRecord","$007CRecordType$007C_$007C","l_1","activePatternResult2706","isUnion","prop","$007CUnionType$007C_$007C","l_2","resolvedType_2","activePatternResult2705","isEnum","getEnumUnderlyingType","activePatternResult2704","$007CListType$007C_$007C","elemType_1","activePatternResult2703","$007CResizeArrayType$007C_$007C","elemType_2","activePatternResult2702","$007CHashSetType$007C_$007C","elemType_3","activePatternResult2701","$007CArrayType$007C_$007C","elemType_4","activePatternResult2700","getTupleElements","$007CTupleType$007C_$007C","types_1","resolvedType_3","activePatternResult2699","$007COptionType$007C_$007C","elemType_5","activePatternResult2698","$007CNullable$007C_$007C","elemType_6","activePatternResult2697","$007CSetType$007C_$007C","elemType_7","activePatternResult2696","genArgs","$007CMapType$007C_$007C","keyType","valueType","activePatternResult2695","$007CDictionaryType$007C_$007C","keyType_1","valueType_1","activePatternResult2694","$007CSeqType$007C_$007C","elemType_8","activePatternResult2693","$007CAsyncType$007C_$007C","elemType_9","activePatternResult2692","$007CPromiseType$007C_$007C","elemType_10","typeInfoCache","ti_1","isPrimitive","enumUnion","every","case$","InternalUtilities_toUInt8Array","data","ByteArrayExtensions_SaveFileAs_72B26259","content","fileName","binaryData","blob","Blob","buffer","type","dataUrl","window","URL","createObjectURL","anchor","document","createElement","href","download","rel","click","remove","revokeObjectURL","defaultRequestConfig","get$","url","post","withHeaders","headers","req","withBody","sendAndRead","preparation","resultMapper","token","tupledArg","xhr","XMLHttpRequest","open","abort","forLoopVar","setRequestHeader","withCredentials","onreadystatechange","readyState","isCancellationRequested","matchValue_2","send","MapTreeLeaf$2","MapTreeLeaf$2_$ctor_5BDDA1","MapTreeLeaf$2__get_Key","MapTreeLeaf$2__get_Value","MapTreeNode$2","left","right","MapTreeNode$2_$ctor_499A11FD","MapTreeNode$2__get_Left","MapTreeNode$2__get_Right","MapTreeNode$2__get_Height","MapTreeModule_sizeAux","acc_mut","m_mut","m2","MapTreeModule_size","MapTreeModule_mk","hl","hr","m2_1","m_2","MapTreeModule_rebalance","m2_2","m_3","m2_3","t1h","t2h","matchValue_3","MapTreeModule_add","MapTreeModule_empty","MapTreeModule_tryFind","comparer_mut","k_mut","MapTreeModule_iterOpt","f_mut","MapTreeModule_iter","MapTreeModule_copyToArray","arr","MapTreeModule_ofSeq","MapTreeModule_ofArray","MapTreeModule_ofList","ie","e_mut","MapTreeModule_mkFromEnumerator","MapTreeModule_MapIterator$2","stack","MapTreeModule_collapseLHS","stack_mut","rest","MapTreeModule_mkIterator","MapTreeModule_current","MapTreeModule_alreadyFinished","MapTreeModule_notStarted","MapTreeModule_mkIEnumerator","MapTreeModule_moveNext","FSharpMap","tree","combineHash","activePatternResult5790","FSharpMap__ComputeHashCode","that","m1","e1c","e2c","b1","b2","kvp1","kvp2","FSharpMap__ContainsKey","FSharpMap__get_Item","FSharpMap__get_Count","FSharpMap_$ctor","MapTreeModule_find","MapTreeModule_mem","table","FSharpMap__TryFind","containsKey","elements","FSharpMap_Create","m_1_mut","m_1","MapTreeModule_toList","empty","P","cmp","_this","MAX_DP","NAME","INVALID","INVALID_DP","DIV_BY_ZERO","UNDEFINED","NUMERIC","n","nl","charAt","Big","DP","RM","rm","more","xc","xci","unshift","pop","stringify","doExponential","isNonzero","isneg","yc","a","b","bl","bt","ri","bz","ai","al","rl","q","qc","qi","gt","gte","lt","lte","minus","sub","xlty","plus","xe","ye","reverse","mod","ygtx","times","one","prec","round","sqrt","NE","PE","strict","valueOf","_Big_","normalize","TypeError","Parsimmon","seed","elem","isParser","isBuffer","Buffer","makeSuccess","status","furthest","expected","makeFailure","mergeReplies","last","hasOwnProperty","union","makeLineColumnIndex","line","column","lines","assertParser","assertNumber","assertRegexp","RegExp","assertFunction","assertString","repeat","string","amount","leftPad","pad","char","rangeFromIndexAndOffsets","before","after","to","formatGot","error","lineWithErrorIndex","lineRange","lastLineNumberLabelLength","verticalMarkerLength","byteLineWithErrorIndex","columnByteIndex","byteRange","bytesPerLine","bytesAfter","bytesInChunks","chunkSize","chunks","chunkIndex","toChunks","byteLines","byteRow","byteValue","byteRangeToRange","byteLine","inputLines","lineWithErrorCurrentIndex","linesWithLineNumbers","lineSource","lineNumberLabel","isLineWithError","re","anchoredRegexp","parsers","arguments","numParsers","accum","seqMap","mapper","apply","results","alt","sepBy1","parser","separator","then","many","rs","regexp","group","anchored","fullMatch","groupMatch","parse","skip","or","alternative","wrap","leftParser","rightParser","middle","thru","wrapper","tieWith","assertArray","tie","prevResult","atMost","atLeast","fn","contramap","promap","g","mark","end","sepBy","lookahead","notFollowedBy","text","desc","reply","fallback","ap","chain","of","digit","optWhitespace","cr","lf","newline","Parsimmon_many","Parsimmon_ofLazy","Parsimmon_digit","Parsimmon_seperateBy","others","Parsimmon_between","skipped","Parsimmon_choose","ps","Parsimmon_satisfy","Parsimmon_str","Parsimmon_optionalWhitespace","Parsimmon_atLeastOneOrMany","Parsimmon_atLeast","Parsimmon_stringReturn","Parsimmon_seq2","Parsimmon_concat","strings","Parsimmon_seq3","jint","negJint","jfloat","digitsLeft","negativeJFloat","jnumber","arg0","jbool","jnull","stringLiteral","escape","Parsimmon_oneOf","anyCharSnippet","otherParser","tuple","c_1","withWhitespace","jvalue","comma","json$004099$002D1","arg_2","jsonParser","BigNat","bound","BigNatModule_FFT_pow32","x_mut","n_mut","BigNatModule_bound","BigNatModule_coeff","BigNatModule_coeff64","BigNatModule_setCoeff","BigNatModule_pow64","BigNatModule_pow32","BigNatModule_FFT_maxTwoPower","Int32Array","BigNatModule_baseBits","BigNatModule_baseN","BigNatModule_baseNi64","BigNatModule_baseMaski64","BigNatModule_divbase","BigNatModule_modbase","BigNatModule_createN","BigNatModule_normN","na_mut","na","findLeastBound","BigNatModule_embed","r_1","BigNatModule_eval32","BigNatModule_one","BigNatModule_zero","BigNatModule_degree","rbound","c_mut","p_mut","q_mut","r_mut","z","i_1","z_1","i_2","BigNatModule_addP","BigNatModule_lt","pa_mut","qa_mut","pa","qa","check","BigNatModule_compare","BigNatModule_mulSchoolBookCarry","rak","BigNatModule_mulSchoolBookOneSmall","bp","q_1","BigNatModule_encoding","bigL","twoToBigL","bigK","bigN","splits","BigNatModule_mkEncoding","BigNatModule_table","pSmall","qSmall","BigNatModule_mulSchoolBookBothSmall","ra","pai","qaj","BigNatModule_mulSchoolBookNeitherSmall","BigNatModule_mulSchoolBook","BigNatModule_scaleSubInPlace","ad","a_1","f_1","zLo","zHi","BigNatModule_scaleAddInPlace","BigNatModule_removeFactor","degx","dega","xa","aa","pn","qai","BigNatModule_copyN","Invariant","BigNatModule_toFloat","evalFloat","BigNatModule_ofInt32","BigNatModule_ofInt64","rem_u","rem_s","BigNatModule_embed64","BigNatModule_toString","degn","collect","isLeading_mut","digits_mut","n_1_mut","_arg1_mut","isLeading","n_1","n_2","prior_1","nL","nH","digits_4","prior_mut","ten2k_mut","prior","ten2k","route","BigNatModule_ofString","ten","build","BigNatModule_getSmall","signInt","BigInteger__get_SignInt","BigInteger__get_V","BigNatModule_hash","nn","BigInteger_$ctor_Z2BE94A1","BigInteger_nat_Z67CCE57D","smallLim","smallPosTab","BigInteger_posn_Z67CCE57D","arg00","text_1","toDecimal","BigInteger__get_ToDecimal","InteropUtil_isBigInt","InteropUtil_isObjectLiteral","SimpleJson_parse","Parsimmon_parse","SimpleJson_tryParse","SimpleJson_toString","arg10_1","_arg1_1","arg10_3","arg20","SimpleJson_toPlainObject","value_3","jsObject","enumerator_1","JSON","jsonValue","InteropUtil_isDateOffset","SimpleJson_parseNative$0027","activePatternResult2794","$007CNativeString$007C_$007C","activePatternResult2793","$007CNativeNumber$007C_$007C","activePatternResult2792","$007CNativeBool$007C_$007C","$007CNull$007C_$007C","activePatternResult2790","$007CNativeArray$007C_$007C","activePatternResult2789","$007CNativeObject$007C_$007C","object","SimpleJson_parseNative","DateTimeOffset","checkOffsetInRange","offsetMatch","fromDayNumber","dayNumber","ticks","Long_op_Multiply","ms","two","guidRegex","guidRegexNoHyphen","guidRegexHex","hyphenateGuid","wsTrimAndLowered","chars","littleEndian","getBytesInt32","DataView","byteOffset","byteLength","setInt32","getInt32","SetTreeLeaf$1","SetTreeLeaf$1_$ctor_2B595","SetTreeLeaf$1__get_Key","SetTreeNode$1","SetTreeNode$1_$ctor_Z6E7BE5F7","SetTreeNode$1__get_Left","SetTreeNode$1__get_Right","SetTreeNode$1__get_Height","SetTreeModule_countAux","t_mut","SetTreeModule_count","SetTreeModule_mk","t2_1","SetTreeModule_rebalance","t2_3","t_3","t2_4","t2_2","SetTreeModule_add","SetTreeModule_empty","SetTreeModule_mem","SetTreeModule_iter","SetTreeModule_SetIterator$1","SetTreeModule_collapseLHS","x2","SetTreeModule_mkIterator","SetTreeModule_current","SetTreeModule_alreadyFinished","SetTreeModule_notStarted","SetTreeModule_mkIEnumerator","SetTreeModule_moveNext","SetTreeModule_compare","l1_mut","l2_mut","SetTreeModule_compareStacks","l1","l2","x1_3","x2_3","t1_6","x1_4","t2_6","x2_4","matchValue_4","pattern_matching_result_1","t1_7","x1_5","t2_7","x2_5","c_3","c_2","matchValue_5","pattern_matching_result_2","t1_8","x1_6","t2_8","x2_6","pattern_matching_result_3","t1_2","x1","x2_1","pattern_matching_result_4","t1_4","x1_2","x2_2","SetTreeModule_copyToArray","SetTreeModule_ofSeq","delegateArg0","delegateArg1","SetTreeModule_ofArray","SetTreeModule_ofList","SetTreeModule_mkFromEnumerator","FSharpSet","FSharpSet__ComputeHashCode","FSharpSet__get_Comparer","FSharpSet__get_Tree","FSharpSet__get_Count","FSharpSet_$ctor","set$","HashSet__Add_2B595","HashSet__Clear","HashSet__Contains_2B595","HashSet__get_Count","HashSet__Remove_2B595","HashSet__TryFindIndex_2B595","v_1","Convert_insideBrowser","Function","Convert_InternalMap","Convert_flattenMap","Convert_$007CMapKey$007C_$007C","Convert_generateMap","json","Convert_$007CMapEmpty$007C_$007C","activePatternResult2872","activePatternResult2867","Convert_$007CMapOne$007C_$007C","activePatternResult2871","activePatternResult2869","Convert_$007CMapNode$007C_$007C","key_1","value_1","leftMap","rightMap","Convert_flatteFable3Map","Convert_flattenFable3Lists","linkedList","Convert_arrayLike","Convert_unionOfRecords","Convert_isRecord","found","Convert_optional","Convert_isQuoted","Convert_betweenQuotes","Convert_removeQuotes","startIndex","Convert_fromJsonAs","input_mut","typeInfo_mut","foundCase","foundCase_2","testExpr","values_8","tree_2","typeInfo","toLocaleLowerCase","value_4","value_5","value_7","value_8","value_9","value_10","value_11","value_12","value_13","value_14","value_15","value_16","value_17","value_18","value_19","value_20","value_21","value_22","value_23","value_24","value_25","getlElemType","value_26","getElemType","value_27","getElemType_1","value_28","genericJson","value_29","value_30","value_31","value_32","value_33","value_34","value_35","value_36","value_37","value_38","value_39","value_40","getTypes","jsonValue_5","optionalTypeDelayed_5","fromCharCode","underlyingType","originalType","outArg_1","arg20_1","arg20_2","WorkerGlobalScope","patternInput_2","unionType","caseName","values_1","caseName_1","activePatternResult2901","expectedCases","case$_1","arg20_4","foundCase_1","foundCase_3","foundCase_4","arg30_1","arg20_5","_arg2","case$_2","pattern_matching_result_5","caseInfo","caseName_2","caseType","input_1","typeInfo_1","expectedCases_1","case$_3","arg20_7","foundDiscriminatorKey","keyword","discriminatorValueJson","discriminatorValue","foundUnionCase","case$_4","case$_5","arg10_12","arg10_13","arg10_11","unexpectedJson","expectedType","pattern_matching_result_6","caseIndex","fieldValues","foundCase_5","value_46","arg20_8","arg10_10","pattern_matching_result_7","value_47","value_48","caseName_4","getTypes_2","_arg3","pattern_matching_result_8","patternInput_3","caseTypes","_arg4","case$_6","expectedCases_2","case$_7","arg20_11","pattern_matching_result_9","caseName_5","getTypes_3","getFields","serializedRecord","caseValue","getTypes_4","elementTypeDelayed","values_4","elementTypeDelayed_1","values_5","elementTypeDelayed_2","elementTypeDelayed_3","values_6","elementTypeDelayed_4","values_7","array_9","tupleTypesDelayed","dict_1","getTypes_5","getTypes_6","tuples","getTypes_7","tuples_1","dict_2","getTypes_8","getType","getTypes_9","getType_1","patternInput_4","caseTypes_1","_arg5","case$_8","expectedCases_3","case$_9","arg20_12","patternInput_5","cases_1","pattern_matching_result_10","caseName_6","caseName_8","values_3","otherwise_6","_arg6","case$_10","expectedCases_4","case$_11","arg20_13","_arg7","case$_12","foundCaseName","caseInfo_4","tupledArg_1","expectedCases_5","unexpectedJson_1","expectedType_1","elementType","value_53","elementType_1","value_55","elementType_2","value_57","elementType_3","x_2","y_1","value_59","elementType_4","value_61","tupledArg_2","patternInput_6","recordType","_arg3_1","fieldType","fieldName","_arg8","tupledArg_3","dictKeys","arg10_27","recordFields","arg10_30","_arg2_1","name_1","arg30_6","patternInput_7","keyValuePair","patternInput_8","pairs_1","keyValuePair_1","output","x_3","y_2","x_4","y_3","x_5","y_4","patternInput_9","keyType_2","pairs_2","tupledArg_4","output_1","x_6","y_5","x_7","y_6","x_8","y_7","forLoopVar_1","hashset","x_9","y_8","x_10","y_9","x_11","y_10","enumerator_2","patternInput_10","valueType_5","keyType_3","pattern_matching_result_11","comparer_1","tree_1","matchValue_6","inputJson","pairs_3","tupledArg_5","key_6","pattern_matching_result_12","comparer_3","tree_3","pairs_4","tupledArg_6","key_7","arg20_17","arg10_33","arg20_18","arg10_34","Convert_quoteText","inputText","escapable","meta","Convert_serialize","value_mut","copyOfStruct_1","copyOfStruct_2","copyOfStruct_3","copyOfStruct_4","Long_fromNumber","element","element_1","element_2","element_3","element_4","elementType_5","element_5","usedCase","serializedFields_1","serializedValues","serializedKey","serializedValue","MapTreeModule_toArray","serializedValues_1","serializedKey_1","serializedValue_1","tupleTypes","index_1","element_6","Proxy_proxyFetch","options","typeName","func","funcArgs","argumentCount","returnTypeAsync","binaryInput","baseUrl","arg10","trimEnd","Proxy_combineRouteWithBaseUrl","funcNeedParameters","contentType","inputArgumentTypes","executeRequest","Proxy_isAsyncOfByteArray","onOk","serializer","typ_mut","typ","Proxy_getReturnType","requestBody","responseType","xhr_1","statusCode","response_1","reader","FileReader","onload","readAsText","response_2","returnType_1","requestBody_1","responseText","response_3","arg1","arg2","arg3","arg4","arg5","arg6","arg7","inputArguments","TaggingStatus","Lemma","Frequency","Form","Pos","Model","Filename","Lemmas","Msg","serverApi","resolver","ResolveType","schemaType","fieldTypes","chooser","delegateArg0_1","delegateArg1_1","delegateArg2","delegateArg0_2","delegateArg1_2","delegateArg2_1","delegateArg3","delegateArg0_3","delegateArg1_3","delegateArg2_2","delegateArg3_1","delegateArg4","delegateArg0_4","delegateArg1_4","delegateArg2_3","delegateArg3_2","delegateArg4_1","delegateArg5","delegateArg0_5","delegateArg1_5","delegateArg2_4","delegateArg3_3","delegateArg4_2","delegateArg5_1","delegateArg6","delegateArg0_6","delegateArg1_6","delegateArg2_5","delegateArg3_4","delegateArg4_3","delegateArg5_2","delegateArg6_1","delegateArg7","Remoting_buildProxy_Z15584635","clo1","clo2","RemotingModule_createApi","methodName","Route_builder","Interop_reactApi","Helpers_combineClasses","cn","classes","Helpers_extractClasses","navbar","_model","_dispatch","elms","children_2","elms_1","props_4","props_7","props_11","Children","toArray","fontSize","className","children","src","ProgramModule_run","console","ProgramModule_mkProgram","arg0_1","arg0_2","arg0_4","extension","arg0_5","file","instance","readAsArrayBuffer","alert","model_1","elms_2","elms_5","elms_3","elms_4","elms_6","s_2","elms_7","children_7","children_9","children_11","value_203","value_204","value_205","value_206","value_207","value_208","value_209","value_210","elms_17","elms_15","elms_16","props_90","contentHash","children_39","elms_10","elm_6","elms_11","children_26","props_49","children_28","elm_9","elms_13","elms_12","children_33","props_60","children_35","props_63","props_92","displayedFilename","textSelector","props_8","ev","files","taggingIndicator","props_17","marginTop","margin","lemmaDownloadButtons","elm_3","textInfo","ti","elms_14","children_45","color","textDecoration","marginLeft","lemmas","header","children_17","children_15","children_21","elms_9","lemma","children_19","textAlign","lazyView2With","placeholderId","getElementById","Program_Internal_withReactSynchronousUsing"],"sourceRoot":""}