{"version":3,"file":"app.abcb6ebccf4f72f208f3.js","mappings":"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","sources":["webpack:///./src/Client/fable_modules/fable-library.3.7.5/Util.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Types.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Int32.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Numeric.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/lib/long.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Long.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Date.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/RegExp.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/String.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Global.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Option.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Array.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/List.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/AsyncBuilder.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Choice.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Async.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Event.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Timer.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Observable.js","webpack:///./src/Client/fable_modules/Fable.Elmish.3.1.0/cmd.fs.js","webpack:///./src/Client/fable_modules/Fable.Elmish.3.1.0/prelude.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/FSharp.Core.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/FSharp.Collections.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Seq.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Range.js","webpack:///./src/Client/fable_modules/Fable.Elmish.3.1.0/ring.fs.js","webpack:///./src/Client/fable_modules/Fable.Elmish.3.1.0/program.fs.js","webpack:///./src/Client/fable_modules/Fable.Elmish.React.3.0.1/common.fs.js","webpack:///./src/Client/fable_modules/Fable.Elmish.Browser.3.0.4/navigation.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Map.js","webpack:///./src/Client/fable_modules/Fable.Elmish.Browser.3.0.4/prelude.fs.js","webpack:///./src/Client/fable_modules/Fable.Elmish.Browser.3.0.4/parser.fs.js","webpack:///./src/Client/Routing.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Reflection.js","webpack:///./src/Shared/IssueTypes.fs.js","webpack:///./src/Shared/FormModel.fs.js","webpack:///./src/Shared/CaptchaTypes.fs.js","webpack:///./src/Client/fable_modules/Fable.Remoting.Client.7.24.0/Types.fs.js","webpack:///./src/Client/fable_modules/Fable.Parsimmon.4.1.0/Parsimmon.js","webpack:///./src/Client/fable_modules/Fable.Parsimmon.4.1.0/Parsimmon.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Double.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/Json.fs.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/Parser.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/lib/big.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Decimal.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/BigInt/n.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/BigInt/z.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/BigInt.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/SimpleJson.fs.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/TypeCheck.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Uri.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/DateOffset.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/DateOnly.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/TimeOnly.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Guid.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/BitConverter.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Set.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/TypeInfo.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/MapUtil.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/MutableMap.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/MutableSet.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/TypeInfo.Converter.fs.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/Json.Converter.fs.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/isBrowser.js","webpack:///./src/Client/fable_modules/Fable.SimpleJson.3.24.0/quote.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/TimeSpan.js","webpack:///./src/Client/fable_modules/Fable.Remoting.Client.7.24.0/Http.fs.js","webpack:///./src/Client/fable_modules/Fable.Remoting.Client.7.24.0/Extensions.fs.js","webpack:///./src/Client/fable_modules/Fable.Remoting.Client.7.24.0/Proxy.fs.js","webpack:///./src/Shared/Shared.fs.js","webpack:///./src/Client/State.fs.js","webpack:///./src/Client/fable_modules/Fable.Remoting.Client.7.24.0/Remoting.fs.js","webpack:///./src/Client/fable_modules/Feliz.1.68.0/Interop.fs.js","webpack:///./src/Client/fable_modules/Feliz.1.68.0/React.fs.js","webpack:///./src/Client/fable_modules/Feliz.SweetAlert.2.8.0/Bindings.fs.js","webpack:///./src/Client/alerts.fs.js","webpack:///./src/Client/fable_modules/Feliz.Bulma.2.19.0/ElementBuilders.fs.js","webpack:///./src/Client/Modal.fs.js","webpack:///./src/Client/nfdi-webcomponents.fs.js","webpack:///./src/Client/fable_modules/Fable.React.8.0.1/Fable.React.Extensions.fs.js","webpack:///./src/Client/FormElements/HelpdeskCaptcha.fs.js","webpack:///./src/Client/FormElements/HelpdeskCheckradio.fs.js","webpack:///./src/Client/fable_modules/fable-library.3.7.5/Seq2.js","webpack:///./src/Client/FormElements/HelpdeskTitle.fs.js","webpack:///./src/Client/FormElements/HelpdeskDescription.fs.js","webpack:///./src/Client/FormElements/HelpdeskEmail.fs.js","webpack:///./src/Client/FormElements/HelpdeskMain.fs.js","webpack:///./src/Client/fable_modules/Fable.Elmish.React.3.0.1/react.fs.js","webpack:///./src/Client/Index.fs.js","webpack:///./src/Client/App.fs.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 disposeSafe(x) {\n    if (isDisposable(x)) {\n        x.Dispose();\n    }\n}\nexport function sameConstructor(x, y) {\n    return Object.getPrototypeOf(x).constructor === Object.getPrototypeOf(y).constructor;\n}\nexport class Enumerator {\n    constructor(iter) {\n        this.iter = iter;\n    }\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\n        const cur = this.iter.next();\n        this.current = cur.value;\n        return !cur.done;\n    }\n    [\"System.Collections.IEnumerator.Reset\"]() {\n        throw new Error(\"JS iterators cannot be reset\");\n    }\n    Dispose() {\n        return;\n    }\n}\nexport function getEnumerator(o) {\n    return typeof o.GetEnumerator === \"function\"\n        ? o.GetEnumerator()\n        : new Enumerator(o[Symbol.iterator]());\n}\nexport function toIterator(en) {\n    return {\n        [Symbol.iterator]() { return this; },\n        next() {\n            const hasNext = en[\"System.Collections.IEnumerator.MoveNext\"]();\n            const current = hasNext ? en[\"System.Collections.IEnumerator.get_Current\"]() : undefined;\n            return { done: !hasNext, value: current };\n        },\n    };\n}\nexport class Comparer {\n    constructor(f) {\n        this.Compare = f || compare;\n    }\n}\nexport function comparerFromEqualityComparer(comparer) {\n    // Sometimes IEqualityComparer also implements IComparer\n    if (isComparer(comparer)) {\n        return new Comparer(comparer.Compare);\n    }\n    else {\n        return new Comparer((x, y) => {\n            const xhash = comparer.GetHashCode(x);\n            const yhash = comparer.GetHashCode(y);\n            if (xhash === yhash) {\n                return comparer.Equals(x, y) ? 0 : -1;\n            }\n            else {\n                return xhash < yhash ? -1 : 1;\n            }\n        });\n    }\n}\nexport function assertEqual(actual, expected, msg) {\n    if (!equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport function assertNotEqual(actual, expected, msg) {\n    if (equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport class Lazy {\n    constructor(factory) {\n        this.factory = factory;\n        this.isValueCreated = false;\n    }\n    get Value() {\n        if (!this.isValueCreated) {\n            this.createdValue = this.factory();\n            this.isValueCreated = true;\n        }\n        return this.createdValue;\n    }\n    get IsValueCreated() {\n        return this.isValueCreated;\n    }\n}\nexport function lazyFromValue(v) {\n    return new Lazy(() => v);\n}\nexport function padWithZeros(i, length) {\n    let str = i.toString(10);\n    while (str.length < length) {\n        str = \"0\" + str;\n    }\n    return str;\n}\nexport function padLeftAndRightWithZeros(i, lengthLeft, lengthRight) {\n    let str = i.toString(10);\n    while (str.length < lengthLeft) {\n        str = \"0\" + str;\n    }\n    while (str.length < lengthRight) {\n        str = str + \"0\";\n    }\n    return str;\n}\nexport function dateOffset(date) {\n    const date1 = date;\n    return typeof date1.offset === \"number\"\n        ? date1.offset\n        : (date.kind === 1 /* UTC */\n            ? 0 : date.getTimezoneOffset() * -60000);\n}\nexport function int16ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport function int32ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFFFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport class ObjectRef {\n    static id(o) {\n        if (!ObjectRef.idMap.has(o)) {\n            ObjectRef.idMap.set(o, ++ObjectRef.count);\n        }\n        return ObjectRef.idMap.get(o);\n    }\n}\nObjectRef.idMap = new WeakMap();\nObjectRef.count = 0;\nexport function stringHash(s) {\n    let i = 0;\n    let h = 5381;\n    const len = s.length;\n    while (i < len) {\n        h = (h * 33) ^ s.charCodeAt(i++);\n    }\n    return h;\n}\nexport function numberHash(x) {\n    return x * 2654435761 | 0;\n}\n// From https://stackoverflow.com/a/37449594\nexport function combineHashCodes(hashes) {\n    if (hashes.length === 0) {\n        return 0;\n    }\n    return hashes.reduce((h1, h2) => {\n        return ((h1 << 5) + h1) ^ h2;\n    });\n}\nexport function physicalHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default:\n            return numberHash(ObjectRef.id(x));\n    }\n}\nexport function identityHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    else if (isHashable(x)) {\n        return x.GetHashCode();\n    }\n    else {\n        return physicalHash(x);\n    }\n}\nexport function dateHash(x) {\n    return x.getTime();\n}\nexport function arrayHash(x) {\n    const len = x.length;\n    const hashes = new Array(len);\n    for (let i = 0; i < len; i++) {\n        hashes[i] = structuralHash(x[i]);\n    }\n    return combineHashCodes(hashes);\n}\nexport function structuralHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default: {\n            if (isHashable(x)) {\n                return x.GetHashCode();\n            }\n            else if (isArrayLike(x)) {\n                return arrayHash(x);\n            }\n            else if (x instanceof Date) {\n                return dateHash(x);\n            }\n            else if (Object.getPrototypeOf(x).constructor === Object) {\n                // TODO: check call-stack to prevent cyclic objects?\n                const hashes = Object.values(x).map((v) => structuralHash(v));\n                return combineHashCodes(hashes);\n            }\n            else {\n                // Classes don't implement GetHashCode by default, but must use identity hashing\n                return numberHash(ObjectRef.id(x));\n                // return stringHash(String(x));\n            }\n        }\n    }\n}\n// Intended for custom numeric types, like long or decimal\nexport function fastStructuralHash(x) {\n    return stringHash(String(x));\n}\n// Intended for declared types that may or may not implement GetHashCode\nexport function safeHash(x) {\n    return x == null ? 0 : isHashable(x) ? x.GetHashCode() : numberHash(ObjectRef.id(x));\n}\nexport function equalArraysWith(x, y, eq) {\n    if (x == null) {\n        return y == null;\n    }\n    if (y == null) {\n        return false;\n    }\n    if (x.length !== y.length) {\n        return false;\n    }\n    for (let i = 0; i < x.length; i++) {\n        if (!eq(x[i], y[i])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equalArrays(x, y) {\n    return equalArraysWith(x, y, equals);\n}\nfunction equalObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return false;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0; i < xKeys.length; i++) {\n        if (xKeys[i] !== yKeys[i] || !equals(x[xKeys[i]], y[yKeys[i]])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equals(x, y) {\n    if (x === y) {\n        return true;\n    }\n    else if (x == null) {\n        return y == null;\n    }\n    else if (y == null) {\n        return false;\n    }\n    else if (typeof x !== \"object\") {\n        return false;\n    }\n    else if (isEquatable(x)) {\n        return x.Equals(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) && equalArrays(x, y);\n    }\n    else if (x instanceof Date) {\n        return (y instanceof Date) && compareDates(x, y) === 0;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object && equalObjects(x, y);\n    }\n}\nexport function compareDates(x, y) {\n    let xtime;\n    let ytime;\n    // DateTimeOffset and DateTime deals with equality differently.\n    if (\"offset\" in x && \"offset\" in y) {\n        xtime = x.getTime();\n        ytime = y.getTime();\n    }\n    else {\n        xtime = x.getTime() + dateOffset(x);\n        ytime = y.getTime() + dateOffset(y);\n    }\n    return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);\n}\nexport function comparePrimitives(x, y) {\n    return x === y ? 0 : (x < y ? -1 : 1);\n}\nexport function compareArraysWith(x, y, comp) {\n    if (x == null) {\n        return y == null ? 0 : 1;\n    }\n    if (y == null) {\n        return -1;\n    }\n    if (x.length !== y.length) {\n        return x.length < y.length ? -1 : 1;\n    }\n    for (let i = 0, j = 0; i < x.length; i++) {\n        j = comp(x[i], y[i]);\n        if (j !== 0) {\n            return j;\n        }\n    }\n    return 0;\n}\nexport function compareArrays(x, y) {\n    return compareArraysWith(x, y, compare);\n}\nfunction compareObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return xKeys.length < yKeys.length ? -1 : 1;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0, j = 0; i < xKeys.length; i++) {\n        const key = xKeys[i];\n        if (key !== yKeys[i]) {\n            return key < yKeys[i] ? -1 : 1;\n        }\n        else {\n            j = compare(x[key], y[key]);\n            if (j !== 0) {\n                return j;\n            }\n        }\n    }\n    return 0;\n}\nexport function compare(x, y) {\n    if (x === y) {\n        return 0;\n    }\n    else if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    else if (y == null) {\n        return 1;\n    }\n    else if (typeof x !== \"object\") {\n        return x < y ? -1 : 1;\n    }\n    else if (isComparable(x)) {\n        return x.CompareTo(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) ? compareArrays(x, y) : -1;\n    }\n    else if (x instanceof Date) {\n        return y instanceof Date ? compareDates(x, y) : -1;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object ? compareObjects(x, y) : -1;\n    }\n}\nexport function min(comparer, x, y) {\n    return comparer(x, y) < 0 ? x : y;\n}\nexport function max(comparer, x, y) {\n    return comparer(x, y) > 0 ? x : y;\n}\nexport function clamp(comparer, value, min, max) {\n    return (comparer(value, min) < 0) ? min : (comparer(value, max) > 0) ? max : value;\n}\nexport function createAtom(value) {\n    let atom = value;\n    return (value, isSetter) => {\n        if (!isSetter) {\n            return atom;\n        }\n        else {\n            atom = value;\n            return void 0;\n        }\n    };\n}\nexport function createObj(fields) {\n    const obj = {};\n    for (const kv of fields) {\n        obj[kv[0]] = kv[1];\n    }\n    return obj;\n}\nexport function jsOptions(mutator) {\n    const opts = {};\n    mutator(opts);\n    return opts;\n}\nexport function round(value, digits = 0) {\n    const m = Math.pow(10, digits);\n    const n = +(digits ? value * m : value).toFixed(8);\n    const i = Math.floor(n);\n    const f = n - i;\n    const e = 1e-8;\n    const r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 === 0) ? i : i + 1) : Math.round(n);\n    return digits ? r / m : r;\n}\nexport function sign(x) {\n    return x > 0 ? 1 : x < 0 ? -1 : 0;\n}\nexport function unescapeDataString(s) {\n    // https://stackoverflow.com/a/4458580/524236\n    return decodeURIComponent((s).replace(/\\+/g, \"%20\"));\n}\nexport function escapeDataString(s) {\n    return encodeURIComponent(s).replace(/!/g, \"%21\")\n        .replace(/'/g, \"%27\")\n        .replace(/\\(/g, \"%28\")\n        .replace(/\\)/g, \"%29\")\n        .replace(/\\*/g, \"%2A\");\n}\nexport function escapeUriString(s) {\n    return encodeURI(s);\n}\n// ICollection.Clear and Count members can be called on Arrays\n// or Dictionaries so we need a runtime check (see #1120)\nexport function count(col) {\n    if (isArrayLike(col)) {\n        return col.length;\n    }\n    else {\n        let count = 0;\n        for (const _ of col) {\n            count++;\n        }\n        return count;\n    }\n}\nexport function clear(col) {\n    if (isArrayLike(col)) {\n        col.splice(0);\n    }\n    else {\n        col.clear();\n    }\n}\nconst CURRIED = Symbol(\"curried\");\nexport function uncurry(arity, f) {\n    // f may be a function option with None value\n    if (f == null || f.length > 1) {\n        return f;\n    }\n    const uncurried = (...args) => {\n        let res = f;\n        for (let i = 0; i < arity; i++) {\n            res = res(args[i]);\n        }\n        return res;\n    };\n    uncurried[CURRIED] = f;\n    return uncurried;\n}\nfunction _curry(args, arity, f) {\n    return (arg) => arity === 1\n        ? f(...args.concat([arg]))\n        // Note it's important to generate a new args array every time\n        // because a partially applied function can be run multiple times\n        : _curry(args.concat([arg]), arity - 1, f);\n}\nexport function curry(arity, f) {\n    if (f == null || f.length === 1) {\n        return f;\n    }\n    else if (CURRIED in f) {\n        return f[CURRIED];\n    }\n    else {\n        return _curry([], arity, f);\n    }\n}\nexport function checkArity(arity, f) {\n    return f.length > arity\n        ? (...args1) => (...args2) => f.apply(undefined, args1.concat(args2))\n        : f;\n}\nexport function partialApply(arity, f, args) {\n    if (f == null) {\n        return undefined;\n    }\n    else if (CURRIED in f) {\n        f = f[CURRIED];\n        for (let i = 0; i < args.length; i++) {\n            f = f(args[i]);\n        }\n        return f;\n    }\n    else {\n        return _curry(args, arity, f);\n    }\n}\nexport function mapCurriedArgs(fn, mappings) {\n    function mapArg(fn, arg, mappings, idx) {\n        const mapping = mappings[idx];\n        if (mapping !== 0) {\n            const expectedArity = mapping[0];\n            const actualArity = mapping[1];\n            if (expectedArity > 1) {\n                arg = curry(expectedArity, arg);\n            }\n            if (actualArity > 1) {\n                arg = uncurry(actualArity, arg);\n            }\n        }\n        const res = fn(arg);\n        if (idx + 1 === mappings.length) {\n            return res;\n        }\n        else {\n            return (arg) => mapArg(res, arg, mappings, idx + 1);\n        }\n    }\n    return (arg) => mapArg(fn, arg, mappings, 0);\n}\n","import { combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from \"./Util.js\";\nexport function seqToString(self) {\n    let count = 0;\n    let str = \"[\";\n    for (const x of self) {\n        if (count === 0) {\n            str += toString(x);\n        }\n        else if (count === 100) {\n            str += \"; ...\";\n            break;\n        }\n        else {\n            str += \"; \" + toString(x);\n        }\n        count++;\n    }\n    return str + \"]\";\n}\nexport function toString(x, callStack = 0) {\n    if (x != null && typeof x === \"object\") {\n        if (typeof x.toString === \"function\") {\n            return x.toString();\n        }\n        else if (Symbol.iterator in x) {\n            return seqToString(x);\n        }\n        else { // TODO: Date?\n            const cons = Object.getPrototypeOf(x).constructor;\n            return cons === Object && callStack < 10\n                // Same format as recordToString\n                ? \"{ \" + Object.entries(x).map(([k, v]) => k + \" = \" + toString(v, callStack + 1)).join(\"\\n  \") + \" }\"\n                : cons.name;\n        }\n    }\n    return String(x);\n}\nexport function unionToString(name, fields) {\n    if (fields.length === 0) {\n        return name;\n    }\n    else {\n        let fieldStr = \"\";\n        let withParens = true;\n        if (fields.length === 1) {\n            fieldStr = toString(fields[0]);\n            withParens = fieldStr.indexOf(\" \") >= 0;\n        }\n        else {\n            fieldStr = fields.map((x) => toString(x)).join(\", \");\n        }\n        return name + (withParens ? \" (\" : \" \") + fieldStr + (withParens ? \")\" : \"\");\n    }\n}\nexport class Union {\n    get name() {\n        return this.cases()[this.tag];\n    }\n    toJSON() {\n        return this.fields.length === 0 ? this.name : [this.name].concat(this.fields);\n    }\n    toString() {\n        return unionToString(this.name, this.fields);\n    }\n    GetHashCode() {\n        const hashes = this.fields.map((x) => structuralHash(x));\n        hashes.splice(0, 0, numberHash(this.tag));\n        return combineHashCodes(hashes);\n    }\n    Equals(other) {\n        if (this === other) {\n            return true;\n        }\n        else if (!sameConstructor(this, other)) {\n            return false;\n        }\n        else if (this.tag === other.tag) {\n            return equalArrays(this.fields, other.fields);\n        }\n        else {\n            return false;\n        }\n    }\n    CompareTo(other) {\n        if (this === other) {\n            return 0;\n        }\n        else if (!sameConstructor(this, other)) {\n            return -1;\n        }\n        else if (this.tag === other.tag) {\n            return compareArrays(this.fields, other.fields);\n        }\n        else {\n            return this.tag < other.tag ? -1 : 1;\n        }\n    }\n}\nfunction recordToJSON(self) {\n    const o = {};\n    const keys = Object.keys(self);\n    for (let i = 0; i < keys.length; i++) {\n        o[keys[i]] = self[keys[i]];\n    }\n    return o;\n}\nfunction recordToString(self) {\n    return \"{ \" + Object.entries(self).map(([k, v]) => k + \" = \" + toString(v)).join(\"\\n  \") + \" }\";\n}\nfunction recordGetHashCode(self) {\n    const hashes = Object.values(self).map((v) => structuralHash(v));\n    return combineHashCodes(hashes);\n}\nfunction recordEquals(self, other) {\n    if (self === other) {\n        return true;\n    }\n    else if (!sameConstructor(self, other)) {\n        return false;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            if (!equals(self[thisNames[i]], other[thisNames[i]])) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\nfunction recordCompareTo(self, other) {\n    if (self === other) {\n        return 0;\n    }\n    else if (!sameConstructor(self, other)) {\n        return -1;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            const result = compare(self[thisNames[i]], other[thisNames[i]]);\n            if (result !== 0) {\n                return result;\n            }\n        }\n        return 0;\n    }\n}\nexport class Record {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class FSharpRef {\n    constructor(contentsOrGetter, setter) {\n        if (typeof setter === \"function\") {\n            this.getter = contentsOrGetter;\n            this.setter = setter;\n        }\n        else {\n            this.getter = () => contentsOrGetter;\n            this.setter = (v) => { contentsOrGetter = v; };\n        }\n    }\n    get contents() {\n        return this.getter();\n    }\n    set contents(v) {\n        this.setter(v);\n    }\n}\n// EXCEPTIONS\n// Exception is intentionally not derived from Error, for performance reasons (see #2160)\nexport class Exception {\n    constructor(message) {\n        this.message = message;\n    }\n}\nexport function isException(x) {\n    return x instanceof Exception || x instanceof Error;\n}\nexport class FSharpException extends Exception {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class MatchFailureException extends FSharpException {\n    constructor(arg1, arg2, arg3) {\n        super();\n        this.arg1 = arg1;\n        this.arg2 = arg2 | 0;\n        this.arg3 = arg3 | 0;\n        this.message = \"The match cases were incomplete\";\n    }\n}\nexport class Attribute {\n}\n","// export type decimal = Decimal;\nexport var NumberStyles;\n(function (NumberStyles) {\n    // None = 0x00000000,\n    // AllowLeadingWhite = 0x00000001,\n    // AllowTrailingWhite = 0x00000002,\n    // AllowLeadingSign = 0x00000004,\n    // AllowTrailingSign = 0x00000008,\n    // AllowParentheses = 0x00000010,\n    // AllowDecimalPoint = 0x00000020,\n    // AllowThousands = 0x00000040,\n    // AllowExponent = 0x00000080,\n    // AllowCurrencySymbol = 0x00000100,\n    NumberStyles[NumberStyles[\"AllowHexSpecifier\"] = 512] = \"AllowHexSpecifier\";\n    // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,\n    // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,\n    // Number = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //          AllowTrailingSign | AllowDecimalPoint | AllowThousands,\n    // Float = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //         AllowDecimalPoint | AllowExponent,\n    // Currency = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,\n    // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,\n})(NumberStyles || (NumberStyles = {}));\nfunction validResponse(regexMatch, radix) {\n    const [/*all*/ , sign, prefix, digits] = regexMatch;\n    return {\n        sign: sign || \"\",\n        prefix: prefix || \"\",\n        digits,\n        radix,\n    };\n}\nfunction getRange(unsigned, bitsize) {\n    switch (bitsize) {\n        case 8: return unsigned ? [0, 255] : [-128, 127];\n        case 16: return unsigned ? [0, 65535] : [-32768, 32767];\n        case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];\n        default: throw new Error(\"Invalid bit size.\");\n    }\n}\nfunction getInvalidDigits(radix) {\n    switch (radix) {\n        case 2: return /[^0-1]/;\n        case 8: return /[^0-7]/;\n        case 10: return /[^0-9]/;\n        case 16: return /[^0-9a-fA-F]/;\n        default:\n            throw new Error(\"Invalid Base.\");\n    }\n}\nfunction getRadix(prefix, style) {\n    if (style & NumberStyles.AllowHexSpecifier) {\n        return 16;\n    }\n    else {\n        switch (prefix) {\n            case \"0b\":\n            case \"0B\": return 2;\n            case \"0o\":\n            case \"0O\": return 8;\n            case \"0x\":\n            case \"0X\": return 16;\n            default: return 10;\n        }\n    }\n}\nexport function isValid(str, style, radix) {\n    const integerRegex = /^\\s*([\\+\\-])?(0[xXoObB])?([0-9a-fA-F]+)\\s*$/;\n    const res = integerRegex.exec(str.replace(/_/g, \"\"));\n    if (res != null) {\n        const [/*all*/ , /*sign*/ , prefix, digits] = res;\n        radix = radix || getRadix(prefix, style);\n        const invalidDigits = getInvalidDigits(radix);\n        if (!invalidDigits.test(digits)) {\n            return validResponse(res, radix);\n        }\n    }\n    return null;\n}\nexport function parse(str, style, unsigned, bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        let v = Number.parseInt(res.sign + res.digits, res.radix);\n        if (!Number.isNaN(v)) {\n            const [umin, umax] = getRange(true, bitsize);\n            if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {\n                v = v << (32 - bitsize) >> (32 - bitsize);\n            }\n            const [min, max] = getRange(unsigned, bitsize);\n            if (v >= min && v <= max) {\n                return v;\n            }\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_UnaryNegation_Int8(x) {\n    return x === -128 ? x : -x;\n}\nexport function op_UnaryNegation_Int16(x) {\n    return x === -32768 ? x : -x;\n}\nexport function op_UnaryNegation_Int32(x) {\n    return x === -2147483648 ? x : -x;\n}\nexport function divRem(x, y, out) {\n    const div = ~~(x / y);\n    const rem = x % y;\n    if (out != null) {\n        out.contents = rem;\n        return div;\n    }\n    else {\n        return [div, rem];\n    }\n}\n","export const symbol = Symbol(\"numeric\");\nexport function isNumeric(x) {\n    return typeof x === \"number\" || (x === null || x === void 0 ? void 0 : x[symbol]);\n}\nexport function compare(x, y) {\n    if (typeof x === \"number\") {\n        return x < y ? -1 : (x > y ? 1 : 0);\n    }\n    else {\n        return x.CompareTo(y);\n    }\n}\nexport function multiply(x, y) {\n    if (typeof x === \"number\") {\n        return x * y;\n    }\n    else {\n        return x[symbol]().multiply(y);\n    }\n}\nexport function toFixed(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toFixed(dp);\n    }\n    else {\n        return x[symbol]().toFixed(dp);\n    }\n}\nexport function toPrecision(x, sd) {\n    if (typeof x === \"number\") {\n        return x.toPrecision(sd);\n    }\n    else {\n        return x[symbol]().toPrecision(sd);\n    }\n}\nexport function toExponential(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toExponential(dp);\n    }\n    else {\n        return x[symbol]().toExponential(dp);\n    }\n}\nexport function toHex(x) {\n    if (typeof x === \"number\") {\n        return (Number(x) >>> 0).toString(16);\n    }\n    else {\n        return x[symbol]().toHex();\n    }\n}\n","// Adapted from: https://github.com/dcodeIO/long.js/blob/master/src/long.js\n// Apache License 2.0: https://github.com/dcodeIO/long.js/blob/master/LICENSE\n/* tslint:disable */\nimport { symbol } from \"../Numeric.js\";\n/**\n * wasm optimizations, to do native i64 multiplication and divide\n */\nvar wasm = null;\ntry {\n    wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11\n    ])), {}).exports;\n}\ncatch (e) {\n    // no wasm support :(\n}\n/**\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n *  See the from* functions below for more convenient ways of constructing Longs.\n * @exports Long\n * @class A Long class for representing a 64 bit two's-complement integer value.\n * @param {number} low The low (signed) 32 bits of the long\n * @param {number} high The high (signed) 32 bits of the long\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @constructor\n */\nexport function Long(low, high, unsigned) {\n    /**\n     * The low 32 bits as a signed value.\n     * @type {number}\n     */\n    this.low = low | 0;\n    /**\n     * The high 32 bits as a signed value.\n     * @type {number}\n     */\n    this.high = high | 0;\n    /**\n     * Whether unsigned or not.\n     * @type {boolean}\n     */\n    this.unsigned = !!unsigned;\n}\nLong.prototype.GetHashCode = function () {\n    let h1 = this.unsigned ? 1 : 0;\n    h1 = ((h1 << 5) + h1) ^ this.high;\n    h1 = ((h1 << 5) + h1) ^ this.low;\n    return h1;\n};\nLong.prototype.Equals = function (x) { return equals(this, x); };\nLong.prototype.CompareTo = function (x) { return compare(this, x); };\nLong.prototype.toString = function (radix) { return toString(this, radix); };\nLong.prototype.toJSON = function () { return toString(this); };\nLong.prototype[symbol] = function () {\n    const x = this;\n    return {\n        multiply: y => multiply(x, y),\n        toPrecision: sd => String(x) + (0).toPrecision(sd).substr(1),\n        toExponential: dp => String(x) + (0).toExponential(dp).substr(1),\n        toFixed: dp => String(x) + (0).toFixed(dp).substr(1),\n        toHex: () => toString(x.unsigned ? x : fromBytes(toBytes(x), true), 16),\n    };\n};\n// The internal representation of a long is the two given signed, 32-bit values.\n// We use 32-bit pieces because these are the size of integers on which\n// Javascript performs bit-operations.  For operations like addition and\n// multiplication, we split each number into 16 bit pieces, which can easily be\n// multiplied within Javascript's floating-point representation without overflow\n// or change in sign.\n//\n// In the algorithms below, we frequently reduce the negative case to the\n// positive case by negating the input(s) and then post-processing the result.\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n// a positive number, it overflows back into a negative).  Not handling this\n// case would often result in infinite recursion.\n//\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\n// methods on which they depend.\n/**\n * An indicator used to reliably determine if an object is a Long or not.\n * @type {boolean}\n * @const\n * @private\n */\nLong.prototype.__isLong__;\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\n/**\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n * @inner\n */\nexport function isLong(obj) {\n    return (obj && obj[\"__isLong__\"]) === true;\n}\n/**\n * Tests if the specified object is a Long.\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n */\n// Long.isLong = isLong;\n/**\n * A cache of the Long representations of small integer values.\n * @type {!Object}\n * @inner\n */\nvar INT_CACHE = {};\n/**\n * A cache of the Long representations of small unsigned integer values.\n * @type {!Object}\n * @inner\n */\nvar UINT_CACHE = {};\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromInt(value, unsigned) {\n    var obj, cachedObj, cache;\n    if (unsigned) {\n        value >>>= 0;\n        if (cache = (0 <= value && value < 256)) {\n            cachedObj = UINT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\n        if (cache)\n            UINT_CACHE[value] = obj;\n        return obj;\n    }\n    else {\n        value |= 0;\n        if (cache = (-128 <= value && value < 128)) {\n            cachedObj = INT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\n        if (cache)\n            INT_CACHE[value] = obj;\n        return obj;\n    }\n}\n/**\n * Returns a Long representing the given 32 bit integer value.\n * @function\n * @param {number} value The 32 bit integer in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromInt = fromInt;\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromNumber(value, unsigned) {\n    if (isNaN(value))\n        return unsigned ? UZERO : ZERO;\n    if (unsigned) {\n        if (value < 0)\n            return UZERO;\n        if (value >= TWO_PWR_64_DBL)\n            return MAX_UNSIGNED_VALUE;\n    }\n    else {\n        if (value <= -TWO_PWR_63_DBL)\n            return MIN_VALUE;\n        if (value + 1 >= TWO_PWR_63_DBL)\n            return MAX_VALUE;\n    }\n    if (value < 0)\n        return negate(fromNumber(-value, unsigned));\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\n}\n/**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @function\n * @param {number} value The number in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromNumber = fromNumber;\n/**\n * @param {number} lowBits\n * @param {number} highBits\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromBits(lowBits, highBits, unsigned) {\n    return new Long(lowBits, highBits, unsigned);\n}\n/**\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\n *  assumed to use 32 bits.\n * @function\n * @param {number} lowBits The low 32 bits\n * @param {number} highBits The high 32 bits\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromBits = fromBits;\n/**\n * @function\n * @param {number} base\n * @param {number} exponent\n * @returns {number}\n * @inner\n */\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\n/**\n * @param {string} str\n * @param {(boolean|number)=} unsigned\n * @param {number=} radix\n * @returns {!Long}\n * @inner\n */\nexport function fromString(str, unsigned, radix) {\n    if (str.length === 0)\n        throw Error('empty string');\n    if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\n        return ZERO;\n    if (typeof unsigned === 'number') {\n        // For goog.math.long compatibility\n        radix = unsigned,\n            unsigned = false;\n    }\n    else {\n        unsigned = !!unsigned;\n    }\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    var p = str.indexOf('-');\n    if (p > 0)\n        throw Error('interior hyphen');\n    else if (p === 0) {\n        return negate(fromString(str.substring(1), unsigned, radix));\n    }\n    // Do several (8) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 8));\n    var result = ZERO;\n    for (var i = 0; i < str.length; i += 8) {\n        var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);\n        if (size < 8) {\n            var power = fromNumber(pow_dbl(radix, size));\n            result = add(multiply(result, power), fromNumber(value));\n        }\n        else {\n            result = multiply(result, radixToPower);\n            result = add(result, fromNumber(value));\n        }\n    }\n    result.unsigned = unsigned;\n    return result;\n}\n/**\n * Returns a Long representation of the given string, written using the specified radix.\n * @function\n * @param {string} str The textual representation of the Long\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromString = fromString;\n/**\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromValue(val, unsigned) {\n    if (typeof val === 'number')\n        return fromNumber(val, unsigned);\n    if (typeof val === 'string')\n        return fromString(val, unsigned);\n    // Throws for non-objects, converts non-instanceof Long:\n    return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);\n}\n/**\n * Converts the specified value to a Long using the appropriate from* function for its type.\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long}\n */\n// Long.fromValue = fromValue;\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\n// no runtime penalty for these.\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_16_DBL = 1 << 16;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_24_DBL = 1 << 24;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n/**\n * @type {!Long}\n * @const\n * @inner\n */\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\n/**\n * @type {!Long}\n * @inner\n */\nexport var ZERO = fromInt(0);\n/**\n * Signed zero.\n * @type {!Long}\n */\n// Long.ZERO = ZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UZERO = fromInt(0, true);\n/**\n * Unsigned zero.\n * @type {!Long}\n */\n// Long.UZERO = UZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var ONE = fromInt(1);\n/**\n * Signed one.\n * @type {!Long}\n */\n// Long.ONE = ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UONE = fromInt(1, true);\n/**\n * Unsigned one.\n * @type {!Long}\n */\n// Long.UONE = UONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var NEG_ONE = fromInt(-1);\n/**\n * Signed negative one.\n * @type {!Long}\n */\n// Long.NEG_ONE = NEG_ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false);\n/**\n * Maximum signed value.\n * @type {!Long}\n */\n// Long.MAX_VALUE = MAX_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true);\n/**\n * Maximum unsigned value.\n * @type {!Long}\n */\n// Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n/**\n * Minimum signed value.\n * @type {!Long}\n */\n// Long.MIN_VALUE = MIN_VALUE;\n/**\n * @alias Long.prototype\n * @inner\n */\n// var LongPrototype = Long.prototype;\n/**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @this {!Long}\n * @returns {number}\n */\nexport function toInt($this) {\n    return $this.unsigned ? $this.low >>> 0 : $this.low;\n}\n;\n/**\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\n * @this {!Long}\n * @returns {number}\n */\nexport function toNumber($this) {\n    if ($this.unsigned)\n        return (($this.high >>> 0) * TWO_PWR_32_DBL) + ($this.low >>> 0);\n    return $this.high * TWO_PWR_32_DBL + ($this.low >>> 0);\n}\n;\n/**\n * Converts the Long to a string written in the specified radix.\n * @this {!Long}\n * @param {number=} radix Radix (2-36), defaults to 10\n * @returns {string}\n * @override\n * @throws {RangeError} If `radix` is out of range\n */\nexport function toString($this, radix) {\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    if (isZero($this))\n        return '0';\n    if (isNegative($this)) { // Unsigned Longs are never negative\n        if (equals($this, MIN_VALUE)) {\n            // We need to change the Long value before it can be negated, so we remove\n            // the bottom-most digit in this base and then recurse to do the rest.\n            var radixLong = fromNumber(radix), div = divide($this, radixLong), rem1 = subtract(multiply(div, radixLong), $this);\n            return toString(div, radix) + toInt(rem1).toString(radix);\n        }\n        else\n            return '-' + toString(negate($this), radix);\n    }\n    // Do several (6) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 6), $this.unsigned), rem = $this;\n    var result = '';\n    while (true) {\n        var remDiv = divide(rem, radixToPower), intval = toInt(subtract(rem, multiply(remDiv, radixToPower))) >>> 0, digits = intval.toString(radix);\n        rem = remDiv;\n        if (isZero(rem))\n            return digits + result;\n        else {\n            while (digits.length < 6)\n                digits = '0' + digits;\n            result = '' + digits + result;\n        }\n    }\n}\n;\n/**\n * Gets the high 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed high bits\n */\nexport function getHighBits($this) {\n    return $this.high;\n}\n;\n/**\n * Gets the high 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned high bits\n */\nexport function getHighBitsUnsigned($this) {\n    return $this.high >>> 0;\n}\n;\n/**\n * Gets the low 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed low bits\n */\nexport function getLowBits($this) {\n    return $this.low;\n}\n;\n/**\n * Gets the low 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned low bits\n */\nexport function getLowBitsUnsigned($this) {\n    return $this.low >>> 0;\n}\n;\n/**\n * Gets the number of bits needed to represent the absolute value of this Long.\n * @this {!Long}\n * @returns {number}\n */\nexport function getNumBitsAbs($this) {\n    if (isNegative($this)) // Unsigned Longs are never negative\n        return equals($this, MIN_VALUE) ? 64 : getNumBitsAbs(negate($this));\n    var val = $this.high != 0 ? $this.high : $this.low;\n    for (var bit = 31; bit > 0; bit--)\n        if ((val & (1 << bit)) != 0)\n            break;\n    return $this.high != 0 ? bit + 33 : bit + 1;\n}\n;\n/**\n * Tests if this Long's value equals zero.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isZero($this) {\n    return $this.high === 0 && $this.low === 0;\n}\n;\n/**\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\n * @returns {boolean}\n */\n// LongPrototype.eqz = LongPrototype.isZero;\n/**\n * Tests if this Long's value is negative.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isNegative($this) {\n    return !$this.unsigned && $this.high < 0;\n}\n;\n/**\n * Tests if this Long's value is positive.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isPositive($this) {\n    return $this.unsigned || $this.high >= 0;\n}\n;\n/**\n * Tests if this Long's value is odd.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isOdd($this) {\n    return ($this.low & 1) === 1;\n}\n;\n/**\n * Tests if this Long's value is even.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isEven($this) {\n    return ($this.low & 1) === 0;\n}\n;\n/**\n * Tests if this Long's value equals the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function equals($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if ($this.unsigned !== other.unsigned && ($this.high >>> 31) === 1 && (other.high >>> 31) === 1)\n        return false;\n    return $this.high === other.high && $this.low === other.low;\n}\n;\n/**\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.eq = LongPrototype.equals;\n/**\n * Tests if this Long's value differs from the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function notEquals($this, other) {\n    return !equals($this, /* validates */ other);\n}\n;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.neq = LongPrototype.notEquals;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ne = LongPrototype.notEquals;\n/**\n * Tests if this Long's value is less than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThan($this, other) {\n    return compare($this, /* validates */ other) < 0;\n}\n;\n/**\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lt = LongPrototype.lessThan;\n/**\n * Tests if this Long's value is less than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) <= 0;\n}\n;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lte = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.le = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is greater than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThan($this, other) {\n    return compare($this, /* validates */ other) > 0;\n}\n;\n/**\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gt = LongPrototype.greaterThan;\n/**\n * Tests if this Long's value is greater than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) >= 0;\n}\n;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gte = LongPrototype.greaterThanOrEqual;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ge = LongPrototype.greaterThanOrEqual;\n/**\n * Compares this Long's value with the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\nexport function compare($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if (equals($this, other))\n        return 0;\n    var thisNeg = isNegative($this), otherNeg = isNegative(other);\n    if (thisNeg && !otherNeg)\n        return -1;\n    if (!thisNeg && otherNeg)\n        return 1;\n    // At this point the sign bits are the same\n    if (!$this.unsigned)\n        return isNegative(subtract($this, other)) ? -1 : 1;\n    // Both are positive if at least one is unsigned\n    return (other.high >>> 0) > ($this.high >>> 0) || (other.high === $this.high && (other.low >>> 0) > ($this.low >>> 0)) ? -1 : 1;\n}\n;\n/**\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\n// LongPrototype.comp = LongPrototype.compare;\n/**\n * Negates this Long's value.\n * @this {!Long}\n * @returns {!Long} Negated Long\n */\nexport function negate($this) {\n    if (!$this.unsigned && equals($this, MIN_VALUE))\n        return MIN_VALUE;\n    return add(not($this), ONE);\n}\n;\n/**\n * Negates this Long's value. This is an alias of {@link Long#negate}.\n * @function\n * @returns {!Long} Negated Long\n */\n// LongPrototype.neg = LongPrototype.negate;\n/**\n * Returns the sum of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} addend Addend\n * @returns {!Long} Sum\n */\nexport function add($this, addend) {\n    if (!isLong(addend))\n        addend = fromValue(addend);\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = addend.high >>> 16;\n    var b32 = addend.high & 0xFFFF;\n    var b16 = addend.low >>> 16;\n    var b00 = addend.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 + b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 + b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 + b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 + b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the difference of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nexport function subtract($this, subtrahend) {\n    if (!isLong(subtrahend))\n        subtrahend = fromValue(subtrahend);\n    return add($this, negate(subtrahend));\n}\n;\n/**\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\n * @function\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\n// LongPrototype.sub = LongPrototype.subtract;\n/**\n * Returns the product of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nexport function multiply($this, multiplier) {\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    if (!isLong(multiplier))\n        multiplier = fromValue(multiplier);\n    // use wasm support if present\n    if (wasm) {\n        var low = wasm.mul($this.low, $this.high, multiplier.low, multiplier.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero(multiplier))\n        return $this.unsigned ? UZERO : ZERO;\n    if (equals($this, MIN_VALUE))\n        return isOdd(multiplier) ? MIN_VALUE : ZERO;\n    if (equals(multiplier, MIN_VALUE))\n        return isOdd($this) ? MIN_VALUE : ZERO;\n    if (isNegative($this)) {\n        if (isNegative(multiplier))\n            return multiply(negate($this), negate(multiplier));\n        else\n            return negate(multiply(negate($this), multiplier));\n    }\n    else if (isNegative(multiplier))\n        return negate(multiply($this, negate(multiplier)));\n    // If both longs are small, use float multiplication\n    if (lessThan($this, TWO_PWR_24) && lessThan(multiplier, TWO_PWR_24))\n        return fromNumber(toNumber($this) * toNumber(multiplier), $this.unsigned);\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n    // We can skip products that would overflow.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = multiplier.high >>> 16;\n    var b32 = multiplier.high & 0xFFFF;\n    var b16 = multiplier.low >>> 16;\n    var b00 = multiplier.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 * b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 * b00;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c16 += a00 * b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 * b00;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a16 * b16;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a00 * b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\n * @function\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\n// LongPrototype.mul = LongPrototype.multiply;\n/**\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\n *  unsigned if this Long is unsigned.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nexport function divide($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    if (isZero(divisor))\n        throw Error('division by zero');\n    // use wasm support if present\n    if (wasm) {\n        // guard against signed division overflow: the largest\n        // negative number / -1 would be 1 larger than the largest\n        // positive number, due to two's complement.\n        if (!$this.unsigned &&\n            $this.high === -0x80000000 &&\n            divisor.low === -1 && divisor.high === -1) {\n            // be consistent with non-wasm code path\n            return $this;\n        }\n        var low = ($this.unsigned ? wasm.div_u : wasm.div_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    var approx, rem, res;\n    if (!$this.unsigned) {\n        // This section is only relevant for signed longs and is derived from the\n        // closure library as a whole.\n        if (equals($this, MIN_VALUE)) {\n            if (equals(divisor, ONE) || equals(divisor, NEG_ONE))\n                return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE\n            else if (equals(divisor, MIN_VALUE))\n                return ONE;\n            else {\n                // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n                var halfThis = shiftRight($this, 1);\n                approx = shiftLeft(divide(halfThis, divisor), 1);\n                if (equals(approx, ZERO)) {\n                    return isNegative(divisor) ? ONE : NEG_ONE;\n                }\n                else {\n                    rem = subtract($this, multiply(divisor, approx));\n                    res = add(approx, divide(rem, divisor));\n                    return res;\n                }\n            }\n        }\n        else if (equals(divisor, MIN_VALUE))\n            return $this.unsigned ? UZERO : ZERO;\n        if (isNegative($this)) {\n            if (isNegative(divisor))\n                return divide(negate($this), negate(divisor));\n            return negate(divide(negate($this), divisor));\n        }\n        else if (isNegative(divisor))\n            return negate(divide($this, negate(divisor)));\n        res = ZERO;\n    }\n    else {\n        // The algorithm below has not been made for unsigned longs. It's therefore\n        // required to take special care of the MSB prior to running it.\n        if (!divisor.unsigned)\n            divisor = toUnsigned(divisor);\n        if (greaterThan(divisor, $this))\n            return UZERO;\n        if (greaterThan(divisor, shiftRightUnsigned($this, 1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\n            return UONE;\n        res = UZERO;\n    }\n    // Repeat the following until the remainder is less than other:  find a\n    // floating-point that approximates remainder / other *from below*, add this\n    // into the result, and subtract it from the remainder.  It is critical that\n    // the approximate value is less than or equal to the real value so that the\n    // remainder never becomes negative.\n    rem = $this;\n    while (greaterThanOrEqual(rem, divisor)) {\n        // Approximate the result of division. This may be a little greater or\n        // smaller than the actual value.\n        approx = Math.max(1, Math.floor(toNumber(rem) / toNumber(divisor)));\n        // We will tweak the approximate result by changing it in the 48-th digit or\n        // the smallest non-fractional digit, whichever is larger.\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), \n        // Decrease the approximation until it is smaller than the remainder.  Note\n        // that if it is too large, the product overflows and is negative.\n        approxRes = fromNumber(approx), approxRem = multiply(approxRes, divisor);\n        while (isNegative(approxRem) || greaterThan(approxRem, rem)) {\n            approx -= delta;\n            approxRes = fromNumber(approx, $this.unsigned);\n            approxRem = multiply(approxRes, divisor);\n        }\n        // We know the answer can't be zero... and actually, zero would cause\n        // infinite recursion since we would make no progress.\n        if (isZero(approxRes))\n            approxRes = ONE;\n        res = add(res, approxRes);\n        rem = subtract(rem, approxRem);\n    }\n    return res;\n}\n;\n/**\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\n// LongPrototype.div = LongPrototype.divide;\n/**\n * Returns this Long modulo the specified.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nexport function modulo($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    // use wasm support if present\n    if (wasm) {\n        var low = ($this.unsigned ? wasm.rem_u : wasm.rem_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    return subtract($this, multiply(divide($this, divisor), divisor));\n}\n;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.mod = LongPrototype.modulo;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.rem = LongPrototype.modulo;\n/**\n * Returns the bitwise NOT of this Long.\n * @this {!Long}\n * @returns {!Long}\n */\nexport function not($this) {\n    return fromBits(~$this.low, ~$this.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise AND of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function and($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low & other.low, $this.high & other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise OR of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function or($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low | other.low, $this.high | other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise XOR of this Long and the given one.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function xor($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low ^ other.low, $this.high ^ other.high, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftLeft($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits($this.low << numBits, ($this.high << numBits) | ($this.low >>> (32 - numBits)), $this.unsigned);\n    else\n        return fromBits(0, $this.low << (numBits - 32), $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shl = LongPrototype.shiftLeft;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRight($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits(($this.low >>> numBits) | ($this.high << (32 - numBits)), $this.high >> numBits, $this.unsigned);\n    else\n        return fromBits($this.high >> (numBits - 32), $this.high >= 0 ? 0 : -1, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr = LongPrototype.shiftRight;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRightUnsigned($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    numBits &= 63;\n    if (numBits === 0)\n        return $this;\n    else {\n        var high = $this.high;\n        if (numBits < 32) {\n            var low = $this.low;\n            return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, $this.unsigned);\n        }\n        else if (numBits === 32)\n            return fromBits(high, 0, $this.unsigned);\n        else\n            return fromBits(high >>> (numBits - 32), 0, $this.unsigned);\n    }\n}\n;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shru = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits rotated to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateLeft = function rotateLeft(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.low << numBits) | (this.high >>> b)), ((this.high << numBits) | (this.low >>> b)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.high << numBits) | (this.low >>> b)), ((this.low << numBits) | (this.high >>> b)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotl = LongPrototype.rotateLeft;\n/**\n * Returns this Long with bits rotated to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateRight = function rotateRight(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.high << b) | (this.low >>> numBits)), ((this.low << b) | (this.high >>> numBits)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.low << b) | (this.high >>> numBits)), ((this.high << b) | (this.low >>> numBits)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotr = LongPrototype.rotateRight;\n/**\n * Converts this Long to signed.\n * @this {!Long}\n * @returns {!Long} Signed long\n */\nexport function toSigned($this) {\n    if (!$this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, false);\n}\n;\n/**\n * Converts this Long to unsigned.\n * @this {!Long}\n * @returns {!Long} Unsigned long\n */\nexport function toUnsigned($this) {\n    if ($this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, true);\n}\n;\n/**\n * Converts this Long to its byte representation.\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @this {!Long}\n * @returns {!Array.<number>} Byte representation\n */\nexport function toBytes($this, le) {\n    return le ? toBytesLE($this) : toBytesBE($this);\n}\n;\n/**\n * Converts this Long to its little endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Little endian byte representation\n */\nexport function toBytesLE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        lo & 0xff,\n        lo >>> 8 & 0xff,\n        lo >>> 16 & 0xff,\n        lo >>> 24,\n        hi & 0xff,\n        hi >>> 8 & 0xff,\n        hi >>> 16 & 0xff,\n        hi >>> 24\n    ];\n}\n;\n/**\n * Converts this Long to its big endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Big endian byte representation\n */\nexport function toBytesBE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        hi >>> 24,\n        hi >>> 16 & 0xff,\n        hi >>> 8 & 0xff,\n        hi & 0xff,\n        lo >>> 24,\n        lo >>> 16 & 0xff,\n        lo >>> 8 & 0xff,\n        lo & 0xff\n    ];\n}\n;\n/**\n * Creates a Long from its byte representation.\n * @param {!Array.<number>} bytes Byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytes(bytes, unsigned, le) {\n    return le ? fromBytesLE(bytes, unsigned) : fromBytesBE(bytes, unsigned);\n}\n;\n/**\n * Creates a Long from its little endian byte representation.\n * @param {!Array.<number>} bytes Little endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesLE(bytes, unsigned) {\n    return new Long(bytes[0] |\n        bytes[1] << 8 |\n        bytes[2] << 16 |\n        bytes[3] << 24, bytes[4] |\n        bytes[5] << 8 |\n        bytes[6] << 16 |\n        bytes[7] << 24, unsigned);\n}\n;\n/**\n * Creates a Long from its big endian byte representation.\n * @param {!Array.<number>} bytes Big endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesBE(bytes, unsigned) {\n    return new Long(bytes[4] << 24 |\n        bytes[5] << 16 |\n        bytes[6] << 8 |\n        bytes[7], bytes[0] << 24 |\n        bytes[1] << 16 |\n        bytes[2] << 8 |\n        bytes[3], unsigned);\n}\n;\n","import { isValid } from \"./Int32.js\";\nimport * as LongLib from \"./lib/long.js\";\nexport default LongLib.Long;\nexport const get_Zero = LongLib.ZERO;\nexport const get_One = LongLib.ONE;\nexport const op_Addition = LongLib.add;\nexport const op_Subtraction = LongLib.subtract;\nexport const op_Multiply = LongLib.multiply;\nexport const op_Division = LongLib.divide;\nexport const op_Modulus = LongLib.modulo;\nexport const op_UnaryNegation = LongLib.negate;\nexport const op_LeftShift = LongLib.shiftLeft;\nexport const op_RightShift = LongLib.shiftRight;\nexport const op_RightShiftUnsigned = LongLib.shiftRightUnsigned;\nexport const op_BitwiseAnd = LongLib.and;\nexport const op_BitwiseOr = LongLib.or;\nexport const op_ExclusiveOr = LongLib.xor;\nexport const op_LogicalNot = LongLib.not;\nexport const op_LessThan = LongLib.lessThan;\nexport const op_LessThanOrEqual = LongLib.lessThanOrEqual;\nexport const op_GreaterThan = LongLib.greaterThan;\nexport const op_GreaterThanOrEqual = LongLib.greaterThanOrEqual;\nexport const op_Equality = LongLib.equals;\nexport const op_Inequality = LongLib.notEquals;\nexport const equals = LongLib.equals;\nexport const compare = LongLib.compare;\nexport const fromInt = LongLib.fromInt;\nexport const fromBits = LongLib.fromBits;\nexport const fromBytes = LongLib.fromBytes;\nexport const fromNumber = LongLib.fromNumber;\nexport const fromString = LongLib.fromString;\nexport const fromValue = LongLib.fromValue;\nexport const toInt = LongLib.toInt;\nexport const toBytes = LongLib.toBytes;\nexport const toNumber = LongLib.toNumber;\nexport const toString = LongLib.toString;\nexport const getLowBits = LongLib.getLowBits;\nexport const getHighBits = LongLib.getHighBits;\nexport const getLowBitsUnsigned = LongLib.getLowBitsUnsigned;\nexport const getHighBitsUnsigned = LongLib.getHighBitsUnsigned;\nfunction getMaxValue(unsigned, radix, isNegative) {\n    switch (radix) {\n        case 2: return unsigned ?\n            \"1111111111111111111111111111111111111111111111111111111111111111\" :\n            (isNegative ? \"1000000000000000000000000000000000000000000000000000000000000000\"\n                : \"111111111111111111111111111111111111111111111111111111111111111\");\n        case 8: return unsigned ?\n            \"1777777777777777777777\" :\n            (isNegative ? \"1000000000000000000000\" : \"777777777777777777777\");\n        case 10: return unsigned ?\n            \"18446744073709551615\" :\n            (isNegative ? \"9223372036854775808\" : \"9223372036854775807\");\n        case 16: return unsigned ?\n            \"FFFFFFFFFFFFFFFF\" :\n            (isNegative ? \"8000000000000000\" : \"7FFFFFFFFFFFFFFF\");\n        default: throw new Error(\"Invalid radix.\");\n    }\n}\nexport function abs(x) {\n    if (!x.unsigned && LongLib.isNegative(x)) {\n        return op_UnaryNegation(x);\n    }\n    else {\n        return x;\n    }\n}\nexport function fromInteger(value, unsigned, kind) {\n    let x = value;\n    let xh = 0;\n    switch (kind) {\n        case 0:\n            x = value << 24 >> 24;\n            xh = x;\n            break;\n        case 4:\n            x = value << 24 >>> 24;\n            break;\n        case 1:\n            x = value << 16 >> 16;\n            xh = x;\n            break;\n        case 5:\n            x = value << 16 >>> 16;\n            break;\n        case 2:\n            x = value >> 0;\n            xh = x;\n            break;\n        case 6:\n            x = value >>> 0;\n            break;\n    }\n    return LongLib.fromBits(x, xh >> 31, unsigned);\n}\nexport function parse(str, style, unsigned, _bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        const lessOrEqual = (x, y) => {\n            const len = Math.max(x.length, y.length);\n            return x.padStart(len, \"0\") <= y.padStart(len, \"0\");\n        };\n        const isNegative = res.sign === \"-\";\n        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);\n        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {\n            str = isNegative ? res.sign + res.digits : res.digits;\n            return LongLib.fromString(str, unsigned, res.radix);\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function unixEpochMillisecondsToTicks(ms, offset) {\n    return op_Multiply(op_Addition(op_Addition(LongLib.fromNumber(ms), 62135596800000), offset), 10000);\n}\nexport function ticksToUnixEpochMilliseconds(ticks) {\n    return LongLib.toNumber(op_Subtraction(op_Division(ticks, 10000), 62135596800000));\n}\n// export function makeRangeStepFunction(step: Long, last: Long, unsigned: boolean) {\n//   const stepComparedWithZero = LongLib.compare(step, unsigned ? LongLib.UZERO : LongLib.ZERO);\n//   if (stepComparedWithZero === 0) {\n//     throw new Error(\"The step of a range cannot be zero\");\n//   }\n//   const stepGreaterThanZero = stepComparedWithZero > 0;\n//   return (x: Long) => {\n//     const comparedWithLast = LongLib.compare(x, last);\n//     if ((stepGreaterThanZero && comparedWithLast <= 0)\n//       || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n//       return [x, op_Addition(x, step)];\n//     } else {\n//       return undefined;\n//     }\n//   };\n// }\nexport function divRem(x, y, out) {\n    const div = op_Division(x, y);\n    const rem = op_Modulus(x, y);\n    if (out != null) {\n        out.contents = rem;\n        return div;\n    }\n    else {\n        return [div, rem];\n    }\n}\n","/**\n * DateTimeOffset functions.\n *\n * Note: Date instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, dateOffset, padWithZeros } from \"./Util.js\";\nexport function dateOffsetToString(offset) {\n    const isMinus = offset < 0;\n    offset = Math.abs(offset);\n    const hours = ~~(offset / 3600000);\n    const minutes = (offset % 3600000) / 60000;\n    return (isMinus ? \"-\" : \"+\") +\n        padWithZeros(hours, 2) + \":\" +\n        padWithZeros(minutes, 2);\n}\nexport function dateToHalfUTCString(date, half) {\n    const str = date.toISOString();\n    return half === \"first\"\n        ? str.substring(0, str.indexOf(\"T\"))\n        : str.substring(str.indexOf(\"T\") + 1, str.length - 1);\n}\nfunction dateToISOString(d, utc) {\n    if (utc) {\n        return d.toISOString();\n    }\n    else {\n        // JS Date is always local\n        const printOffset = d.kind == null ? true : d.kind === 2 /* Local */;\n        return padWithZeros(d.getFullYear(), 4) + \"-\" +\n            padWithZeros(d.getMonth() + 1, 2) + \"-\" +\n            padWithZeros(d.getDate(), 2) + \"T\" +\n            padWithZeros(d.getHours(), 2) + \":\" +\n            padWithZeros(d.getMinutes(), 2) + \":\" +\n            padWithZeros(d.getSeconds(), 2) + \".\" +\n            padWithZeros(d.getMilliseconds(), 3) +\n            (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -60000) : \"\");\n    }\n}\nfunction dateToISOStringWithOffset(dateWithOffset, offset) {\n    const str = dateWithOffset.toISOString();\n    return str.substring(0, str.length - 1) + dateOffsetToString(offset);\n}\nfunction dateToStringWithCustomFormat(date, format, utc) {\n    return format.replace(/(\\w)\\1*/g, (match) => {\n        let rep = Number.NaN;\n        switch (match.substring(0, 1)) {\n            case \"y\":\n                const y = utc ? date.getUTCFullYear() : date.getFullYear();\n                rep = match.length < 4 ? y % 100 : y;\n                break;\n            case \"M\":\n                rep = (utc ? date.getUTCMonth() : date.getMonth()) + 1;\n                break;\n            case \"d\":\n                rep = utc ? date.getUTCDate() : date.getDate();\n                break;\n            case \"H\":\n                rep = utc ? date.getUTCHours() : date.getHours();\n                break;\n            case \"h\":\n                const h = utc ? date.getUTCHours() : date.getHours();\n                rep = h > 12 ? h % 12 : h;\n                break;\n            case \"m\":\n                rep = utc ? date.getUTCMinutes() : date.getMinutes();\n                break;\n            case \"s\":\n                rep = utc ? date.getUTCSeconds() : date.getSeconds();\n                break;\n            case \"f\":\n                rep = utc ? date.getUTCMilliseconds() : date.getMilliseconds();\n                break;\n        }\n        if (Number.isNaN(rep)) {\n            return match;\n        }\n        else {\n            return (rep < 10 && match.length > 1) ? \"0\" + rep : \"\" + rep;\n        }\n    });\n}\nfunction dateToStringWithOffset(date, format) {\n    var _a, _b, _c;\n    const d = new Date(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0));\n    if (typeof format !== \"string\") {\n        return d.toISOString().replace(/\\.\\d+/, \"\").replace(/[A-Z]|\\.\\d+/g, \" \") + dateOffsetToString(((_b = date.offset) !== null && _b !== void 0 ? _b : 0));\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\": return dateToHalfUTCString(d, \"first\");\n            case \"T\":\n            case \"t\": return dateToHalfUTCString(d, \"second\");\n            case \"O\":\n            case \"o\": return dateToISOStringWithOffset(d, ((_c = date.offset) !== null && _c !== void 0 ? _c : 0));\n            default: throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(d, format, true);\n    }\n}\nfunction dateToStringWithKind(date, format) {\n    const utc = date.kind === 1 /* UTC */;\n    if (typeof format !== \"string\") {\n        return utc ? date.toUTCString() : date.toLocaleString();\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\":\n                return utc ? dateToHalfUTCString(date, \"first\") : date.toLocaleDateString();\n            case \"T\":\n            case \"t\":\n                return utc ? dateToHalfUTCString(date, \"second\") : date.toLocaleTimeString();\n            case \"O\":\n            case \"o\":\n                return dateToISOString(date, utc);\n            default:\n                throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(date, format, utc);\n    }\n}\nexport function toString(date, format, _provider) {\n    return date.offset != null\n        ? dateToStringWithOffset(date, format)\n        : dateToStringWithKind(date, format);\n}\nexport function DateTime(value, kind) {\n    const d = new Date(value);\n    d.kind = (kind == null ? 0 /* Unspecified */ : kind) | 0;\n    return d;\n}\nexport function fromTicks(ticks, kind) {\n    ticks = fromValue(ticks);\n    kind = kind != null ? kind : 2 /* Local */; // better default than Unspecified\n    let date = DateTime(ticksToUnixEpochMilliseconds(ticks), kind);\n    // Ticks are local to offset (in this case, either UTC or Local/Unknown).\n    // If kind is anything but UTC, that means that the tick number was not\n    // in utc, thus getTime() cannot return UTC, and needs to be shifted.\n    if (kind !== 1 /* UTC */) {\n        date = DateTime(date.getTime() - dateOffset(date), kind);\n    }\n    return date;\n}\nexport function fromDateTimeOffset(date, kind) {\n    var _a;\n    switch (kind) {\n        case 1 /* UTC */: return DateTime(date.getTime(), 1 /* UTC */);\n        case 2 /* Local */: return DateTime(date.getTime(), 2 /* Local */);\n        default:\n            const d = DateTime(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0), kind);\n            return DateTime(d.getTime() - dateOffset(d), kind);\n    }\n}\nexport function getTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), dateOffset(date));\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTime(-62135596800000, 0 /* Unspecified */);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTime(253402300799999, 0 /* Unspecified */);\n}\nexport function parseRaw(input) {\n    function fail() {\n        throw new Error(`The string is not a valid Date: ${input}`);\n    }\n    if (input == null || input.trim() === \"\") {\n        fail();\n    }\n    // ISO dates without TZ are parsed as UTC. Adding time without TZ keeps them local.\n    if (input.length === 10 && input[4] === \"-\" && input[7] === \"-\") {\n        input += \"T00:00:00\";\n    }\n    let date = new Date(input);\n    let offset = null;\n    if (isNaN(date.getTime())) {\n        // Try to check strings JS Date cannot parse (see #1045, #1422)\n        // tslint:disable-next-line:max-line-length\n        const m = /^\\s*(\\d+[^\\w\\s:]\\d+[^\\w\\s:]\\d+)?\\s*(\\d+:\\d+(?::\\d+(?:\\.\\d+)?)?)?\\s*([AaPp][Mm])?\\s*(Z|[+-]([01]?\\d):?([0-5]?\\d)?)?\\s*$/.exec(input);\n        if (m != null) {\n            let baseDate;\n            let timeInSeconds = 0;\n            if (m[2] != null) {\n                const timeParts = m[2].split(\":\");\n                timeInSeconds =\n                    parseInt(timeParts[0], 10) * 3600 +\n                        parseInt(timeParts[1] || \"0\", 10) * 60 +\n                        parseFloat(timeParts[2] || \"0\");\n                if (m[3] != null && m[3].toUpperCase() === \"PM\") {\n                    timeInSeconds += 720;\n                }\n            }\n            if (m[4] != null) { // There's an offset, parse as UTC\n                if (m[1] != null) {\n                    baseDate = new Date(m[1] + \" UTC\");\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getUTCFullYear() + \"/\" + (d.getUTCMonth() + 1) + \"/\" + d.getUTCDate());\n                }\n                if (m[4] === \"Z\") {\n                    offset = \"Z\";\n                }\n                else {\n                    let offsetInMinutes = parseInt(m[5], 10) * 60 + parseInt(m[6] || \"0\", 10);\n                    if (m[4][0] === \"-\") {\n                        offsetInMinutes *= -1;\n                    }\n                    offset = offsetInMinutes;\n                    timeInSeconds -= offsetInMinutes * 60;\n                }\n            }\n            else {\n                if (m[1] != null) {\n                    baseDate = new Date(m[1]);\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getFullYear() + \"/\" + (d.getMonth() + 1) + \"/\" + d.getDate());\n                }\n            }\n            date = new Date(baseDate.getTime() + timeInSeconds * 1000);\n            // correct for daylight savings time\n            date = new Date(date.getTime() + (date.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 60000);\n        }\n        else {\n            fail();\n        }\n        // Check again the date is valid after transformations, see #2229\n        if (isNaN(date.getTime())) {\n            fail();\n        }\n    }\n    return [date, offset];\n}\nexport function parse(str, detectUTC = false) {\n    const [date, offset] = parseRaw(str);\n    // .NET always parses DateTime as Local if there's offset info (even \"Z\")\n    // Newtonsoft.Json uses UTC if the offset is \"Z\"\n    const kind = offset != null\n        ? (detectUTC && offset === \"Z\" ? 1 /* UTC */ : 2 /* Local */)\n        : 0 /* Unspecified */;\n    return DateTime(date.getTime(), kind);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {\n    const dateValue = kind === 1 /* UTC */\n        ? Date.UTC(year, month - 1, day, h, m, s, ms)\n        : new Date(year, month - 1, day, h, m, s, ms).getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date.\");\n    }\n    const date = DateTime(dateValue, kind);\n    if (year <= 99) {\n        date.setFullYear(year, month - 1, day);\n    }\n    return date;\n}\nexport function now() {\n    return DateTime(Date.now(), 2 /* Local */);\n}\nexport function utcNow() {\n    return DateTime(Date.now(), 1 /* UTC */);\n}\nexport function today() {\n    return date(now());\n}\nexport function isLeapYear(year) {\n    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n}\nexport function daysInMonth(year, month) {\n    return month === 2\n        ? (isLeapYear(year) ? 29 : 28)\n        : (month >= 8 ? (month % 2 === 0 ? 31 : 30) : (month % 2 === 0 ? 30 : 31));\n}\nexport function toUniversalTime(date) {\n    return date.kind === 1 /* UTC */ ? date : DateTime(date.getTime(), 1 /* UTC */);\n}\nexport function toLocalTime(date) {\n    return date.kind === 2 /* Local */ ? date : DateTime(date.getTime(), 2 /* Local */);\n}\nexport function specifyKind(d, kind) {\n    return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), kind);\n}\nexport function timeOfDay(d) {\n    return hour(d) * 3600000\n        + minute(d) * 60000\n        + second(d) * 1000\n        + millisecond(d);\n}\nexport function date(d) {\n    return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);\n}\nexport function day(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDate() : d.getDate();\n}\nexport function hour(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCHours() : d.getHours();\n}\nexport function millisecond(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMilliseconds() : d.getMilliseconds();\n}\nexport function minute(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMinutes() : d.getMinutes();\n}\nexport function month(d) {\n    return (d.kind === 1 /* UTC */ ? d.getUTCMonth() : d.getMonth()) + 1;\n}\nexport function second(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCSeconds() : d.getSeconds();\n}\nexport function year(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCFullYear() : d.getFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDay() : d.getDay();\n}\nexport function dayOfYear(d) {\n    const _year = year(d);\n    const _month = month(d);\n    let _day = day(d);\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    const newDate = DateTime(d.getTime() + ts, d.kind);\n    if (d.kind === 2 /* Local */) {\n        const oldTzOffset = d.getTimezoneOffset();\n        const newTzOffset = newDate.getTimezoneOffset();\n        return oldTzOffset !== newTzOffset\n            ? DateTime(newDate.getTime() + (newTzOffset - oldTzOffset) * 60000, d.kind)\n            : newDate;\n    }\n    else {\n        return newDate;\n    }\n}\nexport function addDays(d, v) {\n    return add(d, v * 86400000);\n}\nexport function addHours(d, v) {\n    return add(d, v * 3600000);\n}\nexport function addMinutes(d, v) {\n    return add(d, v * 60000);\n}\nexport function addSeconds(d, v) {\n    return add(d, v * 1000);\n}\nexport function addMilliseconds(d, v) {\n    return add(d, v);\n}\nexport function addYears(d, v) {\n    const newMonth = month(d);\n    const newYear = year(d) + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function addMonths(d, v) {\n    let newMonth = month(d) + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = year(d) + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function subtract(d, that) {\n    return typeof that === \"number\"\n        ? add(d, -that)\n        : d.getTime() - that.getTime();\n}\nexport function toLongDateString(d) {\n    return d.toDateString();\n}\nexport function toShortDateString(d) {\n    return d.toLocaleDateString();\n}\nexport function toLongTimeString(d) {\n    return d.toLocaleTimeString();\n}\nexport function toShortTimeString(d) {\n    return d.toLocaleTimeString().replace(/:\\d\\d(?!:)/, \"\");\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport const compare = compareDates;\nexport const compareTo = compareDates;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function isDaylightSavingTime(x) {\n    const jan = new Date(x.getFullYear(), 0, 1);\n    const jul = new Date(x.getFullYear(), 6, 1);\n    return isDST(jan.getTimezoneOffset(), jul.getTimezoneOffset(), x.getTimezoneOffset());\n}\nfunction isDST(janOffset, julOffset, tOffset) {\n    return Math.min(janOffset, julOffset) === tOffset;\n}\nexport default DateTime;\n","export function create(pattern, options = 0) {\n    // Supported RegexOptions\n    // * IgnoreCase:  0x0001\n    // * Multiline:   0x0002\n    // * Singleline:  0x0010\n    // * ECMAScript:  0x0100 (ignored)\n    if ((options & ~(1 ^ 2 ^ 16 ^ 256)) !== 0) {\n        throw new Error(\"RegexOptions only supports: IgnoreCase, Multiline, Singleline and ECMAScript\");\n    }\n    let flags = \"g\";\n    flags += options & 1 ? \"i\" : \"\"; // 0x0001 RegexOptions.IgnoreCase\n    flags += options & 2 ? \"m\" : \"\";\n    flags += options & 16 ? \"s\" : \"\";\n    return new RegExp(pattern, flags);\n}\n// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex\nexport function escape(str) {\n    return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n}\nexport function unescape(str) {\n    return str.replace(/\\\\([\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|])/g, \"$1\");\n}\nexport function isMatch(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    return reg.test(input);\n}\nexport function match(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    return reg.exec(input);\n}\nexport function matches(reg, input, startAt = 0) {\n    reg.lastIndex = startAt;\n    if (!reg.global) {\n        throw new Error(\"Non-global RegExp\"); // Prevent infinite loop\n    }\n    let m = reg.exec(input);\n    const matches = [];\n    while (m !== null) {\n        matches.push(m);\n        m = reg.exec(input);\n    }\n    return matches;\n}\nexport function options(reg) {\n    let options = 256; // ECMAScript\n    options |= reg.ignoreCase ? 1 : 0;\n    options |= reg.multiline ? 2 : 0;\n    return options;\n}\nexport function replace(reg, input, replacement, limit, offset = 0) {\n    function replacer() {\n        let res = arguments[0];\n        if (limit) {\n            limit--;\n            const match = [];\n            const len = arguments.length;\n            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter\n            // * match: matched substring\n            // * p1, p2, ...: nth capture group string\n            // * offset: offset of matched substring\n            // * string: whole string examined\n            // * groups: named capturing groups\n            //           ONLY if regex contains a named capture group AND browser supports named groups\n            // -> last element can be groups OR input string\n            // -> check if last element is string\n            const withGroups = typeof arguments[len - 1] !== \"string\";\n            let pLast = withGroups ? len - 3 : len - 2;\n            for (let i = 0; i < pLast; i++) {\n                match.push(arguments[i]);\n            }\n            match.index = arguments[pLast++];\n            match.input = arguments[pLast++];\n            if (withGroups) {\n                match.groups = arguments[pLast];\n            }\n            res = replacement(match);\n        }\n        return res;\n    }\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    if (typeof replacement === \"function\") {\n        limit = limit == null ? -1 : limit;\n        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);\n    }\n    else {\n        replacement =\n            replacement\n                // $0 doesn't work with JS regex, see #1155\n                .replace(/\\$0/g, (_s) => \"$&\")\n                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)\n                .replace(/\\${([^}]+)}/g, \"\\$<$1>\");\n        if (limit != null) {\n            let m;\n            const sub1 = input.substring(offset);\n            const _matches = matches(reg, sub1);\n            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;\n            return input.substring(0, offset) + sub2.replace(reg, replacement)\n                + input.substring(offset + sub2.length);\n        }\n        else {\n            return input.replace(reg, replacement);\n        }\n    }\n}\nexport function split(reg, input, limit, offset = 0) {\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    input = input.substring(offset);\n    return input.split(reg, limit);\n}\n","import { toString as dateToString } from \"./Date.js\";\nimport { compare as numericCompare, isNumeric, multiply, toExponential, toFixed, toHex, toPrecision } from \"./Numeric.js\";\nimport { escape } from \"./RegExp.js\";\nimport { toString } from \"./Types.js\";\nconst fsFormatRegExp = /(^|[^%])%([0+\\- ]*)(\\*|\\d+)?(?:\\.(\\d+))?(\\w)/g;\nconst interpolateRegExp = /(?:(^|[^%])%([0+\\- ]*)(\\d+)?(?:\\.(\\d+))?(\\w))?%P\\(\\)/g;\nconst formatRegExp = /\\{(\\d+)(,-?\\d+)?(?:\\:([a-zA-Z])(\\d{0,2})|\\:(.+?))?\\}/g;\nfunction isLessThan(x, y) {\n    return numericCompare(x, y) < 0;\n}\nfunction cmp(x, y, ic) {\n    function isIgnoreCase(i) {\n        return i === true ||\n            i === 1 /* CurrentCultureIgnoreCase */ ||\n            i === 3 /* InvariantCultureIgnoreCase */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    function isOrdinal(i) {\n        return i === 4 /* Ordinal */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    if (y == null) {\n        return 1;\n    } // everything is bigger than null\n    if (isOrdinal(ic)) {\n        if (isIgnoreCase(ic)) {\n            x = x.toLowerCase();\n            y = y.toLowerCase();\n        }\n        return (x === y) ? 0 : (x < y ? -1 : 1);\n    }\n    else {\n        if (isIgnoreCase(ic)) {\n            x = x.toLocaleLowerCase();\n            y = y.toLocaleLowerCase();\n        }\n        return x.localeCompare(y);\n    }\n}\nexport function compare(...args) {\n    switch (args.length) {\n        case 2: return cmp(args[0], args[1], false);\n        case 3: return cmp(args[0], args[1], args[2]);\n        case 4: return cmp(args[0], args[1], args[2] === true);\n        case 5: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), false);\n        case 6: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5]);\n        case 7: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5] === true);\n        default: throw new Error(\"String.compare: Unsupported number of parameters\");\n    }\n}\nexport function compareOrdinal(x, y) {\n    return cmp(x, y, 4 /* Ordinal */);\n}\nexport function compareTo(x, y) {\n    return cmp(x, y, 0 /* CurrentCulture */);\n}\nexport function startsWith(str, pattern, ic) {\n    if (str.length >= pattern.length) {\n        return cmp(str.substr(0, pattern.length), pattern, ic) === 0;\n    }\n    return false;\n}\nexport function indexOfAny(str, anyOf, ...args) {\n    if (str == null || str === \"\") {\n        return -1;\n    }\n    const startIndex = (args.length > 0) ? args[0] : 0;\n    if (startIndex < 0) {\n        throw new Error(\"Start index cannot be negative\");\n    }\n    const length = (args.length > 1) ? args[1] : str.length - startIndex;\n    if (length < 0) {\n        throw new Error(\"Length cannot be negative\");\n    }\n    if (length > str.length - startIndex) {\n        throw new Error(\"Invalid startIndex and length\");\n    }\n    str = str.substr(startIndex, length);\n    for (const c of anyOf) {\n        const index = str.indexOf(c);\n        if (index > -1) {\n            return index + startIndex;\n        }\n    }\n    return -1;\n}\nexport function printf(input) {\n    return {\n        input,\n        cont: fsFormat(input),\n    };\n}\nexport function interpolate(str, values) {\n    let valIdx = 0;\n    let strIdx = 0;\n    let result = \"\";\n    interpolateRegExp.lastIndex = 0;\n    let match = interpolateRegExp.exec(str);\n    while (match) {\n        // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char\n        // Note: we don't use negative lookbehind because some browsers don't support it yet\n        const matchIndex = match.index + (match[1] || \"\").length;\n        result += str.substring(strIdx, matchIndex).replace(/%%/g, \"%\");\n        const [, , flags, padLength, precision, format] = match;\n        result += formatReplacement(values[valIdx++], flags, padLength, precision, format);\n        strIdx = interpolateRegExp.lastIndex;\n        // Likewise we need to move interpolateRegExp.lastIndex one char behind to make sure we match the no-escape char next time\n        interpolateRegExp.lastIndex -= 1;\n        match = interpolateRegExp.exec(str);\n    }\n    result += str.substring(strIdx).replace(/%%/g, \"%\");\n    return result;\n}\nfunction continuePrint(cont, arg) {\n    return typeof arg === \"string\" ? cont(arg) : arg.cont(cont);\n}\nexport function toConsole(arg) {\n    // Don't remove the lambda here, see #1357\n    return continuePrint((x) => console.log(x), arg);\n}\nexport function toConsoleError(arg) {\n    return continuePrint((x) => console.error(x), arg);\n}\nexport function toText(arg) {\n    return continuePrint((x) => x, arg);\n}\nexport function toFail(arg) {\n    return continuePrint((x) => {\n        throw new Error(x);\n    }, arg);\n}\nfunction formatReplacement(rep, flags, padLength, precision, format) {\n    let sign = \"\";\n    flags = flags || \"\";\n    format = format || \"\";\n    if (isNumeric(rep)) {\n        if (format.toLowerCase() !== \"x\") {\n            if (isLessThan(rep, 0)) {\n                rep = multiply(rep, -1);\n                sign = \"-\";\n            }\n            else {\n                if (flags.indexOf(\" \") >= 0) {\n                    sign = \" \";\n                }\n                else if (flags.indexOf(\"+\") >= 0) {\n                    sign = \"+\";\n                }\n            }\n        }\n        precision = precision == null ? null : parseInt(precision, 10);\n        switch (format) {\n            case \"f\":\n            case \"F\":\n                precision = precision != null ? precision : 6;\n                rep = toFixed(rep, precision);\n                break;\n            case \"g\":\n            case \"G\":\n                rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                break;\n            case \"e\":\n            case \"E\":\n                rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                break;\n            case \"x\":\n                rep = toHex(rep);\n                break;\n            case \"X\":\n                rep = toHex(rep).toUpperCase();\n                break;\n            default: // AOid\n                rep = String(rep);\n                break;\n        }\n    }\n    else if (rep instanceof Date) {\n        rep = dateToString(rep);\n    }\n    else {\n        rep = toString(rep);\n    }\n    padLength = typeof padLength === \"number\" ? padLength : parseInt(padLength, 10);\n    if (!isNaN(padLength)) {\n        const zeroFlag = flags.indexOf(\"0\") >= 0; // Use '0' for left padding\n        const minusFlag = flags.indexOf(\"-\") >= 0; // Right padding\n        const ch = minusFlag || !zeroFlag ? \" \" : \"0\";\n        if (ch === \"0\") {\n            rep = padLeft(rep, padLength - sign.length, ch, minusFlag);\n            rep = sign + rep;\n        }\n        else {\n            rep = padLeft(sign + rep, padLength, ch, minusFlag);\n        }\n    }\n    else {\n        rep = sign + rep;\n    }\n    return rep;\n}\nfunction createPrinter(cont, _strParts, _matches, _result = \"\", padArg = -1) {\n    return (...args) => {\n        // Make copies of the values passed by reference because the function can be used multiple times\n        let result = _result;\n        const strParts = _strParts.slice();\n        const matches = _matches.slice();\n        for (const arg of args) {\n            const [, , flags, _padLength, precision, format] = matches[0];\n            let padLength = _padLength;\n            if (padArg >= 0) {\n                padLength = padArg;\n                padArg = -1;\n            }\n            else if (padLength === \"*\") {\n                if (arg < 0) {\n                    throw new Error(\"Non-negative number required\");\n                }\n                padArg = arg;\n                continue;\n            }\n            result += strParts[0];\n            result += formatReplacement(arg, flags, padLength, precision, format);\n            strParts.splice(0, 1);\n            matches.splice(0, 1);\n        }\n        if (matches.length === 0) {\n            result += strParts[0];\n            return cont(result);\n        }\n        else {\n            return createPrinter(cont, strParts, matches, result, padArg);\n        }\n    };\n}\nexport function fsFormat(str) {\n    return (cont) => {\n        fsFormatRegExp.lastIndex = 0;\n        const strParts = [];\n        const matches = [];\n        let strIdx = 0;\n        let match = fsFormatRegExp.exec(str);\n        while (match) {\n            // The first group corresponds to the no-escape char (^|[^%]), the actual pattern starts in the next char\n            // Note: we don't use negative lookbehind because some browsers don't support it yet\n            const matchIndex = match.index + (match[1] || \"\").length;\n            strParts.push(str.substring(strIdx, matchIndex).replace(/%%/g, \"%\"));\n            matches.push(match);\n            strIdx = fsFormatRegExp.lastIndex;\n            // Likewise we need to move fsFormatRegExp.lastIndex one char behind to make sure we match the no-escape char next time\n            fsFormatRegExp.lastIndex -= 1;\n            match = fsFormatRegExp.exec(str);\n        }\n        if (strParts.length === 0) {\n            return cont(str.replace(/%%/g, \"%\"));\n        }\n        else {\n            strParts.push(str.substring(strIdx).replace(/%%/g, \"%\"));\n            return createPrinter(cont, strParts, matches);\n        }\n    };\n}\nexport function format(str, ...args) {\n    if (typeof str === \"object\" && args.length > 0) {\n        // Called with culture info\n        str = args[0];\n        args.shift();\n    }\n    return str.replace(formatRegExp, (_, idx, padLength, format, precision, pattern) => {\n        if (idx < 0 || idx >= args.length) {\n            throw new Error(\"Index must be greater or equal to zero and less than the arguments' length.\");\n        }\n        let rep = args[idx];\n        if (isNumeric(rep)) {\n            precision = precision == null ? null : parseInt(precision, 10);\n            switch (format) {\n                case \"f\":\n                case \"F\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(rep, precision);\n                    break;\n                case \"g\":\n                case \"G\":\n                    rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                    break;\n                case \"e\":\n                case \"E\":\n                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                    break;\n                case \"p\":\n                case \"P\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(multiply(rep, 100), precision) + \" %\";\n                    break;\n                case \"d\":\n                case \"D\":\n                    rep = precision != null ? padLeft(String(rep), precision, \"0\") : String(rep);\n                    break;\n                case \"x\":\n                case \"X\":\n                    rep = precision != null ? padLeft(toHex(rep), precision, \"0\") : toHex(rep);\n                    if (format === \"X\") {\n                        rep = rep.toUpperCase();\n                    }\n                    break;\n                default:\n                    if (pattern) {\n                        let sign = \"\";\n                        rep = pattern.replace(/([0#,]+)(\\.[0#]+)?/, (_, intPart, decimalPart) => {\n                            if (isLessThan(rep, 0)) {\n                                rep = multiply(rep, -1);\n                                sign = \"-\";\n                            }\n                            const decimalPartLength = decimalPart != null ? decimalPart.length : 0;\n                            rep = toFixed(rep, Math.max(decimalPartLength - 1, 0));\n                            // Thousands separator\n                            if (intPart.indexOf(\",\") > 0) {\n                                const [intPart, decimalPart] = rep.split(\".\");\n                                const i = intPart.length % 3;\n                                const thousandGroups = Math.floor(intPart.length / 3);\n                                let thousands = i > 0 ? intPart.substr(0, i) + (thousandGroups > 0 ? \",\" : \"\") : \"\";\n                                for (let j = 0; j < thousandGroups; j++) {\n                                    thousands += intPart.substr(i + j * 3, 3) + (j < thousandGroups - 1 ? \",\" : \"\");\n                                }\n                                rep = decimalPart ? thousands + \".\" + decimalPart : thousands;\n                            }\n                            // In .NET you can mix 0/# placeholders but for simplicity we only check the left most character\n                            intPart = intPart.replace(/,/g, \"\");\n                            const intPartLength = intPart.length > 0 && intPart[0] === \"0\" ? intPart.length : 0;\n                            return padLeft(rep, intPartLength - sign.length + decimalPartLength, \"0\");\n                        });\n                        rep = sign + rep;\n                    }\n            }\n        }\n        else if (rep instanceof Date) {\n            rep = dateToString(rep, pattern || format);\n        }\n        else {\n            rep = toString(rep);\n        }\n        padLength = parseInt((padLength || \" \").substring(1), 10);\n        if (!isNaN(padLength)) {\n            rep = padLeft(String(rep), Math.abs(padLength), \" \", padLength < 0);\n        }\n        return rep;\n    });\n}\nexport function endsWith(str, search) {\n    const idx = str.lastIndexOf(search);\n    return idx >= 0 && idx === str.length - search.length;\n}\nexport function initialize(n, f) {\n    if (n < 0) {\n        throw new Error(\"String length must be non-negative\");\n    }\n    const xs = new Array(n);\n    for (let i = 0; i < n; i++) {\n        xs[i] = f(i);\n    }\n    return xs.join(\"\");\n}\nexport function insert(str, startIndex, value) {\n    if (startIndex < 0 || startIndex > str.length) {\n        throw new Error(\"startIndex is negative or greater than the length of this instance.\");\n    }\n    return str.substring(0, startIndex) + value + str.substring(startIndex);\n}\nexport function isNullOrEmpty(str) {\n    return typeof str !== \"string\" || str.length === 0;\n}\nexport function isNullOrWhiteSpace(str) {\n    return typeof str !== \"string\" || /^\\s*$/.test(str);\n}\nexport function concat(...xs) {\n    return xs.map((x) => String(x)).join(\"\");\n}\nexport function join(delimiter, xs) {\n    if (Array.isArray(xs)) {\n        return xs.join(delimiter);\n    }\n    else {\n        return Array.from(xs).join(delimiter);\n    }\n}\nexport function joinWithIndices(delimiter, xs, startIndex, count) {\n    const endIndexPlusOne = startIndex + count;\n    if (endIndexPlusOne > xs.length) {\n        throw new Error(\"Index and count must refer to a location within the buffer.\");\n    }\n    return xs.slice(startIndex, endIndexPlusOne).join(delimiter);\n}\nfunction notSupported(name) {\n    throw new Error(\"The environment doesn't support '\" + name + \"', please use a polyfill.\");\n}\nexport function toBase64String(inArray) {\n    let str = \"\";\n    for (let i = 0; i < inArray.length; i++) {\n        str += String.fromCharCode(inArray[i]);\n    }\n    return typeof btoa === \"function\" ? btoa(str) : notSupported(\"btoa\");\n}\nexport function fromBase64String(b64Encoded) {\n    const binary = typeof atob === \"function\" ? atob(b64Encoded) : notSupported(\"atob\");\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n        bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n}\nexport function padLeft(str, len, ch, isRight) {\n    ch = ch || \" \";\n    len = len - str.length;\n    for (let i = 0; i < len; i++) {\n        str = isRight ? str + ch : ch + str;\n    }\n    return str;\n}\nexport function padRight(str, len, ch) {\n    return padLeft(str, len, ch, true);\n}\nexport function remove(str, startIndex, count) {\n    if (startIndex >= str.length) {\n        throw new Error(\"startIndex must be less than length of string\");\n    }\n    if (typeof count === \"number\" && (startIndex + count) > str.length) {\n        throw new Error(\"Index and count must refer to a location within the string.\");\n    }\n    return str.slice(0, startIndex) + (typeof count === \"number\" ? str.substr(startIndex + count) : \"\");\n}\nexport function replace(str, search, replace) {\n    return str.replace(new RegExp(escape(search), \"g\"), replace);\n}\nexport function replicate(n, x) {\n    return initialize(n, () => x);\n}\nexport function getCharAtIndex(input, index) {\n    if (index < 0 || index >= input.length) {\n        throw new Error(\"Index was outside the bounds of the array.\");\n    }\n    return input[index];\n}\nexport function split(str, splitters, count, options) {\n    count = typeof count === \"number\" ? count : undefined;\n    options = typeof options === \"number\" ? options : 0;\n    if (count && count < 0) {\n        throw new Error(\"Count cannot be less than zero\");\n    }\n    if (count === 0) {\n        return [];\n    }\n    const removeEmpty = (options & 1) === 1;\n    const trim = (options & 2) === 2;\n    splitters = splitters || [];\n    splitters = splitters.filter(x => x).map(escape);\n    splitters = splitters.length > 0 ? splitters : [\"\\\\s\"];\n    const splits = [];\n    const reg = new RegExp(splitters.join(\"|\"), \"g\");\n    let findSplits = true;\n    let i = 0;\n    do {\n        const match = reg.exec(str);\n        if (match === null) {\n            const candidate = trim ? str.substring(i).trim() : str.substring(i);\n            if (!removeEmpty || candidate.length > 0) {\n                splits.push(candidate);\n            }\n            findSplits = false;\n        }\n        else {\n            const candidate = trim ? str.substring(i, match.index).trim() : str.substring(i, match.index);\n            if (!removeEmpty || candidate.length > 0) {\n                if (count != null && splits.length + 1 === count) {\n                    splits.push(trim ? str.substring(i).trim() : str.substring(i));\n                    findSplits = false;\n                }\n                else {\n                    splits.push(candidate);\n                }\n            }\n            i = reg.lastIndex;\n        }\n    } while (findSplits);\n    return splits;\n}\nexport function trim(str, ...chars) {\n    if (chars.length === 0) {\n        return str.trim();\n    }\n    const pattern = \"[\" + escape(chars.join(\"\")) + \"]+\";\n    return str.replace(new RegExp(\"^\" + pattern), \"\").replace(new RegExp(pattern + \"$\"), \"\");\n}\nexport function trimStart(str, ...chars) {\n    return chars.length === 0\n        ? str.trimStart()\n        : str.replace(new RegExp(\"^[\" + escape(chars.join(\"\")) + \"]+\"), \"\");\n}\nexport function trimEnd(str, ...chars) {\n    return chars.length === 0\n        ? str.trimEnd()\n        : str.replace(new RegExp(\"[\" + escape(chars.join(\"\")) + \"]+$\"), \"\");\n}\nexport function filter(pred, x) {\n    return x.split(\"\").filter((c) => pred(c)).join(\"\");\n}\nexport function substring(str, startIndex, length) {\n    if ((startIndex + (length || 0) > str.length)) {\n        throw new Error(\"Invalid startIndex and/or length\");\n    }\n    return length != null ? str.substr(startIndex, length) : str.substr(startIndex);\n}\nexport function fmt(strs, ...args) {\n    return ({ strs, args });\n}\nexport function fmtWith(fmts) {\n    return (strs, ...args) => ({ strs, args, fmts });\n}\nexport function getFormat(s) {\n    return s.fmts\n        ? s.strs.reduce((acc, newPart, index) => acc + `{${String(index - 1) + s.fmts[index - 1]}}` + newPart)\n        : s.strs.reduce((acc, newPart, index) => acc + `{${index - 1}}` + newPart);\n}\n","\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 { 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, disposeSafe, getEnumerator, comparePrimitives, max as max_1 } from \"./Util.js\";\r\nimport { SR_indexOutOfBounds } from \"./Global.js\";\r\n\r\nexport function Helpers_allocateArrayFromCons(cons, len) {\r\n    if ((typeof cons) === \"function\") {\r\n        return new cons(len);\r\n    }\r\n    else {\r\n        return new Array(len);\r\n    }\r\n}\r\n\r\nfunction indexNotFound() {\r\n    throw (new Error(\"An index satisfying the predicate was not found in the collection.\"));\r\n}\r\n\r\nfunction differentLengths() {\r\n    throw (new Error(\"Arrays had different lengths\"));\r\n}\r\n\r\nexport function append(array1, array2, cons) {\r\n    const len1 = array1.length | 0;\r\n    const len2 = array2.length | 0;\r\n    const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);\r\n    for (let i = 0; i <= (len1 - 1); i++) {\r\n        newArray[i] = array1[i];\r\n    }\r\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\r\n        newArray[i_1 + len1] = array2[i_1];\r\n    }\r\n    return newArray;\r\n}\r\n\r\nexport function filter(predicate, array) {\r\n    return array.filter(predicate);\r\n}\r\n\r\nexport function fill(target, targetIndex, count, value) {\r\n    const start = targetIndex | 0;\r\n    return target.fill(value, start, (start + count));\r\n}\r\n\r\nexport function getSubArray(array, start, count) {\r\n    const start_1 = start | 0;\r\n    return array.slice(start_1, (start_1 + count));\r\n}\r\n\r\nexport function last(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    return array[array.length - 1];\r\n}\r\n\r\nexport function tryLast(array) {\r\n    if (array.length === 0) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[array.length - 1]);\r\n    }\r\n}\r\n\r\nexport function mapIndexed(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const target = Helpers_allocateArrayFromCons(cons, len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = f(i, source[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function map(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const target = Helpers_allocateArrayFromCons(cons, len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = f(source[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function mapIndexed2(f, source1, source2, cons) {\r\n    if (source1.length !== source2.length) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(i, source1[i], source2[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function map2(f, source1, source2, cons) {\r\n    if (source1.length !== source2.length) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(source1[i], source2[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function mapIndexed3(f, source1, source2, source3, cons) {\r\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(i, source1[i], source2[i], source3[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function map3(f, source1, source2, source3, cons) {\r\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\r\n        throw (new Error(\"Arrays had different lengths\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\r\n    for (let i = 0; i <= (source1.length - 1); i++) {\r\n        result[i] = f(source1[i], source2[i], source3[i]);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function mapFold(mapping, state, array, cons) {\r\n    const matchValue = array.length | 0;\r\n    if (matchValue === 0) {\r\n        return [[], state];\r\n    }\r\n    else {\r\n        let acc = state;\r\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\r\n        for (let i = 0; i <= (array.length - 1); i++) {\r\n            const patternInput = mapping(acc, array[i]);\r\n            res[i] = patternInput[0];\r\n            acc = patternInput[1];\r\n        }\r\n        return [res, acc];\r\n    }\r\n}\r\n\r\nexport function mapFoldBack(mapping, array, state, cons) {\r\n    const matchValue = array.length | 0;\r\n    if (matchValue === 0) {\r\n        return [[], state];\r\n    }\r\n    else {\r\n        let acc = state;\r\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\r\n        for (let i = array.length - 1; i >= 0; i--) {\r\n            const patternInput = mapping(array[i], acc);\r\n            res[i] = patternInput[0];\r\n            acc = patternInput[1];\r\n        }\r\n        return [res, acc];\r\n    }\r\n}\r\n\r\nexport function indexed(source) {\r\n    const len = source.length | 0;\r\n    const target = new Array(len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = [i, source[i]];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function truncate(count, array) {\r\n    const count_1 = max_1(comparePrimitives, 0, count) | 0;\r\n    const start = 0;\r\n    return array.slice(start, (start + count_1));\r\n}\r\n\r\nexport function concat(arrays, cons) {\r\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\r\n    const matchValue = arrays_1.length | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return Helpers_allocateArrayFromCons(cons, 0);\r\n        }\r\n        case 1: {\r\n            return arrays_1[0];\r\n        }\r\n        default: {\r\n            let totalIdx = 0;\r\n            let totalLength = 0;\r\n            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {\r\n                const arr_1 = arrays_1[idx];\r\n                totalLength = ((totalLength + arr_1.length) | 0);\r\n            }\r\n            const result = Helpers_allocateArrayFromCons(cons, totalLength);\r\n            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {\r\n                const arr_2 = arrays_1[idx_1];\r\n                for (let j = 0; j <= (arr_2.length - 1); j++) {\r\n                    result[totalIdx] = arr_2[j];\r\n                    totalIdx = ((totalIdx + 1) | 0);\r\n                }\r\n            }\r\n            return result;\r\n        }\r\n    }\r\n}\r\n\r\nexport function collect(mapping, array, cons) {\r\n    return concat(map(mapping, array, null), cons);\r\n}\r\n\r\nexport function where(predicate, array) {\r\n    return array.filter(predicate);\r\n}\r\n\r\nexport function contains(value, array, eq) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return false;\r\n            }\r\n            else if (eq.Equals(value, array[i])) {\r\n                return true;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function empty(cons) {\r\n    return Helpers_allocateArrayFromCons(cons, 0);\r\n}\r\n\r\nexport function singleton(value, cons) {\r\n    const ar = Helpers_allocateArrayFromCons(cons, 1);\r\n    ar[0] = value;\r\n    return ar;\r\n}\r\n\r\nexport function initialize(count, initializer, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, count);\r\n    for (let i = 0; i <= (count - 1); i++) {\r\n        result[i] = initializer(i);\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function pairwise(array) {\r\n    if (array.length < 2) {\r\n        return [];\r\n    }\r\n    else {\r\n        const count = (array.length - 1) | 0;\r\n        const result = new Array(count);\r\n        for (let i = 0; i <= (count - 1); i++) {\r\n            result[i] = [array[i], array[i + 1]];\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function replicate(count, initial, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    const result = Helpers_allocateArrayFromCons(cons, count);\r\n    for (let i = 0; i <= (result.length - 1); i++) {\r\n        result[i] = initial;\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function copy(array) {\r\n    return array.slice();\r\n}\r\n\r\nexport function reverse(array) {\r\n    const array_2 = array.slice();\r\n    return array_2.reverse();\r\n}\r\n\r\nexport function scan(folder, state, array, cons) {\r\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\r\n    res[0] = state;\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        res[i + 1] = folder(res[i], array[i]);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function scanBack(folder, array, state, cons) {\r\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\r\n    res[array.length] = state;\r\n    for (let i = array.length - 1; i >= 0; i--) {\r\n        res[i] = folder(array[i], res[i + 1]);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function skip(count, array, cons) {\r\n    if (count > array.length) {\r\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\r\n    }\r\n    if (count === array.length) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const count_1 = ((count < 0) ? 0 : count) | 0;\r\n        return array.slice(count_1);\r\n    }\r\n}\r\n\r\nexport function skipWhile(predicate, array, cons) {\r\n    let count = 0;\r\n    while ((count < array.length) && predicate(array[count])) {\r\n        count = ((count + 1) | 0);\r\n    }\r\n    if (count === array.length) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const count_1 = count | 0;\r\n        return array.slice(count_1);\r\n    }\r\n}\r\n\r\nexport function take(count, array, cons) {\r\n    if (count < 0) {\r\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\r\n    }\r\n    if (count > array.length) {\r\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\r\n    }\r\n    if (count === 0) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const start = 0;\r\n        return array.slice(start, (start + count));\r\n    }\r\n}\r\n\r\nexport function takeWhile(predicate, array, cons) {\r\n    let count = 0;\r\n    while ((count < array.length) && predicate(array[count])) {\r\n        count = ((count + 1) | 0);\r\n    }\r\n    if (count === 0) {\r\n        return Helpers_allocateArrayFromCons(cons, 0);\r\n    }\r\n    else {\r\n        const start = 0;\r\n        const count_1 = count | 0;\r\n        return array.slice(start, (start + count_1));\r\n    }\r\n}\r\n\r\nexport function addInPlace(x, array) {\r\n    array.push(x);\r\n}\r\n\r\nexport function addRangeInPlace(range, array) {\r\n    const enumerator = getEnumerator(range);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            addInPlace(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), array);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n}\r\n\r\nexport function insertRangeInPlace(index, range, array) {\r\n    let index_1;\r\n    let i = index;\r\n    const enumerator = getEnumerator(range);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            (index_1 = (i | 0), array.splice(index_1, 0, x));\r\n            i = ((i + 1) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n}\r\n\r\nexport function removeInPlace(item_1, array) {\r\n    const i = (array.indexOf(item_1, 0)) | 0;\r\n    if (i > -1) {\r\n        array.splice(i, 1);\r\n        return true;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function removeAllInPlace(predicate, array) {\r\n    const countRemoveAll = (count) => {\r\n        const i = (array.findIndex(predicate)) | 0;\r\n        if (i > -1) {\r\n            array.splice(i, 1);\r\n            return (countRemoveAll(count) + 1) | 0;\r\n        }\r\n        else {\r\n            return count | 0;\r\n        }\r\n    };\r\n    return countRemoveAll(0) | 0;\r\n}\r\n\r\nexport function copyTo(source, sourceIndex, target, targetIndex, count) {\r\n    const diff = (targetIndex - sourceIndex) | 0;\r\n    for (let i = sourceIndex; i <= ((sourceIndex + count) - 1); i++) {\r\n        target[i + diff] = source[i];\r\n    }\r\n}\r\n\r\nexport function copyToTypedArray(source, sourceIndex, target, targetIndex, count) {\r\n    try {\r\n        target.set(source.subarray(sourceIndex, sourceIndex + count), targetIndex);\r\n    }\r\n    catch (matchValue) {\r\n        copyTo(source, sourceIndex, target, targetIndex, count);\r\n    }\r\n}\r\n\r\nexport function indexOf(array, item_1, start, count) {\r\n    const start_1 = defaultArg(start, 0) | 0;\r\n    const i = (array.indexOf(item_1, start_1)) | 0;\r\n    if ((count != null) && (i >= (start_1 + value_2(count)))) {\r\n        return -1;\r\n    }\r\n    else {\r\n        return i | 0;\r\n    }\r\n}\r\n\r\nexport function partition(f, source, cons) {\r\n    const len = source.length | 0;\r\n    const res1 = Helpers_allocateArrayFromCons(cons, len);\r\n    const res2 = Helpers_allocateArrayFromCons(cons, len);\r\n    let iTrue = 0;\r\n    let iFalse = 0;\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        if (f(source[i])) {\r\n            res1[iTrue] = source[i];\r\n            iTrue = ((iTrue + 1) | 0);\r\n        }\r\n        else {\r\n            res2[iFalse] = source[i];\r\n            iFalse = ((iFalse + 1) | 0);\r\n        }\r\n    }\r\n    return [truncate(iTrue, res1), truncate(iFalse, res2)];\r\n}\r\n\r\nexport function find(predicate, array) {\r\n    const matchValue = array.find(predicate);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_2(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFind(predicate, array) {\r\n    return array.find(predicate);\r\n}\r\n\r\nexport function findIndex(predicate, array) {\r\n    const matchValue = (array.findIndex(predicate)) | 0;\r\n    if (matchValue > -1) {\r\n        return matchValue | 0;\r\n    }\r\n    else {\r\n        return indexNotFound() | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(predicate, array) {\r\n    const matchValue = (array.findIndex(predicate)) | 0;\r\n    if (matchValue > -1) {\r\n        return matchValue;\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function pick(chooser, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return indexNotFound();\r\n            }\r\n            else {\r\n                const matchValue = chooser(array[i]);\r\n                if (matchValue != null) {\r\n                    return value_2(matchValue);\r\n                }\r\n                else {\r\n                    i_mut = (i + 1);\r\n                    continue loop;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function tryPick(chooser, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i >= array.length) {\r\n                return void 0;\r\n            }\r\n            else {\r\n                const matchValue = chooser(array[i]);\r\n                if (matchValue == null) {\r\n                    i_mut = (i + 1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0);\r\n}\r\n\r\nexport function findBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return indexNotFound();\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return array[i];\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function tryFindBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return void 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return some(array[i]);\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function findLastIndex(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return -1;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i | 0;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1) | 0;\r\n}\r\n\r\nexport function findIndexBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return indexNotFound() | 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i | 0;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1) | 0;\r\n}\r\n\r\nexport function tryFindIndexBack(predicate, array) {\r\n    const loop = (i_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (i < 0) {\r\n                return void 0;\r\n            }\r\n            else if (predicate(array[i])) {\r\n                return i;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(array.length - 1);\r\n}\r\n\r\nexport function choose(chooser, array, cons) {\r\n    const res = [];\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        const matchValue = chooser(array[i]);\r\n        if (matchValue != null) {\r\n            const y = value_2(matchValue);\r\n            res.push(y);\r\n        }\r\n    }\r\n    if ((typeof cons) === \"function\") {\r\n        return map((x) => x, res, cons);\r\n    }\r\n    else {\r\n        return res;\r\n    }\r\n}\r\n\r\nexport function foldIndexed(folder, state, array) {\r\n    return array.reduce(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg0, delegateArg1)), state);\r\n}\r\n\r\nexport function fold(folder, state, array) {\r\n    return array.reduce((folder), state);\r\n}\r\n\r\nexport function iterate(action, array) {\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        action(array[i]);\r\n    }\r\n}\r\n\r\nexport function iterateIndexed(action, array) {\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        action(i, array[i]);\r\n    }\r\n}\r\n\r\nexport function iterate2(action, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        action(array1[i], array2[i]);\r\n    }\r\n}\r\n\r\nexport function iterateIndexed2(action, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        action(i, array1[i], array2[i]);\r\n    }\r\n}\r\n\r\nexport function isEmpty(array) {\r\n    return array.length === 0;\r\n}\r\n\r\nexport function forAll(predicate, array) {\r\n    return array.every(predicate);\r\n}\r\n\r\nexport function permute(f, array) {\r\n    const size = array.length | 0;\r\n    const res = array.slice();\r\n    const checkFlags = new Array(size);\r\n    iterateIndexed((i, x) => {\r\n        const j = f(i) | 0;\r\n        if ((j < 0) ? true : (j >= size)) {\r\n            throw (new Error(\"Not a valid permutation\"));\r\n        }\r\n        res[j] = x;\r\n        checkFlags[j] = 1;\r\n    }, array);\r\n    if (!(checkFlags.every((y) => (1 === y)))) {\r\n        throw (new Error(\"Not a valid permutation\"));\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function setSlice(target, lower, upper, source) {\r\n    const lower_1 = defaultArg(lower, 0) | 0;\r\n    const upper_1 = defaultArg(upper, 0) | 0;\r\n    const length = (((upper_1 > 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;\r\n    for (let i = 0; i <= length; i++) {\r\n        target[i + lower_1] = source[i];\r\n    }\r\n}\r\n\r\nexport function sortInPlaceBy(projection, xs, comparer) {\r\n    xs.sort((x, y) => comparer.Compare(projection(x), projection(y)));\r\n}\r\n\r\nexport function sortInPlace(xs, comparer) {\r\n    xs.sort((x, y) => comparer.Compare(x, y));\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => comparer.Compare(x, y));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    return (xs_1.sort((x, y) => comparer.Compare(projection(x), projection(y))), xs_1);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort((x, y) => (comparer.Compare(x, y) * -1));\r\n    return xs_1;\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    const xs_1 = xs.slice();\r\n    return (xs_1.sort((x, y) => (comparer.Compare(projection(x), projection(y)) * -1)), xs_1);\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    const comparer_1 = comparer;\r\n    const xs_1 = xs.slice();\r\n    xs_1.sort(comparer_1);\r\n    return xs_1;\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const len1 = xs.length | 0;\r\n    const len2 = ys.length | 0;\r\n    const res = new Array(len1 * len2);\r\n    for (let i = 0; i <= (xs.length - 1); i++) {\r\n        for (let j = 0; j <= (ys.length - 1); j++) {\r\n            res[(i * len2) + j] = [xs[i], ys[j]];\r\n        }\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function unfold(generator, state) {\r\n    const res = [];\r\n    const loop = (state_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const state_1 = state_1_mut;\r\n            const matchValue = generator(state_1);\r\n            if (matchValue != null) {\r\n                const x = matchValue[0];\r\n                const s = matchValue[1];\r\n                res.push(x);\r\n                state_1_mut = s;\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    loop(state);\r\n    return res;\r\n}\r\n\r\nexport function unzip(array) {\r\n    const len = array.length | 0;\r\n    const res1 = new Array(len);\r\n    const res2 = new Array(len);\r\n    iterateIndexed((i, tupledArg) => {\r\n        res1[i] = tupledArg[0];\r\n        res2[i] = tupledArg[1];\r\n    }, array);\r\n    return [res1, res2];\r\n}\r\n\r\nexport function unzip3(array) {\r\n    const len = array.length | 0;\r\n    const res1 = new Array(len);\r\n    const res2 = new Array(len);\r\n    const res3 = new Array(len);\r\n    iterateIndexed((i, tupledArg) => {\r\n        res1[i] = tupledArg[0];\r\n        res2[i] = tupledArg[1];\r\n        res3[i] = tupledArg[2];\r\n    }, array);\r\n    return [res1, res2, res3];\r\n}\r\n\r\nexport function zip(array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    const result = new Array(array1.length);\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        result[i] = [array1[i], array2[i]];\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function zip3(array1, array2, array3) {\r\n    if ((array1.length !== array2.length) ? true : (array2.length !== array3.length)) {\r\n        differentLengths();\r\n    }\r\n    const result = new Array(array1.length);\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        result[i] = [array1[i], array2[i], array3[i]];\r\n    }\r\n    return result;\r\n}\r\n\r\nexport function chunkBySize(chunkSize, array) {\r\n    if (chunkSize < 1) {\r\n        throw (new Error(\"The input must be positive.\\\\nParameter name: size\"));\r\n    }\r\n    if (array.length === 0) {\r\n        return [[]];\r\n    }\r\n    else {\r\n        const result = [];\r\n        for (let x = 0; x <= ((~(~Math.ceil(array.length / chunkSize))) - 1); x++) {\r\n            let slice;\r\n            const start_1 = (x * chunkSize) | 0;\r\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\r\n            result.push(slice);\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function splitAt(index, array) {\r\n    let start;\r\n    if ((index < 0) ? true : (index > array.length)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return [(start = 0, array.slice(start, (start + index))), array.slice(index)];\r\n}\r\n\r\nexport function compareWith(comparer, array1, array2) {\r\n    if (array1 == null) {\r\n        if (array2 == null) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n    else if (array2 == null) {\r\n        return 1;\r\n    }\r\n    else {\r\n        let i = 0;\r\n        let result = 0;\r\n        const length1 = array1.length | 0;\r\n        const length2 = array2.length | 0;\r\n        if (length1 > length2) {\r\n            return 1;\r\n        }\r\n        else if (length1 < length2) {\r\n            return -1;\r\n        }\r\n        else {\r\n            while ((i < length1) && (result === 0)) {\r\n                result = (comparer(array1[i], array2[i]) | 0);\r\n                i = ((i + 1) | 0);\r\n            }\r\n            return result | 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function equalsWith(equals, array1, array2) {\r\n    if (array1 == null) {\r\n        if (array2 == null) {\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else if (array2 == null) {\r\n        return false;\r\n    }\r\n    else {\r\n        let i = 0;\r\n        let result = true;\r\n        const length1 = array1.length | 0;\r\n        const length2 = array2.length | 0;\r\n        if (length1 > length2) {\r\n            return false;\r\n        }\r\n        else if (length1 < length2) {\r\n            return false;\r\n        }\r\n        else {\r\n            while ((i < length1) && result) {\r\n                result = equals(array1[i], array2[i]);\r\n                i = ((i + 1) | 0);\r\n            }\r\n            return result;\r\n        }\r\n    }\r\n}\r\n\r\nexport function exactlyOne(array) {\r\n    if (array.length === 1) {\r\n        return array[0];\r\n    }\r\n    else if (array.length === 0) {\r\n        throw (new Error(\"The input sequence was empty\\\\nParameter name: array\"));\r\n    }\r\n    else {\r\n        throw (new Error(\"Input array too long\\\\nParameter name: array\"));\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(array) {\r\n    if (array.length === 1) {\r\n        return some(array[0]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function head(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    else {\r\n        return array[0];\r\n    }\r\n}\r\n\r\nexport function tryHead(array) {\r\n    if (array.length === 0) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[0]);\r\n    }\r\n}\r\n\r\nexport function tail(array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"Not enough elements\\\\nParameter name: array\"));\r\n    }\r\n    return array.slice(1);\r\n}\r\n\r\nexport function item(index, array) {\r\n    return array[index];\r\n}\r\n\r\nexport function tryItem(index, array) {\r\n    if ((index < 0) ? true : (index >= array.length)) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(array[index]);\r\n    }\r\n}\r\n\r\nexport function foldBackIndexed(folder, array, state) {\r\n    return array.reduceRight(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg1, delegateArg0)), state);\r\n}\r\n\r\nexport function foldBack(folder, array, state) {\r\n    return array.reduceRight(((delegateArg0, delegateArg1) => folder(delegateArg1, delegateArg0)), state);\r\n}\r\n\r\nexport function foldIndexed2(folder, state, array1, array2) {\r\n    let acc = state;\r\n    if (array1.length !== array2.length) {\r\n        throw (new Error(\"Arrays have different lengths\"));\r\n    }\r\n    for (let i = 0; i <= (array1.length - 1); i++) {\r\n        acc = folder(i, acc, array1[i], array2[i]);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function fold2(folder, state, array1, array2) {\r\n    return foldIndexed2((_arg1, acc, x, y) => folder(acc, x, y), state, array1, array2);\r\n}\r\n\r\nexport function foldBackIndexed2(folder, array1, array2, state) {\r\n    let acc = state;\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    const size = array1.length | 0;\r\n    for (let i = 1; i <= size; i++) {\r\n        acc = folder(i - 1, array1[size - i], array2[size - i], acc);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function foldBack2(f, array1, array2, state) {\r\n    return foldBackIndexed2((_arg1, x, y, acc) => f(x, y, acc), array1, array2, state);\r\n}\r\n\r\nexport function reduce(reduction, array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\"));\r\n    }\r\n    const reduction_1 = reduction;\r\n    return array.reduce(reduction_1);\r\n}\r\n\r\nexport function reduceBack(reduction, array) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\"));\r\n    }\r\n    const reduction_1 = reduction;\r\n    return array.reduceRight(reduction_1);\r\n}\r\n\r\nexport function forAll2(predicate, array1, array2) {\r\n    return fold2((acc, x, y) => (acc && predicate(x, y)), true, array1, array2);\r\n}\r\n\r\nexport function existsOffset(predicate_mut, array_mut, index_mut) {\r\n    existsOffset:\r\n    while (true) {\r\n        const predicate = predicate_mut, array = array_mut, index = index_mut;\r\n        if (index === array.length) {\r\n            return false;\r\n        }\r\n        else if (predicate(array[index])) {\r\n            return true;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            array_mut = array;\r\n            index_mut = (index + 1);\r\n            continue existsOffset;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function exists(predicate, array) {\r\n    return existsOffset(predicate, array, 0);\r\n}\r\n\r\nexport function existsOffset2(predicate_mut, array1_mut, array2_mut, index_mut) {\r\n    existsOffset2:\r\n    while (true) {\r\n        const predicate = predicate_mut, array1 = array1_mut, array2 = array2_mut, index = index_mut;\r\n        if (index === array1.length) {\r\n            return false;\r\n        }\r\n        else if (predicate(array1[index], array2[index])) {\r\n            return true;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            array1_mut = array1;\r\n            array2_mut = array2;\r\n            index_mut = (index + 1);\r\n            continue existsOffset2;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function exists2(predicate, array1, array2) {\r\n    if (array1.length !== array2.length) {\r\n        differentLengths();\r\n    }\r\n    return existsOffset2(predicate, array1, array2, 0);\r\n}\r\n\r\nexport function sum(array, adder) {\r\n    let acc = adder.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        acc = adder.Add(acc, array[i]);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function sumBy(projection, array, adder) {\r\n    let acc = adder.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        acc = adder.Add(acc, projection(array[i]));\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(array, averager) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    let total = averager.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        total = averager.Add(total, array[i]);\r\n    }\r\n    return averager.DivideByInt(total, array.length);\r\n}\r\n\r\nexport function averageBy(projection, array, averager) {\r\n    if (array.length === 0) {\r\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\r\n    }\r\n    let total = averager.GetZero();\r\n    for (let i = 0; i <= (array.length - 1); i++) {\r\n        total = averager.Add(total, projection(array[i]));\r\n    }\r\n    return averager.DivideByInt(total, array.length);\r\n}\r\n\r\nexport function windowed(windowSize, source) {\r\n    if (windowSize <= 0) {\r\n        throw (new Error(\"windowSize must be positive\"));\r\n    }\r\n    let res;\r\n    const len = max_1(comparePrimitives, 0, (source.length - windowSize) + 1) | 0;\r\n    res = (new Array(len));\r\n    for (let i = windowSize; i <= source.length; i++) {\r\n        res[i - windowSize] = source.slice(i - windowSize, (i - 1) + 1);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function splitInto(chunks, array) {\r\n    if (chunks < 1) {\r\n        throw (new Error(\"The input must be positive.\\\\nParameter name: chunks\"));\r\n    }\r\n    if (array.length === 0) {\r\n        return [[]];\r\n    }\r\n    else {\r\n        const result = [];\r\n        const chunks_1 = min_1(comparePrimitives, chunks, array.length) | 0;\r\n        const minChunkSize = (~(~(array.length / chunks_1))) | 0;\r\n        const chunksWithExtraItem = (array.length % chunks_1) | 0;\r\n        for (let i = 0; i <= (chunks_1 - 1); i++) {\r\n            const chunkSize = ((i < chunksWithExtraItem) ? (minChunkSize + 1) : minChunkSize) | 0;\r\n            let slice;\r\n            const start_1 = ((i * minChunkSize) + min_1(comparePrimitives, chunksWithExtraItem, i)) | 0;\r\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\r\n            result.push(slice);\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function transpose(arrays, cons) {\r\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\r\n    const len = arrays_1.length | 0;\r\n    if (len === 0) {\r\n        return new Array(0);\r\n    }\r\n    else {\r\n        const firstArray = arrays_1[0];\r\n        const lenInner = firstArray.length | 0;\r\n        if (!forAll((a) => (a.length === lenInner), arrays_1)) {\r\n            differentLengths();\r\n        }\r\n        const result = new Array(lenInner);\r\n        for (let i = 0; i <= (lenInner - 1); i++) {\r\n            result[i] = Helpers_allocateArrayFromCons(cons, len);\r\n            for (let j = 0; j <= (len - 1); j++) {\r\n                result[i][j] = arrays_1[j][i];\r\n            }\r\n        }\r\n        return result;\r\n    }\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index > len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const target = new xs.constructor(len + 1);\r\n    for (let i = 0; i <= (index - 1); i++) {\r\n        target[i] = xs[i];\r\n    }\r\n    target[index] = y;\r\n    for (let i_1 = index; i_1 <= (len - 1); i_1++) {\r\n        target[i_1 + 1] = xs[i_1];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index > len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const ys_1 = Array.from(ys);\r\n    const len2 = ys_1.length | 0;\r\n    const target = new xs.constructor(len + len2);\r\n    for (let i = 0; i <= (index - 1); i++) {\r\n        target[i] = xs[i];\r\n    }\r\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\r\n        target[index + i_1] = ys_1[i_1];\r\n    }\r\n    for (let i_2 = index; i_2 <= (len - 1); i_2++) {\r\n        target[i_2 + len2] = xs[i_2];\r\n    }\r\n    return target;\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    if ((index < 0) ? true : (index >= xs.length)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    let i = -1;\r\n    return filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        return i !== index;\r\n    }, xs);\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    let i = -1;\r\n    let status = -1;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            status = 0;\r\n            return false;\r\n        }\r\n        else if (i > index) {\r\n            if (i < (index + count)) {\r\n                return false;\r\n            }\r\n            else {\r\n                status = 1;\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;\r\n    if (status_1 < 1) {\r\n        const arg = (status_1 < 0) ? \"index\" : \"count\";\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + arg));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    const len = xs.length | 0;\r\n    if ((index < 0) ? true : (index >= len)) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    const target = new xs.constructor(len);\r\n    for (let i = 0; i <= (len - 1); i++) {\r\n        target[i] = ((i === index) ? y : xs[i]);\r\n    }\r\n    return target;\r\n}\r\n\r\n","import { join } from \"./String.js\";\r\nimport { uncurry, disposeSafe, isArrayLike, getEnumerator, toIterator, compare, structuralHash, equals } from \"./Util.js\";\r\nimport { Record } from \"./Types.js\";\r\nimport { class_type, record_type, option_type } from \"./Reflection.js\";\r\nimport { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from \"./Global.js\";\r\nimport { defaultArg, value as value_1, some } from \"./Option.js\";\r\nimport { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, fill } from \"./Array.js\";\r\n\r\nexport class FSharpList extends Record {\r\n    constructor(head, tail) {\r\n        super();\r\n        this.head = head;\r\n        this.tail = tail;\r\n    }\r\n    toString() {\r\n        const xs = this;\r\n        return (\"[\" + join(\"; \", xs)) + \"]\";\r\n    }\r\n    Equals(other) {\r\n        const xs = this;\r\n        if (xs === other) {\r\n            return true;\r\n        }\r\n        else {\r\n            const loop = (xs_1_mut, ys_1_mut) => {\r\n                loop:\r\n                while (true) {\r\n                    const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n                    const matchValue = [xs_1.tail, ys_1.tail];\r\n                    if (matchValue[0] != null) {\r\n                        if (matchValue[1] != null) {\r\n                            const xt = matchValue[0];\r\n                            const yt = matchValue[1];\r\n                            if (equals(xs_1.head, ys_1.head)) {\r\n                                xs_1_mut = xt;\r\n                                ys_1_mut = yt;\r\n                                continue loop;\r\n                            }\r\n                            else {\r\n                                return false;\r\n                            }\r\n                        }\r\n                        else {\r\n                            return false;\r\n                        }\r\n                    }\r\n                    else if (matchValue[1] != null) {\r\n                        return false;\r\n                    }\r\n                    else {\r\n                        return true;\r\n                    }\r\n                    break;\r\n                }\r\n            };\r\n            return loop(xs, other);\r\n        }\r\n    }\r\n    GetHashCode() {\r\n        const xs = this;\r\n        const loop = (i_mut, h_mut, xs_1_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const i = i_mut, h = h_mut, xs_1 = xs_1_mut;\r\n                const matchValue = xs_1.tail;\r\n                if (matchValue != null) {\r\n                    const t = matchValue;\r\n                    if (i > 18) {\r\n                        return h | 0;\r\n                    }\r\n                    else {\r\n                        i_mut = (i + 1);\r\n                        h_mut = (((h << 1) + structuralHash(xs_1.head)) + (631 * i));\r\n                        xs_1_mut = t;\r\n                        continue loop;\r\n                    }\r\n                }\r\n                else {\r\n                    return h | 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(0, 0, xs) | 0;\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    CompareTo(other) {\r\n        const xs = this;\r\n        const loop = (xs_1_mut, ys_1_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n                const matchValue = [xs_1.tail, ys_1.tail];\r\n                if (matchValue[0] != null) {\r\n                    if (matchValue[1] != null) {\r\n                        const xt = matchValue[0];\r\n                        const yt = matchValue[1];\r\n                        const c = compare(xs_1.head, ys_1.head) | 0;\r\n                        if (c === 0) {\r\n                            xs_1_mut = xt;\r\n                            ys_1_mut = yt;\r\n                            continue loop;\r\n                        }\r\n                        else {\r\n                            return c | 0;\r\n                        }\r\n                    }\r\n                    else {\r\n                        return 1;\r\n                    }\r\n                }\r\n                else if (matchValue[1] != null) {\r\n                    return -1;\r\n                }\r\n                else {\r\n                    return 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(xs, other) | 0;\r\n    }\r\n    GetEnumerator() {\r\n        const xs = this;\r\n        return ListEnumerator$1_$ctor_3002E699(xs);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const xs = this;\r\n        return getEnumerator(xs);\r\n    }\r\n}\r\n\r\nexport function FSharpList$reflection(gen0) {\r\n    return record_type(\"ListModule.FSharpList\", [gen0], FSharpList, () => [[\"head\", gen0], [\"tail\", option_type(FSharpList$reflection(gen0))]]);\r\n}\r\n\r\nexport class ListEnumerator$1 {\r\n    constructor(xs) {\r\n        this.xs = xs;\r\n        this.it = this.xs;\r\n        this.current = null;\r\n    }\r\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current;\r\n    }\r\n    [\"System.Collections.IEnumerator.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current;\r\n    }\r\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n        const __ = this;\r\n        const matchValue = __.it.tail;\r\n        if (matchValue != null) {\r\n            const t = matchValue;\r\n            __.current = __.it.head;\r\n            __.it = t;\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.IEnumerator.Reset\"]() {\r\n        const __ = this;\r\n        __.it = __.xs;\r\n        __.current = null;\r\n    }\r\n    Dispose() {\r\n    }\r\n}\r\n\r\nexport function ListEnumerator$1$reflection(gen0) {\r\n    return class_type(\"ListModule.ListEnumerator`1\", [gen0], ListEnumerator$1);\r\n}\r\n\r\nexport function ListEnumerator$1_$ctor_3002E699(xs) {\r\n    return new ListEnumerator$1(xs);\r\n}\r\n\r\nexport function FSharpList_get_Empty() {\r\n    return new FSharpList(null, void 0);\r\n}\r\n\r\nexport function FSharpList_Cons_305B8EAC(x, xs) {\r\n    return new FSharpList(x, xs);\r\n}\r\n\r\nexport function FSharpList__get_IsEmpty(xs) {\r\n    return xs.tail == null;\r\n}\r\n\r\nexport function FSharpList__get_Length(xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            const matchValue = xs_1.tail;\r\n            if (matchValue != null) {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = matchValue;\r\n                continue loop;\r\n            }\r\n            else {\r\n                return i | 0;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs) | 0;\r\n}\r\n\r\nexport function FSharpList__get_Head(xs) {\r\n    const matchValue = xs.tail;\r\n    if (matchValue != null) {\r\n        return xs.head;\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputWasEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function FSharpList__get_Tail(xs) {\r\n    const matchValue = xs.tail;\r\n    if (matchValue != null) {\r\n        return matchValue;\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputWasEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function FSharpList__get_Item_Z524259A4(xs, index) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            const matchValue = xs_1.tail;\r\n            if (matchValue != null) {\r\n                if (i === index) {\r\n                    return xs_1.head;\r\n                }\r\n                else {\r\n                    i_mut = (i + 1);\r\n                    xs_1_mut = matchValue;\r\n                    continue loop;\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function empty() {\r\n    return FSharpList_get_Empty();\r\n}\r\n\r\nexport function cons(x, xs) {\r\n    return FSharpList_Cons_305B8EAC(x, xs);\r\n}\r\n\r\nexport function singleton(x) {\r\n    return FSharpList_Cons_305B8EAC(x, FSharpList_get_Empty());\r\n}\r\n\r\nexport function isEmpty(xs) {\r\n    return FSharpList__get_IsEmpty(xs);\r\n}\r\n\r\nexport function length(xs) {\r\n    return FSharpList__get_Length(xs);\r\n}\r\n\r\nexport function head(xs) {\r\n    return FSharpList__get_Head(xs);\r\n}\r\n\r\nexport function tryHead(xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        return void 0;\r\n    }\r\n    else {\r\n        return some(FSharpList__get_Head(xs));\r\n    }\r\n}\r\n\r\nexport function tail(xs) {\r\n    return FSharpList__get_Tail(xs);\r\n}\r\n\r\nexport function tryLast(xs_mut) {\r\n    tryLast:\r\n    while (true) {\r\n        const xs = xs_mut;\r\n        if (FSharpList__get_IsEmpty(xs)) {\r\n            return void 0;\r\n        }\r\n        else {\r\n            const t = FSharpList__get_Tail(xs);\r\n            if (FSharpList__get_IsEmpty(t)) {\r\n                return some(FSharpList__get_Head(xs));\r\n            }\r\n            else {\r\n                xs_mut = t;\r\n                continue tryLast;\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function last(xs) {\r\n    const matchValue = tryLast(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function compareWith(comparer, xs, ys) {\r\n    const loop = (xs_1_mut, ys_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n            const matchValue = [FSharpList__get_IsEmpty(xs_1), FSharpList__get_IsEmpty(ys_1)];\r\n            if (matchValue[0]) {\r\n                if (matchValue[1]) {\r\n                    return 0;\r\n                }\r\n                else {\r\n                    return -1;\r\n                }\r\n            }\r\n            else if (matchValue[1]) {\r\n                return 1;\r\n            }\r\n            else {\r\n                const c = comparer(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)) | 0;\r\n                if (c === 0) {\r\n                    xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                    ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return c | 0;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(xs, ys) | 0;\r\n}\r\n\r\nexport function toArray(xs) {\r\n    const len = FSharpList__get_Length(xs) | 0;\r\n    const res = fill(new Array(len), 0, len, null);\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (!FSharpList__get_IsEmpty(xs_1)) {\r\n                res[i] = FSharpList__get_Head(xs_1);\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    loop(0, xs);\r\n    return res;\r\n}\r\n\r\nexport function fold(folder, state, xs) {\r\n    let acc = state;\r\n    let xs_1 = xs;\r\n    while (!FSharpList__get_IsEmpty(xs_1)) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_1));\r\n        xs_1 = FSharpList__get_Tail(xs_1);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function reverse(xs) {\r\n    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), FSharpList_get_Empty(), xs);\r\n}\r\n\r\nexport function foldBack(folder, xs, state) {\r\n    return foldBack_1(folder, toArray(xs), state);\r\n}\r\n\r\nexport function foldIndexed(folder, state, xs) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                acc_mut = folder(i, acc, FSharpList__get_Head(xs_1));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, state, xs);\r\n}\r\n\r\nexport function fold2(folder, state, xs, ys) {\r\n    let acc = state;\r\n    let xs_1 = xs;\r\n    let ys_1 = ys;\r\n    while ((!FSharpList__get_IsEmpty(xs_1)) && (!FSharpList__get_IsEmpty(ys_1))) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1));\r\n        xs_1 = FSharpList__get_Tail(xs_1);\r\n        ys_1 = FSharpList__get_Tail(ys_1);\r\n    }\r\n    return acc;\r\n}\r\n\r\nexport function foldBack2(folder, xs, ys, state) {\r\n    return foldBack2_1(folder, toArray(xs), toArray(ys), state);\r\n}\r\n\r\nexport function unfold(gen, state) {\r\n    const loop = (acc_mut, node_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, node = node_mut;\r\n            const matchValue = gen(acc);\r\n            if (matchValue != null) {\r\n                acc_mut = matchValue[1];\r\n                node_mut = ((t = (new FSharpList(matchValue[0], void 0)), (node.tail = t, t)));\r\n                continue loop;\r\n            }\r\n            else {\r\n                return node;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(state, root);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function iterate(action, xs) {\r\n    fold((unitVar0, x) => {\r\n        action(x);\r\n    }, void 0, xs);\r\n}\r\n\r\nexport function iterate2(action, xs, ys) {\r\n    fold2((unitVar0, x, y) => {\r\n        action(x, y);\r\n    }, void 0, xs, ys);\r\n}\r\n\r\nexport function iterateIndexed(action, xs) {\r\n    fold((i, x) => {\r\n        action(i, x);\r\n        return (i + 1) | 0;\r\n    }, 0, xs);\r\n}\r\n\r\nexport function iterateIndexed2(action, xs, ys) {\r\n    fold2((i, x, y) => {\r\n        action(i, x, y);\r\n        return (i + 1) | 0;\r\n    }, 0, xs, ys);\r\n}\r\n\r\nexport function toSeq(xs) {\r\n    return xs;\r\n}\r\n\r\nexport function ofArrayWithTail(xs, tail_1) {\r\n    let res = tail_1;\r\n    for (let i = xs.length - 1; i >= 0; i--) {\r\n        res = FSharpList_Cons_305B8EAC(xs[i], res);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function ofArray(xs) {\r\n    return ofArrayWithTail(xs, FSharpList_get_Empty());\r\n}\r\n\r\nexport function ofSeq(xs) {\r\n    let xs_3, t;\r\n    if (isArrayLike(xs)) {\r\n        return ofArray(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return xs;\r\n    }\r\n    else {\r\n        const root = FSharpList_get_Empty();\r\n        let node = root;\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                node = ((xs_3 = node, (t = (new FSharpList(x, void 0)), (xs_3.tail = t, t))));\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n        const xs_5 = node;\r\n        const t_2 = FSharpList_get_Empty();\r\n        xs_5.tail = t_2;\r\n        return FSharpList__get_Tail(root);\r\n    }\r\n}\r\n\r\nexport function concat(lists) {\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    const action = (xs) => {\r\n        node = fold((acc, x) => {\r\n            const t = new FSharpList(x, void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }, node, xs);\r\n    };\r\n    if (isArrayLike(lists)) {\r\n        lists.forEach(action);\r\n    }\r\n    else if (lists instanceof FSharpList) {\r\n        iterate(action, lists);\r\n    }\r\n    else {\r\n        const enumerator = getEnumerator(lists);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                action(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n    }\r\n    const xs_6 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_6.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function scan(folder, state, xs) {\r\n    let t, xs_4, t_2;\r\n    const root = FSharpList_get_Empty();\r\n    let node = (t = (new FSharpList(state, void 0)), (root.tail = t, t));\r\n    let acc = state;\r\n    let xs_3 = xs;\r\n    while (!FSharpList__get_IsEmpty(xs_3)) {\r\n        acc = folder(acc, FSharpList__get_Head(xs_3));\r\n        node = ((xs_4 = node, (t_2 = (new FSharpList(acc, void 0)), (xs_4.tail = t_2, t_2))));\r\n        xs_3 = FSharpList__get_Tail(xs_3);\r\n    }\r\n    const xs_6 = node;\r\n    const t_4 = FSharpList_get_Empty();\r\n    xs_6.tail = t_4;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function scanBack(folder, xs, state) {\r\n    return ofArray(scanBack_1(folder, toArray(xs), state));\r\n}\r\n\r\nexport function append(xs, ys) {\r\n    return fold((acc, x) => FSharpList_Cons_305B8EAC(x, acc), ys, reverse(xs));\r\n}\r\n\r\nexport function collect(mapping, xs) {\r\n    let xs_1, t;\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    let ys = xs;\r\n    while (!FSharpList__get_IsEmpty(ys)) {\r\n        let zs = mapping(FSharpList__get_Head(ys));\r\n        while (!FSharpList__get_IsEmpty(zs)) {\r\n            node = ((xs_1 = node, (t = (new FSharpList(FSharpList__get_Head(zs), void 0)), (xs_1.tail = t, t))));\r\n            zs = FSharpList__get_Tail(zs);\r\n        }\r\n        ys = FSharpList__get_Tail(ys);\r\n    }\r\n    const xs_3 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_3.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapIndexed(mapping, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = foldIndexed((i, acc, x) => {\r\n        let t;\r\n        return (t = (new FSharpList(mapping(i, x), void 0)), (acc.tail = t, t));\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function map(mapping, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        let t;\r\n        return (t = (new FSharpList(mapping(x), void 0)), (acc.tail = t, t));\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function indexed(xs) {\r\n    return mapIndexed((i, x) => [i, x], xs);\r\n}\r\n\r\nexport function map2(mapping, xs, ys) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold2((acc, x, y) => {\r\n        let t;\r\n        return (t = (new FSharpList(mapping(x, y), void 0)), (acc.tail = t, t));\r\n    }, root, xs, ys);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapIndexed2(mapping, xs, ys) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut, ys_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                acc_mut = ((t = (new FSharpList(mapping(i, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(0, root, xs, ys);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function map3(mapping, xs, ys, zs) {\r\n    const loop = (acc_mut, xs_1_mut, ys_1_mut, zs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, xs_1 = xs_1_mut, ys_1 = ys_1_mut, zs_1 = zs_1_mut;\r\n            if ((FSharpList__get_IsEmpty(xs_1) ? true : FSharpList__get_IsEmpty(ys_1)) ? true : FSharpList__get_IsEmpty(zs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = ((t = (new FSharpList(mapping(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1), FSharpList__get_Head(zs_1)), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                ys_1_mut = FSharpList__get_Tail(ys_1);\r\n                zs_1_mut = FSharpList__get_Tail(zs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node_1 = loop(root, xs, ys, zs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node_1.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function mapFold(mapping, state, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const patternInput_1 = fold((tupledArg, x) => {\r\n        let t;\r\n        const patternInput = mapping(tupledArg[1], x);\r\n        return [(t = (new FSharpList(patternInput[0], void 0)), (tupledArg[0].tail = t, t)), patternInput[1]];\r\n    }, [root, state], xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    patternInput_1[0].tail = t_2;\r\n    return [FSharpList__get_Tail(root), patternInput_1[1]];\r\n}\r\n\r\nexport function mapFoldBack(mapping, xs, state) {\r\n    return mapFold((acc, x) => mapping(x, acc), state, reverse(xs));\r\n}\r\n\r\nexport function tryPick(f, xs) {\r\n    const loop = (xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else {\r\n                const matchValue = f(FSharpList__get_Head(xs_1));\r\n                if (matchValue == null) {\r\n                    xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(xs);\r\n}\r\n\r\nexport function pick(f, xs) {\r\n    const matchValue = tryPick(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFind(f, xs) {\r\n    return tryPick((x) => (f(x) ? some(x) : (void 0)), xs);\r\n}\r\n\r\nexport function find(f, xs) {\r\n    const matchValue = tryFind(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindBack(f, xs) {\r\n    return tryFindBack_1(f, toArray(xs));\r\n}\r\n\r\nexport function findBack(f, xs) {\r\n    const matchValue = tryFindBack(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(f, xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else if (f(FSharpList__get_Head(xs_1))) {\r\n                return i;\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function findIndex(f, xs) {\r\n    const matchValue = tryFindIndex(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndexBack(f, xs) {\r\n    return tryFindIndexBack_1(f, toArray(xs));\r\n}\r\n\r\nexport function findIndexBack(f, xs) {\r\n    const matchValue = tryFindIndexBack(f, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error(SR_keyNotFoundAlt));\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryItem(n, xs) {\r\n    const loop = (i_mut, xs_1_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return void 0;\r\n            }\r\n            else if (i === n) {\r\n                return some(FSharpList__get_Head(xs_1));\r\n            }\r\n            else {\r\n                i_mut = (i + 1);\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(0, xs);\r\n}\r\n\r\nexport function item(n, xs) {\r\n    return FSharpList__get_Item_Z524259A4(xs, n);\r\n}\r\n\r\nexport function filter(f, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        if (f(x)) {\r\n            const t = new FSharpList(x, void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function partition(f, xs) {\r\n    const patternInput = [FSharpList_get_Empty(), FSharpList_get_Empty()];\r\n    const root2 = patternInput[1];\r\n    const root1 = patternInput[0];\r\n    const patternInput_1 = fold(uncurry(2, (tupledArg) => {\r\n        const lacc = tupledArg[0];\r\n        const racc = tupledArg[1];\r\n        return (x) => {\r\n            let t, t_2;\r\n            return f(x) ? [(t = (new FSharpList(x, void 0)), (lacc.tail = t, t)), racc] : [lacc, (t_2 = (new FSharpList(x, void 0)), (racc.tail = t_2, t_2))];\r\n        };\r\n    }), [root1, root2], xs);\r\n    const t_4 = FSharpList_get_Empty();\r\n    patternInput_1[0].tail = t_4;\r\n    const t_5 = FSharpList_get_Empty();\r\n    patternInput_1[1].tail = t_5;\r\n    return [FSharpList__get_Tail(root1), FSharpList__get_Tail(root2)];\r\n}\r\n\r\nexport function choose(f, xs) {\r\n    const root = FSharpList_get_Empty();\r\n    const node = fold((acc, x) => {\r\n        const matchValue = f(x);\r\n        if (matchValue == null) {\r\n            return acc;\r\n        }\r\n        else {\r\n            const t = new FSharpList(value_1(matchValue), void 0);\r\n            acc.tail = t;\r\n            return t;\r\n        }\r\n    }, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function contains(value, xs, eq) {\r\n    return tryFindIndex((v) => eq.Equals(value, v), xs) != null;\r\n}\r\n\r\nexport function initialize(n, f) {\r\n    let xs, t;\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    for (let i = 0; i <= (n - 1); i++) {\r\n        node = ((xs = node, (t = (new FSharpList(f(i), void 0)), (xs.tail = t, t))));\r\n    }\r\n    const xs_2 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_2.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function replicate(n, x) {\r\n    return initialize(n, (_arg1) => x);\r\n}\r\n\r\nexport function reduce(f, xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return fold(f, head(xs), tail(xs));\r\n    }\r\n}\r\n\r\nexport function reduceBack(f, xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error(SR_inputWasEmpty));\r\n    }\r\n    else {\r\n        return foldBack(f, tail(xs), head(xs));\r\n    }\r\n}\r\n\r\nexport function forAll(f, xs) {\r\n    return fold((acc, x) => (acc && f(x)), true, xs);\r\n}\r\n\r\nexport function forAll2(f, xs, ys) {\r\n    return fold2((acc, x, y) => (acc && f(x, y)), true, xs, ys);\r\n}\r\n\r\nexport function exists(f, xs) {\r\n    return tryFindIndex(f, xs) != null;\r\n}\r\n\r\nexport function exists2(f_mut, xs_mut, ys_mut) {\r\n    exists2:\r\n    while (true) {\r\n        const f = f_mut, xs = xs_mut, ys = ys_mut;\r\n        const matchValue = [FSharpList__get_IsEmpty(xs), FSharpList__get_IsEmpty(ys)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0]) {\r\n            if (matchValue[1]) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 2;\r\n            }\r\n        }\r\n        else if (matchValue[1]) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return false;\r\n            }\r\n            case 1: {\r\n                if (f(FSharpList__get_Head(xs), FSharpList__get_Head(ys))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    xs_mut = FSharpList__get_Tail(xs);\r\n                    ys_mut = FSharpList__get_Tail(ys);\r\n                    continue exists2;\r\n                }\r\n            }\r\n            case 2: {\r\n                throw (new Error((SR_differentLengths + \"\\\\nParameter name: \") + \"list2\"));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function unzip(xs) {\r\n    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty()]);\r\n}\r\n\r\nexport function unzip3(xs) {\r\n    return foldBack((tupledArg, tupledArg_1) => [FSharpList_Cons_305B8EAC(tupledArg[0], tupledArg_1[0]), FSharpList_Cons_305B8EAC(tupledArg[1], tupledArg_1[1]), FSharpList_Cons_305B8EAC(tupledArg[2], tupledArg_1[2])], xs, [FSharpList_get_Empty(), FSharpList_get_Empty(), FSharpList_get_Empty()]);\r\n}\r\n\r\nexport function zip(xs, ys) {\r\n    return map2((x, y) => [x, y], xs, ys);\r\n}\r\n\r\nexport function zip3(xs, ys, zs) {\r\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    const arr = toArray(xs);\r\n    arr.sort(comparer);\r\n    return ofArray(arr);\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(x, y), xs);\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);\r\n}\r\n\r\nexport function sum(xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\r\n}\r\n\r\nexport function sumBy(f, xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, x);\r\n    }, averager.GetZero(), xs);\r\n    return averager.DivideByInt(total, count);\r\n}\r\n\r\nexport function averageBy(f, xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, f(x));\r\n    }, averager.GetZero(), xs);\r\n    return averager.DivideByInt(total, count);\r\n}\r\n\r\nexport function permute(f, xs) {\r\n    return ofArray(permute_1(f, toArray(xs)));\r\n}\r\n\r\nexport function chunkBySize(chunkSize, xs) {\r\n    return ofArray(map_1(ofArray, chunkBySize_1(chunkSize, toArray(xs))));\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const root = FSharpList_get_Empty();\r\n    let node = root;\r\n    iterate((x) => {\r\n        iterate((y) => {\r\n            let xs_1, t;\r\n            node = ((xs_1 = node, (t = (new FSharpList([x, y], void 0)), (xs_1.tail = t, t))));\r\n        }, ys);\r\n    }, xs);\r\n    const xs_3 = node;\r\n    const t_2 = FSharpList_get_Empty();\r\n    xs_3.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function skip(count_mut, xs_mut) {\r\n    skip:\r\n    while (true) {\r\n        const count = count_mut, xs = xs_mut;\r\n        if (count <= 0) {\r\n            return xs;\r\n        }\r\n        else if (FSharpList__get_IsEmpty(xs)) {\r\n            throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"list\"));\r\n        }\r\n        else {\r\n            count_mut = (count - 1);\r\n            xs_mut = FSharpList__get_Tail(xs);\r\n            continue skip;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function skipWhile(predicate_mut, xs_mut) {\r\n    skipWhile:\r\n    while (true) {\r\n        const predicate = predicate_mut, xs = xs_mut;\r\n        if (FSharpList__get_IsEmpty(xs)) {\r\n            return xs;\r\n        }\r\n        else if (!predicate(FSharpList__get_Head(xs))) {\r\n            return xs;\r\n        }\r\n        else {\r\n            predicate_mut = predicate;\r\n            xs_mut = FSharpList__get_Tail(xs);\r\n            continue skipWhile;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function take(count, xs) {\r\n    if (count < 0) {\r\n        throw (new Error((SR_inputMustBeNonNegative + \"\\\\nParameter name: \") + \"count\"));\r\n    }\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (i <= 0) {\r\n                return acc;\r\n            }\r\n            else if (FSharpList__get_IsEmpty(xs_1)) {\r\n                throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"list\"));\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(count, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function takeWhile(predicate, xs) {\r\n    const loop = (acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else if (!predicate(FSharpList__get_Head(xs_1))) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function truncate(count, xs) {\r\n    const loop = (i_mut, acc_mut, xs_1_mut) => {\r\n        let t;\r\n        loop:\r\n        while (true) {\r\n            const i = i_mut, acc = acc_mut, xs_1 = xs_1_mut;\r\n            if (i <= 0) {\r\n                return acc;\r\n            }\r\n            else if (FSharpList__get_IsEmpty(xs_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                i_mut = (i - 1);\r\n                acc_mut = ((t = (new FSharpList(FSharpList__get_Head(xs_1), void 0)), (acc.tail = t, t)));\r\n                xs_1_mut = FSharpList__get_Tail(xs_1);\r\n                continue loop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const root = FSharpList_get_Empty();\r\n    const node = loop(count, root, xs);\r\n    const t_2 = FSharpList_get_Empty();\r\n    node.tail = t_2;\r\n    return FSharpList__get_Tail(root);\r\n}\r\n\r\nexport function getSlice(startIndex, endIndex, xs) {\r\n    const len = length(xs) | 0;\r\n    const startIndex_1 = defaultArg(startIndex, 0) | 0;\r\n    const endIndex_1 = defaultArg(endIndex, len - 1) | 0;\r\n    if (startIndex_1 < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"startIndex\"));\r\n    }\r\n    else if (endIndex_1 >= len) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"endIndex\"));\r\n    }\r\n    else if (endIndex_1 < startIndex_1) {\r\n        return FSharpList_get_Empty();\r\n    }\r\n    else {\r\n        return take((endIndex_1 - startIndex_1) + 1, skip(startIndex_1, xs));\r\n    }\r\n}\r\n\r\nexport function splitAt(index, xs) {\r\n    if (index < 0) {\r\n        throw (new Error((SR_inputMustBeNonNegative + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    if (index > FSharpList__get_Length(xs)) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return [take(index, xs), skip(index, xs)];\r\n}\r\n\r\nexport function exactlyOne(xs) {\r\n    if (FSharpList__get_IsEmpty(xs)) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n    else if (FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {\r\n        return FSharpList__get_Head(xs);\r\n    }\r\n    else {\r\n        throw (new Error((SR_inputSequenceTooLong + \"\\\\nParameter name: \") + \"list\"));\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(xs) {\r\n    if ((!FSharpList__get_IsEmpty(xs)) && FSharpList__get_IsEmpty(FSharpList__get_Tail(xs))) {\r\n        return some(FSharpList__get_Head(xs));\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function where(predicate, xs) {\r\n    return filter(predicate, xs);\r\n}\r\n\r\nexport function pairwise(xs) {\r\n    return ofArray(pairwise_1(toArray(xs)));\r\n}\r\n\r\nexport function windowed(windowSize, xs) {\r\n    return ofArray(map_1(ofArray, windowed_1(windowSize, toArray(xs))));\r\n}\r\n\r\nexport function splitInto(chunks, xs) {\r\n    return ofArray(map_1(ofArray, splitInto_1(chunks, toArray(xs))));\r\n}\r\n\r\nexport function transpose(lists) {\r\n    return ofArray(map_1(ofArray, transpose_1(map_1(toArray, Array.from(lists)))));\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const result = fold((acc, x) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return FSharpList_Cons_305B8EAC(x, FSharpList_Cons_305B8EAC(y, acc));\r\n        }\r\n        else {\r\n            return FSharpList_Cons_305B8EAC(x, acc);\r\n        }\r\n    }, FSharpList_get_Empty(), xs);\r\n    return reverse(isDone ? result : (((i + 1) === index) ? FSharpList_Cons_305B8EAC(y, result) : (() => {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    })()));\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const ys_1 = ofSeq(ys);\r\n    const result = fold((acc, x) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return FSharpList_Cons_305B8EAC(x, append(ys_1, acc));\r\n        }\r\n        else {\r\n            return FSharpList_Cons_305B8EAC(x, acc);\r\n        }\r\n    }, FSharpList_get_Empty(), xs);\r\n    return reverse(isDone ? result : (((i + 1) === index) ? append(ys_1, result) : (() => {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    })()));\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    let i = -1;\r\n    let isDone = false;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            isDone = true;\r\n            return false;\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    if (!isDone) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    let i = -1;\r\n    let status = -1;\r\n    const ys = filter((_arg1) => {\r\n        i = ((i + 1) | 0);\r\n        if (i === index) {\r\n            status = 0;\r\n            return false;\r\n        }\r\n        else if (i > index) {\r\n            if (i < (index + count)) {\r\n                return false;\r\n            }\r\n            else {\r\n                status = 1;\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n    }, xs);\r\n    const status_1 = (((status === 0) && ((i + 1) === (index + count))) ? 1 : status) | 0;\r\n    if (status_1 < 1) {\r\n        const arg = (status_1 < 0) ? \"index\" : \"count\";\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + arg));\r\n    }\r\n    return ys;\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    let isDone = false;\r\n    const ys = mapIndexed((i, x) => {\r\n        if (i === index) {\r\n            isDone = true;\r\n            return y;\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n    }, xs);\r\n    if (!isDone) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return ys;\r\n}\r\n\r\n","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 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 { 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 { singleton, concat, map, empty, iterate } from \"../fable-library.3.7.5/List.js\";\nimport { singleton as singleton_1 } from \"../fable-library.3.7.5/AsyncBuilder.js\";\nimport { startImmediate, catchAsync } from \"../fable-library.3.7.5/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 { some } from \"../fable-library.3.7.5/Option.js\";\nimport Timer from \"../fable-library.3.7.5/Timer.js\";\nimport { add } from \"../fable-library.3.7.5/Observable.js\";\n\nexport function Log_onError(text, ex) {\n    console.error(some(text), ex);\n}\n\nexport function Log_toConsole(text, o) {\n    console.log(some(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 { disposeSafe, structuralHash, equals } from \"./Util.js\";\r\nimport { HashIdentity_Structural, ComparisonIdentity_Structural } from \"./FSharp.Collections.js\";\r\nimport { StringBuilder__Append_Z721C83C5 } from \"./System.Text.js\";\r\n\r\nexport const LanguagePrimitives_GenericEqualityComparer = {\r\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\r\n        return equals(x, y);\r\n    },\r\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\r\n        return structuralHash(x_1);\r\n    },\r\n};\r\n\r\nexport const LanguagePrimitives_GenericEqualityERComparer = {\r\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\r\n        return equals(x, y);\r\n    },\r\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\r\n        return structuralHash(x_1);\r\n    },\r\n};\r\n\r\nexport function LanguagePrimitives_FastGenericComparer() {\r\n    return ComparisonIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericComparerFromTable() {\r\n    return ComparisonIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericEqualityComparer() {\r\n    return HashIdentity_Structural();\r\n}\r\n\r\nexport function LanguagePrimitives_FastGenericEqualityComparerFromTable() {\r\n    return HashIdentity_Structural();\r\n}\r\n\r\nexport function Operators_Failure(message) {\r\n    return new Error(message);\r\n}\r\n\r\nexport function Operators_FailurePattern(exn) {\r\n    return exn.message;\r\n}\r\n\r\nexport function Operators_NullArg(x) {\r\n    throw (new Error(x));\r\n}\r\n\r\nexport function Operators_Using(resource, action) {\r\n    try {\r\n        return action(resource);\r\n    }\r\n    finally {\r\n        if (equals(resource, null)) {\r\n        }\r\n        else {\r\n            disposeSafe(resource);\r\n        }\r\n    }\r\n}\r\n\r\nexport function Operators_Lock(_lockObj, action) {\r\n    return action();\r\n}\r\n\r\nexport function ExtraTopLevelOperators_LazyPattern(input) {\r\n    return input.Value;\r\n}\r\n\r\nexport function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {\r\n    return format.cont((s) => {\r\n        StringBuilder__Append_Z721C83C5(builder, s);\r\n        return continuation();\r\n    });\r\n}\r\n\r\nexport function PrintfModule_PrintFormatToStringBuilder(builder, format) {\r\n    return PrintfModule_PrintFormatToStringBuilderThen(() => {\r\n    }, builder, format);\r\n}\r\n\r\n","import { compare, physicalHash, equals, structuralHash } from \"./Util.js\";\r\n\r\nexport function HashIdentity_FromFunctions(hash, eq) {\r\n    return {\r\n        Equals(x, y) {\r\n            return eq(x, y);\r\n        },\r\n        GetHashCode(x_1) {\r\n            return hash(x_1);\r\n        },\r\n    };\r\n}\r\n\r\nexport function HashIdentity_Structural() {\r\n    return HashIdentity_FromFunctions(structuralHash, equals);\r\n}\r\n\r\nexport function HashIdentity_Reference() {\r\n    return HashIdentity_FromFunctions(physicalHash, (e1, e2) => (e1 === e2));\r\n}\r\n\r\nexport function ComparisonIdentity_FromFunction(comparer) {\r\n    return {\r\n        Compare(x, y) {\r\n            return comparer(x, y);\r\n        },\r\n    };\r\n}\r\n\r\nexport function ComparisonIdentity_Structural() {\r\n    return ComparisonIdentity_FromFunction(compare);\r\n}\r\n\r\n","import { clear, equals, isArrayLike, isDisposable, toIterator, disposeSafe, getEnumerator } from \"./Util.js\";\r\nimport { toString } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { Operators_Lock, Operators_NullArg } from \"./FSharp.Core.js\";\r\nimport { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, windowed as windowed_1, splitInto as splitInto_1, map as map_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from \"./Array.js\";\r\nimport { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from \"./List.js\";\r\nimport { SR_indexOutOfBounds } from \"./Global.js\";\r\n\r\nexport const SR_enumerationAlreadyFinished = \"Enumeration already finished.\";\r\n\r\nexport const SR_enumerationNotStarted = \"Enumeration has not started. Call MoveNext.\";\r\n\r\nexport const SR_inputSequenceEmpty = \"The input sequence was empty.\";\r\n\r\nexport const SR_inputSequenceTooLong = \"The input sequence contains more than one element.\";\r\n\r\nexport const SR_keyNotFoundAlt = \"An index satisfying the predicate was not found in the collection.\";\r\n\r\nexport const SR_notEnoughElements = \"The input sequence has an insufficient number of elements.\";\r\n\r\nexport const SR_resetNotSupported = \"Reset is not supported on this enumerator.\";\r\n\r\nexport function Enumerator_noReset() {\r\n    throw (new Error(SR_resetNotSupported));\r\n}\r\n\r\nexport function Enumerator_notStarted() {\r\n    throw (new Error(SR_enumerationNotStarted));\r\n}\r\n\r\nexport function Enumerator_alreadyFinished() {\r\n    throw (new Error(SR_enumerationAlreadyFinished));\r\n}\r\n\r\nexport class Enumerator_Seq {\r\n    constructor(f) {\r\n        this.f = f;\r\n    }\r\n    toString() {\r\n        const xs = this;\r\n        const maxCount = 4;\r\n        let i = 0;\r\n        let str = \"seq [\";\r\n        const e = getEnumerator(xs);\r\n        try {\r\n            while ((i < maxCount) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                if (i > 0) {\r\n                    str = (str + \"; \");\r\n                }\r\n                str = (str + toString(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()));\r\n                i = ((i + 1) | 0);\r\n            }\r\n            if (i === maxCount) {\r\n                str = (str + \"; ...\");\r\n            }\r\n            return str + \"]\";\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n    GetEnumerator() {\r\n        const x = this;\r\n        return x.f();\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const x = this;\r\n        return x.f();\r\n    }\r\n}\r\n\r\nexport function Enumerator_Seq$reflection(gen0) {\r\n    return class_type(\"SeqModule.Enumerator.Seq\", [gen0], Enumerator_Seq);\r\n}\r\n\r\nexport function Enumerator_Seq_$ctor_673A07F2(f) {\r\n    return new Enumerator_Seq(f);\r\n}\r\n\r\nexport class Enumerator_FromFunctions$1 {\r\n    constructor(current, next, dispose) {\r\n        this.current = current;\r\n        this.next = next;\r\n        this.dispose = dispose;\r\n    }\r\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current();\r\n    }\r\n    [\"System.Collections.IEnumerator.get_Current\"]() {\r\n        const __ = this;\r\n        return __.current();\r\n    }\r\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n        const __ = this;\r\n        return __.next();\r\n    }\r\n    [\"System.Collections.IEnumerator.Reset\"]() {\r\n        Enumerator_noReset();\r\n    }\r\n    Dispose() {\r\n        const __ = this;\r\n        __.dispose();\r\n    }\r\n}\r\n\r\nexport function Enumerator_FromFunctions$1$reflection(gen0) {\r\n    return class_type(\"SeqModule.Enumerator.FromFunctions`1\", [gen0], Enumerator_FromFunctions$1);\r\n}\r\n\r\nexport function Enumerator_FromFunctions$1_$ctor_58C54629(current, next, dispose) {\r\n    return new Enumerator_FromFunctions$1(current, next, dispose);\r\n}\r\n\r\nexport function Enumerator_cast(e) {\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e[\"System.Collections.IEnumerator.get_Current\"](), () => e[\"System.Collections.IEnumerator.MoveNext\"](), () => {\r\n        if (isDisposable(e)) {\r\n            disposeSafe(e);\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_concat(sources) {\r\n    let outerOpt = void 0;\r\n    let innerOpt = void 0;\r\n    let started = false;\r\n    let finished = false;\r\n    let curr = void 0;\r\n    const finish = () => {\r\n        finished = true;\r\n        if (innerOpt != null) {\r\n            const inner = innerOpt;\r\n            try {\r\n                disposeSafe(inner);\r\n            }\r\n            finally {\r\n                innerOpt = (void 0);\r\n            }\r\n        }\r\n        if (outerOpt != null) {\r\n            const outer = outerOpt;\r\n            try {\r\n                disposeSafe(outer);\r\n            }\r\n            finally {\r\n                outerOpt = (void 0);\r\n            }\r\n        }\r\n    };\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (!started) {\r\n            Enumerator_notStarted();\r\n        }\r\n        else if (finished) {\r\n            Enumerator_alreadyFinished();\r\n        }\r\n        if (curr != null) {\r\n            return value_1(curr);\r\n        }\r\n        else {\r\n            return Enumerator_alreadyFinished();\r\n        }\r\n    }, () => {\r\n        let copyOfStruct;\r\n        if (!started) {\r\n            started = true;\r\n        }\r\n        if (finished) {\r\n            return false;\r\n        }\r\n        else {\r\n            let res = void 0;\r\n            while (res == null) {\r\n                const matchValue = [outerOpt, innerOpt];\r\n                if (matchValue[0] != null) {\r\n                    if (matchValue[1] != null) {\r\n                        const inner_1 = matchValue[1];\r\n                        if (inner_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            curr = some(inner_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                            res = true;\r\n                        }\r\n                        else {\r\n                            try {\r\n                                disposeSafe(inner_1);\r\n                            }\r\n                            finally {\r\n                                innerOpt = (void 0);\r\n                            }\r\n                        }\r\n                    }\r\n                    else {\r\n                        const outer_1 = matchValue[0];\r\n                        if (outer_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            const ie = outer_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                            innerOpt = ((copyOfStruct = ie, getEnumerator(copyOfStruct)));\r\n                        }\r\n                        else {\r\n                            finish();\r\n                            res = false;\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    outerOpt = getEnumerator(sources);\r\n                }\r\n            }\r\n            return value_1(res);\r\n        }\r\n    }, () => {\r\n        if (!finished) {\r\n            finish();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_enumerateThenFinally(f, e) {\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), () => e[\"System.Collections.IEnumerator.MoveNext\"](), () => {\r\n        try {\r\n            disposeSafe(e);\r\n        }\r\n        finally {\r\n            f();\r\n        }\r\n    });\r\n}\r\n\r\nexport function Enumerator_generateWhileSome(openf, compute, closef) {\r\n    let started = false;\r\n    let curr = void 0;\r\n    let state = some(openf());\r\n    const dispose = () => {\r\n        if (state != null) {\r\n            const x_1 = value_1(state);\r\n            try {\r\n                closef(x_1);\r\n            }\r\n            finally {\r\n                state = (void 0);\r\n            }\r\n        }\r\n    };\r\n    const finish = () => {\r\n        try {\r\n            dispose();\r\n        }\r\n        finally {\r\n            curr = (void 0);\r\n        }\r\n    };\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (!started) {\r\n            Enumerator_notStarted();\r\n        }\r\n        if (curr != null) {\r\n            return value_1(curr);\r\n        }\r\n        else {\r\n            return Enumerator_alreadyFinished();\r\n        }\r\n    }, () => {\r\n        if (!started) {\r\n            started = true;\r\n        }\r\n        if (state != null) {\r\n            const s = value_1(state);\r\n            let matchValue_1;\r\n            try {\r\n                matchValue_1 = compute(s);\r\n            }\r\n            catch (matchValue) {\r\n                finish();\r\n                throw matchValue;\r\n            }\r\n            if (matchValue_1 != null) {\r\n                curr = matchValue_1;\r\n                return true;\r\n            }\r\n            else {\r\n                finish();\r\n                return false;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, dispose);\r\n}\r\n\r\nexport function Enumerator_unfold(f, state) {\r\n    let curr = void 0;\r\n    let acc = state;\r\n    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {\r\n        if (curr != null) {\r\n            const x = curr[0];\r\n            const st = curr[1];\r\n            return x;\r\n        }\r\n        else {\r\n            return Enumerator_notStarted();\r\n        }\r\n    }, () => {\r\n        curr = f(acc);\r\n        if (curr != null) {\r\n            const x_1 = curr[0];\r\n            const st_1 = curr[1];\r\n            acc = st_1;\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, () => {\r\n    });\r\n}\r\n\r\nexport function indexNotFound() {\r\n    throw (new Error(SR_keyNotFoundAlt));\r\n}\r\n\r\nexport function checkNonNull(argName, arg) {\r\n    if (arg == null) {\r\n        Operators_NullArg(argName);\r\n    }\r\n}\r\n\r\nexport function mkSeq(f) {\r\n    return Enumerator_Seq_$ctor_673A07F2(f);\r\n}\r\n\r\nexport function ofSeq(xs) {\r\n    checkNonNull(\"source\", xs);\r\n    return getEnumerator(xs);\r\n}\r\n\r\nexport function delay(generator) {\r\n    return mkSeq(() => getEnumerator(generator()));\r\n}\r\n\r\nexport function concat(sources) {\r\n    return mkSeq(() => Enumerator_concat(sources));\r\n}\r\n\r\nexport function unfold(generator, state) {\r\n    return mkSeq(() => Enumerator_unfold(generator, state));\r\n}\r\n\r\nexport function empty() {\r\n    return delay(() => (new Array(0)));\r\n}\r\n\r\nexport function singleton(x) {\r\n    return delay(() => singleton_1(x));\r\n}\r\n\r\nexport function ofArray(arr) {\r\n    return arr;\r\n}\r\n\r\nexport function toArray(xs) {\r\n    if (xs instanceof FSharpList) {\r\n        return toArray_1(xs);\r\n    }\r\n    else {\r\n        return Array.from(xs);\r\n    }\r\n}\r\n\r\nexport function ofList(xs) {\r\n    return xs;\r\n}\r\n\r\nexport function toList(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return ofArray_1(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return xs;\r\n    }\r\n    else {\r\n        return ofSeq_1(xs);\r\n    }\r\n}\r\n\r\nexport function generate(create, compute, dispose) {\r\n    return mkSeq(() => Enumerator_generateWhileSome(create, compute, dispose));\r\n}\r\n\r\nexport function generateIndexed(create, compute, dispose) {\r\n    return mkSeq(() => {\r\n        let i = -1;\r\n        return Enumerator_generateWhileSome(create, (x) => {\r\n            i = ((i + 1) | 0);\r\n            return compute(i, x);\r\n        }, dispose);\r\n    });\r\n}\r\n\r\nexport function append(xs, ys) {\r\n    return concat([xs, ys]);\r\n}\r\n\r\nexport function cast(xs) {\r\n    return mkSeq(() => {\r\n        checkNonNull(\"source\", xs);\r\n        return Enumerator_cast(getEnumerator(xs));\r\n    });\r\n}\r\n\r\nexport function choose(chooser, xs) {\r\n    return generate(() => ofSeq(xs), (e) => {\r\n        let curr = void 0;\r\n        while ((curr == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            curr = chooser(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return curr;\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function compareWith(comparer, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let c = 0;\r\n            let b1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n            let b2 = e2[\"System.Collections.IEnumerator.MoveNext\"]();\r\n            while (((c === 0) && b1) && b2) {\r\n                c = (comparer(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) | 0);\r\n                if (c === 0) {\r\n                    b1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                    b2 = e2[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                }\r\n            }\r\n            return ((c !== 0) ? c : (b1 ? 1 : (b2 ? -1 : 0))) | 0;\r\n        }\r\n        finally {\r\n            disposeSafe(e2);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e1);\r\n    }\r\n}\r\n\r\nexport function contains(value, xs, comparer) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let found = false;\r\n        while ((!found) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            found = comparer.Equals(value, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return found;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function enumerateFromFunctions(create, moveNext, current) {\r\n    return generate(create, (x) => (moveNext(x) ? some(current(x)) : (void 0)), (x_1) => {\r\n        const matchValue = x_1;\r\n        if (isDisposable(matchValue)) {\r\n            disposeSafe(matchValue);\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateThenFinally(source, compensation) {\r\n    const compensation_1 = compensation;\r\n    return mkSeq(() => {\r\n        try {\r\n            return Enumerator_enumerateThenFinally(compensation_1, ofSeq(source));\r\n        }\r\n        catch (matchValue) {\r\n            compensation_1();\r\n            throw matchValue;\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateUsing(resource, source) {\r\n    const compensation = () => {\r\n        if (equals(resource, null)) {\r\n        }\r\n        else {\r\n            let copyOfStruct = resource;\r\n            disposeSafe(copyOfStruct);\r\n        }\r\n    };\r\n    return mkSeq(() => {\r\n        try {\r\n            return Enumerator_enumerateThenFinally(compensation, (ofSeq)(source(resource)));\r\n        }\r\n        catch (matchValue_1) {\r\n            compensation();\r\n            throw matchValue_1;\r\n        }\r\n    });\r\n}\r\n\r\nexport function enumerateWhile(guard, xs) {\r\n    return concat(unfold((i) => (guard() ? [xs, i + 1] : (void 0)), 0));\r\n}\r\n\r\nexport function filter(f, xs) {\r\n    return choose((x) => {\r\n        if (f(x)) {\r\n            return some(x);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, xs);\r\n}\r\n\r\nexport function exists(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let found = false;\r\n        while ((!found) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            found = predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return found;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function exists2(predicate, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let found = false;\r\n            while (((!found) && e1[\"System.Collections.IEnumerator.MoveNext\"]()) && e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                found = predicate(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            return found;\r\n        }\r\n        finally {\r\n            disposeSafe(e2);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e1);\r\n    }\r\n}\r\n\r\nexport function exactlyOne(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const v = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                throw (new Error((SR_inputSequenceTooLong + \"\\\\nParameter name: \") + \"source\"));\r\n            }\r\n            else {\r\n                return v;\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function tryExactlyOne(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const v = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? (void 0) : some(v);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function tryFind(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let res = void 0;\r\n        while ((res == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const c = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            if (predicate(c)) {\r\n                res = some(c);\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function find(predicate, xs) {\r\n    const matchValue = tryFind(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindBack(predicate, xs) {\r\n    return tryFindBack_1(predicate, toArray(xs));\r\n}\r\n\r\nexport function findBack(predicate, xs) {\r\n    const matchValue = tryFindBack(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function tryFindIndex(predicate, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (i_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const i = i_mut;\r\n                if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    if (predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) {\r\n                        return i;\r\n                    }\r\n                    else {\r\n                        i_mut = (i + 1);\r\n                        continue loop;\r\n                    }\r\n                }\r\n                else {\r\n                    return void 0;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(0);\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function findIndex(predicate, xs) {\r\n    const matchValue = tryFindIndex(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound() | 0;\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function tryFindIndexBack(predicate, xs) {\r\n    return tryFindIndexBack_1(predicate, toArray(xs));\r\n}\r\n\r\nexport function findIndexBack(predicate, xs) {\r\n    const matchValue = tryFindIndexBack(predicate, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound() | 0;\r\n    }\r\n    else {\r\n        return matchValue | 0;\r\n    }\r\n}\r\n\r\nexport function fold(folder, state, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let acc = state;\r\n        while (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            acc = folder(acc, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return acc;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function foldBack(folder, xs, state) {\r\n    return foldBack_1(folder, toArray(xs), state);\r\n}\r\n\r\nexport function fold2(folder, state, xs, ys) {\r\n    const e1 = ofSeq(xs);\r\n    try {\r\n        const e2 = ofSeq(ys);\r\n        try {\r\n            let acc = state;\r\n            while (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                acc = folder(acc, e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            return acc;\r\n        }\r\n        finally {\r\n            disposeSafe(e2);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e1);\r\n    }\r\n}\r\n\r\nexport function foldBack2(folder, xs, ys, state) {\r\n    return foldBack2_1(folder, toArray(xs), toArray(ys), state);\r\n}\r\n\r\nexport function forAll(predicate, xs) {\r\n    return !exists((x) => (!predicate(x)), xs);\r\n}\r\n\r\nexport function forAll2(predicate, xs, ys) {\r\n    return !exists2((x, y) => (!predicate(x, y)), xs, ys);\r\n}\r\n\r\nexport function tryHead(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return tryHead_1(xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return tryHead_2(xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function head(xs) {\r\n    const matchValue = tryHead(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function initialize(count, f) {\r\n    return unfold((i) => ((i < count) ? [f(i), i + 1] : (void 0)), 0);\r\n}\r\n\r\nexport function initializeInfinite(f) {\r\n    return initialize(2147483647, f);\r\n}\r\n\r\nexport function isEmpty(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return xs.length === 0;\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return isEmpty_1(xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            return !e[\"System.Collections.IEnumerator.MoveNext\"]();\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function tryItem(index, xs) {\r\n    if (isArrayLike(xs)) {\r\n        return tryItem_1(index, xs);\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return tryItem_2(index, xs);\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            const loop = (index_1_mut) => {\r\n                loop:\r\n                while (true) {\r\n                    const index_1 = index_1_mut;\r\n                    if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        return void 0;\r\n                    }\r\n                    else if (index_1 === 0) {\r\n                        return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                    }\r\n                    else {\r\n                        index_1_mut = (index_1 - 1);\r\n                        continue loop;\r\n                    }\r\n                    break;\r\n                }\r\n            };\r\n            return loop(index);\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function item(index, xs) {\r\n    const matchValue = tryItem(index, xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function iterate(action, xs) {\r\n    fold((unitVar0, x) => {\r\n        action(x);\r\n    }, void 0, xs);\r\n}\r\n\r\nexport function iterate2(action, xs, ys) {\r\n    fold2((unitVar0, x, y) => {\r\n        action(x, y);\r\n    }, void 0, xs, ys);\r\n}\r\n\r\nexport function iterateIndexed(action, xs) {\r\n    fold((i, x) => {\r\n        action(i, x);\r\n        return (i + 1) | 0;\r\n    }, 0, xs);\r\n}\r\n\r\nexport function iterateIndexed2(action, xs, ys) {\r\n    fold2((i, x, y) => {\r\n        action(i, x, y);\r\n        return (i + 1) | 0;\r\n    }, 0, xs, ys);\r\n}\r\n\r\nexport function tryLast(xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (acc_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const acc = acc_mut;\r\n                if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    return acc;\r\n                }\r\n                else {\r\n                    acc_mut = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                    continue loop;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(loop(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function last(xs) {\r\n    const matchValue = tryLast(xs);\r\n    if (matchValue == null) {\r\n        throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function length(xs) {\r\n    if (isArrayLike(xs)) {\r\n        return xs.length | 0;\r\n    }\r\n    else if (xs instanceof FSharpList) {\r\n        return length_1(xs) | 0;\r\n    }\r\n    else {\r\n        const e = ofSeq(xs);\r\n        try {\r\n            let count = 0;\r\n            while (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                count = ((count + 1) | 0);\r\n            }\r\n            return count | 0;\r\n        }\r\n        finally {\r\n            disposeSafe(e);\r\n        }\r\n    }\r\n}\r\n\r\nexport function map(mapping, xs) {\r\n    return generate(() => ofSeq(xs), (e) => (e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(mapping(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function mapIndexed(mapping, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => (e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(mapping(i, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function indexed(xs) {\r\n    return mapIndexed((i, x) => [i, x], xs);\r\n}\r\n\r\nexport function map2(mapping, xs, ys) {\r\n    return generate(() => [ofSeq(xs), ofSeq(ys)], (tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        return (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            disposeSafe(tupledArg_1[0]);\r\n        }\r\n        finally {\r\n            disposeSafe(tupledArg_1[1]);\r\n        }\r\n    });\r\n}\r\n\r\nexport function mapIndexed2(mapping, xs, ys) {\r\n    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        return (e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(i, e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            disposeSafe(tupledArg_1[0]);\r\n        }\r\n        finally {\r\n            disposeSafe(tupledArg_1[1]);\r\n        }\r\n    });\r\n}\r\n\r\nexport function map3(mapping, xs, ys, zs) {\r\n    return generate(() => [ofSeq(xs), ofSeq(ys), ofSeq(zs)], (tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        const e3 = tupledArg[2];\r\n        return ((e1[\"System.Collections.IEnumerator.MoveNext\"]() && e2[\"System.Collections.IEnumerator.MoveNext\"]()) && e3[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(mapping(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), e3[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) : (void 0);\r\n    }, (tupledArg_1) => {\r\n        try {\r\n            disposeSafe(tupledArg_1[0]);\r\n        }\r\n        finally {\r\n            try {\r\n                disposeSafe(tupledArg_1[1]);\r\n            }\r\n            finally {\r\n                disposeSafe(tupledArg_1[2]);\r\n            }\r\n        }\r\n    });\r\n}\r\n\r\nexport function readOnly(xs) {\r\n    checkNonNull(\"source\", xs);\r\n    return map((x) => x, xs);\r\n}\r\n\r\nexport class CachedSeq$1 {\r\n    constructor(cleanup, res) {\r\n        this.cleanup = cleanup;\r\n        this.res = res;\r\n    }\r\n    Dispose() {\r\n        const _ = this;\r\n        _.cleanup();\r\n    }\r\n    GetEnumerator() {\r\n        const _ = this;\r\n        return getEnumerator(_.res);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const _ = this;\r\n        return getEnumerator(_.res);\r\n    }\r\n}\r\n\r\nexport function CachedSeq$1$reflection(gen0) {\r\n    return class_type(\"SeqModule.CachedSeq`1\", [gen0], CachedSeq$1);\r\n}\r\n\r\nexport function CachedSeq$1_$ctor_Z7A8347D4(cleanup, res) {\r\n    return new CachedSeq$1(cleanup, res);\r\n}\r\n\r\nexport function CachedSeq$1__Clear(_) {\r\n    _.cleanup();\r\n}\r\n\r\nexport function cache(source) {\r\n    checkNonNull(\"source\", source);\r\n    const prefix = [];\r\n    let enumeratorR = void 0;\r\n    return CachedSeq$1_$ctor_Z7A8347D4(() => {\r\n        Operators_Lock(prefix, () => {\r\n            clear(prefix);\r\n            let pattern_matching_result, e;\r\n            if (enumeratorR != null) {\r\n                if (value_1(enumeratorR) != null) {\r\n                    pattern_matching_result = 0;\r\n                    e = value_1(enumeratorR);\r\n                }\r\n                else {\r\n                    pattern_matching_result = 1;\r\n                }\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n            switch (pattern_matching_result) {\r\n                case 0: {\r\n                    disposeSafe(e);\r\n                    break;\r\n                }\r\n            }\r\n            enumeratorR = (void 0);\r\n        });\r\n    }, unfold((i_1) => Operators_Lock(prefix, () => {\r\n        if (i_1 < prefix.length) {\r\n            return [prefix[i_1], i_1 + 1];\r\n        }\r\n        else {\r\n            if (i_1 >= prefix.length) {\r\n                let optEnumerator_2;\r\n                if (enumeratorR != null) {\r\n                    optEnumerator_2 = value_1(enumeratorR);\r\n                }\r\n                else {\r\n                    const optEnumerator = getEnumerator(source);\r\n                    enumeratorR = some(optEnumerator);\r\n                    optEnumerator_2 = optEnumerator;\r\n                }\r\n                if (optEnumerator_2 == null) {\r\n                }\r\n                else {\r\n                    const enumerator = optEnumerator_2;\r\n                    if (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        void (prefix.push(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()));\r\n                    }\r\n                    else {\r\n                        disposeSafe(enumerator);\r\n                        enumeratorR = some(void 0);\r\n                    }\r\n                }\r\n            }\r\n            return (i_1 < prefix.length) ? [prefix[i_1], i_1 + 1] : (void 0);\r\n        }\r\n    }), 0));\r\n}\r\n\r\nexport function allPairs(xs, ys) {\r\n    const ysCache = cache(ys);\r\n    return delay(() => concat(map((x) => map((y) => [x, y], ysCache), xs)));\r\n}\r\n\r\nexport function mapFold(mapping, state, xs) {\r\n    const patternInput = mapFold_1(mapping, state, toArray(xs));\r\n    return [readOnly(patternInput[0]), patternInput[1]];\r\n}\r\n\r\nexport function mapFoldBack(mapping, xs, state) {\r\n    const patternInput = mapFoldBack_1(mapping, toArray(xs), state);\r\n    return [readOnly(patternInput[0]), patternInput[1]];\r\n}\r\n\r\nexport function tryPick(chooser, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        let res = void 0;\r\n        while ((res == null) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            res = chooser(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        return res;\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function pick(chooser, xs) {\r\n    const matchValue = tryPick(chooser, xs);\r\n    if (matchValue == null) {\r\n        return indexNotFound();\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function reduce(folder, xs) {\r\n    const e = ofSeq(xs);\r\n    try {\r\n        const loop = (acc_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const acc = acc_mut;\r\n                if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    acc_mut = folder(acc, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return acc;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return loop(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else {\r\n            throw (new Error(SR_inputSequenceEmpty));\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(e);\r\n    }\r\n}\r\n\r\nexport function reduceBack(folder, xs) {\r\n    const arr = toArray(xs);\r\n    if (arr.length > 0) {\r\n        return arr.reduceRight(folder);\r\n    }\r\n    else {\r\n        throw (new Error(SR_inputSequenceEmpty));\r\n    }\r\n}\r\n\r\nexport function replicate(n, x) {\r\n    return initialize(n, (_arg1) => x);\r\n}\r\n\r\nexport function reverse(xs) {\r\n    return delay(() => ofArray(reverse_1(toArray(xs))));\r\n}\r\n\r\nexport function scan(folder, state, xs) {\r\n    return delay(() => {\r\n        let acc = state;\r\n        return concat([singleton(state), map((x) => {\r\n            acc = folder(acc, x);\r\n            return acc;\r\n        }, xs)]);\r\n    });\r\n}\r\n\r\nexport function scanBack(folder, xs, state) {\r\n    return delay(() => ofArray(scanBack_1(folder, toArray(xs), state)));\r\n}\r\n\r\nexport function skip(count, source) {\r\n    return mkSeq(() => {\r\n        const e = ofSeq(source);\r\n        try {\r\n            for (let _ = 1; _ <= count; _++) {\r\n                if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                    throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n                }\r\n            }\r\n            return Enumerator_enumerateThenFinally(() => {\r\n            }, e);\r\n        }\r\n        catch (matchValue) {\r\n            disposeSafe(e);\r\n            throw matchValue;\r\n        }\r\n    });\r\n}\r\n\r\nexport function skipWhile(predicate, xs) {\r\n    return delay(() => {\r\n        let skipped = true;\r\n        return filter((x) => {\r\n            if (skipped) {\r\n                skipped = predicate(x);\r\n            }\r\n            return !skipped;\r\n        }, xs);\r\n    });\r\n}\r\n\r\nexport function tail(xs) {\r\n    return skip(1, xs);\r\n}\r\n\r\nexport function take(count, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if (i < count) {\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                throw (new Error((SR_notEnoughElements + \"\\\\nParameter name: \") + \"source\"));\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function takeWhile(predicate, xs) {\r\n    return generate(() => ofSeq(xs), (e) => ((e[\"System.Collections.IEnumerator.MoveNext\"]() && predicate(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]())) ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function truncate(count, xs) {\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => (((i < count) && e[\"System.Collections.IEnumerator.MoveNext\"]()) ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0)), (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function zip(xs, ys) {\r\n    return map2((x, y) => [x, y], xs, ys);\r\n}\r\n\r\nexport function zip3(xs, ys, zs) {\r\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\r\n}\r\n\r\nexport function collect(mapping, xs) {\r\n    return delay(() => concat(map(mapping, xs)));\r\n}\r\n\r\nexport function where(predicate, xs) {\r\n    return filter(predicate, xs);\r\n}\r\n\r\nexport function pairwise(xs) {\r\n    return delay(() => ofArray(pairwise_1(toArray(xs))));\r\n}\r\n\r\nexport function splitInto(chunks, xs) {\r\n    return delay(() => ofArray(map_1(ofArray, splitInto_1(chunks, toArray(xs)))));\r\n}\r\n\r\nexport function windowed(windowSize, xs) {\r\n    return delay(() => ofArray(map_1(ofArray, windowed_1(windowSize, toArray(xs)))));\r\n}\r\n\r\nexport function transpose(xss) {\r\n    return delay(() => ofArray(map_1(ofArray, transpose_1(map_1(toArray, toArray(xss))))));\r\n}\r\n\r\nexport function sortWith(comparer, xs) {\r\n    return delay(() => {\r\n        const arr = toArray(xs);\r\n        arr.sort(comparer);\r\n        return ofArray(arr);\r\n    });\r\n}\r\n\r\nexport function sort(xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(x, y), xs);\r\n}\r\n\r\nexport function sortBy(projection, xs, comparer) {\r\n    return sortWith((x, y) => comparer.Compare(projection(x), projection(y)), xs);\r\n}\r\n\r\nexport function sortDescending(xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(x, y) * -1), xs);\r\n}\r\n\r\nexport function sortByDescending(projection, xs, comparer) {\r\n    return sortWith((x, y) => (comparer.Compare(projection(x), projection(y)) * -1), xs);\r\n}\r\n\r\nexport function sum(xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\r\n}\r\n\r\nexport function sumBy(f, xs, adder) {\r\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\r\n}\r\n\r\nexport function maxBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function max(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\r\n}\r\n\r\nexport function minBy(projection, xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function min(xs, comparer) {\r\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\r\n}\r\n\r\nexport function average(xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, x);\r\n    }, averager.GetZero(), xs);\r\n    if (count === 0) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return averager.DivideByInt(total, count);\r\n    }\r\n}\r\n\r\nexport function averageBy(f, xs, averager) {\r\n    let count = 0;\r\n    const total = fold((acc, x) => {\r\n        count = ((count + 1) | 0);\r\n        return averager.Add(acc, f(x));\r\n    }, averager.GetZero(), xs);\r\n    if (count === 0) {\r\n        throw (new Error((SR_inputSequenceEmpty + \"\\\\nParameter name: \") + \"source\"));\r\n    }\r\n    else {\r\n        return averager.DivideByInt(total, count);\r\n    }\r\n}\r\n\r\nexport function permute(f, xs) {\r\n    return delay(() => ofArray(permute_1(f, toArray(xs))));\r\n}\r\n\r\nexport function chunkBySize(chunkSize, xs) {\r\n    return delay(() => ofArray(map_1(ofArray, chunkBySize_1(chunkSize, toArray(xs)))));\r\n}\r\n\r\nexport function insertAt(index, y, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if (i === index) {\r\n            isDone = true;\r\n            return some(y);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function insertManyAt(index, ys, xs) {\r\n    let status = -1;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {\r\n        const e1 = tupledArg[0];\r\n        const e2 = tupledArg[1];\r\n        if (i === index) {\r\n            status = 0;\r\n        }\r\n        let inserted;\r\n        if (status === 0) {\r\n            if (e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                inserted = some(e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                status = 1;\r\n                inserted = (void 0);\r\n            }\r\n        }\r\n        else {\r\n            inserted = (void 0);\r\n        }\r\n        if (inserted == null) {\r\n            if (e1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                if (status < 1) {\r\n                    throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n                }\r\n                return void 0;\r\n            }\r\n        }\r\n        else {\r\n            return some(value_1(inserted));\r\n        }\r\n    }, (tupledArg_1) => {\r\n        disposeSafe(tupledArg_1[0]);\r\n        disposeSafe(tupledArg_1[1]);\r\n    });\r\n}\r\n\r\nexport function removeAt(index, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if ((i === index) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            isDone = true;\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function removeManyAt(index, count, xs) {\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if (i < index) {\r\n            if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n            }\r\n            else {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n        }\r\n        else {\r\n            if (i === index) {\r\n                for (let _ = 1; _ <= count; _++) {\r\n                    if (!e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"count\"));\r\n                    }\r\n                }\r\n            }\r\n            return e[\"System.Collections.IEnumerator.MoveNext\"]() ? some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]()) : (void 0);\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\nexport function updateAt(index, y, xs) {\r\n    let isDone = false;\r\n    if (index < 0) {\r\n        throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n    }\r\n    return generateIndexed(() => ofSeq(xs), (i, e) => {\r\n        if ((isDone ? true : (i < index)) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return some(e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n        }\r\n        else if ((i === index) && e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            isDone = true;\r\n            return some(y);\r\n        }\r\n        else {\r\n            if (!isDone) {\r\n                throw (new Error((SR_indexOutOfBounds + \"\\\\nParameter name: \") + \"index\"));\r\n            }\r\n            return void 0;\r\n        }\r\n    }, (e_1) => {\r\n        disposeSafe(e_1);\r\n    });\r\n}\r\n\r\n","import { compare } from \"./Util.js\";\r\nimport { unfold, delay } from \"./Seq.js\";\r\nimport { op_Addition, fromZero } from \"./BigInt.js\";\r\nimport { op_Addition as op_Addition_1, fromParts } from \"./Decimal.js\";\r\nimport { op_Addition as op_Addition_2, fromBits } from \"./Long.js\";\r\n\r\nexport function makeRangeStepFunction(step, stop, zero, add) {\r\n    const stepComparedWithZero = compare(step, zero) | 0;\r\n    if (stepComparedWithZero === 0) {\r\n        throw (new Error(\"The step of a range cannot be zero\"));\r\n    }\r\n    const stepGreaterThanZero = stepComparedWithZero > 0;\r\n    return (x) => {\r\n        const comparedWithLast = compare(x, stop) | 0;\r\n        return ((stepGreaterThanZero && (comparedWithLast <= 0)) ? true : ((!stepGreaterThanZero) && (comparedWithLast >= 0))) ? [x, add(x, step)] : (void 0);\r\n    };\r\n}\r\n\r\nexport function integralRangeStep(start, step, stop, zero, add) {\r\n    const stepFn = makeRangeStepFunction(step, stop, zero, add);\r\n    return delay(() => unfold(stepFn, start));\r\n}\r\n\r\nexport function rangeBigInt(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromZero(), op_Addition);\r\n}\r\n\r\nexport function rangeDecimal(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromParts(0, 0, 0, false, 0), op_Addition_1);\r\n}\r\n\r\nexport function rangeDouble(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, 0, (x, y) => (x + y));\r\n}\r\n\r\nexport function rangeInt64(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromBits(0, 0, false), op_Addition_2);\r\n}\r\n\r\nexport function rangeUInt64(start, step, stop) {\r\n    return integralRangeStep(start, step, stop, fromBits(0, 0, true), op_Addition_2);\r\n}\r\n\r\nexport function rangeChar(start, stop) {\r\n    const intStop = stop.charCodeAt(0) | 0;\r\n    return delay(() => unfold((c) => {\r\n        if (c <= intStop) {\r\n            return [String.fromCharCode(c), c + 1];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, start.charCodeAt(0)));\r\n}\r\n\r\n","import { Union } from \"../fable-library.3.7.5/Types.js\";\nimport { class_type, union_type, int32_type, array_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { fill } from \"../fable-library.3.7.5/Array.js\";\nimport { comparePrimitives, max } from \"../fable-library.3.7.5/Util.js\";\nimport { some } from \"../fable-library.3.7.5/Option.js\";\nimport { singleton, collect, take, skip, append, delay } from \"../fable-library.3.7.5/Seq.js\";\nimport { rangeDouble } from \"../fable-library.3.7.5/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(comparePrimitives, size, 10)), 0, max(comparePrimitives, 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.7.5/Types.js\";\nimport { record_type, class_type, string_type, tuple_type, list_type, lambda_type, unit_type } from \"../fable-library.3.7.5/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.7.5/Util.js\";\nimport { ofArray } from \"../fable-library.3.7.5/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.7.5/Option.js\";\nimport { printf, toText } from \"../fable-library.3.7.5/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, [curry(2, program.update)]);\n    const view = partialApply(2, mapView, [curry(2, program.view)]);\n    const setState = partialApply(2, mapSetState, [curry(2, 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.7.5/Types.js\";\nimport { obj_type, record_type, bool_type, lambda_type, class_type, unit_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { Component } from \"react\";\nimport * as react from \"react\";\nimport { equalArrays, equals } from \"../fable-library.3.7.5/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    const props = new LazyProps$1(state, () => view(state), equal);\n    return react.createElement(Components_LazyView$1, props);\n}\n\nexport function Common_lazyView2With(equal, view, state, dispatch) {\n    const props = new LazyProps$1(state, () => view(state, dispatch), equal);\n    return react.createElement(Components_LazyView$1, props);\n}\n\nexport function Common_lazyView3With(equal, view, state1, state2, dispatch) {\n    const props = new LazyProps$1([state1, state2], () => view(state1, state2, dispatch), equal);\n    return react.createElement(Components_LazyView$1, props);\n}\n\nexport function Common_lazyView(view) {\n    return (state) => Common_lazyViewWith(equals, view, state);\n}\n\nexport function Common_lazyView2(view) {\n    return (state) => ((dispatch) => Common_lazyView2With(equals, view, state, dispatch));\n}\n\nexport function Common_lazyView3(view) {\n    return (state1) => ((state2) => ((dispatch) => Common_lazyView3With(equalArrays, view, state1, state2, dispatch)));\n}\n\n","import { Union } from \"../fable-library.3.7.5/Types.js\";\nimport { union_type, class_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { ofArray, singleton } from \"../fable-library.3.7.5/List.js\";\nimport { Cmd_batch, Cmd_map } from \"../Fable.Elmish.3.1.0/cmd.fs.js\";\nimport { ProgramModule_map } from \"../Fable.Elmish.3.1.0/program.fs.js\";\n\nexport class Navigable$1 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Change\", \"UserMsg\"];\n    }\n}\n\nexport function Navigable$1$reflection(gen0) {\n    return union_type(\"Elmish.Navigation.Navigable`1\", [gen0], Navigable$1, () => [[[\"Item\", class_type(\"Browser.Types.Location\")]], [[\"Item\", gen0]]]);\n}\n\nexport function Navigation_modifyUrl(newUrl) {\n    return singleton((_arg1) => {\n        history.replaceState(void 0, \"\", newUrl);\n    });\n}\n\nexport function Navigation_newUrl(newUrl) {\n    return singleton((_arg1) => {\n        history.pushState(void 0, \"\", newUrl);\n        const ev = new CustomEvent(\"NavigatedEvent\");\n        window.dispatchEvent(ev);\n    });\n}\n\nexport function Navigation_jump(n) {\n    return singleton((_arg1) => {\n        history.go(n);\n    });\n}\n\nlet ProgramModule_Internal_onChangeRef = (_arg1) => {\n    throw (new Error(\"`onChangeRef` has not been initialized.\\nPlease make sure you used Elmish.Navigation.Program.Internal.subscribe\"));\n};\n\nexport function ProgramModule_Internal_subscribe(dispatch) {\n    let clo1, clo1_1, clo1_2;\n    let lastLocation = void 0;\n    ProgramModule_Internal_onChangeRef = ((_arg1) => {\n        let value;\n        let pattern_matching_result;\n        if (lastLocation != null) {\n            if (lastLocation === window.location.href) {\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                value = (void 0);\n                break;\n            }\n            case 1: {\n                lastLocation = window.location.href;\n                value = dispatch(new Navigable$1(0, window.location));\n                break;\n            }\n        }\n        return void 0;\n    });\n    window.addEventListener(\"popstate\", (clo1 = ProgramModule_Internal_onChangeRef, (arg10) => {\n        clo1(arg10);\n    }));\n    window.addEventListener(\"hashchange\", (clo1_1 = ProgramModule_Internal_onChangeRef, (arg10_1) => {\n        clo1_1(arg10_1);\n    }));\n    window.addEventListener(\"NavigatedEvent\", (clo1_2 = ProgramModule_Internal_onChangeRef, (arg10_2) => {\n        clo1_2(arg10_2);\n    }));\n}\n\nexport function ProgramModule_Internal_unsubscribe() {\n    let clo1, clo1_1, clo1_2;\n    window.removeEventListener(\"popstate\", (clo1 = ProgramModule_Internal_onChangeRef, (arg10) => {\n        clo1(arg10);\n    }));\n    window.removeEventListener(\"hashchange\", (clo1_1 = ProgramModule_Internal_onChangeRef, (arg10_1) => {\n        clo1_1(arg10_1);\n    }));\n    window.removeEventListener(\"NavigatedEvent\", (clo1_2 = ProgramModule_Internal_onChangeRef, (arg10_2) => {\n        clo1_2(arg10_2);\n    }));\n}\n\nexport function ProgramModule_Internal_toNavigableWith(parser, urlUpdate, program, onLocationChange) {\n    const map = (tupledArg) => [tupledArg[0], Cmd_map((arg0) => (new Navigable$1(1, arg0)), tupledArg[1])];\n    return ProgramModule_map((userInit, unitVar1) => map(userInit(parser(window.location))), (userUpdate, msg, model_1) => map((msg.tag === 1) ? userUpdate(msg.fields[0])(model_1) : urlUpdate(parser(msg.fields[0]), model_1)), (userView, model_4, dispatch_1) => userView(model_4)((arg_1) => dispatch_1(new Navigable$1(1, arg_1))), (userSetState, model_3, dispatch) => userSetState(model_3)((arg) => dispatch(new Navigable$1(1, arg))), (userSubscribe, model_2) => Cmd_batch(ofArray([singleton(onLocationChange), Cmd_map((arg0_1) => (new Navigable$1(1, arg0_1)), userSubscribe(model_2))])), program);\n}\n\nexport function ProgramModule_toNavigable(parser, urlUpdate, program) {\n    return ProgramModule_Internal_toNavigableWith(parser, urlUpdate, program, (dispatch) => {\n        ProgramModule_Internal_subscribe(dispatch);\n    });\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 { map as map_2, fill } from \"./Array.js\";\r\nimport { structuralHash, compare, toIterator, equals, disposeSafe, getEnumerator, isArrayLike } from \"./Util.js\";\r\nimport { Record } from \"./Types.js\";\r\nimport { tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, map as map_1, unfold } from \"./Seq.js\";\r\nimport { format, join } from \"./String.js\";\r\nimport { LanguagePrimitives_FastGenericComparer } from \"./FSharp.Core.js\";\r\n\r\nexport class MapTreeLeaf$2 {\r\n    constructor(k, v) {\r\n        this.k = k;\r\n        this.v = v;\r\n    }\r\n}\r\n\r\nexport function MapTreeLeaf$2$reflection(gen0, gen1) {\r\n    return class_type(\"Map.MapTreeLeaf`2\", [gen0, gen1], MapTreeLeaf$2);\r\n}\r\n\r\nexport function MapTreeLeaf$2_$ctor_5BDDA1(k, v) {\r\n    return new MapTreeLeaf$2(k, v);\r\n}\r\n\r\nexport function MapTreeLeaf$2__get_Key(_) {\r\n    return _.k;\r\n}\r\n\r\nexport function MapTreeLeaf$2__get_Value(_) {\r\n    return _.v;\r\n}\r\n\r\nexport class MapTreeNode$2 extends MapTreeLeaf$2 {\r\n    constructor(k, v, left, right, h) {\r\n        super(k, v);\r\n        this.left = left;\r\n        this.right = right;\r\n        this.h = (h | 0);\r\n    }\r\n}\r\n\r\nexport function MapTreeNode$2$reflection(gen0, gen1) {\r\n    return class_type(\"Map.MapTreeNode`2\", [gen0, gen1], MapTreeNode$2, MapTreeLeaf$2$reflection(gen0, gen1));\r\n}\r\n\r\nexport function MapTreeNode$2_$ctor_499A11FD(k, v, left, right, h) {\r\n    return new MapTreeNode$2(k, v, left, right, h);\r\n}\r\n\r\nexport function MapTreeNode$2__get_Left(_) {\r\n    return _.left;\r\n}\r\n\r\nexport function MapTreeNode$2__get_Right(_) {\r\n    return _.right;\r\n}\r\n\r\nexport function MapTreeNode$2__get_Height(_) {\r\n    return _.h;\r\n}\r\n\r\nexport function MapTreeModule_empty() {\r\n    return void 0;\r\n}\r\n\r\nexport function MapTreeModule_sizeAux(acc_mut, m_mut) {\r\n    MapTreeModule_sizeAux:\r\n    while (true) {\r\n        const acc = acc_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                acc_mut = MapTreeModule_sizeAux(acc + 1, MapTreeNode$2__get_Left(m2));\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_sizeAux;\r\n            }\r\n            else {\r\n                return (acc + 1) | 0;\r\n            }\r\n        }\r\n        else {\r\n            return acc | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_size(x) {\r\n    return MapTreeModule_sizeAux(0, x);\r\n}\r\n\r\nexport function MapTreeModule_mk(l, k, v, r) {\r\n    let hl;\r\n    const m = l;\r\n    if (m != null) {\r\n        const m2 = m;\r\n        hl = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\r\n    }\r\n    else {\r\n        hl = 0;\r\n    }\r\n    let hr;\r\n    const m_1 = r;\r\n    if (m_1 != null) {\r\n        const m2_1 = m_1;\r\n        hr = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\r\n    }\r\n    else {\r\n        hr = 0;\r\n    }\r\n    const m_2 = ((hl < hr) ? hr : hl) | 0;\r\n    if (m_2 === 0) {\r\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n    }\r\n    else {\r\n        return MapTreeNode$2_$ctor_499A11FD(k, v, l, r, m_2 + 1);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_rebalance(t1, k, v, t2) {\r\n    let m_2, m2_2, m_3, m2_3;\r\n    let t1h;\r\n    const m = t1;\r\n    if (m != null) {\r\n        const m2 = m;\r\n        t1h = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\r\n    }\r\n    else {\r\n        t1h = 0;\r\n    }\r\n    let t2h;\r\n    const m_1 = t2;\r\n    if (m_1 != null) {\r\n        const m2_1 = m_1;\r\n        t2h = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\r\n    }\r\n    else {\r\n        t2h = 0;\r\n    }\r\n    if (t2h > (t1h + 2)) {\r\n        const matchValue = value_1(t2);\r\n        if (matchValue instanceof MapTreeNode$2) {\r\n            if (((m_2 = MapTreeNode$2__get_Left(matchValue), (m_2 != null) ? ((m2_2 = m_2, (m2_2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_2) : 1)) : 0)) > (t1h + 1)) {\r\n                const matchValue_1 = value_1(MapTreeNode$2__get_Left(matchValue));\r\n                if (matchValue_1 instanceof MapTreeNode$2) {\r\n                    return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue_1)), MapTreeLeaf$2__get_Key(matchValue_1), MapTreeLeaf$2__get_Value(matchValue_1), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_1), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue)));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Map.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue)), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Map.rebalance\"));\r\n        }\r\n    }\r\n    else if (t1h > (t2h + 2)) {\r\n        const matchValue_2 = value_1(t1);\r\n        if (matchValue_2 instanceof MapTreeNode$2) {\r\n            if (((m_3 = MapTreeNode$2__get_Right(matchValue_2), (m_3 != null) ? ((m2_3 = m_3, (m2_3 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_3) : 1)) : 0)) > (t2h + 1)) {\r\n                const matchValue_3 = value_1(MapTreeNode$2__get_Right(matchValue_2));\r\n                if (matchValue_3 instanceof MapTreeNode$2) {\r\n                    return MapTreeModule_mk(MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeNode$2__get_Left(matchValue_3)), MapTreeLeaf$2__get_Key(matchValue_3), MapTreeLeaf$2__get_Value(matchValue_3), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_3), k, v, t2));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Map.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_2), k, v, t2));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Map.rebalance\"));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_mk(t1, k, v, t2);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_add(comparer, k, v, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else if (c < 0) {\r\n            return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeModule_empty(), m, 2);\r\n        }\r\n        else if (c === 0) {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n        }\r\n        else {\r\n            return MapTreeNode$2_$ctor_499A11FD(k, v, m, MapTreeModule_empty(), 2);\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_tryFind(comparer_mut, k_mut, m_mut) {\r\n    MapTreeModule_tryFind:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c === 0) {\r\n                return some(MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n            else if (m2 instanceof MapTreeNode$2) {\r\n                comparer_mut = comparer;\r\n                k_mut = k;\r\n                m_mut = ((c < 0) ? MapTreeNode$2__get_Left(m2) : MapTreeNode$2__get_Right(m2));\r\n                continue MapTreeModule_tryFind;\r\n            }\r\n            else {\r\n                return void 0;\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_find(comparer, k, m) {\r\n    const matchValue = MapTreeModule_tryFind(comparer, k, m);\r\n    if (matchValue == null) {\r\n        throw (new Error());\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partition1(comparer, f, k, v, acc1, acc2) {\r\n    if (f(k, v)) {\r\n        return [MapTreeModule_add(comparer, k, v, acc1), acc2];\r\n    }\r\n    else {\r\n        return [acc1, MapTreeModule_add(comparer, k, v, acc2)];\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partitionAux(comparer_mut, f_mut, m_mut, acc_0_mut, acc_1_mut) {\r\n    MapTreeModule_partitionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\r\n        const acc = [acc_0, acc_1];\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const acc_2 = MapTreeModule_partitionAux(comparer, f, MapTreeNode$2__get_Right(m2), acc[0], acc[1]);\r\n                const acc_3 = MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_2[0], acc_2[1]);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Left(m2);\r\n                acc_0_mut = acc_3[0];\r\n                acc_1_mut = acc_3[1];\r\n                continue MapTreeModule_partitionAux;\r\n            }\r\n            else {\r\n                return MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc[0], acc[1]);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_partition(comparer, f, m) {\r\n    return MapTreeModule_partitionAux(comparer, f, m, MapTreeModule_empty(), MapTreeModule_empty());\r\n}\r\n\r\nexport function MapTreeModule_filter1(comparer, f, k, v, acc) {\r\n    if (f(k, v)) {\r\n        return MapTreeModule_add(comparer, k, v, acc);\r\n    }\r\n    else {\r\n        return acc;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_filterAux(comparer_mut, f_mut, m_mut, acc_mut) {\r\n    MapTreeModule_filterAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc = acc_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const acc_1 = MapTreeModule_filterAux(comparer, f, MapTreeNode$2__get_Left(m2), acc);\r\n                const acc_2 = MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_1);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                acc_mut = acc_2;\r\n                continue MapTreeModule_filterAux;\r\n            }\r\n            else {\r\n                return MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_filter(comparer, f, m) {\r\n    return MapTreeModule_filterAux(comparer, f, m, MapTreeModule_empty());\r\n}\r\n\r\nexport function MapTreeModule_spliceOutSuccessor(m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (MapTreeNode$2__get_Left(m2) == null) {\r\n                return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2)];\r\n            }\r\n            else {\r\n                const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Left(m2));\r\n                return [patternInput[0], patternInput[1], MapTreeModule_mk(patternInput[2], MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2))];\r\n            }\r\n        }\r\n        else {\r\n            return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_empty()];\r\n        }\r\n    }\r\n    else {\r\n        throw (new Error(\"internal error: Map.spliceOutSuccessor\"));\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_remove(comparer, k, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                if (MapTreeNode$2__get_Left(m2) == null) {\r\n                    return MapTreeNode$2__get_Right(m2);\r\n                }\r\n                else if (MapTreeNode$2__get_Right(m2) == null) {\r\n                    return MapTreeNode$2__get_Left(m2);\r\n                }\r\n                else {\r\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\r\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else if (c === 0) {\r\n            return MapTreeModule_empty();\r\n        }\r\n        else {\r\n            return m;\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_change(comparer, k, u, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c < 0) {\r\n                return MapTreeModule_rebalance(MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\r\n            }\r\n            else if (c === 0) {\r\n                const matchValue_1 = u(some(MapTreeLeaf$2__get_Value(m2)));\r\n                if (matchValue_1 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_1), MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\r\n                }\r\n                else if (MapTreeNode$2__get_Left(m2) == null) {\r\n                    return MapTreeNode$2__get_Right(m2);\r\n                }\r\n                else if (MapTreeNode$2__get_Right(m2) == null) {\r\n                    return MapTreeNode$2__get_Left(m2);\r\n                }\r\n                else {\r\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\r\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\r\n                }\r\n            }\r\n            else {\r\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Right(m2)));\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (c_1 < 0) {\r\n                const matchValue_2 = u(void 0);\r\n                if (matchValue_2 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_2), MapTreeModule_empty(), m, 2);\r\n                }\r\n                else {\r\n                    return m;\r\n                }\r\n            }\r\n            else if (c_1 === 0) {\r\n                const matchValue_3 = u(some(MapTreeLeaf$2__get_Value(m2)));\r\n                if (matchValue_3 != null) {\r\n                    return MapTreeLeaf$2_$ctor_5BDDA1(k, value_1(matchValue_3));\r\n                }\r\n                else {\r\n                    return MapTreeModule_empty();\r\n                }\r\n            }\r\n            else {\r\n                const matchValue_4 = u(void 0);\r\n                if (matchValue_4 != null) {\r\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_1(matchValue_4), m, MapTreeModule_empty(), 2);\r\n                }\r\n                else {\r\n                    return m;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        const matchValue = u(void 0);\r\n        if (matchValue != null) {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, value_1(matchValue));\r\n        }\r\n        else {\r\n            return m;\r\n        }\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {\r\n    MapTreeModule_mem:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (c < 0) {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    m_mut = MapTreeNode$2__get_Left(m2);\r\n                    continue MapTreeModule_mem;\r\n                }\r\n                else if (c === 0) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_mem;\r\n                }\r\n            }\r\n            else {\r\n                return c === 0;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_iterOpt(f_mut, m_mut) {\r\n    MapTreeModule_iterOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                MapTreeModule_iterOpt(f, MapTreeNode$2__get_Left(m2));\r\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_iterOpt;\r\n            }\r\n            else {\r\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_iter(f, m) {\r\n    MapTreeModule_iterOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_tryPickOpt(f_mut, m_mut) {\r\n    MapTreeModule_tryPickOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const matchValue = MapTreeModule_tryPickOpt(f, MapTreeNode$2__get_Left(m2));\r\n                if (matchValue == null) {\r\n                    const matchValue_1 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                    if (matchValue_1 == null) {\r\n                        f_mut = f;\r\n                        m_mut = MapTreeNode$2__get_Right(m2);\r\n                        continue MapTreeModule_tryPickOpt;\r\n                    }\r\n                    else {\r\n                        return matchValue_1;\r\n                    }\r\n                }\r\n                else {\r\n                    return matchValue;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_tryPick(f, m) {\r\n    return MapTreeModule_tryPickOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_existsOpt(f_mut, m_mut) {\r\n    MapTreeModule_existsOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (MapTreeModule_existsOpt(f, MapTreeNode$2__get_Left(m2)) ? true : f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_existsOpt;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_exists(f, m) {\r\n    return MapTreeModule_existsOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_forallOpt(f_mut, m_mut) {\r\n    MapTreeModule_forallOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                if (MapTreeModule_forallOpt(f, MapTreeNode$2__get_Left(m2)) && f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\r\n                    f_mut = f;\r\n                    m_mut = MapTreeNode$2__get_Right(m2);\r\n                    continue MapTreeModule_forallOpt;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_forall(f, m) {\r\n    return MapTreeModule_forallOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_map(f, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const l2 = MapTreeModule_map(f, MapTreeNode$2__get_Left(m2));\r\n            const v2 = f(MapTreeLeaf$2__get_Value(m2));\r\n            const r2 = MapTreeModule_map(f, MapTreeNode$2__get_Right(m2));\r\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\r\n        }\r\n        else {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Value(m2)));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mapiOpt(f, m) {\r\n    if (m != null) {\r\n        const m2 = m;\r\n        if (m2 instanceof MapTreeNode$2) {\r\n            const l2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Left(m2));\r\n            const v2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            const r2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Right(m2));\r\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\r\n        }\r\n        else {\r\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)));\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_empty();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mapi(f, m) {\r\n    return MapTreeModule_mapiOpt(f, m);\r\n}\r\n\r\nexport function MapTreeModule_foldBackOpt(f_mut, m_mut, x_mut) {\r\n    MapTreeModule_foldBackOpt:\r\n    while (true) {\r\n        const f = f_mut, m = m_mut, x = x_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                const x_1 = MapTreeModule_foldBackOpt(f, MapTreeNode$2__get_Right(m2), x);\r\n                const x_2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\r\n                f_mut = f;\r\n                m_mut = MapTreeNode$2__get_Left(m2);\r\n                x_mut = x_2;\r\n                continue MapTreeModule_foldBackOpt;\r\n            }\r\n            else {\r\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x);\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_foldBack(f, m, x) {\r\n    return MapTreeModule_foldBackOpt(f, m, x);\r\n}\r\n\r\nexport function MapTreeModule_foldOpt(f_mut, x_mut, m_mut) {\r\n    MapTreeModule_foldOpt:\r\n    while (true) {\r\n        const f = f_mut, x = x_mut, m = m_mut;\r\n        if (m != null) {\r\n            const m2 = m;\r\n            if (m2 instanceof MapTreeNode$2) {\r\n                f_mut = f;\r\n                x_mut = f(MapTreeModule_foldOpt(f, x, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n                m_mut = MapTreeNode$2__get_Right(m2);\r\n                continue MapTreeModule_foldOpt;\r\n            }\r\n            else {\r\n                return f(x, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_fold(f, x, m) {\r\n    return MapTreeModule_foldOpt(f, x, m);\r\n}\r\n\r\nexport function MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x) {\r\n    const foldFromTo = (f_1_mut, m_1_mut, x_1_mut) => {\r\n        foldFromTo:\r\n        while (true) {\r\n            const f_1 = f_1_mut, m_1 = m_1_mut, x_1 = x_1_mut;\r\n            if (m_1 != null) {\r\n                const m2 = m_1;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    const cLoKey = comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) | 0;\r\n                    const cKeyHi = comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) | 0;\r\n                    const x_2 = (cLoKey < 0) ? foldFromTo(f_1, MapTreeNode$2__get_Left(m2), x_1) : x_1;\r\n                    const x_3 = ((cLoKey <= 0) && (cKeyHi <= 0)) ? f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_2) : x_2;\r\n                    if (cKeyHi < 0) {\r\n                        f_1_mut = f_1;\r\n                        m_1_mut = MapTreeNode$2__get_Right(m2);\r\n                        x_1_mut = x_3;\r\n                        continue foldFromTo;\r\n                    }\r\n                    else {\r\n                        return x_3;\r\n                    }\r\n                }\r\n                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) <= 0) && (comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) <= 0)) {\r\n                    return f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\r\n                }\r\n                else {\r\n                    return x_1;\r\n                }\r\n            }\r\n            else {\r\n                return x_1;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (comparer.Compare(lo, hi) === 1) {\r\n        return x;\r\n    }\r\n    else {\r\n        return foldFromTo(f, m, x);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_foldSection(comparer, lo, hi, f, m, x) {\r\n    return MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x);\r\n}\r\n\r\nexport function MapTreeModule_toList(m) {\r\n    const loop = (m_1_mut, acc_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const m_1 = m_1_mut, acc = acc_mut;\r\n            if (m_1 != null) {\r\n                const m2 = m_1;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    m_1_mut = MapTreeNode$2__get_Left(m2);\r\n                    acc_mut = cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], loop(MapTreeNode$2__get_Right(m2), acc));\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return cons([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], acc);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(m, empty_1());\r\n}\r\n\r\nexport function MapTreeModule_copyToArray(m, arr, i) {\r\n    let j = i;\r\n    MapTreeModule_iter((x, y) => {\r\n        arr[j] = [x, y];\r\n        j = ((j + 1) | 0);\r\n    }, m);\r\n}\r\n\r\nexport function MapTreeModule_toArray(m) {\r\n    const n = MapTreeModule_size(m) | 0;\r\n    const res = fill(new Array(n), 0, n, [null, null]);\r\n    MapTreeModule_copyToArray(m, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function MapTreeModule_ofList(comparer, l) {\r\n    return fold_1((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);\r\n}\r\n\r\nexport function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\r\n    MapTreeModule_mkFromEnumerator:\r\n    while (true) {\r\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const patternInput = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            comparer_mut = comparer;\r\n            acc_mut = MapTreeModule_add(comparer, patternInput[0], patternInput[1], acc);\r\n            e_mut = e;\r\n            continue MapTreeModule_mkFromEnumerator;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_ofArray(comparer, arr) {\r\n    let res = MapTreeModule_empty();\r\n    for (let idx = 0; idx <= (arr.length - 1); idx++) {\r\n        const forLoopVar = arr[idx];\r\n        res = MapTreeModule_add(comparer, forLoopVar[0], forLoopVar[1], res);\r\n    }\r\n    return res;\r\n}\r\n\r\nexport function MapTreeModule_ofSeq(comparer, c) {\r\n    if (isArrayLike(c)) {\r\n        return MapTreeModule_ofArray(comparer, c);\r\n    }\r\n    else if (c instanceof FSharpList) {\r\n        return MapTreeModule_ofList(comparer, c);\r\n    }\r\n    else {\r\n        const ie = getEnumerator(c);\r\n        try {\r\n            return MapTreeModule_mkFromEnumerator(comparer, MapTreeModule_empty(), ie);\r\n        }\r\n        finally {\r\n            disposeSafe(ie);\r\n        }\r\n    }\r\n}\r\n\r\nexport class MapTreeModule_MapIterator$2 extends Record {\r\n    constructor(stack, started) {\r\n        super();\r\n        this.stack = stack;\r\n        this.started = started;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_MapIterator$2$reflection(gen0, gen1) {\r\n    return record_type(\"Map.MapTreeModule.MapIterator`2\", [gen0, gen1], MapTreeModule_MapIterator$2, () => [[\"stack\", list_type(option_type(MapTreeLeaf$2$reflection(gen0, gen1)))], [\"started\", bool_type]]);\r\n}\r\n\r\nexport function MapTreeModule_collapseLHS(stack_mut) {\r\n    MapTreeModule_collapseLHS:\r\n    while (true) {\r\n        const stack = stack_mut;\r\n        if (!isEmpty_1(stack)) {\r\n            const rest = tail(stack);\r\n            const m = head(stack);\r\n            if (m != null) {\r\n                const m2 = m;\r\n                if (m2 instanceof MapTreeNode$2) {\r\n                    stack_mut = ofArrayWithTail([MapTreeNode$2__get_Left(m2), MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)), MapTreeNode$2__get_Right(m2)], rest);\r\n                    continue MapTreeModule_collapseLHS;\r\n                }\r\n                else {\r\n                    return stack;\r\n                }\r\n            }\r\n            else {\r\n                stack_mut = rest;\r\n                continue MapTreeModule_collapseLHS;\r\n            }\r\n        }\r\n        else {\r\n            return empty_1();\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mkIterator(m) {\r\n    return new MapTreeModule_MapIterator$2(MapTreeModule_collapseLHS(singleton(m)), false);\r\n}\r\n\r\nexport function MapTreeModule_notStarted() {\r\n    throw (new Error(\"enumeration not started\"));\r\n}\r\n\r\nexport function MapTreeModule_alreadyFinished() {\r\n    throw (new Error(\"enumeration already finished\"));\r\n}\r\n\r\nexport function MapTreeModule_current(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const m = head(matchValue);\r\n                if (m instanceof MapTreeNode$2) {\r\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\r\n                }\r\n                else {\r\n                    return [MapTreeLeaf$2__get_Key(m), MapTreeLeaf$2__get_Value(m)];\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\r\n            }\r\n        }\r\n        else {\r\n            return MapTreeModule_alreadyFinished();\r\n        }\r\n    }\r\n    else {\r\n        return MapTreeModule_notStarted();\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_moveNext(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const m = head(matchValue);\r\n                if (m instanceof MapTreeNode$2) {\r\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\r\n                }\r\n                else {\r\n                    i.stack = MapTreeModule_collapseLHS(tail(matchValue));\r\n                    return !isEmpty_1(i.stack);\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else {\r\n        i.started = true;\r\n        return !isEmpty_1(i.stack);\r\n    }\r\n}\r\n\r\nexport function MapTreeModule_mkIEnumerator(m) {\r\n    let i = MapTreeModule_mkIterator(m);\r\n    return {\r\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n            return MapTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.get_Current\"]() {\r\n            return MapTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n            return MapTreeModule_moveNext(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.Reset\"]() {\r\n            i = MapTreeModule_mkIterator(m);\r\n        },\r\n        Dispose() {\r\n        },\r\n    };\r\n}\r\n\r\nexport function MapTreeModule_toSeq(s) {\r\n    return unfold((en_1) => {\r\n        if (en_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            return [en_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), en_1];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, MapTreeModule_mkIEnumerator(s));\r\n}\r\n\r\nexport class FSharpMap {\r\n    constructor(comparer, tree) {\r\n        this.comparer = comparer;\r\n        this.tree = tree;\r\n    }\r\n    GetHashCode() {\r\n        const this$ = this;\r\n        return FSharpMap__ComputeHashCode(this$) | 0;\r\n    }\r\n    Equals(that) {\r\n        const this$ = this;\r\n        if (that instanceof FSharpMap) {\r\n            const e1 = getEnumerator(this$);\r\n            try {\r\n                const e2 = getEnumerator(that);\r\n                try {\r\n                    const loop = () => {\r\n                        const m1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\r\n                        if (m1 === e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                            if (!m1) {\r\n                                return true;\r\n                            }\r\n                            else {\r\n                                const e1c = e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                                const e2c = e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                                if (equals(e1c[0], e2c[0]) && equals(e1c[1], e2c[1])) {\r\n                                    return loop();\r\n                                }\r\n                                else {\r\n                                    return false;\r\n                                }\r\n                            }\r\n                        }\r\n                        else {\r\n                            return false;\r\n                        }\r\n                    };\r\n                    return loop();\r\n                }\r\n                finally {\r\n                    disposeSafe(e2);\r\n                }\r\n            }\r\n            finally {\r\n                disposeSafe(e1);\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    toString() {\r\n        const this$ = this;\r\n        return (\"map [\" + join(\"; \", map_1((kv) => format(\"({0}, {1})\", kv[0], kv[1]), this$))) + \"]\";\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"FSharpMap\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const __ = this;\r\n        return MapTreeModule_mkIEnumerator(__.tree);\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const __ = this;\r\n        return MapTreeModule_mkIEnumerator(__.tree);\r\n    }\r\n    CompareTo(obj) {\r\n        const m = this;\r\n        if (obj instanceof FSharpMap) {\r\n            return compareWith((kvp1, kvp2) => {\r\n                const c = m.comparer.Compare(kvp1[0], kvp2[0]) | 0;\r\n                return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;\r\n            }, m, obj) | 0;\r\n        }\r\n        else {\r\n            throw (new Error(\"not comparable\\\\nParameter name: obj\"));\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\r\n        const m = this;\r\n        return FSharpMap__ContainsKey(m, x[0]) && equals(FSharpMap__get_Item(m, x[0]), x[1]);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\r\n        const m = this;\r\n        MapTreeModule_copyToArray(m.tree, arr, i);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return true;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    get size() {\r\n        const m = this;\r\n        return FSharpMap__get_Count(m) | 0;\r\n    }\r\n    clear() {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n    }\r\n    delete(_arg1) {\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n        return false;\r\n    }\r\n    entries() {\r\n        const m = this;\r\n        return map_1((p) => [p[0], p[1]], m);\r\n    }\r\n    get(k) {\r\n        const m = this;\r\n        return FSharpMap__get_Item(m, k);\r\n    }\r\n    has(k) {\r\n        const m = this;\r\n        return FSharpMap__ContainsKey(m, k);\r\n    }\r\n    keys() {\r\n        const m = this;\r\n        return map_1((p) => p[0], m);\r\n    }\r\n    set(k, v) {\r\n        const m = this;\r\n        throw (new Error(\"Map cannot be mutated\"));\r\n        return m;\r\n    }\r\n    values() {\r\n        const m = this;\r\n        return map_1((p) => p[1], m);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const m = this;\r\n        iterate_1((p) => {\r\n            f(p[1], p[0], m);\r\n        }, m);\r\n    }\r\n}\r\n\r\nexport function FSharpMap$reflection(gen0, gen1) {\r\n    return class_type(\"Map.FSharpMap\", [gen0, gen1], FSharpMap);\r\n}\r\n\r\nexport function FSharpMap_$ctor(comparer, tree) {\r\n    return new FSharpMap(comparer, tree);\r\n}\r\n\r\n(() => {\r\n    FSharpMap.empty = FSharpMap_$ctor(LanguagePrimitives_FastGenericComparer(), MapTreeModule_empty());\r\n})();\r\n\r\nexport function FSharpMap_get_Empty() {\r\n    return FSharpMap.empty;\r\n}\r\n\r\nexport function FSharpMap_Create(ie) {\r\n    const comparer = LanguagePrimitives_FastGenericComparer();\r\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, ie));\r\n}\r\n\r\nexport function FSharpMap__get_Comparer(m) {\r\n    return m.comparer;\r\n}\r\n\r\nexport function FSharpMap__get_Tree(m) {\r\n    return m.tree;\r\n}\r\n\r\nexport function FSharpMap__Add(m, key, value) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_add(m.comparer, key, value, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Change(m, key, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_change(m.comparer, key, f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__get_IsEmpty(m) {\r\n    return m.tree == null;\r\n}\r\n\r\nexport function FSharpMap__get_Item(m, key) {\r\n    return MapTreeModule_find(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__TryPick(m, f) {\r\n    return MapTreeModule_tryPick(f, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Exists(m, predicate) {\r\n    return MapTreeModule_exists(predicate, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Filter(m, predicate) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_filter(m.comparer, predicate, m.tree));\r\n}\r\n\r\nexport function FSharpMap__ForAll(m, predicate) {\r\n    return MapTreeModule_forall(predicate, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Fold(m, f, acc) {\r\n    return MapTreeModule_foldBack(f, m.tree, acc);\r\n}\r\n\r\nexport function FSharpMap__FoldSection(m, lo, hi, f, acc) {\r\n    return MapTreeModule_foldSection(m.comparer, lo, hi, f, m.tree, acc);\r\n}\r\n\r\nexport function FSharpMap__Iterate(m, f) {\r\n    MapTreeModule_iter(f, m.tree);\r\n}\r\n\r\nexport function FSharpMap__MapRange(m, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_map(f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Map(m, f) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_mapi(f, m.tree));\r\n}\r\n\r\nexport function FSharpMap__Partition(m, predicate) {\r\n    const patternInput = MapTreeModule_partition(m.comparer, predicate, m.tree);\r\n    return [FSharpMap_$ctor(m.comparer, patternInput[0]), FSharpMap_$ctor(m.comparer, patternInput[1])];\r\n}\r\n\r\nexport function FSharpMap__get_Count(m) {\r\n    return MapTreeModule_size(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ContainsKey(m, key) {\r\n    return MapTreeModule_mem(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__Remove(m, key) {\r\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_remove(m.comparer, key, m.tree));\r\n}\r\n\r\nexport function FSharpMap__TryGetValue(__, key, value) {\r\n    const matchValue = MapTreeModule_tryFind(__.comparer, key, __.tree);\r\n    if (matchValue == null) {\r\n        return false;\r\n    }\r\n    else {\r\n        const v = value_1(matchValue);\r\n        value.contents = v;\r\n        return true;\r\n    }\r\n}\r\n\r\nexport function FSharpMap__get_Keys(__) {\r\n    return map_2((kvp) => kvp[0], MapTreeModule_toArray(__.tree));\r\n}\r\n\r\nexport function FSharpMap__get_Values(__) {\r\n    return map_2((kvp) => kvp[1], MapTreeModule_toArray(__.tree));\r\n}\r\n\r\nexport function FSharpMap__TryFind(m, key) {\r\n    return MapTreeModule_tryFind(m.comparer, key, m.tree);\r\n}\r\n\r\nexport function FSharpMap__ToList(m) {\r\n    return MapTreeModule_toList(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ToArray(m) {\r\n    return MapTreeModule_toArray(m.tree);\r\n}\r\n\r\nexport function FSharpMap__ComputeHashCode(this$) {\r\n    const combineHash = (x, y) => (((x << 1) + y) + 631);\r\n    let res = 0;\r\n    const enumerator = getEnumerator(this$);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const activePatternResult8263 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            res = (combineHash(res, structuralHash(activePatternResult8263[0])) | 0);\r\n            res = (combineHash(res, structuralHash(activePatternResult8263[1])) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return res | 0;\r\n}\r\n\r\nexport function isEmpty(table) {\r\n    return FSharpMap__get_IsEmpty(table);\r\n}\r\n\r\nexport function add(key, value, table) {\r\n    return FSharpMap__Add(table, key, value);\r\n}\r\n\r\nexport function change(key, f, table) {\r\n    return FSharpMap__Change(table, key, f);\r\n}\r\n\r\nexport function find(key, table) {\r\n    return FSharpMap__get_Item(table, key);\r\n}\r\n\r\nexport function tryFind(key, table) {\r\n    return FSharpMap__TryFind(table, key);\r\n}\r\n\r\nexport function remove(key, table) {\r\n    return FSharpMap__Remove(table, key);\r\n}\r\n\r\nexport function containsKey(key, table) {\r\n    return FSharpMap__ContainsKey(table, key);\r\n}\r\n\r\nexport function iterate(action, table) {\r\n    FSharpMap__Iterate(table, action);\r\n}\r\n\r\nexport function tryPick(chooser, table) {\r\n    return FSharpMap__TryPick(table, chooser);\r\n}\r\n\r\nexport function pick(chooser, table) {\r\n    const matchValue = tryPick(chooser, table);\r\n    if (matchValue != null) {\r\n        return value_1(matchValue);\r\n    }\r\n    else {\r\n        throw (new Error());\r\n    }\r\n}\r\n\r\nexport function exists(predicate, table) {\r\n    return FSharpMap__Exists(table, predicate);\r\n}\r\n\r\nexport function filter(predicate, table) {\r\n    return FSharpMap__Filter(table, predicate);\r\n}\r\n\r\nexport function partition(predicate, table) {\r\n    return FSharpMap__Partition(table, predicate);\r\n}\r\n\r\nexport function forAll(predicate, table) {\r\n    return FSharpMap__ForAll(table, predicate);\r\n}\r\n\r\nexport function map(mapping, table) {\r\n    return FSharpMap__Map(table, mapping);\r\n}\r\n\r\nexport function fold(folder, state, table) {\r\n    return MapTreeModule_fold(folder, state, FSharpMap__get_Tree(table));\r\n}\r\n\r\nexport function foldBack(folder, table, state) {\r\n    return MapTreeModule_foldBack(folder, FSharpMap__get_Tree(table), state);\r\n}\r\n\r\nexport function toSeq(table) {\r\n    return map_1((kvp) => [kvp[0], kvp[1]], table);\r\n}\r\n\r\nexport function findKey(predicate, table) {\r\n    return pick_1((kvp) => {\r\n        const k = kvp[0];\r\n        if (predicate(k, kvp[1])) {\r\n            return some(k);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, table);\r\n}\r\n\r\nexport function tryFindKey(predicate, table) {\r\n    return tryPick_1((kvp) => {\r\n        const k = kvp[0];\r\n        if (predicate(k, kvp[1])) {\r\n            return some(k);\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, table);\r\n}\r\n\r\nexport function ofList(elements) {\r\n    return FSharpMap_Create(elements);\r\n}\r\n\r\nexport function ofSeq(elements) {\r\n    return FSharpMap_Create(elements);\r\n}\r\n\r\nexport function ofArray(elements) {\r\n    const comparer = LanguagePrimitives_FastGenericComparer();\r\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofArray(comparer, elements));\r\n}\r\n\r\nexport function toList(table) {\r\n    return FSharpMap__ToList(table);\r\n}\r\n\r\nexport function toArray(table) {\r\n    return FSharpMap__ToArray(table);\r\n}\r\n\r\nexport function keys(table) {\r\n    return FSharpMap__get_Keys(table);\r\n}\r\n\r\nexport function values(table) {\r\n    return FSharpMap__get_Values(table);\r\n}\r\n\r\nexport function empty() {\r\n    return FSharpMap_get_Empty();\r\n}\r\n\r\nexport function count(table) {\r\n    return FSharpMap__get_Count(table);\r\n}\r\n\r\n","import { some, value } from \"../fable-library.3.7.5/Option.js\";\n\nexport function tuple(a, b) {\n    const matchValue = [a, b];\n    let pattern_matching_result, a_1, b_1;\n    if (matchValue[0] != null) {\n        if (matchValue[1] != null) {\n            pattern_matching_result = 0;\n            a_1 = value(matchValue[0]);\n            b_1 = value(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 [a_1, b_1];\n        }\n        case 1: {\n            return void 0;\n        }\n    }\n}\n\nexport function ofFunc(f, arg) {\n    try {\n        return some(f(arg));\n    }\n    catch (matchValue) {\n        return void 0;\n    }\n}\n\n","import { FSharpRef, Record } from \"../fable-library.3.7.5/Types.js\";\nimport { record_type, class_type, list_type, string_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { ofArray, collect, map as map_1, singleton, tail, cons, empty, head, isEmpty } from \"../fable-library.3.7.5/List.js\";\nimport { FSharpResult$2 } from \"../fable-library.3.7.5/Choice.js\";\nimport { tryParse } from \"../fable-library.3.7.5/Int32.js\";\nimport { empty as empty_1, ofSeq, tryFind } from \"../fable-library.3.7.5/Map.js\";\nimport { some, bind } from \"../fable-library.3.7.5/Option.js\";\nimport { substring, split } from \"../fable-library.3.7.5/String.js\";\nimport { equalsWith } from \"../fable-library.3.7.5/Array.js\";\nimport { ofFunc, tuple } from \"./prelude.fs.js\";\nimport { map as map_2, choose } from \"../fable-library.3.7.5/Seq.js\";\n\nexport class State$1 extends Record {\n    constructor(visited, unvisited, args, value) {\n        super();\n        this.visited = visited;\n        this.unvisited = unvisited;\n        this.args = args;\n        this.value = value;\n    }\n}\n\nexport function State$1$reflection(gen0) {\n    return record_type(\"Elmish.UrlParser.State`1\", [gen0], State$1, () => [[\"visited\", list_type(string_type)], [\"unvisited\", list_type(string_type)], [\"args\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, string_type])], [\"value\", gen0]]);\n}\n\nexport function StateModule_mkState(visited, unvisited, args, value) {\n    return new State$1(visited, unvisited, args, value);\n}\n\nexport function StateModule_map(f, _arg1) {\n    return new State$1(_arg1.visited, _arg1.unvisited, _arg1.args, f(_arg1.value));\n}\n\nexport function custom(tipe, stringToSomething) {\n    return (_arg1) => {\n        const unvisited = _arg1.unvisited;\n        if (!isEmpty(unvisited)) {\n            const next = head(unvisited);\n            const matchValue = stringToSomething(next);\n            if (matchValue.tag === 1) {\n                return empty();\n            }\n            else {\n                return singleton(StateModule_mkState(cons(next, _arg1.visited), tail(unvisited), _arg1.args, _arg1.value(matchValue.fields[0])));\n            }\n        }\n        else {\n            return empty();\n        }\n    };\n}\n\nexport function str(state) {\n    return custom(\"string\", (arg0) => (new FSharpResult$2(0, arg0)))(state);\n}\n\nexport function i32(state) {\n    return custom(\"i32\", (arg) => {\n        let _arg1;\n        let outArg = 0;\n        _arg1 = [tryParse(arg, 511, false, 32, new FSharpRef(() => outArg, (v) => {\n            outArg = (v | 0);\n        })), outArg];\n        return _arg1[0] ? (new FSharpResult$2(0, _arg1[1])) : (new FSharpResult$2(1, \"Can\\u0027t parse int\"));\n    })(state);\n}\n\nexport function s(str_1) {\n    return (_arg1) => {\n        const unvisited = _arg1.unvisited;\n        if (!isEmpty(unvisited)) {\n            const next = head(unvisited);\n            if (next === str_1) {\n                return singleton(StateModule_mkState(cons(next, _arg1.visited), tail(unvisited), _arg1.args, _arg1.value));\n            }\n            else {\n                return empty();\n            }\n        }\n        else {\n            return empty();\n        }\n    };\n}\n\nexport function map(subValue, parse_1) {\n    return (_arg1) => map_1((arg10$0040) => StateModule_map(_arg1.value, arg10$0040), parse_1(new State$1(_arg1.visited, _arg1.unvisited, _arg1.args, subValue)));\n}\n\nexport function oneOf(parsers, state) {\n    return collect((parser) => parser(state), parsers);\n}\n\nexport function top(state) {\n    return singleton(state);\n}\n\nexport function customParam(key, func) {\n    return (_arg1) => {\n        const args = _arg1.args;\n        return singleton(StateModule_mkState(_arg1.visited, _arg1.unvisited, args, _arg1.value(func(tryFind(key, args)))));\n    };\n}\n\nexport function stringParam(name) {\n    return customParam(name, (x) => x);\n}\n\nexport const intParamHelp = (option) => bind((value) => {\n    let matchValue;\n    let outArg = 0;\n    matchValue = [tryParse(value, 511, false, 32, new FSharpRef(() => outArg, (v) => {\n        outArg = (v | 0);\n    })), outArg];\n    if (matchValue[0]) {\n        return matchValue[1];\n    }\n    else {\n        return void 0;\n    }\n}, option);\n\nexport function intParam(name) {\n    return customParam(name, intParamHelp);\n}\n\nexport function parseHelp(states_mut) {\n    parseHelp:\n    while (true) {\n        const states = states_mut;\n        if (!isEmpty(states)) {\n            const state = head(states);\n            const matchValue = state.unvisited;\n            let pattern_matching_result;\n            if (!isEmpty(matchValue)) {\n                if (head(matchValue) === \"\") {\n                    if (isEmpty(tail(matchValue))) {\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 = 0;\n            }\n            switch (pattern_matching_result) {\n                case 0: {\n                    return some(state.value);\n                }\n                case 1: {\n                    return some(state.value);\n                }\n                case 2: {\n                    states_mut = tail(states);\n                    continue parseHelp;\n                }\n            }\n        }\n        else {\n            return void 0;\n        }\n        break;\n    }\n}\n\nexport function splitUrl(url) {\n    const matchValue = ofArray(url.split(\"/\"));\n    let pattern_matching_result, segments, segments_1;\n    if (!isEmpty(matchValue)) {\n        if (head(matchValue) === \"\") {\n            pattern_matching_result = 0;\n            segments = tail(matchValue);\n        }\n        else {\n            pattern_matching_result = 1;\n            segments_1 = matchValue;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n        segments_1 = matchValue;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return segments;\n        }\n        case 1: {\n            return segments_1;\n        }\n    }\n}\n\nexport function parse(parser, url, args) {\n    return parseHelp(parser(new State$1(empty(), splitUrl(url), args, (x) => x)));\n}\n\nexport function toKeyValuePair(segment) {\n    const matchValue = split(segment, [\"=\"], null, 0);\n    if ((!equalsWith((x, y) => (x === y), matchValue, null)) && (matchValue.length === 2)) {\n        const value = matchValue[1];\n        return tuple(ofFunc(decodeURIComponent, matchValue[0]), ofFunc(decodeURIComponent, value));\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function parseParams(querystring) {\n    if (querystring.length > 1) {\n        return ofSeq(choose((x) => x, map_2(toKeyValuePair, split(substring(querystring, 1), [\"\\u0026\"], null, 0))));\n    }\n    else {\n        return empty_1();\n    }\n}\n\nexport function parsePath(parser, location) {\n    return parse(parser, location.pathname, parseParams(location.search));\n}\n\nexport function parseHash(parser, location) {\n    let patternInput;\n    const hash = (location.hash.length > 1) ? substring(location.hash, 1) : \"\";\n    if (hash.indexOf(\"?\") >= 0) {\n        const h = substring(hash, 0, hash.indexOf(\"?\"));\n        patternInput = [h, substring(hash, h.length)];\n    }\n    else {\n        patternInput = [hash, \"?\"];\n    }\n    return parse(parser, patternInput[0], parseParams(patternInput[1]));\n}\n\n","import { Union } from \"./fable_modules/fable-library.3.7.5/Types.js\";\nimport { union_type, option_type, string_type } from \"./fable_modules/fable-library.3.7.5/Reflection.js\";\nimport { printf, toText } from \"./fable_modules/fable-library.3.7.5/String.js\";\nimport { parsePath, oneOf, stringParam, s, map } from \"./fable_modules/Fable.Elmish.Browser.3.0.4/parser.fs.js\";\nimport { singleton, collect } from \"./fable_modules/fable-library.3.7.5/List.js\";\n\nexport class Route extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Home\"];\n    }\n}\n\nexport function Route$reflection() {\n    return union_type(\"Routing.Route\", [], Route, () => [[[\"Item\", option_type(string_type)]]]);\n}\n\nexport function toRouteUrl(route) {\n    const topicOpt = route.fields[0];\n    if (topicOpt == null) {\n        return \"/\";\n    }\n    else {\n        const generalTopic = topicOpt;\n        return toText(printf(\"/?topic=%s\"))(generalTopic);\n    }\n}\n\nexport function curry(f, x, y) {\n    return f([x, y]);\n}\n\nexport const Routing_route = (() => {\n    let parser, queryParser;\n    const parsers = singleton(map((arg0) => (new Route(0, arg0)), (parser = s(\"\"), (queryParser = stringParam(\"topic\"), (state) => collect(queryParser, parser(state))))));\n    return (state_2) => oneOf(parsers, state_2);\n})();\n\nexport function Routing_parsePath(location) {\n    return parsePath(Routing_route, location);\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 (t2.fullname === obj_type.fullname) || (t1.parent != null && (t1.parent.Equals(t2) || isSubclassOf(t1.parent, t2)));\n}\nfunction isErasedToNumber(t) {\n    return isEnum(t) || [\n        int8_type.fullname,\n        uint8_type.fullname,\n        int16_type.fullname,\n        uint16_type.fullname,\n        int32_type.fullname,\n        uint32_type.fullname,\n        float32_type.fullname,\n        float64_type.fullname,\n    ].includes(t.fullname);\n}\nexport function isInstanceOfType(t, o) {\n    if (t.fullname === obj_type.fullname)\n        return true;\n    switch (typeof o) {\n        case \"boolean\":\n            return t.fullname === bool_type.fullname;\n        case \"string\":\n            return t.fullname === string_type.fullname;\n        case \"function\":\n            return isFunction(t);\n        case \"number\":\n            return isErasedToNumber(t);\n        default:\n            return t.construct != null && o instanceof t.construct;\n    }\n}\n/**\n * This doesn't replace types for fields (records) or cases (unions)\n * but it should be enough for type comparison purposes\n */\nexport function getGenericTypeDefinition(t) {\n    return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));\n}\nexport function getEnumUnderlyingType(t) {\n    var _a;\n    return (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0];\n}\nexport function getEnumValues(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[1]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function getEnumNames(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[0]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nfunction getEnumCase(t, v) {\n    if (t.enumCases != null) {\n        if (typeof v === \"string\") {\n            for (const kv of t.enumCases) {\n                if (kv[0] === v) {\n                    return kv;\n                }\n            }\n            throw new Error(`'${v}' was not found in ${t.fullname}`);\n        }\n        else {\n            for (const kv of t.enumCases) {\n                if (kv[1] === v) {\n                    return kv;\n                }\n            }\n            // .NET returns the number even if it doesn't match any of the cases\n            return [\"\", v];\n        }\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function parseEnum(t, str) {\n    // TODO: better int parsing here, parseInt ceils floats: \"4.8\" -> 4\n    const value = parseInt(str, 10);\n    return getEnumCase(t, isNaN(value) ? str : value)[1];\n}\nexport function tryParseEnum(t, str, defValue) {\n    try {\n        defValue.contents = parseEnum(t, str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getEnumName(t, v) {\n    return getEnumCase(t, v)[0];\n}\nexport function isEnumDefined(t, v) {\n    try {\n        const kv = getEnumCase(t, v);\n        return kv[0] != null && kv[0] !== \"\";\n    }\n    catch (_a) {\n        // supress error\n    }\n    return false;\n}\n// FSharpType\nexport function getUnionCases(t) {\n    if (t.cases != null) {\n        return t.cases();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# union type`);\n    }\n}\nexport function getRecordElements(t) {\n    if (t.fields != null) {\n        return t.fields();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# record type`);\n    }\n}\nexport function getTupleElements(t) {\n    if (isTuple(t) && t.generics != null) {\n        return t.generics;\n    }\n    else {\n        throw new Error(`${t.fullname} is not a tuple type`);\n    }\n}\nexport function getFunctionElements(t) {\n    if (isFunction(t) && t.generics != null) {\n        const gen = t.generics;\n        return [gen[0], gen[1]];\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# function type`);\n    }\n}\nexport function isUnion(t) {\n    return t instanceof TypeInfo ? t.cases != null : t instanceof Union;\n}\nexport function isRecord(t) {\n    return t instanceof TypeInfo ? t.fields != null : t instanceof Record;\n}\nexport function isTuple(t) {\n    return t.fullname.startsWith(\"System.Tuple\");\n}\n// In .NET this is false for delegates\nexport function isFunction(t) {\n    return t.fullname === \"Microsoft.FSharp.Core.FSharpFunc`2\";\n}\n// FSharpValue\nexport function getUnionFields(v, t) {\n    const cases = getUnionCases(t);\n    const case_ = cases[v.tag];\n    if (case_ == null) {\n        throw new Error(`Cannot find case ${v.name} in union type`);\n    }\n    return [case_, v.fields];\n}\nexport function getUnionCaseFields(uci) {\n    return uci.fields == null ? [] : uci.fields;\n}\n// This is used as replacement of `FSharpValue.GetRecordFields`\n// For `FSharpTypes.GetRecordFields` see `getRecordElements`\n// Object.keys returns keys in the order they were added to the object\nexport function getRecordFields(v) {\n    return Object.keys(v).map((k) => v[k]);\n}\nexport function getRecordField(v, field) {\n    return v[field[0]];\n}\nexport function getTupleFields(v) {\n    return v;\n}\nexport function getTupleField(v, i) {\n    return v[i];\n}\nexport function makeUnion(uci, values) {\n    const expectedLength = (uci.fields || []).length;\n    if (values.length !== expectedLength) {\n        throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);\n    }\n    return uci.declaringType.construct != null\n        ? new uci.declaringType.construct(uci.tag, ...values)\n        : {};\n}\nexport function makeRecord(t, values) {\n    const fields = getRecordElements(t);\n    if (fields.length !== values.length) {\n        throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);\n    }\n    return t.construct != null\n        ? new t.construct(...values)\n        : fields.reduce((obj, [key, _t], i) => {\n            obj[key] = values[i];\n            return obj;\n        }, {});\n}\nexport function makeTuple(values, _t) {\n    return values;\n}\nexport function makeGenericType(t, generics) {\n    return new TypeInfo(t.fullname, generics, t.construct, t.parent, t.fields, t.cases);\n}\nexport function createInstance(t, consArgs) {\n    // TODO: Check if consArgs length is same as t.construct?\n    // (Arg types can still be different)\n    if (typeof t.construct === \"function\") {\n        return new t.construct(...(consArgs !== null && consArgs !== void 0 ? consArgs : []));\n    }\n    else if (isErasedToNumber(t)) {\n        return 0;\n    }\n    else {\n        switch (t.fullname) {\n            case obj_type.fullname:\n                return {};\n            case bool_type.fullname:\n                return false;\n            case \"System.Int64\":\n            case \"System.UInt64\":\n                // typeof<int64> and typeof<uint64> get transformed to class_type(\"System.Int64\")\n                // and class_type(\"System.UInt64\") respectively. Test for the name of the primitive type.\n                return int64FromInt(0);\n            case decimal_type.fullname:\n                return new Decimal(0);\n            case char_type.fullname:\n                // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null\n                return null;\n            default:\n                throw new Error(`Cannot access constructor of ${t.fullname}`);\n        }\n    }\n}\nexport function getValue(propertyInfo, v) {\n    return v[propertyInfo[0]];\n}\n// Fable.Core.Reflection\nfunction assertUnion(x) {\n    if (!(x instanceof Union)) {\n        throw new Error(`Value is not an F# union type`);\n    }\n}\nexport function getCaseTag(x) {\n    assertUnion(x);\n    return x.tag;\n}\nexport function getCaseName(x) {\n    assertUnion(x);\n    return x.cases()[x.tag];\n}\nexport function getCaseFields(x) {\n    assertUnion(x);\n    return x.fields;\n}\n","import { Union } from \"../Client/fable_modules/fable-library.3.7.5/Types.js\";\nimport { union_type } from \"../Client/fable_modules/fable-library.3.7.5/Reflection.js\";\nimport { replace } from \"../Client/fable_modules/fable-library.3.7.5/String.js\";\n\nexport class IssueType extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Question\", \"Bug\", \"Request\"];\n    }\n}\n\nexport function IssueType$reflection() {\n    return union_type(\"IssueTypes.IssueType\", [], IssueType, () => [[], [], []]);\n}\n\nexport class Topic extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"RDM\", \"Infrastructure\", \"Tools\", \"Workflows\", \"Metadata\", \"Documentation\", \"Other\"];\n    }\n}\n\nexport function Topic$reflection() {\n    return union_type(\"IssueTypes.Topic\", [], Topic, () => [[[\"Item\", IssueSubtopics_RDM$reflection()]], [[\"Item\", IssueSubtopics_Infrastructure$reflection()]], [[\"Item\", IssueSubtopics_Tools$reflection()]], [[\"Item\", IssueSubtopics_Workflows$reflection()]], [[\"Item\", IssueSubtopics_Metadata$reflection()]], [[\"Item\", IssueSubtopics_Documentation$reflection()]], []]);\n}\n\nexport class IssueGeneralTopic extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"RDM\", \"Infrastructure\", \"Tools\", \"Workflows\", \"Metadata\", \"Documentation\", \"Other\"];\n    }\n}\n\nexport function IssueGeneralTopic$reflection() {\n    return union_type(\"IssueTypes.IssueGeneralTopic\", [], IssueGeneralTopic, () => [[], [], [], [], [], [], []]);\n}\n\nexport function IssueType_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"Question\": {\n            return new IssueType(0);\n        }\n        case \"Bug\": {\n            return new IssueType(1);\n        }\n        case \"Request\": {\n            return new IssueType(2);\n        }\n        default: {\n            throw (new Error(`Unable to parse '${str}' to IssueType.`));\n        }\n    }\n}\n\nexport class IssueSubtopics_RDM extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"DataSecurity\", \"DataLiteracy\", \"Teaching\", \"ARCStructure\", \"AnnotationPrinciples\", \"More\"];\n    }\n}\n\nexport function IssueSubtopics_RDM$reflection() {\n    return union_type(\"IssueTypes.IssueSubtopics.RDM\", [], IssueSubtopics_RDM, () => [[], [], [], [], [], []]);\n}\n\nexport class IssueSubtopics_Infrastructure extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"RegistrationLogin\", \"DataHUB\", \"MetadataRegistry\", \"Invenio\", \"InfrastructureCode\", \"More\"];\n    }\n}\n\nexport function IssueSubtopics_Infrastructure$reflection() {\n    return union_type(\"IssueTypes.IssueSubtopics.Infrastructure\", [], IssueSubtopics_Infrastructure, () => [[], [], [], [], [], []]);\n}\n\nexport class IssueSubtopics_Tools extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"ARCCommander\", \"ARCitect\", \"Swate\", \"DataPLAN\", \"Swobup\", \"Converters\", \"More\"];\n    }\n}\n\nexport function IssueSubtopics_Tools$reflection() {\n    return union_type(\"IssueTypes.IssueSubtopics.Tools\", [], IssueSubtopics_Tools, () => [[], [], [], [], [], [], []]);\n}\n\nexport class IssueSubtopics_Workflows extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"CWL\", \"Galaxy\", \"More\"];\n    }\n}\n\nexport function IssueSubtopics_Workflows$reflection() {\n    return union_type(\"IssueTypes.IssueSubtopics.Workflows\", [], IssueSubtopics_Workflows, () => [[], [], []]);\n}\n\nexport class IssueSubtopics_Metadata extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"OntologyUpdate\", \"SwateTemplate\", \"More\"];\n    }\n}\n\nexport function IssueSubtopics_Metadata$reflection() {\n    return union_type(\"IssueTypes.IssueSubtopics.Metadata\", [], IssueSubtopics_Metadata, () => [[], [], []]);\n}\n\nexport class IssueSubtopics_Documentation extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"KnowledgeBase\", \"More\"];\n    }\n}\n\nexport function IssueSubtopics_Documentation$reflection() {\n    return union_type(\"IssueTypes.IssueSubtopics.Documentation\", [], IssueSubtopics_Documentation, () => [[], []]);\n}\n\nexport function IssueSubtopics_RDM__get_toString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return \"Data Literacy\";\n        }\n        case 2: {\n            return \"Teaching\";\n        }\n        case 3: {\n            return \"ARC Structure\";\n        }\n        case 4: {\n            return \"Annotation Principles\";\n        }\n        case 5: {\n            return \"More\";\n        }\n        default: {\n            return \"Data Security\";\n        }\n    }\n}\n\nexport function IssueSubtopics_RDM_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"Data Security\":\n        case \"DataSecurity\": {\n            return new IssueSubtopics_RDM(0);\n        }\n        case \"Data Literacy\":\n        case \"DataLiteracy\": {\n            return new IssueSubtopics_RDM(1);\n        }\n        case \"Teaching\": {\n            return new IssueSubtopics_RDM(2);\n        }\n        case \"ARC Structure\":\n        case \"ARCStructure\": {\n            return new IssueSubtopics_RDM(3);\n        }\n        case \"Annotation Principles\":\n        case \"AnnotationPrinciples\": {\n            return new IssueSubtopics_RDM(4);\n        }\n        case \"More\": {\n            return new IssueSubtopics_RDM(5);\n        }\n        default: {\n            throw (new Error(`Could not parse ${str} to RDM subtopic`));\n        }\n    }\n}\n\nexport function IssueSubtopics_Infrastructure__get_toString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return \"DataHUB\";\n        }\n        case 2: {\n            return \"Metadata Registry\";\n        }\n        case 3: {\n            return \"Invenio\";\n        }\n        case 4: {\n            return \"Infrastructure Code\";\n        }\n        case 5: {\n            return \"More\";\n        }\n        default: {\n            return \"Registration Login\";\n        }\n    }\n}\n\nexport function IssueSubtopics_Infrastructure_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"Registration Login\":\n        case \"RegistrationLogin\": {\n            return new IssueSubtopics_Infrastructure(0);\n        }\n        case \"GitLab\":\n        case \"DataHUB\": {\n            return new IssueSubtopics_Infrastructure(1);\n        }\n        case \"Metadata Registry\":\n        case \"MetadataRegistry\": {\n            return new IssueSubtopics_Infrastructure(2);\n        }\n        case \"Invenio\": {\n            return new IssueSubtopics_Infrastructure(3);\n        }\n        case \"Infrastructure Code\":\n        case \"InfrastructureCode\": {\n            return new IssueSubtopics_Infrastructure(4);\n        }\n        case \"More\": {\n            return new IssueSubtopics_Infrastructure(5);\n        }\n        default: {\n            throw (new Error(`Could not parse ${str} to Infrastructure subtopic`));\n        }\n    }\n}\n\nexport function IssueSubtopics_Tools__get_toString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return \"ARCitect\";\n        }\n        case 2: {\n            return \"Swate\";\n        }\n        case 3: {\n            return \"DataPLAN\";\n        }\n        case 4: {\n            return \"Swobup\";\n        }\n        case 5: {\n            return \"Converters\";\n        }\n        case 6: {\n            return \"More\";\n        }\n        default: {\n            return \"ARC Commander\";\n        }\n    }\n}\n\nexport function IssueSubtopics_Tools_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"ARC Commander\": {\n            return new IssueSubtopics_Tools(0);\n        }\n        case \"ARCitect\": {\n            return new IssueSubtopics_Tools(1);\n        }\n        case \"Swate\": {\n            return new IssueSubtopics_Tools(2);\n        }\n        case \"DMP Generator\":\n        case \"DataPLAN\": {\n            return new IssueSubtopics_Tools(3);\n        }\n        case \"Swobup\": {\n            return new IssueSubtopics_Tools(4);\n        }\n        case \"Converters\": {\n            return new IssueSubtopics_Tools(5);\n        }\n        case \"More\": {\n            return new IssueSubtopics_Tools(6);\n        }\n        default: {\n            throw (new Error(`Could not parse ${str} to Tools subtopic`));\n        }\n    }\n}\n\nexport function IssueSubtopics_Workflows__get_toString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return \"Galaxy\";\n        }\n        case 2: {\n            return \"More\";\n        }\n        default: {\n            return \"CWL\";\n        }\n    }\n}\n\nexport function IssueSubtopics_Workflows_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"CWL\": {\n            return new IssueSubtopics_Workflows(0);\n        }\n        case \"Galaxy\": {\n            return new IssueSubtopics_Workflows(1);\n        }\n        case \"More\": {\n            return new IssueSubtopics_Workflows(2);\n        }\n        default: {\n            throw (new Error(`Could not parse ${str} to Workflows subtopic`));\n        }\n    }\n}\n\nexport function IssueSubtopics_Metadata__get_toString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return \"Swate Template\";\n        }\n        case 2: {\n            return \"More\";\n        }\n        default: {\n            return \"Ontology Update\";\n        }\n    }\n}\n\nexport function IssueSubtopics_Metadata_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"Ontology Update\":\n        case \"OntologyUpdate\": {\n            return new IssueSubtopics_Metadata(0);\n        }\n        case \"Swate Template\":\n        case \"SwateTemplate\": {\n            return new IssueSubtopics_Metadata(1);\n        }\n        case \"More\": {\n            return new IssueSubtopics_Metadata(2);\n        }\n        default: {\n            throw (new Error(`Could not parse ${str} to Metadata subtopic`));\n        }\n    }\n}\n\nexport function IssueSubtopics_Documentation__get_toString(this$) {\n    if (this$.tag === 1) {\n        return \"More\";\n    }\n    else {\n        return \"Knowledge Base\";\n    }\n}\n\nexport function IssueSubtopics_Documentation_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"Knowledge Base\":\n        case \"KnowledgeBase\": {\n            return new IssueSubtopics_Documentation(0);\n        }\n        case \"More\": {\n            return new IssueSubtopics_Documentation(1);\n        }\n        default: {\n            throw (new Error(`Could not parse ${str} to Metadata subtopic`));\n        }\n    }\n}\n\nexport function Topic__get_toSubCategoryString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return IssueSubtopics_Infrastructure__get_toString(this$.fields[0]);\n        }\n        case 2: {\n            return IssueSubtopics_Tools__get_toString(this$.fields[0]);\n        }\n        case 3: {\n            return IssueSubtopics_Workflows__get_toString(this$.fields[0]);\n        }\n        case 4: {\n            return IssueSubtopics_Metadata__get_toString(this$.fields[0]);\n        }\n        case 5: {\n            return IssueSubtopics_Documentation__get_toString(this$.fields[0]);\n        }\n        case 6: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(6));\n        }\n        default: {\n            return IssueSubtopics_RDM__get_toString(this$.fields[0]);\n        }\n    }\n}\n\nexport function Topic__get_toCategoryString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(1));\n        }\n        case 2: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(2));\n        }\n        case 3: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(3));\n        }\n        case 4: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(4));\n        }\n        case 5: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(5));\n        }\n        case 6: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(6));\n        }\n        default: {\n            return IssueGeneralTopic__get_toString(new IssueGeneralTopic(0));\n        }\n    }\n}\n\nexport function Topic__get_toUrlString(this$) {\n    const rmWhitespace = (str) => replace(str, \" \", \"\");\n    switch (this$.tag) {\n        case 1: {\n            return `${rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(1)))}_${rmWhitespace(IssueSubtopics_Infrastructure__get_toString(this$.fields[0]))}`;\n        }\n        case 2: {\n            return `${rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(2)))}_${rmWhitespace(IssueSubtopics_Tools__get_toString(this$.fields[0]))}`;\n        }\n        case 3: {\n            return `${rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(3)))}_${rmWhitespace(IssueSubtopics_Workflows__get_toString(this$.fields[0]))}`;\n        }\n        case 4: {\n            return `${rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(4)))}_${rmWhitespace(IssueSubtopics_Metadata__get_toString(this$.fields[0]))}`;\n        }\n        case 5: {\n            return `${rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(5)))}_${rmWhitespace(IssueSubtopics_Documentation__get_toString(this$.fields[0]))}`;\n        }\n        case 6: {\n            return rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(6)));\n        }\n        default: {\n            return `${rmWhitespace(IssueGeneralTopic__get_toString(new IssueGeneralTopic(0)))}_${rmWhitespace(IssueSubtopics_RDM__get_toString(this$.fields[0]))}`;\n        }\n    }\n}\n\nexport function Topic_ofUrlString_Z721C83C5(str) {\n    let patternInput;\n    const ind = str.indexOf(\"_\") | 0;\n    patternInput = [str.slice(void 0, (ind - 1) + 1), str.slice(ind + 1, str.length)];\n    const subtopic = patternInput[1];\n    const matchValue = IssueGeneralTopic_ofString_Z721C83C5(patternInput[0]);\n    switch (matchValue.tag) {\n        case 1: {\n            return new Topic(1, IssueSubtopics_Infrastructure_ofString_Z721C83C5(subtopic));\n        }\n        case 2: {\n            return new Topic(2, IssueSubtopics_Tools_ofString_Z721C83C5(subtopic));\n        }\n        case 3: {\n            return new Topic(3, IssueSubtopics_Workflows_ofString_Z721C83C5(subtopic));\n        }\n        case 4: {\n            return new Topic(4, IssueSubtopics_Metadata_ofString_Z721C83C5(subtopic));\n        }\n        case 5: {\n            return new Topic(5, IssueSubtopics_Documentation_ofString_Z721C83C5(subtopic));\n        }\n        case 6: {\n            return new Topic(6);\n        }\n        default: {\n            return new Topic(0, IssueSubtopics_RDM_ofString_Z721C83C5(subtopic));\n        }\n    }\n}\n\nexport function IssueGeneralTopic_ofString_Z721C83C5(str) {\n    switch (str) {\n        case \"RDM\":\n        case \"Research Data Management\":\n        case \"ResearchDataManagement\": {\n            return new IssueGeneralTopic(0);\n        }\n        case \"Infrastructure\": {\n            return new IssueGeneralTopic(1);\n        }\n        case \"Tools\": {\n            return new IssueGeneralTopic(2);\n        }\n        case \"Workflows\": {\n            return new IssueGeneralTopic(3);\n        }\n        case \"Metadata\": {\n            return new IssueGeneralTopic(4);\n        }\n        case \"Documentation\": {\n            return new IssueGeneralTopic(5);\n        }\n        case \"Other\": {\n            return new IssueGeneralTopic(6);\n        }\n        default: {\n            throw (new Error(`Unable to parse '${str}' to IssueCategory.`));\n        }\n    }\n}\n\nexport function IssueGeneralTopic__get_toString(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return \"Infrastructure\";\n        }\n        case 2: {\n            return \"Tools\";\n        }\n        case 3: {\n            return \"Workflows\";\n        }\n        case 4: {\n            return \"Metadata\";\n        }\n        case 5: {\n            return \"Documentation\";\n        }\n        case 6: {\n            return \"Other\";\n        }\n        default: {\n            return \"Research Data Management\";\n        }\n    }\n}\n\nexport function IssueGeneralTopic__get_subcategories(this$) {\n    switch (this$.tag) {\n        case 1: {\n            return [new Topic(1, new IssueSubtopics_Infrastructure(1)), new Topic(1, new IssueSubtopics_Infrastructure(4)), new Topic(1, new IssueSubtopics_Infrastructure(3)), new Topic(1, new IssueSubtopics_Infrastructure(2)), new Topic(1, new IssueSubtopics_Infrastructure(0)), new Topic(1, new IssueSubtopics_Infrastructure(5))];\n        }\n        case 2: {\n            return [new Topic(2, new IssueSubtopics_Tools(0)), new Topic(2, new IssueSubtopics_Tools(5)), new Topic(2, new IssueSubtopics_Tools(3)), new Topic(2, new IssueSubtopics_Tools(2)), new Topic(2, new IssueSubtopics_Tools(4)), new Topic(2, new IssueSubtopics_Tools(6))];\n        }\n        case 3: {\n            return [new Topic(3, new IssueSubtopics_Workflows(0)), new Topic(3, new IssueSubtopics_Workflows(1)), new Topic(3, new IssueSubtopics_Workflows(2))];\n        }\n        case 4: {\n            return [new Topic(4, new IssueSubtopics_Metadata(1)), new Topic(4, new IssueSubtopics_Metadata(0)), new Topic(4, new IssueSubtopics_Metadata(2))];\n        }\n        case 5: {\n            return [new Topic(5, new IssueSubtopics_Documentation(0)), new Topic(5, new IssueSubtopics_Documentation(1))];\n        }\n        case 6: {\n            return [];\n        }\n        default: {\n            return [new Topic(0, new IssueSubtopics_RDM(4)), new Topic(0, new IssueSubtopics_RDM(3)), new Topic(0, new IssueSubtopics_RDM(1)), new Topic(0, new IssueSubtopics_RDM(0)), new Topic(0, new IssueSubtopics_RDM(2)), new Topic(0, new IssueSubtopics_RDM(5))];\n        }\n    }\n}\n\n","import { Record } from \"../Client/fable_modules/fable-library.3.7.5/Types.js\";\nimport { IssueType, Topic$reflection, IssueType$reflection } from \"./IssueTypes.fs.js\";\nimport { record_type, string_type, option_type } from \"../Client/fable_modules/fable-library.3.7.5/Reflection.js\";\n\nexport class Model extends Record {\n    constructor(IssueType, IssueTopic, IssueTitle, IssueContent, UserEmail) {\n        super();\n        this.IssueType = IssueType;\n        this.IssueTopic = IssueTopic;\n        this.IssueTitle = IssueTitle;\n        this.IssueContent = IssueContent;\n        this.UserEmail = UserEmail;\n    }\n}\n\nexport function Model$reflection() {\n    return record_type(\"Form.Model\", [], Model, () => [[\"IssueType\", IssueType$reflection()], [\"IssueTopic\", option_type(Topic$reflection())], [\"IssueTitle\", string_type], [\"IssueContent\", string_type], [\"UserEmail\", string_type]]);\n}\n\nexport function Model_init() {\n    return new Model(new IssueType(0), void 0, \"\", \"\", \"\");\n}\n\n","import { Record } from \"../Client/fable_modules/fable-library.3.7.5/Types.js\";\nimport { record_type, string_type, class_type } from \"../Client/fable_modules/fable-library.3.7.5/Reflection.js\";\n\nexport class ClientCaptcha extends Record {\n    constructor(Id, ImageBase64, UserInput, AccessToken) {\n        super();\n        this.Id = Id;\n        this.ImageBase64 = ImageBase64;\n        this.UserInput = UserInput;\n        this.AccessToken = AccessToken;\n    }\n}\n\nexport function ClientCaptcha$reflection() {\n    return record_type(\"CaptchaTypes.ClientCaptcha\", [], ClientCaptcha, () => [[\"Id\", class_type(\"System.Guid\")], [\"ImageBase64\", string_type], [\"UserInput\", string_type], [\"AccessToken\", string_type]]);\n}\n\n","import { Exception, Record, Union } from \"../fable-library.3.7.5/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.7.5/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","\"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.7.5/Types.js\";\nimport { string_type, record_type, int32_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { some } from \"../fable-library.3.7.5/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.7.5/String.js\";\nimport { reduce } from \"../fable-library.3.7.5/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","import { FSharpRef } from \"./Types.js\";\nexport function tryParse(str, defValue) {\n    // TODO: test if value is valid and in range\n    if (str != null && /\\S/.test(str)) {\n        const v = +str.replace(\"_\", \"\");\n        if (!Number.isNaN(v)) {\n            defValue.contents = v;\n            return true;\n        }\n    }\n    return false;\n}\nexport function parse(str) {\n    const defValue = new FSharpRef(0);\n    if (tryParse(str, defValue)) {\n        return defValue.contents;\n    }\n    else {\n        throw new Error(\"Input string was not in a correct format.\");\n    }\n}\n// JS Number.isFinite function evals false for NaN\nexport function isInfinity(x) {\n    return x === Number.POSITIVE_INFINITY || x === Number.NEGATIVE_INFINITY;\n}\n","import { Union } from \"../fable-library.3.7.5/Types.js\";\nimport { union_type, class_type, list_type, bool_type, string_type, float64_type } from \"../fable-library.3.7.5/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 { Parsimmon_seq3, Parsimmon_seperateBy, Parsimmon_ofLazy, Parsimmon_optionalWhitespace, Parsimmon_between, Parsimmon_satisfy, Parsimmon_orTry, Parsimmon_many, Parsimmon_oneOf, Parsimmon_stringReturn, Parsimmon_choose, 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.7.5/Double.js\";\nimport { regexp } from \"../Fable.Parsimmon.4.1.0/./Parsimmon.js\";\nimport { map, ofArray } from \"../fable-library.3.7.5/List.js\";\nimport { Json } from \"./Json.fs.js\";\nimport { ofList } from \"../fable-library.3.7.5/Map.js\";\nimport { Lazy } from \"../fable-library.3.7.5/Util.js\";\n\nexport const digits = Parsimmon_concat(Parsimmon_atLeastOneOrMany(Parsimmon_digit));\n\nexport const jint = Parsimmon_map(parse, digits);\n\nexport const negJint = Parsimmon_map((tupledArg) => (-tupledArg[1]), Parsimmon_seq2(Parsimmon_str(\"-\"), jint));\n\nexport const jfloat = Parsimmon_map(parse, Parsimmon_choose(ofArray([regexp(new RegExp(\"-?(0|[1-9][0-9]*)?[.][0-9]+([eE][+-]?[0-9]+)?\")), regexp(new RegExp(\"-?[1-9][0-9]*[eE][+-]?[0-9]+\"))])));\n\nexport const jnumber = Parsimmon_map((arg0) => (new Json(0, arg0)), Parsimmon_choose(ofArray([jfloat, 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(withWhitespace, ofArray([jnull, jbool, jnumber, jstring])));\n\nexport const comma = withWhitespace(Parsimmon_str(\",\"));\n\nfunction json$004080() {\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$004080$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$004080$002D1.Value))))))])));\n}\n\nconst json$004080$002D1 = new Lazy(json$004080);\n\nexport const json = json$004080$002D1.Value;\n\nexport const jsonParser = withWhitespace(json);\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","import { Record } from \"../Types.js\";\r\nimport { record_type, array_type, int32_type } from \"../Reflection.js\";\r\nimport { op_LeftShift, op_BitwiseAnd, op_Addition, compare, op_Subtraction, op_Division, equals, fromInteger, op_Multiply, op_Modulus, toInt, fromBits } from \"../Long.js\";\r\nimport { copy, initialize, map, fill } from \"../Array.js\";\r\nimport { toArray, empty, head, tail, isEmpty, cons } from \"../List.js\";\r\nimport { int32ToString } from \"../Util.js\";\r\nimport { isNullOrEmpty, join } from \"../String.js\";\r\n\r\nexport class BigNat extends Record {\r\n    constructor(bound, digits) {\r\n        super();\r\n        this.bound = (bound | 0);\r\n        this.digits = digits;\r\n    }\r\n}\r\n\r\nexport function BigNat$reflection() {\r\n    return record_type(\"BigInt.BigNat\", [], BigNat, () => [[\"bound\", int32_type], [\"digits\", array_type(int32_type)]]);\r\n}\r\n\r\nexport function BigNatModule_FFT_pow32(x_mut, n_mut) {\r\n    BigNatModule_FFT_pow32:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return 1;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (x * x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_FFT_pow32;\r\n        }\r\n        else {\r\n            return (x * BigNatModule_FFT_pow32(x * x, ~(~(n / 2)))) | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_leastBounding2Power(b) {\r\n    const findBounding2Power = (b_1_mut, tp_mut, i_mut) => {\r\n        findBounding2Power:\r\n        while (true) {\r\n            const b_1 = b_1_mut, tp = tp_mut, i = i_mut;\r\n            if (b_1 <= tp) {\r\n                return [tp, i];\r\n            }\r\n            else {\r\n                b_1_mut = b_1;\r\n                tp_mut = (tp * 2);\r\n                i_mut = (i + 1);\r\n                continue findBounding2Power;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return findBounding2Power(b, 1, 0);\r\n}\r\n\r\nexport const BigNatModule_FFT_p = fromBits(2013265921, 0, false);\r\n\r\nconst BigNatModule_FFT_patternInput$004075 = [27, 15, 31, 440564289];\r\n\r\nexport const BigNatModule_FFT_w = BigNatModule_FFT_patternInput$004075[3];\r\n\r\nexport const BigNatModule_FFT_m = BigNatModule_FFT_patternInput$004075[1];\r\n\r\nexport const BigNatModule_FFT_k = BigNatModule_FFT_patternInput$004075[0];\r\n\r\nexport const BigNatModule_FFT_g = BigNatModule_FFT_patternInput$004075[2];\r\n\r\nexport const BigNatModule_FFT_primeP = BigNatModule_FFT_p;\r\n\r\nexport const BigNatModule_FFT_maxBitsInsideFp = 30;\r\n\r\nexport const BigNatModule_FFT_Fp_p = 2013265921;\r\n\r\nexport const BigNatModule_FFT_Fp_p64 = fromBits(2013265921, 0, true);\r\n\r\nexport function BigNatModule_FFT_Fp_toInt(x) {\r\n    return ~(~x);\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_ofInt32(x) {\r\n    return x >>> 0;\r\n}\r\n\r\nexport const BigNatModule_FFT_Fp_mzero = 0;\r\n\r\nexport const BigNatModule_FFT_Fp_mone = 1;\r\n\r\nexport const BigNatModule_FFT_Fp_mtwo = 2;\r\n\r\nexport function BigNatModule_FFT_Fp_mpow(x_mut, n_mut) {\r\n    BigNatModule_FFT_Fp_mpow:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return BigNatModule_FFT_Fp_mone;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_FFT_Fp_mpow;\r\n        }\r\n        else {\r\n            const y_2 = BigNatModule_FFT_Fp_mpow(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, ~(~(n / 2)));\r\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_mpowL(x_mut, n_mut) {\r\n    BigNatModule_FFT_Fp_mpowL:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (equals(n, fromBits(0, 0, false))) {\r\n            return BigNatModule_FFT_Fp_mone;\r\n        }\r\n        else if (equals(op_Modulus(n, fromBits(2, 0, false)), fromBits(0, 0, false))) {\r\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\r\n            n_mut = op_Division(n, fromBits(2, 0, false));\r\n            continue BigNatModule_FFT_Fp_mpowL;\r\n        }\r\n        else {\r\n            const y_2 = BigNatModule_FFT_Fp_mpowL(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, op_Division(n, fromBits(2, 0, false)));\r\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_m2PowNthRoot(n) {\r\n    return BigNatModule_FFT_Fp_mpow(BigNatModule_FFT_w >>> 0, BigNatModule_FFT_pow32(2, BigNatModule_FFT_k - n));\r\n}\r\n\r\nexport function BigNatModule_FFT_Fp_minv(x) {\r\n    return BigNatModule_FFT_Fp_mpowL(x, op_Subtraction(BigNatModule_FFT_primeP, fromBits(2, 0, false)));\r\n}\r\n\r\nexport function BigNatModule_FFT_computeFFT(lambda, mu, n, w, u, res, offset) {\r\n    let x_1, x_3, y_5;\r\n    if (n === 1) {\r\n        res[offset] = u[mu];\r\n    }\r\n    else {\r\n        const halfN = (~(~(n / 2))) | 0;\r\n        const ww = toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(w, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n        const offsetHalfN = (offset + halfN) | 0;\r\n        BigNatModule_FFT_computeFFT(lambda * 2, mu, halfN, ww, u, res, offset);\r\n        BigNatModule_FFT_computeFFT(lambda * 2, lambda + mu, halfN, ww, u, res, offsetHalfN);\r\n        let wj = BigNatModule_FFT_Fp_mone;\r\n        for (let j = 0; j <= (halfN - 1); j++) {\r\n            const even = res[offset + j];\r\n            const odd = res[offsetHalfN + j];\r\n            res[offset + j] = ((even + ((x_1 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_1, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0))) % BigNatModule_FFT_Fp_p);\r\n            res[offsetHalfN + j] = (((even + BigNatModule_FFT_Fp_p) - ((x_3 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_3, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0))) % BigNatModule_FFT_Fp_p);\r\n            wj = ((y_5 = wj, toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(y_5, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_FFT_computFftInPlace(n, w, u) {\r\n    const res = fill(new Uint32Array(n), 0, n, BigNatModule_FFT_Fp_mzero);\r\n    BigNatModule_FFT_computeFFT(1, 0, n, w, u, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function BigNatModule_FFT_computeInverseFftInPlace(n, w, uT) {\r\n    const bigKInv = BigNatModule_FFT_Fp_minv(n >>> 0);\r\n    return map((y) => (toInt(op_Modulus(op_Multiply(fromInteger(bigKInv, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0), BigNatModule_FFT_computFftInPlace(n, BigNatModule_FFT_Fp_minv(w), uT), Uint32Array);\r\n}\r\n\r\nexport const BigNatModule_FFT_maxTwoPower = 29;\r\n\r\nexport const BigNatModule_FFT_twoPowerTable = initialize(BigNatModule_FFT_maxTwoPower - 1, (i) => BigNatModule_FFT_pow32(2, i), Int32Array);\r\n\r\nexport function BigNatModule_FFT_computeFftPaddedPolynomialProduct(bigK, k, u, v) {\r\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(k);\r\n    const n = bigK | 0;\r\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u);\r\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v);\r\n    return BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\r\n        const x = uT[i];\r\n        const y = vT[i];\r\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n    }, Uint32Array));\r\n}\r\n\r\nexport function BigNatModule_FFT_padTo(n, u) {\r\n    const uBound = u.length | 0;\r\n    return initialize(n, (i) => ((i < uBound) ? BigNatModule_FFT_Fp_ofInt32(u[i]) : BigNatModule_FFT_Fp_mzero), Uint32Array);\r\n}\r\n\r\nexport function BigNatModule_FFT_computeFftPolynomialProduct(degu, u, degv, v) {\r\n    const patternInput = BigNatModule_FFT_leastBounding2Power((degu + degv) + 1);\r\n    const bigK = patternInput[0] | 0;\r\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(patternInput[1]);\r\n    const u_1 = BigNatModule_FFT_padTo(bigK, u);\r\n    const v_1 = BigNatModule_FFT_padTo(bigK, v);\r\n    const n = bigK | 0;\r\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u_1);\r\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v_1);\r\n    return map(BigNatModule_FFT_Fp_toInt, BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\r\n        const x = uT[i];\r\n        const y = vT[i];\r\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\r\n    }, Uint32Array)), Int32Array);\r\n}\r\n\r\nexport const BigNatModule_FFT_mzero = BigNatModule_FFT_Fp_mzero;\r\n\r\nexport const BigNatModule_FFT_mone = BigNatModule_FFT_Fp_mone;\r\n\r\nexport const BigNatModule_FFT_maxFp = ((BigNatModule_FFT_Fp_p + BigNatModule_FFT_Fp_p) - BigNatModule_FFT_mone) % BigNatModule_FFT_Fp_p;\r\n\r\nexport function BigNatModule_bound(n) {\r\n    return n.bound;\r\n}\r\n\r\nexport function BigNatModule_setBound(n, v) {\r\n    n.bound = (v | 0);\r\n}\r\n\r\nexport function BigNatModule_coeff(n, i) {\r\n    return n.digits[i];\r\n}\r\n\r\nexport function BigNatModule_coeff64(n, i) {\r\n    return fromInteger(BigNatModule_coeff(n, i), false, 2);\r\n}\r\n\r\nexport function BigNatModule_setCoeff(n, i, v) {\r\n    n.digits[i] = (v | 0);\r\n}\r\n\r\nexport function BigNatModule_pow64(x_mut, n_mut) {\r\n    BigNatModule_pow64:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return fromBits(1, 0, false);\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = op_Multiply(x, x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_pow64;\r\n        }\r\n        else {\r\n            return op_Multiply(x, BigNatModule_pow64(op_Multiply(x, x), ~(~(n / 2))));\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_pow32(x_mut, n_mut) {\r\n    BigNatModule_pow32:\r\n    while (true) {\r\n        const x = x_mut, n = n_mut;\r\n        if (n === 0) {\r\n            return 1;\r\n        }\r\n        else if ((n % 2) === 0) {\r\n            x_mut = (x * x);\r\n            n_mut = (~(~(n / 2)));\r\n            continue BigNatModule_pow32;\r\n        }\r\n        else {\r\n            return (x * BigNatModule_pow32(x * x, ~(~(n / 2)))) | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_hash(n) {\r\n    let res = 0;\r\n    for (let i = 0; i <= (n.bound - 1); i++) {\r\n        res = ((n.digits[i] + (res << 3)) | 0);\r\n    }\r\n    return res | 0;\r\n}\r\n\r\nexport function BigNatModule_maxInt(a, b) {\r\n    if (a < b) {\r\n        return b | 0;\r\n    }\r\n    else {\r\n        return a | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_minInt(a, b) {\r\n    if (a < b) {\r\n        return a | 0;\r\n    }\r\n    else {\r\n        return b | 0;\r\n    }\r\n}\r\n\r\nexport const BigNatModule_baseBits = 24;\r\n\r\nexport const BigNatModule_baseN = 16777216;\r\n\r\nexport const BigNatModule_baseMask = 16777215;\r\n\r\nexport const BigNatModule_baseNi64 = fromBits(16777216, 0, false);\r\n\r\nexport const BigNatModule_baseMaski64 = fromBits(16777215, 0, false);\r\n\r\nexport const BigNatModule_baseMaskU = fromBits(16777215, 0, true);\r\n\r\nexport const BigNatModule_baseMask32A = 16777215;\r\n\r\nexport const BigNatModule_baseMask32B = 255;\r\n\r\nexport const BigNatModule_baseShift32B = 24;\r\n\r\nexport const BigNatModule_baseMask64A = 16777215;\r\n\r\nexport const BigNatModule_baseMask64B = 16777215;\r\n\r\nexport const BigNatModule_baseMask64C = 65535;\r\n\r\nexport const BigNatModule_baseShift64B = 24;\r\n\r\nexport const BigNatModule_baseShift64C = 48;\r\n\r\nexport function BigNatModule_divbase(x) {\r\n    return ~(~((x >>> 0) >>> BigNatModule_baseBits));\r\n}\r\n\r\nexport function BigNatModule_modbase(x) {\r\n    return x & BigNatModule_baseMask;\r\n}\r\n\r\nexport function BigNatModule_createN(b) {\r\n    return new BigNat(b, new Int32Array(b));\r\n}\r\n\r\nexport function BigNatModule_copyN(x) {\r\n    return new BigNat(x.bound, copy(x.digits));\r\n}\r\n\r\nexport function BigNatModule_normN(n) {\r\n    const findLeastBound = (na_mut, i_mut) => {\r\n        findLeastBound:\r\n        while (true) {\r\n            const na = na_mut, i = i_mut;\r\n            if ((i === -1) ? true : (na[i] !== 0)) {\r\n                return (i + 1) | 0;\r\n            }\r\n            else {\r\n                na_mut = na;\r\n                i_mut = (i - 1);\r\n                continue findLeastBound;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const bound = findLeastBound(n.digits, n.bound - 1) | 0;\r\n    n.bound = (bound | 0);\r\n    return n;\r\n}\r\n\r\nexport const BigNatModule_boundInt = 2;\r\n\r\nexport const BigNatModule_boundInt64 = 3;\r\n\r\nexport const BigNatModule_boundBase = 1;\r\n\r\nexport function BigNatModule_embed(x) {\r\n    const x_1 = ((x < 0) ? 0 : x) | 0;\r\n    if (x_1 < BigNatModule_baseN) {\r\n        const r = BigNatModule_createN(1);\r\n        r.digits[0] = (x_1 | 0);\r\n        return BigNatModule_normN(r);\r\n    }\r\n    else {\r\n        const r_1 = BigNatModule_createN(BigNatModule_boundInt);\r\n        for (let i = 0; i <= (BigNatModule_boundInt - 1); i++) {\r\n            r_1.digits[i] = (((~(~(x_1 / BigNatModule_pow32(BigNatModule_baseN, i)))) % BigNatModule_baseN) | 0);\r\n        }\r\n        return BigNatModule_normN(r_1);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_embed64(x) {\r\n    const x_1 = (compare(x, fromBits(0, 0, false)) < 0) ? fromBits(0, 0, false) : x;\r\n    const r = BigNatModule_createN(BigNatModule_boundInt64);\r\n    for (let i = 0; i <= (BigNatModule_boundInt64 - 1); i++) {\r\n        r.digits[i] = ((~(~toInt(op_Modulus(op_Division(x_1, BigNatModule_pow64(BigNatModule_baseNi64, i)), BigNatModule_baseNi64)))) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_eval32(n) {\r\n    if (n.bound === 1) {\r\n        return n.digits[0] | 0;\r\n    }\r\n    else {\r\n        let acc = 0;\r\n        for (let i = n.bound - 1; i >= 0; i--) {\r\n            acc = ((n.digits[i] + (BigNatModule_baseN * acc)) | 0);\r\n        }\r\n        return acc | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_eval64(n) {\r\n    if (n.bound === 1) {\r\n        return fromInteger(n.digits[0], false, 2);\r\n    }\r\n    else {\r\n        let acc = fromBits(0, 0, false);\r\n        for (let i = n.bound - 1; i >= 0; i--) {\r\n            acc = op_Addition(fromInteger(n.digits[i], false, 2), op_Multiply(BigNatModule_baseNi64, acc));\r\n        }\r\n        return acc;\r\n    }\r\n}\r\n\r\nexport const BigNatModule_one = BigNatModule_embed(1);\r\n\r\nexport const BigNatModule_zero = BigNatModule_embed(0);\r\n\r\nexport function BigNatModule_restrictTo(d, n) {\r\n    return new BigNat(BigNatModule_minInt(d, n.bound), n.digits);\r\n}\r\n\r\nexport function BigNatModule_shiftUp(d, n) {\r\n    const m = BigNatModule_createN(n.bound + d);\r\n    for (let i = 0; i <= (n.bound - 1); i++) {\r\n        m.digits[i + d] = (n.digits[i] | 0);\r\n    }\r\n    return m;\r\n}\r\n\r\nexport function BigNatModule_shiftDown(d, n) {\r\n    if ((n.bound - d) <= 0) {\r\n        return BigNatModule_zero;\r\n    }\r\n    else {\r\n        const m = BigNatModule_createN(n.bound - d);\r\n        for (let i = 0; i <= (m.bound - 1); i++) {\r\n            m.digits[i] = (n.digits[i + d] | 0);\r\n        }\r\n        return m;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_degree(n) {\r\n    return n.bound - 1;\r\n}\r\n\r\nexport function BigNatModule_addP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\r\n    let z, i_1, z_1, i_2;\r\n    BigNatModule_addP:\r\n    while (true) {\r\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\r\n        if (i < n) {\r\n            const x = ((((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0))) + ((z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0)))) + c) | 0;\r\n            r.digits[i] = (BigNatModule_modbase(x) | 0);\r\n            i_mut = (i + 1);\r\n            n_mut = n;\r\n            c_mut = BigNatModule_divbase(x);\r\n            p_mut = p;\r\n            q_mut = q;\r\n            r_mut = r;\r\n            continue BigNatModule_addP;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_add(p, q) {\r\n    const rbound = (1 + BigNatModule_maxInt(p.bound, q.bound)) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    BigNatModule_addP(0, rbound, 0, p, q, r);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_subP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\r\n    let z, i_1, z_1, i_2;\r\n    BigNatModule_subP:\r\n    while (true) {\r\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\r\n        if (i < n) {\r\n            const x = ((((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0))) - ((z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0)))) + c) | 0;\r\n            if (x > 0) {\r\n                r.digits[i] = (BigNatModule_modbase(x) | 0);\r\n                i_mut = (i + 1);\r\n                n_mut = n;\r\n                c_mut = BigNatModule_divbase(x);\r\n                p_mut = p;\r\n                q_mut = q;\r\n                r_mut = r;\r\n                continue BigNatModule_subP;\r\n            }\r\n            else {\r\n                const x_1 = (x + BigNatModule_baseN) | 0;\r\n                r.digits[i] = (BigNatModule_modbase(x_1) | 0);\r\n                i_mut = (i + 1);\r\n                n_mut = n;\r\n                c_mut = (BigNatModule_divbase(x_1) - 1);\r\n                p_mut = p;\r\n                q_mut = q;\r\n                r_mut = r;\r\n                continue BigNatModule_subP;\r\n            }\r\n        }\r\n        else {\r\n            return c !== 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_sub(p, q) {\r\n    const rbound = BigNatModule_maxInt(p.bound, q.bound) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    if (BigNatModule_subP(0, rbound, 0, p, q, r)) {\r\n        return BigNatModule_embed(0);\r\n    }\r\n    else {\r\n        return BigNatModule_normN(r);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_isZero(p) {\r\n    return p.bound === 0;\r\n}\r\n\r\nexport function BigNatModule_IsZero(p) {\r\n    return BigNatModule_isZero(p);\r\n}\r\n\r\nexport function BigNatModule_isOne(p) {\r\n    if (p.bound === 1) {\r\n        return p.digits[0] === 1;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_equal(p, q) {\r\n    if (p.bound === q.bound) {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return true;\r\n                }\r\n                else if (pa[i] === qa[i]) {\r\n                    pa_mut = pa;\r\n                    qa_mut = qa;\r\n                    i_mut = (i - 1);\r\n                    continue check;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, p.bound - 1);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_shiftCompare(p, pn, q, qn) {\r\n    if ((p.bound + pn) < (q.bound + qn)) {\r\n        return -1;\r\n    }\r\n    else if ((p.bound + pn) > (q.bound + pn)) {\r\n        return 1;\r\n    }\r\n    else {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return 0;\r\n                }\r\n                else {\r\n                    const pai = ((i < pn) ? 0 : pa[i - pn]) | 0;\r\n                    const qai = ((i < qn) ? 0 : qa[i - qn]) | 0;\r\n                    if (pai === qai) {\r\n                        pa_mut = pa;\r\n                        qa_mut = qa;\r\n                        i_mut = (i - 1);\r\n                        continue check;\r\n                    }\r\n                    else if (pai < qai) {\r\n                        return -1;\r\n                    }\r\n                    else {\r\n                        return 1;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, (p.bound + pn) - 1) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_compare(p, q) {\r\n    if (p.bound < q.bound) {\r\n        return -1;\r\n    }\r\n    else if (p.bound > q.bound) {\r\n        return 1;\r\n    }\r\n    else {\r\n        const check = (pa_mut, qa_mut, i_mut) => {\r\n            check:\r\n            while (true) {\r\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\r\n                if (i === -1) {\r\n                    return 0;\r\n                }\r\n                else if (pa[i] === qa[i]) {\r\n                    pa_mut = pa;\r\n                    qa_mut = qa;\r\n                    i_mut = (i - 1);\r\n                    continue check;\r\n                }\r\n                else if (pa[i] < qa[i]) {\r\n                    return -1;\r\n                }\r\n                else {\r\n                    return 1;\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return check(p.digits, q.digits, p.bound - 1) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_lt(p, q) {\r\n    return BigNatModule_compare(p, q) === -1;\r\n}\r\n\r\nexport function BigNatModule_gt(p, q) {\r\n    return BigNatModule_compare(p, q) === 1;\r\n}\r\n\r\nexport function BigNatModule_lte(p, q) {\r\n    return BigNatModule_compare(p, q) !== 1;\r\n}\r\n\r\nexport function BigNatModule_gte(p, q) {\r\n    return BigNatModule_compare(p, q) !== -1;\r\n}\r\n\r\nexport function BigNatModule_min(a, b) {\r\n    if (BigNatModule_lt(a, b)) {\r\n        return a;\r\n    }\r\n    else {\r\n        return b;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_max(a, b) {\r\n    if (BigNatModule_lt(a, b)) {\r\n        return b;\r\n    }\r\n    else {\r\n        return a;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_contributeArr(a_mut, i_mut, c_mut) {\r\n    BigNatModule_contributeArr:\r\n    while (true) {\r\n        const a = a_mut, i = i_mut, c = c_mut;\r\n        const x = op_Addition(fromInteger(a[i], false, 2), c);\r\n        const c_1 = op_Division(x, BigNatModule_baseNi64);\r\n        const x_3 = (~(~toInt(op_BitwiseAnd(x, BigNatModule_baseMaski64)))) | 0;\r\n        a[i] = (x_3 | 0);\r\n        if (compare(c_1, fromBits(0, 0, false)) > 0) {\r\n            a_mut = a;\r\n            i_mut = (i + 1);\r\n            c_mut = c_1;\r\n            continue BigNatModule_contributeArr;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_scale(k, p) {\r\n    const r = BigNatModule_createN(p.bound + BigNatModule_boundInt);\r\n    const k_1 = fromInteger(k, false, 2);\r\n    for (let i = 0; i <= (p.bound - 1); i++) {\r\n        BigNatModule_contributeArr(r.digits, i, op_Multiply(k_1, fromInteger(p.digits[i], false, 2)));\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookBothSmall(p, q) {\r\n    const r = BigNatModule_createN(2);\r\n    const rak = op_Multiply(fromInteger(p, false, 2), fromInteger(q, false, 2));\r\n    BigNatModule_setCoeff(r, 0, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n    BigNatModule_setCoeff(r, 1, ~(~toInt(op_Division(rak, BigNatModule_baseNi64))));\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookCarry(r_mut, c_mut, k_mut) {\r\n    BigNatModule_mulSchoolBookCarry:\r\n    while (true) {\r\n        const r = r_mut, c = c_mut, k = k_mut;\r\n        if (compare(c, fromBits(0, 0, false)) > 0) {\r\n            const rak = op_Addition(BigNatModule_coeff64(r, k), c);\r\n            BigNatModule_setCoeff(r, k, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n            r_mut = r;\r\n            c_mut = op_Division(rak, BigNatModule_baseNi64);\r\n            k_mut = (k + 1);\r\n            continue BigNatModule_mulSchoolBookCarry;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookOneSmall(p, q) {\r\n    const bp = BigNatModule_bound(p) | 0;\r\n    const r = BigNatModule_createN(bp + 1);\r\n    const q_1 = fromInteger(q, false, 2);\r\n    let c = fromBits(0, 0, false);\r\n    for (let i = 0; i <= (bp - 1); i++) {\r\n        const rak = op_Addition(op_Addition(c, BigNatModule_coeff64(r, i)), op_Multiply(BigNatModule_coeff64(p, i), q_1));\r\n        BigNatModule_setCoeff(r, i, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\r\n        c = op_Division(rak, BigNatModule_baseNi64);\r\n    }\r\n    BigNatModule_mulSchoolBookCarry(r, c, bp);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBookNeitherSmall(p, q) {\r\n    const r = BigNatModule_createN(p.bound + q.bound);\r\n    const ra = r.digits;\r\n    for (let i = 0; i <= (p.bound - 1); i++) {\r\n        const pai = fromInteger(p.digits[i], false, 2);\r\n        let c = fromBits(0, 0, false);\r\n        let k = i;\r\n        for (let j = 0; j <= (q.bound - 1); j++) {\r\n            const qaj = fromInteger(q.digits[j], false, 2);\r\n            const rak = op_Addition(op_Addition(fromInteger(ra[k], false, 2), c), op_Multiply(pai, qaj));\r\n            ra[k] = ((~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64)))) | 0);\r\n            c = op_Division(rak, BigNatModule_baseNi64);\r\n            k = ((k + 1) | 0);\r\n        }\r\n        BigNatModule_mulSchoolBookCarry(r, c, k);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_mulSchoolBook(p, q) {\r\n    const pSmall = BigNatModule_bound(p) === 1;\r\n    const qSmall = BigNatModule_bound(q) === 1;\r\n    if (pSmall && qSmall) {\r\n        return BigNatModule_mulSchoolBookBothSmall(BigNatModule_coeff(p, 0), BigNatModule_coeff(q, 0));\r\n    }\r\n    else if (pSmall) {\r\n        return BigNatModule_mulSchoolBookOneSmall(q, BigNatModule_coeff(p, 0));\r\n    }\r\n    else if (qSmall) {\r\n        return BigNatModule_mulSchoolBookOneSmall(p, BigNatModule_coeff(q, 0));\r\n    }\r\n    else {\r\n        return BigNatModule_mulSchoolBookNeitherSmall(p, q);\r\n    }\r\n}\r\n\r\nexport class BigNatModule_encoding extends Record {\r\n    constructor(bigL, twoToBigL, k, bigK, bigN, split, splits) {\r\n        super();\r\n        this.bigL = (bigL | 0);\r\n        this.twoToBigL = (twoToBigL | 0);\r\n        this.k = (k | 0);\r\n        this.bigK = (bigK | 0);\r\n        this.bigN = (bigN | 0);\r\n        this.split = (split | 0);\r\n        this.splits = splits;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_encoding$reflection() {\r\n    return record_type(\"BigInt.BigNatModule.encoding\", [], BigNatModule_encoding, () => [[\"bigL\", int32_type], [\"twoToBigL\", int32_type], [\"k\", int32_type], [\"bigK\", int32_type], [\"bigN\", int32_type], [\"split\", int32_type], [\"splits\", array_type(int32_type)]]);\r\n}\r\n\r\nexport function BigNatModule_mkEncoding(bigL, k, bigK, bigN) {\r\n    return new BigNatModule_encoding(bigL, BigNatModule_pow32(2, bigL), k, bigK, bigN, ~(~(BigNatModule_baseBits / bigL)), initialize(~(~(BigNatModule_baseBits / bigL)), (i) => BigNatModule_pow32(2, bigL * i), Int32Array));\r\n}\r\n\r\nexport const BigNatModule_table = [BigNatModule_mkEncoding(1, 28, 268435456, 268435456), BigNatModule_mkEncoding(2, 26, 67108864, 134217728), BigNatModule_mkEncoding(3, 24, 16777216, 50331648), BigNatModule_mkEncoding(4, 22, 4194304, 16777216), BigNatModule_mkEncoding(5, 20, 1048576, 5242880), BigNatModule_mkEncoding(6, 18, 262144, 1572864), BigNatModule_mkEncoding(7, 16, 65536, 458752), BigNatModule_mkEncoding(8, 14, 16384, 131072), BigNatModule_mkEncoding(9, 12, 4096, 36864), BigNatModule_mkEncoding(10, 10, 1024, 10240), BigNatModule_mkEncoding(11, 8, 256, 2816), BigNatModule_mkEncoding(12, 6, 64, 768), BigNatModule_mkEncoding(13, 4, 16, 208)];\r\n\r\nexport function BigNatModule_calculateTableTow(bigL) {\r\n    const k = (BigNatModule_FFT_maxBitsInsideFp - (2 * bigL)) | 0;\r\n    const bigK = BigNatModule_pow64(fromBits(2, 0, false), k);\r\n    return [bigL, k, bigK, op_Multiply(bigK, fromInteger(bigL, false, 2))];\r\n}\r\n\r\nexport function BigNatModule_encodingGivenResultBits(bitsRes) {\r\n    const selectFrom = (i_mut) => {\r\n        selectFrom:\r\n        while (true) {\r\n            const i = i_mut;\r\n            if (((i + 1) < BigNatModule_table.length) && (bitsRes < BigNatModule_table[i + 1].bigN)) {\r\n                i_mut = (i + 1);\r\n                continue selectFrom;\r\n            }\r\n            else {\r\n                return BigNatModule_table[i];\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (bitsRes >= BigNatModule_table[0].bigN) {\r\n        throw (new Error(\"Product is huge, around 268435456 bits, beyond quickmul\"));\r\n    }\r\n    else {\r\n        return selectFrom(0);\r\n    }\r\n}\r\n\r\nexport const BigNatModule_bitmask = initialize(BigNatModule_baseBits, (i) => (BigNatModule_pow32(2, i) - 1), Int32Array);\r\n\r\nexport const BigNatModule_twopowers = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow32(2, i), Int32Array);\r\n\r\nexport const BigNatModule_twopowersI64 = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow64(fromBits(2, 0, false), i));\r\n\r\nexport function BigNatModule_wordBits(word) {\r\n    const hi = (k_mut) => {\r\n        hi:\r\n        while (true) {\r\n            const k = k_mut;\r\n            if (k === 0) {\r\n                return 0;\r\n            }\r\n            else if ((word & BigNatModule_twopowers[k - 1]) !== 0) {\r\n                return k | 0;\r\n            }\r\n            else {\r\n                k_mut = (k - 1);\r\n                continue hi;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return hi(BigNatModule_baseBits) | 0;\r\n}\r\n\r\nexport function BigNatModule_bits(u) {\r\n    if (u.bound === 0) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return ((BigNatModule_degree(u) * BigNatModule_baseBits) + BigNatModule_wordBits(u.digits[BigNatModule_degree(u)])) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_extractBits(n, enc, bi) {\r\n    let z, i, z_1, i_1, z_2, i_2;\r\n    const biw = (~(~(bi / BigNatModule_baseBits))) | 0;\r\n    const bjw = (~(~(((bi + enc.bigL) - 1) / BigNatModule_baseBits))) | 0;\r\n    if (biw !== bjw) {\r\n        const xbit = (bi % BigNatModule_baseBits) | 0;\r\n        return (((((z = n, (i = (biw | 0), (i < z.bound) ? z.digits[i] : 0))) >> xbit) | (((z_1 = n, (i_1 = (bjw | 0), (i_1 < z_1.bound) ? z_1.digits[i_1] : 0))) << (BigNatModule_baseBits - xbit))) & BigNatModule_bitmask[enc.bigL]) | 0;\r\n    }\r\n    else {\r\n        return ((((z_2 = n, (i_2 = (biw | 0), (i_2 < z_2.bound) ? z_2.digits[i_2] : 0))) >> (bi % BigNatModule_baseBits)) & BigNatModule_bitmask[enc.bigL]) | 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_encodePoly(enc, n) {\r\n    const poly = fill(new Uint32Array(enc.bigK), 0, enc.bigK, BigNatModule_FFT_Fp_ofInt32(0));\r\n    const biMax = (n.bound * BigNatModule_baseBits) | 0;\r\n    const encoder = (i_mut, bi_mut) => {\r\n        encoder:\r\n        while (true) {\r\n            const i = i_mut, bi = bi_mut;\r\n            if ((i === enc.bigK) ? true : (bi > biMax)) {\r\n            }\r\n            else {\r\n                const pi = BigNatModule_extractBits(n, enc, bi) | 0;\r\n                poly[i] = BigNatModule_FFT_Fp_ofInt32(pi);\r\n                i_mut = (i + 1);\r\n                bi_mut = (bi + enc.bigL);\r\n                continue encoder;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    encoder(0, 0);\r\n    return poly;\r\n}\r\n\r\nexport function BigNatModule_decodeResultBits(enc, poly) {\r\n    let n = 0;\r\n    for (let i = 0; i <= (poly.length - 1); i++) {\r\n        if (poly[i] !== BigNatModule_FFT_mzero) {\r\n            n = (i | 0);\r\n        }\r\n    }\r\n    return (((BigNatModule_FFT_maxBitsInsideFp + (enc.bigL * n)) + 1) + 1) | 0;\r\n}\r\n\r\nexport function BigNatModule_decodePoly(enc, poly) {\r\n    const rbound = ((~(~(BigNatModule_decodeResultBits(enc, poly) / BigNatModule_baseBits))) + 1) | 0;\r\n    const r = BigNatModule_createN(rbound);\r\n    const evaluate = (i_mut, j_mut, d_mut) => {\r\n        evaluate:\r\n        while (true) {\r\n            const i = i_mut, j = j_mut, d = d_mut;\r\n            if (i === enc.bigK) {\r\n            }\r\n            else {\r\n                if (j >= rbound) {\r\n                }\r\n                else {\r\n                    BigNatModule_contributeArr(r.digits, j, op_Multiply(fromInteger(BigNatModule_FFT_Fp_toInt(poly[i]), false, 2), BigNatModule_twopowersI64[d]));\r\n                }\r\n                const d_1 = (d + enc.bigL) | 0;\r\n                const patternInput = (d_1 >= BigNatModule_baseBits) ? [j + 1, d_1 - BigNatModule_baseBits] : [j, d_1];\r\n                i_mut = (i + 1);\r\n                j_mut = patternInput[0];\r\n                d_mut = patternInput[1];\r\n                continue evaluate;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    evaluate(0, 0, 0);\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_quickMulUsingFft(u, v) {\r\n    const enc = BigNatModule_encodingGivenResultBits(BigNatModule_bits(u) + BigNatModule_bits(v));\r\n    return BigNatModule_normN(BigNatModule_decodePoly(enc, BigNatModule_FFT_computeFftPaddedPolynomialProduct(enc.bigK, enc.k, BigNatModule_encodePoly(enc, u), BigNatModule_encodePoly(enc, v))));\r\n}\r\n\r\nexport const BigNatModule_minDigitsKaratsuba = 16;\r\n\r\nexport function BigNatModule_recMulKaratsuba(mul, p, q) {\r\n    const bmax = BigNatModule_maxInt(p.bound, q.bound) | 0;\r\n    if (bmax > BigNatModule_minDigitsKaratsuba) {\r\n        const k = (~(~(bmax / 2))) | 0;\r\n        const a0 = BigNatModule_restrictTo(k, p);\r\n        const a1 = BigNatModule_shiftDown(k, p);\r\n        const b0 = BigNatModule_restrictTo(k, q);\r\n        const b1 = BigNatModule_shiftDown(k, q);\r\n        const q0 = mul(a0, b0);\r\n        const q1 = mul(BigNatModule_add(a0, a1), BigNatModule_add(b0, b1));\r\n        const q2 = mul(a1, b1);\r\n        return BigNatModule_add(q0, BigNatModule_shiftUp(k, BigNatModule_add(BigNatModule_sub(q1, BigNatModule_add(q0, q2)), BigNatModule_shiftUp(k, q2))));\r\n    }\r\n    else {\r\n        return BigNatModule_mulSchoolBook(p, q);\r\n    }\r\n}\r\n\r\nexport function BigNatModule_mulKaratsuba(x, y) {\r\n    return BigNatModule_recMulKaratsuba(BigNatModule_mulKaratsuba, x, y);\r\n}\r\n\r\nexport const BigNatModule_productDigitsUpperSchoolBook = ~(~(64000 / BigNatModule_baseBits));\r\n\r\nexport const BigNatModule_singleDigitForceSchoolBook = ~(~(32000 / BigNatModule_baseBits));\r\n\r\nexport const BigNatModule_productDigitsUpperFft = ~(~(BigNatModule_table[0].bigN / BigNatModule_baseBits));\r\n\r\nexport function BigNatModule_mul(p, q) {\r\n    return BigNatModule_mulSchoolBook(p, q);\r\n}\r\n\r\nexport function BigNatModule_scaleSubInPlace(x, f, a, n) {\r\n    const patternInput = [x.digits, BigNatModule_degree(x)];\r\n    const x_1 = patternInput[0];\r\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\r\n    const ad = patternInput_1[1] | 0;\r\n    const a_1 = patternInput_1[0];\r\n    const f_1 = fromInteger(f, false, 2);\r\n    let j = 0;\r\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\r\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\r\n        if (j > patternInput[1]) {\r\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\r\n        }\r\n        let zLo = ~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)));\r\n        let zHi = op_Division(z, BigNatModule_baseNi64);\r\n        if (zLo <= x_1[j + n]) {\r\n            x_1[j + n] = ((x_1[j + n] - zLo) | 0);\r\n        }\r\n        else {\r\n            x_1[j + n] = ((x_1[j + n] + (BigNatModule_baseN - zLo)) | 0);\r\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\r\n        }\r\n        if (j < ad) {\r\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\r\n        }\r\n        else {\r\n            z = zHi;\r\n        }\r\n        j = ((j + 1) | 0);\r\n    }\r\n    BigNatModule_normN(x);\r\n}\r\n\r\nexport function BigNatModule_scaleSub(x, f, a, n) {\r\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\r\n    BigNatModule_scaleSubInPlace(freshx, f, a, n);\r\n    return BigNatModule_normN(freshx);\r\n}\r\n\r\nexport function BigNatModule_scaleAddInPlace(x, f, a, n) {\r\n    const patternInput = [x.digits, BigNatModule_degree(x)];\r\n    const x_1 = patternInput[0];\r\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\r\n    const ad = patternInput_1[1] | 0;\r\n    const a_1 = patternInput_1[0];\r\n    const f_1 = fromInteger(f, false, 2);\r\n    let j = 0;\r\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\r\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\r\n        if (j > patternInput[1]) {\r\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\r\n        }\r\n        let zLo = ~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)));\r\n        let zHi = op_Division(z, BigNatModule_baseNi64);\r\n        if (zLo < (BigNatModule_baseN - x_1[j + n])) {\r\n            x_1[j + n] = ((x_1[j + n] + zLo) | 0);\r\n        }\r\n        else {\r\n            x_1[j + n] = ((zLo - (BigNatModule_baseN - x_1[j + n])) | 0);\r\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\r\n        }\r\n        if (j < ad) {\r\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\r\n        }\r\n        else {\r\n            z = zHi;\r\n        }\r\n        j = ((j + 1) | 0);\r\n    }\r\n    BigNatModule_normN(x);\r\n}\r\n\r\nexport function BigNatModule_scaleAdd(x, f, a, n) {\r\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\r\n    BigNatModule_scaleAddInPlace(freshx, f, a, n);\r\n    return BigNatModule_normN(freshx);\r\n}\r\n\r\nexport function BigNatModule_removeFactor(x, a, n) {\r\n    const patternInput = [BigNatModule_degree(a), BigNatModule_degree(x)];\r\n    const degx = patternInput[1] | 0;\r\n    const dega = patternInput[0] | 0;\r\n    if (degx < (dega + n)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        const patternInput_1 = [a.digits, x.digits];\r\n        const xa = patternInput_1[1];\r\n        const aa = patternInput_1[0];\r\n        const f = ((dega === 0) ? ((degx === n) ? (~(~(xa[n] / aa[0]))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), fromInteger(aa[0], false, 2)))))) : ((degx === (dega + n)) ? (~(~(xa[degx] / (aa[dega] + 1)))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), op_Addition(fromInteger(aa[dega], false, 2), fromBits(1, 0, false)))))))) | 0;\r\n        if (f === 0) {\r\n            if (BigNatModule_shiftCompare(a, n, x, 0) !== 1) {\r\n                return 1;\r\n            }\r\n            else {\r\n                return 0;\r\n            }\r\n        }\r\n        else {\r\n            return f | 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_divmod(b, a) {\r\n    if (BigNatModule_isZero(a)) {\r\n        throw (new Error());\r\n    }\r\n    else if (BigNatModule_degree(b) < BigNatModule_degree(a)) {\r\n        return [BigNatModule_zero, b];\r\n    }\r\n    else {\r\n        const x = BigNatModule_copyN(b);\r\n        const d = BigNatModule_createN(((BigNatModule_degree(b) - BigNatModule_degree(a)) + 1) + 1);\r\n        let p = BigNatModule_degree(b);\r\n        const m = BigNatModule_degree(a) | 0;\r\n        let n = p - m;\r\n        const Invariant = (tupledArg) => {\r\n        };\r\n        let finished = false;\r\n        while (!finished) {\r\n            Invariant([d, x, n, p]);\r\n            const f = BigNatModule_removeFactor(x, a, n) | 0;\r\n            if (f > 0) {\r\n                BigNatModule_scaleSubInPlace(x, f, a, n);\r\n                BigNatModule_scaleAddInPlace(d, f, BigNatModule_one, n);\r\n                Invariant([d, x, n, p]);\r\n            }\r\n            else {\r\n                finished = ((f === 0) && (n === 0));\r\n                if (!finished) {\r\n                    if (p === (m + n)) {\r\n                        Invariant([d, x, n - 1, p]);\r\n                        n = ((n - 1) | 0);\r\n                    }\r\n                    else {\r\n                        Invariant([d, x, n - 1, p - 1]);\r\n                        n = ((n - 1) | 0);\r\n                        p = ((p - 1) | 0);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return [BigNatModule_normN(d), BigNatModule_normN(x)];\r\n    }\r\n}\r\n\r\nexport function BigNatModule_div(b, a) {\r\n    return BigNatModule_divmod(b, a)[0];\r\n}\r\n\r\nexport function BigNatModule_rem(b, a) {\r\n    return BigNatModule_divmod(b, a)[1];\r\n}\r\n\r\nexport function BigNatModule_bitAnd(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_minInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (r.bound - 1); i++) {\r\n        r.digits[i] = ((a.digits[i] & b.digits[i]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_bitOr(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (a.bound - 1); i++) {\r\n        r.digits[i] = ((r.digits[i] | a.digits[i]) | 0);\r\n    }\r\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\r\n        r.digits[i_1] = ((r.digits[i_1] | b.digits[i_1]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_bitXor(a, b) {\r\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\r\n    for (let i = 0; i <= (a.bound - 1); i++) {\r\n        r.digits[i] = ((r.digits[i] ^ a.digits[i]) | 0);\r\n    }\r\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\r\n        r.digits[i_1] = ((r.digits[i_1] ^ b.digits[i_1]) | 0);\r\n    }\r\n    return BigNatModule_normN(r);\r\n}\r\n\r\nexport function BigNatModule_hcf(a, b) {\r\n    const hcfloop = (a_1_mut, b_1_mut) => {\r\n        hcfloop:\r\n        while (true) {\r\n            const a_1 = a_1_mut, b_1 = b_1_mut;\r\n            if (BigNatModule_equal(BigNatModule_zero, a_1)) {\r\n                return b_1;\r\n            }\r\n            else {\r\n                a_1_mut = BigNatModule_divmod(b_1, a_1)[1];\r\n                b_1_mut = a_1;\r\n                continue hcfloop;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    if (BigNatModule_lt(a, b)) {\r\n        return hcfloop(a, b);\r\n    }\r\n    else {\r\n        return hcfloop(b, a);\r\n    }\r\n}\r\n\r\nexport const BigNatModule_two = BigNatModule_embed(2);\r\n\r\nexport function BigNatModule_powi(x, n) {\r\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\r\n        power:\r\n        while (true) {\r\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\r\n            if (n_1 === 0) {\r\n                return acc;\r\n            }\r\n            else if ((n_1 % 2) === 0) {\r\n                acc_mut = acc;\r\n                x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                n_1_mut = (~(~(n_1 / 2)));\r\n                continue power;\r\n            }\r\n            else {\r\n                acc_mut = BigNatModule_mul(x_1, acc);\r\n                x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                n_1_mut = (~(~(n_1 / 2)));\r\n                continue power;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return power(BigNatModule_one, x, n);\r\n}\r\n\r\nexport function BigNatModule_pow(x, n) {\r\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\r\n        power:\r\n        while (true) {\r\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\r\n            if (BigNatModule_isZero(n_1)) {\r\n                return acc;\r\n            }\r\n            else {\r\n                const patternInput = BigNatModule_divmod(n_1, BigNatModule_two);\r\n                const ndiv2 = patternInput[0];\r\n                if (BigNatModule_isZero(patternInput[1])) {\r\n                    acc_mut = acc;\r\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                    n_1_mut = ndiv2;\r\n                    continue power;\r\n                }\r\n                else {\r\n                    acc_mut = BigNatModule_mul(x_1, acc);\r\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\r\n                    n_1_mut = ndiv2;\r\n                    continue power;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return power(BigNatModule_one, x, n);\r\n}\r\n\r\nexport function BigNatModule_toFloat(n) {\r\n    const evalFloat = (acc_mut, k_mut, i_mut) => {\r\n        evalFloat:\r\n        while (true) {\r\n            const acc = acc_mut, k = k_mut, i = i_mut;\r\n            if (i === n.bound) {\r\n                return acc;\r\n            }\r\n            else {\r\n                acc_mut = (acc + (k * n.digits[i]));\r\n                k_mut = (k * BigNatModule_baseN);\r\n                i_mut = (i + 1);\r\n                continue evalFloat;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return evalFloat(0, 1, 0);\r\n}\r\n\r\nexport function BigNatModule_ofInt32(n) {\r\n    return BigNatModule_embed(n);\r\n}\r\n\r\nexport function BigNatModule_ofInt64(n) {\r\n    return BigNatModule_embed64(n);\r\n}\r\n\r\nexport function BigNatModule_toUInt32(n) {\r\n    const matchValue = n.bound | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return 0;\r\n        }\r\n        case 1: {\r\n            const value = n.digits[0] | 0;\r\n            return value >>> 0;\r\n        }\r\n        case 2: {\r\n            const patternInput = [n.digits[0], n.digits[1]];\r\n            const xB = patternInput[1] | 0;\r\n            if (xB > BigNatModule_baseMask32B) {\r\n                throw (new Error());\r\n            }\r\n            return ((patternInput[0] & BigNatModule_baseMask32A) >>> 0) + ((((xB & BigNatModule_baseMask32B) >>> 0) << BigNatModule_baseShift32B) >>> 0);\r\n        }\r\n        default: {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_toUInt64(n) {\r\n    const matchValue = n.bound | 0;\r\n    switch (matchValue) {\r\n        case 0: {\r\n            return fromBits(0, 0, true);\r\n        }\r\n        case 1: {\r\n            return fromInteger(n.digits[0], true, 2);\r\n        }\r\n        case 2: {\r\n            const patternInput = [n.digits[0], n.digits[1]];\r\n            return op_Addition(fromInteger(patternInput[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B));\r\n        }\r\n        case 3: {\r\n            const patternInput_1 = [n.digits[0], n.digits[1], n.digits[2]];\r\n            const xC = patternInput_1[2] | 0;\r\n            if (xC > BigNatModule_baseMask64C) {\r\n                throw (new Error());\r\n            }\r\n            return op_Addition(op_Addition(fromInteger(patternInput_1[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput_1[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B)), op_LeftShift(fromInteger(xC & BigNatModule_baseMask64C, true, 2), BigNatModule_baseShift64C));\r\n        }\r\n        default: {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigNatModule_toString(n) {\r\n    const degn = BigNatModule_degree(n) | 0;\r\n    const route = (prior_mut, k_mut, ten2k_mut) => {\r\n        route:\r\n        while (true) {\r\n            const prior = prior_mut, k = k_mut, ten2k = ten2k_mut;\r\n            if (BigNatModule_degree(ten2k) > degn) {\r\n                return cons([k, ten2k], prior);\r\n            }\r\n            else {\r\n                prior_mut = cons([k, ten2k], prior);\r\n                k_mut = (k + 1);\r\n                ten2k_mut = BigNatModule_mul(ten2k, ten2k);\r\n                continue route;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const collect = (isLeading_mut, digits_mut, n_1_mut, _arg1_mut) => {\r\n        collect:\r\n        while (true) {\r\n            const isLeading = isLeading_mut, digits = digits_mut, n_1 = n_1_mut, _arg1 = _arg1_mut;\r\n            if (!isEmpty(_arg1)) {\r\n                const prior_1 = tail(_arg1);\r\n                const patternInput = BigNatModule_divmod(n_1, head(_arg1)[1]);\r\n                const nL = patternInput[1];\r\n                const nH = patternInput[0];\r\n                if (isLeading && BigNatModule_isZero(nH)) {\r\n                    isLeading_mut = isLeading;\r\n                    digits_mut = digits;\r\n                    n_1_mut = nL;\r\n                    _arg1_mut = prior_1;\r\n                    continue collect;\r\n                }\r\n                else {\r\n                    isLeading_mut = isLeading;\r\n                    digits_mut = collect(false, digits, nL, prior_1);\r\n                    n_1_mut = nH;\r\n                    _arg1_mut = prior_1;\r\n                    continue collect;\r\n                }\r\n            }\r\n            else {\r\n                const n_2 = BigNatModule_eval32(n_1) | 0;\r\n                if (isLeading && (n_2 === 0)) {\r\n                    return digits;\r\n                }\r\n                else {\r\n                    return cons(int32ToString(n_2), digits);\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    const digits_4 = collect(true, empty(), n, route(empty(), 0, BigNatModule_embed(10)));\r\n    if (isEmpty(digits_4)) {\r\n        return \"0\";\r\n    }\r\n    else {\r\n        return join(\"\", toArray(digits_4));\r\n    }\r\n}\r\n\r\nexport function BigNatModule_ofString(str) {\r\n    const len = str.length | 0;\r\n    if (isNullOrEmpty(str)) {\r\n        throw (new Error(\"empty string\\\\nParameter name: str\"));\r\n    }\r\n    const ten = BigNatModule_embed(10);\r\n    const build = (acc_mut, i_mut) => {\r\n        build:\r\n        while (true) {\r\n            const acc = acc_mut, i = i_mut;\r\n            if (i === len) {\r\n                return acc;\r\n            }\r\n            else {\r\n                const c = str[i];\r\n                const d = (c.charCodeAt(0) - 48) | 0;\r\n                if ((0 <= d) && (d <= 9)) {\r\n                    acc_mut = BigNatModule_add(BigNatModule_mul(ten, acc), BigNatModule_embed(d));\r\n                    i_mut = (i + 1);\r\n                    continue build;\r\n                }\r\n                else {\r\n                    throw (new Error());\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return build(BigNatModule_embed(0), 0);\r\n}\r\n\r\nexport function BigNatModule_isSmall(n) {\r\n    return n.bound <= 1;\r\n}\r\n\r\nexport function BigNatModule_getSmall(n) {\r\n    const z = n;\r\n    const i = 0;\r\n    if (i < z.bound) {\r\n        return z.digits[i] | 0;\r\n    }\r\n    else {\r\n        return 0;\r\n    }\r\n}\r\n\r\nexport function BigNatModule_factorial(n) {\r\n    const productR = (a, b) => {\r\n        if (BigNatModule_equal(a, b)) {\r\n            return a;\r\n        }\r\n        else {\r\n            const m = BigNatModule_div(BigNatModule_add(a, b), BigNatModule_ofInt32(2));\r\n            return BigNatModule_mul(productR(a, m), productR(BigNatModule_add(m, BigNatModule_one), b));\r\n        }\r\n    };\r\n    return productR(BigNatModule_one, n);\r\n}\r\n\r\n","import { BigNatModule_factorial, BigNatModule_ofString, BigNatModule_toFloat, BigNatModule_toUInt64, BigNatModule_toUInt32, BigNatModule_pow, BigNatModule_two, BigNatModule_rem, BigNatModule_lte, BigNatModule_hcf, BigNatModule_bitXor, BigNatModule_bitOr, BigNatModule_bitAnd, BigNatModule_divmod, BigNatModule_mul, BigNatModule_isOne, BigNatModule_sub, BigNatModule_gte, BigNatModule_scale, BigNatModule_one, BigNatModule_add, BigNatModule_ofInt64, BigNatModule_hash, BigNatModule_gt, BigNatModule_lt, BigNatModule_equal, BigNatModule_getSmall, BigNatModule_isSmall, BigNatModule_ofInt32, BigNatModule_toString, BigNatModule_isZero } from \"./n.js\";\r\nimport { Record, toString } from \"../Types.js\";\r\nimport { class_type } from \"../Reflection.js\";\r\nimport { initialize } from \"../Array.js\";\r\nimport { op_Addition, op_Multiply, fromValue, equals, fromBits, compare, fromInteger, op_UnaryNegation } from \"../Long.js\";\r\nimport { op_UnaryNegation_Int32 } from \"../Int32.js\";\r\nimport Decimal from \"../Decimal.js\";\r\n\r\nexport class BigInteger extends Record {\r\n    constructor(signInt, v) {\r\n        super();\r\n        this.signInt = (signInt | 0);\r\n        this.v = v;\r\n    }\r\n    toString() {\r\n        const x = this;\r\n        const matchValue = BigInteger__get_SignInt(x) | 0;\r\n        switch (matchValue) {\r\n            case -1: {\r\n                return BigNatModule_isZero(BigInteger__get_V(x)) ? \"0\" : (\"-\" + BigNatModule_toString(BigInteger__get_V(x)));\r\n            }\r\n            case 0: {\r\n                return \"0\";\r\n            }\r\n            case 1: {\r\n                return BigNatModule_toString(BigInteger__get_V(x));\r\n            }\r\n            default: {\r\n                throw (new Error(\"signs should be +/- 1 or 0\"));\r\n            }\r\n        }\r\n    }\r\n    Equals(obj) {\r\n        const this$ = this;\r\n        return (obj instanceof BigInteger) && BigInteger_op_Equality_56F059C0(this$, obj);\r\n    }\r\n    GetHashCode() {\r\n        const x = this;\r\n        return BigInteger_hash_Z665282C2(x) | 0;\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return toString(this$);\r\n    }\r\n    CompareTo(obj) {\r\n        const this$ = this;\r\n        if (obj instanceof BigInteger) {\r\n            return BigInteger_compare_56F059C0(this$, obj) | 0;\r\n        }\r\n        else {\r\n            throw (new Error(\"the objects are not comparable\\\\nParameter name: obj\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger$reflection() {\r\n    return class_type(\"BigInt.BigInteger\", void 0, BigInteger, class_type(\"System.ValueType\"));\r\n}\r\n\r\nexport function BigInteger_$ctor_Z2BE94A1(signInt, v) {\r\n    return new BigInteger(signInt, v);\r\n}\r\n\r\n(() => {\r\n    BigInteger.smallLim = 4096;\r\n    BigInteger.smallPosTab = initialize(BigInteger.smallLim, BigNatModule_ofInt32);\r\n    BigInteger.one = BigInteger_$ctor_Z524259A4(1);\r\n    BigInteger.two = BigInteger_$ctor_Z524259A4(2);\r\n    BigInteger.zero = BigInteger_$ctor_Z524259A4(0);\r\n})();\r\n\r\nexport function BigInteger_nat_Z67CCE57D(n) {\r\n    if (BigNatModule_isSmall(n) && (BigNatModule_getSmall(n) < BigInteger.smallLim)) {\r\n        return BigInteger.smallPosTab[BigNatModule_getSmall(n)];\r\n    }\r\n    else {\r\n        return n;\r\n    }\r\n}\r\n\r\nexport function BigInteger_create_Z2BE94A1(s, n) {\r\n    return BigInteger_$ctor_Z2BE94A1(s, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger_posn_Z67CCE57D(n) {\r\n    return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger_negn_Z67CCE57D(n) {\r\n    return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(n));\r\n}\r\n\r\nexport function BigInteger__get_Sign(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return x.signInt | 0;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_SignInt(x) {\r\n    return x.signInt;\r\n}\r\n\r\nexport function BigInteger__get_V(x) {\r\n    return x.v;\r\n}\r\n\r\nexport function BigInteger_op_Equality_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 2: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 3: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 6: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 7: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 8: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Inequality_56F059C0(x, y) {\r\n    return !BigInteger_op_Equality_56F059C0(x, y);\r\n}\r\n\r\nexport function BigInteger_op_LessThan_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_lt(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_lt(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            return false;\r\n        }\r\n        case 3: {\r\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return true;\r\n            }\r\n            else {\r\n                return !BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n        }\r\n        case 4: {\r\n            return false;\r\n        }\r\n        case 5: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 6: {\r\n            return false;\r\n        }\r\n        case 7: {\r\n            return false;\r\n        }\r\n        case 8: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_GreaterThan_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_gt(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_gt(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return true;\r\n            }\r\n            else {\r\n                return !BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n        }\r\n        case 3: {\r\n            return false;\r\n        }\r\n        case 4: {\r\n            return false;\r\n        }\r\n        case 5: {\r\n            return false;\r\n        }\r\n        case 6: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 7: {\r\n            return !BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 8: {\r\n            return false;\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_compare_56F059C0(n, nn) {\r\n    if (BigInteger_op_LessThan_56F059C0(n, nn)) {\r\n        return -1;\r\n    }\r\n    else if (BigInteger_op_Equality_56F059C0(n, nn)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return 1;\r\n    }\r\n}\r\n\r\nexport function BigInteger_hash_Z665282C2(z) {\r\n    if (BigInteger__get_SignInt(z) === 0) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return (BigInteger__get_SignInt(z) + BigNatModule_hash(BigInteger__get_V(z))) | 0;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_StructuredDisplayString(x) {\r\n    return toString(x);\r\n}\r\n\r\nexport function BigInteger_$ctor_Z524259A4(n) {\r\n    if (n >= 0) {\r\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(n)));\r\n    }\r\n    else if (n === -2147483648) {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(fromInteger(n, false, 2)))));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(op_UnaryNegation_Int32(n))));\r\n    }\r\n}\r\n\r\nexport function BigInteger_$ctor_Z524259C1(n) {\r\n    if (compare(n, fromBits(0, 0, false)) >= 0) {\r\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(n)));\r\n    }\r\n    else if (equals(n, fromBits(0, 2147483648, false))) {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_add(BigNatModule_ofInt64(fromBits(4294967295, 2147483647, false)), BigNatModule_one)));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(n))));\r\n    }\r\n}\r\n\r\nexport function BigInteger_get_One() {\r\n    return BigInteger.one;\r\n}\r\n\r\nexport function BigInteger_get_Two() {\r\n    return BigInteger.two;\r\n}\r\n\r\nexport function BigInteger_get_Zero() {\r\n    return BigInteger.zero;\r\n}\r\n\r\nexport function BigInteger_op_UnaryNegation_Z665282C2(z) {\r\n    const matchValue = BigInteger__get_SignInt(z) | 0;\r\n    if (matchValue === 0) {\r\n        return BigInteger_get_Zero();\r\n    }\r\n    else {\r\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(matchValue), BigInteger__get_V(z));\r\n    }\r\n}\r\n\r\nexport function BigInteger_Scale_Z320F31E(k, z) {\r\n    if (BigInteger__get_SignInt(z) === 0) {\r\n        return BigInteger_get_Zero();\r\n    }\r\n    else if (k < 0) {\r\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(BigInteger__get_SignInt(z)), BigNatModule_scale(op_UnaryNegation_Int32(k), BigInteger__get_V(z)));\r\n    }\r\n    else {\r\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(z), BigNatModule_scale(k, BigInteger__get_V(z)));\r\n    }\r\n}\r\n\r\nexport function BigInteger_subnn_6A57060(nx, ny) {\r\n    if (BigNatModule_gte(nx, ny)) {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_sub(nx, ny));\r\n    }\r\n    else {\r\n        return BigInteger_negn_Z67CCE57D(BigNatModule_sub(ny, nx));\r\n    }\r\n}\r\n\r\nexport function BigInteger_addnn_6A57060(nx, ny) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_add(nx, ny));\r\n}\r\n\r\nexport function BigInteger__get_IsZero(x) {\r\n    if (BigInteger__get_SignInt(x) === 0) {\r\n        return true;\r\n    }\r\n    else {\r\n        return BigNatModule_isZero(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsOne(x) {\r\n    if (BigInteger__get_SignInt(x) === 1) {\r\n        return BigNatModule_isOne(BigInteger__get_V(x));\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Addition_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(x)) {\r\n        return y;\r\n    }\r\n    else {\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 1: {\r\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n            }\r\n            case 2: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 3: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Subtraction_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(x)) {\r\n        return BigInteger_op_UnaryNegation_Z665282C2(y);\r\n    }\r\n    else {\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 1: {\r\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\r\n            }\r\n            case 2: {\r\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\r\n            }\r\n            case 3: {\r\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Multiply_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return x;\r\n    }\r\n    else if (BigInteger__get_IsZero(y)) {\r\n        return y;\r\n    }\r\n    else if (BigInteger__get_IsOne(x)) {\r\n        return y;\r\n    }\r\n    else if (BigInteger__get_IsOne(y)) {\r\n        return x;\r\n    }\r\n    else {\r\n        const m = BigNatModule_mul(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(x) * BigInteger__get_SignInt(y), m);\r\n    }\r\n}\r\n\r\nexport function BigInteger_DivRem_56F059C0(x, y) {\r\n    if (BigInteger__get_IsZero(y)) {\r\n        throw (new Error());\r\n    }\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return [BigInteger_get_Zero(), BigInteger_get_Zero()];\r\n    }\r\n    else {\r\n        const patternInput = BigNatModule_divmod(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        const r = patternInput[1];\r\n        const d = patternInput[0];\r\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n        let pattern_matching_result;\r\n        if (matchValue[0] === -1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 1;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 3;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else if (matchValue[0] === 1) {\r\n            if (matchValue[1] === -1) {\r\n                pattern_matching_result = 2;\r\n            }\r\n            else if (matchValue[1] === 1) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 4;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 4;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\r\n            }\r\n            case 1: {\r\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\r\n            }\r\n            case 2: {\r\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\r\n            }\r\n            case 3: {\r\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\r\n            }\r\n            case 4: {\r\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_Division_56F059C0(x, y) {\r\n    return BigInteger_DivRem_56F059C0(x, y)[0];\r\n}\r\n\r\nexport function BigInteger_op_Modulus_56F059C0(x, y) {\r\n    return BigInteger_DivRem_56F059C0(x, y)[1];\r\n}\r\n\r\nexport function BigInteger_op_RightShift_62E082A2(x, y) {\r\n    return BigInteger_op_Division_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\r\n}\r\n\r\nexport function BigInteger_op_LeftShift_62E082A2(x, y) {\r\n    return BigInteger_op_Multiply_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\r\n}\r\n\r\nexport function BigInteger_op_BitwiseAnd_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitAnd(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_op_BitwiseOr_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitOr(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_op_ExclusiveOr_56F059C0(x, y) {\r\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitXor(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n}\r\n\r\nexport function BigInteger_GreatestCommonDivisor_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    if (matchValue[0] === 0) {\r\n        if (matchValue[1] === 0) {\r\n            return BigInteger_get_Zero();\r\n        }\r\n        else {\r\n            return BigInteger_posn_Z67CCE57D(BigInteger__get_V(y));\r\n        }\r\n    }\r\n    else if (matchValue[1] === 0) {\r\n        return BigInteger_posn_Z67CCE57D(BigInteger__get_V(x));\r\n    }\r\n    else {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_hcf(BigInteger__get_V(x), BigInteger__get_V(y)));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsNegative(x) {\r\n    if (BigInteger__get_SignInt(x) === -1) {\r\n        return !BigInteger__get_IsZero(x);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsPositive(x) {\r\n    if (BigInteger__get_SignInt(x) === 1) {\r\n        return !BigInteger__get_IsZero(x);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function BigInteger_Abs_Z665282C2(x) {\r\n    if (BigInteger__get_SignInt(x) === -1) {\r\n        return BigInteger_op_UnaryNegation_Z665282C2(x);\r\n    }\r\n    else {\r\n        return x;\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_LessThanOrEqual_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_lte(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_lte(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 3: {\r\n            return true;\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 6: {\r\n            return true;\r\n        }\r\n        case 7: {\r\n            return true;\r\n        }\r\n        case 8: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_GreaterThanOrEqual_56F059C0(x, y) {\r\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] === -1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 1;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 6;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 8;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 4;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 7;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else if (matchValue[0] === 1) {\r\n        if (matchValue[1] === -1) {\r\n            pattern_matching_result = 2;\r\n        }\r\n        else if (matchValue[1] === 0) {\r\n            pattern_matching_result = 5;\r\n        }\r\n        else if (matchValue[1] === 1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 9;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 9;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return BigNatModule_gte(BigInteger__get_V(x), BigInteger__get_V(y));\r\n        }\r\n        case 1: {\r\n            return BigNatModule_gte(BigInteger__get_V(y), BigInteger__get_V(x));\r\n        }\r\n        case 2: {\r\n            return true;\r\n        }\r\n        case 3: {\r\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\r\n                return BigNatModule_isZero(BigInteger__get_V(y));\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }\r\n        case 4: {\r\n            return true;\r\n        }\r\n        case 5: {\r\n            return true;\r\n        }\r\n        case 6: {\r\n            return BigNatModule_isZero(BigInteger__get_V(x));\r\n        }\r\n        case 7: {\r\n            return BigNatModule_isZero(BigInteger__get_V(y));\r\n        }\r\n        case 8: {\r\n            return true;\r\n        }\r\n        case 9: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger_Pow_62E082A2(x, y) {\r\n    if (y < 0) {\r\n        throw (new Error(\"y\"));\r\n    }\r\n    const matchValue = [BigInteger__get_IsZero(x), y];\r\n    if (matchValue[0]) {\r\n        if (matchValue[1] === 0) {\r\n            return BigInteger_get_One();\r\n        }\r\n        else {\r\n            return BigInteger_get_Zero();\r\n        }\r\n    }\r\n    else {\r\n        const yval = BigInteger_$ctor_Z524259A4(y);\r\n        return BigInteger_create_Z2BE94A1(BigNatModule_isZero(BigNatModule_rem(BigInteger__get_V(yval), BigNatModule_two)) ? 1 : BigInteger__get_SignInt(x), BigNatModule_pow(BigInteger__get_V(x), BigInteger__get_V(yval)));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToInt32(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        const u = BigNatModule_toUInt32(BigInteger__get_V(x));\r\n        if (u <= (2147483647 >>> 0)) {\r\n            return (BigInteger__get_SignInt(x) * (~(~u))) | 0;\r\n        }\r\n        else if ((BigInteger__get_SignInt(x) === -1) && (u === ((2147483647 + 1) >>> 0))) {\r\n            return -2147483648;\r\n        }\r\n        else {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToUInt32(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return 0;\r\n    }\r\n    else {\r\n        return BigNatModule_toUInt32(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToInt64(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return fromBits(0, 0, false);\r\n    }\r\n    else {\r\n        const u = BigNatModule_toUInt64(BigInteger__get_V(x));\r\n        if (compare(u, fromValue(fromBits(4294967295, 2147483647, false), true)) <= 0) {\r\n            return op_Multiply(fromInteger(BigInteger__get_SignInt(x), false, 2), fromValue(u, false));\r\n        }\r\n        else if ((BigInteger__get_SignInt(x) === -1) && equals(u, fromValue(op_Addition(fromBits(4294967295, 2147483647, false), fromBits(1, 0, false)), true))) {\r\n            return fromBits(0, 2147483648, false);\r\n        }\r\n        else {\r\n            throw (new Error());\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToUInt64(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return fromBits(0, 0, true);\r\n    }\r\n    else {\r\n        return BigNatModule_toUInt64(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToDouble(x) {\r\n    const matchValue = BigInteger__get_SignInt(x) | 0;\r\n    switch (matchValue) {\r\n        case -1: {\r\n            return -BigNatModule_toFloat(BigInteger__get_V(x));\r\n        }\r\n        case 0: {\r\n            return 0;\r\n        }\r\n        case 1: {\r\n            return BigNatModule_toFloat(BigInteger__get_V(x));\r\n        }\r\n        default: {\r\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\r\n        }\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_ToSByte(x) {\r\n    return (BigInteger__get_ToInt32(x) + 0x80 & 0xFF) - 0x80;\r\n}\r\n\r\nexport function BigInteger__get_ToByte(x) {\r\n    return BigInteger__get_ToUInt32(x) & 0xFF;\r\n}\r\n\r\nexport function BigInteger__get_ToInt16(x) {\r\n    return (BigInteger__get_ToInt32(x) + 0x8000 & 0xFFFF) - 0x8000;\r\n}\r\n\r\nexport function BigInteger__get_ToUInt16(x) {\r\n    return BigInteger__get_ToUInt32(x) & 0xFFFF;\r\n}\r\n\r\nexport function BigInteger__get_ToSingle(x) {\r\n    return BigInteger__get_ToDouble(x);\r\n}\r\n\r\nexport function BigInteger__get_ToDecimal(x) {\r\n    return new Decimal(BigInteger__get_ToDouble(x));\r\n}\r\n\r\nexport function BigInteger_Parse_Z721C83C5(text) {\r\n    if (text == null) {\r\n        throw (new Error(\"text\"));\r\n    }\r\n    const text_1 = text.trim();\r\n    const len = text_1.length | 0;\r\n    if (len === 0) {\r\n        throw (new Error());\r\n    }\r\n    const matchValue = [text_1[0], len];\r\n    if (matchValue[0] === \"+\") {\r\n        if (matchValue[1] === 1) {\r\n            throw (new Error());\r\n        }\r\n        else {\r\n            return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\r\n        }\r\n    }\r\n    else if (matchValue[0] === \"-\") {\r\n        if (matchValue[1] === 1) {\r\n            throw (new Error());\r\n        }\r\n        else {\r\n            return BigInteger_negn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\r\n        }\r\n    }\r\n    else {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1));\r\n    }\r\n}\r\n\r\nexport function BigInteger__get_IsSmall(x) {\r\n    if (BigInteger__get_IsZero(x)) {\r\n        return true;\r\n    }\r\n    else {\r\n        return BigNatModule_isSmall(BigInteger__get_V(x));\r\n    }\r\n}\r\n\r\nexport function BigInteger_Factorial_Z665282C2(x) {\r\n    if (BigInteger__get_IsNegative(x)) {\r\n        throw (new Error(\"mustBeNonNegative\\\\nParameter name: x\"));\r\n    }\r\n    if (BigInteger__get_IsPositive(x)) {\r\n        return BigInteger_posn_Z67CCE57D(BigNatModule_factorial(BigInteger__get_V(x)));\r\n    }\r\n    else {\r\n        return BigInteger_get_One();\r\n    }\r\n}\r\n\r\nexport function BigInteger_op_UnaryPlus_Z665282C2(n1) {\r\n    return n1;\r\n}\r\n\r\nexport function BigInteger_FromInt64_Z524259C1(x) {\r\n    return BigInteger_$ctor_Z524259C1(x);\r\n}\r\n\r\nexport function BigInteger_FromInt32_Z524259A4(x) {\r\n    return BigInteger_$ctor_Z524259A4(x);\r\n}\r\n\r\n","import { BigInteger_op_Inequality_56F059C0, BigInteger_op_Equality_56F059C0, BigInteger_op_GreaterThanOrEqual_56F059C0, BigInteger_op_GreaterThan_56F059C0, BigInteger_op_LessThanOrEqual_56F059C0, BigInteger_op_LessThan_56F059C0, BigInteger_op_ExclusiveOr_56F059C0, BigInteger_op_BitwiseOr_56F059C0, BigInteger_op_BitwiseAnd_56F059C0, BigInteger_op_LeftShift_62E082A2, BigInteger_op_RightShift_62E082A2, BigInteger_op_UnaryPlus_Z665282C2, BigInteger_op_UnaryNegation_Z665282C2, BigInteger_op_Modulus_56F059C0, BigInteger_op_Division_56F059C0, BigInteger_op_Multiply_56F059C0, BigInteger_op_Subtraction_56F059C0, BigInteger_op_Addition_56F059C0, BigInteger__get_IsOne, BigInteger__get_IsZero, BigInteger__get_Sign, BigInteger__get_ToDecimal, BigInteger__get_ToDouble, BigInteger__get_ToSingle, BigInteger__get_ToUInt64, BigInteger__get_ToInt64, BigInteger__get_ToUInt32, BigInteger__get_ToInt32, BigInteger__get_ToUInt16, BigInteger__get_ToInt16, BigInteger__get_ToByte, BigInteger__get_ToSByte, BigInteger_$ctor_Z524259A4, BigInteger_$ctor_Z524259C1, BigInteger_get_Two, BigInteger_get_One, BigInteger_get_Zero, BigInteger_Abs_Z665282C2, BigInteger_Pow_62E082A2, BigInteger_GreatestCommonDivisor_56F059C0, BigInteger_DivRem_56F059C0, BigInteger_Parse_Z721C83C5, BigInteger } from \"./BigInt/z.js\";\r\nimport { fromInteger } from \"./Long.js\";\r\nimport { comparePrimitives, min, compare as compare_1, equals as equals_1, safeHash } from \"./Util.js\";\r\nimport { toString as toString_1 } from \"./Types.js\";\r\nimport { fold, empty, ofArrayWithTail, cons, toArray, head, skipWhile } from \"./List.js\";\r\nimport { fill, reverse } from \"./Array.js\";\r\n\r\nexport function isBigInt(x) {\r\n    return x instanceof BigInteger;\r\n}\r\n\r\nexport function tryParse(str, res) {\r\n    try {\r\n        res.contents = BigInteger_Parse_Z721C83C5(str);\r\n        return true;\r\n    }\r\n    catch (matchValue) {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function divRem(x, y, remainder) {\r\n    const patternInput = BigInteger_DivRem_56F059C0(x, y);\r\n    remainder.contents = patternInput[1];\r\n    return patternInput[0];\r\n}\r\n\r\nexport function parse(arg00) {\r\n    return BigInteger_Parse_Z721C83C5(arg00);\r\n}\r\n\r\nexport function greatestCommonDivisor(arg00, arg01) {\r\n    return BigInteger_GreatestCommonDivisor_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function pow(arg00, arg01) {\r\n    return BigInteger_Pow_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function abs(arg00) {\r\n    return BigInteger_Abs_Z665282C2(arg00);\r\n}\r\n\r\nexport const zero = BigInteger_get_Zero();\r\n\r\nexport const one = BigInteger_get_One();\r\n\r\nexport const two = BigInteger_get_Two();\r\n\r\nexport function fromString(s) {\r\n    return BigInteger_Parse_Z721C83C5(s);\r\n}\r\n\r\nexport function fromZero() {\r\n    return BigInteger_get_Zero();\r\n}\r\n\r\nexport function fromOne() {\r\n    return BigInteger_get_One();\r\n}\r\n\r\nexport function fromInt64(i) {\r\n    return BigInteger_$ctor_Z524259C1(i);\r\n}\r\n\r\nexport function fromInt32(i) {\r\n    if (i > 2147483647) {\r\n        return BigInteger_$ctor_Z524259C1(fromInteger(i, false, 6));\r\n    }\r\n    else {\r\n        return BigInteger_$ctor_Z524259A4(i);\r\n    }\r\n}\r\n\r\nexport function toSByte(x) {\r\n    return BigInteger__get_ToSByte(x);\r\n}\r\n\r\nexport function toByte(x) {\r\n    return BigInteger__get_ToByte(x);\r\n}\r\n\r\nexport function toInt16(x) {\r\n    return BigInteger__get_ToInt16(x);\r\n}\r\n\r\nexport function toUInt16(x) {\r\n    return BigInteger__get_ToUInt16(x);\r\n}\r\n\r\nexport function toInt32(x) {\r\n    return BigInteger__get_ToInt32(x);\r\n}\r\n\r\nexport function toUInt32(x) {\r\n    return BigInteger__get_ToUInt32(x);\r\n}\r\n\r\nexport function toInt64(x) {\r\n    return BigInteger__get_ToInt64(x);\r\n}\r\n\r\nexport function toUInt64(x) {\r\n    return BigInteger__get_ToUInt64(x);\r\n}\r\n\r\nexport function toSingle(x) {\r\n    return BigInteger__get_ToSingle(x);\r\n}\r\n\r\nexport function toDouble(x) {\r\n    return BigInteger__get_ToDouble(x);\r\n}\r\n\r\nexport function toDecimal(x) {\r\n    return BigInteger__get_ToDecimal(x);\r\n}\r\n\r\nexport function sign(x) {\r\n    return BigInteger__get_Sign(x);\r\n}\r\n\r\nexport function isZero(x) {\r\n    return BigInteger__get_IsZero(x);\r\n}\r\n\r\nexport function isOne(x) {\r\n    return BigInteger__get_IsOne(x);\r\n}\r\n\r\nexport function hash(x) {\r\n    return safeHash(x);\r\n}\r\n\r\nexport function compare(x, y) {\r\n    return x.CompareTo(y);\r\n}\r\n\r\nexport function equals(x, y) {\r\n    return equals_1(x, y);\r\n}\r\n\r\nexport function toString(x) {\r\n    return toString_1(x);\r\n}\r\n\r\nexport const get_Zero = BigInteger_get_Zero();\r\n\r\nexport const get_One = BigInteger_get_One();\r\n\r\nexport function op_Addition(arg00, arg01) {\r\n    return BigInteger_op_Addition_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Subtraction(arg00, arg01) {\r\n    return BigInteger_op_Subtraction_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Multiply(arg00, arg01) {\r\n    return BigInteger_op_Multiply_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Division(arg00, arg01) {\r\n    return BigInteger_op_Division_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Modulus(arg00, arg01) {\r\n    return BigInteger_op_Modulus_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_UnaryNegation(arg00) {\r\n    return BigInteger_op_UnaryNegation_Z665282C2(arg00);\r\n}\r\n\r\nexport function op_UnaryPlus(arg00) {\r\n    return BigInteger_op_UnaryPlus_Z665282C2(arg00);\r\n}\r\n\r\nexport function op_RightShift(arg00, arg01) {\r\n    return BigInteger_op_RightShift_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function op_LeftShift(arg00, arg01) {\r\n    return BigInteger_op_LeftShift_62E082A2(arg00, arg01);\r\n}\r\n\r\nexport function op_BitwiseAnd(arg00, arg01) {\r\n    return BigInteger_op_BitwiseAnd_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_BitwiseOr(arg00, arg01) {\r\n    return BigInteger_op_BitwiseOr_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_ExclusiveOr(arg00, arg01) {\r\n    return BigInteger_op_ExclusiveOr_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_LessThan(arg00, arg01) {\r\n    return BigInteger_op_LessThan_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_LessThanOrEqual(arg00, arg01) {\r\n    return BigInteger_op_LessThanOrEqual_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_GreaterThan(arg00, arg01) {\r\n    return BigInteger_op_GreaterThan_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_GreaterThanOrEqual(arg00, arg01) {\r\n    return BigInteger_op_GreaterThanOrEqual_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Equality(arg00, arg01) {\r\n    return BigInteger_op_Equality_56F059C0(arg00, arg01);\r\n}\r\n\r\nexport function op_Inequality(arg00, arg01) {\r\n    return BigInteger_op_Inequality_56F059C0(arg00, arg01);\r\n}\r\n\r\nfunction flipTwosComplement(currByte, lowBitFound) {\r\n    let array;\r\n    const matchValue = [currByte, lowBitFound];\r\n    if (matchValue[1]) {\r\n        return [(currByte ^ 255) & 255, true];\r\n    }\r\n    else if (matchValue[0] === 0) {\r\n        return [0, false];\r\n    }\r\n    else {\r\n        return [(currByte ^ (254 << ((array = (new Int32Array([0, 1, 2, 3, 4, 5, 6, 7])), array.find((i) => ((currByte & (1 << i)) > 0)))))) & 255, true];\r\n    }\r\n}\r\n\r\nexport function toByteArray(value) {\r\n    if (equals_1(value, zero)) {\r\n        return new Uint8Array([0]);\r\n    }\r\n    else {\r\n        const isPositive = compare_1(value, zero) > 0;\r\n        const value_1 = isPositive ? value : BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value);\r\n        const mask32 = fromInt64(fromInteger(4294967295, false, 6));\r\n        const loop = (accumBytes_mut, consumeValue_mut, lowBitFound_mut) => {\r\n            let value_6, value_8, value_9, value_10;\r\n            loop:\r\n            while (true) {\r\n                const accumBytes = accumBytes_mut, consumeValue = consumeValue_mut, lowBitFound = lowBitFound_mut;\r\n                if (compare_1(consumeValue, zero) <= 0) {\r\n                    const accumBytes_1 = isPositive ? skipWhile((b) => (b === 0), accumBytes) : skipWhile((b_1) => (b_1 === 255), accumBytes);\r\n                    const isHighBitOne = (head(accumBytes_1) & 128) !== 0;\r\n                    return reverse(toArray((isPositive && isHighBitOne) ? cons(0, accumBytes_1) : (((!isPositive) && (!isHighBitOne)) ? cons(255, accumBytes_1) : accumBytes_1)));\r\n                }\r\n                else {\r\n                    const currValue = toUInt32(BigInteger_op_BitwiseAnd_56F059C0(consumeValue, mask32));\r\n                    if (isPositive) {\r\n                        const b0 = currValue & 0xFF;\r\n                        let b1;\r\n                        const value_4 = currValue >>> 8;\r\n                        b1 = (value_4 & 0xFF);\r\n                        let b2;\r\n                        const value_5 = currValue >>> 16;\r\n                        b2 = (value_5 & 0xFF);\r\n                        accumBytes_mut = ofArrayWithTail([(value_6 = (currValue >>> 24), value_6 & 0xFF), b2, b1, b0], accumBytes);\r\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\r\n                        lowBitFound_mut = false;\r\n                        continue loop;\r\n                    }\r\n                    else {\r\n                        const patternInput = flipTwosComplement(currValue & 0xFF, lowBitFound);\r\n                        const patternInput_1 = flipTwosComplement((value_8 = (currValue >>> 8), value_8 & 0xFF), patternInput[1]);\r\n                        const patternInput_2 = flipTwosComplement((value_9 = (currValue >>> 16), value_9 & 0xFF), patternInput_1[1]);\r\n                        const patternInput_3 = flipTwosComplement((value_10 = (currValue >>> 24), value_10 & 0xFF), patternInput_2[1]);\r\n                        accumBytes_mut = ofArrayWithTail([patternInput_3[0], patternInput_2[0], patternInput_1[0], patternInput[0]], accumBytes);\r\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\r\n                        lowBitFound_mut = patternInput_3[1];\r\n                        continue loop;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(empty(), value_1, false);\r\n    }\r\n}\r\n\r\nexport function fromByteArray(bytes) {\r\n    if (bytes == null) {\r\n        throw (new Error(\"bytes\"));\r\n    }\r\n    if (bytes.length === 0) {\r\n        return zero;\r\n    }\r\n    else {\r\n        const isPositive = (bytes[bytes.length - 1] & 128) === 0;\r\n        const buffer = fill(new Uint8Array(4), 0, 4, 0);\r\n        const loop = (accumUInt32_mut, currIndex_mut, bytesRemaining_mut, lowBitFound_mut) => {\r\n            loop:\r\n            while (true) {\r\n                const accumUInt32 = accumUInt32_mut, currIndex = currIndex_mut, bytesRemaining = bytesRemaining_mut, lowBitFound = lowBitFound_mut;\r\n                if (bytesRemaining === 0) {\r\n                    const value_2 = fold((acc, value) => BigInteger_op_Addition_56F059C0(BigInteger_op_LeftShift_62E082A2(acc, 32), fromInt64(fromInteger(value, false, 6))), zero, accumUInt32);\r\n                    if (isPositive) {\r\n                        return value_2;\r\n                    }\r\n                    else {\r\n                        return BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value_2);\r\n                    }\r\n                }\r\n                else {\r\n                    const bytesToProcess = min(comparePrimitives, bytesRemaining, 4) | 0;\r\n                    for (let i_1 = 0; i_1 <= (bytesToProcess - 1); i_1++) {\r\n                        buffer[i_1] = bytes[currIndex + i_1];\r\n                    }\r\n                    if (isPositive) {\r\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 0);\r\n                        accumUInt32_mut = cons((((((buffer[0] | ((buffer[1] << 8) >>> 0)) >>> 0) | ((buffer[2] << 16) >>> 0)) >>> 0) | ((buffer[3] << 24) >>> 0)) >>> 0, accumUInt32);\r\n                        currIndex_mut = (currIndex + bytesToProcess);\r\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\r\n                        lowBitFound_mut = false;\r\n                        continue loop;\r\n                    }\r\n                    else {\r\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 255);\r\n                        const patternInput = flipTwosComplement(buffer[0], lowBitFound);\r\n                        const patternInput_1 = flipTwosComplement(buffer[1], patternInput[1]);\r\n                        const patternInput_2 = flipTwosComplement(buffer[2], patternInput_1[1]);\r\n                        const patternInput_3 = flipTwosComplement(buffer[3], patternInput_2[1]);\r\n                        accumUInt32_mut = cons((((((patternInput[0] | ((patternInput_1[0] << 8) >>> 0)) >>> 0) | ((patternInput_2[0] << 16) >>> 0)) >>> 0) | ((patternInput_3[0] << 24) >>> 0)) >>> 0, accumUInt32);\r\n                        currIndex_mut = (currIndex + bytesToProcess);\r\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\r\n                        lowBitFound_mut = patternInput_3[1];\r\n                        continue loop;\r\n                    }\r\n                }\r\n                break;\r\n            }\r\n        };\r\n        return loop(empty(), 0, bytes.length, false);\r\n    }\r\n}\r\n\r\n","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.7.5/String.js\";\nimport { head, tail, isEmpty, empty, singleton, concat, ofArray, map as map_1 } from \"../fable-library.3.7.5/List.js\";\nimport { tryFind, ofList, toList } from \"../fable-library.3.7.5/Map.js\";\nimport { partialApply, isIterable, disposeSafe, getEnumerator } from \"../fable-library.3.7.5/Util.js\";\nimport { toString } from \"../fable-library.3.7.5/Decimal.js\";\nimport { toDecimal } from \"../fable-library.3.7.5/BigInt.js\";\nimport { toString as toString_1 } from \"../fable-library.3.7.5/Date.js\";\nimport { value as value_5, some } from \"../fable-library.3.7.5/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.7.5/Array.js\";\nimport { map as map_3, delay, toList as toList_1 } from \"../fable-library.3.7.5/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(SimpleJson_toString, _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                disposeSafe(enumerator);\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                disposeSafe(enumerator_1);\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 activePatternResult6342 = $007CNativeString$007C_$007C(x);\n    if (activePatternResult6342 != null) {\n        const str = activePatternResult6342;\n        return new Json(1, str);\n    }\n    else {\n        const activePatternResult6341 = $007CNativeNumber$007C_$007C(x);\n        if (activePatternResult6341 != null) {\n            const number = activePatternResult6341;\n            return new Json(0, number);\n        }\n        else {\n            const activePatternResult6340 = $007CNativeBool$007C_$007C(x);\n            if (activePatternResult6340 != null) {\n                const value = activePatternResult6340;\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 activePatternResult6338 = $007CNativeArray$007C_$007C(x);\n                if (activePatternResult6338 != null) {\n                    const arr = activePatternResult6338;\n                    return new Json(4, ofArray(map_2(SimpleJson_parseNative$0027, arr)));\n                }\n                else {\n                    const activePatternResult6337 = $007CNativeObject$007C_$007C(x);\n                    if (activePatternResult6337 != null) {\n                        const object = value_5(activePatternResult6337);\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.7.5/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","const ok = (value) => ({\n    tag: \"ok\",\n    value,\n});\nconst error = (error) => ({ tag: \"error\", error });\nexport class Uri {\n    constructor(state) {\n        this.uri = state;\n    }\n    static isAbsoluteUri(uri) {\n        try {\n            // tslint:disable-next-line no-unused-expression\n            new URL(uri);\n            return true;\n        }\n        catch (_a) {\n            return false;\n        }\n    }\n    static tryCreateWithKind(uri, kind) {\n        switch (kind) {\n            case 1 /* Absolute */:\n                return Uri.isAbsoluteUri(uri)\n                    ? ok(new Uri({ original: uri, value: new URL(uri), kind }))\n                    : error(\"Invalid URI: The format of the URI could not be determined.\");\n            case 2 /* Relative */:\n                return Uri.isAbsoluteUri(uri)\n                    ? error(\"URI is not a relative path.\")\n                    : ok(new Uri({ original: uri, value: uri, kind }));\n            case 0 /* RelativeOrAbsolute */:\n                return Uri.isAbsoluteUri(uri)\n                    ? ok(new Uri({ original: uri, value: new URL(uri), kind: 1 /* Absolute */ }))\n                    : ok(new Uri({ original: uri, value: uri, kind: 2 /* Relative */ }));\n            default:\n                const never = kind;\n                return never;\n        }\n    }\n    static tryCreateWithBase(baseUri, relativeUri) {\n        return baseUri.uri.kind !== 1 /* Absolute */\n            ? error(\"Base URI should have Absolute kind\")\n            : typeof relativeUri === \"string\"\n                ? ok(new Uri({\n                    original: new URL(relativeUri, baseUri.uri.value).toString(),\n                    value: new URL(relativeUri, baseUri.uri.value),\n                    kind: 1 /* Absolute */,\n                }))\n                : relativeUri.uri.kind === 2 /* Relative */\n                    ? ok(new Uri({\n                        original: new URL(relativeUri.uri.value, baseUri.uri.value).toString(),\n                        value: new URL(relativeUri.uri.value, baseUri.uri.value),\n                        kind: 1 /* Absolute */,\n                    }))\n                    : ok(baseUri);\n    }\n    static tryCreateImpl(value, kindOrUri = 1 /* Absolute */) {\n        return typeof value === \"string\"\n            ? typeof kindOrUri !== \"number\"\n                ? error(\"Kind must be specified when the baseUri is a string.\")\n                : Uri.tryCreateWithKind(value, kindOrUri)\n            : typeof kindOrUri === \"number\"\n                ? error(\"Kind should not be specified when the baseUri is an absolute Uri.\")\n                : Uri.tryCreateWithBase(value, kindOrUri);\n    }\n    static create(value, kindOrUri = 1 /* Absolute */) {\n        const result = Uri.tryCreateImpl(value, kindOrUri);\n        switch (result.tag) {\n            case \"ok\":\n                return result.value;\n            case \"error\":\n                throw new Error(result.error);\n            default:\n                const never = result;\n                return never;\n        }\n    }\n    static tryCreate(value, kindOrUri = 1 /* Absolute */, out) {\n        const result = Uri.tryCreateImpl(value, kindOrUri);\n        switch (result.tag) {\n            case \"ok\":\n                out.contents = result.value;\n                return true;\n            case \"error\":\n                return false;\n            default:\n                const never = result;\n                return never;\n        }\n    }\n    toString() {\n        switch (this.uri.kind) {\n            case 1 /* Absolute */:\n                return decodeURIComponent(this.asUrl().toString());\n            case 2 /* Relative */:\n                return this.uri.value;\n            default:\n                const never = this.uri;\n                return never;\n        }\n    }\n    asUrl() {\n        switch (this.uri.kind) {\n            case 1 /* Absolute */:\n                return this.uri.value;\n            case 2 /* Relative */:\n                throw new Error(\"This operation is not supported for a relative URI.\");\n            default:\n                const never = this.uri;\n                return never;\n        }\n    }\n    get isAbsoluteUri() {\n        return this.uri.kind === 1 /* Absolute */;\n    }\n    get absoluteUri() {\n        return this.asUrl().href;\n    }\n    get scheme() {\n        const protocol = this.asUrl().protocol;\n        return protocol.slice(0, protocol.length - 1);\n    }\n    get host() {\n        return this.asUrl().host;\n    }\n    get absolutePath() {\n        return this.asUrl().pathname;\n    }\n    get query() {\n        return this.asUrl().search;\n    }\n    get pathAndQuery() {\n        const url = this.asUrl();\n        return url.pathname + url.search;\n    }\n    get fragment() {\n        return this.asUrl().hash;\n    }\n    get originalString() {\n        return this.uri.original;\n    }\n}\nexport default Uri;\n","/**\n * DateTimeOffset functions.\n *\n * Note: DateOffset instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * However, this means that in order to construct an UTC date\n * from a DateOffset with offset of +5 hours, you first need\n * to subtract those 5 hours, than add the \"local\" offset.\n * As said, all kinds of messed up.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { create as createDate, dateOffsetToString, daysInMonth, parseRaw } from \"./Date.js\";\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, padWithZeros } from \"./Util.js\";\nexport default function DateTimeOffset(value, offset) {\n    checkOffsetInRange(offset);\n    const d = new Date(value);\n    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;\n    return d;\n}\nfunction checkOffsetInRange(offset) {\n    if (offset != null && offset !== 0) {\n        if (offset % 60000 !== 0) {\n            throw new Error(\"Offset must be specified in whole minutes.\");\n        }\n        if (Math.abs(offset / 3600000) > 14) {\n            throw new Error(\"Offset must be within plus or minus 14 hours.\");\n        }\n    }\n}\nexport function fromDate(date, offset) {\n    let offset2 = 0;\n    switch (date.kind) {\n        case 1 /* UTC */:\n            if (offset != null && offset !== 0) {\n                throw new Error(\"The UTC Offset for Utc DateTime instances must be 0.\");\n            }\n            offset2 = 0;\n            break;\n        case 2 /* Local */:\n            offset2 = date.getTimezoneOffset() * -60000;\n            if (offset != null && offset !== offset2) {\n                throw new Error(\"The UTC Offset of the local dateTime parameter does not match the offset argument.\");\n            }\n            break;\n        case 0 /* Unspecified */:\n        default:\n            if (offset == null) {\n                offset2 = date.getTimezoneOffset() * -60000;\n            }\n            else {\n                offset2 = offset;\n            }\n            break;\n    }\n    return DateTimeOffset(date.getTime(), offset2);\n}\nexport function fromTicks(ticks, offset) {\n    ticks = fromValue(ticks);\n    const epoc = ticksToUnixEpochMilliseconds(ticks) - offset;\n    return DateTimeOffset(epoc, offset);\n}\nexport function getUtcTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), 0);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTimeOffset(-62135596800000, 0);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTimeOffset(253402300799999, 0);\n}\nexport function parse(str) {\n    const [date, offsetMatch] = parseRaw(str);\n    const offset = offsetMatch == null\n        ? date.getTimezoneOffset() * -60000\n        : (offsetMatch === \"Z\" ? 0 : offsetMatch * 60000);\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h, m, s, ms, offset) {\n    if (offset == null) {\n        offset = ms;\n        ms = 0;\n    }\n    checkOffsetInRange(offset);\n    let date;\n    if (offset === 0) {\n        date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));\n        if (year <= 99) {\n            date.setFullYear(year, month - 1, day);\n        }\n    }\n    else {\n        const str = padWithZeros(year, 4) + \"-\" +\n            padWithZeros(month, 2) + \"-\" +\n            padWithZeros(day, 2) + \"T\" +\n            padWithZeros(h, 2) + \":\" +\n            padWithZeros(m, 2) + \":\" +\n            padWithZeros(s, 2) + \".\" +\n            padWithZeros(ms, 3) +\n            dateOffsetToString(offset);\n        date = new Date(str);\n    }\n    const dateValue = date.getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date\");\n    }\n    return DateTimeOffset(dateValue, offset);\n}\nexport function now() {\n    const date = new Date();\n    const offset = date.getTimezoneOffset() * -60000;\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function utcNow() {\n    const date = now();\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toUniversalTime(date) {\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toLocalTime(date) {\n    return DateTimeOffset(date.getTime(), date.getTimezoneOffset() * -60000);\n}\nexport function timeOfDay(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return d2.getUTCHours() * 3600000\n        + d2.getUTCMinutes() * 60000\n        + d2.getUTCSeconds() * 1000\n        + d2.getUTCMilliseconds();\n}\nexport function date(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);\n}\nexport function day(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDate();\n}\nexport function hour(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCHours();\n}\nexport function millisecond(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMilliseconds();\n}\nexport function minute(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMinutes();\n}\nexport function month(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMonth() + 1;\n}\nexport function second(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCSeconds();\n}\nexport function year(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDay();\n}\nexport function dayOfYear(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    const _year = d2.getUTCFullYear();\n    const _month = d2.getUTCMonth() + 1;\n    let _day = d2.getUTCDate();\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    var _a;\n    return DateTimeOffset(d.getTime() + ts, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addDays(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 86400000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addHours(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 3600000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMinutes(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 60000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addSeconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 1000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMilliseconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addYears(d, v) {\n    var _a;\n    const newMonth = d.getUTCMonth() + 1;\n    const newYear = d.getUTCFullYear() + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d.getUTCDate());\n    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMonths(d, v) {\n    var _a, _b;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    let newMonth = d2.getUTCMonth() + 1 + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = d2.getUTCFullYear() + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d2.getUTCDate());\n    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), ((_b = d.offset) !== null && _b !== void 0 ? _b : 0));\n}\nexport function subtract(d, that) {\n    var _a;\n    return typeof that === \"number\"\n        ? DateTimeOffset(d.getTime() - that, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0))\n        : d.getTime() - that.getTime();\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport function equalsExact(d1, d2) {\n    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;\n}\nexport function compare(d1, d2) {\n    return compareDates(d1, d2);\n}\nexport const compareTo = compare;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function toOffset(d, offset) {\n    return DateTimeOffset(d.getTime(), offset);\n}\n","import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth } from \"./Date.js\";\nimport { padWithZeros } from \"./Util.js\";\nimport { toInt, fromNumber, op_Division as Long_op_Division, op_Multiply as Long_op_Multiply, ticksToUnixEpochMilliseconds } from \"./Long.js\";\nexport function fromUnixMilliseconds(value) {\n    return DateTime(value, 1 /* UTC */);\n}\nexport function create(year, month, day) {\n    const d = fromUnixMilliseconds(Date.UTC(year, month - 1, day));\n    if (year <= 99) {\n        d.setUTCFullYear(year);\n    }\n    return d;\n}\nexport function maxValue() {\n    // This is \"9999-12-31T00:00:00.000Z\"\n    return fromUnixMilliseconds(253402214400000);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\"\n    return fromUnixMilliseconds(-62135596800000);\n}\nexport function dayNumber(d) {\n    return toInt(Long_op_Division(getTicks(d), 864000000000));\n}\nexport function fromDayNumber(dayNumber) {\n    const ticks = Long_op_Multiply(fromNumber(864000000000), dayNumber);\n    return fromUnixMilliseconds(ticksToUnixEpochMilliseconds(ticks));\n}\nexport function fromDateTime(d) {\n    return create(Date_year(d), Date_month(d), Date_day(d));\n}\nexport function day(d) {\n    return d.getUTCDate();\n}\nexport function month(d) {\n    return d.getUTCMonth() + 1;\n}\nexport function year(d) {\n    return d.getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.getUTCDay();\n}\nexport function dayOfYear(d) {\n    return Date_dayOfYear(d);\n}\nexport function toDateTime(d, time, kind = 0 /* Unspecified */) {\n    return DateTime(d.getTime() + time + (kind !== 1 /* UTC */ ? d.getTimezoneOffset() : 0) * 60000, kind);\n}\nexport function toString(d, format = \"d\", _provider) {\n    if ([\"d\", \"o\", \"O\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const y = padWithZeros(year(d), 4);\n    const m = padWithZeros(month(d), 2);\n    const dd = padWithZeros(day(d), 2);\n    return format === \"d\" ? `${m}/${dd}/${y}` : `${y}-${m}-${dd}`;\n}\nexport function parse(str) {\n    function fail() {\n        throw new Error(`String '${str}' was not recognized as a valid DateOnly.`);\n    }\n    // Allowed separators: . , / -\n    // TODO whitespace alone as the separator\n    //\n    // Whitespace around separators\n    //\n    // Allowed format types:\n    // yyyy/mm/dd\n    // mm/dd/yyyy\n    // mm/dd\n    // mm/yyyy\n    // yyyy/mm\n    const r = /^\\s*(\\d{1,4})(?:\\s*[.,-\\/]\\s*(\\d{1,2}))?\\s*[.,-\\/]\\s*(\\d{1,4})\\s*$/.exec(str);\n    if (r != null) {\n        let y = 0;\n        let m = 0;\n        let d = 1;\n        if (r[2] == null) {\n            if (r[1].length < 3) {\n                if (r[3].length < 3) {\n                    // 12/30 = December 30, {CurrentYear}\n                    y = new Date().getFullYear();\n                    m = +r[1];\n                    d = +r[3];\n                }\n                else {\n                    // 12/2000 = December 1, 2000\n                    m = +r[1];\n                    y = +r[3];\n                }\n            }\n            else {\n                if (r[3].length > 2)\n                    fail();\n                // 2000/12 = December 1, 2000\n                y = +r[1];\n                m = +r[3];\n            }\n        }\n        else {\n            // 2000/1/30 or 1/30/2000\n            const yearFirst = r[1].length > 2;\n            const yTmp = r[yearFirst ? 1 : 3];\n            y = +yTmp;\n            // year 0-29 is 2000-2029, 30-99 is 1930-1999\n            if (yTmp.length < 3)\n                y += y >= 30 ? 1900 : 2000;\n            m = +r[yearFirst ? 2 : 1];\n            d = +r[yearFirst ? 3 : 2];\n        }\n        if (y > 0 && m > 0 && m < 13 && d > 0 && d <= Date_daysInMonth(y, m))\n            return create(y, m, d);\n    }\n    return fail();\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n","import { op_Division as Long_op_Division, toNumber as Long_toNumber } from \"./Long.js\";\nimport { hours, minutes, seconds, milliseconds } from \"./TimeSpan.js\";\nimport { padWithZeros } from \"./Util.js\";\nconst millisecondsPerDay = 86400000;\nexport function create(h = 0, m = 0, s = 0, ms = 0) {\n    if (h < 0 || m < 0 || s < 0 || ms < 0)\n        throw new Error(\"The parameters describe an unrepresentable TimeOnly.\");\n    if (arguments.length === 1)\n        // ticks\n        return fromTicks(arguments[0]);\n    else\n        return h * 3600000 + m * 60000 + s * 1000 + ms;\n}\nexport function fromTicks(ticks) {\n    return Long_toNumber(Long_op_Division(ticks, 10000));\n}\nexport function fromTimeSpan(timeSpan) {\n    if (timeSpan < 0 || timeSpan >= millisecondsPerDay)\n        throw new Error(\"The TimeSpan describes an unrepresentable TimeOnly.\");\n    return timeSpan;\n}\nexport function fromDateTime(d) {\n    return d.kind === 1 /* UTC */\n        ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())\n        : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());\n}\nexport function maxValue() {\n    // This is \"23:59:59.999\"\n    return millisecondsPerDay - 1;\n}\nexport function add(t, ts, wrappedDays) {\n    if (wrappedDays === undefined) {\n        const t2 = (t + ts) % millisecondsPerDay;\n        return t2 < 0 ? millisecondsPerDay + t2 : t2;\n    }\n    wrappedDays.contents = ts / millisecondsPerDay;\n    let newMs = t + ts % millisecondsPerDay;\n    if (newMs < 0) {\n        wrappedDays.contents--;\n        newMs += millisecondsPerDay;\n    }\n    else {\n        if (newMs >= millisecondsPerDay) {\n            wrappedDays.contents++;\n            newMs -= millisecondsPerDay;\n        }\n    }\n    return newMs;\n}\nexport function addHours(t, h) {\n    return add(t, h * 3600000);\n}\nexport function addMinutes(t, m) {\n    return add(t, m * 60000);\n}\nexport function isBetween(t, start, end) {\n    return start <= end\n        ? (start <= t && end > t)\n        : (start <= t || end > t);\n}\nexport function toString(t, format = \"t\", _provider) {\n    if ([\"r\", \"R\", \"o\", \"O\", \"t\", \"T\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`;\n    if (format === \"t\")\n        return base;\n    const s = padWithZeros(seconds(t), 2);\n    // We're limited to millisecond precision, so the last 4 digits will always be 0\n    return `${base}${format === \"o\" || format === \"O\" ? `:${s}.${padWithZeros(milliseconds(t), 3)}0000` : `:${s}`}`;\n}\nexport function parse(str) {\n    // Allowed format types:\n    // hh:mm\n    // hh:mm:ss\n    // hh:mm:ss.fffffff\n    const r = /^\\s*([0-1]?\\d|2[0-3])\\s*:\\s*([0-5]?\\d)(\\s*:\\s*([0-5]?\\d)(\\.(\\d+))?)?\\s*$/.exec(str);\n    if (r != null && r[1] != null && r[2] != null) {\n        let ms = 0;\n        let s = 0;\n        const h = +r[1];\n        const m = +r[2];\n        if (r[4] != null) {\n            s = +r[4];\n        }\n        if (r[6] != null) {\n            // Depending on the number of decimals passed, we need to adapt the numbers\n            switch (r[6].length) {\n                case 1:\n                    ms = +r[6] * 100;\n                    break;\n                case 2:\n                    ms = +r[6] * 10;\n                    break;\n                case 3:\n                    ms = +r[6];\n                    break;\n                case 4:\n                    ms = +r[6] / 10;\n                    break;\n                case 5:\n                    ms = +r[6] / 100;\n                    break;\n                case 6:\n                    ms = +r[6] / 1000;\n                    break;\n                default:\n                    ms = +r[6].substring(0, 7) / 10000;\n                    break;\n            }\n        }\n        return create(h, m, s, Math.trunc(ms));\n    }\n    throw new Error(`String '${str}' was not recognized as a valid TimeOnly.`);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_Subtraction(left, right) {\n    return add(left, -right);\n}\n","import { trim } from \"./String.js\";\n// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220\n// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;\n// Relax GUID parsing, see #1637\nconst guidRegex = /^[\\(\\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\\)\\}]{0,2}$/;\nconst guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;\nconst guidRegexHex = /^\\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\\}\\}$/;\nconst guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;\nexport function toString(str, format, _provider) {\n    if (format && (format === null || format === void 0 ? void 0 : format.length) > 0) {\n        switch (format) {\n            case \"N\":\n                return str.replace(/-/g, '');\n            case \"D\":\n                return str;\n            case \"B\":\n                return \"{\" + str + \"}\";\n            case \"P\":\n                return \"(\" + str + \")\";\n            case \"X\":\n                return str.replace(guidHexCaptures, \"{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}\");\n            default:\n                throw new Error(\"Unrecognized Guid print format\");\n        }\n    }\n    else {\n        return str;\n    }\n}\n/** Validates UUID as specified in RFC4122 (versions 1-5). */\nexport function parse(str) {\n    function hyphenateGuid(str) {\n        return str.replace(guidRegexNoHyphen, \"$1-$2-$3-$4-$5\");\n    }\n    const wsTrimAndLowered = str.trim().toLowerCase();\n    if (guidRegex.test(wsTrimAndLowered)) {\n        return trim(wsTrimAndLowered, \"{\", \"}\", \"(\", \")\");\n    }\n    else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered);\n    }\n    else if (guidRegexHex.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered.replace(/[\\{\\},]|0x/g, ''));\n    }\n    else {\n        throw new Error(\"Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\");\n    }\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = parse(str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n// From https://gist.github.com/LeverOne/1308368\nexport function newGuid() {\n    let b = \"\";\n    for (let a = 0; a++ < 36;) {\n        b += a * 51 & 52\n            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)\n            : \"-\";\n    }\n    return b;\n}\n// Maps for number <-> hex string conversion\nlet _convertMapsInitialized = false;\nlet _byteToHex;\nlet _hexToByte;\nfunction initConvertMaps() {\n    _byteToHex = new Array(256);\n    _hexToByte = {};\n    for (let i = 0; i < 256; i++) {\n        _byteToHex[i] = (i + 0x100).toString(16).substr(1);\n        _hexToByte[_byteToHex[i]] = i;\n    }\n    _convertMapsInitialized = true;\n}\n/** Parse a UUID into it's component bytes */\n// Adapted from https://github.com/zefferus/uuid-parse\nexport function guidToArray(s) {\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    let i = 0;\n    const buf = new Uint8Array(16);\n    s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct) => {\n        switch (i) {\n            // .NET saves first three byte groups with different endianness\n            // See https://stackoverflow.com/a/16722909/3922220\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n                buf[3 - i++] = _hexToByte[oct];\n                break;\n            case 4:\n            case 5:\n                buf[9 - i++] = _hexToByte[oct];\n                break;\n            case 6:\n            case 7:\n                buf[13 - i++] = _hexToByte[oct];\n                break;\n            case 8:\n            case 9:\n            case 10:\n            case 11:\n            case 12:\n            case 13:\n            case 14:\n            case 15:\n                buf[i++] = _hexToByte[oct];\n                break;\n        }\n    }));\n    // Zero out remaining bytes if string was short\n    while (i < 16) {\n        buf[i++] = 0;\n    }\n    return buf;\n}\n/** Convert UUID byte array into a string */\nexport function arrayToGuid(buf) {\n    if (buf.length !== 16) {\n        throw new Error(\"Byte array for GUID must be exactly 16 bytes long\");\n    }\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    const guid = _byteToHex[buf[3]] + _byteToHex[buf[2]] +\n        _byteToHex[buf[1]] + _byteToHex[buf[0]] + \"-\" +\n        _byteToHex[buf[5]] + _byteToHex[buf[4]] + \"-\" +\n        _byteToHex[buf[7]] + _byteToHex[buf[6]] + \"-\" +\n        _byteToHex[buf[8]] + _byteToHex[buf[9]] + \"-\" +\n        _byteToHex[buf[10]] + _byteToHex[buf[11]] +\n        _byteToHex[buf[12]] + _byteToHex[buf[13]] +\n        _byteToHex[buf[14]] + _byteToHex[buf[15]];\n    return guid;\n}\n","import { fromBits, getHighBits, getHighBitsUnsigned, getLowBits, getLowBitsUnsigned } from \"./Long.js\";\nconst littleEndian = true;\nexport function isLittleEndian() {\n    return littleEndian;\n}\nexport function getBytesBoolean(value) {\n    const bytes = new Uint8Array(1);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint8(0, value ? 1 : 0);\n    return bytes;\n}\nexport function getBytesChar(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint16(0, value.charCodeAt(0), littleEndian);\n    return bytes;\n}\nexport function getBytesInt16(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt16(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesInt32(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesInt64(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setInt32(littleEndian ? 0 : 4, getLowBits(value), littleEndian);\n    view.setInt32(littleEndian ? 4 : 0, getHighBits(value), littleEndian);\n    return bytes;\n}\nexport function getBytesUInt16(value) {\n    const bytes = new Uint8Array(2);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint16(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesUInt32(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesUInt64(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setUint32(littleEndian ? 0 : 4, getLowBitsUnsigned(value), littleEndian);\n    view.setUint32(littleEndian ? 4 : 0, getHighBitsUnsigned(value), littleEndian);\n    return bytes;\n}\nexport function getBytesSingle(value) {\n    const bytes = new Uint8Array(4);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setFloat32(0, value, littleEndian);\n    return bytes;\n}\nexport function getBytesDouble(value) {\n    const bytes = new Uint8Array(8);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    view.setFloat64(0, value, littleEndian);\n    return bytes;\n}\nexport function int64BitsToDouble(value) {\n    const buffer = new ArrayBuffer(8);\n    const view = new DataView(buffer);\n    view.setInt32(littleEndian ? 0 : 4, getLowBits(value), littleEndian);\n    view.setInt32(littleEndian ? 4 : 0, getHighBits(value), littleEndian);\n    return view.getFloat64(0, littleEndian);\n}\nexport function doubleToInt64Bits(value) {\n    const buffer = new ArrayBuffer(8);\n    const view = new DataView(buffer);\n    view.setFloat64(0, value, littleEndian);\n    const lowBits = view.getInt32(littleEndian ? 0 : 4, littleEndian);\n    const highBits = view.getInt32(littleEndian ? 4 : 0, littleEndian);\n    return fromBits(lowBits, highBits, false);\n}\nexport function toBoolean(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint8(offset) === 1 ? true : false;\n}\nexport function toChar(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const code = view.getUint16(offset, littleEndian);\n    return String.fromCharCode(code);\n}\nexport function toInt16(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getInt16(offset, littleEndian);\n}\nexport function toInt32(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getInt32(offset, littleEndian);\n}\nexport function toInt64(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const lowBits = view.getInt32(offset + (littleEndian ? 0 : 4), littleEndian);\n    const highBits = view.getInt32(offset + (littleEndian ? 4 : 0), littleEndian);\n    return fromBits(lowBits, highBits, false);\n}\nexport function toUInt16(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint16(offset, littleEndian);\n}\nexport function toUInt32(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getUint32(offset, littleEndian);\n}\nexport function toUInt64(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    const lowBits = view.getUint32(offset + (littleEndian ? 0 : 4), littleEndian);\n    const highBits = view.getUint32(offset + (littleEndian ? 4 : 0), littleEndian);\n    return fromBits(lowBits, highBits, true);\n}\nexport function toSingle(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getFloat32(offset, littleEndian);\n}\nexport function toDouble(bytes, offset) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    return view.getFloat64(offset, littleEndian);\n}\nexport function toString(bytes, offset, count) {\n    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);\n    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);\n    if (offset != null && count != null) {\n        buffer = buffer.subarray(offset, offset + count);\n    }\n    else if (offset != null) {\n        buffer = buffer.subarray(offset);\n    }\n    return Array.from(buffer).map((b) => (\"0\" + b.toString(16)).slice(-2)).join(\"-\");\n}\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\r\nimport { some, value as value_1 } from \"./Option.js\";\r\nimport { toString, Record } from \"./Types.js\";\r\nimport { FSharpList, fold as fold_2, cons, singleton as singleton_1, empty as empty_1, ofArrayWithTail, tail, head, isEmpty as isEmpty_1 } from \"./List.js\";\r\nimport { fold as fold_1, fill } from \"./Array.js\";\r\nimport { structuralHash, toIterator, disposeSafe, getEnumerator, isArrayLike } from \"./Util.js\";\r\nimport { join } from \"./String.js\";\r\nimport { exists as exists_1, cache, forAll as forAll_1, fold as fold_3, reduce, iterate as iterate_1, map as map_1 } from \"./Seq.js\";\r\nimport { HashSet__get_Comparer, HashSet_$ctor_Z6150332D, HashSet } from \"./MutableSet.js\";\r\n\r\nexport class SetTreeLeaf$1 {\r\n    constructor(k) {\r\n        this.k = k;\r\n    }\r\n}\r\n\r\nexport function SetTreeLeaf$1$reflection(gen0) {\r\n    return class_type(\"Set.SetTreeLeaf`1\", [gen0], SetTreeLeaf$1);\r\n}\r\n\r\nexport function SetTreeLeaf$1_$ctor_2B595(k) {\r\n    return new SetTreeLeaf$1(k);\r\n}\r\n\r\nexport function SetTreeLeaf$1__get_Key(_) {\r\n    return _.k;\r\n}\r\n\r\nexport class SetTreeNode$1 extends SetTreeLeaf$1 {\r\n    constructor(v, left, right, h) {\r\n        super(v);\r\n        this.left = left;\r\n        this.right = right;\r\n        this.h = (h | 0);\r\n    }\r\n}\r\n\r\nexport function SetTreeNode$1$reflection(gen0) {\r\n    return class_type(\"Set.SetTreeNode`1\", [gen0], SetTreeNode$1, SetTreeLeaf$1$reflection(gen0));\r\n}\r\n\r\nexport function SetTreeNode$1_$ctor_Z6E7BE5F7(v, left, right, h) {\r\n    return new SetTreeNode$1(v, left, right, h);\r\n}\r\n\r\nexport function SetTreeNode$1__get_Left(_) {\r\n    return _.left;\r\n}\r\n\r\nexport function SetTreeNode$1__get_Right(_) {\r\n    return _.right;\r\n}\r\n\r\nexport function SetTreeNode$1__get_Height(_) {\r\n    return _.h;\r\n}\r\n\r\nexport function SetTreeModule_empty() {\r\n    return void 0;\r\n}\r\n\r\nexport function SetTreeModule_countAux(t_mut, acc_mut) {\r\n    SetTreeModule_countAux:\r\n    while (true) {\r\n        const t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_countAux(SetTreeNode$1__get_Right(t2), acc + 1);\r\n                continue SetTreeModule_countAux;\r\n            }\r\n            else {\r\n                return (acc + 1) | 0;\r\n            }\r\n        }\r\n        else {\r\n            return acc | 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_count(s) {\r\n    return SetTreeModule_countAux(s, 0);\r\n}\r\n\r\nexport function SetTreeModule_mk(l, k, r) {\r\n    let hl;\r\n    const t = l;\r\n    if (t != null) {\r\n        const t2 = t;\r\n        hl = ((t2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2) : 1);\r\n    }\r\n    else {\r\n        hl = 0;\r\n    }\r\n    let hr;\r\n    const t_1 = r;\r\n    if (t_1 != null) {\r\n        const t2_1 = t_1;\r\n        hr = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\r\n    }\r\n    else {\r\n        hr = 0;\r\n    }\r\n    const m = ((hl < hr) ? hr : hl) | 0;\r\n    if (m === 0) {\r\n        return SetTreeLeaf$1_$ctor_2B595(k);\r\n    }\r\n    else {\r\n        return SetTreeNode$1_$ctor_Z6E7BE5F7(k, l, r, m + 1);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_rebalance(t1, v, t2) {\r\n    let t_2, t2_3, t_3, t2_4;\r\n    let t1h;\r\n    const t = t1;\r\n    if (t != null) {\r\n        const t2_1 = t;\r\n        t1h = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\r\n    }\r\n    else {\r\n        t1h = 0;\r\n    }\r\n    let t2h;\r\n    const t_1 = t2;\r\n    if (t_1 != null) {\r\n        const t2_2 = t_1;\r\n        t2h = ((t2_2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_2) : 1);\r\n    }\r\n    else {\r\n        t2h = 0;\r\n    }\r\n    if (t2h > (t1h + 2)) {\r\n        const matchValue = value_1(t2);\r\n        if (matchValue instanceof SetTreeNode$1) {\r\n            if (((t_2 = SetTreeNode$1__get_Left(matchValue), (t_2 != null) ? ((t2_3 = t_2, (t2_3 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_3) : 1)) : 0)) > (t1h + 1)) {\r\n                const matchValue_1 = value_1(SetTreeNode$1__get_Left(matchValue));\r\n                if (matchValue_1 instanceof SetTreeNode$1) {\r\n                    return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue_1)), SetTreeLeaf$1__get_Key(matchValue_1), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_1), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue)));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Set.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue)), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Set.rebalance\"));\r\n        }\r\n    }\r\n    else if (t1h > (t2h + 2)) {\r\n        const matchValue_2 = value_1(t1);\r\n        if (matchValue_2 instanceof SetTreeNode$1) {\r\n            if (((t_3 = SetTreeNode$1__get_Right(matchValue_2), (t_3 != null) ? ((t2_4 = t_3, (t2_4 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_4) : 1)) : 0)) > (t2h + 1)) {\r\n                const matchValue_3 = value_1(SetTreeNode$1__get_Right(matchValue_2));\r\n                if (matchValue_3 instanceof SetTreeNode$1) {\r\n                    return SetTreeModule_mk(SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeNode$1__get_Left(matchValue_3)), SetTreeLeaf$1__get_Key(matchValue_3), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_3), v, t2));\r\n                }\r\n                else {\r\n                    throw (new Error(\"internal error: Set.rebalance\"));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_2), v, t2));\r\n            }\r\n        }\r\n        else {\r\n            throw (new Error(\"internal error: Set.rebalance\"));\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_mk(t1, v, t2);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_add(comparer, k, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (c < 0) {\r\n                return SetTreeModule_rebalance(SetTreeModule_add(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\r\n            }\r\n            else if (c === 0) {\r\n                return t;\r\n            }\r\n            else {\r\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_add(comparer, k, SetTreeNode$1__get_Right(t2)));\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (c_1 < 0) {\r\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, SetTreeModule_empty(), t, 2);\r\n            }\r\n            else if (c_1 === 0) {\r\n                return t;\r\n            }\r\n            else {\r\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, t, SetTreeModule_empty(), 2);\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeLeaf$1_$ctor_2B595(k);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_balance(comparer, t1, k, t2) {\r\n    if (t1 != null) {\r\n        const t1$0027 = t1;\r\n        if (t2 != null) {\r\n            const t2$0027 = t2;\r\n            if (t1$0027 instanceof SetTreeNode$1) {\r\n                if (t2$0027 instanceof SetTreeNode$1) {\r\n                    if ((SetTreeNode$1__get_Height(t1$0027) + 2) < SetTreeNode$1__get_Height(t2$0027)) {\r\n                        return SetTreeModule_rebalance(SetTreeModule_balance(comparer, t1, k, SetTreeNode$1__get_Left(t2$0027)), SetTreeLeaf$1__get_Key(t2$0027), SetTreeNode$1__get_Right(t2$0027));\r\n                    }\r\n                    else if ((SetTreeNode$1__get_Height(t2$0027) + 2) < SetTreeNode$1__get_Height(t1$0027)) {\r\n                        return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t1$0027), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_balance(comparer, SetTreeNode$1__get_Right(t1$0027), k, t2));\r\n                    }\r\n                    else {\r\n                        return SetTreeModule_mk(t1, k, t2);\r\n                    }\r\n                }\r\n                else {\r\n                    return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1));\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2));\r\n            }\r\n        }\r\n        else {\r\n            return SetTreeModule_add(comparer, k, t1);\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_add(comparer, k, t2);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_split(comparer, pivot, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            const c = comparer.Compare(pivot, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (c < 0) {\r\n                const patternInput = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Left(t2));\r\n                return [patternInput[0], patternInput[1], SetTreeModule_balance(comparer, patternInput[2], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\r\n            }\r\n            else if (c === 0) {\r\n                return [SetTreeNode$1__get_Left(t2), true, SetTreeNode$1__get_Right(t2)];\r\n            }\r\n            else {\r\n                const patternInput_1 = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Right(t2));\r\n                return [SetTreeModule_balance(comparer, SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), patternInput_1[0]), patternInput_1[1], patternInput_1[2]];\r\n            }\r\n        }\r\n        else {\r\n            const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(t2), pivot) | 0;\r\n            if (c_1 < 0) {\r\n                return [t, false, SetTreeModule_empty()];\r\n            }\r\n            else if (c_1 === 0) {\r\n                return [SetTreeModule_empty(), true, SetTreeModule_empty()];\r\n            }\r\n            else {\r\n                return [SetTreeModule_empty(), false, t];\r\n            }\r\n        }\r\n    }\r\n    else {\r\n        return [SetTreeModule_empty(), false, SetTreeModule_empty()];\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_spliceOutSuccessor(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (SetTreeNode$1__get_Left(t2) == null) {\r\n                return [SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2)];\r\n            }\r\n            else {\r\n                const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Left(t2));\r\n                return [patternInput[0], SetTreeModule_mk(patternInput[1], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\r\n            }\r\n        }\r\n        else {\r\n            return [SetTreeLeaf$1__get_Key(t2), SetTreeModule_empty()];\r\n        }\r\n    }\r\n    else {\r\n        throw (new Error(\"internal error: Set.spliceOutSuccessor\"));\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_remove(comparer, k, t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            if (c < 0) {\r\n                return SetTreeModule_rebalance(SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\r\n            }\r\n            else if (c === 0) {\r\n                if (SetTreeNode$1__get_Left(t2) == null) {\r\n                    return SetTreeNode$1__get_Right(t2);\r\n                }\r\n                else if (SetTreeNode$1__get_Right(t2) == null) {\r\n                    return SetTreeNode$1__get_Left(t2);\r\n                }\r\n                else {\r\n                    const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Right(t2));\r\n                    return SetTreeModule_mk(SetTreeNode$1__get_Left(t2), patternInput[0], patternInput[1]);\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Right(t2)));\r\n            }\r\n        }\r\n        else if (c === 0) {\r\n            return SetTreeModule_empty();\r\n        }\r\n        else {\r\n            return t;\r\n        }\r\n    }\r\n    else {\r\n        return t;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {\r\n    SetTreeModule_mem:\r\n    while (true) {\r\n        const comparer = comparer_mut, k = k_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (c < 0) {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    t_mut = SetTreeNode$1__get_Left(t2);\r\n                    continue SetTreeModule_mem;\r\n                }\r\n                else if (c === 0) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    k_mut = k;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_mem;\r\n                }\r\n            }\r\n            else {\r\n                return c === 0;\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_iter(f_mut, t_mut) {\r\n    SetTreeModule_iter:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                SetTreeModule_iter(f, SetTreeNode$1__get_Left(t2));\r\n                f(SetTreeLeaf$1__get_Key(t2));\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                continue SetTreeModule_iter;\r\n            }\r\n            else {\r\n                f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_foldBackOpt(f_mut, t_mut, x_mut) {\r\n    SetTreeModule_foldBackOpt:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut, x = x_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                x_mut = f(SetTreeLeaf$1__get_Key(t2), SetTreeModule_foldBackOpt(f, SetTreeNode$1__get_Right(t2), x));\r\n                continue SetTreeModule_foldBackOpt;\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2), x);\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_foldBack(f, m, x) {\r\n    return SetTreeModule_foldBackOpt(f, m, x);\r\n}\r\n\r\nexport function SetTreeModule_foldOpt(f_mut, x_mut, t_mut) {\r\n    SetTreeModule_foldOpt:\r\n    while (true) {\r\n        const f = f_mut, x = x_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                f_mut = f;\r\n                x_mut = f(SetTreeModule_foldOpt(f, x, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2));\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                continue SetTreeModule_foldOpt;\r\n            }\r\n            else {\r\n                return f(x, SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return x;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_fold(f, x, m) {\r\n    return SetTreeModule_foldOpt(f, x, m);\r\n}\r\n\r\nexport function SetTreeModule_forall(f_mut, t_mut) {\r\n    SetTreeModule_forall:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (f(SetTreeLeaf$1__get_Key(t2)) && SetTreeModule_forall(f, SetTreeNode$1__get_Left(t2))) {\r\n                    f_mut = f;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_forall;\r\n                }\r\n                else {\r\n                    return false;\r\n                }\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return true;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_exists(f_mut, t_mut) {\r\n    SetTreeModule_exists:\r\n    while (true) {\r\n        const f = f_mut, t = t_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                if (f(SetTreeLeaf$1__get_Key(t2)) ? true : SetTreeModule_exists(f, SetTreeNode$1__get_Left(t2))) {\r\n                    return true;\r\n                }\r\n                else {\r\n                    f_mut = f;\r\n                    t_mut = SetTreeNode$1__get_Right(t2);\r\n                    continue SetTreeModule_exists;\r\n                }\r\n            }\r\n            else {\r\n                return f(SetTreeLeaf$1__get_Key(t2));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_subset(comparer, a, b) {\r\n    return SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a);\r\n}\r\n\r\nexport function SetTreeModule_properSubset(comparer, a, b) {\r\n    if (SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a)) {\r\n        return SetTreeModule_exists((x_1) => (!SetTreeModule_mem(comparer, x_1, a)), b);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_filterAux(comparer_mut, f_mut, t_mut, acc_mut) {\r\n    SetTreeModule_filterAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_1 = f(SetTreeLeaf$1__get_Key(t2)) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc) : acc;\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_filterAux(comparer, f, SetTreeNode$1__get_Right(t2), acc_1);\r\n                continue SetTreeModule_filterAux;\r\n            }\r\n            else if (f(SetTreeLeaf$1__get_Key(t2))) {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_filter(comparer, f, s) {\r\n    return SetTreeModule_filterAux(comparer, f, s, SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_diffAux(comparer_mut, t_mut, acc_mut) {\r\n    SetTreeModule_diffAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, t = t_mut, acc = acc_mut;\r\n        if (acc == null) {\r\n            return acc;\r\n        }\r\n        else if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                comparer_mut = comparer;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = SetTreeModule_diffAux(comparer, SetTreeNode$1__get_Right(t2), SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc));\r\n                continue SetTreeModule_diffAux;\r\n            }\r\n            else {\r\n                return SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_diff(comparer, a, b) {\r\n    return SetTreeModule_diffAux(comparer, b, a);\r\n}\r\n\r\nexport function SetTreeModule_union(comparer, t1, t2) {\r\n    if (t1 != null) {\r\n        const t1$0027 = t1;\r\n        if (t2 != null) {\r\n            const t2$0027 = t2;\r\n            if (t1$0027 instanceof SetTreeNode$1) {\r\n                if (t2$0027 instanceof SetTreeNode$1) {\r\n                    if (SetTreeNode$1__get_Height(t1$0027) > SetTreeNode$1__get_Height(t2$0027)) {\r\n                        const patternInput = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\r\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t1$0027), patternInput[0]), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t1$0027), patternInput[2]));\r\n                    }\r\n                    else {\r\n                        const patternInput_1 = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\r\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t2$0027), patternInput_1[0]), SetTreeLeaf$1__get_Key(t2$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t2$0027), patternInput_1[2]));\r\n                    }\r\n                }\r\n                else {\r\n                    return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\r\n                }\r\n            }\r\n            else {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\r\n            }\r\n        }\r\n        else {\r\n            return t1;\r\n        }\r\n    }\r\n    else {\r\n        return t2;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_intersectionAux(comparer_mut, b_mut, t_mut, acc_mut) {\r\n    SetTreeModule_intersectionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, b = b_mut, t = t_mut, acc = acc_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_1 = SetTreeModule_intersectionAux(comparer, b, SetTreeNode$1__get_Right(t2), acc);\r\n                const acc_2 = SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc_1) : acc_1;\r\n                comparer_mut = comparer;\r\n                b_mut = b;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_mut = acc_2;\r\n                continue SetTreeModule_intersectionAux;\r\n            }\r\n            else if (SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b)) {\r\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_intersection(comparer, a, b) {\r\n    return SetTreeModule_intersectionAux(comparer, b, a, SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_partition1(comparer, f, k, acc1, acc2) {\r\n    if (f(k)) {\r\n        return [SetTreeModule_add(comparer, k, acc1), acc2];\r\n    }\r\n    else {\r\n        return [acc1, SetTreeModule_add(comparer, k, acc2)];\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_partitionAux(comparer_mut, f_mut, t_mut, acc_0_mut, acc_1_mut) {\r\n    SetTreeModule_partitionAux:\r\n    while (true) {\r\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\r\n        const acc = [acc_0, acc_1];\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                const acc_2 = SetTreeModule_partitionAux(comparer, f, SetTreeNode$1__get_Right(t2), acc[0], acc[1]);\r\n                const acc_3 = SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc_2[0], acc_2[1]);\r\n                comparer_mut = comparer;\r\n                f_mut = f;\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                acc_0_mut = acc_3[0];\r\n                acc_1_mut = acc_3[1];\r\n                continue SetTreeModule_partitionAux;\r\n            }\r\n            else {\r\n                return SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc[0], acc[1]);\r\n            }\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_partition(comparer, f, s) {\r\n    return SetTreeModule_partitionAux(comparer, f, s, SetTreeModule_empty(), SetTreeModule_empty());\r\n}\r\n\r\nexport function SetTreeModule_minimumElementAux(t_mut, n_mut) {\r\n    SetTreeModule_minimumElementAux:\r\n    while (true) {\r\n        const t = t_mut, n = n_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Left(t2);\r\n                n_mut = SetTreeLeaf$1__get_Key(t2);\r\n                continue SetTreeModule_minimumElementAux;\r\n            }\r\n            else {\r\n                return SetTreeLeaf$1__get_Key(t2);\r\n            }\r\n        }\r\n        else {\r\n            return n;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_minimumElementOpt(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            return some(SetTreeModule_minimumElementAux(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2)));\r\n        }\r\n        else {\r\n            return some(SetTreeLeaf$1__get_Key(t2));\r\n        }\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElementAux(t_mut, n_mut) {\r\n    SetTreeModule_maximumElementAux:\r\n    while (true) {\r\n        const t = t_mut, n = n_mut;\r\n        if (t != null) {\r\n            const t2 = t;\r\n            if (t2 instanceof SetTreeNode$1) {\r\n                t_mut = SetTreeNode$1__get_Right(t2);\r\n                n_mut = SetTreeLeaf$1__get_Key(t2);\r\n                continue SetTreeModule_maximumElementAux;\r\n            }\r\n            else {\r\n                return SetTreeLeaf$1__get_Key(t2);\r\n            }\r\n        }\r\n        else {\r\n            return n;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElementOpt(t) {\r\n    if (t != null) {\r\n        const t2 = t;\r\n        if (t2 instanceof SetTreeNode$1) {\r\n            return some(SetTreeModule_maximumElementAux(SetTreeNode$1__get_Right(t2), SetTreeLeaf$1__get_Key(t2)));\r\n        }\r\n        else {\r\n            return some(SetTreeLeaf$1__get_Key(t2));\r\n        }\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_minimumElement(s) {\r\n    const matchValue = SetTreeModule_minimumElementOpt(s);\r\n    if (matchValue == null) {\r\n        throw (new Error(\"Set contains no elements\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_maximumElement(s) {\r\n    const matchValue = SetTreeModule_maximumElementOpt(s);\r\n    if (matchValue == null) {\r\n        throw (new Error(\"Set contains no elements\"));\r\n    }\r\n    else {\r\n        return value_1(matchValue);\r\n    }\r\n}\r\n\r\nexport class SetTreeModule_SetIterator$1 extends Record {\r\n    constructor(stack, started) {\r\n        super();\r\n        this.stack = stack;\r\n        this.started = started;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_SetIterator$1$reflection(gen0) {\r\n    return record_type(\"Set.SetTreeModule.SetIterator`1\", [gen0], SetTreeModule_SetIterator$1, () => [[\"stack\", list_type(option_type(SetTreeLeaf$1$reflection(gen0)))], [\"started\", bool_type]]);\r\n}\r\n\r\nexport function SetTreeModule_collapseLHS(stack_mut) {\r\n    SetTreeModule_collapseLHS:\r\n    while (true) {\r\n        const stack = stack_mut;\r\n        if (!isEmpty_1(stack)) {\r\n            const x = head(stack);\r\n            const rest = tail(stack);\r\n            if (x != null) {\r\n                const x2 = x;\r\n                if (x2 instanceof SetTreeNode$1) {\r\n                    stack_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2)), SetTreeNode$1__get_Right(x2)], rest);\r\n                    continue SetTreeModule_collapseLHS;\r\n                }\r\n                else {\r\n                    return stack;\r\n                }\r\n            }\r\n            else {\r\n                stack_mut = rest;\r\n                continue SetTreeModule_collapseLHS;\r\n            }\r\n        }\r\n        else {\r\n            return empty_1();\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mkIterator(s) {\r\n    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(singleton_1(s)), false);\r\n}\r\n\r\nexport function SetTreeModule_notStarted() {\r\n    throw (new Error(\"Enumeration not started\"));\r\n}\r\n\r\nexport function SetTreeModule_alreadyFinished() {\r\n    throw (new Error(\"Enumeration already started\"));\r\n}\r\n\r\nexport function SetTreeModule_current(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (isEmpty_1(matchValue)) {\r\n            return SetTreeModule_alreadyFinished();\r\n        }\r\n        else if (head(matchValue) != null) {\r\n            const t = head(matchValue);\r\n            return SetTreeLeaf$1__get_Key(t);\r\n        }\r\n        else {\r\n            throw (new Error(\"Please report error: Set iterator, unexpected stack for current\"));\r\n        }\r\n    }\r\n    else {\r\n        return SetTreeModule_notStarted();\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_moveNext(i) {\r\n    if (i.started) {\r\n        const matchValue = i.stack;\r\n        if (!isEmpty_1(matchValue)) {\r\n            if (head(matchValue) != null) {\r\n                const t = head(matchValue);\r\n                if (t instanceof SetTreeNode$1) {\r\n                    throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\r\n                }\r\n                else {\r\n                    i.stack = SetTreeModule_collapseLHS(tail(matchValue));\r\n                    return !isEmpty_1(i.stack);\r\n                }\r\n            }\r\n            else {\r\n                throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\r\n            }\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    else {\r\n        i.started = true;\r\n        return !isEmpty_1(i.stack);\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_mkIEnumerator(s) {\r\n    let i = SetTreeModule_mkIterator(s);\r\n    return {\r\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\r\n            return SetTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.get_Current\"]() {\r\n            return SetTreeModule_current(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\r\n            return SetTreeModule_moveNext(i);\r\n        },\r\n        [\"System.Collections.IEnumerator.Reset\"]() {\r\n            i = SetTreeModule_mkIterator(s);\r\n        },\r\n        Dispose() {\r\n        },\r\n    };\r\n}\r\n\r\nexport function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {\r\n    SetTreeModule_compareStacks:\r\n    while (true) {\r\n        const comparer = comparer_mut, l1 = l1_mut, l2 = l2_mut;\r\n        const matchValue = [l1, l2];\r\n        if (!isEmpty_1(matchValue[0])) {\r\n            if (!isEmpty_1(matchValue[1])) {\r\n                if (head(matchValue[1]) != null) {\r\n                    if (head(matchValue[0]) != null) {\r\n                        const x1_3 = head(matchValue[0]);\r\n                        const x2_3 = head(matchValue[1]);\r\n                        if (x1_3 instanceof SetTreeNode$1) {\r\n                            if (SetTreeNode$1__get_Left(x1_3) == null) {\r\n                                if (x2_3 instanceof SetTreeNode$1) {\r\n                                    if (SetTreeNode$1__get_Left(x2_3) == null) {\r\n                                        const c = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                        if (c !== 0) {\r\n                                            return c | 0;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = cons(SetTreeNode$1__get_Right(x1_3), tail(matchValue[0]));\r\n                                            l2_mut = cons(SetTreeNode$1__get_Right(x2_3), tail(matchValue[1]));\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        const matchValue_3 = [l1, l2];\r\n                                        let pattern_matching_result, t1_6, x1_4, t2_6, x2_4;\r\n                                        if (!isEmpty_1(matchValue_3[0])) {\r\n                                            if (head(matchValue_3[0]) != null) {\r\n                                                pattern_matching_result = 0;\r\n                                                t1_6 = tail(matchValue_3[0]);\r\n                                                x1_4 = head(matchValue_3[0]);\r\n                                            }\r\n                                            else if (!isEmpty_1(matchValue_3[1])) {\r\n                                                if (head(matchValue_3[1]) != null) {\r\n                                                    pattern_matching_result = 1;\r\n                                                    t2_6 = tail(matchValue_3[1]);\r\n                                                    x2_4 = head(matchValue_3[1]);\r\n                                                }\r\n                                                else {\r\n                                                    pattern_matching_result = 2;\r\n                                                }\r\n                                            }\r\n                                            else {\r\n                                                pattern_matching_result = 2;\r\n                                            }\r\n                                        }\r\n                                        else if (!isEmpty_1(matchValue_3[1])) {\r\n                                            if (head(matchValue_3[1]) != null) {\r\n                                                pattern_matching_result = 1;\r\n                                                t2_6 = tail(matchValue_3[1]);\r\n                                                x2_4 = head(matchValue_3[1]);\r\n                                            }\r\n                                            else {\r\n                                                pattern_matching_result = 2;\r\n                                            }\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result = 2;\r\n                                        }\r\n                                        switch (pattern_matching_result) {\r\n                                            case 0: {\r\n                                                if (x1_4 instanceof SetTreeNode$1) {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_4), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_4), 0)], t1_6);\r\n                                                    l2_mut = l2;\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                                else {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_4))], t1_6);\r\n                                                    l2_mut = l2;\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                            }\r\n                                            case 1: {\r\n                                                if (x2_4 instanceof SetTreeNode$1) {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = l1;\r\n                                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_4), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_4), 0)], t2_6);\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                                else {\r\n                                                    comparer_mut = comparer;\r\n                                                    l1_mut = l1;\r\n                                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_4))], t2_6);\r\n                                                    continue SetTreeModule_compareStacks;\r\n                                                }\r\n                                            }\r\n                                            case 2: {\r\n                                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                            }\r\n                                        }\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                    if (c_1 !== 0) {\r\n                                        return c_1 | 0;\r\n                                    }\r\n                                    else {\r\n                                        comparer_mut = comparer;\r\n                                        l1_mut = cons(SetTreeNode$1__get_Right(x1_3), tail(matchValue[0]));\r\n                                        l2_mut = cons(SetTreeModule_empty(), tail(matchValue[1]));\r\n                                        continue SetTreeModule_compareStacks;\r\n                                    }\r\n                                }\r\n                            }\r\n                            else {\r\n                                const matchValue_4 = [l1, l2];\r\n                                let pattern_matching_result_1, t1_7, x1_5, t2_7, x2_5;\r\n                                if (!isEmpty_1(matchValue_4[0])) {\r\n                                    if (head(matchValue_4[0]) != null) {\r\n                                        pattern_matching_result_1 = 0;\r\n                                        t1_7 = tail(matchValue_4[0]);\r\n                                        x1_5 = head(matchValue_4[0]);\r\n                                    }\r\n                                    else if (!isEmpty_1(matchValue_4[1])) {\r\n                                        if (head(matchValue_4[1]) != null) {\r\n                                            pattern_matching_result_1 = 1;\r\n                                            t2_7 = tail(matchValue_4[1]);\r\n                                            x2_5 = head(matchValue_4[1]);\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result_1 = 2;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_1 = 2;\r\n                                    }\r\n                                }\r\n                                else if (!isEmpty_1(matchValue_4[1])) {\r\n                                    if (head(matchValue_4[1]) != null) {\r\n                                        pattern_matching_result_1 = 1;\r\n                                        t2_7 = tail(matchValue_4[1]);\r\n                                        x2_5 = head(matchValue_4[1]);\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_1 = 2;\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_1 = 2;\r\n                                }\r\n                                switch (pattern_matching_result_1) {\r\n                                    case 0: {\r\n                                        if (x1_5 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_5), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_5), 0)], t1_7);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_5))], t1_7);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 1: {\r\n                                        if (x2_5 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_5), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_5), 0)], t2_7);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_5))], t2_7);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 2: {\r\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        else if (x2_3 instanceof SetTreeNode$1) {\r\n                            if (SetTreeNode$1__get_Left(x2_3) == null) {\r\n                                const c_2 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                                if (c_2 !== 0) {\r\n                                    return c_2 | 0;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = cons(SetTreeModule_empty(), tail(matchValue[0]));\r\n                                    l2_mut = cons(SetTreeNode$1__get_Right(x2_3), tail(matchValue[1]));\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            else {\r\n                                const matchValue_5 = [l1, l2];\r\n                                let pattern_matching_result_2, t1_8, x1_6, t2_8, x2_6;\r\n                                if (!isEmpty_1(matchValue_5[0])) {\r\n                                    if (head(matchValue_5[0]) != null) {\r\n                                        pattern_matching_result_2 = 0;\r\n                                        t1_8 = tail(matchValue_5[0]);\r\n                                        x1_6 = head(matchValue_5[0]);\r\n                                    }\r\n                                    else if (!isEmpty_1(matchValue_5[1])) {\r\n                                        if (head(matchValue_5[1]) != null) {\r\n                                            pattern_matching_result_2 = 1;\r\n                                            t2_8 = tail(matchValue_5[1]);\r\n                                            x2_6 = head(matchValue_5[1]);\r\n                                        }\r\n                                        else {\r\n                                            pattern_matching_result_2 = 2;\r\n                                        }\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_2 = 2;\r\n                                    }\r\n                                }\r\n                                else if (!isEmpty_1(matchValue_5[1])) {\r\n                                    if (head(matchValue_5[1]) != null) {\r\n                                        pattern_matching_result_2 = 1;\r\n                                        t2_8 = tail(matchValue_5[1]);\r\n                                        x2_6 = head(matchValue_5[1]);\r\n                                    }\r\n                                    else {\r\n                                        pattern_matching_result_2 = 2;\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_2 = 2;\r\n                                }\r\n                                switch (pattern_matching_result_2) {\r\n                                    case 0: {\r\n                                        if (x1_6 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_6), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_6), 0)], t1_8);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_6))], t1_8);\r\n                                            l2_mut = l2;\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 1: {\r\n                                        if (x2_6 instanceof SetTreeNode$1) {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_6), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_6), 0)], t2_8);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                        else {\r\n                                            comparer_mut = comparer;\r\n                                            l1_mut = l1;\r\n                                            l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_6))], t2_8);\r\n                                            continue SetTreeModule_compareStacks;\r\n                                        }\r\n                                    }\r\n                                    case 2: {\r\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                        else {\r\n                            const c_3 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\r\n                            if (c_3 !== 0) {\r\n                                return c_3 | 0;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = tail(matchValue[0]);\r\n                                l2_mut = tail(matchValue[1]);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                    }\r\n                    else {\r\n                        const x2 = head(matchValue[1]);\r\n                        const matchValue_1 = [l1, l2];\r\n                        let pattern_matching_result_3, t1_2, x1, t2_2, x2_1;\r\n                        if (!isEmpty_1(matchValue_1[0])) {\r\n                            if (head(matchValue_1[0]) != null) {\r\n                                pattern_matching_result_3 = 0;\r\n                                t1_2 = tail(matchValue_1[0]);\r\n                                x1 = head(matchValue_1[0]);\r\n                            }\r\n                            else if (!isEmpty_1(matchValue_1[1])) {\r\n                                if (head(matchValue_1[1]) != null) {\r\n                                    pattern_matching_result_3 = 1;\r\n                                    t2_2 = tail(matchValue_1[1]);\r\n                                    x2_1 = head(matchValue_1[1]);\r\n                                }\r\n                                else {\r\n                                    pattern_matching_result_3 = 2;\r\n                                }\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_3 = 2;\r\n                            }\r\n                        }\r\n                        else if (!isEmpty_1(matchValue_1[1])) {\r\n                            if (head(matchValue_1[1]) != null) {\r\n                                pattern_matching_result_3 = 1;\r\n                                t2_2 = tail(matchValue_1[1]);\r\n                                x2_1 = head(matchValue_1[1]);\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_3 = 2;\r\n                            }\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_3 = 2;\r\n                        }\r\n                        switch (pattern_matching_result_3) {\r\n                            case 0: {\r\n                                if (x1 instanceof SetTreeNode$1) {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1), 0)], t1_2);\r\n                                    l2_mut = l2;\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1))], t1_2);\r\n                                    l2_mut = l2;\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            case 1: {\r\n                                if (x2_1 instanceof SetTreeNode$1) {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = l1;\r\n                                    l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_1), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_1), 0)], t2_2);\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                                else {\r\n                                    comparer_mut = comparer;\r\n                                    l1_mut = l1;\r\n                                    l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_1))], t2_2);\r\n                                    continue SetTreeModule_compareStacks;\r\n                                }\r\n                            }\r\n                            case 2: {\r\n                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                else if (head(matchValue[0]) != null) {\r\n                    const x1_1 = head(matchValue[0]);\r\n                    const matchValue_2 = [l1, l2];\r\n                    let pattern_matching_result_4, t1_4, x1_2, t2_4, x2_2;\r\n                    if (!isEmpty_1(matchValue_2[0])) {\r\n                        if (head(matchValue_2[0]) != null) {\r\n                            pattern_matching_result_4 = 0;\r\n                            t1_4 = tail(matchValue_2[0]);\r\n                            x1_2 = head(matchValue_2[0]);\r\n                        }\r\n                        else if (!isEmpty_1(matchValue_2[1])) {\r\n                            if (head(matchValue_2[1]) != null) {\r\n                                pattern_matching_result_4 = 1;\r\n                                t2_4 = tail(matchValue_2[1]);\r\n                                x2_2 = head(matchValue_2[1]);\r\n                            }\r\n                            else {\r\n                                pattern_matching_result_4 = 2;\r\n                            }\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_4 = 2;\r\n                        }\r\n                    }\r\n                    else if (!isEmpty_1(matchValue_2[1])) {\r\n                        if (head(matchValue_2[1]) != null) {\r\n                            pattern_matching_result_4 = 1;\r\n                            t2_4 = tail(matchValue_2[1]);\r\n                            x2_2 = head(matchValue_2[1]);\r\n                        }\r\n                        else {\r\n                            pattern_matching_result_4 = 2;\r\n                        }\r\n                    }\r\n                    else {\r\n                        pattern_matching_result_4 = 2;\r\n                    }\r\n                    switch (pattern_matching_result_4) {\r\n                        case 0: {\r\n                            if (x1_2 instanceof SetTreeNode$1) {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x1_2), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_2), 0)], t1_4);\r\n                                l2_mut = l2;\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_2))], t1_4);\r\n                                l2_mut = l2;\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                        case 1: {\r\n                            if (x2_2 instanceof SetTreeNode$1) {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = l1;\r\n                                l2_mut = ofArrayWithTail([SetTreeNode$1__get_Left(x2_2), SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_2), 0)], t2_4);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                            else {\r\n                                comparer_mut = comparer;\r\n                                l1_mut = l1;\r\n                                l2_mut = ofArrayWithTail([SetTreeModule_empty(), SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_2))], t2_4);\r\n                                continue SetTreeModule_compareStacks;\r\n                            }\r\n                        }\r\n                        case 2: {\r\n                            throw (new Error(\"unexpected state in SetTree.compareStacks\"));\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    comparer_mut = comparer;\r\n                    l1_mut = tail(matchValue[0]);\r\n                    l2_mut = tail(matchValue[1]);\r\n                    continue SetTreeModule_compareStacks;\r\n                }\r\n            }\r\n            else {\r\n                return 1;\r\n            }\r\n        }\r\n        else if (isEmpty_1(matchValue[1])) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_compare(comparer, t1, t2) {\r\n    if (t1 == null) {\r\n        if (t2 == null) {\r\n            return 0;\r\n        }\r\n        else {\r\n            return -1;\r\n        }\r\n    }\r\n    else if (t2 == null) {\r\n        return 1;\r\n    }\r\n    else {\r\n        return SetTreeModule_compareStacks(comparer, singleton_1(t1), singleton_1(t2)) | 0;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_choose(s) {\r\n    return SetTreeModule_minimumElement(s);\r\n}\r\n\r\nexport function SetTreeModule_toList(t) {\r\n    const loop = (t$0027_mut, acc_mut) => {\r\n        loop:\r\n        while (true) {\r\n            const t$0027 = t$0027_mut, acc = acc_mut;\r\n            if (t$0027 != null) {\r\n                const t2 = t$0027;\r\n                if (t2 instanceof SetTreeNode$1) {\r\n                    t$0027_mut = SetTreeNode$1__get_Left(t2);\r\n                    acc_mut = cons(SetTreeLeaf$1__get_Key(t2), loop(SetTreeNode$1__get_Right(t2), acc));\r\n                    continue loop;\r\n                }\r\n                else {\r\n                    return cons(SetTreeLeaf$1__get_Key(t2), acc);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return loop(t, empty_1());\r\n}\r\n\r\nexport function SetTreeModule_copyToArray(s, arr, i) {\r\n    let j = i;\r\n    SetTreeModule_iter((x) => {\r\n        arr[j] = x;\r\n        j = ((j + 1) | 0);\r\n    }, s);\r\n}\r\n\r\nexport function SetTreeModule_toArray(s) {\r\n    const n = SetTreeModule_count(s) | 0;\r\n    const res = fill(new Array(n), 0, n, null);\r\n    SetTreeModule_copyToArray(s, res, 0);\r\n    return res;\r\n}\r\n\r\nexport function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\r\n    SetTreeModule_mkFromEnumerator:\r\n    while (true) {\r\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\r\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            comparer_mut = comparer;\r\n            acc_mut = SetTreeModule_add(comparer, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), acc);\r\n            e_mut = e;\r\n            continue SetTreeModule_mkFromEnumerator;\r\n        }\r\n        else {\r\n            return acc;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function SetTreeModule_ofArray(comparer, l) {\r\n    return fold_1((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\r\n}\r\n\r\nexport function SetTreeModule_ofList(comparer, l) {\r\n    return fold_2((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\r\n}\r\n\r\nexport function SetTreeModule_ofSeq(comparer, c) {\r\n    if (isArrayLike(c)) {\r\n        return SetTreeModule_ofArray(comparer, c);\r\n    }\r\n    else if (c instanceof FSharpList) {\r\n        return SetTreeModule_ofList(comparer, c);\r\n    }\r\n    else {\r\n        const ie = getEnumerator(c);\r\n        try {\r\n            return SetTreeModule_mkFromEnumerator(comparer, SetTreeModule_empty(), ie);\r\n        }\r\n        finally {\r\n            disposeSafe(ie);\r\n        }\r\n    }\r\n}\r\n\r\nexport class FSharpSet {\r\n    constructor(comparer, tree) {\r\n        this.comparer = comparer;\r\n        this.tree = tree;\r\n    }\r\n    GetHashCode() {\r\n        const this$ = this;\r\n        return FSharpSet__ComputeHashCode(this$) | 0;\r\n    }\r\n    Equals(that) {\r\n        const this$ = this;\r\n        return (that instanceof FSharpSet) && (SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that)) === 0);\r\n    }\r\n    toString() {\r\n        const this$ = this;\r\n        return (\"set [\" + join(\"; \", map_1((x) => {\r\n            let copyOfStruct = x;\r\n            return toString(copyOfStruct);\r\n        }, this$))) + \"]\";\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"FSharpSet\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    CompareTo(that) {\r\n        const s = this;\r\n        return SetTreeModule_compare(FSharpSet__get_Comparer(s), FSharpSet__get_Tree(s), FSharpSet__get_Tree(that)) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\r\n        throw (new Error(\"ReadOnlyCollection\"));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\r\n        const s = this;\r\n        return SetTreeModule_mem(FSharpSet__get_Comparer(s), x, FSharpSet__get_Tree(s));\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\r\n        const s = this;\r\n        SetTreeModule_copyToArray(FSharpSet__get_Tree(s), arr, i);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return true;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    GetEnumerator() {\r\n        const s = this;\r\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const s = this;\r\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\r\n    }\r\n    get size() {\r\n        const s = this;\r\n        return FSharpSet__get_Count(s) | 0;\r\n    }\r\n    add(k) {\r\n        const s = this;\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n        return s;\r\n    }\r\n    clear() {\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n    }\r\n    delete(k) {\r\n        throw (new Error(\"Set cannot be mutated\"));\r\n        return false;\r\n    }\r\n    has(k) {\r\n        const s = this;\r\n        return FSharpSet__Contains(s, k);\r\n    }\r\n    keys() {\r\n        const s = this;\r\n        return map_1((x) => x, s);\r\n    }\r\n    values() {\r\n        const s = this;\r\n        return map_1((x) => x, s);\r\n    }\r\n    entries() {\r\n        const s = this;\r\n        return map_1((v) => [v, v], s);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const s = this;\r\n        iterate_1((x) => {\r\n            f(x, x, s);\r\n        }, s);\r\n    }\r\n}\r\n\r\nexport function FSharpSet$reflection(gen0) {\r\n    return class_type(\"Set.FSharpSet\", [gen0], FSharpSet);\r\n}\r\n\r\nexport function FSharpSet_$ctor(comparer, tree) {\r\n    return new FSharpSet(comparer, tree);\r\n}\r\n\r\nexport function FSharpSet__get_Comparer(set$) {\r\n    return set$.comparer;\r\n}\r\n\r\nexport function FSharpSet__get_Tree(set$) {\r\n    return set$.tree;\r\n}\r\n\r\nexport function FSharpSet_Empty(comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_empty());\r\n}\r\n\r\nexport function FSharpSet__Add(s, value) {\r\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_add(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__Remove(s, value) {\r\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_remove(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__get_Count(s) {\r\n    return SetTreeModule_count(FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Contains(s, value) {\r\n    return SetTreeModule_mem(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Iterate(s, x) {\r\n    SetTreeModule_iter(x, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__Fold(s, f, z) {\r\n    const f_1 = f;\r\n    return SetTreeModule_fold((x, z_1) => f_1(z_1, x), z, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__get_IsEmpty(s) {\r\n    return FSharpSet__get_Tree(s) == null;\r\n}\r\n\r\nexport function FSharpSet__Partition(s, f) {\r\n    if (FSharpSet__get_Tree(s) == null) {\r\n        return [s, s];\r\n    }\r\n    else {\r\n        const patternInput = SetTreeModule_partition(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s));\r\n        return [FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[0]), FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[1])];\r\n    }\r\n}\r\n\r\nexport function FSharpSet__Filter(s, f) {\r\n    if (FSharpSet__get_Tree(s) == null) {\r\n        return s;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_filter(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet__Map(s, f, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_fold((acc, k) => SetTreeModule_add(comparer, f(k), acc), SetTreeModule_empty(), FSharpSet__get_Tree(s)));\r\n}\r\n\r\nexport function FSharpSet__Exists(s, f) {\r\n    return SetTreeModule_exists(f, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet__ForAll(s, f) {\r\n    return SetTreeModule_forall(f, FSharpSet__get_Tree(s));\r\n}\r\n\r\nexport function FSharpSet_op_Subtraction(set1, set2) {\r\n    if (FSharpSet__get_Tree(set1) == null) {\r\n        return set1;\r\n    }\r\n    else if (FSharpSet__get_Tree(set2) == null) {\r\n        return set1;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_diff(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_op_Addition(set1, set2) {\r\n    if (FSharpSet__get_Tree(set2) == null) {\r\n        return set1;\r\n    }\r\n    else if (FSharpSet__get_Tree(set1) == null) {\r\n        return set2;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_union(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_Intersection(a, b) {\r\n    if (FSharpSet__get_Tree(b) == null) {\r\n        return b;\r\n    }\r\n    else if (FSharpSet__get_Tree(a) == null) {\r\n        return a;\r\n    }\r\n    else {\r\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(a), SetTreeModule_intersection(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)));\r\n    }\r\n}\r\n\r\nexport function FSharpSet_IntersectionMany(sets) {\r\n    return reduce(FSharpSet_Intersection, sets);\r\n}\r\n\r\nexport function FSharpSet_Equality(a, b) {\r\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) === 0;\r\n}\r\n\r\nexport function FSharpSet_Compare(a, b) {\r\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b));\r\n}\r\n\r\nexport function FSharpSet__get_Choose(x) {\r\n    return SetTreeModule_choose(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__get_MinimumElement(x) {\r\n    return SetTreeModule_minimumElement(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__get_MaximumElement(x) {\r\n    return SetTreeModule_maximumElement(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__IsSubsetOf(x, otherSet) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\r\n}\r\n\r\nexport function FSharpSet__IsSupersetOf(x, otherSet) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__IsProperSubsetOf(x, otherSet) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\r\n}\r\n\r\nexport function FSharpSet__IsProperSupersetOf(x, otherSet) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ToList(x) {\r\n    return SetTreeModule_toList(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ToArray(x) {\r\n    return SetTreeModule_toArray(FSharpSet__get_Tree(x));\r\n}\r\n\r\nexport function FSharpSet__ComputeHashCode(this$) {\r\n    let y;\r\n    let res = 0;\r\n    const enumerator = getEnumerator(this$);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const x_1 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            res = (((y = (structuralHash(x_1) | 0), ((res << 1) + y) + 631)) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return Math.abs(res) | 0;\r\n}\r\n\r\nexport function isEmpty(set$) {\r\n    return FSharpSet__get_IsEmpty(set$);\r\n}\r\n\r\nexport function contains(element, set$) {\r\n    return FSharpSet__Contains(set$, element);\r\n}\r\n\r\nexport function add(value, set$) {\r\n    return FSharpSet__Add(set$, value);\r\n}\r\n\r\nexport function singleton(value, comparer) {\r\n    return FSharpSet__Add(FSharpSet_Empty(comparer), value);\r\n}\r\n\r\nexport function remove(value, set$) {\r\n    return FSharpSet__Remove(set$, value);\r\n}\r\n\r\nexport function union(set1, set2) {\r\n    return FSharpSet_op_Addition(set1, set2);\r\n}\r\n\r\nexport function unionMany(sets, comparer) {\r\n    return fold_3(FSharpSet_op_Addition, FSharpSet_Empty(comparer), sets);\r\n}\r\n\r\nexport function intersect(set1, set2) {\r\n    return FSharpSet_Intersection(set1, set2);\r\n}\r\n\r\nexport function intersectMany(sets) {\r\n    return FSharpSet_IntersectionMany(sets);\r\n}\r\n\r\nexport function iterate(action, set$) {\r\n    FSharpSet__Iterate(set$, action);\r\n}\r\n\r\nexport function empty(comparer) {\r\n    return FSharpSet_Empty(comparer);\r\n}\r\n\r\nexport function forAll(predicate, set$) {\r\n    return FSharpSet__ForAll(set$, predicate);\r\n}\r\n\r\nexport function exists(predicate, set$) {\r\n    return FSharpSet__Exists(set$, predicate);\r\n}\r\n\r\nexport function filter(predicate, set$) {\r\n    return FSharpSet__Filter(set$, predicate);\r\n}\r\n\r\nexport function partition(predicate, set$) {\r\n    return FSharpSet__Partition(set$, predicate);\r\n}\r\n\r\nexport function fold(folder, state, set$) {\r\n    return SetTreeModule_fold(folder, state, FSharpSet__get_Tree(set$));\r\n}\r\n\r\nexport function foldBack(folder, set$, state) {\r\n    return SetTreeModule_foldBack(folder, FSharpSet__get_Tree(set$), state);\r\n}\r\n\r\nexport function map(mapping, set$, comparer) {\r\n    return FSharpSet__Map(set$, mapping, comparer);\r\n}\r\n\r\nexport function count(set$) {\r\n    return FSharpSet__get_Count(set$);\r\n}\r\n\r\nexport function ofList(elements, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\r\n}\r\n\r\nexport function ofArray(array, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofArray(comparer, array));\r\n}\r\n\r\nexport function toList(set$) {\r\n    return FSharpSet__ToList(set$);\r\n}\r\n\r\nexport function toArray(set$) {\r\n    return FSharpSet__ToArray(set$);\r\n}\r\n\r\nexport function toSeq(set$) {\r\n    return map_1((x) => x, set$);\r\n}\r\n\r\nexport function ofSeq(elements, comparer) {\r\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\r\n}\r\n\r\nexport function difference(set1, set2) {\r\n    return FSharpSet_op_Subtraction(set1, set2);\r\n}\r\n\r\nexport function isSubset(set1, set2) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\r\n}\r\n\r\nexport function isSuperset(set1, set2) {\r\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\r\n}\r\n\r\nexport function isProperSubset(set1, set2) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\r\n}\r\n\r\nexport function isProperSuperset(set1, set2) {\r\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\r\n}\r\n\r\nexport function minElement(set$) {\r\n    return FSharpSet__get_MinimumElement(set$);\r\n}\r\n\r\nexport function maxElement(set$) {\r\n    return FSharpSet__get_MaximumElement(set$);\r\n}\r\n\r\nexport function unionWith(s1, s2) {\r\n    return fold_3((acc, x) => acc.add(x), s1, s2);\r\n}\r\n\r\nexport function newMutableSetWith(s1, s2) {\r\n    if (s1 instanceof HashSet) {\r\n        return HashSet_$ctor_Z6150332D(s2, HashSet__get_Comparer(s1));\r\n    }\r\n    else {\r\n        return new Set(s2);\r\n    }\r\n}\r\n\r\nexport function intersectWith(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    iterate_1((x) => {\r\n        if (!s2_1.has(x)) {\r\n            s1.delete(x);\r\n        }\r\n    }, s1.values());\r\n}\r\n\r\nexport function exceptWith(s1, s2) {\r\n    iterate_1((x) => {\r\n        s1.delete(x);\r\n    }, s2);\r\n}\r\n\r\nexport function isSubsetOf(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    return forAll_1((arg00) => s2_1.has(arg00), s1.values());\r\n}\r\n\r\nexport function isSupersetOf(s1, s2) {\r\n    return forAll_1((arg00) => s1.has(arg00), s2);\r\n}\r\n\r\nexport function isProperSubsetOf(s1, s2) {\r\n    const s2_1 = newMutableSetWith(s1, s2);\r\n    if (s2_1.size > s1.size) {\r\n        return forAll_1((arg00) => s2_1.has(arg00), s1.values());\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function isProperSupersetOf(s1, s2) {\r\n    const s2_1 = cache(s2);\r\n    if (exists_1((arg) => (!s1.has(arg)), s2_1)) {\r\n        return forAll_1((arg00_1) => s1.has(arg00_1), s2_1);\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\n","import { Union, Record } from \"../fable-library.3.7.5/Types.js\";\nimport { union_type, tuple_type, lambda_type, unit_type, array_type, record_type, class_type, string_type } from \"../fable-library.3.7.5/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\", \"Uri\", \"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 { disposeSafe, equals, toIterator, getEnumerator } from \"./Util.js\";\r\nimport { iterate, map, delay, toArray, iterateIndexed, concat } from \"./Seq.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\r\nimport { format } from \"./String.js\";\r\n\r\nexport class Dictionary {\r\n    constructor(pairs, comparer) {\r\n        const this$ = new FSharpRef(null);\r\n        this.comparer = comparer;\r\n        this$.contents = this;\r\n        this.hashMap = (new Map([]));\r\n        this[\"init@8-1\"] = 1;\r\n        const enumerator = getEnumerator(pairs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const pair = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                Dictionary__Add_5BDDA1(this$.contents, pair[0], pair[1]);\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"Dictionary\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const this$ = this;\r\n        return getEnumerator(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const this$ = this;\r\n        return getEnumerator(concat(this$.hashMap.values()));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\r\n        const this$ = this;\r\n        Dictionary__Add_5BDDA1(this$, item[0], item[1]);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        const this$ = this;\r\n        Dictionary__Clear(this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\r\n        let pattern_matching_result;\r\n        if (matchValue != null) {\r\n            if (equals(matchValue[1], item[1])) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return true;\r\n            }\r\n            case 1: {\r\n                return false;\r\n            }\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\r\n        const this$ = this;\r\n        iterateIndexed((i, e) => {\r\n            array[arrayIndex + i] = e;\r\n        }, this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const this$ = this;\r\n        return Dictionary__get_Count(this$) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return false;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\r\n        if (matchValue != null) {\r\n            if (equals(matchValue[1], item[1])) {\r\n                Dictionary__Remove_2B595(this$, item[0]);\r\n            }\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.Add5BDDA1\"](key, value) {\r\n        const this$ = this;\r\n        Dictionary__Add_5BDDA1(this$, key, value);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.ContainsKey2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__ContainsKey_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Item2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__get_Item_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.set_Item5BDDA1\"](key, v) {\r\n        const this$ = this;\r\n        Dictionary__set_Item_5BDDA1(this$, key, v);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Keys\"]() {\r\n        const this$ = this;\r\n        return toArray(delay(() => map((pair) => pair[0], this$)));\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.Remove2B595\"](key) {\r\n        const this$ = this;\r\n        return Dictionary__Remove_2B595(this$, key);\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.TryGetValue23A0B95A\"](key, value) {\r\n        const this$ = this;\r\n        const matchValue = Dictionary__TryFind_2B595(this$, key);\r\n        if (matchValue != null) {\r\n            const pair = matchValue;\r\n            value.contents = pair[1];\r\n            return true;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }\r\n    [\"System.Collections.Generic.IDictionary`2.get_Values\"]() {\r\n        const this$ = this;\r\n        return toArray(delay(() => map((pair) => pair[1], this$)));\r\n    }\r\n    get size() {\r\n        const this$ = this;\r\n        return Dictionary__get_Count(this$) | 0;\r\n    }\r\n    clear() {\r\n        const this$ = this;\r\n        Dictionary__Clear(this$);\r\n    }\r\n    delete(k) {\r\n        const this$ = this;\r\n        return Dictionary__Remove_2B595(this$, k);\r\n    }\r\n    entries() {\r\n        const this$ = this;\r\n        return map((p) => [p[0], p[1]], this$);\r\n    }\r\n    get(k) {\r\n        const this$ = this;\r\n        return Dictionary__get_Item_2B595(this$, k);\r\n    }\r\n    has(k) {\r\n        const this$ = this;\r\n        return Dictionary__ContainsKey_2B595(this$, k);\r\n    }\r\n    keys() {\r\n        const this$ = this;\r\n        return map((p) => p[0], this$);\r\n    }\r\n    set(k, v) {\r\n        const this$ = this;\r\n        Dictionary__set_Item_5BDDA1(this$, k, v);\r\n        return this$;\r\n    }\r\n    values() {\r\n        const this$ = this;\r\n        return map((p) => p[1], this$);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const this$ = this;\r\n        iterate((p) => {\r\n            f(p[1], p[0], this$);\r\n        }, this$);\r\n    }\r\n}\r\n\r\nexport function Dictionary$reflection(gen0, gen1) {\r\n    return class_type(\"Fable.Collections.Dictionary\", [gen0, gen1], Dictionary);\r\n}\r\n\r\nexport function Dictionary_$ctor_6623D9B3(pairs, comparer) {\r\n    return new Dictionary(pairs, comparer);\r\n}\r\n\r\nfunction Dictionary__TryFindIndex_2B595(this$, k) {\r\n    const h = this$.comparer.GetHashCode(k) | 0;\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return [true, h, matchValue[1].findIndex((pair) => this$.comparer.Equals(k, pair[0]))];\r\n    }\r\n    else {\r\n        return [false, h, -1];\r\n    }\r\n}\r\n\r\nexport function Dictionary__TryFind_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__get_Comparer(this$) {\r\n    return this$.comparer;\r\n}\r\n\r\nexport function Dictionary__Clear(this$) {\r\n    this$.hashMap.clear();\r\n}\r\n\r\nexport function Dictionary__get_Count(this$) {\r\n    let count = 0;\r\n    let enumerator = getEnumerator(this$.hashMap.values());\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const pairs = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            count = ((count + pairs.length) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return count | 0;\r\n}\r\n\r\nexport function Dictionary__get_Item_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFind_2B595(this$, k);\r\n    if (matchValue != null) {\r\n        return matchValue[1];\r\n    }\r\n    else {\r\n        throw (new Error(\"The item was not found in collection\"));\r\n    }\r\n}\r\n\r\nexport function Dictionary__set_Item_5BDDA1(this$, k, v) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];\r\n            break;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [[k, v]]);\r\n            }\r\n            break;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__Add_5BDDA1(this$, k, v) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            const msg = format(\"An item with the same key has already been added. Key: {0}\", k);\r\n            throw (new Error(msg));\r\n            break;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [[k, v]]);\r\n            }\r\n            break;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__ContainsKey_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport function Dictionary__Remove_2B595(this$, k) {\r\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\n","import { disposeSafe, toIterator, getEnumerator } from \"./Util.js\";\r\nimport { iterate, map, iterateIndexed, concat } from \"./Seq.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\nimport { class_type } from \"./Reflection.js\";\r\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\r\nimport { some } from \"./Option.js\";\r\n\r\nexport class HashSet {\r\n    constructor(items, comparer) {\r\n        const this$ = new FSharpRef(null);\r\n        this.comparer = comparer;\r\n        this$.contents = this;\r\n        this.hashMap = (new Map([]));\r\n        this[\"init@8-2\"] = 1;\r\n        const enumerator = getEnumerator(items);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const item = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                HashSet__Add_2B595(this$.contents, item);\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n    }\r\n    get [Symbol.toStringTag]() {\r\n        return \"HashSet\";\r\n    }\r\n    toJSON(_key) {\r\n        const this$ = this;\r\n        return Array.from(this$);\r\n    }\r\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\r\n        const this$ = this;\r\n        return getEnumerator(this$);\r\n    }\r\n    GetEnumerator() {\r\n        const this$ = this;\r\n        return getEnumerator(concat(this$.hashMap.values()));\r\n    }\r\n    [Symbol.iterator]() {\r\n        return toIterator(this.GetEnumerator());\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\r\n        const this$ = this;\r\n        HashSet__Add_2B595(this$, item);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\r\n        const this$ = this;\r\n        HashSet__Clear(this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\r\n        const this$ = this;\r\n        return HashSet__Contains_2B595(this$, item);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\r\n        const this$ = this;\r\n        iterateIndexed((i, e) => {\r\n            array[arrayIndex + i] = e;\r\n        }, this$);\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\r\n        const this$ = this;\r\n        return HashSet__get_Count(this$) | 0;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\r\n        return false;\r\n    }\r\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\r\n        const this$ = this;\r\n        return HashSet__Remove_2B595(this$, item);\r\n    }\r\n    get size() {\r\n        const this$ = this;\r\n        return HashSet__get_Count(this$) | 0;\r\n    }\r\n    add(k) {\r\n        const this$ = this;\r\n        HashSet__Add_2B595(this$, k);\r\n        return this$;\r\n    }\r\n    clear() {\r\n        const this$ = this;\r\n        HashSet__Clear(this$);\r\n    }\r\n    delete(k) {\r\n        const this$ = this;\r\n        return HashSet__Remove_2B595(this$, k);\r\n    }\r\n    has(k) {\r\n        const this$ = this;\r\n        return HashSet__Contains_2B595(this$, k);\r\n    }\r\n    keys() {\r\n        const this$ = this;\r\n        return map((x) => x, this$);\r\n    }\r\n    values() {\r\n        const this$ = this;\r\n        return map((x) => x, this$);\r\n    }\r\n    entries() {\r\n        const this$ = this;\r\n        return map((v) => [v, v], this$);\r\n    }\r\n    forEach(f, thisArg) {\r\n        const this$ = this;\r\n        iterate((x) => {\r\n            f(x, x, this$);\r\n        }, this$);\r\n    }\r\n}\r\n\r\nexport function HashSet$reflection(gen0) {\r\n    return class_type(\"Fable.Collections.HashSet\", [gen0], HashSet);\r\n}\r\n\r\nexport function HashSet_$ctor_Z6150332D(items, comparer) {\r\n    return new HashSet(items, comparer);\r\n}\r\n\r\nfunction HashSet__TryFindIndex_2B595(this$, k) {\r\n    const h = this$.comparer.GetHashCode(k) | 0;\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return [true, h, matchValue[1].findIndex((v_1) => this$.comparer.Equals(k, v_1))];\r\n    }\r\n    else {\r\n        return [false, h, -1];\r\n    }\r\n}\r\n\r\nfunction HashSet__TryFind_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__get_Comparer(this$) {\r\n    return this$.comparer;\r\n}\r\n\r\nexport function HashSet__Clear(this$) {\r\n    this$.hashMap.clear();\r\n}\r\n\r\nexport function HashSet__get_Count(this$) {\r\n    let count = 0;\r\n    let enumerator = getEnumerator(this$.hashMap.values());\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const items = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            count = ((count + items.length) | 0);\r\n        }\r\n    }\r\n    finally {\r\n        disposeSafe(enumerator);\r\n    }\r\n    return count | 0;\r\n}\r\n\r\nexport function HashSet__Add_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return false;\r\n        }\r\n        case 1: {\r\n            if (matchValue[0]) {\r\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));\r\n                return true;\r\n            }\r\n            else {\r\n                this$.hashMap.set(matchValue[1], [k]);\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__Contains_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\nexport function HashSet__Remove_2B595(this$, k) {\r\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\r\n    let pattern_matching_result;\r\n    if (matchValue[0]) {\r\n        if (matchValue[2] > -1) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\r\n            return true;\r\n        }\r\n        case 1: {\r\n            return false;\r\n        }\r\n    }\r\n}\r\n\r\n","import { equals, getEnumUnderlyingType, isEnum, getTupleElements, isTuple, getElementType, isArray, getFunctionElements, isFunction, getUnionCases, getUnionCaseFields, isUnion, getGenerics, getRecordElements, name, isRecord, fullName } from \"../fable-library.3.7.5/Reflection.js\";\nimport { UnionCase, RecordField, TypeInfo } from \"./TypeInfo.fs.js\";\nimport { map } from \"../fable-library.3.7.5/Array.js\";\nimport { collect, singleton, append, delay, toArray } from \"../fable-library.3.7.5/Seq.js\";\nimport { structuralHash, Lazy } from \"../fable-library.3.7.5/Util.js\";\nimport { Dictionary } from \"../fable-library.3.7.5/MutableMap.js\";\nimport { tryGetValue } from \"../fable-library.3.7.5/MapUtil.js\";\nimport { FSharpRef } from \"../fable-library.3.7.5/Types.js\";\nimport { endsWith, isNullOrEmpty } from \"../fable-library.3.7.5/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(23);\n        }\n        case \"System.Uri\": {\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 activePatternResult6012 = $007CPrimitiveType$007C_$007C(resolvedType);\n    if (activePatternResult6012 != null) {\n        const typeInfo = activePatternResult6012;\n        return typeInfo;\n    }\n    else {\n        const activePatternResult6011 = $007CFuncType$007C_$007C(resolvedType);\n        if (activePatternResult6011 != null) {\n            const types = activePatternResult6011;\n            return new TypeInfo(37, (l = (new Lazy(() => map(createTypeInfo, types))), () => lazyToDelayed(l, void 0)));\n        }\n        else {\n            const activePatternResult6010 = $007CRecordType$007C_$007C(resolvedType);\n            if (activePatternResult6010 != null) {\n                const fields = activePatternResult6010;\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(39, () => lazyToDelayed(l_1, void 0));\n            }\n            else {\n                const activePatternResult6009 = $007CUnionType$007C_$007C(resolvedType);\n                if (activePatternResult6009 != null) {\n                    const cases = activePatternResult6009;\n                    const l_2 = new Lazy(() => [toArray(delay(() => collect((matchValue_1) => singleton(new UnionCase(matchValue_1[0], map(createTypeInfo, matchValue_1[2]), matchValue_1[1])), cases))), resolvedType]);\n                    return new TypeInfo(40, () => lazyToDelayed(l_2, void 0));\n                }\n                else {\n                    const activePatternResult6008 = $007CEnumType$007C_$007C(resolvedType);\n                    if (activePatternResult6008 != null) {\n                        const elemType = activePatternResult6008;\n                        return new TypeInfo(38, (l_3 = (new Lazy(() => [createTypeInfo(elemType), resolvedType])), () => lazyToDelayed(l_3, void 0)));\n                    }\n                    else {\n                        const activePatternResult6007 = $007CListType$007C_$007C(resolvedType);\n                        if (activePatternResult6007 != null) {\n                            const elemType_1 = activePatternResult6007;\n                            return new TypeInfo(28, (l_4 = (new Lazy(() => createTypeInfo(elemType_1))), () => lazyToDelayed(l_4, void 0)));\n                        }\n                        else {\n                            const activePatternResult6006 = $007CResizeArrayType$007C_$007C(resolvedType);\n                            if (activePatternResult6006 != null) {\n                                const elemType_2 = activePatternResult6006;\n                                return new TypeInfo(35, (l_5 = (new Lazy(() => createTypeInfo(elemType_2))), () => lazyToDelayed(l_5, void 0)));\n                            }\n                            else {\n                                const activePatternResult6005 = $007CHashSetType$007C_$007C(resolvedType);\n                                if (activePatternResult6005 != null) {\n                                    const elemType_3 = activePatternResult6005;\n                                    return new TypeInfo(36, (l_6 = (new Lazy(() => createTypeInfo(elemType_3))), () => lazyToDelayed(l_6, void 0)));\n                                }\n                                else {\n                                    const activePatternResult6004 = $007CArrayType$007C_$007C(resolvedType);\n                                    if (activePatternResult6004 != null) {\n                                        const elemType_4 = activePatternResult6004;\n                                        return new TypeInfo(30, (l_7 = (new Lazy(() => createTypeInfo(elemType_4))), () => lazyToDelayed(l_7, void 0)));\n                                    }\n                                    else {\n                                        const activePatternResult6003 = $007CTupleType$007C_$007C(resolvedType);\n                                        if (activePatternResult6003 != null) {\n                                            const types_1 = activePatternResult6003;\n                                            return new TypeInfo(32, (l_8 = (new Lazy(() => map(createTypeInfo, types_1))), () => lazyToDelayed(l_8, void 0)));\n                                        }\n                                        else {\n                                            const activePatternResult6002 = $007COptionType$007C_$007C(resolvedType);\n                                            if (activePatternResult6002 != null) {\n                                                const elemType_5 = activePatternResult6002;\n                                                return new TypeInfo(27, (l_9 = (new Lazy(() => createTypeInfo(elemType_5))), () => lazyToDelayed(l_9, void 0)));\n                                            }\n                                            else {\n                                                const activePatternResult6001 = $007CNullable$007C_$007C(resolvedType);\n                                                if (activePatternResult6001 != null) {\n                                                    const elemType_6 = activePatternResult6001;\n                                                    return new TypeInfo(27, (l_10 = (new Lazy(() => createTypeInfo(elemType_6))), () => lazyToDelayed(l_10, void 0)));\n                                                }\n                                                else {\n                                                    const activePatternResult6000 = $007CSetType$007C_$007C(resolvedType);\n                                                    if (activePatternResult6000 != null) {\n                                                        const elemType_7 = activePatternResult6000;\n                                                        return new TypeInfo(29, (l_11 = (new Lazy(() => createTypeInfo(elemType_7))), () => lazyToDelayed(l_11, void 0)));\n                                                    }\n                                                    else {\n                                                        const activePatternResult5999 = $007CMapType$007C_$007C(resolvedType);\n                                                        if (activePatternResult5999 != null) {\n                                                            const keyType = activePatternResult5999[0];\n                                                            const valueType = activePatternResult5999[1];\n                                                            return new TypeInfo(33, (l_12 = (new Lazy(() => [createTypeInfo(keyType), createTypeInfo(valueType)])), () => lazyToDelayed(l_12, void 0)));\n                                                        }\n                                                        else {\n                                                            const activePatternResult5998 = $007CDictionaryType$007C_$007C(resolvedType);\n                                                            if (activePatternResult5998 != null) {\n                                                                const keyType_1 = activePatternResult5998[0];\n                                                                const valueType_1 = activePatternResult5998[1];\n                                                                return new TypeInfo(34, (l_13 = (new Lazy(() => [createTypeInfo(keyType_1), createTypeInfo(valueType_1), valueType_1])), () => lazyToDelayed(l_13, void 0)));\n                                                            }\n                                                            else {\n                                                                const activePatternResult5997 = $007CSeqType$007C_$007C(resolvedType);\n                                                                if (activePatternResult5997 != null) {\n                                                                    const elemType_8 = activePatternResult5997;\n                                                                    return new TypeInfo(31, (l_14 = (new Lazy(() => createTypeInfo(elemType_8))), () => lazyToDelayed(l_14, void 0)));\n                                                                }\n                                                                else {\n                                                                    const activePatternResult5996 = $007CAsyncType$007C_$007C(resolvedType);\n                                                                    if (activePatternResult5996 != null) {\n                                                                        const elemType_9 = activePatternResult5996;\n                                                                        return new TypeInfo(25, (l_15 = (new Lazy(() => createTypeInfo(elemType_9))), () => lazyToDelayed(l_15, void 0)));\n                                                                    }\n                                                                    else {\n                                                                        const activePatternResult5995 = $007CPromiseType$007C_$007C(resolvedType);\n                                                                        if (activePatternResult5995 != null) {\n                                                                            const elemType_10 = activePatternResult5995;\n                                                                            return new TypeInfo(26, (l_16 = (new Lazy(() => createTypeInfo(elemType_10))), () => lazyToDelayed(l_16, void 0)));\n                                                                        }\n                                                                        else {\n                                                                            return new TypeInfo(24, (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: equals,\n    GetHashCode: structuralHash,\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 27: {\n            return true;\n        }\n        default: {\n            return false;\n        }\n    }\n}\n\nexport function enumUnion(_arg1) {\n    if (_arg1.tag === 40) {\n        const array = _arg1.fields[0]()[0];\n        return array.every((case$) => (case$.CaseTypes.length === 0));\n    }\n    else {\n        return false;\n    }\n}\n\n","import isBrowser from \"./isBrowser.js\";\nimport { toString as toString_3, FSharpRef, Union } from \"../fable-library.3.7.5/Types.js\";\nimport { getUnionFields, getRecordField, makeRecord, fullName, makeUnion, name as name_2, union_type, string_type } from \"../fable-library.3.7.5/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.7.5/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.7.5/Seq.js\";\nimport { value as value_91, some, map as map_1 } from \"../fable-library.3.7.5/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.7.5/Map.js\";\nimport { toText, join, fromBase64String, printf, toFail, substring, endsWith } from \"../fable-library.3.7.5/String.js\";\nimport { parse } from \"../fable-library.3.7.5/Double.js\";\nimport { tryParse, parse as parse_1 } from \"../fable-library.3.7.5/Int32.js\";\nimport { Uri } from \"../fable-library.3.7.5/Uri.js\";\nimport { toString as toString_2 } from \"../fable-library.3.7.5/Decimal.js\";\nimport Decimal from \"../fable-library.3.7.5/Decimal.js\";\nimport { toString, fromInteger, toNumber, tryParse as tryParse_1, fromInt, parse as parse_2, fromNumber } from \"../fable-library.3.7.5/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.7.5/BigInt.js\";\nimport { toString as toString_4, parse as parse_4 } from \"../fable-library.3.7.5/Date.js\";\nimport { parse as parse_5 } from \"../fable-library.3.7.5/DateOffset.js\";\nimport DateOffset from \"../fable-library.3.7.5/DateOffset.js\";\nimport { dayNumber, fromDayNumber } from \"../fable-library.3.7.5/DateOnly.js\";\nimport { create } from \"../fable-library.3.7.5/TimeOnly.js\";\nimport { concat, mapIndexed, equalsWith, zip, map as map_2, tryFind as tryFind_1 } from \"../fable-library.3.7.5/Array.js\";\nimport { int32ToString, disposeSafe, getEnumerator, structuralHash, safeHash, compare, equals } from \"../fable-library.3.7.5/Util.js\";\nimport { parse as parse_6 } from \"../fable-library.3.7.5/Guid.js\";\nimport { getBytesInt32, toInt64 } from \"../fable-library.3.7.5/BitConverter.js\";\nimport { ofList } from \"../fable-library.3.7.5/Set.js\";\nimport { TypeInfo } from \"./TypeInfo.fs.js\";\nimport { Dictionary } from \"../fable-library.3.7.5/MutableMap.js\";\nimport { addToSet, addToDict } from \"../fable-library.3.7.5/MapUtil.js\";\nimport { HashSet } from \"../fable-library.3.7.5/MutableSet.js\";\nimport { enumUnion, isPrimitive } from \"./TypeInfo.Converter.fs.js\";\nimport quote from \"./quote.js\";\nimport { ticks } from \"../fable-library.3.7.5/TimeSpan.js\";\n\nexport const Convert_isBrowser = isBrowser;\n\nexport const Convert_insideBrowser = Convert_isBrowser();\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 activePatternResult6446 = Convert_$007CMapKey$007C_$007C(head(tail_1(_arg1.fields[0])));\n                        if (activePatternResult6446 != 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 = activePatternResult6446;\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 activePatternResult6448 = Convert_$007CMapKey$007C_$007C(head(tail_1(_arg1.fields[0])));\n                        if (activePatternResult6448 != 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 = activePatternResult6448;\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 activePatternResult6451 = Convert_$007CMapOne$007C_$007C(json);\n        if (activePatternResult6451 != null) {\n            const key = activePatternResult6451[0];\n            const value = activePatternResult6451[1];\n            return new Convert_InternalMap(1, key, value);\n        }\n        else {\n            const activePatternResult6450 = Convert_$007CMapNode$007C_$007C(json);\n            if (activePatternResult6450 != null) {\n                const key_1 = activePatternResult6450[0];\n                const left = activePatternResult6450[2];\n                const right = activePatternResult6450[3];\n                const value_1 = activePatternResult6450[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 30: {\n            return true;\n        }\n        case 28: {\n            return true;\n        }\n        case 31: {\n            return true;\n        }\n        case 32: {\n            return true;\n        }\n        case 29: {\n            return true;\n        }\n        case 35: {\n            return true;\n        }\n        case 36: {\n            return true;\n        }\n        default: {\n            return false;\n        }\n    }\n}\n\nexport function Convert_isRecord(_arg1) {\n    if (_arg1.tag === 39) {\n        return true;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function Convert_unionOfRecords(_arg1) {\n    if (_arg1.tag === 40) {\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 === 27) {\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, value_26, getlElemType, value_27, getElemType, value_28, getElemType_1, value_29, genericJson, value_30, value_31, value_32, value_33, value_34, value_35, value_36, value_37, value_38, value_39, value_40, value_41, value_42, 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 === 22) {\n                                pattern_matching_result_2 = 8;\n                                value_15 = 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 = 14;\n                                value_21 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 4) {\n                                pattern_matching_result_2 = 16;\n                                value_23 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 5) {\n                                pattern_matching_result_2 = 18;\n                                value_25 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 38) {\n                                pattern_matching_result_2 = 20;\n                                getlElemType = matchValue[1].fields[0];\n                                value_27 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 30) {\n                                pattern_matching_result_2 = 22;\n                                getElemType_1 = matchValue[1].fields[0];\n                                value_29 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 23) {\n                                pattern_matching_result_2 = 25;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 12) {\n                                pattern_matching_result_2 = 26;\n                                value_30 = matchValue[0].fields[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 = 30;\n                                value_34 = 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 === 15) {\n                                pattern_matching_result_2 = 33;\n                                value_37 = 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 = 37;\n                                value_41 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 18) {\n                                pattern_matching_result_2 = 38;\n                                value_42 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 27) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 41;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 42;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 42;\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 = 10;\n                                value_17 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 11) {\n                                pattern_matching_result_2 = 12;\n                                value_19 = 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 === 20) {\n                                pattern_matching_result_2 = 19;\n                                value_26 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 38) {\n                                pattern_matching_result_2 = 21;\n                                getElemType = matchValue[1].fields[0];\n                                value_28 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 23) {\n                                pattern_matching_result_2 = 25;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 13) {\n                                pattern_matching_result_2 = 28;\n                                value_32 = 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 = 32;\n                                value_36 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 16) {\n                                pattern_matching_result_2 = 35;\n                                value_39 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 17) {\n                                pattern_matching_result_2 = 36;\n                                value_40 = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 27) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 41;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 42;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 42;\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 === 23) {\n                                pattern_matching_result_2 = 25;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 27) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 41;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 42;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 42;\n                            }\n                        }\n                        else if (matchValue[0].tag === 3) {\n                            if (matchValue[1].tag === 2) {\n                                pattern_matching_result_2 = 23;\n                            }\n                            else if (matchValue[1].tag === 0) {\n                                pattern_matching_result_2 = 24;\n                            }\n                            else if (matchValue[1].tag === 23) {\n                                pattern_matching_result_2 = 25;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 27) {\n                                pattern_matching_result_2 = 40;\n                            }\n                            else {\n                                pattern_matching_result_2 = 42;\n                            }\n                        }\n                        else if (matchValue[0].tag === 5) {\n                            if (matchValue[1].tag === 23) {\n                                pattern_matching_result_2 = 25;\n                                genericJson = matchValue[0];\n                            }\n                            else if (matchValue[1].tag === 40) {\n                                pattern_matching_result_2 = 39;\n                                getTypes = matchValue[1].fields[0];\n                                values = matchValue[0].fields[0];\n                            }\n                            else if (matchValue[1].tag === 27) {\n                                if (!equals(matchValue[0], new Json(3))) {\n                                    pattern_matching_result_2 = 41;\n                                    jsonValue_5 = matchValue[0];\n                                    optionalTypeDelayed_5 = matchValue[1].fields[0];\n                                }\n                                else {\n                                    pattern_matching_result_2 = 42;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_2 = 42;\n                            }\n                        }\n                        else if (matchValue[1].tag === 23) {\n                            pattern_matching_result_2 = 25;\n                            genericJson = matchValue[0];\n                        }\n                        else if (matchValue[1].tag === 27) {\n                            if (!equals(matchValue[0], new Json(3))) {\n                                pattern_matching_result_2 = 41;\n                                jsonValue_5 = matchValue[0];\n                                optionalTypeDelayed_5 = matchValue[1].fields[0];\n                            }\n                            else {\n                                pattern_matching_result_2 = 42;\n                            }\n                        }\n                        else {\n                            pattern_matching_result_2 = 42;\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 Uri.create(value_15);\n                            }\n                            case 9: {\n                                return new Decimal(value_16);\n                            }\n                            case 10: {\n                                return new Decimal(value_17);\n                            }\n                            case 11: {\n                                return parse_1(value_18, 511, false, 16);\n                            }\n                            case 12: {\n                                return (value_19 + 0x8000 & 0xFFFF) - 0x8000;\n                            }\n                            case 13: {\n                                return value_20 & 0xFFFF;\n                            }\n                            case 14: {\n                                return parse_1(value_21, 511, true, 16);\n                            }\n                            case 15: {\n                                return value_22 >>> 0;\n                            }\n                            case 16: {\n                                return parse_1(value_23, 511, true, 32);\n                            }\n                            case 17: {\n                                return fromNumber(value_24, true);\n                            }\n                            case 18: {\n                                return parse_2(value_25, 511, true, 64);\n                            }\n                            case 19: {\n                                return Math.floor(value_26);\n                            }\n                            case 20: {\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_27, 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_27)(arg20);\n                                        }\n                                    }\n                                    case 12: {\n                                        let matchValue_2;\n                                        let outArg_1 = fromInt(0);\n                                        matchValue_2 = [tryParse_1(value_27, 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_27)(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_27)(arg20_2);\n                                    }\n                                }\n                            }\n                            case 21: {\n                                const patternInput_1 = getElemType();\n                                return value_28;\n                            }\n                            case 22: {\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_29);\n                                    }\n                                    else {\n                                        return Array.prototype.slice.call(Buffer.from(value_29, 'base64'));\n                                    }\n                                }\n                                else {\n                                    return toFail(printf(\"Cannot convert arbitrary string \\u0027%s\\u0027 to %A\"))(value_29)(elemType);\n                                }\n                            }\n                            case 23: {\n                                return null;\n                            }\n                            case 24: {\n                                return void 0;\n                            }\n                            case 25: {\n                                return SimpleJson_toPlainObject(genericJson);\n                            }\n                            case 26: {\n                                return parse_2(value_30, 511, false, 64);\n                            }\n                            case 27: {\n                                return parse_1(value_31, 511, true, 8);\n                            }\n                            case 28: {\n                                return value_32 & 0xFF;\n                            }\n                            case 29: {\n                                return (value_33 + 0x80 & 0xFF) - 0x80;\n                            }\n                            case 30: {\n                                return parse_1(value_34, 511, false, 8);\n                            }\n                            case 31: {\n                                return parse_3(value_35);\n                            }\n                            case 32: {\n                                return fromInt32(Math.floor(value_36));\n                            }\n                            case 33: {\n                                return parse_4(value_37);\n                            }\n                            case 34: {\n                                return parse_5(value_38);\n                            }\n                            case 35: {\n                                return DateOffset(toNumber(fromNumber(Math.floor(value_39), false)) * 1000, 0);\n                            }\n                            case 36: {\n                                return fromDayNumber(~(~value_40));\n                            }\n                            case 37: {\n                                return fromDayNumber(parse_1(value_41, 511, false, 32));\n                            }\n                            case 38: {\n                                return create(parse_2(value_42, 511, false, 64));\n                            }\n                            case 39: {\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 activePatternResult6538 = Convert_$007CNonArray$007C_$007C(head(matchValue_3)[1]);\n                                        if (activePatternResult6538 != null) {\n                                            if (isEmpty(tail_1(matchValue_3))) {\n                                                pattern_matching_result_3 = 1;\n                                                caseName_1 = head(matchValue_3)[0];\n                                                json = activePatternResult6538;\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(equals, 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_48) => Convert_fromJsonAs(value_48, 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 40: {\n                                return void 0;\n                            }\n                            case 41: {\n                                return (some)(Convert_fromJsonAs(jsonValue_5, optionalTypeDelayed_5()));\n                            }\n                            case 42: {\n                                let pattern_matching_result_7, value_49, value_50, 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_49 = matchValue[0].fields[0];\n                                    }\n                                    else if (matchValue[1].tag === 40) {\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_50 = 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_49);\n                                    }\n                                    case 1: {\n                                        return ((value_51) => fromInteger(value_51, false, 2))(~(~value_50));\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 === 40) {\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 === 39) {\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 === 24) {\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 === 40) {\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 === 30) {\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 === 28) {\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 === 29) {\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 === 31) {\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 === 32) {\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 === 33) {\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 === 34) {\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 === 36) {\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 === 24) {\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 === 28) {\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 === 39) {\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 === 34) {\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 === 33) {\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 === 24) {\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 === 24) {\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_55) => Convert_fromJsonAs(value_55, elementType), values_4));\n                                            }\n                                            case 4: {\n                                                const elementType_1 = elementTypeDelayed_1();\n                                                return map_3((value_57) => Convert_fromJsonAs(value_57, elementType_1), values_5);\n                                            }\n                                            case 5: {\n                                                const elementType_2 = elementTypeDelayed_2();\n                                                return map_3((value_59) => Convert_fromJsonAs(value_59, elementType_2), Convert_flattenFable3Lists(linkedList));\n                                            }\n                                            case 6: {\n                                                const elementType_3 = elementTypeDelayed_3();\n                                                return ofList(map_3((value_61) => Convert_fromJsonAs(value_61, elementType_3), values_6), {\n                                                    Compare: compare,\n                                                });\n                                            }\n                                            case 7: {\n                                                const elementType_4 = elementTypeDelayed_4();\n                                                return map_3((value_63) => Convert_fromJsonAs(value_63, 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 === 27) {\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 === 27) {\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(32, (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(32, () => [keyType_1, patternInput_8[1]]))), tuples_1)));\n                                                const output = (keyType_1.tag === 40) ? (new Dictionary([], {\n                                                    Equals: equals,\n                                                    GetHashCode: safeHash,\n                                                })) : ((keyType_1.tag === 39) ? (new Dictionary([], {\n                                                    Equals: equals,\n                                                    GetHashCode: structuralHash,\n                                                })) : (new Dictionary([], {\n                                                    Equals: equals,\n                                                    GetHashCode: structuralHash,\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                                                    disposeSafe(enumerator);\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 === 40) ? (new Dictionary([], {\n                                                    Equals: equals,\n                                                    GetHashCode: safeHash,\n                                                })) : ((keyType_2.tag === 39) ? (new Dictionary([], {\n                                                    Equals: equals,\n                                                    GetHashCode: structuralHash,\n                                                })) : (new Dictionary([], {\n                                                    Equals: equals,\n                                                    GetHashCode: structuralHash,\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                                                    disposeSafe(enumerator_1);\n                                                }\n                                                return output_1;\n                                            }\n                                            case 13: {\n                                                const elemType_1 = getType();\n                                                const hashset = (elemType_1.tag === 40) ? (new HashSet([], {\n                                                    Equals: equals,\n                                                    GetHashCode: safeHash,\n                                                })) : ((elemType_1.tag === 39) ? (new HashSet([], {\n                                                    Equals: equals,\n                                                    GetHashCode: structuralHash,\n                                                })) : (new HashSet([], {\n                                                    Equals: equals,\n                                                    GetHashCode: structuralHash,\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                                                    disposeSafe(enumerator_2);\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 38:\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 22: {\n                return Convert_betweenQuotes(toString_3(value));\n            }\n            case 15: {\n                return Convert_betweenQuotes((copyOfStruct_1 = value, toString_4(copyOfStruct_1, \"O\")));\n            }\n            case 16: {\n                return Convert_betweenQuotes((copyOfStruct_2 = value, toString_4(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 39: {\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 35: {\n                const elementType = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_4((element) => Convert_serialize(element, elementType), value))) + \"]\";\n            }\n            case 36: {\n                const elementType_1 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_4((element_1) => Convert_serialize(element_1, elementType_1), value))) + \"]\";\n            }\n            case 29: {\n                const elementType_2 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_4((element_2) => Convert_serialize(element_2, elementType_2), value))) + \"]\";\n            }\n            case 30: {\n                const elementType_3 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_2((element_3) => Convert_serialize(element_3, elementType_3), value))) + \"]\";\n            }\n            case 28: {\n                const elementType_4 = typeInfo.fields[0]();\n                return (\"[\" + join(\", \", map_3((element_4) => Convert_serialize(element_4, elementType_4), value))) + \"]\";\n            }\n            case 31: {\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 27: {\n                const matchValue = value;\n                if (matchValue != null) {\n                    value_mut = value_91(matchValue);\n                    typeInfo_mut = typeInfo.fields[0]();\n                    continue Convert_serialize;\n                }\n                else {\n                    return \"null\";\n                }\n            }\n            case 40: {\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 33: {\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 34: {\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 32: {\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 23: {\n                return SimpleJson_stringify(value);\n            }\n            case 24: {\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(some(\"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 isBrowser() {\n    return typeof window !== \"undefined\" && typeof window.document !== \"undefined\";\n}","export default function quote(inputText) {\n    var escapable = /[\\\\\\\"\\x00-\\x1f\\x7f-\\x9f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g;\n    var meta = {\n        '\\b': '\\\\b',\n        '\\t': '\\\\t',\n        '\\n': '\\\\n',\n        '\\f': '\\\\f',\n        '\\r': '\\\\r',\n        '\"': '\\\\\"',\n        '\\\\': '\\\\\\\\'\n    }\n\n    escapable.lastIndex = 0;\n    return escapable.test(inputText) ?\n        '\"' + inputText.replace(escapable, function (a) {\n            var c = meta[a];\n            return typeof c === 'string' ? c :\n                '\\\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);\n        }) + '\"' :\n        '\"' + inputText + '\"';\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 { HttpResponse, HttpRequest, RequestBody, HttpMethod as HttpMethod_1 } from \"./Types.fs.js\";\nimport { empty } from \"../fable-library.3.7.5/List.js\";\nimport { singleton } from \"../fable-library.3.7.5/AsyncBuilder.js\";\nimport { isCancellationRequested, fromContinuations, cancellationToken } from \"../fable-library.3.7.5/Async.js\";\nimport { disposeSafe, getEnumerator } from \"../fable-library.3.7.5/Util.js\";\nimport { some } from \"../fable-library.3.7.5/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        const request_1 = 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                disposeSafe(enumerator);\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        return singleton.ReturnFrom(request_1);\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 { fromContinuations } from \"../fable-library.3.7.5/Async.js\";\nimport { class_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { isNullOrWhiteSpace } from \"../fable-library.3.7.5/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 { fromContinuations } from \"../fable-library.3.7.5/Async.js\";\nimport { toFail, printf, toText, trimEnd } from \"../fable-library.3.7.5/String.js\";\nimport { getGenerics, isGenericType, getFunctionElements, isFunction } from \"../fable-library.3.7.5/Reflection.js\";\nimport { take, equalsWith, last, head } from \"../fable-library.3.7.5/Array.js\";\nimport { curry, equals } from \"../fable-library.3.7.5/Util.js\";\nimport { empty, singleton, append, delay, toList } from \"../fable-library.3.7.5/Seq.js\";\nimport { singleton as singleton_1 } from \"../fable-library.3.7.5/AsyncBuilder.js\";\nimport { send, get$, post, withBody, withHeaders, withCredentials as withCredentials_4, sendAndReadBinary } from \"./Http.fs.js\";\nimport { RequestBody, ProxyRequestException_$ctor_76BC5104, HttpResponse } from \"./Types.fs.js\";\nimport { SimpleJson_parseNative } from \"../Fable.SimpleJson.3.24.0/SimpleJson.fs.js\";\nimport { Convert_serialize, Convert_arrayLike, Convert_fromJsonAs } from \"../Fable.SimpleJson.3.24.0/Json.Converter.fs.js\";\nimport { TypeInfo } from \"../Fable.SimpleJson.3.24.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 === 30) {\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 === 25) {\n        const matchValue = _arg1.fields[0]();\n        if (matchValue.tag === 30) {\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 25: {\n            funcArgs = [func.FieldType];\n            break;\n        }\n        case 26: {\n            funcArgs = [func.FieldType];\n            break;\n        }\n        case 37: {\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 === 37) {\n        const matchValue_2 = matchValue_1.fields[0]();\n        if ((!equalsWith(equals, 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(equals, funcArgs, null)) && (funcArgs.length === 1)) ? ((funcArgs[0].tag === 25) ? false : (!(funcArgs[0].tag === 26))) : (((!equalsWith(equals, funcArgs, null)) && (funcArgs.length === 2)) ? ((funcArgs[0].tag === 0) ? (!(funcArgs[1].tag === 25)) : 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(withCredentials_4(options.WithCredentials, withHeaders(headers, withBody(requestBody, post(url))))) : sendAndReadBinary(withCredentials_4(options.WithCredentials, 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                const responseAsBlob = new Blob([response_1.buffer], { type: 'text/plain' });\n                return singleton_1.Bind(Blob_readBlobAsText(responseAsBlob), (_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 === 25) ? returnTypeAsync.fields[0]() : ((returnTypeAsync.tag === 26) ? 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(withCredentials_4(options.WithCredentials, withHeaders(headers, withBody(requestBody_1, post(url))))) : send(withCredentials_4(options.WithCredentials, 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                    const parsedJson = SimpleJson_parseNative(response_3.ResponseBody);\n                    return singleton_1.Return(Convert_fromJsonAs(parsedJson, 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(32, () => inputArgumentTypes)))) : ((matchValue_6 === 1) ? (new RequestBody(1, Convert_serialize([inputArguments[0]], new TypeInfo(30, () => inputArgumentTypes[0])))) : (new RequestBody(1, Convert_serialize(inputArguments, new TypeInfo(32, () => inputArgumentTypes)))))) : ((matchValue_6 === 1) ? (new RequestBody(1, Convert_serialize([inputArguments[0]], new TypeInfo(30, () => inputArgumentTypes[0])))) : (new RequestBody(1, Convert_serialize(inputArguments, new TypeInfo(32, () => inputArgumentTypes))))))));\n    })))))));\n}\n\n","import { split, printf, toText } from \"../Client/fable_modules/fable-library.3.7.5/String.js\";\nimport { Record } from \"../Client/fable_modules/fable-library.3.7.5/Types.js\";\nimport { Model$reflection } from \"./FormModel.fs.js\";\nimport { ClientCaptcha$reflection } from \"./CaptchaTypes.fs.js\";\nimport { record_type, union_type, lambda_type, class_type, unit_type, tuple_type } from \"../Client/fable_modules/fable-library.3.7.5/Reflection.js\";\nimport { FSharpResult$2 } from \"../Client/fable_modules/fable-library.3.7.5/Choice.js\";\n\nexport function Route_builder(typeName, methodName) {\n    return toText(printf(\"/api/%s/%s\"))(typeName)(methodName);\n}\n\nexport function Route_deconstructor(path) {\n    const splitArr = split(path, [\"/\"], null, 1);\n    return [splitArr[1], splitArr[2]];\n}\n\nexport class IHelpdeskAPI extends Record {\n    constructor(submitIssue, getCaptcha, checkCaptcha) {\n        super();\n        this.submitIssue = submitIssue;\n        this.getCaptcha = getCaptcha;\n        this.checkCaptcha = checkCaptcha;\n    }\n}\n\nexport function IHelpdeskAPI$reflection() {\n    return record_type(\"Shared.IHelpdeskAPI\", [], IHelpdeskAPI, () => [[\"submitIssue\", lambda_type(tuple_type(Model$reflection(), ClientCaptcha$reflection()), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [unit_type]))], [\"getCaptcha\", lambda_type(unit_type, class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [ClientCaptcha$reflection()]))], [\"checkCaptcha\", lambda_type(ClientCaptcha$reflection(), class_type(\"Microsoft.FSharp.Control.FSharpAsync`1\", [union_type(\"Microsoft.FSharp.Core.FSharpResult`2\", [ClientCaptcha$reflection(), ClientCaptcha$reflection()], FSharpResult$2, () => [[[\"ResultValue\", ClientCaptcha$reflection()]], [[\"ErrorValue\", ClientCaptcha$reflection()]]])]))]]);\n}\n\n","import { ofArray } from \"./fable_modules/fable-library.3.7.5/List.js\";\nimport { Union, Record } from \"./fable_modules/fable-library.3.7.5/Types.js\";\nimport { union_type, class_type, list_type, lambda_type, unit_type, anonRecord_type, string_type, record_type, option_type, bool_type } from \"./fable_modules/fable-library.3.7.5/Reflection.js\";\nimport { Topic$reflection, IssueGeneralTopic$reflection } from \"../Shared/IssueTypes.fs.js\";\nimport { Model$reflection as Model$reflection_1 } from \"../Shared/FormModel.fs.js\";\nimport { ClientCaptcha$reflection } from \"../Shared/CaptchaTypes.fs.js\";\nimport { ProxyRequestException__get_ResponseText, ProxyRequestException } from \"./fable_modules/Fable.Remoting.Client.7.24.0/Types.fs.js\";\nimport { SimpleJson_tryParse } from \"./fable_modules/Fable.SimpleJson.3.24.0/./SimpleJson.fs.js\";\nimport { Convert_fromJson } from \"./fable_modules/Fable.SimpleJson.3.24.0/./Json.Converter.fs.js\";\nimport { createTypeInfo } from \"./fable_modules/Fable.SimpleJson.3.24.0/./TypeInfo.Converter.fs.js\";\nimport { FSharpResult$2 } from \"./fable_modules/fable-library.3.7.5/Choice.js\";\nimport { Remoting_buildProxy_64DC51C } from \"./fable_modules/Fable.Remoting.Client.7.24.0/./Remoting.fs.js\";\nimport { RemotingModule_createApi, RemotingModule_withRouteBuilder } from \"./fable_modules/Fable.Remoting.Client.7.24.0/Remoting.fs.js\";\nimport { IHelpdeskAPI$reflection, Route_builder } from \"../Shared/Shared.fs.js\";\n\nexport const InputIds_inputIdList = ofArray([\"CaptchaInput\", \"TitleInput\", \"DescriptionInput\", \"EmailInput\"]);\n\nexport class Model extends Record {\n    constructor(DropdownIsActive, LoadingModal, DropdownActiveTopic, DropdownActiveSubtopic, FormModel, Captcha, CaptchaLoading, CaptchaDoneWrong) {\n        super();\n        this.DropdownIsActive = DropdownIsActive;\n        this.LoadingModal = LoadingModal;\n        this.DropdownActiveTopic = DropdownActiveTopic;\n        this.DropdownActiveSubtopic = DropdownActiveSubtopic;\n        this.FormModel = FormModel;\n        this.Captcha = Captcha;\n        this.CaptchaLoading = CaptchaLoading;\n        this.CaptchaDoneWrong = CaptchaDoneWrong;\n    }\n}\n\nexport function Model$reflection() {\n    return record_type(\"State.Model\", [], Model, () => [[\"DropdownIsActive\", bool_type], [\"LoadingModal\", bool_type], [\"DropdownActiveTopic\", option_type(IssueGeneralTopic$reflection())], [\"DropdownActiveSubtopic\", option_type(Topic$reflection())], [\"FormModel\", Model$reflection_1()], [\"Captcha\", option_type(ClientCaptcha$reflection())], [\"CaptchaLoading\", bool_type], [\"CaptchaDoneWrong\", bool_type]]);\n}\n\nexport function System_Exception__Exception_GetPropagatedError(this$) {\n    let matchValue;\n    if (this$ instanceof ProxyRequestException) {\n        return ((matchValue = SimpleJson_tryParse(ProxyRequestException__get_ResponseText(this$)), (matchValue != null) ? Convert_fromJson(matchValue, createTypeInfo(anonRecord_type([\"error\", string_type], [\"handled\", bool_type], [\"ignored\", bool_type]))) : (() => {\n            throw (new Error(\"Couldn\\u0027t parse the input JSON string because it seems to be invalid\"));\n        })())).error;\n    }\n    else {\n        return this$.message;\n    }\n}\n\nexport function curry(f, a, b) {\n    return f([a, b]);\n}\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 [\"ToggleIssueCategoryDropdown\", \"UpdateDropdownActiveTopic\", \"UpdateDropdownActiveSubtopic\", \"UpdateLoadingModal\", \"UpdateCaptchaLoading\", \"UpdateCaptchaDoneWrong\", \"UpdateCaptchaClient\", \"UpdateFormModel\", \"SubmitIssueRequest\", \"SubmitIssueResponse\", \"GenericError\", \"GetCaptcha\", \"GetCaptchaResponse\", \"CheckCaptcha\", \"CheckCaptchaResponse\"];\n    }\n}\n\nexport function Msg$reflection() {\n    return union_type(\"State.Msg\", [], Msg, () => [[], [[\"Item\", option_type(IssueGeneralTopic$reflection())]], [[\"Item\", option_type(Topic$reflection())]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", option_type(ClientCaptcha$reflection())]], [[\"Item\", Model$reflection_1()]], [], [], [[\"Item1\", list_type(lambda_type(lambda_type(Msg$reflection(), unit_type), unit_type))], [\"Item2\", class_type(\"System.Exception\")]], [], [[\"Item\", option_type(ClientCaptcha$reflection())]], [], [[\"Item\", union_type(\"Microsoft.FSharp.Core.FSharpResult`2\", [ClientCaptcha$reflection(), ClientCaptcha$reflection()], FSharpResult$2, () => [[[\"ResultValue\", ClientCaptcha$reflection()]], [[\"ErrorValue\", ClientCaptcha$reflection()]]])]]]);\n}\n\nexport const api = Remoting_buildProxy_64DC51C(RemotingModule_withRouteBuilder(Route_builder, RemotingModule_createApi()), IHelpdeskAPI$reflection());\n\n","import { empty } from \"../fable-library.3.7.5/List.js\";\nimport { uncurry } from \"../fable-library.3.7.5/Util.js\";\nimport { toFail, printf, toText } from \"../fable-library.3.7.5/String.js\";\nimport { RemoteBuilderOptions } from \"./Types.fs.js\";\nimport { Reader_$ctor_6C95DA22, Reader__Read_24524716 } from \"../Fable.Remoting.MsgPack.1.18.0/Read.fs.js\";\nimport { fullName, makeRecord, getRecordElements, name as name_1, class_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { createTypeInfo } from \"../Fable.SimpleJson.3.24.0/TypeInfo.Converter.fs.js\";\nimport { pick, map } from \"../fable-library.3.7.5/Array.js\";\nimport { singleton, collect, delay, toArray } from \"../fable-library.3.7.5/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 clo2;\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_64DC51C(options, resolvedType) {\n    const schemaType = createTypeInfo(resolvedType);\n    if (schemaType.tag === 39) {\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 === 25) ? 0 : ((matchValue.tag === 26) ? 0 : ((matchValue.tag === 37) ? (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.7.5/Option.js\";\nimport { create, isLeapYear } from \"../fable-library.3.7.5/Date.js\";\nimport { parse } from \"../fable-library.3.7.5/Int32.js\";\nimport { split, isNullOrWhiteSpace } from \"../fable-library.3.7.5/String.js\";\nimport { equalsWith } from \"../fable-library.3.7.5/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 activePatternResult7871 = DateParsing_$007CInt$007C_$007C(parts[0]);\n                if (activePatternResult7871 != null) {\n                    const activePatternResult7872 = DateParsing_$007CInt$007C_$007C(parts[1]);\n                    if (activePatternResult7872 != null) {\n                        pattern_matching_result = 0;\n                        month = activePatternResult7872;\n                        year = activePatternResult7871;\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 activePatternResult7868 = DateParsing_$007CInt$007C_$007C(parts[0]);\n                        if (activePatternResult7868 != null) {\n                            const activePatternResult7869 = DateParsing_$007CInt$007C_$007C(parts[1]);\n                            if (activePatternResult7869 != null) {\n                                const activePatternResult7870 = DateParsing_$007CInt$007C_$007C(parts[2]);\n                                if (activePatternResult7870 != null) {\n                                    pattern_matching_result_1 = 0;\n                                    day = activePatternResult7870;\n                                    month_1 = activePatternResult7869;\n                                    year_1 = activePatternResult7868;\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 activePatternResult7866 = DateParsing_$007CInt$007C_$007C(parts[0]);\n                                if (activePatternResult7866 != null) {\n                                    const activePatternResult7867 = DateParsing_$007CInt$007C_$007C(parts[1]);\n                                    if (activePatternResult7867 != null) {\n                                        pattern_matching_result_2 = 0;\n                                        day_1 = parts[2];\n                                        month_2 = activePatternResult7867;\n                                        year_2 = activePatternResult7866;\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 activePatternResult7865 = DateParsing_$007CInt$007C_$007C(matchValue[0]);\n                                            if (activePatternResult7865 != null) {\n                                                pattern_matching_result_3 = 0;\n                                                parsedDay = activePatternResult7865;\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 activePatternResult7863 = DateParsing_$007CInt$007C_$007C(matchValue_1[0]);\n                                                    if (activePatternResult7863 != null) {\n                                                        const activePatternResult7864 = DateParsing_$007CInt$007C_$007C(matchValue_1[1]);\n                                                        if (activePatternResult7864 != null) {\n                                                            pattern_matching_result_4 = 0;\n                                                            hour = activePatternResult7863;\n                                                            minute = activePatternResult7864;\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 { useLayoutEffectWithDeps, useLayoutEffect, useEffectWithDeps, useEffect, useDebugValue } from \"./ReactInterop.js\";\nimport { class_type } from \"../fable-library.3.7.5/Reflection.js\";\nimport { iterate } from \"../fable-library.3.7.5/Seq.js\";\nimport { defaultArg, some, toArray } from \"../fable-library.3.7.5/Option.js\";\nimport { Interop_reactApi } from \"./Interop.fs.js\";\nimport { disposeSafe, curry, uncurry } from \"../fable-library.3.7.5/Util.js\";\nimport { useState } from \"react\";\nimport * as react from \"react\";\n\nexport const ReactInterop_useDebugValueWithFormatter = useDebugValue;\n\nexport const ReactInterop_useEffect = useEffect;\n\nexport const ReactInterop_useEffectWithDeps = useEffectWithDeps;\n\nexport const ReactInterop_useLayoutEffect = useLayoutEffect;\n\nexport const ReactInterop_useLayoutEffectWithDeps = useLayoutEffectWithDeps;\n\nexport class Internal {\n    constructor() {\n    }\n}\n\nexport function Internal$reflection() {\n    return class_type(\"Feliz.Internal\", void 0, Internal);\n}\n\nexport function Internal_$ctor() {\n    return new Internal();\n}\n\n\nexport function Internal_functionComponent_Z1B155329(renderElement, name, withKey) {\n    iterate((name_1) => {\n        renderElement.displayName = name_1;\n    }, toArray(name));\n    console.warn(some(\"Feliz: using React.functionComponent in Fable 3 is obsolete, please consider using the [\\u003cReactComponent\\u003e] attribute instead which makes Feliz output better Javascript code that is compatible with react-refresh\"));\n    return (props) => {\n        const props_2 = Internal_propsWithKey(withKey, props);\n        return Interop_reactApi.createElement(renderElement, props_2);\n    };\n}\n\nexport function Internal_memo_Z603636D8(renderElement, name, areEqual, withKey) {\n    const memoElementType = Interop_reactApi.memo(renderElement, uncurry(2, defaultArg(curry(2, areEqual), null)));\n    iterate((name_1) => {\n        renderElement.displayName = name_1;\n    }, toArray(name));\n    return (props) => {\n        const props_2 = Internal_propsWithKey(withKey, props);\n        return Interop_reactApi.createElement(memoElementType, props_2);\n    };\n}\n\nfunction Internal_propsWithKey(withKey, props) {\n    if (withKey == null) {\n        return props;\n    }\n    else {\n        const f = withKey;\n        props.key = f(props);\n        return props;\n    }\n}\n\nexport class React {\n    constructor() {\n    }\n}\n\nexport function React$reflection() {\n    return class_type(\"Feliz.React\", void 0, React);\n}\n\nexport function React_createDisposable_3A5B6456(dispose) {\n    return {\n        Dispose() {\n            dispose();\n        },\n    };\n}\n\nexport function useReact_useState_FCFD9EF(initializer) {\n    return Interop_reactApi.useState(initializer);\n}\n\nexport function useReact_useReducer_2B9E6EA0(update, initialState) {\n    const arg00 = update;\n    return Interop_reactApi.useReducer(arg00, initialState);\n}\n\nexport function useReact_useEffect_Z5ECA432F(effect) {\n    ReactInterop_useEffect(effect);\n}\n\nexport function useReact_useEffect_Z5234A374(effect, dependencies) {\n    ReactInterop_useEffectWithDeps(effect, dependencies);\n}\n\nexport function useReact_useLayoutEffect_Z5ECA432F(effect) {\n    ReactInterop_useLayoutEffect(effect);\n}\n\nexport function useReact_useLayoutEffect_Z5234A374(effect, dependencies) {\n    ReactInterop_useLayoutEffectWithDeps(effect, dependencies);\n}\n\nexport function useReact_useLayoutEffect_3A5B6456(effect) {\n    ReactInterop_useLayoutEffect((_arg1) => {\n        effect();\n        return React_createDisposable_3A5B6456(() => {\n        });\n    });\n}\n\nexport function useReact_useLayoutEffect_Z101E1A95(effect, dependencies) {\n    ReactInterop_useLayoutEffectWithDeps((_arg2) => {\n        effect();\n        return React_createDisposable_3A5B6456(() => {\n        });\n    }, dependencies);\n}\n\nexport function useReact_useEffectOnce_3A5B6456(effect) {\n    useReact_useEffect_Z101E1A95(effect, []);\n}\n\nexport function useReact_useEffectOnce_Z5ECA432F(effect) {\n    useReact_useEffect_Z5234A374(effect, []);\n}\n\nexport function useReact_useEffectOnce_6E825304(effect) {\n    useReact_useEffect_Z5234A374(() => {\n        const disposeOption = effect();\n        return {\n            Dispose() {\n                ((option) => {\n                    iterate((d) => {\n                        let copyOfStruct = d;\n                        disposeSafe(copyOfStruct);\n                    }, toArray(option));\n                })(disposeOption);\n            },\n        };\n    }, []);\n}\n\nexport function useReact_useEffect_3A5B6456(effect) {\n    ReactInterop_useEffect((_arg3) => {\n        effect();\n        return React_createDisposable_3A5B6456(() => {\n        });\n    });\n}\n\nexport function useReact_useEffect_Z101E1A95(effect, dependencies) {\n    ReactInterop_useEffectWithDeps((_arg4) => {\n        effect();\n        return React_createDisposable_3A5B6456(() => {\n        });\n    }, dependencies);\n}\n\nexport function useReact_useDebugValue_Z721C83C5(value) {\n    ReactInterop_useDebugValueWithFormatter(value, (x) => x);\n}\n\nexport function useReact_useDebugValue_77A55D6D(value, formatter) {\n    ReactInterop_useDebugValueWithFormatter(value, formatter);\n}\n\nexport function useReact_useCallback_93353E(callbackFunction, dependencies) {\n    const arg10 = defaultArg(dependencies, []);\n    return Interop_reactApi.useCallback(callbackFunction, arg10);\n}\n\nexport function useReact_useRef_1505(initialValue) {\n    return Interop_reactApi.useRef(initialValue);\n}\n\nexport function useReact_useInputRef() {\n    return useReact_useRef_1505(void 0);\n}\n\nexport function useReact_useButtonRef() {\n    return useReact_useRef_1505(void 0);\n}\n\nexport function useReact_useElementRef() {\n    return useReact_useRef_1505(void 0);\n}\n\nexport function useReact_useMemo_CF4EA67(createFunction, dependencies) {\n    const arg10 = defaultArg(dependencies, []);\n    return Interop_reactApi.useMemo(createFunction, arg10);\n}\n\nexport function React_functionComponent_2F9D7239(render, withKey) {\n    return Internal_functionComponent_Z1B155329(render, void 0, withKey);\n}\n\nexport function React_functionComponent_Z4C5FE1BE(name, render, withKey) {\n    return Internal_functionComponent_Z1B155329(render, name, withKey);\n}\n\nexport function React_functionComponent_19A12FB2(render, withKey) {\n    return Internal_functionComponent_Z1B155329((arg) => {\n        const arg00 = render(arg);\n        return react.createElement(react.Fragment, {}, ...arg00);\n    }, void 0, withKey);\n}\n\nexport function React_functionComponent_2E1DD889(name, render, withKey) {\n    return Internal_functionComponent_Z1B155329((arg) => {\n        const arg00 = render(arg);\n        return react.createElement(react.Fragment, {}, ...arg00);\n    }, name, withKey);\n}\n\nexport function React_memo_62A0F746(render, withKey, areEqual) {\n    return Internal_memo_Z603636D8(render, void 0, areEqual, withKey);\n}\n\nexport function React_memo_6648A89D(name, render, withKey, areEqual) {\n    return Internal_memo_Z603636D8(render, name, areEqual, withKey);\n}\n\nexport function React_memo_C2C6BED(render, withKey, areEqual) {\n    return Internal_memo_Z603636D8((arg) => {\n        const arg00 = render(arg);\n        return react.createElement(react.Fragment, {}, ...arg00);\n    }, void 0, areEqual, withKey);\n}\n\nexport function React_memo_Z4FCC584A(name, render, withKey, areEqual) {\n    return Internal_memo_Z603636D8((arg) => {\n        const arg00 = render(arg);\n        return react.createElement(react.Fragment, {}, ...arg00);\n    }, name, areEqual, withKey);\n}\n\nexport function React_createContext_1AE444D8(name, defaultValue) {\n    const contextObject = Interop_reactApi.createContext(defaultArg(defaultValue, void 0));\n    iterate((name_1) => {\n        contextObject.displayName = name_1;\n    }, toArray(name));\n    return contextObject;\n}\n\nexport function React_contextProvider_34D9BBBD(contextObject, contextValue, child) {\n    return Interop_reactApi.createElement(contextObject.Provider, {\n        value: contextValue,\n    }, child);\n}\n\nexport function React_contextProvider_138D2F56(contextObject, contextValue, children) {\n    return Interop_reactApi.createElement(contextObject.Provider, {\n        value: contextValue,\n    }, ...children);\n}\n\nexport function React_contextConsumer_Z68910595(contextObject, render) {\n    return Interop_reactApi.createElement(contextObject.Consumer, null, render);\n}\n\nexport function React_contextConsumer_56D53A40(contextObject, render) {\n    return Interop_reactApi.createElement(contextObject.Consumer, null, (arg) => {\n        const arg00 = render(arg);\n        return react.createElement(react.Fragment, {}, ...arg00);\n    });\n}\n\nexport function useReact_useContext_37FA55CF(contextObject) {\n    return Interop_reactApi.useContext(contextObject);\n}\n\nexport function useReact_useCallbackRef_7C4B0DD6(callback) {\n    const lastRenderCallbackRef = useReact_useRef_1505(callback);\n    const callbackRef = useReact_useCallback_93353E((arg) => lastRenderCallbackRef.current(arg), []);\n    useReact_useLayoutEffect_3A5B6456(() => {\n        lastRenderCallbackRef.current = callback;\n    });\n    return callbackRef;\n}\n\nexport const React_useStateWithUpdater_1505 = useState;\n\nexport function React_forwardRef_3790D881(render) {\n    const forwardRefType = Interop_reactApi.forwardRef((props, ref) => render([props, ref]));\n    return (tupledArg) => {\n        const propsObj = Object.assign({}, tupledArg[0]);\n        propsObj.ref = tupledArg[1];\n        return Interop_reactApi.createElement(forwardRefType, propsObj);\n    };\n}\n\nexport function React_forwardRef_7DC3DB1A(name, render) {\n    const forwardRefType = Interop_reactApi.forwardRef((props, ref) => render([props, ref]));\n    render.displayName = name;\n    return (tupledArg) => {\n        const propsObj = Object.assign({}, tupledArg[0]);\n        propsObj.ref = tupledArg[1];\n        return Interop_reactApi.createElement(forwardRefType, propsObj);\n    };\n}\n\nexport function React_strictMode_6E3A73D(children) {\n    return Interop_reactApi.createElement(Interop_reactApi.StrictMode, void 0, ...children);\n}\n\nexport function React_lazy$0027_4712D3AE(dynamicImport, props) {\n    return Interop_reactApi.createElement(Interop_reactApi.lazy(() => dynamicImport), props);\n}\n\nexport function React_lazy$0027_Z3D8450FC(dynamicImport, props) {\n    return Interop_reactApi.createElement(Interop_reactApi.lazy(dynamicImport), props);\n}\n\nexport function React_suspense_6E3A73D(children) {\n    let o;\n    return Interop_reactApi.createElement(Interop_reactApi.Suspense, (o = {\n        fallback: null,\n    }, Object.assign({}, o)), ...children);\n}\n\nexport function React_suspense_Z3796A576(children, fallback) {\n    let o;\n    return Interop_reactApi.createElement(Interop_reactApi.Suspense, (o = {\n        fallback: fallback,\n    }, Object.assign({}, o)), ...children);\n}\n\nexport function useReact_useImperativeHandle_596DDC25(ref, createHandle) {\n    Interop_reactApi.useImperativeHandle(ref, createHandle);\n}\n\nexport function useReact_useImperativeHandle_Z12F09548(ref, createHandle, dependencies) {\n    Interop_reactApi.useImperativeHandle(ref, createHandle, dependencies);\n}\n\nexport function useFeliz_React__React_useState_Static_1505(initial) {\n    return Interop_reactApi.useState(initial);\n}\n\nexport const Feliz_React__React_useStateWithUpdater_Static_FCFD9EF = useState;\n\n","import sweetalert2 from \"sweetalert2\";\nimport sweetalert2_react_content from \"sweetalert2-react-content\";\n\nexport const Bindings_swalInternal = sweetalert2;\n\nexport const Bindings_withReactContent = sweetalert2_react_content;\n\nexport const Bindings_swal = Bindings_withReactContent(Bindings_swalInternal);\n\n","import { React_functionComponent_2F9D7239 } from \"./fable_modules/Feliz.1.68.0/React.fs.js\";\nimport { createElement } from \"react\";\nimport { ofArray } from \"./fable_modules/fable-library.3.7.5/List.js\";\nimport { Bindings_swal } from \"./fable_modules/Feliz.SweetAlert.2.8.0/./Bindings.fs.js\";\nimport { createObj } from \"./fable_modules/fable-library.3.7.5/Util.js\";\nimport { System_Exception__Exception_GetPropagatedError } from \"./State.fs.js\";\n\nexport const bodyComp = React_functionComponent_2F9D7239(() => createElement(\"div\", {\n    className: \"modal-card-body\",\n    children: \"Your ticket was submitted successfully\",\n}));\n\nexport function submitSuccessfullyAlert() {\n    const options = ofArray([[\"icon\", \"success\"], [\"html\", bodyComp()], [\"focusConfirm\", true], [\"confirmButtonColor\", \"#4FB3D9\"]]);\n    const pr = Bindings_swal.fire(createObj(options));\n    pr.then();\n}\n\nexport function genericErrorAlert(exn) {\n    const e = System_Exception__Exception_GetPropagatedError(exn);\n    const pr = Bindings_swal.fire({\n        text: e,\n        icon: \"error\",\n    });\n    pr.then();\n}\n\n","import { reverse, empty, cons, fold } from \"../fable-library.3.7.5/List.js\";\nimport { uncurry } from \"../fable-library.3.7.5/Util.js\";\nimport { toString } from \"../fable-library.3.7.5/Types.js\";\nimport { join } from \"../fable-library.3.7.5/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 { empty, singleton, append, delay, toList } from \"./fable_modules/fable-library.3.7.5/Seq.js\";\nimport { createElement } from \"react\";\nimport { createObj } from \"./fable_modules/fable-library.3.7.5/Util.js\";\nimport { Helpers_combineClasses } from \"./fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { singleton as singleton_1, ofArray, empty as empty_1 } from \"./fable_modules/fable-library.3.7.5/List.js\";\nimport { join } from \"./fable_modules/fable-library.3.7.5/String.js\";\nimport { Interop_reactApi } from \"./fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { Msg } from \"./State.fs.js\";\n\nexport function loadingModal(model, dispatch) {\n    const props_6 = toList(delay(() => append(singleton([\"id\", \"modal-sample\"]), delay(() => append(model.LoadingModal ? singleton([\"className\", \"is-active\"]) : empty(), delay(() => {\n        let elems_1, elems;\n        return singleton((elems_1 = [createElement(\"div\", createObj(Helpers_combineClasses(\"modal-background\", empty_1()))), createElement(\"span\", createObj(ofArray([[\"style\", {\n            color: \"white\",\n            zIndex: 31,\n        }], [\"className\", join(\" \", [\"icon fa-6x fa-spin\"])], (elems = [createElement(\"i\", {\n            className: \"fa-solid fa-circle-notch\",\n        })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])]))), createElement(\"button\", createObj(Helpers_combineClasses(\"modal-close\", singleton_1([\"onClick\", (_arg1) => {\n            dispatch(new Msg(3, false));\n        }]))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))]));\n    }))))));\n    return createElement(\"div\", createObj(Helpers_combineClasses(\"modal\", props_6)));\n}\n\n","import { Footer, Navbar } from \"@nfdi4plants/web-components\";\nimport * as react from \"react\";\nimport { keyValueList } from \"./fable_modules/fable-library.3.7.5/MapUtil.js\";\n\n\n\nexport function nfdiNavbar(props, children) {\n    return react.createElement(\"nfdi-navbar\", keyValueList(props, 1), ...children);\n}\n\nexport function nfdiFooter(props, children) {\n    return react.createElement(\"nfdi-footer\", keyValueList(props, 1), ...children);\n}\n\n","\nexport function Browser_Types_Event__Event_get_Value(this$) {\n    return this$.target.value;\n}\n\nexport function Browser_Types_Event__Event_get_Checked(this$) {\n    return this$.target.checked;\n}\n\n","import { empty, singleton, append, delay, toList } from \"../fable_modules/fable-library.3.7.5/Seq.js\";\nimport { createElement } from \"react\";\nimport { cons, ofArray, singleton as singleton_1 } from \"../fable_modules/fable-library.3.7.5/List.js\";\nimport { Interop_reactApi } from \"../fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { value as value_85 } from \"../fable_modules/fable-library.3.7.5/Option.js\";\nimport { join } from \"../fable_modules/fable-library.3.7.5/String.js\";\nimport { createObj } from \"../fable_modules/fable-library.3.7.5/Util.js\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { Msg } from \"../State.fs.js\";\nimport { Browser_Types_Event__Event_get_Value } from \"../fable_modules/Fable.React.8.0.1/Fable.React.Extensions.fs.js\";\nimport { ClientCaptcha } from \"../../Shared/CaptchaTypes.fs.js\";\n\nexport function mainElement(model, dispatch) {\n    const elms_4 = toList(delay(() => {\n        let elms;\n        return append(singleton((elms = singleton_1(createElement(\"p\", {\n            children: [\"Captcha\"],\n        })), createElement(\"label\", {\n            className: \"label\",\n            children: Interop_reactApi.Children.toArray(Array.from(elms)),\n        }))), delay(() => {\n            let src, props_3, elems_1, properties_2;\n            return append((model.Captcha != null) ? ((src = (\"data:image/png;base64, \" + value_85(model.Captcha).ImageBase64), singleton((props_3 = ofArray([[\"className\", join(\" \", [\"has-ratio\"])], [\"style\", {\n                textAlign: \"center\",\n            }], (elems_1 = [createElement(\"img\", createObj(ofArray([(properties_2 = ofArray([[\"width\", 100 + \"%\"], [\"maxWidth\", 400 + \"px\"]]), [\"style\", createObj(properties_2)]), [\"alt\", \"Captcha\"], [\"src\", src]])))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"field\", props_3))))))) : empty(), delay(() => {\n                let props_23, elems_8, elms_1, props_7, elems_2, children_1, props_12, properties_8, elems_4, elms_2;\n                return append(singleton((props_23 = ofArray([[\"className\", \"has-addons\"], (elems_8 = [(elms_1 = singleton_1((props_7 = ofArray([[\"className\", \"is-small\"], [\"className\", join(\" \", [\"is-nfdidark\"])], [\"title\", \"Get new Captcha\"], [\"onClick\", (_arg1) => {\n                    dispatch(new Msg(11));\n                }], (elems_2 = [(children_1 = singleton_1(createElement(\"i\", {\n                    className: join(\" \", toList(delay(() => append(singleton(\"fa-solid fa-repeat\"), delay(() => (model.CaptchaLoading ? singleton(\"fa-spin\") : empty())))))),\n                })), createElement(\"span\", {\n                    children: Interop_reactApi.Children.toArray(Array.from(children_1)),\n                }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_2))])]), createElement(\"a\", createObj(Helpers_combineClasses(\"button\", props_7))))), createElement(\"div\", {\n                    className: \"control\",\n                    children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n                })), (props_12 = ofArray([(properties_8 = singleton_1([\"width\", 100 + \"%\"]), [\"style\", createObj(properties_8)]), (elems_4 = [createElement(\"input\", createObj(cons([\"type\", \"text\"], Helpers_combineClasses(\"input\", ofArray([[\"id\", \"CaptchaInput\"], [\"className\", \"is-small\"], [\"placeholder\", \"Captcha\"], [\"onChange\", (e) => {\n                    let inputRecord;\n                    dispatch(new Msg(6, (inputRecord = value_85(model.Captcha), new ClientCaptcha(inputRecord.Id, inputRecord.ImageBase64, Browser_Types_Event__Event_get_Value(e), inputRecord.AccessToken))));\n                }]])))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_4))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"control\", props_12)))), (elms_2 = toList(delay(() => {\n                    let props_16, elems_5, children_4, props_20, elems_6, children_6;\n                    return ((model.Captcha != null) && (value_85(model.Captcha).AccessToken !== \"\")) ? singleton((props_16 = ofArray([[\"className\", \"is-small\"], [\"className\", \"is-success\"], [\"title\", \"Captcha correct!\"], [\"style\", {\n                        cursor: \"default\",\n                        pointerEvents: \"none\",\n                        [\"--fa-animation-duration\"]: \"1s\",\n                        [\"--fa-animation-iteration-count\"]: \"2\",\n                    }], [\"onClick\", (e_1) => {\n                        e_1.preventDefault();\n                        e_1.stopPropagation();\n                    }], (elems_5 = [(children_4 = singleton_1(createElement(\"i\", {\n                        className: join(\" \", [\"fa-solid fa-check fa-bounce\"]),\n                    })), createElement(\"span\", {\n                        children: Interop_reactApi.Children.toArray(Array.from(children_4)),\n                    }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_5))])]), createElement(\"a\", createObj(Helpers_combineClasses(\"button\", props_16))))) : singleton((props_20 = ofArray([[\"className\", \"is-small\"], [\"className\", join(\" \", [\"is-nfdidark\"])], [\"title\", \"Check Captcha\"], [\"onClick\", (_arg2) => {\n                        dispatch(new Msg(13));\n                    }], (elems_6 = [(children_6 = singleton_1(createElement(\"i\", {\n                        className: join(\" \", [\"fa-solid fa-share\"]),\n                    })), createElement(\"span\", {\n                        children: Interop_reactApi.Children.toArray(Array.from(children_6)),\n                    }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_6))])]), createElement(\"button\", createObj(Helpers_combineClasses(\"button\", props_20)))));\n                })), createElement(\"div\", {\n                    className: \"control\",\n                    children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n                }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_8))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"field\", props_23))))), delay(() => {\n                    let elms_3, props_28, elems_9;\n                    return model.CaptchaDoneWrong ? singleton((elms_3 = singleton_1((props_28 = ofArray([[\"className\", \"is-danger\"], (elems_9 = [createElement(\"button\", createObj(Helpers_combineClasses(\"delete\", singleton_1([\"onClick\", (_arg3) => {\n                        dispatch(new Msg(5, false));\n                    }])))), createElement(\"p\", {\n                        children: [\"Ups! That was wrong, try again!\"],\n                    })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_9))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"notification\", props_28))))), createElement(\"div\", {\n                        className: \"field\",\n                        children: Interop_reactApi.Children.toArray(Array.from(elms_3)),\n                    }))) : empty();\n                }));\n            }));\n        }));\n    }));\n    return createElement(\"div\", {\n        className: \"container\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_4)),\n    });\n}\n\n","import { singleton, append, delay, toList } from \"../fable_modules/fable-library.3.7.5/Seq.js\";\nimport { toString } from \"../fable_modules/fable-library.3.7.5/Types.js\";\nimport { join } from \"../fable_modules/fable-library.3.7.5/String.js\";\nimport { createObj, equals } from \"../fable_modules/fable-library.3.7.5/Util.js\";\nimport { Model } from \"../../Shared/FormModel.fs.js\";\nimport { Msg } from \"../State.fs.js\";\nimport { singleton as singleton_1, cons, ofArray } from \"../fable_modules/fable-library.3.7.5/List.js\";\nimport { createElement } from \"react\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { Interop_reactApi } from \"../fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { IssueType } from \"../../Shared/IssueTypes.fs.js\";\n\nfunction myCheckradio(model, dispatch, name, issueType) {\n    const children = toList(delay(() => {\n        let props;\n        const text = toString(issueType);\n        const id = `${name}${text}`;\n        return append(singleton((props = ofArray([[\"id\", id], [\"name\", name], [\"className\", join(\" \", [\"is-nfdiolive\"])], [\"className\", \"is-circle\"], [\"className\", \"is-info\"], [\"checked\", equals(model.FormModel.IssueType, issueType)], [\"onChange\", (e) => {\n            let inputRecord;\n            dispatch(new Msg(7, (inputRecord = model.FormModel, new Model(issueType, inputRecord.IssueTopic, inputRecord.IssueTitle, inputRecord.IssueContent, inputRecord.UserEmail))));\n        }]]), createElement(\"input\", createObj(cons([\"type\", \"radio\"], Helpers_combineClasses(\"is-checkradio\", props)))))), delay(() => singleton(createElement(\"label\", {\n            htmlFor: id,\n            children: text,\n        }))));\n    }));\n    return createElement(\"div\", {\n        children: Interop_reactApi.Children.toArray(Array.from(children)),\n    });\n}\n\nexport function issueTypeElement(model, dispatch) {\n    let elms_1, elms, props_3, elems_1;\n    const elms_2 = singleton_1((elms_1 = ofArray([(elms = ofArray([createElement(\"span\", {\n        children: [\"Type \"],\n    }), createElement(\"span\", {\n        style: {\n            color: \"#c21f3a\",\n        },\n        children: \"*\",\n    })]), createElement(\"label\", {\n        className: \"label\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), (props_3 = ofArray([[\"style\", {\n        justifyContent: \"space-around\",\n        display: \"flex\",\n    }], (elems_1 = [myCheckradio(model, dispatch, \"radio1\", new IssueType(0)), myCheckradio(model, dispatch, \"radio1\", new IssueType(1)), myCheckradio(model, dispatch, \"radio1\", new IssueType(2))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"field\", props_3))))]), createElement(\"div\", {\n        className: \"box\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    })));\n    return createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    });\n}\n\n","import { toList, toArray, map, filter, delay } from \"./Seq.js\";\r\nimport { HashSet } from \"./MutableSet.js\";\r\nimport { addToDict, getItemFromDict, tryGetValue, addToSet } from \"./MapUtil.js\";\r\nimport { Dictionary } from \"./MutableMap.js\";\r\nimport { disposeSafe, getEnumerator } from \"./Util.js\";\r\nimport { FSharpRef } from \"./Types.js\";\r\n\r\nexport function distinct(xs, comparer) {\r\n    return delay(() => {\r\n        const hashSet = new HashSet([], comparer);\r\n        return filter((x) => addToSet(x, hashSet), xs);\r\n    });\r\n}\r\n\r\nexport function distinctBy(projection, xs, comparer) {\r\n    return delay(() => {\r\n        const hashSet = new HashSet([], comparer);\r\n        return filter((x) => addToSet(projection(x), hashSet), xs);\r\n    });\r\n}\r\n\r\nexport function except(itemsToExclude, xs, comparer) {\r\n    return delay(() => {\r\n        const hashSet = new HashSet(itemsToExclude, comparer);\r\n        return filter((x) => addToSet(x, hashSet), xs);\r\n    });\r\n}\r\n\r\nexport function countBy(projection, xs, comparer) {\r\n    return delay(() => {\r\n        const dict = new Dictionary([], comparer);\r\n        const keys = [];\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const key = projection(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\r\n                let matchValue;\r\n                let outArg = 0;\r\n                matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {\r\n                    outArg = (v | 0);\r\n                })), outArg];\r\n                if (matchValue[0]) {\r\n                    dict.set(key, matchValue[1] + 1);\r\n                }\r\n                else {\r\n                    dict.set(key, 1);\r\n                    void (keys.push(key));\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n        return map((key_1) => [key_1, getItemFromDict(dict, key_1)], keys);\r\n    });\r\n}\r\n\r\nexport function groupBy(projection, xs, comparer) {\r\n    return delay(() => {\r\n        const dict = new Dictionary([], comparer);\r\n        const keys = [];\r\n        const enumerator = getEnumerator(xs);\r\n        try {\r\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n                const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n                const key = projection(x);\r\n                let matchValue;\r\n                let outArg = null;\r\n                matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {\r\n                    outArg = v;\r\n                })), outArg];\r\n                if (matchValue[0]) {\r\n                    void (matchValue[1].push(x));\r\n                }\r\n                else {\r\n                    addToDict(dict, key, [x]);\r\n                    void (keys.push(key));\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            disposeSafe(enumerator);\r\n        }\r\n        return map((key_1) => [key_1, getItemFromDict(dict, key_1)], keys);\r\n    });\r\n}\r\n\r\nexport function Array_distinct(xs, comparer) {\r\n    return toArray(distinct(xs, comparer));\r\n}\r\n\r\nexport function Array_distinctBy(projection, xs, comparer) {\r\n    return toArray(distinctBy(projection, xs, comparer));\r\n}\r\n\r\nexport function Array_except(itemsToExclude, xs, comparer) {\r\n    return toArray(except(itemsToExclude, xs, comparer));\r\n}\r\n\r\nexport function Array_countBy(projection, xs, comparer) {\r\n    return toArray(countBy(projection, xs, comparer));\r\n}\r\n\r\nexport function Array_groupBy(projection, xs, comparer) {\r\n    return toArray(map((tupledArg) => [tupledArg[0], toArray(tupledArg[1])], groupBy(projection, xs, comparer)));\r\n}\r\n\r\nexport function List_distinct(xs, comparer) {\r\n    return toList(distinct(xs, comparer));\r\n}\r\n\r\nexport function List_distinctBy(projection, xs, comparer) {\r\n    return toList(distinctBy(projection, xs, comparer));\r\n}\r\n\r\nexport function List_except(itemsToExclude, xs, comparer) {\r\n    return toList(except(itemsToExclude, xs, comparer));\r\n}\r\n\r\nexport function List_countBy(projection, xs, comparer) {\r\n    return toList(countBy(projection, xs, comparer));\r\n}\r\n\r\nexport function List_groupBy(projection, xs, comparer) {\r\n    return toList(map((tupledArg) => [tupledArg[0], toList(tupledArg[1])], groupBy(projection, xs, comparer)));\r\n}\r\n\r\n","import { Topic__get_toSubCategoryString, Topic__get_toCategoryString, IssueGeneralTopic__get_toString, Topic, IssueSubtopics_Documentation__get_toString, IssueSubtopics_Workflows__get_toString, IssueSubtopics_Tools__get_toString, IssueSubtopics_Metadata__get_toString, IssueSubtopics_Infrastructure__get_toString, IssueSubtopics_RDM__get_toString, IssueGeneralTopic__get_subcategories, Topic__get_toUrlString, IssueGeneralTopic } from \"../../Shared/IssueTypes.fs.js\";\nimport { cons, empty as empty_1, item as item_1, singleton, ofArray } from \"../fable_modules/fable-library.3.7.5/List.js\";\nimport { Msg } from \"../State.fs.js\";\nimport { Model } from \"../../Shared/FormModel.fs.js\";\nimport { createElement } from \"react\";\nimport { safeHash, equals, createObj } from \"../fable_modules/fable-library.3.7.5/Util.js\";\nimport { Interop_reactApi } from \"../fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { map as map_1, length, findIndex, append, collect, empty, singleton as singleton_1, delay, toList } from \"../fable_modules/fable-library.3.7.5/Seq.js\";\nimport { value as value_40 } from \"../fable_modules/fable-library.3.7.5/Option.js\";\nimport { map, last } from \"../fable_modules/fable-library.3.7.5/Array.js\";\nimport { split, join } from \"../fable_modules/fable-library.3.7.5/String.js\";\nimport { List_except } from \"../fable_modules/fable-library.3.7.5/Seq2.js\";\n\nconst topicList = ofArray([new IssueGeneralTopic(0), new IssueGeneralTopic(1), new IssueGeneralTopic(4), new IssueGeneralTopic(2), new IssueGeneralTopic(3), new IssueGeneralTopic(5), new IssueGeneralTopic(6)]);\n\nconst SwitchDropdownResponsivePX = 600;\n\nfunction ButtonDropdown_updateFormWithTopic(model, dispatch, topic) {\n    dispatch(new Msg(0));\n    let nextModel;\n    const inputRecord = model.FormModel;\n    nextModel = (new Model(inputRecord.IssueType, topic, inputRecord.IssueTitle, inputRecord.IssueContent, inputRecord.UserEmail));\n    const pathName = `/?topic=${Topic__get_toUrlString(topic)}`;\n    window.history.replaceState(\"\", void 0, pathName);\n    dispatch(new Msg(7, nextModel));\n}\n\nfunction ButtonDropdown_backResponsiveDropdownItem(model, dispatch) {\n    let elems_1, elems, properties_3;\n    const props_3 = ofArray([[\"onClick\", (e) => {\n        e.stopPropagation();\n        dispatch(new Msg(1, void 0));\n    }], (elems_1 = [createElement(\"span\", createObj(ofArray([[\"style\", {\n        display: \"flex\",\n        flexGrow: 1,\n        alignItems: \"center\",\n    }], (elems = [createElement(\"i\", {\n        style: {\n            marginRight: \"1rem\",\n        },\n        className: \"fa-solid fa-angle-left\",\n    }), createElement(\"span\", createObj(ofArray([(properties_3 = singleton([\"marginRight\", 1.5 + \"rem\"]), [\"style\", createObj(properties_3)]), [\"children\", \"Back\"]])))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])])))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])]);\n    return createElement(\"a\", createObj(Helpers_combineClasses(\"dropdown-item\", props_3)));\n}\n\nexport function ButtonDropdown_subcategories(model, dispatch, block) {\n    let properties, elems;\n    const subcategories = IssueGeneralTopic__get_subcategories(block);\n    const isActive = equals(model.DropdownActiveTopic, block);\n    return createElement(\"div\", createObj(ofArray([[\"className\", \"nested-dropdown\"], (properties = toList(delay(() => (isActive ? singleton_1([\"display\", \"block\"]) : empty()))), [\"style\", createObj(properties)]), (elems = toList(delay(() => collect((topic) => {\n        let properties_1;\n        let subCText;\n        switch (topic.tag) {\n            case 0: {\n                subCText = IssueSubtopics_RDM__get_toString(topic.fields[0]);\n                break;\n            }\n            case 1: {\n                subCText = IssueSubtopics_Infrastructure__get_toString(topic.fields[0]);\n                break;\n            }\n            case 4: {\n                subCText = IssueSubtopics_Metadata__get_toString(topic.fields[0]);\n                break;\n            }\n            case 2: {\n                subCText = IssueSubtopics_Tools__get_toString(topic.fields[0]);\n                break;\n            }\n            case 3: {\n                subCText = IssueSubtopics_Workflows__get_toString(topic.fields[0]);\n                break;\n            }\n            case 5: {\n                subCText = IssueSubtopics_Documentation__get_toString(topic.fields[0]);\n                break;\n            }\n            default: {\n                throw (new Error(`Could not match ${topic} with issue subcategories.`));\n            }\n        }\n        return singleton_1(createElement(\"div\", createObj(ofArray([(properties_1 = toList(delay(() => (equals(model.DropdownActiveSubtopic, topic) ? append(singleton_1([\"backgroundColor\", \"#4FB3D9\"]), delay(() => singleton_1([\"color\", \"white\"]))) : empty()))), [\"style\", createObj(properties_1)]), [\"onMouseOver\", (_arg1) => {\n            dispatch(new Msg(2, topic));\n        }], [\"onMouseOut\", (_arg2) => {\n            dispatch(new Msg(2, void 0));\n        }], [\"onClick\", (e) => {\n            e.stopPropagation();\n            e.preventDefault();\n            ButtonDropdown_updateFormWithTopic(model, dispatch, topic);\n        }], [\"children\", subCText]]))));\n    }, subcategories))), [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])])));\n}\n\nexport function ButtonDropdown_createDropdownItem(model, dispatch, block) {\n    const props_3 = toList(delay(() => append(equals(model.DropdownActiveTopic, block) ? singleton_1([\"className\", \"is-active\"]) : empty(), delay(() => {\n        let properties;\n        return append(singleton_1((properties = singleton([\"paddingRight\", 1 + \"rem\"]), [\"style\", createObj(properties)])), delay(() => append(singleton_1([\"onMouseOver\", (e) => {\n            if (e.view.innerWidth > SwitchDropdownResponsivePX) {\n                dispatch(new Msg(1, block));\n            }\n        }]), delay(() => append(singleton_1([\"onMouseOut\", (e_1) => {\n            if (e_1.view.innerWidth > SwitchDropdownResponsivePX) {\n                dispatch(new Msg(1, void 0));\n            }\n        }]), delay(() => append(singleton_1([\"onTouchEnd\", (e_2) => {\n            e_2.stopPropagation();\n            e_2.preventDefault();\n            if ((e_2.view.innerWidth < SwitchDropdownResponsivePX) && (!equals(block, new IssueGeneralTopic(6)))) {\n                dispatch(new Msg(1, block));\n            }\n            else if ((e_2.view.innerWidth < SwitchDropdownResponsivePX) && equals(block, new IssueGeneralTopic(6))) {\n                ButtonDropdown_updateFormWithTopic(model, dispatch, new Topic(6));\n            }\n        }]), delay(() => append(singleton_1([\"onClick\", (e_3) => {\n            e_3.stopPropagation();\n            e_3.preventDefault();\n            if (equals(block, new IssueGeneralTopic(6))) {\n                ButtonDropdown_updateFormWithTopic(model, dispatch, new Topic(6));\n            }\n        }]), delay(() => {\n            let elems_1;\n            return singleton_1((elems_1 = toList(delay(() => {\n                let elems;\n                return append(singleton_1(createElement(\"span\", createObj(ofArray([[\"style\", {\n                    display: \"flex\",\n                    flexGrow: 1,\n                    alignItems: \"center\",\n                }], (elems = toList(delay(() => {\n                    let properties_2;\n                    return append(singleton_1(createElement(\"span\", createObj(ofArray([(properties_2 = singleton([\"marginRight\", 1.5 + \"rem\"]), [\"style\", createObj(properties_2)]), [\"children\", IssueGeneralTopic__get_toString(block)]])))), delay(() => ((!equals(block, new IssueGeneralTopic(6))) ? singleton_1(createElement(\"i\", {\n                        style: {\n                            marginLeft: \"auto\",\n                        },\n                        className: \"fa-solid fa-angle-right\",\n                    })) : empty())));\n                })), [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])])))), delay(() => ((!equals(block, new IssueGeneralTopic(6))) ? singleton_1(ButtonDropdown_subcategories(model, dispatch, block)) : empty())));\n            })), [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))]));\n        }))))))))));\n    }))));\n    return createElement(\"a\", createObj(Helpers_combineClasses(\"dropdown-item\", props_3)));\n}\n\nexport function ButtonDropdown_createDropdownItemSubcategory(model, dispatch, topic) {\n    let properties, elems;\n    const props_1 = ofArray([(properties = toList(delay(() => (equals(model.DropdownActiveSubtopic, topic) ? append(singleton_1([\"backgroundColor\", \"#4FB3D9\"]), delay(() => singleton_1([\"color\", \"white\"]))) : empty()))), [\"style\", createObj(properties)]), [\"onMouseOver\", (e) => {\n        if (e.view.innerWidth > SwitchDropdownResponsivePX) {\n            dispatch(new Msg(2, topic));\n        }\n    }], [\"onMouseOut\", (e_1) => {\n        if (e_1.view.innerWidth > SwitchDropdownResponsivePX) {\n            dispatch(new Msg(2, void 0));\n        }\n    }], [\"onClick\", (e_2) => {\n        e_2.stopPropagation();\n        e_2.preventDefault();\n        let nextModel;\n        const inputRecord = model.FormModel;\n        nextModel = (new Model(inputRecord.IssueType, topic, inputRecord.IssueTitle, inputRecord.IssueContent, inputRecord.UserEmail));\n        const pathName = `/?topic=${Topic__get_toUrlString(topic)}`;\n        window.history.replaceState(\"\", void 0, pathName);\n        dispatch(new Msg(7, nextModel));\n        dispatch(new Msg(0));\n    }], (elems = toList(delay(() => {\n        let subCText;\n        switch (topic.tag) {\n            case 0: {\n                subCText = IssueSubtopics_RDM__get_toString(topic.fields[0]);\n                break;\n            }\n            case 1: {\n                subCText = IssueSubtopics_Infrastructure__get_toString(topic.fields[0]);\n                break;\n            }\n            case 4: {\n                subCText = IssueSubtopics_Metadata__get_toString(topic.fields[0]);\n                break;\n            }\n            case 2: {\n                subCText = IssueSubtopics_Tools__get_toString(topic.fields[0]);\n                break;\n            }\n            case 3: {\n                subCText = IssueSubtopics_Workflows__get_toString(topic.fields[0]);\n                break;\n            }\n            case 5: {\n                subCText = IssueSubtopics_Documentation__get_toString(topic.fields[0]);\n                break;\n            }\n            default: {\n                throw (new Error(`Could not match ${topic} with issue subcategories.`));\n            }\n        }\n        return singleton_1(createElement(\"span\", {\n            children: subCText,\n        }));\n    })), [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])]);\n    return createElement(\"a\", createObj(Helpers_combineClasses(\"dropdown-item\", props_1)));\n}\n\nfunction ButtonDropdown_findCurrentTopicIndex(item, itemList) {\n    if (item == null) {\n        return -1;\n    }\n    else {\n        return findIndex((x) => equals(x, value_40(item)), itemList) | 0;\n    }\n}\n\nfunction ButtonDropdown_findNextTopicIndex(item, itemList) {\n    const current = ButtonDropdown_findCurrentTopicIndex(item, itemList) | 0;\n    if (current >= (length(itemList) - 1)) {\n        return (length(itemList) - 1) | 0;\n    }\n    else {\n        return (current + 1) | 0;\n    }\n}\n\nfunction ButtonDropdown_findPreviousTopicIndec(item, itemList) {\n    const current = ButtonDropdown_findCurrentTopicIndex(item, itemList) | 0;\n    if (current <= 0) {\n        return 0;\n    }\n    else {\n        return (current - 1) | 0;\n    }\n}\n\nexport function ButtonDropdown_createDropdown(model, dispatch) {\n    let elems_8, props_18;\n    const props_20 = singleton((elems_8 = [(props_18 = toList(delay(() => append(model.DropdownIsActive ? singleton_1([\"className\", \"is-active\"]) : empty(), delay(() => {\n        let elems_7, elms, props_6, elms_1;\n        return singleton_1((elems_7 = [(elms = singleton((props_6 = toList(delay(() => append(singleton_1([\"tabIndex\", 0]), delay(() => append(singleton_1([\"title\", (model.FormModel.IssueTopic == null) ? \"Choose a topic\" : (`${Topic__get_toCategoryString(value_40(model.FormModel.IssueTopic))} > ${Topic__get_toSubCategoryString(value_40(model.FormModel.IssueTopic))}`)]), delay(() => append(singleton_1([\"onClick\", (e) => {\n            e.stopPropagation();\n            dispatch(new Msg(0));\n        }]), delay(() => append(singleton_1([\"onKeyDown\", (e_1) => {\n            let ind, inputRecord, matchValue_1, uc, bc, inputRecord_1, ind_2;\n            const matchValue = e_1.which;\n            let pattern_matching_result;\n            if (matchValue === 13) {\n                if (!model.DropdownIsActive) {\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                    e_1.preventDefault();\n                    dispatch(new Msg(0));\n                    break;\n                }\n                case 1: {\n                    let pattern_matching_result_1;\n                    if (matchValue === 9) {\n                        if (model.DropdownIsActive) {\n                            pattern_matching_result_1 = 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                            e_1.preventDefault();\n                            dispatch(new Msg(0));\n                            break;\n                        }\n                        case 1: {\n                            let pattern_matching_result_2;\n                            if (matchValue === 37) {\n                                if (model.DropdownActiveSubtopic != null) {\n                                    pattern_matching_result_2 = 0;\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                                    e_1.preventDefault();\n                                    dispatch(new Msg(2, void 0));\n                                    break;\n                                }\n                                case 1: {\n                                    let pattern_matching_result_3;\n                                    if (matchValue === 38) {\n                                        if (model.DropdownActiveSubtopic != null) {\n                                            pattern_matching_result_3 = 0;\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                                            e_1.preventDefault();\n                                            const list = IssueGeneralTopic__get_subcategories(value_40(model.DropdownActiveTopic));\n                                            dispatch(new Msg(2, (ind = (ButtonDropdown_findPreviousTopicIndec(model.DropdownActiveSubtopic, list) | 0), list[ind])));\n                                            break;\n                                        }\n                                        case 1: {\n                                            let pattern_matching_result_4;\n                                            if (matchValue === 38) {\n                                                pattern_matching_result_4 = 0;\n                                            }\n                                            else if (matchValue === 39) {\n                                                if (equals(model.DropdownActiveTopic, new IssueGeneralTopic(6))) {\n                                                    pattern_matching_result_4 = 1;\n                                                }\n                                                else {\n                                                    pattern_matching_result_4 = 2;\n                                                }\n                                            }\n                                            else if (matchValue === 13) {\n                                                if (equals(model.DropdownActiveTopic, new IssueGeneralTopic(6))) {\n                                                    pattern_matching_result_4 = 1;\n                                                }\n                                                else {\n                                                    pattern_matching_result_4 = 2;\n                                                }\n                                            }\n                                            else {\n                                                pattern_matching_result_4 = 2;\n                                            }\n                                            switch (pattern_matching_result_4) {\n                                                case 0: {\n                                                    e_1.preventDefault();\n                                                    dispatch(new Msg(1, item_1(ButtonDropdown_findPreviousTopicIndec(model.DropdownActiveTopic, topicList), topicList)));\n                                                    break;\n                                                }\n                                                case 1: {\n                                                    e_1.preventDefault();\n                                                    const pathName = `/?topic=${Topic__get_toUrlString(new Topic(6))}`;\n                                                    window.history.replaceState(\"\", void 0, pathName);\n                                                    dispatch(new Msg(0));\n                                                    dispatch(new Msg(7, (inputRecord = model.FormModel, new Model(inputRecord.IssueType, new Topic(6), inputRecord.IssueTitle, inputRecord.IssueContent, inputRecord.UserEmail))));\n                                                    break;\n                                                }\n                                                case 2: {\n                                                    let pattern_matching_result_5;\n                                                    if (matchValue === 39) {\n                                                        if (equals(model.DropdownActiveSubtopic, void 0)) {\n                                                            pattern_matching_result_5 = 0;\n                                                        }\n                                                        else {\n                                                            pattern_matching_result_5 = 1;\n                                                        }\n                                                    }\n                                                    else if (matchValue === 13) {\n                                                        if (equals(model.DropdownActiveSubtopic, void 0)) {\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                                                            e_1.preventDefault();\n                                                            dispatch(new Msg(2, (matchValue_1 = value_40(model.DropdownActiveTopic), ((uc = matchValue_1, (equals(uc, new IssueGeneralTopic(0)) ? true : equals(uc, new IssueGeneralTopic(1))) ? true : equals(uc, new IssueGeneralTopic(4)))) ? IssueGeneralTopic__get_subcategories(matchValue_1)[0] : (((bc = matchValue_1, equals(bc, new IssueGeneralTopic(2)) ? true : equals(bc, new IssueGeneralTopic(3)))) ? last(IssueGeneralTopic__get_subcategories(matchValue_1)) : (() => {\n                                                                throw (new Error(`Could not parse ${matchValue_1} to keyboard navigation event`));\n                                                            })()))));\n                                                            break;\n                                                        }\n                                                        case 1: {\n                                                            let pattern_matching_result_6;\n                                                            if (matchValue === 39) {\n                                                                if (model.DropdownActiveSubtopic != null) {\n                                                                    pattern_matching_result_6 = 0;\n                                                                }\n                                                                else {\n                                                                    pattern_matching_result_6 = 1;\n                                                                }\n                                                            }\n                                                            else if (matchValue === 13) {\n                                                                if (model.DropdownActiveSubtopic != null) {\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                                                            switch (pattern_matching_result_6) {\n                                                                case 0: {\n                                                                    e_1.preventDefault();\n                                                                    const pathName_1 = `/?topic=${Topic__get_toUrlString(value_40(model.DropdownActiveSubtopic))}`;\n                                                                    window.history.replaceState(\"\", void 0, pathName_1);\n                                                                    dispatch(new Msg(0));\n                                                                    dispatch(new Msg(7, (inputRecord_1 = model.FormModel, new Model(inputRecord_1.IssueType, value_40(model.DropdownActiveSubtopic), inputRecord_1.IssueTitle, inputRecord_1.IssueContent, inputRecord_1.UserEmail))));\n                                                                    break;\n                                                                }\n                                                                case 1: {\n                                                                    let pattern_matching_result_7;\n                                                                    if (matchValue === 40) {\n                                                                        if (model.DropdownActiveSubtopic != null) {\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                                                                    switch (pattern_matching_result_7) {\n                                                                        case 0: {\n                                                                            e_1.preventDefault();\n                                                                            const list_1 = IssueGeneralTopic__get_subcategories(value_40(model.DropdownActiveTopic));\n                                                                            dispatch(new Msg(2, (ind_2 = (ButtonDropdown_findNextTopicIndex(model.DropdownActiveSubtopic, list_1) | 0), list_1[ind_2])));\n                                                                            break;\n                                                                        }\n                                                                        case 1: {\n                                                                            if (matchValue === 40) {\n                                                                                e_1.preventDefault();\n                                                                                dispatch(new Msg(1, item_1(ButtonDropdown_findNextTopicIndex(model.DropdownActiveTopic, topicList), topicList)));\n                                                                            }\n                                                                            break;\n                                                                        }\n                                                                    }\n                                                                    break;\n                                                                }\n                                                            }\n                                                            break;\n                                                        }\n                                                    }\n                                                    break;\n                                                }\n                                            }\n                                            break;\n                                        }\n                                    }\n                                    break;\n                                }\n                            }\n                            break;\n                        }\n                    }\n                    break;\n                }\n            }\n        }]), delay(() => {\n            let elems_2, elems, properties, elems_1, properties_4;\n            return singleton_1((elems_2 = [createElement(\"span\", createObj(ofArray([[\"className\", join(\" \", [\"min-hide\"])], (elems = [createElement(\"span\", createObj(ofArray([(properties = singleton([\"marginRight\", 5 + \"px\"]), [\"style\", createObj(properties)]), [\"children\", (model.FormModel.IssueTopic == null) ? \"Please select\" : Topic__get_toSubCategoryString(value_40(model.FormModel.IssueTopic))]]))), createElement(\"i\", {\n                className: \"fa-solid fa-angle-down\",\n            })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])]))), createElement(\"span\", createObj(ofArray([[\"className\", join(\" \", [\"min-hide-opposite\"])], (elems_1 = [createElement(\"span\", createObj(ofArray([(properties_4 = singleton([\"marginRight\", 5 + \"px\"]), [\"style\", createObj(properties_4)]), [\"children\", (model.FormModel.IssueTopic == null) ? \"Select\" : join(\"\", map((x) => x[0], split(Topic__get_toSubCategoryString(value_40(model.FormModel.IssueTopic)), [\" \"], null, 1)))]]))), createElement(\"i\", {\n                className: \"fa-solid fa-angle-down\",\n            })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])])))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_2))]));\n        })))))))))), createElement(\"a\", createObj(Helpers_combineClasses(\"button\", props_6))))), createElement(\"div\", {\n            className: \"dropdown-trigger\",\n            children: Interop_reactApi.Children.toArray(Array.from(elms)),\n        })), (elms_1 = toList(delay(() => {\n            let subcategories, props_11, elems_4;\n            return append((model.DropdownActiveTopic != null) ? ((subcategories = IssueGeneralTopic__get_subcategories(value_40(model.DropdownActiveTopic)), singleton_1((props_11 = ofArray([[\"className\", join(\" \", [\"responsive-dropdown-subcontent\"])], (elems_4 = toList(delay(() => append(singleton_1(ButtonDropdown_backResponsiveDropdownItem(model, dispatch)), delay(() => append(singleton_1(createElement(\"hr\", createObj(Helpers_combineClasses(\"dropdown-divider\", empty_1())))), delay(() => map_1((topic) => ButtonDropdown_createDropdownItemSubcategory(model, dispatch, topic), subcategories))))))), [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_4))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"dropdown-content\", props_11))))))) : empty(), delay(() => {\n                let props_15;\n                return singleton_1((props_15 = toList(delay(() => append((model.DropdownActiveTopic != null) ? singleton_1([\"className\", join(\" \", [\"responsive-dropdown-content\"])]) : empty(), delay(() => {\n                    let elems_5;\n                    return singleton_1((elems_5 = toList(delay(() => append(map_1((topic_1) => ButtonDropdown_createDropdownItem(model, dispatch, topic_1), List_except([new IssueGeneralTopic(6)], topicList, {\n                        Equals: equals,\n                        GetHashCode: safeHash,\n                    })), delay(() => append(singleton_1(createElement(\"hr\", createObj(Helpers_combineClasses(\"dropdown-divider\", empty_1())))), delay(() => singleton_1(ButtonDropdown_createDropdownItem(model, dispatch, new IssueGeneralTopic(6))))))))), [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_5))]));\n                })))), createElement(\"div\", createObj(Helpers_combineClasses(\"dropdown-content\", props_15)))));\n            }));\n        })), createElement(\"div\", {\n            className: \"dropdown-menu\",\n            children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n        }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_7))]));\n    })))), createElement(\"div\", createObj(Helpers_combineClasses(\"dropdown\", props_18))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_8))]));\n    return createElement(\"div\", createObj(Helpers_combineClasses(\"control\", props_20)));\n}\n\nexport function issueTitleElement(model, dispatch) {\n    let elms_1, elms, props_7, elems_2, props_5, elems_1;\n    const elms_2 = singleton((elms_1 = ofArray([(elms = ofArray([createElement(\"span\", {\n        children: [\"Title \"],\n    }), createElement(\"span\", {\n        style: {\n            color: \"#c21f3a\",\n        },\n        children: \"*\",\n    })]), createElement(\"label\", {\n        className: \"label\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), (props_7 = ofArray([[\"className\", \"has-addons\"], (elems_2 = [ButtonDropdown_createDropdown(model, dispatch), (props_5 = ofArray([[\"className\", \"is-expanded\"], (elems_1 = [createElement(\"input\", createObj(cons([\"type\", \"text\"], Helpers_combineClasses(\"input\", ofArray([[\"id\", \"TitleInput\"], [\"placeholder\", \"please give your issue a title ..\"], [\"onChange\", (ev) => {\n        let inputRecord;\n        dispatch(new Msg(7, (inputRecord = model.FormModel, new Model(inputRecord.IssueType, inputRecord.IssueTopic, ev.target.value, inputRecord.IssueContent, inputRecord.UserEmail))));\n    }]])))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])]), createElement(\"p\", createObj(Helpers_combineClasses(\"control\", props_5))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_2))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"field\", props_7))))]), createElement(\"div\", {\n        className: \"box\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    })));\n    return createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    });\n}\n\n","import { createElement } from \"react\";\nimport { singleton, ofArray } from \"../fable_modules/fable-library.3.7.5/List.js\";\nimport { Interop_reactApi } from \"../fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { createObj } from \"../fable_modules/fable-library.3.7.5/Util.js\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { Browser_Types_Event__Event_get_Value } from \"../fable_modules/Fable.React.8.0.1/Fable.React.Extensions.fs.js\";\nimport { Model } from \"../../Shared/FormModel.fs.js\";\nimport { Msg } from \"../State.fs.js\";\n\nexport function issueContentElement(model, dispatch) {\n    let elms_1, elms;\n    const elms_2 = singleton((elms_1 = ofArray([(elms = ofArray([createElement(\"span\", {\n        children: [\"Description \"],\n    }), createElement(\"span\", {\n        style: {\n            color: \"#c21f3a\",\n        },\n        children: \"*\",\n    })]), createElement(\"label\", {\n        className: \"label\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), createElement(\"textarea\", createObj(Helpers_combineClasses(\"textarea\", ofArray([[\"id\", \"DescriptionInput\"], [\"placeholder\", \"please describe your issue ..\"], [\"onChange\", (e) => {\n        let inputRecord;\n        dispatch(new Msg(7, (inputRecord = model.FormModel, new Model(inputRecord.IssueType, inputRecord.IssueTopic, inputRecord.IssueTitle, Browser_Types_Event__Event_get_Value(e), inputRecord.UserEmail))));\n    }]]))))]), createElement(\"div\", {\n        className: \"box\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    })));\n    return createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    });\n}\n\n","import { createElement } from \"react\";\nimport { cons, ofArray, singleton } from \"../fable_modules/fable-library.3.7.5/List.js\";\nimport { Interop_reactApi } from \"../fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { createObj } from \"../fable_modules/fable-library.3.7.5/Util.js\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { Browser_Types_Event__Event_get_Value } from \"../fable_modules/Fable.React.8.0.1/Fable.React.Extensions.fs.js\";\nimport { Model } from \"../../Shared/FormModel.fs.js\";\nimport { Msg } from \"../State.fs.js\";\nimport { join } from \"../fable_modules/fable-library.3.7.5/String.js\";\n\nexport function userEmailElement(model, dispatch) {\n    let elms_1, elms, props_8, elems_2, elems_1;\n    const elms_2 = singleton((elms_1 = ofArray([(elms = singleton(createElement(\"p\", {\n        children: [\"Email\"],\n    })), createElement(\"label\", {\n        className: \"label\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), createElement(\"p\", createObj(Helpers_combineClasses(\"help\", singleton([\"children\", \"If you want updates about your issue you can give us your email address. We will keep your contact information only as long as your issue is open.\"])))), (props_8 = ofArray([[\"className\", \"has-icons-left\"], (elems_2 = [createElement(\"input\", createObj(cons([\"type\", \"email\"], Helpers_combineClasses(\"input\", ofArray([[\"id\", \"EmailInput\"], [\"placeholder\", \"Email\"], [\"onChange\", (e) => {\n        let inputRecord;\n        dispatch(new Msg(7, (inputRecord = model.FormModel, new Model(inputRecord.IssueType, inputRecord.IssueTopic, inputRecord.IssueTitle, inputRecord.IssueContent, Browser_Types_Event__Event_get_Value(e)))));\n    }]]))))), createElement(\"span\", createObj(ofArray([[\"className\", join(\" \", [\"icon is-small is-left\"])], (elems_1 = [createElement(\"i\", {\n        className: \"fas fa-envelope\",\n    })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])])))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_2))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"control\", props_8))))]), createElement(\"div\", {\n        className: \"box\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    })));\n    return createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    });\n}\n\n","import { singleton, ofArray } from \"../fable_modules/fable-library.3.7.5/List.js\";\nimport { createObj } from \"../fable_modules/fable-library.3.7.5/Util.js\";\nimport { join } from \"../fable_modules/fable-library.3.7.5/String.js\";\nimport { createElement } from \"react\";\nimport { Interop_reactApi } from \"../fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { Helpers_combineClasses } from \"../fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\nimport { mainElement as mainElement_1 } from \"./HelpdeskCaptcha.fs.js\";\nimport { empty, singleton as singleton_1, append, delay, toList } from \"../fable_modules/fable-library.3.7.5/Seq.js\";\nimport { value as value_38 } from \"../fable_modules/fable-library.3.7.5/Option.js\";\nimport { Msg } from \"../State.fs.js\";\nimport { issueTypeElement } from \"./HelpdeskCheckradio.fs.js\";\nimport { issueTitleElement } from \"./HelpdeskTitle.fs.js\";\nimport { issueContentElement } from \"./HelpdeskDescription.fs.js\";\nimport { userEmailElement } from \"./HelpdeskEmail.fs.js\";\n\nexport const header = (() => {\n    let properties, elems_7, props_10, elems_5, props_8, elems_4, elms, props_1, elems, props_6, elems_3, elms_1, elms_2;\n    const props_14 = ofArray([(properties = ofArray([[\"backgroundColor\", \"#ECEBEB\"], [\"padding\", ((1 + \"rem\") + \" \") + (2 + \"rem\")]]), [\"style\", createObj(properties)]), (elems_7 = [(props_10 = ofArray([[\"className\", join(\" \", [\"decrease-margin-bottom\"])], (elems_5 = [(props_8 = ofArray([[\"className\", join(\" \", [\"min-flex-column\"])], (elems_4 = [(elms = singleton((props_1 = ofArray([[\"className\", \"is-128x128\"], [\"style\", {\n        marginLeft: 0,\n        marginRight: 0,\n    }], (elems = [createElement(\"img\", {\n        src: \"https://raw.githubusercontent.com/nfdi4plants/Branding/master/logos/DataPLANT/DataPLANT_logo_square_bg_darkblue.svg\",\n    })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])]), createElement(\"figure\", createObj(Helpers_combineClasses(\"image\", props_1))))), createElement(\"div\", {\n        className: \"media-left\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), (props_6 = ofArray([[\"style\", {\n        margin: \"auto\",\n    }], (elems_3 = [(elms_1 = singleton(createElement(\"h1\", {\n        style: {\n            color: \"grey\",\n        },\n        children: \"Submit a ticket\",\n    })), createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_3))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"media-content\", props_6))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_4))])]), createElement(\"article\", createObj(Helpers_combineClasses(\"media\", props_8))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_5))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"content\", props_10)))), (elms_2 = singleton(createElement(\"h5\", {\n        children: \"Please fill out this form to submit a new request to DataPLANT\",\n    })), createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    }))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_7))])]);\n    return createElement(\"div\", createObj(Helpers_combineClasses(\"content\", props_14)));\n})();\n\nexport function captchaANDsubmit(model, dispatch) {\n    let elms_2, elms, elms_1, props_4;\n    const elms_3 = singleton((elms_2 = ofArray([(elms = singleton(mainElement_1(model, dispatch)), createElement(\"div\", {\n        className: \"field\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), (elms_1 = singleton((props_4 = toList(delay(() => {\n        const isActive = ((((model.Captcha != null) && (value_38(model.Captcha).AccessToken !== \"\")) && (model.FormModel.IssueTitle !== \"\")) && (model.FormModel.IssueTopic != null)) && (model.FormModel.IssueContent !== \"\");\n        return append(singleton_1([\"onClick\", (_arg1) => {\n            if (isActive) {\n                dispatch(new Msg(8));\n            }\n        }]), delay(() => append(singleton_1([\"className\", join(\" \", [\"is-nfdidark\"])]), delay(() => append((!isActive) ? singleton_1([\"className\", \"is-static\"]) : empty(), delay(() => append(singleton_1([\"className\", \"is-fullwidth\"]), delay(() => {\n            let elems_2, elems_1;\n            return singleton_1((elems_2 = [createElement(\"span\", {\n                children: [\"Submit\"],\n            }), createElement(\"span\", createObj(ofArray([[\"className\", join(\" \", [\"icon is-small\"])], (elems_1 = [createElement(\"i\", {\n                className: \"fa-solid fa-share\",\n            })], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])])))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_2))]));\n        }))))))));\n    })), createElement(\"button\", createObj(Helpers_combineClasses(\"button\", props_4))))), createElement(\"div\", {\n        className: \"field\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_1)),\n    }))]), createElement(\"div\", {\n        className: \"box\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_2)),\n    })));\n    return createElement(\"div\", {\n        className: \"content\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms_3)),\n    });\n}\n\nexport function mainElement(model, dispatch) {\n    let elems;\n    const props = ofArray([[\"style\", {}], (elems = [header, issueTypeElement(model, dispatch), issueTitleElement(model, dispatch), issueContentElement(model, dispatch), userEmailElement(model, dispatch), captchaANDsubmit(model, dispatch)], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems))])]);\n    return createElement(\"div\", createObj(Helpers_combineClasses(\"container\", props)));\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 { Common_lazyView2With } from \"./common.fs.js\";\nimport { uncurry } from \"../fable-library.3.7.5/Util.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            const r = lastRequest;\n            window.cancelAnimationFrame(r);\n        }\n        lastRequest = window.requestAnimationFrame((_arg1) => {\n            react_dom.render(lazyView2With((x) => ((y) => (x === y)), 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)), 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)), 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(uncurry(2, equal), uncurry(2, view), state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReactSynchronous(placeholderId, program) {\n    return Program_Internal_withReactSynchronousUsing((equal, view, state, dispatch) => Common_lazyView2With(uncurry(2, equal), uncurry(2, view), state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReact(placeholderId, program) {\n    return Program_Internal_withReactBatchedUsing((equal, view, state, dispatch) => Common_lazyView2With(uncurry(2, equal), uncurry(2, view), state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReactUnoptimized(placeholderId, program) {\n    return Program_Internal_withReactSynchronousUsing((equal, view, state, dispatch) => Common_lazyView2With(uncurry(2, equal), uncurry(2, view), state, dispatch), placeholderId, program);\n}\n\nexport function Program_withReactHydrate(placeholderId, program) {\n    return Program_Internal_withReactHydrateUsing((equal, view, state, dispatch) => Common_lazyView2With(uncurry(2, equal), uncurry(2, view), state, dispatch), placeholderId, program);\n}\n\n","import { Cmd_batch, Cmd_none } from \"./fable_modules/Fable.Elmish.3.1.0/cmd.fs.js\";\nimport { Topic_ofUrlString_Z721C83C5 } from \"../Shared/IssueTypes.fs.js\";\nimport { value as value_20 } from \"./fable_modules/fable-library.3.7.5/Option.js\";\nimport { Model_init, Model } from \"../Shared/FormModel.fs.js\";\nimport { curry, api, Msg, Model as Model_1 } from \"./State.fs.js\";\nimport { Cmd_OfAsync_start, Cmd_OfAsyncWith_either, Cmd_OfFunc_result } from \"./fable_modules/Fable.Elmish.3.1.0/./cmd.fs.js\";\nimport { Routing_parsePath } from \"./Routing.fs.js\";\nimport { singleton, ofArray } from \"./fable_modules/fable-library.3.7.5/List.js\";\nimport { genericErrorAlert, submitSuccessfullyAlert } from \"./alerts.fs.js\";\nimport { loadingModal } from \"./Modal.fs.js\";\nimport { nfdiFooter, nfdiNavbar } from \"./nfdi-webcomponents.fs.js\";\nimport { createElement } from \"react\";\nimport { Interop_reactApi } from \"./fable_modules/Feliz.1.68.0/./Interop.fs.js\";\nimport { join } from \"./fable_modules/fable-library.3.7.5/String.js\";\nimport { createObj } from \"./fable_modules/fable-library.3.7.5/Util.js\";\nimport { mainElement } from \"./FormElements/HelpdeskMain.fs.js\";\nimport { Helpers_combineClasses } from \"./fable_modules/Feliz.Bulma.2.19.0/./ElementBuilders.fs.js\";\n\nexport function urlUpdate(route, model) {\n    let inputRecord;\n    if (route == null) {\n        return [model, Cmd_none()];\n    }\n    else {\n        const topicStr = route.fields[0];\n        return [(topicStr == null) ? model : (new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, (inputRecord = model.FormModel, new Model(inputRecord.IssueType, Topic_ofUrlString_Z721C83C5(value_20(topicStr)), inputRecord.IssueTitle, inputRecord.IssueContent, inputRecord.UserEmail)), model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong)), Cmd_none()];\n    }\n}\n\nexport function clearInputs() {\n    const inptuById = (id) => document.getElementById(id);\n    const title = inptuById(\"TitleInput\");\n    title.value = \"\";\n    const description = inptuById(\"DescriptionInput\");\n    description.value = \"\";\n    const email = inptuById(\"EmailInput\");\n    email.value = \"\";\n    const captcha = inptuById(\"CaptchaInput\");\n    captcha.value = \"\";\n}\n\nexport function init(url) {\n    const model = new Model_1(false, false, void 0, void 0, Model_init(), void 0, false, false);\n    const initCaptcha = Cmd_OfFunc_result(new Msg(11));\n    const patternInput = urlUpdate(Routing_parsePath(document.location), model);\n    return [patternInput[0], Cmd_batch(ofArray([initCaptcha, patternInput[1]]))];\n}\n\nexport function update(msg, model) {\n    let a, a_1, a_2;\n    if (msg.tag === 1) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, msg.fields[0], model.DropdownActiveSubtopic, model.FormModel, model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 2) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, msg.fields[0], model.FormModel, model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 3) {\n        return [new Model_1(model.DropdownIsActive, msg.fields[0], model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 4) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, model.Captcha, msg.fields[0], model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 5) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, model.Captcha, model.CaptchaLoading, msg.fields[0]), Cmd_none()];\n    }\n    else if (msg.tag === 6) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, msg.fields[0], model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 7) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, msg.fields[0], model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 8) {\n        return [new Model_1(model.DropdownIsActive, true, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_OfAsyncWith_either((x) => {\n            Cmd_OfAsync_start(x);\n        }, api.submitIssue, [model.FormModel, value_20(model.Captcha)], () => (new Msg(9)), (a = Cmd_OfFunc_result(new Msg(3, false)), (b) => curry((tupledArg) => (new Msg(10, tupledArg[0], tupledArg[1])), a, b)))];\n    }\n    else if (msg.tag === 9) {\n        clearInputs();\n        window.scroll({ top: 0, left: 0, behavior: \"smooth\" });\n        document.getElementById(\"radio1Question\").focus();\n        const patternInput = init(void 0);\n        submitSuccessfullyAlert();\n        return [patternInput[0], patternInput[1]];\n    }\n    else if (msg.tag === 11) {\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, model.Captcha, true, model.CaptchaDoneWrong), Cmd_OfAsyncWith_either((x_1) => {\n            Cmd_OfAsync_start(x_1);\n        }, api.getCaptcha, void 0, (arg_1) => (new Msg(12, arg_1)), (a_1 = Cmd_OfFunc_result(new Msg(4, false)), (b_1) => curry((tupledArg_1) => (new Msg(10, tupledArg_1[0], tupledArg_1[1])), a_1, b_1)))];\n    }\n    else if (msg.tag === 12) {\n        document.getElementById(\"CaptchaInput\").value = \"\";\n        return [new Model_1(model.DropdownIsActive, model.LoadingModal, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, msg.fields[0], false, model.CaptchaDoneWrong), Cmd_none()];\n    }\n    else if (msg.tag === 13) {\n        return [new Model_1(model.DropdownIsActive, true, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, model.Captcha, model.CaptchaLoading, false), Cmd_OfAsyncWith_either((x_2) => {\n            Cmd_OfAsync_start(x_2);\n        }, api.checkCaptcha, value_20(model.Captcha), (arg0_4) => (new Msg(14, arg0_4)), (a_2 = Cmd_OfFunc_result(new Msg(3, false)), (b_2) => curry((tupledArg_2) => (new Msg(10, tupledArg_2[0], tupledArg_2[1])), a_2, b_2)))];\n    }\n    else if (msg.tag === 14) {\n        if (msg.fields[0].tag === 1) {\n            return [new Model_1(model.DropdownIsActive, false, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, msg.fields[0].fields[0], model.CaptchaLoading, true), Cmd_none()];\n        }\n        else {\n            return [new Model_1(model.DropdownIsActive, false, model.DropdownActiveTopic, model.DropdownActiveSubtopic, model.FormModel, msg.fields[0].fields[0], model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n        }\n    }\n    else if (msg.tag === 10) {\n        genericErrorAlert(msg.fields[1]);\n        return [model, msg.fields[0]];\n    }\n    else {\n        return [new Model_1(!model.DropdownIsActive, model.LoadingModal, void 0, void 0, model.FormModel, model.Captcha, model.CaptchaLoading, model.CaptchaDoneWrong), Cmd_none()];\n    }\n}\n\nexport function view(model, dispatch) {\n    let elems_4, elms, props_5, elems_3, props_3, properties_1, elems_2, props_1, elems_1;\n    const props_7 = ofArray([[\"className\", \"is-fullheight\"], [\"onClick\", (e) => {\n        if (model.DropdownIsActive) {\n            dispatch(new Msg(0));\n        }\n    }], (elems_4 = [loadingModal(model, dispatch), (elms = singleton(nfdiNavbar([], [])), createElement(\"div\", {\n        className: \"hero-head\",\n        children: Interop_reactApi.Children.toArray(Array.from(elms)),\n    })), (props_5 = ofArray([[\"className\", join(\" \", [\"decrease-padding\"])], (elems_3 = [(props_3 = ofArray([(properties_1 = singleton([\"maxWidth\", 100 + \"%\"]), [\"style\", createObj(properties_1)]), (elems_2 = [(props_1 = ofArray([[\"className\", \"is-8\"], [\"className\", \"is-offset-2\"], [\"className\", join(\" \", [\"decrease-padding\"])], (elems_1 = [mainElement(model, dispatch)], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_1))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"column\", props_1))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_2))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"container\", props_3))))], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_3))])]), createElement(\"div\", createObj(Helpers_combineClasses(\"hero-body\", props_5)))), nfdiFooter([], [])], [\"children\", Interop_reactApi.Children.toArray(Array.from(elems_4))])]);\n    return createElement(\"section\", createObj(Helpers_combineClasses(\"hero\", props_7)));\n}\n\n","import { ProgramModule_mkProgram, ProgramModule_run } from \"./fable_modules/Fable.Elmish.3.1.0/program.fs.js\";\nimport { Program_withReactBatched } from \"./fable_modules/Fable.Elmish.React.3.0.1/react.fs.js\";\nimport { ProgramModule_toNavigable } from \"./fable_modules/Fable.Elmish.Browser.3.0.4/navigation.fs.js\";\nimport { parsePath } from \"./fable_modules/Fable.Elmish.Browser.3.0.4/parser.fs.js\";\nimport { Routing_route } from \"./Routing.fs.js\";\nimport { view, update, init, urlUpdate as urlUpdate_1 } from \"./Index.fs.js\";\n\nProgramModule_run(Program_withReactBatched(\"elmish-app\", ProgramModule_toNavigable((location) => parsePath(Routing_route, location), urlUpdate_1, ProgramModule_mkProgram(init, update, view))));\n\n"],"names":["isArrayLike","x","Array","isArray","ArrayBuffer","isView","isHashable","GetHashCode","disposeSafe","Dispose","isDisposable","sameConstructor","y","Object","getPrototypeOf","constructor","Enumerator","iter","this","current","cur","next","value","done","Error","getEnumerator","o","GetEnumerator","Symbol","iterator","toIterator","en","hasNext","undefined","Lazy","factory","isValueCreated","createdValue","padWithZeros","i","length","str","toString","dateOffset","date","date1","offset","kind","getTimezoneOffset","int32ToString","radix","ObjectRef","idMap","has","set","count","get","stringHash","s","h","len","charCodeAt","numberHash","combineHashCodes","hashes","reduce","h1","h2","structuralHash","arrayHash","Date","getTime","dateHash","values","map","v","id","safeHash","equalArraysWith","eq","equalArrays","equals","Equals","isEquatable","compareDates","xKeys","keys","yKeys","sort","equalObjects","xtime","ytime","comparePrimitives","compareArrays","comp","j","compareArraysWith","compare","CompareTo","isComparable","key","compareObjects","max","comparer","createObj","fields","obj","kv","WeakMap","CURRIED","uncurry","arity","f","uncurried","res","_curry","args","arg","concat","curry","partialApply","callStack","self","seqToString","cons","entries","join","name","String","Union","cases","tag","fieldStr","withParens","indexOf","unionToString","splice","other","NumberStyles","Record","recordToJSON","recordToString","recordGetHashCode","thisNames","recordEquals","result","recordCompareTo","FSharpRef","contentsOrGetter","setter","getter","Exception","message","getRange","unsigned","bitsize","isValid","style","exec","replace","prefix","digits","AllowHexSpecifier","getRadix","invalidDigits","getInvalidDigits","test","regexMatch","sign","validResponse","parse","Number","parseInt","isNaN","umin","umax","min","tryParse","defValue","contents","_a","symbol","isNumeric","multiply","toFixed","dp","toPrecision","sd","toExponential","toHex","wasm","WebAssembly","Instance","Module","Uint8Array","exports","e","Long","low","high","isLong","prototype","toJSON","substr","bytes","le","fromBytesLE","fromBytesBE","fromBytes","$this","hi","lo","toBytesLE","toBytesBE","__isLong__","defineProperty","INT_CACHE","UINT_CACHE","fromInt","cachedObj","cache","fromBits","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","fromValue","val","TWO_PWR_16_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","toInt","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_Addition","LongLib","op_Subtraction","op_Multiply","op_Division","op_Modulus","rem_u","rem_s","op_UnaryNegation","op_BitwiseAnd","fromInteger","xh","_bitsize","maxValue","getMaxValue","toUpperCase","padStart","dateOffsetToString","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","dateWithOffset","d","dateToStringWithOffset","toUTCString","toLocaleString","toLocaleDateString","toLocaleTimeString","printOffset","dateToISOString","dateToStringWithKind","DateTime","parseRaw","input","fail","trim","m","baseDate","timeInSeconds","timeParts","split","parseFloat","offsetInMinutes","detectUTC","escape","fsFormatRegExp","formatRegExp","isLessThan","numericCompare","printf","cont","lastIndex","strParts","matches","strIdx","matchIndex","index","push","createPrinter","continuePrint","toText","toFail","formatReplacement","flags","padLength","precision","toLowerCase","dateToString","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","splitters","options","removeEmpty","filter","splits","reg","RegExp","findSplits","candidate","startIndex","SR_indexOutOfBounds","SR_inputWasEmpty","Some","some","Helpers_allocateArrayFromCons","indexNotFound","fill","target","targetIndex","start","last","array","mapIndexed","source","arrays","arrays_1","totalIdx","totalLength","idx_1","arr_2","initialize","initializer","take","tryFind","predicate","find","zip","array1","array2","differentLengths","equalsWith","length1","length2","head","FSharpList","tail","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","empty","singleton","isEmpty","toArray","fold","folder","state","acc","iterate","action","unitVar0","ofArrayWithTail","tail_1","ofArray","collect","mapping","root","node","ys","zs","xs_3","t_2","tryPick","item","n","FSharpList__get_Item_Z524259A4","CancellationToken","cancelled","_id","_cancelled","_listeners","Map","listener","$","addListener","removeListener","OperationCanceledError","setPrototypeOf","Trampoline","callCount","maxTrampolineCallCount","setTimeout","protectedCont","ctx","cancelToken","isCancelled","onCancel","trampoline","incrementAndCheck","hijack","err","onError","computation","binder","onSuccess","ex","protectedBind","computation1","computation2","Bind","generator","sequence","body","While","Delay","protectedReturn","compensation","catchHandler","ex2","resource","TryFinally","guard","Return","FSharpResult$2","FSharpChoice$2","emptyContinuation","_x","defaultCancellationToken","fromContinuations","startImmediate","cancellationToken","continuation","exceptionContinuation","cancellationContinuation","startWithContinuations","delegates","_addHandler","senderOrValue","valueOrUndefined","sender","forEach","handler","_removeHandler","callback","OnNext","interval","_enabled","_isDisposed","_intervalId","_timeoutId","Interval","AutoReset","_elapsed","Event","setInterval","Enabled","Trigger","clearTimeout","clearInterval","Observer","onNext","onCompleted","OnError","_e","OnCompleted","Cmd_exec","dispatch","cmd","call","Cmd_none","Cmd_map","g","arg_1","Cmd_batch","cmds","lists","enumerator","xs_6","Cmd_OfFunc_result","msg","Cmd_OfAsyncWith_either","task","ofSuccess","ofError","singleton_1","work","Choice_makeChoice1Of2","_arg1","r","Zero","Cmd_OfAsync_start","returnVal","Timer","Subscribe","Elapsed","Start","LanguagePrimitives_FastGenericComparer","Compare","x_1","SR_enumerationAlreadyFinished","SR_enumerationNotStarted","SR_keyNotFoundAlt","SR_notEnoughElements","Enumerator_notStarted","Enumerator_alreadyFinished","Enumerator_Seq","Enumerator_FromFunctions$1","dispose","Enumerator_noReset","Enumerator_FromFunctions$1_$ctor_58C54629","Enumerator_generateWhileSome","openf","compute","closef","started","curr","value_1","finish","matchValue_1","mkSeq","Enumerator_Seq_$ctor_673A07F2","ofSeq","argName","Operators_NullArg","delay","sources","outerOpt","innerOpt","finished","inner","outer","inner_1","outer_1","ie","Enumerator_concat","ar","toArray_1","toList","ofArray_1","xs_5","ofSeq_1","generate","create","append","choose","chooser","e_1","findIndex","tryFindIndex","iterateIndexed","length_1","skip","Enumerator_enumerateThenFinally","integralRangeStep","step","stop","zero","stepFn","stepComparedWithZero","stepGreaterThanZero","comparedWithLast","makeRangeStepFunction","st_1","Enumerator_unfold","RingState$1","RingBuffer$1","RingBuffer$1__Push_2B595","wix_1","rix","items_1","wix$0027","this$","ix","items","RingBuffer$1__doubleSize","wix","Program$4","init","update","subscribe","view","setState","syncDispatch","LazyProps$1","model","render","equal","Components_LazyView$1","props","nextProps","_nextState","Component","Navigable$1","ProgramModule_Internal_onChangeRef","ProgramModule_Internal_toNavigableWith","parser","urlUpdate","program","onLocationChange","tupledArg","arg0","mapInit","mapUpdate","mapView","mapSetState","mapSubscribe","userInit","unitVar1","window","location","userUpdate","model_1","userView","model_4","dispatch_1","userSetState","model_3","userSubscribe","model_2","arg0_1","ProgramModule_map","MapTreeLeaf$2","k","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","l","hl","hr","m_2","MapTreeModule_rebalance","t1","t2","m2_2","m_3","m2_3","t1h","t2h","matchValue_2","matchValue_3","MapTreeModule_add","MapTreeModule_empty","MapTreeModule_tryFind","comparer_mut","k_mut","MapTreeModule_iterOpt","f_mut","MapTreeModule_iter","MapTreeModule_copyToArray","arr","MapTreeModule_ofSeq","forLoopVar","MapTreeModule_ofArray","fold_1","MapTreeModule_ofList","e_mut","patternInput","MapTreeModule_mkFromEnumerator","MapTreeModule_MapIterator$2","stack","MapTreeModule_collapseLHS","stack_mut","isEmpty_1","empty_1","rest","MapTreeModule_mkIterator","MapTreeModule_current","MapTreeModule_alreadyFinished","MapTreeModule_notStarted","MapTreeModule_mkIEnumerator","MapTreeModule_moveNext","FSharpMap","tree","combineHash","activePatternResult8263","FSharpMap__ComputeHashCode","that","e1","e2","m1","e1c","e2c","map_1","toStringTag","b1","b2","compareWith","kvp1","kvp2","FSharpMap__ContainsKey","FSharpMap__get_Item","FSharpMap__get_Count","thisArg","iterate_1","FSharpMap_$ctor","FSharpMap_Create","MapTreeModule_find","MapTreeModule_mem","table","FSharpMap__TryFind","containsKey","ofList","elements","m_1_mut","MapTreeModule_toList","ofFunc","State$1","visited","unvisited","StateModule_mkState","toKeyValuePair","segment","a","b","pattern_matching_result","a_1","b_1","tuple","decodeURIComponent","parseParams","querystring","map_2","parsePath","url","states_mut","parseHelp","states","segments","segments_1","splitUrl","pathname","queryParser","parsers","subValue","parse_1","func","Route","Routing_route","arg10$0040","StateModule_map","state_2","oneOf","CaseInfo","declaringType","TypeInfo","fullname","generics","construct","parent","enumCases","fullName","getHashCode","getGenerics","fullnameHash","genHashes","getRecordElements","k1","v1","k2","v2","class_type","record_type","union_type","caseNames","tuple_type","lambda_type","argType","returnType","unit_type","string_type","bool_type","info","elemType","getElementType","getUnionCases","getFunctionElements","isFunction","gen","isTuple","startsWith","makeUnion","uci","expectedLength","makeRecord","IssueType","Topic","IssueGeneralTopic","IssueSubtopics_RDM","IssueSubtopics_Infrastructure","IssueSubtopics_Tools","IssueSubtopics_Workflows","IssueSubtopics_Metadata","IssueSubtopics_Documentation","IssueSubtopics_RDM__get_toString","IssueSubtopics_Infrastructure__get_toString","IssueSubtopics_Tools__get_toString","IssueSubtopics_Workflows__get_toString","IssueSubtopics_Metadata__get_toString","IssueSubtopics_Documentation__get_toString","Topic__get_toSubCategoryString","IssueGeneralTopic__get_toString","Topic__get_toCategoryString","Topic__get_toUrlString","rmWhitespace","Topic_ofUrlString_Z721C83C5","ind","subtopic","IssueGeneralTopic_ofString_Z721C83C5","IssueSubtopics_Infrastructure_ofString_Z721C83C5","IssueSubtopics_Tools_ofString_Z721C83C5","IssueSubtopics_Workflows_ofString_Z721C83C5","IssueSubtopics_Metadata_ofString_Z721C83C5","IssueSubtopics_Documentation_ofString_Z721C83C5","IssueSubtopics_RDM_ofString_Z721C83C5","IssueGeneralTopic__get_subcategories","Model","IssueTopic","IssueTitle","IssueContent","UserEmail","ClientCaptcha","Id","ImageBase64","UserInput","AccessToken","ClientCaptcha$reflection","HttpMethod","RequestBody","HttpRequest","Url","Headers","WithCredentials","HttpResponse","StatusCode","ResponseBody","RemoteBuilderOptions","CustomHeaders","BaseUrl","Authorization","RouteBuilder","CustomResponseSerialization","ProxyRequestException","response","errorMsg","reponseText","ProxyRequestException_$ctor_76BC5104","Parsimmon","seed","times","elem","isParser","isBuffer","Buffer","makeSuccess","status","furthest","expected","makeFailure","mergeReplies","hasOwnProperty","union","makeLineColumnIndex","line","column","lines","assertParser","charAt","assertNumber","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","data","byteLines","byteRow","byteValue","byteRangeToRange","byteLine","inputLines","lineWithErrorCurrentIndex","linesWithLineNumbers","lineSource","lineNumberLabel","isLineWithError","re","seq","arguments","numParsers","accum","seqMap","mapper","pop","apply","results","alt","sepBy1","separator","then","many","rs","regexp","group","assertRegexp","anchored","anchoredRegexp","fullMatch","groupMatch","succeed","lookahead","eof","formatError","type","or","alternative","wrap","leftParser","rightParser","middle","thru","wrapper","tieWith","assertArray","tie","prevResult","atMost","atLeast","fn","contramap","promap","mark","end","sepBy","notFollowedBy","text","desc","reply","fallback","ap","chain","of","digit","optWhitespace","cr","lf","newline","Parsimmon_many","Parsimmon_ofLazy","Parsimmon_digit","Parsimmon_seperateBy","content","others","Parsimmon_between","skipped","Parsimmon_map","Parsimmon_choose","ps","Parsimmon_satisfy","Parsimmon_str","Parsimmon_optionalWhitespace","Parsimmon_stringReturn","Parsimmon_seq2","Parsimmon_concat","strings","Parsimmon_seq3","anyCharSnippet","Json","Parsimmon_atLeast","Parsimmon_atLeastOneOrMany","jint","negJint","jfloat","jnumber","jbool","jnull","stringLiteral","Parsimmon_oneOf","otherParser","Parsimmon_orTry","c_1","withWhitespace","jvalue","comma","json$004080$002D1","Value","arg_2","jsonParser","P","cmp","_this","MAX_DP","NAME","INVALID","INVALID_DP","INVALID_RM","DIV_BY_ZERO","UNDEFINED","NUMERIC","nl","round","Big","DP","RM","rm","more","xc","xci","unshift","stringify","doExponential","isNonzero","isneg","yc","bl","bt","ri","bz","ai","al","rl","q","qc","qi","gt","gte","lt","lte","minus","sub","xlty","plus","xe","ye","reverse","mod","ygtx","one","prec","sqrt","NE","PE","strict","valueOf","_Big_","normalize","TypeError","Decimal","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_baseMask","BigNatModule_baseNi64","BigNatModule_baseMaski64","BigNatModule_divbase","BigNatModule_modbase","BigNatModule_createN","BigNatModule_normN","na_mut","na","findLeastBound","BigNatModule_boundInt","BigNatModule_boundInt64","BigNatModule_embed","r_1","BigNatModule_eval32","BigNatModule_one","BigNatModule_zero","BigNatModule_degree","BigNatModule_add","rbound","c_mut","p_mut","q_mut","r_mut","z","i_1","z_1","i_2","BigNatModule_addP","BigNatModule_isZero","BigNatModule_lt","pa_mut","qa_mut","pa","qa","check","BigNatModule_compare","BigNatModule_mulSchoolBookCarry","rak","BigNatModule_mulSchoolBookOneSmall","bp","q_1","BigNatModule_encoding","bigL","twoToBigL","bigK","bigN","BigNatModule_mkEncoding","BigNatModule_table","BigNatModule_mul","pSmall","qSmall","BigNatModule_mulSchoolBookBothSmall","ra","pai","qaj","BigNatModule_mulSchoolBookNeitherSmall","BigNatModule_mulSchoolBook","BigNatModule_scaleSubInPlace","patternInput_1","ad","f_1","zLo","zHi","BigNatModule_scaleAddInPlace","BigNatModule_removeFactor","degx","dega","pn","xa","aa","qai","BigNatModule_divmod","BigNatModule_copyN","BigNatModule_toFloat","evalFloat","BigNatModule_ofInt32","BigNatModule_ofInt64","BigNatModule_embed64","BigNatModule_toString","degn","digits_4","isLeading_mut","digits_mut","n_1_mut","_arg1_mut","isLeading","n_1","n_2","prior_1","nL","nH","prior_mut","ten2k_mut","prior","ten2k","route","BigNatModule_ofString","ten","build","BigNatModule_getSmall","BigInteger","signInt","BigInteger__get_SignInt","BigInteger__get_V","BigInteger_op_Equality_56F059C0","BigNatModule_hash","nn","BigInteger_op_LessThan_56F059C0","BigInteger_$ctor_Z2BE94A1","BigInteger_nat_Z67CCE57D","BigNatModule_isSmall","smallLim","smallPosTab","BigInteger_posn_Z67CCE57D","BigInteger_$ctor_Z524259A4","BigInteger_get_One","BigInteger_get_Zero","arg00","text_1","BigInteger_Parse_Z721C83C5","toDecimal","BigInteger__get_ToDouble","BigInteger__get_ToDecimal","InteropUtil_isBigInt","InteropUtil_isObjectLiteral","SimpleJson_tryParse","Parsimmon_parse","SimpleJson_parse","SimpleJson_toString","arg10_1","arg10_3","arg20","SimpleJson_toPlainObject","value_3","jsObject","enumerator_1","SimpleJson_stringify","JSON","jsonValue","toString_1","InteropUtil_isDateOffset","SimpleJson_parseNative$0027","activePatternResult6342","$007CNativeString$007C_$007C","activePatternResult6341","$007CNativeNumber$007C_$007C","activePatternResult6340","$007CNativeBool$007C_$007C","$007CNull$007C_$007C","activePatternResult6338","$007CNativeArray$007C_$007C","activePatternResult6337","$007CNativeObject$007C_$007C","object","value_5","toList_1","map_3","SimpleJson_parseNative","two","ok","Uri","uri","URL","isAbsoluteUri","original","baseUri","relativeUri","kindOrUri","tryCreateWithKind","tryCreateWithBase","tryCreateImpl","out","asUrl","href","protocol","host","hash","DateTimeOffset","checkOffsetInRange","offsetMatch","fromDayNumber","dayNumber","ticks","Long_op_Multiply","ms","Long_toNumber","Long_op_Division","guidRegex","guidRegexNoHyphen","guidRegexHex","hyphenateGuid","wsTrimAndLowered","chars","littleEndian","getBytesInt32","DataView","buffer","byteOffset","byteLength","setInt32","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","SetTreeModule_rebalance","t2_3","t_3","t2_4","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","t2_2","x2_1","pattern_matching_result_4","t1_4","x1_2","x2_2","SetTreeModule_copyToArray","SetTreeModule_ofSeq","SetTreeModule_ofArray","fold_2","SetTreeModule_ofList","SetTreeModule_mkFromEnumerator","FSharpSet","FSharpSet__ComputeHashCode","FSharpSet__get_Comparer","FSharpSet__get_Tree","FSharpSet__get_Count","FSharpSet_$ctor","set$","RecordField","FieldName","FieldType","PropertyInfo","UnionCase","CaseName","CaseTypes","Info","CaseRules","None","LowerFirst","SnakeCase","SnakeCaseAllCaps","KebabCase","dashify","keyValueList","caseRule","definedCaseRule","kvPair","assign","changeCase","tryGetValue","defaultValue","addToSet","addToDict","dict","getItemFromDict","Dictionary","pairs","hashMap","pair","Dictionary__Add_5BDDA1","Dictionary__Clear","Dictionary__TryFind_2B595","arrayIndex","Dictionary__get_Count","Dictionary__Remove_2B595","Dictionary__ContainsKey_2B595","Dictionary__get_Item_2B595","Dictionary__set_Item_5BDDA1","Dictionary__TryFindIndex_2B595","outArg","clear","HashSet","HashSet__Add_2B595","HashSet__Clear","HashSet__Contains_2B595","HashSet__get_Count","HashSet__Remove_2B595","HashSet__TryFindIndex_2B595","v_1","flattenFuncTypes","typeDef","$007CFuncType$007C_$007C","lazyToDelayed","_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","activePatternResult6012","primType","$007CPrimitiveType$007C_$007C","activePatternResult6011","types","createTypeInfo","activePatternResult6010","isRecord","field","$007CRecordType$007C_$007C","l_1","activePatternResult6009","isUnion","prop","$007CUnionType$007C_$007C","l_2","activePatternResult6008","isEnum","getEnumUnderlyingType","activePatternResult6007","$007CListType$007C_$007C","elemType_1","activePatternResult6006","$007CResizeArrayType$007C_$007C","elemType_2","activePatternResult6005","$007CHashSetType$007C_$007C","elemType_3","activePatternResult6004","$007CArrayType$007C_$007C","elemType_4","activePatternResult6003","getTupleElements","$007CTupleType$007C_$007C","types_1","activePatternResult6002","$007COptionType$007C_$007C","elemType_5","activePatternResult6001","$007CNullable$007C_$007C","elemType_6","activePatternResult6000","$007CSetType$007C_$007C","elemType_7","activePatternResult5999","genArgs","$007CMapType$007C_$007C","keyType","valueType","activePatternResult5998","$007CDictionaryType$007C_$007C","keyType_1","valueType_1","activePatternResult5997","$007CSeqType$007C_$007C","elemType_8","activePatternResult5996","$007CAsyncType$007C_$007C","elemType_9","activePatternResult5995","$007CPromiseType$007C_$007C","elemType_10","typeInfoCache","ti_1","isPrimitive","enumUnion","every","case$","Convert_insideBrowser","document","Convert_InternalMap","Convert_flattenMap","Convert_$007CNonArray$007C_$007C","Convert_$007CMapKey$007C_$007C","Convert_generateMap","json","Convert_$007CMapEmpty$007C_$007C","activePatternResult6451","activePatternResult6446","Convert_$007CMapOne$007C_$007C","activePatternResult6450","activePatternResult6448","Convert_$007CMapNode$007C_$007C","leftMap","rightMap","key_1","Convert_flatteFable3Map","Convert_flattenFable3Lists","linkedList","Convert_arrayLike","Convert_unionOfRecords","Convert_isRecord","found","exists","Convert_optional","Convert_isQuoted","Convert_betweenQuotes","Convert_removeQuotes","Convert_fromJsonAs","input_mut","typeInfo_mut","foundCase","foundCase_2","testExpr","values_8","typeInfo","toLocaleLowerCase","value_4","value_51","input_1","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","value_26","getlElemType","value_27","getElemType","value_28","getElemType_1","value_29","genericJson","value_30","value_31","value_32","value_33","value_34","value_35","value_36","value_37","value_38","value_39","value_40","value_41","value_42","getTypes","jsonValue_5","optionalTypeDelayed_5","fromCharCode","parse_2","underlyingType","originalType","name_2","outArg_1","tryParse_1","arg20_1","arg20_2","WorkerGlobalScope","parse_3","parse_4","parse_5","DateOffset","caseName","values_1","caseName_1","patternInput_2","unionType","activePatternResult6538","foundCase_3","tryFind_1","expectedCases","case$_1","arg20_4","foundCase_1","foundCase_4","arg30_1","arg20_5","pattern_matching_result_5","caseInfo","caseType","_arg2","case$_2","typeInfo_1","expectedCases_1","case$_3","arg20_7","foundDiscriminatorKey","tryFind_2","keyword","discriminatorValueJson","discriminatorValue","foundUnionCase","tryFind_3","case$_4","case$_5","arg10_12","arg10_13","arg10_11","unexpectedJson","expectedType","pattern_matching_result_6","caseIndex","fieldValues","foundCase_5","value_48","arg20_8","arg10_10","pattern_matching_result_7","value_49","value_50","caseName_4","getTypes_2","parse_6","pattern_matching_result_8","get$","_arg3","getInt32","patternInput_3","caseTypes","_arg4","case$_6","expectedCases_2","case$_7","arg20_11","pattern_matching_result_9","caseName_5","getTypes_3","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","pattern_matching_result_10","caseName_6","caseName_8","values_3","otherwise_6","patternInput_5","cases_1","_arg6","case$_10","expectedCases_4","case$_11","arg20_13","_arg7","case$_12","foundCaseName","caseInfo_4","tupledArg_1","expectedCases_5","_arg1_1","unexpectedJson_1","expectedType_1","elementType","value_55","elementType_1","value_57","elementType_2","value_59","elementType_3","value_61","elementType_4","value_63","tupledArg_2","patternInput_6","recordType","_arg3_1","fieldType","fieldName","_arg8","tupledArg_3","dictKeys","recordFields","arg10_27","arg10_30","_arg2_1","name_1","arg30_6","patternInput_7","keyValuePair","ofList_1","patternInput_8","pairs_1","keyValuePair_1","output","patternInput_9","keyType_2","pairs_2","tupledArg_4","output_1","forLoopVar_1","hashset","enumerator_2","pattern_matching_result_11","tree_1","patternInput_10","valueType_5","keyType_3","matchValue_6","inputJson","pairs_3","tupledArg_5","key_6","pattern_matching_result_12","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","copyOfStruct_1","copyOfStruct_2","copyOfStruct_3","copyOfStruct_4","ts","toString_2","toString_3","toString_4","Long_fromNumber","getRecordField","map_4","element","element_1","element_2","element_3","element_4","elementType_5","element_5","value_91","case_","getUnionFields","usedCase","serializedFields_1","serializedValues","serializedKey","serializedValue","toArray_2","serializedValues_1","serializedKey_1","serializedValue_1","tupleTypes","index_1","element_6","defaultRequestConfig","HttpMethod_1","post","withHeaders","headers","req","withCredentials","withCredentials_1","withBody","sendAndRead","preparation","resultMapper","token","request_1","xhr","XMLHttpRequest","open","register","abort","setRequestHeader","onreadystatechange","readyState","isCancellationRequested","send","ReturnFrom","Proxy_proxyFetch","typeName","funcArgs","binaryInput","argumentCount","returnTypeAsync","executeRequest","baseUrl","arg10","trimEnd","Proxy_combineRouteWithBaseUrl","funcNeedParameters","contentType","inputArgumentTypes","Proxy_isAsyncOfByteArray","onOk","serializer","typ_mut","typ","Proxy_getReturnType","requestBody","responseType","xhr_1","withCredentials_4","statusCode","response_1","blob","responseAsBlob","Blob","reader","FileReader","onload","readAsText","response_2","returnType_1","requestBody_1","responseText","response_3","parsedJson","arg1","arg2","arg3","arg4","arg5","arg6","arg7","inputArguments","IHelpdeskAPI","submitIssue","getCaptcha","checkCaptcha","DropdownIsActive","LoadingModal","DropdownActiveTopic","DropdownActiveSubtopic","FormModel","Captcha","CaptchaLoading","CaptchaDoneWrong","clo1","Msg","api","schemaType","fieldTypes","value_2","delegateArg0","delegateArg1","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_64DC51C","methodName","generic","Interop_reactApi","react","Bindings_swalInternal","sweetalert2","Bindings_swal","sweetalert2_react_content","Bindings_withReactContent","bodyComp","renderElement","withKey","opt","displayName","console","warn","props_2","Internal_propsWithKey","createElement","Internal_functionComponent_Z1B155329","className","children","Helpers_combineClasses","cn","classes","Helpers_extractClasses","loadingModal","props_6","elems_1","elems","color","zIndex","Children","nfdiFooter","Browser_Types_Event__Event_get_Value","mainElement","elms_4","elms","src","props_3","properties_2","value_85","textAlign","props_23","elems_8","elms_1","props_7","elems_2","children_1","props_12","properties_8","elems_4","elms_2","inputRecord","props_16","elems_5","children_4","props_20","elems_6","children_6","cursor","pointerEvents","preventDefault","stopPropagation","elms_3","props_28","elems_9","myCheckradio","issueType","htmlFor","issueTypeElement","justifyContent","display","except","itemsToExclude","hashSet","topicList","SwitchDropdownResponsivePX","ButtonDropdown_updateFormWithTopic","topic","nextModel","pathName","history","replaceState","ButtonDropdown_createDropdownItem","block","innerWidth","e_2","e_3","flexGrow","alignItems","marginLeft","properties","subcategories","isActive","properties_1","subCText","ButtonDropdown_subcategories","ButtonDropdown_findCurrentTopicIndex","itemList","ButtonDropdown_findNextTopicIndex","ButtonDropdown_findPreviousTopicIndec","ButtonDropdown_createDropdown","props_18","elems_7","uc","bc","inputRecord_1","which","list","item_1","pathName_1","list_1","properties_4","props_11","properties_3","marginRight","ButtonDropdown_backResponsiveDropdownItem","props_1","ButtonDropdown_createDropdownItemSubcategory","props_15","topic_1","issueTitleElement","props_5","ev","issueContentElement","userEmailElement","props_8","props_10","elems_3","props_14","header","margin","captchaANDsubmit","props_4","mainElement_1","topicStr","Model_1","initCaptcha","rb","reentered","nextMsg","msg_1","model$0027","ex_1","rix$0027","RingBuffer$1__Pop","ex_3","ex_2","ProgramModule_runWith","ProgramModule_run","clo1_1","clo1_2","lastLocation","addEventListener","arg10_2","ProgramModule_Internal_subscribe","ProgramModule_toNavigable","urlUpdate_1","ProgramModule_mkProgram","a_2","exn","inptuById","getElementById","scroll","top","behavior","focus","fire","submitSuccessfullyAlert","x_2","arg0_4","b_2","ProxyRequestException__get_ResponseText","anonRecord_type","icon","lazyView2With","placeholderId","lastRequest","ProgramModule_withSetState","cancelAnimationFrame","requestAnimationFrame","react_dom","ProgramModule_view","Program_Internal_withReactBatchedUsing","Common_lazyView2With"],"sourceRoot":""}