{"version":3,"file":"contract-OvRfXdTf.js","sources":["../../node_modules/ethers/lib.esm/utils/events.js","../../node_modules/ethers/lib.esm/utils/utf8.js","../../node_modules/ethers/lib.esm/abi/coders/abstract-coder.js","../../node_modules/ethers/node_modules/@noble/hashes/esm/_assert.js","../../node_modules/ethers/node_modules/@noble/hashes/esm/crypto.js","../../node_modules/ethers/node_modules/@noble/hashes/esm/utils.js","../../node_modules/ethers/node_modules/@noble/hashes/esm/_u64.js","../../node_modules/ethers/node_modules/@noble/hashes/esm/sha3.js","../../node_modules/ethers/lib.esm/crypto/keccak.js","../../node_modules/ethers/lib.esm/address/address.js","../../node_modules/ethers/lib.esm/address/checks.js","../../node_modules/ethers/lib.esm/abi/typed.js","../../node_modules/ethers/lib.esm/abi/coders/address.js","../../node_modules/ethers/lib.esm/abi/coders/anonymous.js","../../node_modules/ethers/lib.esm/abi/coders/array.js","../../node_modules/ethers/lib.esm/abi/coders/boolean.js","../../node_modules/ethers/lib.esm/abi/coders/bytes.js","../../node_modules/ethers/lib.esm/abi/coders/fixed-bytes.js","../../node_modules/ethers/lib.esm/abi/coders/null.js","../../node_modules/ethers/lib.esm/abi/coders/number.js","../../node_modules/ethers/lib.esm/abi/coders/string.js","../../node_modules/ethers/lib.esm/abi/coders/tuple.js","../../node_modules/ethers/lib.esm/hash/id.js","../../node_modules/ethers/lib.esm/transaction/accesslist.js","../../node_modules/ethers/lib.esm/abi/fragments.js","../../node_modules/ethers/lib.esm/abi/abi-coder.js","../../node_modules/ethers/lib.esm/abi/interface.js","../../node_modules/ethers/lib.esm/providers/provider.js","../../node_modules/ethers/lib.esm/contract/wrappers.js","../../node_modules/ethers/lib.esm/contract/contract.js"],"sourcesContent":["/**\n *  Events allow for applications to use the observer pattern, which\n *  allows subscribing and publishing events, outside the normal\n *  execution paths.\n *\n *  @_section api/utils/events:Events  [about-events]\n */\nimport { defineProperties } from \"./properties.js\";\n/**\n *  When an [[EventEmitterable]] triggers a [[Listener]], the\n *  callback always ahas one additional argument passed, which is\n *  an **EventPayload**.\n */\nexport class EventPayload {\n    /**\n     *  The event filter.\n     */\n    filter;\n    /**\n     *  The **EventEmitterable**.\n     */\n    emitter;\n    #listener;\n    /**\n     *  Create a new **EventPayload** for %%emitter%% with\n     *  the %%listener%% and for %%filter%%.\n     */\n    constructor(emitter, listener, filter) {\n        this.#listener = listener;\n        defineProperties(this, { emitter, filter });\n    }\n    /**\n     *  Unregister the triggered listener for future events.\n     */\n    async removeListener() {\n        if (this.#listener == null) {\n            return;\n        }\n        await this.emitter.off(this.filter, this.#listener);\n    }\n}\n//# sourceMappingURL=events.js.map","/**\n *  Using strings in Ethereum (or any security-basd system) requires\n *  additional care. These utilities attempt to mitigate some of the\n *  safety issues as well as provide the ability to recover and analyse\n *  strings.\n *\n *  @_subsection api/utils:Strings and UTF-8  [about-strings]\n */\nimport { getBytes } from \"./data.js\";\nimport { assertArgument, assertNormalize } from \"./errors.js\";\nfunction errorFunc(reason, offset, bytes, output, badCodepoint) {\n    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, \"bytes\", bytes);\n}\nfunction ignoreFunc(reason, offset, bytes, output, badCodepoint) {\n    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes\n    if (reason === \"BAD_PREFIX\" || reason === \"UNEXPECTED_CONTINUE\") {\n        let i = 0;\n        for (let o = offset + 1; o < bytes.length; o++) {\n            if (bytes[o] >> 6 !== 0x02) {\n                break;\n            }\n            i++;\n        }\n        return i;\n    }\n    // This byte runs us past the end of the string, so just jump to the end\n    // (but the first byte was read already read and therefore skipped)\n    if (reason === \"OVERRUN\") {\n        return bytes.length - offset - 1;\n    }\n    // Nothing to skip\n    return 0;\n}\nfunction replaceFunc(reason, offset, bytes, output, badCodepoint) {\n    // Overlong representations are otherwise \"valid\" code points; just non-deistingtished\n    if (reason === \"OVERLONG\") {\n        assertArgument(typeof (badCodepoint) === \"number\", \"invalid bad code point for replacement\", \"badCodepoint\", badCodepoint);\n        output.push(badCodepoint);\n        return 0;\n    }\n    // Put the replacement character into the output\n    output.push(0xfffd);\n    // Otherwise, process as if ignoring errors\n    return ignoreFunc(reason, offset, bytes, output, badCodepoint);\n}\n/**\n *  A handful of popular, built-in UTF-8 error handling strategies.\n *\n *  **``\"error\"``** - throws on ANY illegal UTF-8 sequence or\n *  non-canonical (overlong) codepoints (this is the default)\n *\n *  **``\"ignore\"``** - silently drops any illegal UTF-8 sequence\n *  and accepts non-canonical (overlong) codepoints\n *\n *  **``\"replace\"``** - replace any illegal UTF-8 sequence with the\n *  UTF-8 replacement character (i.e. ``\"\\\\ufffd\"``) and accepts\n *  non-canonical (overlong) codepoints\n *\n *  @returns: Record<\"error\" | \"ignore\" | \"replace\", Utf8ErrorFunc>\n */\nexport const Utf8ErrorFuncs = Object.freeze({\n    error: errorFunc,\n    ignore: ignoreFunc,\n    replace: replaceFunc\n});\n// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499\nfunction getUtf8CodePoints(_bytes, onError) {\n    if (onError == null) {\n        onError = Utf8ErrorFuncs.error;\n    }\n    const bytes = getBytes(_bytes, \"bytes\");\n    const result = [];\n    let i = 0;\n    // Invalid bytes are ignored\n    while (i < bytes.length) {\n        const c = bytes[i++];\n        // 0xxx xxxx\n        if (c >> 7 === 0) {\n            result.push(c);\n            continue;\n        }\n        // Multibyte; how many bytes left for this character?\n        let extraLength = null;\n        let overlongMask = null;\n        // 110x xxxx 10xx xxxx\n        if ((c & 0xe0) === 0xc0) {\n            extraLength = 1;\n            overlongMask = 0x7f;\n            // 1110 xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf0) === 0xe0) {\n            extraLength = 2;\n            overlongMask = 0x7ff;\n            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf8) === 0xf0) {\n            extraLength = 3;\n            overlongMask = 0xffff;\n        }\n        else {\n            if ((c & 0xc0) === 0x80) {\n                i += onError(\"UNEXPECTED_CONTINUE\", i - 1, bytes, result);\n            }\n            else {\n                i += onError(\"BAD_PREFIX\", i - 1, bytes, result);\n            }\n            continue;\n        }\n        // Do we have enough bytes in our data?\n        if (i - 1 + extraLength >= bytes.length) {\n            i += onError(\"OVERRUN\", i - 1, bytes, result);\n            continue;\n        }\n        // Remove the length prefix from the char\n        let res = c & ((1 << (8 - extraLength - 1)) - 1);\n        for (let j = 0; j < extraLength; j++) {\n            let nextChar = bytes[i];\n            // Invalid continuation byte\n            if ((nextChar & 0xc0) != 0x80) {\n                i += onError(\"MISSING_CONTINUE\", i, bytes, result);\n                res = null;\n                break;\n            }\n            ;\n            res = (res << 6) | (nextChar & 0x3f);\n            i++;\n        }\n        // See above loop for invalid continuation byte\n        if (res === null) {\n            continue;\n        }\n        // Maximum code point\n        if (res > 0x10ffff) {\n            i += onError(\"OUT_OF_RANGE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Reserved for UTF-16 surrogate halves\n        if (res >= 0xd800 && res <= 0xdfff) {\n            i += onError(\"UTF16_SURROGATE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Check for overlong sequences (more bytes than needed)\n        if (res <= overlongMask) {\n            i += onError(\"OVERLONG\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        result.push(res);\n    }\n    return result;\n}\n// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\n/**\n *  Returns the UTF-8 byte representation of %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8Bytes(str, form) {\n    assertArgument(typeof (str) === \"string\", \"invalid string value\", \"str\", str);\n    if (form != null) {\n        assertNormalize(form);\n        str = str.normalize(form);\n    }\n    let result = [];\n    for (let i = 0; i < str.length; i++) {\n        const c = str.charCodeAt(i);\n        if (c < 0x80) {\n            result.push(c);\n        }\n        else if (c < 0x800) {\n            result.push((c >> 6) | 0xc0);\n            result.push((c & 0x3f) | 0x80);\n        }\n        else if ((c & 0xfc00) == 0xd800) {\n            i++;\n            const c2 = str.charCodeAt(i);\n            assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), \"invalid surrogate pair\", \"str\", str);\n            // Surrogate Pair\n            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);\n            result.push((pair >> 18) | 0xf0);\n            result.push(((pair >> 12) & 0x3f) | 0x80);\n            result.push(((pair >> 6) & 0x3f) | 0x80);\n            result.push((pair & 0x3f) | 0x80);\n        }\n        else {\n            result.push((c >> 12) | 0xe0);\n            result.push(((c >> 6) & 0x3f) | 0x80);\n            result.push((c & 0x3f) | 0x80);\n        }\n    }\n    return new Uint8Array(result);\n}\n;\n//export \nfunction _toUtf8String(codePoints) {\n    return codePoints.map((codePoint) => {\n        if (codePoint <= 0xffff) {\n            return String.fromCharCode(codePoint);\n        }\n        codePoint -= 0x10000;\n        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));\n    }).join(\"\");\n}\n/**\n *  Returns the string represented by the UTF-8 data %%bytes%%.\n *\n *  When %%onError%% function is specified, it is called on UTF-8\n *  errors allowing recovery using the [[Utf8ErrorFunc]] API.\n *  (default: [error](Utf8ErrorFuncs))\n */\nexport function toUtf8String(bytes, onError) {\n    return _toUtf8String(getUtf8CodePoints(bytes, onError));\n}\n/**\n *  Returns the UTF-8 code-points for %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8CodePoints(str, form) {\n    return getUtf8CodePoints(toUtf8Bytes(str, form));\n}\n//# sourceMappingURL=utf8.js.map","import { defineProperties, concat, getBytesCopy, getNumber, hexlify, toBeArray, toBigInt, toNumber, assert, assertArgument } from \"../../utils/index.js\";\n/**\n * @_ignore:\n */\nexport const WordSize = 32;\nconst Padding = new Uint8Array(WordSize);\n// Properties used to immediate pass through to the underlying object\n// - `then` is used to detect if an object is a Promise for await\nconst passProperties = [\"then\"];\nconst _guard = {};\nfunction throwError(name, error) {\n    const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);\n    wrapped.error = error;\n    throw wrapped;\n}\n/**\n *  A [[Result]] is a sub-class of Array, which allows accessing any\n *  of its values either positionally by its index or, if keys are\n *  provided by its name.\n *\n *  @_docloc: api/abi\n */\nexport class Result extends Array {\n    #names;\n    /**\n     *  @private\n     */\n    constructor(...args) {\n        // To properly sub-class Array so the other built-in\n        // functions work, the constructor has to behave fairly\n        // well. So, in the event we are created via fromItems()\n        // we build the read-only Result object we want, but on\n        // any other input, we use the default constructor\n        // constructor(guard: any, items: Array<any>, keys?: Array<null | string>);\n        const guard = args[0];\n        let items = args[1];\n        let names = (args[2] || []).slice();\n        let wrap = true;\n        if (guard !== _guard) {\n            items = args;\n            names = [];\n            wrap = false;\n        }\n        // Can't just pass in ...items since an array of length 1\n        // is a special case in the super.\n        super(items.length);\n        items.forEach((item, index) => { this[index] = item; });\n        // Find all unique keys\n        const nameCounts = names.reduce((accum, name) => {\n            if (typeof (name) === \"string\") {\n                accum.set(name, (accum.get(name) || 0) + 1);\n            }\n            return accum;\n        }, (new Map()));\n        // Remove any key thats not unique\n        this.#names = Object.freeze(items.map((item, index) => {\n            const name = names[index];\n            if (name != null && nameCounts.get(name) === 1) {\n                return name;\n            }\n            return null;\n        }));\n        if (!wrap) {\n            return;\n        }\n        // A wrapped Result is immutable\n        Object.freeze(this);\n        // Proxy indices and names so we can trap deferred errors\n        return new Proxy(this, {\n            get: (target, prop, receiver) => {\n                if (typeof (prop) === \"string\") {\n                    // Index accessor\n                    if (prop.match(/^[0-9]+$/)) {\n                        const index = getNumber(prop, \"%index\");\n                        if (index < 0 || index >= this.length) {\n                            throw new RangeError(\"out of result range\");\n                        }\n                        const item = target[index];\n                        if (item instanceof Error) {\n                            throwError(`index ${index}`, item);\n                        }\n                        return item;\n                    }\n                    // Pass important checks (like `then` for Promise) through\n                    if (passProperties.indexOf(prop) >= 0) {\n                        return Reflect.get(target, prop, receiver);\n                    }\n                    const value = target[prop];\n                    if (value instanceof Function) {\n                        // Make sure functions work with private variables\n                        // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#no_private_property_forwarding\n                        return function (...args) {\n                            return value.apply((this === receiver) ? target : this, args);\n                        };\n                    }\n                    else if (!(prop in target)) {\n                        // Possible name accessor\n                        return target.getValue.apply((this === receiver) ? target : this, [prop]);\n                    }\n                }\n                return Reflect.get(target, prop, receiver);\n            }\n        });\n    }\n    /**\n     *  Returns the Result as a normal Array. If %%deep%%, any children\n     *  which are Result objects are also converted to a normal Array.\n     *\n     *  This will throw if there are any outstanding deferred\n     *  errors.\n     */\n    toArray(deep) {\n        const result = [];\n        this.forEach((item, index) => {\n            if (item instanceof Error) {\n                throwError(`index ${index}`, item);\n            }\n            if (deep && item instanceof Result) {\n                item = item.toArray(deep);\n            }\n            result.push(item);\n        });\n        return result;\n    }\n    /**\n     *  Returns the Result as an Object with each name-value pair. If\n     *  %%deep%%, any children which are Result objects are also\n     *  converted to an Object.\n     *\n     *  This will throw if any value is unnamed, or if there are\n     *  any outstanding deferred errors.\n     */\n    toObject(deep) {\n        return this.#names.reduce((accum, name, index) => {\n            assert(name != null, \"value at index ${ index } unnamed\", \"UNSUPPORTED_OPERATION\", {\n                operation: \"toObject()\"\n            });\n            // Add values for names that don't conflict\n            if (!(name in accum)) {\n                let child = this.getValue(name);\n                if (deep && child instanceof Result) {\n                    child = child.toObject(deep);\n                }\n                accum[name] = child;\n            }\n            return accum;\n        }, {});\n    }\n    /**\n     *  @_ignore\n     */\n    slice(start, end) {\n        if (start == null) {\n            start = 0;\n        }\n        if (start < 0) {\n            start += this.length;\n            if (start < 0) {\n                start = 0;\n            }\n        }\n        if (end == null) {\n            end = this.length;\n        }\n        if (end < 0) {\n            end += this.length;\n            if (end < 0) {\n                end = 0;\n            }\n        }\n        if (end > this.length) {\n            end = this.length;\n        }\n        const result = [], names = [];\n        for (let i = start; i < end; i++) {\n            result.push(this[i]);\n            names.push(this.#names[i]);\n        }\n        return new Result(_guard, result, names);\n    }\n    /**\n     *  @_ignore\n     */\n    filter(callback, thisArg) {\n        const result = [], names = [];\n        for (let i = 0; i < this.length; i++) {\n            const item = this[i];\n            if (item instanceof Error) {\n                throwError(`index ${i}`, item);\n            }\n            if (callback.call(thisArg, item, i, this)) {\n                result.push(item);\n                names.push(this.#names[i]);\n            }\n        }\n        return new Result(_guard, result, names);\n    }\n    /**\n     *  @_ignore\n     */\n    map(callback, thisArg) {\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            const item = this[i];\n            if (item instanceof Error) {\n                throwError(`index ${i}`, item);\n            }\n            result.push(callback.call(thisArg, item, i, this));\n        }\n        return result;\n    }\n    /**\n     *  Returns the value for %%name%%.\n     *\n     *  Since it is possible to have a key whose name conflicts with\n     *  a method on a [[Result]] or its superclass Array, or any\n     *  JavaScript keyword, this ensures all named values are still\n     *  accessible by name.\n     */\n    getValue(name) {\n        const index = this.#names.indexOf(name);\n        if (index === -1) {\n            return undefined;\n        }\n        const value = this[index];\n        if (value instanceof Error) {\n            throwError(`property ${JSON.stringify(name)}`, value.error);\n        }\n        return value;\n    }\n    /**\n     *  Creates a new [[Result]] for %%items%% with each entry\n     *  also accessible by its corresponding name in %%keys%%.\n     */\n    static fromItems(items, keys) {\n        return new Result(_guard, items, keys);\n    }\n}\n/**\n *  Returns all errors found in a [[Result]].\n *\n *  Since certain errors encountered when creating a [[Result]] do\n *  not impact the ability to continue parsing data, they are\n *  deferred until they are actually accessed. Hence a faulty string\n *  in an Event that is never used does not impact the program flow.\n *\n *  However, sometimes it may be useful to access, identify or\n *  validate correctness of a [[Result]].\n *\n *  @_docloc api/abi\n */\nexport function checkResultErrors(result) {\n    // Find the first error (if any)\n    const errors = [];\n    const checkErrors = function (path, object) {\n        if (!Array.isArray(object)) {\n            return;\n        }\n        for (let key in object) {\n            const childPath = path.slice();\n            childPath.push(key);\n            try {\n                checkErrors(childPath, object[key]);\n            }\n            catch (error) {\n                errors.push({ path: childPath, error: error });\n            }\n        }\n    };\n    checkErrors([], result);\n    return errors;\n}\nfunction getValue(value) {\n    let bytes = toBeArray(value);\n    assert(bytes.length <= WordSize, \"value out-of-bounds\", \"BUFFER_OVERRUN\", { buffer: bytes, length: WordSize, offset: bytes.length });\n    if (bytes.length !== WordSize) {\n        bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));\n    }\n    return bytes;\n}\n/**\n *  @_ignore\n */\nexport class Coder {\n    // The coder name:\n    //   - address, uint256, tuple, array, etc.\n    name;\n    // The fully expanded type, including composite types:\n    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.\n    type;\n    // The localName bound in the signature, in this example it is \"baz\":\n    //   - tuple(address foo, uint bar) baz\n    localName;\n    // Whether this type is dynamic:\n    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.\n    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)\n    dynamic;\n    constructor(name, type, localName, dynamic) {\n        defineProperties(this, { name, type, localName, dynamic }, {\n            name: \"string\", type: \"string\", localName: \"string\", dynamic: \"boolean\"\n        });\n    }\n    _throwError(message, value) {\n        assertArgument(false, message, this.localName, value);\n    }\n}\n/**\n *  @_ignore\n */\nexport class Writer {\n    // An array of WordSize lengthed objects to concatenation\n    #data;\n    #dataLength;\n    constructor() {\n        this.#data = [];\n        this.#dataLength = 0;\n    }\n    get data() {\n        return concat(this.#data);\n    }\n    get length() { return this.#dataLength; }\n    #writeData(data) {\n        this.#data.push(data);\n        this.#dataLength += data.length;\n        return data.length;\n    }\n    appendWriter(writer) {\n        return this.#writeData(getBytesCopy(writer.data));\n    }\n    // Arrayish item; pad on the right to *nearest* WordSize\n    writeBytes(value) {\n        let bytes = getBytesCopy(value);\n        const paddingOffset = bytes.length % WordSize;\n        if (paddingOffset) {\n            bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));\n        }\n        return this.#writeData(bytes);\n    }\n    // Numeric item; pad on the left *to* WordSize\n    writeValue(value) {\n        return this.#writeData(getValue(value));\n    }\n    // Inserts a numeric place-holder, returning a callback that can\n    // be used to asjust the value later\n    writeUpdatableValue() {\n        const offset = this.#data.length;\n        this.#data.push(Padding);\n        this.#dataLength += WordSize;\n        return (value) => {\n            this.#data[offset] = getValue(value);\n        };\n    }\n}\n/**\n *  @_ignore\n */\nexport class Reader {\n    // Allows incomplete unpadded data to be read; otherwise an error\n    // is raised if attempting to overrun the buffer. This is required\n    // to deal with an old Solidity bug, in which event data for\n    // external (not public thoguh) was tightly packed.\n    allowLoose;\n    #data;\n    #offset;\n    #bytesRead;\n    #parent;\n    #maxInflation;\n    constructor(data, allowLoose, maxInflation) {\n        defineProperties(this, { allowLoose: !!allowLoose });\n        this.#data = getBytesCopy(data);\n        this.#bytesRead = 0;\n        this.#parent = null;\n        this.#maxInflation = (maxInflation != null) ? maxInflation : 1024;\n        this.#offset = 0;\n    }\n    get data() { return hexlify(this.#data); }\n    get dataLength() { return this.#data.length; }\n    get consumed() { return this.#offset; }\n    get bytes() { return new Uint8Array(this.#data); }\n    #incrementBytesRead(count) {\n        if (this.#parent) {\n            return this.#parent.#incrementBytesRead(count);\n        }\n        this.#bytesRead += count;\n        // Check for excessive inflation (see: #4537)\n        assert(this.#maxInflation < 1 || this.#bytesRead <= this.#maxInflation * this.dataLength, `compressed ABI data exceeds inflation ratio of ${this.#maxInflation} ( see: https:/\\/github.com/ethers-io/ethers.js/issues/4537 )`, \"BUFFER_OVERRUN\", {\n            buffer: getBytesCopy(this.#data), offset: this.#offset,\n            length: count, info: {\n                bytesRead: this.#bytesRead,\n                dataLength: this.dataLength\n            }\n        });\n    }\n    #peekBytes(offset, length, loose) {\n        let alignedLength = Math.ceil(length / WordSize) * WordSize;\n        if (this.#offset + alignedLength > this.#data.length) {\n            if (this.allowLoose && loose && this.#offset + length <= this.#data.length) {\n                alignedLength = length;\n            }\n            else {\n                assert(false, \"data out-of-bounds\", \"BUFFER_OVERRUN\", {\n                    buffer: getBytesCopy(this.#data),\n                    length: this.#data.length,\n                    offset: this.#offset + alignedLength\n                });\n            }\n        }\n        return this.#data.slice(this.#offset, this.#offset + alignedLength);\n    }\n    // Create a sub-reader with the same underlying data, but offset\n    subReader(offset) {\n        const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);\n        reader.#parent = this;\n        return reader;\n    }\n    // Read bytes\n    readBytes(length, loose) {\n        let bytes = this.#peekBytes(0, length, !!loose);\n        this.#incrementBytesRead(length);\n        this.#offset += bytes.length;\n        // @TODO: Make sure the length..end bytes are all 0?\n        return bytes.slice(0, length);\n    }\n    // Read a numeric values\n    readValue() {\n        return toBigInt(this.readBytes(WordSize));\n    }\n    readIndex() {\n        return toNumber(this.readBytes(WordSize));\n    }\n}\n//# sourceMappingURL=abstract-coder.js.map","function number(n) {\n    if (!Number.isSafeInteger(n) || n < 0)\n        throw new Error(`Wrong positive integer: ${n}`);\n}\nfunction bool(b) {\n    if (typeof b !== 'boolean')\n        throw new Error(`Expected boolean, not ${b}`);\n}\nfunction bytes(b, ...lengths) {\n    if (!(b instanceof Uint8Array))\n        throw new Error('Expected Uint8Array');\n    if (lengths.length > 0 && !lengths.includes(b.length))\n        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);\n}\nfunction hash(hash) {\n    if (typeof hash !== 'function' || typeof hash.create !== 'function')\n        throw new Error('Hash should be wrapped by utils.wrapConstructor');\n    number(hash.outputLen);\n    number(hash.blockLen);\n}\nfunction exists(instance, checkFinished = true) {\n    if (instance.destroyed)\n        throw new Error('Hash instance has been destroyed');\n    if (checkFinished && instance.finished)\n        throw new Error('Hash#digest() has already been called');\n}\nfunction output(out, instance) {\n    bytes(out);\n    const min = instance.outputLen;\n    if (out.length < min) {\n        throw new Error(`digestInto() expects output buffer of length at least ${min}`);\n    }\n}\nexport { number, bool, bytes, hash, exists, output };\nconst assert = { number, bool, bytes, hash, exists, output };\nexport default assert;\n//# sourceMappingURL=_assert.js.map","export const crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n//# sourceMappingURL=crypto.js.map","/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated, we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nconst u8a = (a) => a instanceof Uint8Array;\n// Cast array to different type\nexport const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\nexport const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n// Cast array to view\nexport const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n// The rotate right (circular right shift) operation for uint32\nexport const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);\n// big-endian hardware is rare. Just in case someone still decides to run hashes:\n// early-throw an error because we don't support BE yet.\nexport const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;\nif (!isLE)\n    throw new Error('Non little-endian hardware is not supported');\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes) {\n    if (!u8a(bytes))\n        throw new Error('Uint8Array expected');\n    // pre-caching improves the speed 6x\n    let hex = '';\n    for (let i = 0; i < bytes.length; i++) {\n        hex += hexes[bytes[i]];\n    }\n    return hex;\n}\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex) {\n    if (typeof hex !== 'string')\n        throw new Error('hex string expected, got ' + typeof hex);\n    const len = hex.length;\n    if (len % 2)\n        throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n    const array = new Uint8Array(len / 2);\n    for (let i = 0; i < array.length; i++) {\n        const j = i * 2;\n        const hexByte = hex.slice(j, j + 2);\n        const byte = Number.parseInt(hexByte, 16);\n        if (Number.isNaN(byte) || byte < 0)\n            throw new Error('Invalid byte sequence');\n        array[i] = byte;\n    }\n    return array;\n}\n// There is no setImmediate in browser and setTimeout is slow.\n// call of async fn will return Promise, which will be fullfiled only on\n// next scheduler queue processing step and this is exactly what we need.\nexport const nextTick = async () => { };\n// Returns control to thread each 'tick' ms to avoid blocking\nexport async function asyncLoop(iters, tick, cb) {\n    let ts = Date.now();\n    for (let i = 0; i < iters; i++) {\n        cb(i);\n        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n        const diff = Date.now() - ts;\n        if (diff >= 0 && diff < tick)\n            continue;\n        await nextTick();\n        ts += diff;\n    }\n}\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str) {\n    if (typeof str !== 'string')\n        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data) {\n    if (typeof data === 'string')\n        data = utf8ToBytes(data);\n    if (!u8a(data))\n        throw new Error(`expected Uint8Array, got ${typeof data}`);\n    return data;\n}\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays) {\n    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n    let pad = 0; // walk through each item, ensure they have proper type\n    arrays.forEach((a) => {\n        if (!u8a(a))\n            throw new Error('Uint8Array expected');\n        r.set(a, pad);\n        pad += a.length;\n    });\n    return r;\n}\n// For runtime check if class implements interface\nexport class Hash {\n    // Safe version that clones internal state\n    clone() {\n        return this._cloneInto();\n    }\n}\nconst toStr = {}.toString;\nexport function checkOpts(defaults, opts) {\n    if (opts !== undefined && toStr.call(opts) !== '[object Object]')\n        throw new Error('Options should be object or undefined');\n    const merged = Object.assign(defaults, opts);\n    return merged;\n}\nexport function wrapConstructor(hashCons) {\n    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n    const tmp = hashCons();\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = () => hashCons();\n    return hashC;\n}\nexport function wrapConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\nexport function wrapXOFConstructorWithOpts(hashCons) {\n    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();\n    const tmp = hashCons({});\n    hashC.outputLen = tmp.outputLen;\n    hashC.blockLen = tmp.blockLen;\n    hashC.create = (opts) => hashCons(opts);\n    return hashC;\n}\n/**\n * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.\n */\nexport function randomBytes(bytesLength = 32) {\n    if (crypto && typeof crypto.getRandomValues === 'function') {\n        return crypto.getRandomValues(new Uint8Array(bytesLength));\n    }\n    throw new Error('crypto.getRandomValues must be defined');\n}\n//# sourceMappingURL=utils.js.map","const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nfunction fromBig(n, le = false) {\n    if (le)\n        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\nfunction split(lst, le = false) {\n    let Ah = new Uint32Array(lst.length);\n    let Al = new Uint32Array(lst.length);\n    for (let i = 0; i < lst.length; i++) {\n        const { h, l } = fromBig(lst[i], le);\n        [Ah[i], Al[i]] = [h, l];\n    }\n    return [Ah, Al];\n}\nconst toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h, _l, s) => h >>> s;\nconst shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h, l) => l;\nconst rotr32L = (h, _l) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah, Al, Bh, Bl) {\n    const l = (Al >>> 0) + (Bl >>> 0);\n    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n// prettier-ignore\nexport { fromBig, split, toBig, shrSH, shrSL, rotrSH, rotrSL, rotrBH, rotrBL, rotr32H, rotr32L, rotlSH, rotlSL, rotlBH, rotlBL, add, add3L, add3H, add4L, add4H, add5H, add5L, };\n// prettier-ignore\nconst u64 = {\n    fromBig, split, toBig,\n    shrSH, shrSL,\n    rotrSH, rotrSL, rotrBH, rotrBL,\n    rotr32H, rotr32L,\n    rotlSH, rotlSL, rotlBH, rotlBL,\n    add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n//# sourceMappingURL=_u64.js.map","import { bytes, exists, number, output } from './_assert.js';\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';\nimport { Hash, u32, toBytes, wrapConstructor, wrapXOFConstructorWithOpts, } from './utils.js';\n// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.\n// It's called a sponge function.\n// Various per round constants calculations\nconst [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nconst _7n = /* @__PURE__ */ BigInt(7);\nconst _256n = /* @__PURE__ */ BigInt(256);\nconst _0x71n = /* @__PURE__ */ BigInt(0x71);\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n// Same as keccakf1600, but allows to skip some rounds\nexport function keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    B.fill(0);\n}\nexport class Keccak extends Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        // Can be passed from user as dkLen\n        number(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        if (0 >= this.blockLen || this.blockLen >= 200)\n            throw new Error('Sha3 supports only keccak-f1600 function');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    keccak() {\n        keccakP(this.state32, this.rounds);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        exists(this);\n        const { blockLen, state } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        exists(this, false);\n        bytes(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        number(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        output(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        this.state.fill(0);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nconst gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));\nexport const sha3_224 = /* @__PURE__ */ gen(0x06, 144, 224 / 8);\n/**\n * SHA3-256 hash function\n * @param message - that would be hashed\n */\nexport const sha3_256 = /* @__PURE__ */ gen(0x06, 136, 256 / 8);\nexport const sha3_384 = /* @__PURE__ */ gen(0x06, 104, 384 / 8);\nexport const sha3_512 = /* @__PURE__ */ gen(0x06, 72, 512 / 8);\nexport const keccak_224 = /* @__PURE__ */ gen(0x01, 144, 224 / 8);\n/**\n * keccak-256 hash function. Different from SHA3-256.\n * @param message - that would be hashed\n */\nexport const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);\nexport const keccak_384 = /* @__PURE__ */ gen(0x01, 104, 384 / 8);\nexport const keccak_512 = /* @__PURE__ */ gen(0x01, 72, 512 / 8);\nconst genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\nexport const shake128 = /* @__PURE__ */ genShake(0x1f, 168, 128 / 8);\nexport const shake256 = /* @__PURE__ */ genShake(0x1f, 136, 256 / 8);\n//# sourceMappingURL=sha3.js.map","/**\n *  Cryptographic hashing functions\n *\n *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]\n */\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { getBytes, hexlify } from \"../utils/index.js\";\nlet locked = false;\nconst _keccak256 = function (data) {\n    return keccak_256(data);\n};\nlet __keccak256 = _keccak256;\n/**\n *  Compute the cryptographic KECCAK256 hash of %%data%%.\n *\n *  The %%data%% **must** be a data representation, to compute the\n *  hash of UTF-8 data use the [[id]] function.\n *\n *  @returns DataHexstring\n *  @example:\n *    keccak256(\"0x\")\n *    //_result:\n *\n *    keccak256(\"0x1337\")\n *    //_result:\n *\n *    keccak256(new Uint8Array([ 0x13, 0x37 ]))\n *    //_result:\n *\n *    // Strings are assumed to be DataHexString, otherwise it will\n *    // throw. To hash UTF-8 data, see the note above.\n *    keccak256(\"Hello World\")\n *    //_error:\n */\nexport function keccak256(_data) {\n    const data = getBytes(_data, \"data\");\n    return hexlify(__keccak256(data));\n}\nkeccak256._ = _keccak256;\nkeccak256.lock = function () { locked = true; };\nkeccak256.register = function (func) {\n    if (locked) {\n        throw new TypeError(\"keccak256 is locked\");\n    }\n    __keccak256 = func;\n};\nObject.freeze(keccak256);\n//# sourceMappingURL=keccak.js.map","import { keccak256 } from \"../crypto/index.js\";\nimport { getBytes, assertArgument } from \"../utils/index.js\";\nconst BN_0 = BigInt(0);\nconst BN_36 = BigInt(36);\nfunction getChecksumAddress(address) {\n    //    if (!isHexString(address, 20)) {\n    //        logger.throwArgumentError(\"invalid address\", \"address\", address);\n    //    }\n    address = address.toLowerCase();\n    const chars = address.substring(2).split(\"\");\n    const expanded = new Uint8Array(40);\n    for (let i = 0; i < 40; i++) {\n        expanded[i] = chars[i].charCodeAt(0);\n    }\n    const hashed = getBytes(keccak256(expanded));\n    for (let i = 0; i < 40; i += 2) {\n        if ((hashed[i >> 1] >> 4) >= 8) {\n            chars[i] = chars[i].toUpperCase();\n        }\n        if ((hashed[i >> 1] & 0x0f) >= 8) {\n            chars[i + 1] = chars[i + 1].toUpperCase();\n        }\n    }\n    return \"0x\" + chars.join(\"\");\n}\n// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number\n// Create lookup table\nconst ibanLookup = {};\nfor (let i = 0; i < 10; i++) {\n    ibanLookup[String(i)] = String(i);\n}\nfor (let i = 0; i < 26; i++) {\n    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);\n}\n// How many decimal digits can we process? (for 64-bit float, this is 15)\n// i.e. Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));\nconst safeDigits = 15;\nfunction ibanChecksum(address) {\n    address = address.toUpperCase();\n    address = address.substring(4) + address.substring(0, 2) + \"00\";\n    let expanded = address.split(\"\").map((c) => { return ibanLookup[c]; }).join(\"\");\n    // Javascript can handle integers safely up to 15 (decimal) digits\n    while (expanded.length >= safeDigits) {\n        let block = expanded.substring(0, safeDigits);\n        expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);\n    }\n    let checksum = String(98 - (parseInt(expanded, 10) % 97));\n    while (checksum.length < 2) {\n        checksum = \"0\" + checksum;\n    }\n    return checksum;\n}\n;\nconst Base36 = (function () {\n    ;\n    const result = {};\n    for (let i = 0; i < 36; i++) {\n        const key = \"0123456789abcdefghijklmnopqrstuvwxyz\"[i];\n        result[key] = BigInt(i);\n    }\n    return result;\n})();\nfunction fromBase36(value) {\n    value = value.toLowerCase();\n    let result = BN_0;\n    for (let i = 0; i < value.length; i++) {\n        result = result * BN_36 + Base36[value[i]];\n    }\n    return result;\n}\n/**\n *  Returns a normalized and checksumed address for %%address%%.\n *  This accepts non-checksum addresses, checksum addresses and\n *  [[getIcapAddress]] formats.\n *\n *  The checksum in Ethereum uses the capitalization (upper-case\n *  vs lower-case) of the characters within an address to encode\n *  its checksum, which offers, on average, a checksum of 15-bits.\n *\n *  If %%address%% contains both upper-case and lower-case, it is\n *  assumed to already be a checksum address and its checksum is\n *  validated, and if the address fails its expected checksum an\n *  error is thrown.\n *\n *  If you wish the checksum of %%address%% to be ignore, it should\n *  be converted to lower-case (i.e. ``.toLowercase()``) before\n *  being passed in. This should be a very rare situation though,\n *  that you wish to bypass the safegaurds in place to protect\n *  against an address that has been incorrectly copied from another\n *  source.\n *\n *  @example:\n *    // Adds the checksum (via upper-casing specific letters)\n *    getAddress(\"0x8ba1f109551bd432803012645ac136ddd64dba72\")\n *    //_result:\n *\n *    // Converts ICAP address and adds checksum\n *    getAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\");\n *    //_result:\n *\n *    // Throws an error if an address contains mixed case,\n *    // but the checksum fails\n *    getAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_error:\n */\nexport function getAddress(address) {\n    assertArgument(typeof (address) === \"string\", \"invalid address\", \"address\", address);\n    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {\n        // Missing the 0x prefix\n        if (!address.startsWith(\"0x\")) {\n            address = \"0x\" + address;\n        }\n        const result = getChecksumAddress(address);\n        // It is a checksummed address with a bad checksum\n        assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, \"bad address checksum\", \"address\", address);\n        return result;\n    }\n    // Maybe ICAP? (we only support direct mode)\n    if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {\n        // It is an ICAP address with a bad checksum\n        assertArgument(address.substring(2, 4) === ibanChecksum(address), \"bad icap checksum\", \"address\", address);\n        let result = fromBase36(address.substring(4)).toString(16);\n        while (result.length < 40) {\n            result = \"0\" + result;\n        }\n        return getChecksumAddress(\"0x\" + result);\n    }\n    assertArgument(false, \"invalid address\", \"address\", address);\n}\n/**\n *  The [ICAP Address format](link-icap) format is an early checksum\n *  format which attempts to be compatible with the banking\n *  industry [IBAN format](link-wiki-iban) for bank accounts.\n *\n *  It is no longer common or a recommended format.\n *\n *  @example:\n *    getIcapAddress(\"0x8ba1f109551bd432803012645ac136ddd64dba72\");\n *    //_result:\n *\n *    getIcapAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\");\n *    //_result:\n *\n *    // Throws an error if the ICAP checksum is wrong\n *    getIcapAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37\");\n *    //_error:\n */\nexport function getIcapAddress(address) {\n    //let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase();\n    let base36 = BigInt(getAddress(address)).toString(36).toUpperCase();\n    while (base36.length < 30) {\n        base36 = \"0\" + base36;\n    }\n    return \"XE\" + ibanChecksum(\"XE00\" + base36) + base36;\n}\n//# sourceMappingURL=address.js.map","import { assert, assertArgument } from \"../utils/index.js\";\nimport { getAddress } from \"./address.js\";\n/**\n *  Returns true if %%value%% is an object which implements the\n *  [[Addressable]] interface.\n *\n *  @example:\n *    // Wallets and AbstractSigner sub-classes\n *    isAddressable(Wallet.createRandom())\n *    //_result:\n *\n *    // Contracts\n *    contract = new Contract(\"dai.tokens.ethers.eth\", [ ], provider)\n *    isAddressable(contract)\n *    //_result:\n */\nexport function isAddressable(value) {\n    return (value && typeof (value.getAddress) === \"function\");\n}\n/**\n *  Returns true if %%value%% is a valid address.\n *\n *  @example:\n *    // Valid address\n *    isAddress(\"0x8ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_result:\n *\n *    // Valid ICAP address\n *    isAddress(\"XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36\")\n *    //_result:\n *\n *    // Invalid checksum\n *    isAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBa72\")\n *    //_result:\n *\n *    // Invalid ICAP checksum\n *    isAddress(\"0x8Ba1f109551bD432803012645Ac136ddd64DBA72\")\n *    //_result:\n *\n *    // Not an address (an ENS name requires a provided and an\n *    // asynchronous API to access)\n *    isAddress(\"ricmoo.eth\")\n *    //_result:\n */\nexport function isAddress(value) {\n    try {\n        getAddress(value);\n        return true;\n    }\n    catch (error) { }\n    return false;\n}\nasync function checkAddress(target, promise) {\n    const result = await promise;\n    if (result == null || result === \"0x0000000000000000000000000000000000000000\") {\n        assert(typeof (target) !== \"string\", \"unconfigured name\", \"UNCONFIGURED_NAME\", { value: target });\n        assertArgument(false, \"invalid AddressLike value; did not resolve to a value address\", \"target\", target);\n    }\n    return getAddress(result);\n}\n/**\n *  Resolves to an address for the %%target%%, which may be any\n *  supported address type, an [[Addressable]] or a Promise which\n *  resolves to an address.\n *\n *  If an ENS name is provided, but that name has not been correctly\n *  configured a [[UnconfiguredNameError]] is thrown.\n *\n *  @example:\n *    addr = \"0x6B175474E89094C44Da98b954EedeAC495271d0F\"\n *\n *    // Addresses are return synchronously\n *    resolveAddress(addr, provider)\n *    //_result:\n *\n *    // Address promises are resolved asynchronously\n *    resolveAddress(Promise.resolve(addr))\n *    //_result:\n *\n *    // ENS names are resolved asynchronously\n *    resolveAddress(\"dai.tokens.ethers.eth\", provider)\n *    //_result:\n *\n *    // Addressable objects are resolved asynchronously\n *    contract = new Contract(addr, [ ])\n *    resolveAddress(contract, provider)\n *    //_result:\n *\n *    // Unconfigured ENS names reject\n *    resolveAddress(\"nothing-here.ricmoo.eth\", provider)\n *    //_error:\n *\n *    // ENS names require a NameResolver object passed in\n *    // (notice the provider was omitted)\n *    resolveAddress(\"nothing-here.ricmoo.eth\")\n *    //_error:\n */\nexport function resolveAddress(target, resolver) {\n    if (typeof (target) === \"string\") {\n        if (target.match(/^0x[0-9a-f]{40}$/i)) {\n            return getAddress(target);\n        }\n        assert(resolver != null, \"ENS resolution requires a provider\", \"UNSUPPORTED_OPERATION\", { operation: \"resolveName\" });\n        return checkAddress(target, resolver.resolveName(target));\n    }\n    else if (isAddressable(target)) {\n        return checkAddress(target, target.getAddress());\n    }\n    else if (target && typeof (target.then) === \"function\") {\n        return checkAddress(target, target);\n    }\n    assertArgument(false, \"unsupported addressable value\", \"target\", target);\n}\n//# sourceMappingURL=checks.js.map","/**\n *  A Typed object allows a value to have its type explicitly\n *  specified.\n *\n *  For example, in Solidity, the value ``45`` could represent a\n *  ``uint8`` or a ``uint256``. The value ``0x1234`` could represent\n *  a ``bytes2`` or ``bytes``.\n *\n *  Since JavaScript has no meaningful way to explicitly inform any\n *  APIs which what the type is, this allows transparent interoperation\n *  with Soldity.\n *\n *  @_subsection: api/abi:Typed Values\n */\nimport { assertPrivate, defineProperties } from \"../utils/index.js\";\nconst _gaurd = {};\nfunction n(value, width) {\n    let signed = false;\n    if (width < 0) {\n        signed = true;\n        width *= -1;\n    }\n    // @TODO: Check range is valid for value\n    return new Typed(_gaurd, `${signed ? \"\" : \"u\"}int${width}`, value, { signed, width });\n}\nfunction b(value, size) {\n    // @TODO: Check range is valid for value\n    return new Typed(_gaurd, `bytes${(size) ? size : \"\"}`, value, { size });\n}\nconst _typedSymbol = Symbol.for(\"_ethers_typed\");\n/**\n *  The **Typed** class to wrap values providing explicit type information.\n */\nexport class Typed {\n    /**\n     *  The type, as a Solidity-compatible type.\n     */\n    type;\n    /**\n     *  The actual value.\n     */\n    value;\n    #options;\n    /**\n     *  @_ignore:\n     */\n    _typedSymbol;\n    /**\n     *  @_ignore:\n     */\n    constructor(gaurd, type, value, options) {\n        if (options == null) {\n            options = null;\n        }\n        assertPrivate(_gaurd, gaurd, \"Typed\");\n        defineProperties(this, { _typedSymbol, type, value });\n        this.#options = options;\n        // Check the value is valid\n        this.format();\n    }\n    /**\n     *  Format the type as a Human-Readable type.\n     */\n    format() {\n        if (this.type === \"array\") {\n            throw new Error(\"\");\n        }\n        else if (this.type === \"dynamicArray\") {\n            throw new Error(\"\");\n        }\n        else if (this.type === \"tuple\") {\n            return `tuple(${this.value.map((v) => v.format()).join(\",\")})`;\n        }\n        return this.type;\n    }\n    /**\n     *  The default value returned by this type.\n     */\n    defaultValue() {\n        return 0;\n    }\n    /**\n     *  The minimum value for numeric types.\n     */\n    minValue() {\n        return 0;\n    }\n    /**\n     *  The maximum value for numeric types.\n     */\n    maxValue() {\n        return 0;\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].\n     */\n    isBigInt() {\n        return !!(this.type.match(/^u?int[0-9]+$/));\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedData]].\n     */\n    isData() {\n        return this.type.startsWith(\"bytes\");\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedString]].\n     */\n    isString() {\n        return (this.type === \"string\");\n    }\n    /**\n     *  Returns the tuple name, if this is a tuple. Throws otherwise.\n     */\n    get tupleName() {\n        if (this.type !== \"tuple\") {\n            throw TypeError(\"not a tuple\");\n        }\n        return this.#options;\n    }\n    // Returns the length of this type as an array\n    // - `null` indicates the length is unforced, it could be dynamic\n    // - `-1` indicates the length is dynamic\n    // - any other value indicates it is a static array and is its length\n    /**\n     *  Returns the length of the array type or ``-1`` if it is dynamic.\n     *\n     *  Throws if the type is not an array.\n     */\n    get arrayLength() {\n        if (this.type !== \"array\") {\n            throw TypeError(\"not an array\");\n        }\n        if (this.#options === true) {\n            return -1;\n        }\n        if (this.#options === false) {\n            return (this.value).length;\n        }\n        return null;\n    }\n    /**\n     *  Returns a new **Typed** of %%type%% with the %%value%%.\n     */\n    static from(type, value) {\n        return new Typed(_gaurd, type, value);\n    }\n    /**\n     *  Return a new ``uint8`` type for %%v%%.\n     */\n    static uint8(v) { return n(v, 8); }\n    /**\n     *  Return a new ``uint16`` type for %%v%%.\n     */\n    static uint16(v) { return n(v, 16); }\n    /**\n     *  Return a new ``uint24`` type for %%v%%.\n     */\n    static uint24(v) { return n(v, 24); }\n    /**\n     *  Return a new ``uint32`` type for %%v%%.\n     */\n    static uint32(v) { return n(v, 32); }\n    /**\n     *  Return a new ``uint40`` type for %%v%%.\n     */\n    static uint40(v) { return n(v, 40); }\n    /**\n     *  Return a new ``uint48`` type for %%v%%.\n     */\n    static uint48(v) { return n(v, 48); }\n    /**\n     *  Return a new ``uint56`` type for %%v%%.\n     */\n    static uint56(v) { return n(v, 56); }\n    /**\n     *  Return a new ``uint64`` type for %%v%%.\n     */\n    static uint64(v) { return n(v, 64); }\n    /**\n     *  Return a new ``uint72`` type for %%v%%.\n     */\n    static uint72(v) { return n(v, 72); }\n    /**\n     *  Return a new ``uint80`` type for %%v%%.\n     */\n    static uint80(v) { return n(v, 80); }\n    /**\n     *  Return a new ``uint88`` type for %%v%%.\n     */\n    static uint88(v) { return n(v, 88); }\n    /**\n     *  Return a new ``uint96`` type for %%v%%.\n     */\n    static uint96(v) { return n(v, 96); }\n    /**\n     *  Return a new ``uint104`` type for %%v%%.\n     */\n    static uint104(v) { return n(v, 104); }\n    /**\n     *  Return a new ``uint112`` type for %%v%%.\n     */\n    static uint112(v) { return n(v, 112); }\n    /**\n     *  Return a new ``uint120`` type for %%v%%.\n     */\n    static uint120(v) { return n(v, 120); }\n    /**\n     *  Return a new ``uint128`` type for %%v%%.\n     */\n    static uint128(v) { return n(v, 128); }\n    /**\n     *  Return a new ``uint136`` type for %%v%%.\n     */\n    static uint136(v) { return n(v, 136); }\n    /**\n     *  Return a new ``uint144`` type for %%v%%.\n     */\n    static uint144(v) { return n(v, 144); }\n    /**\n     *  Return a new ``uint152`` type for %%v%%.\n     */\n    static uint152(v) { return n(v, 152); }\n    /**\n     *  Return a new ``uint160`` type for %%v%%.\n     */\n    static uint160(v) { return n(v, 160); }\n    /**\n     *  Return a new ``uint168`` type for %%v%%.\n     */\n    static uint168(v) { return n(v, 168); }\n    /**\n     *  Return a new ``uint176`` type for %%v%%.\n     */\n    static uint176(v) { return n(v, 176); }\n    /**\n     *  Return a new ``uint184`` type for %%v%%.\n     */\n    static uint184(v) { return n(v, 184); }\n    /**\n     *  Return a new ``uint192`` type for %%v%%.\n     */\n    static uint192(v) { return n(v, 192); }\n    /**\n     *  Return a new ``uint200`` type for %%v%%.\n     */\n    static uint200(v) { return n(v, 200); }\n    /**\n     *  Return a new ``uint208`` type for %%v%%.\n     */\n    static uint208(v) { return n(v, 208); }\n    /**\n     *  Return a new ``uint216`` type for %%v%%.\n     */\n    static uint216(v) { return n(v, 216); }\n    /**\n     *  Return a new ``uint224`` type for %%v%%.\n     */\n    static uint224(v) { return n(v, 224); }\n    /**\n     *  Return a new ``uint232`` type for %%v%%.\n     */\n    static uint232(v) { return n(v, 232); }\n    /**\n     *  Return a new ``uint240`` type for %%v%%.\n     */\n    static uint240(v) { return n(v, 240); }\n    /**\n     *  Return a new ``uint248`` type for %%v%%.\n     */\n    static uint248(v) { return n(v, 248); }\n    /**\n     *  Return a new ``uint256`` type for %%v%%.\n     */\n    static uint256(v) { return n(v, 256); }\n    /**\n     *  Return a new ``uint256`` type for %%v%%.\n     */\n    static uint(v) { return n(v, 256); }\n    /**\n     *  Return a new ``int8`` type for %%v%%.\n     */\n    static int8(v) { return n(v, -8); }\n    /**\n     *  Return a new ``int16`` type for %%v%%.\n     */\n    static int16(v) { return n(v, -16); }\n    /**\n     *  Return a new ``int24`` type for %%v%%.\n     */\n    static int24(v) { return n(v, -24); }\n    /**\n     *  Return a new ``int32`` type for %%v%%.\n     */\n    static int32(v) { return n(v, -32); }\n    /**\n     *  Return a new ``int40`` type for %%v%%.\n     */\n    static int40(v) { return n(v, -40); }\n    /**\n     *  Return a new ``int48`` type for %%v%%.\n     */\n    static int48(v) { return n(v, -48); }\n    /**\n     *  Return a new ``int56`` type for %%v%%.\n     */\n    static int56(v) { return n(v, -56); }\n    /**\n     *  Return a new ``int64`` type for %%v%%.\n     */\n    static int64(v) { return n(v, -64); }\n    /**\n     *  Return a new ``int72`` type for %%v%%.\n     */\n    static int72(v) { return n(v, -72); }\n    /**\n     *  Return a new ``int80`` type for %%v%%.\n     */\n    static int80(v) { return n(v, -80); }\n    /**\n     *  Return a new ``int88`` type for %%v%%.\n     */\n    static int88(v) { return n(v, -88); }\n    /**\n     *  Return a new ``int96`` type for %%v%%.\n     */\n    static int96(v) { return n(v, -96); }\n    /**\n     *  Return a new ``int104`` type for %%v%%.\n     */\n    static int104(v) { return n(v, -104); }\n    /**\n     *  Return a new ``int112`` type for %%v%%.\n     */\n    static int112(v) { return n(v, -112); }\n    /**\n     *  Return a new ``int120`` type for %%v%%.\n     */\n    static int120(v) { return n(v, -120); }\n    /**\n     *  Return a new ``int128`` type for %%v%%.\n     */\n    static int128(v) { return n(v, -128); }\n    /**\n     *  Return a new ``int136`` type for %%v%%.\n     */\n    static int136(v) { return n(v, -136); }\n    /**\n     *  Return a new ``int144`` type for %%v%%.\n     */\n    static int144(v) { return n(v, -144); }\n    /**\n     *  Return a new ``int52`` type for %%v%%.\n     */\n    static int152(v) { return n(v, -152); }\n    /**\n     *  Return a new ``int160`` type for %%v%%.\n     */\n    static int160(v) { return n(v, -160); }\n    /**\n     *  Return a new ``int168`` type for %%v%%.\n     */\n    static int168(v) { return n(v, -168); }\n    /**\n     *  Return a new ``int176`` type for %%v%%.\n     */\n    static int176(v) { return n(v, -176); }\n    /**\n     *  Return a new ``int184`` type for %%v%%.\n     */\n    static int184(v) { return n(v, -184); }\n    /**\n     *  Return a new ``int92`` type for %%v%%.\n     */\n    static int192(v) { return n(v, -192); }\n    /**\n     *  Return a new ``int200`` type for %%v%%.\n     */\n    static int200(v) { return n(v, -200); }\n    /**\n     *  Return a new ``int208`` type for %%v%%.\n     */\n    static int208(v) { return n(v, -208); }\n    /**\n     *  Return a new ``int216`` type for %%v%%.\n     */\n    static int216(v) { return n(v, -216); }\n    /**\n     *  Return a new ``int224`` type for %%v%%.\n     */\n    static int224(v) { return n(v, -224); }\n    /**\n     *  Return a new ``int232`` type for %%v%%.\n     */\n    static int232(v) { return n(v, -232); }\n    /**\n     *  Return a new ``int240`` type for %%v%%.\n     */\n    static int240(v) { return n(v, -240); }\n    /**\n     *  Return a new ``int248`` type for %%v%%.\n     */\n    static int248(v) { return n(v, -248); }\n    /**\n     *  Return a new ``int256`` type for %%v%%.\n     */\n    static int256(v) { return n(v, -256); }\n    /**\n     *  Return a new ``int256`` type for %%v%%.\n     */\n    static int(v) { return n(v, -256); }\n    /**\n     *  Return a new ``bytes1`` type for %%v%%.\n     */\n    static bytes1(v) { return b(v, 1); }\n    /**\n     *  Return a new ``bytes2`` type for %%v%%.\n     */\n    static bytes2(v) { return b(v, 2); }\n    /**\n     *  Return a new ``bytes3`` type for %%v%%.\n     */\n    static bytes3(v) { return b(v, 3); }\n    /**\n     *  Return a new ``bytes4`` type for %%v%%.\n     */\n    static bytes4(v) { return b(v, 4); }\n    /**\n     *  Return a new ``bytes5`` type for %%v%%.\n     */\n    static bytes5(v) { return b(v, 5); }\n    /**\n     *  Return a new ``bytes6`` type for %%v%%.\n     */\n    static bytes6(v) { return b(v, 6); }\n    /**\n     *  Return a new ``bytes7`` type for %%v%%.\n     */\n    static bytes7(v) { return b(v, 7); }\n    /**\n     *  Return a new ``bytes8`` type for %%v%%.\n     */\n    static bytes8(v) { return b(v, 8); }\n    /**\n     *  Return a new ``bytes9`` type for %%v%%.\n     */\n    static bytes9(v) { return b(v, 9); }\n    /**\n     *  Return a new ``bytes10`` type for %%v%%.\n     */\n    static bytes10(v) { return b(v, 10); }\n    /**\n     *  Return a new ``bytes11`` type for %%v%%.\n     */\n    static bytes11(v) { return b(v, 11); }\n    /**\n     *  Return a new ``bytes12`` type for %%v%%.\n     */\n    static bytes12(v) { return b(v, 12); }\n    /**\n     *  Return a new ``bytes13`` type for %%v%%.\n     */\n    static bytes13(v) { return b(v, 13); }\n    /**\n     *  Return a new ``bytes14`` type for %%v%%.\n     */\n    static bytes14(v) { return b(v, 14); }\n    /**\n     *  Return a new ``bytes15`` type for %%v%%.\n     */\n    static bytes15(v) { return b(v, 15); }\n    /**\n     *  Return a new ``bytes16`` type for %%v%%.\n     */\n    static bytes16(v) { return b(v, 16); }\n    /**\n     *  Return a new ``bytes17`` type for %%v%%.\n     */\n    static bytes17(v) { return b(v, 17); }\n    /**\n     *  Return a new ``bytes18`` type for %%v%%.\n     */\n    static bytes18(v) { return b(v, 18); }\n    /**\n     *  Return a new ``bytes19`` type for %%v%%.\n     */\n    static bytes19(v) { return b(v, 19); }\n    /**\n     *  Return a new ``bytes20`` type for %%v%%.\n     */\n    static bytes20(v) { return b(v, 20); }\n    /**\n     *  Return a new ``bytes21`` type for %%v%%.\n     */\n    static bytes21(v) { return b(v, 21); }\n    /**\n     *  Return a new ``bytes22`` type for %%v%%.\n     */\n    static bytes22(v) { return b(v, 22); }\n    /**\n     *  Return a new ``bytes23`` type for %%v%%.\n     */\n    static bytes23(v) { return b(v, 23); }\n    /**\n     *  Return a new ``bytes24`` type for %%v%%.\n     */\n    static bytes24(v) { return b(v, 24); }\n    /**\n     *  Return a new ``bytes25`` type for %%v%%.\n     */\n    static bytes25(v) { return b(v, 25); }\n    /**\n     *  Return a new ``bytes26`` type for %%v%%.\n     */\n    static bytes26(v) { return b(v, 26); }\n    /**\n     *  Return a new ``bytes27`` type for %%v%%.\n     */\n    static bytes27(v) { return b(v, 27); }\n    /**\n     *  Return a new ``bytes28`` type for %%v%%.\n     */\n    static bytes28(v) { return b(v, 28); }\n    /**\n     *  Return a new ``bytes29`` type for %%v%%.\n     */\n    static bytes29(v) { return b(v, 29); }\n    /**\n     *  Return a new ``bytes30`` type for %%v%%.\n     */\n    static bytes30(v) { return b(v, 30); }\n    /**\n     *  Return a new ``bytes31`` type for %%v%%.\n     */\n    static bytes31(v) { return b(v, 31); }\n    /**\n     *  Return a new ``bytes32`` type for %%v%%.\n     */\n    static bytes32(v) { return b(v, 32); }\n    /**\n     *  Return a new ``address`` type for %%v%%.\n     */\n    static address(v) { return new Typed(_gaurd, \"address\", v); }\n    /**\n     *  Return a new ``bool`` type for %%v%%.\n     */\n    static bool(v) { return new Typed(_gaurd, \"bool\", !!v); }\n    /**\n     *  Return a new ``bytes`` type for %%v%%.\n     */\n    static bytes(v) { return new Typed(_gaurd, \"bytes\", v); }\n    /**\n     *  Return a new ``string`` type for %%v%%.\n     */\n    static string(v) { return new Typed(_gaurd, \"string\", v); }\n    /**\n     *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.\n     */\n    static array(v, dynamic) {\n        throw new Error(\"not implemented yet\");\n        return new Typed(_gaurd, \"array\", v, dynamic);\n    }\n    /**\n     *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.\n     */\n    static tuple(v, name) {\n        throw new Error(\"not implemented yet\");\n        return new Typed(_gaurd, \"tuple\", v, name);\n    }\n    /**\n     *  Return a new ``uint8`` type for %%v%%.\n     */\n    static overrides(v) {\n        return new Typed(_gaurd, \"overrides\", Object.assign({}, v));\n    }\n    /**\n     *  Returns true only if %%value%% is a [[Typed]] instance.\n     */\n    static isTyped(value) {\n        return (value\n            && typeof (value) === \"object\"\n            && \"_typedSymbol\" in value\n            && value._typedSymbol === _typedSymbol);\n    }\n    /**\n     *  If the value is a [[Typed]] instance, validates the underlying value\n     *  and returns it, otherwise returns value directly.\n     *\n     *  This is useful for functions that with to accept either a [[Typed]]\n     *  object or values.\n     */\n    static dereference(value, type) {\n        if (Typed.isTyped(value)) {\n            if (value.type !== type) {\n                throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);\n            }\n            return value.value;\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=typed.js.map","import { getAddress } from \"../../address/index.js\";\nimport { toBeHex } from \"../../utils/maths.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class AddressCoder extends Coder {\n    constructor(localName) {\n        super(\"address\", \"address\", localName, false);\n    }\n    defaultValue() {\n        return \"0x0000000000000000000000000000000000000000\";\n    }\n    encode(writer, _value) {\n        let value = Typed.dereference(_value, \"string\");\n        try {\n            value = getAddress(value);\n        }\n        catch (error) {\n            return this._throwError(error.message, _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        return getAddress(toBeHex(reader.readValue(), 20));\n    }\n}\n//# sourceMappingURL=address.js.map","import { Coder } from \"./abstract-coder.js\";\n/**\n *  Clones the functionality of an existing Coder, but without a localName\n *\n *  @_ignore\n */\nexport class AnonymousCoder extends Coder {\n    coder;\n    constructor(coder) {\n        super(coder.name, coder.type, \"_\", coder.dynamic);\n        this.coder = coder;\n    }\n    defaultValue() {\n        return this.coder.defaultValue();\n    }\n    encode(writer, value) {\n        return this.coder.encode(writer, value);\n    }\n    decode(reader) {\n        return this.coder.decode(reader);\n    }\n}\n//# sourceMappingURL=anonymous.js.map","import { defineProperties, isError, assert, assertArgument, assertArgumentCount } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, Result, WordSize, Writer } from \"./abstract-coder.js\";\nimport { AnonymousCoder } from \"./anonymous.js\";\n/**\n *  @_ignore\n */\nexport function pack(writer, coders, values) {\n    let arrayValues = [];\n    if (Array.isArray(values)) {\n        arrayValues = values;\n    }\n    else if (values && typeof (values) === \"object\") {\n        let unique = {};\n        arrayValues = coders.map((coder) => {\n            const name = coder.localName;\n            assert(name, \"cannot encode object for signature with missing names\", \"INVALID_ARGUMENT\", { argument: \"values\", info: { coder }, value: values });\n            assert(!unique[name], \"cannot encode object for signature with duplicate names\", \"INVALID_ARGUMENT\", { argument: \"values\", info: { coder }, value: values });\n            unique[name] = true;\n            return values[name];\n        });\n    }\n    else {\n        assertArgument(false, \"invalid tuple value\", \"tuple\", values);\n    }\n    assertArgument(coders.length === arrayValues.length, \"types/value length mismatch\", \"tuple\", values);\n    let staticWriter = new Writer();\n    let dynamicWriter = new Writer();\n    let updateFuncs = [];\n    coders.forEach((coder, index) => {\n        let value = arrayValues[index];\n        if (coder.dynamic) {\n            // Get current dynamic offset (for the future pointer)\n            let dynamicOffset = dynamicWriter.length;\n            // Encode the dynamic value into the dynamicWriter\n            coder.encode(dynamicWriter, value);\n            // Prepare to populate the correct offset once we are done\n            let updateFunc = staticWriter.writeUpdatableValue();\n            updateFuncs.push((baseOffset) => {\n                updateFunc(baseOffset + dynamicOffset);\n            });\n        }\n        else {\n            coder.encode(staticWriter, value);\n        }\n    });\n    // Backfill all the dynamic offsets, now that we know the static length\n    updateFuncs.forEach((func) => { func(staticWriter.length); });\n    let length = writer.appendWriter(staticWriter);\n    length += writer.appendWriter(dynamicWriter);\n    return length;\n}\n/**\n *  @_ignore\n */\nexport function unpack(reader, coders) {\n    let values = [];\n    let keys = [];\n    // A reader anchored to this base\n    let baseReader = reader.subReader(0);\n    coders.forEach((coder) => {\n        let value = null;\n        if (coder.dynamic) {\n            let offset = reader.readIndex();\n            let offsetReader = baseReader.subReader(offset);\n            try {\n                value = coder.decode(offsetReader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (isError(error, \"BUFFER_OVERRUN\")) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        else {\n            try {\n                value = coder.decode(reader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (isError(error, \"BUFFER_OVERRUN\")) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        if (value == undefined) {\n            throw new Error(\"investigate\");\n        }\n        values.push(value);\n        keys.push(coder.localName || null);\n    });\n    return Result.fromItems(values, keys);\n}\n/**\n *  @_ignore\n */\nexport class ArrayCoder extends Coder {\n    coder;\n    length;\n    constructor(coder, length, localName) {\n        const type = (coder.type + \"[\" + (length >= 0 ? length : \"\") + \"]\");\n        const dynamic = (length === -1 || coder.dynamic);\n        super(\"array\", type, localName, dynamic);\n        defineProperties(this, { coder, length });\n    }\n    defaultValue() {\n        // Verifies the child coder is valid (even if the array is dynamic or 0-length)\n        const defaultChild = this.coder.defaultValue();\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            result.push(defaultChild);\n        }\n        return result;\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"array\");\n        if (!Array.isArray(value)) {\n            this._throwError(\"expected array value\", value);\n        }\n        let count = this.length;\n        if (count === -1) {\n            count = value.length;\n            writer.writeValue(value.length);\n        }\n        assertArgumentCount(value.length, count, \"coder array\" + (this.localName ? (\" \" + this.localName) : \"\"));\n        let coders = [];\n        for (let i = 0; i < value.length; i++) {\n            coders.push(this.coder);\n        }\n        return pack(writer, coders, value);\n    }\n    decode(reader) {\n        let count = this.length;\n        if (count === -1) {\n            count = reader.readIndex();\n            // Check that there is *roughly* enough data to ensure\n            // stray random data is not being read as a length. Each\n            // slot requires at least 32 bytes for their value (or 32\n            // bytes as a link to the data). This could use a much\n            // tighter bound, but we are erroring on the side of safety.\n            assert(count * WordSize <= reader.dataLength, \"insufficient data length\", \"BUFFER_OVERRUN\", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });\n        }\n        let coders = [];\n        for (let i = 0; i < count; i++) {\n            coders.push(new AnonymousCoder(this.coder));\n        }\n        return unpack(reader, coders);\n    }\n}\n//# sourceMappingURL=array.js.map","import { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class BooleanCoder extends Coder {\n    constructor(localName) {\n        super(\"bool\", \"bool\", localName, false);\n    }\n    defaultValue() {\n        return false;\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"bool\");\n        return writer.writeValue(value ? 1 : 0);\n    }\n    decode(reader) {\n        return !!reader.readValue();\n    }\n}\n//# sourceMappingURL=boolean.js.map","import { getBytesCopy, hexlify } from \"../../utils/index.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class DynamicBytesCoder extends Coder {\n    constructor(type, localName) {\n        super(type, type, localName, true);\n    }\n    defaultValue() {\n        return \"0x\";\n    }\n    encode(writer, value) {\n        value = getBytesCopy(value);\n        let length = writer.writeValue(value.length);\n        length += writer.writeBytes(value);\n        return length;\n    }\n    decode(reader) {\n        return reader.readBytes(reader.readIndex(), true);\n    }\n}\n/**\n *  @_ignore\n */\nexport class BytesCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"bytes\", localName);\n    }\n    decode(reader) {\n        return hexlify(super.decode(reader));\n    }\n}\n//# sourceMappingURL=bytes.js.map","import { defineProperties, getBytesCopy, hexlify } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class FixedBytesCoder extends Coder {\n    size;\n    constructor(size, localName) {\n        let name = \"bytes\" + String(size);\n        super(name, name, localName, false);\n        defineProperties(this, { size }, { size: \"number\" });\n    }\n    defaultValue() {\n        return (\"0x0000000000000000000000000000000000000000000000000000000000000000\").substring(0, 2 + this.size * 2);\n    }\n    encode(writer, _value) {\n        let data = getBytesCopy(Typed.dereference(_value, this.type));\n        if (data.length !== this.size) {\n            this._throwError(\"incorrect data length\", _value);\n        }\n        return writer.writeBytes(data);\n    }\n    decode(reader) {\n        return hexlify(reader.readBytes(this.size));\n    }\n}\n//# sourceMappingURL=fixed-bytes.js.map","import { Coder } from \"./abstract-coder.js\";\nconst Empty = new Uint8Array([]);\n/**\n *  @_ignore\n */\nexport class NullCoder extends Coder {\n    constructor(localName) {\n        super(\"null\", \"\", localName, false);\n    }\n    defaultValue() {\n        return null;\n    }\n    encode(writer, value) {\n        if (value != null) {\n            this._throwError(\"not null\", value);\n        }\n        return writer.writeBytes(Empty);\n    }\n    decode(reader) {\n        reader.readBytes(0);\n        return null;\n    }\n}\n//# sourceMappingURL=null.js.map","import { defineProperties, fromTwos, getBigInt, mask, toTwos } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, WordSize } from \"./abstract-coder.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_MAX_UINT256 = BigInt(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\n/**\n *  @_ignore\n */\nexport class NumberCoder extends Coder {\n    size;\n    signed;\n    constructor(size, signed, localName) {\n        const name = ((signed ? \"int\" : \"uint\") + (size * 8));\n        super(name, name, localName, false);\n        defineProperties(this, { size, signed }, { size: \"number\", signed: \"boolean\" });\n    }\n    defaultValue() {\n        return 0;\n    }\n    encode(writer, _value) {\n        let value = getBigInt(Typed.dereference(_value, this.type));\n        // Check bounds are safe for encoding\n        let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);\n        if (this.signed) {\n            let bounds = mask(maxUintValue, (this.size * 8) - 1);\n            if (value > bounds || value < -(bounds + BN_1)) {\n                this._throwError(\"value out-of-bounds\", _value);\n            }\n            value = toTwos(value, 8 * WordSize);\n        }\n        else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {\n            this._throwError(\"value out-of-bounds\", _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        let value = mask(reader.readValue(), this.size * 8);\n        if (this.signed) {\n            value = fromTwos(value, this.size * 8);\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=number.js.map","import { toUtf8Bytes, toUtf8String } from \"../../utils/utf8.js\";\nimport { Typed } from \"../typed.js\";\nimport { DynamicBytesCoder } from \"./bytes.js\";\n/**\n *  @_ignore\n */\nexport class StringCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"string\", localName);\n    }\n    defaultValue() {\n        return \"\";\n    }\n    encode(writer, _value) {\n        return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, \"string\")));\n    }\n    decode(reader) {\n        return toUtf8String(super.decode(reader));\n    }\n}\n//# sourceMappingURL=string.js.map","import { defineProperties } from \"../../utils/properties.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\nimport { pack, unpack } from \"./array.js\";\n/**\n *  @_ignore\n */\nexport class TupleCoder extends Coder {\n    coders;\n    constructor(coders, localName) {\n        let dynamic = false;\n        const types = [];\n        coders.forEach((coder) => {\n            if (coder.dynamic) {\n                dynamic = true;\n            }\n            types.push(coder.type);\n        });\n        const type = (\"tuple(\" + types.join(\",\") + \")\");\n        super(\"tuple\", type, localName, dynamic);\n        defineProperties(this, { coders: Object.freeze(coders.slice()) });\n    }\n    defaultValue() {\n        const values = [];\n        this.coders.forEach((coder) => {\n            values.push(coder.defaultValue());\n        });\n        // We only output named properties for uniquely named coders\n        const uniqueNames = this.coders.reduce((accum, coder) => {\n            const name = coder.localName;\n            if (name) {\n                if (!accum[name]) {\n                    accum[name] = 0;\n                }\n                accum[name]++;\n            }\n            return accum;\n        }, {});\n        // Add named values\n        this.coders.forEach((coder, index) => {\n            let name = coder.localName;\n            if (!name || uniqueNames[name] !== 1) {\n                return;\n            }\n            if (name === \"length\") {\n                name = \"_length\";\n            }\n            if (values[name] != null) {\n                return;\n            }\n            values[name] = values[index];\n        });\n        return Object.freeze(values);\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"tuple\");\n        return pack(writer, this.coders, value);\n    }\n    decode(reader) {\n        return unpack(reader, this.coders);\n    }\n}\n//# sourceMappingURL=tuple.js.map","import { keccak256 } from \"../crypto/index.js\";\nimport { toUtf8Bytes } from \"../utils/index.js\";\n/**\n *  A simple hashing function which operates on UTF-8 strings to\n *  compute an 32-byte identifier.\n *\n *  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes\n *  the [[keccak256]].\n *\n *  @example:\n *    id(\"hello world\")\n *    //_result:\n */\nexport function id(value) {\n    return keccak256(toUtf8Bytes(value));\n}\n//# sourceMappingURL=id.js.map","import { getAddress } from \"../address/index.js\";\nimport { assertArgument, isHexString } from \"../utils/index.js\";\nfunction accessSetify(addr, storageKeys) {\n    return {\n        address: getAddress(addr),\n        storageKeys: storageKeys.map((storageKey, index) => {\n            assertArgument(isHexString(storageKey, 32), \"invalid slot\", `storageKeys[${index}]`, storageKey);\n            return storageKey.toLowerCase();\n        })\n    };\n}\n/**\n *  Returns a [[AccessList]] from any ethers-supported access-list structure.\n */\nexport function accessListify(value) {\n    if (Array.isArray(value)) {\n        return value.map((set, index) => {\n            if (Array.isArray(set)) {\n                assertArgument(set.length === 2, \"invalid slot set\", `value[${index}]`, set);\n                return accessSetify(set[0], set[1]);\n            }\n            assertArgument(set != null && typeof (set) === \"object\", \"invalid address-slot set\", \"value\", value);\n            return accessSetify(set.address, set.storageKeys);\n        });\n    }\n    assertArgument(value != null && typeof (value) === \"object\", \"invalid access list\", \"value\", value);\n    const result = Object.keys(value).map((addr) => {\n        const storageKeys = value[addr].reduce((accum, storageKey) => {\n            accum[storageKey] = true;\n            return accum;\n        }, {});\n        return accessSetify(addr, Object.keys(storageKeys).sort());\n    });\n    result.sort((a, b) => (a.address.localeCompare(b.address)));\n    return result;\n}\n//# sourceMappingURL=accesslist.js.map","/**\n *  A fragment is a single item from an ABI, which may represent any of:\n *\n *  - [Functions](FunctionFragment)\n *  - [Events](EventFragment)\n *  - [Constructors](ConstructorFragment)\n *  - Custom [Errors](ErrorFragment)\n *  - [Fallback or Receive](FallbackFragment) functions\n *\n *  @_subsection api/abi/abi-coder:Fragments  [about-fragments]\n */\nimport { defineProperties, getBigInt, getNumber, assert, assertPrivate, assertArgument } from \"../utils/index.js\";\nimport { id } from \"../hash/index.js\";\n;\n// [ \"a\", \"b\" ] => { \"a\": 1, \"b\": 1 }\nfunction setify(items) {\n    const result = new Set();\n    items.forEach((k) => result.add(k));\n    return Object.freeze(result);\n}\nconst _kwVisibDeploy = \"external public payable override\";\nconst KwVisibDeploy = setify(_kwVisibDeploy.split(\" \"));\n// Visibility Keywords\nconst _kwVisib = \"constant external internal payable private public pure view override\";\nconst KwVisib = setify(_kwVisib.split(\" \"));\nconst _kwTypes = \"constructor error event fallback function receive struct\";\nconst KwTypes = setify(_kwTypes.split(\" \"));\nconst _kwModifiers = \"calldata memory storage payable indexed\";\nconst KwModifiers = setify(_kwModifiers.split(\" \"));\nconst _kwOther = \"tuple returns\";\n// All Keywords\nconst _keywords = [_kwTypes, _kwModifiers, _kwOther, _kwVisib].join(\" \");\nconst Keywords = setify(_keywords.split(\" \"));\n// Single character tokens\nconst SimpleTokens = {\n    \"(\": \"OPEN_PAREN\", \")\": \"CLOSE_PAREN\",\n    \"[\": \"OPEN_BRACKET\", \"]\": \"CLOSE_BRACKET\",\n    \",\": \"COMMA\", \"@\": \"AT\"\n};\n// Parser regexes to consume the next token\nconst regexWhitespacePrefix = new RegExp(\"^(\\\\s*)\");\nconst regexNumberPrefix = new RegExp(\"^([0-9]+)\");\nconst regexIdPrefix = new RegExp(\"^([a-zA-Z$_][a-zA-Z0-9$_]*)\");\n// Parser regexs to check validity\nconst regexId = new RegExp(\"^([a-zA-Z$_][a-zA-Z0-9$_]*)$\");\nconst regexType = new RegExp(\"^(address|bool|bytes([0-9]*)|string|u?int([0-9]*))$\");\nclass TokenString {\n    #offset;\n    #tokens;\n    get offset() { return this.#offset; }\n    get length() { return this.#tokens.length - this.#offset; }\n    constructor(tokens) {\n        this.#offset = 0;\n        this.#tokens = tokens.slice();\n    }\n    clone() { return new TokenString(this.#tokens); }\n    reset() { this.#offset = 0; }\n    #subTokenString(from = 0, to = 0) {\n        return new TokenString(this.#tokens.slice(from, to).map((t) => {\n            return Object.freeze(Object.assign({}, t, {\n                match: (t.match - from),\n                linkBack: (t.linkBack - from),\n                linkNext: (t.linkNext - from),\n            }));\n        }));\n    }\n    // Pops and returns the value of the next token, if it is a keyword in allowed; throws if out of tokens\n    popKeyword(allowed) {\n        const top = this.peek();\n        if (top.type !== \"KEYWORD\" || !allowed.has(top.text)) {\n            throw new Error(`expected keyword ${top.text}`);\n        }\n        return this.pop().text;\n    }\n    // Pops and returns the value of the next token if it is `type`; throws if out of tokens\n    popType(type) {\n        if (this.peek().type !== type) {\n            const top = this.peek();\n            throw new Error(`expected ${type}; got ${top.type} ${JSON.stringify(top.text)}`);\n        }\n        return this.pop().text;\n    }\n    // Pops and returns a \"(\" TOKENS \")\"\n    popParen() {\n        const top = this.peek();\n        if (top.type !== \"OPEN_PAREN\") {\n            throw new Error(\"bad start\");\n        }\n        const result = this.#subTokenString(this.#offset + 1, top.match + 1);\n        this.#offset = top.match + 1;\n        return result;\n    }\n    // Pops and returns the items within \"(\" ITEM1 \",\" ITEM2 \",\" ... \")\"\n    popParams() {\n        const top = this.peek();\n        if (top.type !== \"OPEN_PAREN\") {\n            throw new Error(\"bad start\");\n        }\n        const result = [];\n        while (this.#offset < top.match - 1) {\n            const link = this.peek().linkNext;\n            result.push(this.#subTokenString(this.#offset + 1, link));\n            this.#offset = link;\n        }\n        this.#offset = top.match + 1;\n        return result;\n    }\n    // Returns the top Token, throwing if out of tokens\n    peek() {\n        if (this.#offset >= this.#tokens.length) {\n            throw new Error(\"out-of-bounds\");\n        }\n        return this.#tokens[this.#offset];\n    }\n    // Returns the next value, if it is a keyword in `allowed`\n    peekKeyword(allowed) {\n        const top = this.peekType(\"KEYWORD\");\n        return (top != null && allowed.has(top)) ? top : null;\n    }\n    // Returns the value of the next token if it is `type`\n    peekType(type) {\n        if (this.length === 0) {\n            return null;\n        }\n        const top = this.peek();\n        return (top.type === type) ? top.text : null;\n    }\n    // Returns the next token; throws if out of tokens\n    pop() {\n        const result = this.peek();\n        this.#offset++;\n        return result;\n    }\n    toString() {\n        const tokens = [];\n        for (let i = this.#offset; i < this.#tokens.length; i++) {\n            const token = this.#tokens[i];\n            tokens.push(`${token.type}:${token.text}`);\n        }\n        return `<TokenString ${tokens.join(\" \")}>`;\n    }\n}\nfunction lex(text) {\n    const tokens = [];\n    const throwError = (message) => {\n        const token = (offset < text.length) ? JSON.stringify(text[offset]) : \"$EOI\";\n        throw new Error(`invalid token ${token} at ${offset}: ${message}`);\n    };\n    let brackets = [];\n    let commas = [];\n    let offset = 0;\n    while (offset < text.length) {\n        // Strip off any leading whitespace\n        let cur = text.substring(offset);\n        let match = cur.match(regexWhitespacePrefix);\n        if (match) {\n            offset += match[1].length;\n            cur = text.substring(offset);\n        }\n        const token = { depth: brackets.length, linkBack: -1, linkNext: -1, match: -1, type: \"\", text: \"\", offset, value: -1 };\n        tokens.push(token);\n        let type = (SimpleTokens[cur[0]] || \"\");\n        if (type) {\n            token.type = type;\n            token.text = cur[0];\n            offset++;\n            if (type === \"OPEN_PAREN\") {\n                brackets.push(tokens.length - 1);\n                commas.push(tokens.length - 1);\n            }\n            else if (type == \"CLOSE_PAREN\") {\n                if (brackets.length === 0) {\n                    throwError(\"no matching open bracket\");\n                }\n                token.match = brackets.pop();\n                (tokens[token.match]).match = tokens.length - 1;\n                token.depth--;\n                token.linkBack = commas.pop();\n                (tokens[token.linkBack]).linkNext = tokens.length - 1;\n            }\n            else if (type === \"COMMA\") {\n                token.linkBack = commas.pop();\n                (tokens[token.linkBack]).linkNext = tokens.length - 1;\n                commas.push(tokens.length - 1);\n            }\n            else if (type === \"OPEN_BRACKET\") {\n                token.type = \"BRACKET\";\n            }\n            else if (type === \"CLOSE_BRACKET\") {\n                // Remove the CLOSE_BRACKET\n                let suffix = tokens.pop().text;\n                if (tokens.length > 0 && tokens[tokens.length - 1].type === \"NUMBER\") {\n                    const value = tokens.pop().text;\n                    suffix = value + suffix;\n                    (tokens[tokens.length - 1]).value = getNumber(value);\n                }\n                if (tokens.length === 0 || tokens[tokens.length - 1].type !== \"BRACKET\") {\n                    throw new Error(\"missing opening bracket\");\n                }\n                (tokens[tokens.length - 1]).text += suffix;\n            }\n            continue;\n        }\n        match = cur.match(regexIdPrefix);\n        if (match) {\n            token.text = match[1];\n            offset += token.text.length;\n            if (Keywords.has(token.text)) {\n                token.type = \"KEYWORD\";\n                continue;\n            }\n            if (token.text.match(regexType)) {\n                token.type = \"TYPE\";\n                continue;\n            }\n            token.type = \"ID\";\n            continue;\n        }\n        match = cur.match(regexNumberPrefix);\n        if (match) {\n            token.text = match[1];\n            token.type = \"NUMBER\";\n            offset += token.text.length;\n            continue;\n        }\n        throw new Error(`unexpected token ${JSON.stringify(cur[0])} at position ${offset}`);\n    }\n    return new TokenString(tokens.map((t) => Object.freeze(t)));\n}\n// Check only one of `allowed` is in `set`\nfunction allowSingle(set, allowed) {\n    let included = [];\n    for (const key in allowed.keys()) {\n        if (set.has(key)) {\n            included.push(key);\n        }\n    }\n    if (included.length > 1) {\n        throw new Error(`conflicting types: ${included.join(\", \")}`);\n    }\n}\n// Functions to process a Solidity Signature TokenString from left-to-right for...\n// ...the name with an optional type, returning the name\nfunction consumeName(type, tokens) {\n    if (tokens.peekKeyword(KwTypes)) {\n        const keyword = tokens.pop().text;\n        if (keyword !== type) {\n            throw new Error(`expected ${type}, got ${keyword}`);\n        }\n    }\n    return tokens.popType(\"ID\");\n}\n// ...all keywords matching allowed, returning the keywords\nfunction consumeKeywords(tokens, allowed) {\n    const keywords = new Set();\n    while (true) {\n        const keyword = tokens.peekType(\"KEYWORD\");\n        if (keyword == null || (allowed && !allowed.has(keyword))) {\n            break;\n        }\n        tokens.pop();\n        if (keywords.has(keyword)) {\n            throw new Error(`duplicate keywords: ${JSON.stringify(keyword)}`);\n        }\n        keywords.add(keyword);\n    }\n    return Object.freeze(keywords);\n}\n// ...all visibility keywords, returning the coalesced mutability\nfunction consumeMutability(tokens) {\n    let modifiers = consumeKeywords(tokens, KwVisib);\n    // Detect conflicting modifiers\n    allowSingle(modifiers, setify(\"constant payable nonpayable\".split(\" \")));\n    allowSingle(modifiers, setify(\"pure view payable nonpayable\".split(\" \")));\n    // Process mutability states\n    if (modifiers.has(\"view\")) {\n        return \"view\";\n    }\n    if (modifiers.has(\"pure\")) {\n        return \"pure\";\n    }\n    if (modifiers.has(\"payable\")) {\n        return \"payable\";\n    }\n    if (modifiers.has(\"nonpayable\")) {\n        return \"nonpayable\";\n    }\n    // Process legacy `constant` last\n    if (modifiers.has(\"constant\")) {\n        return \"view\";\n    }\n    return \"nonpayable\";\n}\n// ...a parameter list, returning the ParamType list\nfunction consumeParams(tokens, allowIndexed) {\n    return tokens.popParams().map((t) => ParamType.from(t, allowIndexed));\n}\n// ...a gas limit, returning a BigNumber or null if none\nfunction consumeGas(tokens) {\n    if (tokens.peekType(\"AT\")) {\n        tokens.pop();\n        if (tokens.peekType(\"NUMBER\")) {\n            return getBigInt(tokens.pop().text);\n        }\n        throw new Error(\"invalid gas\");\n    }\n    return null;\n}\nfunction consumeEoi(tokens) {\n    if (tokens.length) {\n        throw new Error(`unexpected tokens at offset ${tokens.offset}: ${tokens.toString()}`);\n    }\n}\nconst regexArrayType = new RegExp(/^(.*)\\[([0-9]*)\\]$/);\nfunction verifyBasicType(type) {\n    const match = type.match(regexType);\n    assertArgument(match, \"invalid type\", \"type\", type);\n    if (type === \"uint\") {\n        return \"uint256\";\n    }\n    if (type === \"int\") {\n        return \"int256\";\n    }\n    if (match[2]) {\n        // bytesXX\n        const length = parseInt(match[2]);\n        assertArgument(length !== 0 && length <= 32, \"invalid bytes length\", \"type\", type);\n    }\n    else if (match[3]) {\n        // intXX or uintXX\n        const size = parseInt(match[3]);\n        assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, \"invalid numeric width\", \"type\", type);\n    }\n    return type;\n}\n// Make the Fragment constructors effectively private\nconst _guard = {};\nconst internal = Symbol.for(\"_ethers_internal\");\nconst ParamTypeInternal = \"_ParamTypeInternal\";\nconst ErrorFragmentInternal = \"_ErrorInternal\";\nconst EventFragmentInternal = \"_EventInternal\";\nconst ConstructorFragmentInternal = \"_ConstructorInternal\";\nconst FallbackFragmentInternal = \"_FallbackInternal\";\nconst FunctionFragmentInternal = \"_FunctionInternal\";\nconst StructFragmentInternal = \"_StructInternal\";\n/**\n *  Each input and output of a [[Fragment]] is an Array of **ParamType**.\n */\nexport class ParamType {\n    /**\n     *  The local name of the parameter (or ``\"\"`` if unbound)\n     */\n    name;\n    /**\n     *  The fully qualified type (e.g. ``\"address\"``, ``\"tuple(address)\"``,\n     *  ``\"uint256[3][]\"``)\n     */\n    type;\n    /**\n     *  The base type (e.g. ``\"address\"``, ``\"tuple\"``, ``\"array\"``)\n     */\n    baseType;\n    /**\n     *  True if the parameters is indexed.\n     *\n     *  For non-indexable types this is ``null``.\n     */\n    indexed;\n    /**\n     *  The components for the tuple.\n     *\n     *  For non-tuple types this is ``null``.\n     */\n    components;\n    /**\n     *  The array length, or ``-1`` for dynamic-lengthed arrays.\n     *\n     *  For non-array types this is ``null``.\n     */\n    arrayLength;\n    /**\n     *  The type of each child in the array.\n     *\n     *  For non-array types this is ``null``.\n     */\n    arrayChildren;\n    /**\n     *  @private\n     */\n    constructor(guard, name, type, baseType, indexed, components, arrayLength, arrayChildren) {\n        assertPrivate(guard, _guard, \"ParamType\");\n        Object.defineProperty(this, internal, { value: ParamTypeInternal });\n        if (components) {\n            components = Object.freeze(components.slice());\n        }\n        if (baseType === \"array\") {\n            if (arrayLength == null || arrayChildren == null) {\n                throw new Error(\"\");\n            }\n        }\n        else if (arrayLength != null || arrayChildren != null) {\n            throw new Error(\"\");\n        }\n        if (baseType === \"tuple\") {\n            if (components == null) {\n                throw new Error(\"\");\n            }\n        }\n        else if (components != null) {\n            throw new Error(\"\");\n        }\n        defineProperties(this, {\n            name, type, baseType, indexed, components, arrayLength, arrayChildren\n        });\n    }\n    /**\n     *  Return a string representation of this type.\n     *\n     *  For example,\n     *\n     *  ``sighash\" => \"(uint256,address)\"``\n     *\n     *  ``\"minimal\" => \"tuple(uint256,address) indexed\"``\n     *\n     *  ``\"full\" => \"tuple(uint256 foo, address bar) indexed baz\"``\n     */\n    format(format) {\n        if (format == null) {\n            format = \"sighash\";\n        }\n        if (format === \"json\") {\n            const name = this.name || \"\";\n            if (this.isArray()) {\n                const result = JSON.parse(this.arrayChildren.format(\"json\"));\n                result.name = name;\n                result.type += `[${(this.arrayLength < 0 ? \"\" : String(this.arrayLength))}]`;\n                return JSON.stringify(result);\n            }\n            const result = {\n                type: ((this.baseType === \"tuple\") ? \"tuple\" : this.type),\n                name\n            };\n            if (typeof (this.indexed) === \"boolean\") {\n                result.indexed = this.indexed;\n            }\n            if (this.isTuple()) {\n                result.components = this.components.map((c) => JSON.parse(c.format(format)));\n            }\n            return JSON.stringify(result);\n        }\n        let result = \"\";\n        // Array\n        if (this.isArray()) {\n            result += this.arrayChildren.format(format);\n            result += `[${(this.arrayLength < 0 ? \"\" : String(this.arrayLength))}]`;\n        }\n        else {\n            if (this.isTuple()) {\n                result += \"(\" + this.components.map((comp) => comp.format(format)).join((format === \"full\") ? \", \" : \",\") + \")\";\n            }\n            else {\n                result += this.type;\n            }\n        }\n        if (format !== \"sighash\") {\n            if (this.indexed === true) {\n                result += \" indexed\";\n            }\n            if (format === \"full\" && this.name) {\n                result += \" \" + this.name;\n            }\n        }\n        return result;\n    }\n    /**\n     *  Returns true if %%this%% is an Array type.\n     *\n     *  This provides a type gaurd ensuring that [[arrayChildren]]\n     *  and [[arrayLength]] are non-null.\n     */\n    isArray() {\n        return (this.baseType === \"array\");\n    }\n    /**\n     *  Returns true if %%this%% is a Tuple type.\n     *\n     *  This provides a type gaurd ensuring that [[components]]\n     *  is non-null.\n     */\n    isTuple() {\n        return (this.baseType === \"tuple\");\n    }\n    /**\n     *  Returns true if %%this%% is an Indexable type.\n     *\n     *  This provides a type gaurd ensuring that [[indexed]]\n     *  is non-null.\n     */\n    isIndexable() {\n        return (this.indexed != null);\n    }\n    /**\n     *  Walks the **ParamType** with %%value%%, calling %%process%%\n     *  on each type, destructing the %%value%% recursively.\n     */\n    walk(value, process) {\n        if (this.isArray()) {\n            if (!Array.isArray(value)) {\n                throw new Error(\"invalid array value\");\n            }\n            if (this.arrayLength !== -1 && value.length !== this.arrayLength) {\n                throw new Error(\"array is wrong length\");\n            }\n            const _this = this;\n            return value.map((v) => (_this.arrayChildren.walk(v, process)));\n        }\n        if (this.isTuple()) {\n            if (!Array.isArray(value)) {\n                throw new Error(\"invalid tuple value\");\n            }\n            if (value.length !== this.components.length) {\n                throw new Error(\"array is wrong length\");\n            }\n            const _this = this;\n            return value.map((v, i) => (_this.components[i].walk(v, process)));\n        }\n        return process(this.type, value);\n    }\n    #walkAsync(promises, value, process, setValue) {\n        if (this.isArray()) {\n            if (!Array.isArray(value)) {\n                throw new Error(\"invalid array value\");\n            }\n            if (this.arrayLength !== -1 && value.length !== this.arrayLength) {\n                throw new Error(\"array is wrong length\");\n            }\n            const childType = this.arrayChildren;\n            const result = value.slice();\n            result.forEach((value, index) => {\n                childType.#walkAsync(promises, value, process, (value) => {\n                    result[index] = value;\n                });\n            });\n            setValue(result);\n            return;\n        }\n        if (this.isTuple()) {\n            const components = this.components;\n            // Convert the object into an array\n            let result;\n            if (Array.isArray(value)) {\n                result = value.slice();\n            }\n            else {\n                if (value == null || typeof (value) !== \"object\") {\n                    throw new Error(\"invalid tuple value\");\n                }\n                result = components.map((param) => {\n                    if (!param.name) {\n                        throw new Error(\"cannot use object value with unnamed components\");\n                    }\n                    if (!(param.name in value)) {\n                        throw new Error(`missing value for component ${param.name}`);\n                    }\n                    return value[param.name];\n                });\n            }\n            if (result.length !== this.components.length) {\n                throw new Error(\"array is wrong length\");\n            }\n            result.forEach((value, index) => {\n                components[index].#walkAsync(promises, value, process, (value) => {\n                    result[index] = value;\n                });\n            });\n            setValue(result);\n            return;\n        }\n        const result = process(this.type, value);\n        if (result.then) {\n            promises.push((async function () { setValue(await result); })());\n        }\n        else {\n            setValue(result);\n        }\n    }\n    /**\n     *  Walks the **ParamType** with %%value%%, asynchronously calling\n     *  %%process%% on each type, destructing the %%value%% recursively.\n     *\n     *  This can be used to resolve ENS naes by walking and resolving each\n     *  ``\"address\"`` type.\n     */\n    async walkAsync(value, process) {\n        const promises = [];\n        const result = [value];\n        this.#walkAsync(promises, value, process, (value) => {\n            result[0] = value;\n        });\n        if (promises.length) {\n            await Promise.all(promises);\n        }\n        return result[0];\n    }\n    /**\n     *  Creates a new **ParamType** for %%obj%%.\n     *\n     *  If %%allowIndexed%% then the ``indexed`` keyword is permitted,\n     *  otherwise the ``indexed`` keyword will throw an error.\n     */\n    static from(obj, allowIndexed) {\n        if (ParamType.isParamType(obj)) {\n            return obj;\n        }\n        if (typeof (obj) === \"string\") {\n            try {\n                return ParamType.from(lex(obj), allowIndexed);\n            }\n            catch (error) {\n                assertArgument(false, \"invalid param type\", \"obj\", obj);\n            }\n        }\n        else if (obj instanceof TokenString) {\n            let type = \"\", baseType = \"\";\n            let comps = null;\n            if (consumeKeywords(obj, setify([\"tuple\"])).has(\"tuple\") || obj.peekType(\"OPEN_PAREN\")) {\n                // Tuple\n                baseType = \"tuple\";\n                comps = obj.popParams().map((t) => ParamType.from(t));\n                type = `tuple(${comps.map((c) => c.format()).join(\",\")})`;\n            }\n            else {\n                // Normal\n                type = verifyBasicType(obj.popType(\"TYPE\"));\n                baseType = type;\n            }\n            // Check for Array\n            let arrayChildren = null;\n            let arrayLength = null;\n            while (obj.length && obj.peekType(\"BRACKET\")) {\n                const bracket = obj.pop(); //arrays[i];\n                arrayChildren = new ParamType(_guard, \"\", type, baseType, null, comps, arrayLength, arrayChildren);\n                arrayLength = bracket.value;\n                type += bracket.text;\n                baseType = \"array\";\n                comps = null;\n            }\n            let indexed = null;\n            const keywords = consumeKeywords(obj, KwModifiers);\n            if (keywords.has(\"indexed\")) {\n                if (!allowIndexed) {\n                    throw new Error(\"\");\n                }\n                indexed = true;\n            }\n            const name = (obj.peekType(\"ID\") ? obj.pop().text : \"\");\n            if (obj.length) {\n                throw new Error(\"leftover tokens\");\n            }\n            return new ParamType(_guard, name, type, baseType, indexed, comps, arrayLength, arrayChildren);\n        }\n        const name = obj.name;\n        assertArgument(!name || (typeof (name) === \"string\" && name.match(regexId)), \"invalid name\", \"obj.name\", name);\n        let indexed = obj.indexed;\n        if (indexed != null) {\n            assertArgument(allowIndexed, \"parameter cannot be indexed\", \"obj.indexed\", obj.indexed);\n            indexed = !!indexed;\n        }\n        let type = obj.type;\n        let arrayMatch = type.match(regexArrayType);\n        if (arrayMatch) {\n            const arrayLength = parseInt(arrayMatch[2] || \"-1\");\n            const arrayChildren = ParamType.from({\n                type: arrayMatch[1],\n                components: obj.components\n            });\n            return new ParamType(_guard, name || \"\", type, \"array\", indexed, null, arrayLength, arrayChildren);\n        }\n        if (type === \"tuple\" || type.startsWith(\"tuple(\" /* fix: ) */) || type.startsWith(\"(\" /* fix: ) */)) {\n            const comps = (obj.components != null) ? obj.components.map((c) => ParamType.from(c)) : null;\n            const tuple = new ParamType(_guard, name || \"\", type, \"tuple\", indexed, comps, null, null);\n            // @TODO: use lexer to validate and normalize type\n            return tuple;\n        }\n        type = verifyBasicType(obj.type);\n        return new ParamType(_guard, name || \"\", type, type, indexed, null, null, null);\n    }\n    /**\n     *  Returns true if %%value%% is a **ParamType**.\n     */\n    static isParamType(value) {\n        return (value && value[internal] === ParamTypeInternal);\n    }\n}\n/**\n *  An abstract class to represent An individual fragment from a parse ABI.\n */\nexport class Fragment {\n    /**\n     *  The type of the fragment.\n     */\n    type;\n    /**\n     *  The inputs for the fragment.\n     */\n    inputs;\n    /**\n     *  @private\n     */\n    constructor(guard, type, inputs) {\n        assertPrivate(guard, _guard, \"Fragment\");\n        inputs = Object.freeze(inputs.slice());\n        defineProperties(this, { type, inputs });\n    }\n    /**\n     *  Creates a new **Fragment** for %%obj%%, wich can be any supported\n     *  ABI frgament type.\n     */\n    static from(obj) {\n        if (typeof (obj) === \"string\") {\n            // Try parsing JSON...\n            try {\n                Fragment.from(JSON.parse(obj));\n            }\n            catch (e) { }\n            // ...otherwise, use the human-readable lexer\n            return Fragment.from(lex(obj));\n        }\n        if (obj instanceof TokenString) {\n            // Human-readable ABI (already lexed)\n            const type = obj.peekKeyword(KwTypes);\n            switch (type) {\n                case \"constructor\": return ConstructorFragment.from(obj);\n                case \"error\": return ErrorFragment.from(obj);\n                case \"event\": return EventFragment.from(obj);\n                case \"fallback\":\n                case \"receive\":\n                    return FallbackFragment.from(obj);\n                case \"function\": return FunctionFragment.from(obj);\n                case \"struct\": return StructFragment.from(obj);\n            }\n        }\n        else if (typeof (obj) === \"object\") {\n            // JSON ABI\n            switch (obj.type) {\n                case \"constructor\": return ConstructorFragment.from(obj);\n                case \"error\": return ErrorFragment.from(obj);\n                case \"event\": return EventFragment.from(obj);\n                case \"fallback\":\n                case \"receive\":\n                    return FallbackFragment.from(obj);\n                case \"function\": return FunctionFragment.from(obj);\n                case \"struct\": return StructFragment.from(obj);\n            }\n            assert(false, `unsupported type: ${obj.type}`, \"UNSUPPORTED_OPERATION\", {\n                operation: \"Fragment.from\"\n            });\n        }\n        assertArgument(false, \"unsupported frgament object\", \"obj\", obj);\n    }\n    /**\n     *  Returns true if %%value%% is a [[ConstructorFragment]].\n     */\n    static isConstructor(value) {\n        return ConstructorFragment.isFragment(value);\n    }\n    /**\n     *  Returns true if %%value%% is an [[ErrorFragment]].\n     */\n    static isError(value) {\n        return ErrorFragment.isFragment(value);\n    }\n    /**\n     *  Returns true if %%value%% is an [[EventFragment]].\n     */\n    static isEvent(value) {\n        return EventFragment.isFragment(value);\n    }\n    /**\n     *  Returns true if %%value%% is a [[FunctionFragment]].\n     */\n    static isFunction(value) {\n        return FunctionFragment.isFragment(value);\n    }\n    /**\n     *  Returns true if %%value%% is a [[StructFragment]].\n     */\n    static isStruct(value) {\n        return StructFragment.isFragment(value);\n    }\n}\n/**\n *  An abstract class to represent An individual fragment\n *  which has a name from a parse ABI.\n */\nexport class NamedFragment extends Fragment {\n    /**\n     *  The name of the fragment.\n     */\n    name;\n    /**\n     *  @private\n     */\n    constructor(guard, type, name, inputs) {\n        super(guard, type, inputs);\n        assertArgument(typeof (name) === \"string\" && name.match(regexId), \"invalid identifier\", \"name\", name);\n        inputs = Object.freeze(inputs.slice());\n        defineProperties(this, { name });\n    }\n}\nfunction joinParams(format, params) {\n    return \"(\" + params.map((p) => p.format(format)).join((format === \"full\") ? \", \" : \",\") + \")\";\n}\n/**\n *  A Fragment which represents a //Custom Error//.\n */\nexport class ErrorFragment extends NamedFragment {\n    /**\n     *  @private\n     */\n    constructor(guard, name, inputs) {\n        super(guard, \"error\", name, inputs);\n        Object.defineProperty(this, internal, { value: ErrorFragmentInternal });\n    }\n    /**\n     *  The Custom Error selector.\n     */\n    get selector() {\n        return id(this.format(\"sighash\")).substring(0, 10);\n    }\n    /**\n     *  Returns a string representation of this fragment as %%format%%.\n     */\n    format(format) {\n        if (format == null) {\n            format = \"sighash\";\n        }\n        if (format === \"json\") {\n            return JSON.stringify({\n                type: \"error\",\n                name: this.name,\n                inputs: this.inputs.map((input) => JSON.parse(input.format(format))),\n            });\n        }\n        const result = [];\n        if (format !== \"sighash\") {\n            result.push(\"error\");\n        }\n        result.push(this.name + joinParams(format, this.inputs));\n        return result.join(\" \");\n    }\n    /**\n     *  Returns a new **ErrorFragment** for %%obj%%.\n     */\n    static from(obj) {\n        if (ErrorFragment.isFragment(obj)) {\n            return obj;\n        }\n        if (typeof (obj) === \"string\") {\n            return ErrorFragment.from(lex(obj));\n        }\n        else if (obj instanceof TokenString) {\n            const name = consumeName(\"error\", obj);\n            const inputs = consumeParams(obj);\n            consumeEoi(obj);\n            return new ErrorFragment(_guard, name, inputs);\n        }\n        return new ErrorFragment(_guard, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);\n    }\n    /**\n     *  Returns ``true`` and provides a type guard if %%value%% is an\n     *  **ErrorFragment**.\n     */\n    static isFragment(value) {\n        return (value && value[internal] === ErrorFragmentInternal);\n    }\n}\n/**\n *  A Fragment which represents an Event.\n */\nexport class EventFragment extends NamedFragment {\n    /**\n     *  Whether this event is anonymous.\n     */\n    anonymous;\n    /**\n     *  @private\n     */\n    constructor(guard, name, inputs, anonymous) {\n        super(guard, \"event\", name, inputs);\n        Object.defineProperty(this, internal, { value: EventFragmentInternal });\n        defineProperties(this, { anonymous });\n    }\n    /**\n     *  The Event topic hash.\n     */\n    get topicHash() {\n        return id(this.format(\"sighash\"));\n    }\n    /**\n     *  Returns a string representation of this event as %%format%%.\n     */\n    format(format) {\n        if (format == null) {\n            format = \"sighash\";\n        }\n        if (format === \"json\") {\n            return JSON.stringify({\n                type: \"event\",\n                anonymous: this.anonymous,\n                name: this.name,\n                inputs: this.inputs.map((i) => JSON.parse(i.format(format)))\n            });\n        }\n        const result = [];\n        if (format !== \"sighash\") {\n            result.push(\"event\");\n        }\n        result.push(this.name + joinParams(format, this.inputs));\n        if (format !== \"sighash\" && this.anonymous) {\n            result.push(\"anonymous\");\n        }\n        return result.join(\" \");\n    }\n    /**\n     *  Return the topic hash for an event with %%name%% and %%params%%.\n     */\n    static getTopicHash(name, params) {\n        params = (params || []).map((p) => ParamType.from(p));\n        const fragment = new EventFragment(_guard, name, params, false);\n        return fragment.topicHash;\n    }\n    /**\n     *  Returns a new **EventFragment** for %%obj%%.\n     */\n    static from(obj) {\n        if (EventFragment.isFragment(obj)) {\n            return obj;\n        }\n        if (typeof (obj) === \"string\") {\n            try {\n                return EventFragment.from(lex(obj));\n            }\n            catch (error) {\n                assertArgument(false, \"invalid event fragment\", \"obj\", obj);\n            }\n        }\n        else if (obj instanceof TokenString) {\n            const name = consumeName(\"event\", obj);\n            const inputs = consumeParams(obj, true);\n            const anonymous = !!consumeKeywords(obj, setify([\"anonymous\"])).has(\"anonymous\");\n            consumeEoi(obj);\n            return new EventFragment(_guard, name, inputs, anonymous);\n        }\n        return new EventFragment(_guard, obj.name, obj.inputs ? obj.inputs.map((p) => ParamType.from(p, true)) : [], !!obj.anonymous);\n    }\n    /**\n     *  Returns ``true`` and provides a type guard if %%value%% is an\n     *  **EventFragment**.\n     */\n    static isFragment(value) {\n        return (value && value[internal] === EventFragmentInternal);\n    }\n}\n/**\n *  A Fragment which represents a constructor.\n */\nexport class ConstructorFragment extends Fragment {\n    /**\n     *  Whether the constructor can receive an endowment.\n     */\n    payable;\n    /**\n     *  The recommended gas limit for deployment or ``null``.\n     */\n    gas;\n    /**\n     *  @private\n     */\n    constructor(guard, type, inputs, payable, gas) {\n        super(guard, type, inputs);\n        Object.defineProperty(this, internal, { value: ConstructorFragmentInternal });\n        defineProperties(this, { payable, gas });\n    }\n    /**\n     *  Returns a string representation of this constructor as %%format%%.\n     */\n    format(format) {\n        assert(format != null && format !== \"sighash\", \"cannot format a constructor for sighash\", \"UNSUPPORTED_OPERATION\", { operation: \"format(sighash)\" });\n        if (format === \"json\") {\n            return JSON.stringify({\n                type: \"constructor\",\n                stateMutability: (this.payable ? \"payable\" : \"undefined\"),\n                payable: this.payable,\n                gas: ((this.gas != null) ? this.gas : undefined),\n                inputs: this.inputs.map((i) => JSON.parse(i.format(format)))\n            });\n        }\n        const result = [`constructor${joinParams(format, this.inputs)}`];\n        if (this.payable) {\n            result.push(\"payable\");\n        }\n        if (this.gas != null) {\n            result.push(`@${this.gas.toString()}`);\n        }\n        return result.join(\" \");\n    }\n    /**\n     *  Returns a new **ConstructorFragment** for %%obj%%.\n     */\n    static from(obj) {\n        if (ConstructorFragment.isFragment(obj)) {\n            return obj;\n        }\n        if (typeof (obj) === \"string\") {\n            try {\n                return ConstructorFragment.from(lex(obj));\n            }\n            catch (error) {\n                assertArgument(false, \"invalid constuctor fragment\", \"obj\", obj);\n            }\n        }\n        else if (obj instanceof TokenString) {\n            consumeKeywords(obj, setify([\"constructor\"]));\n            const inputs = consumeParams(obj);\n            const payable = !!consumeKeywords(obj, KwVisibDeploy).has(\"payable\");\n            const gas = consumeGas(obj);\n            consumeEoi(obj);\n            return new ConstructorFragment(_guard, \"constructor\", inputs, payable, gas);\n        }\n        return new ConstructorFragment(_guard, \"constructor\", obj.inputs ? obj.inputs.map(ParamType.from) : [], !!obj.payable, (obj.gas != null) ? obj.gas : null);\n    }\n    /**\n     *  Returns ``true`` and provides a type guard if %%value%% is a\n     *  **ConstructorFragment**.\n     */\n    static isFragment(value) {\n        return (value && value[internal] === ConstructorFragmentInternal);\n    }\n}\n/**\n *  A Fragment which represents a method.\n */\nexport class FallbackFragment extends Fragment {\n    /**\n     *  If the function can be sent value during invocation.\n     */\n    payable;\n    constructor(guard, inputs, payable) {\n        super(guard, \"fallback\", inputs);\n        Object.defineProperty(this, internal, { value: FallbackFragmentInternal });\n        defineProperties(this, { payable });\n    }\n    /**\n     *  Returns a string representation of this fallback as %%format%%.\n     */\n    format(format) {\n        const type = ((this.inputs.length === 0) ? \"receive\" : \"fallback\");\n        if (format === \"json\") {\n            const stateMutability = (this.payable ? \"payable\" : \"nonpayable\");\n            return JSON.stringify({ type, stateMutability });\n        }\n        return `${type}()${this.payable ? \" payable\" : \"\"}`;\n    }\n    /**\n     *  Returns a new **FallbackFragment** for %%obj%%.\n     */\n    static from(obj) {\n        if (FallbackFragment.isFragment(obj)) {\n            return obj;\n        }\n        if (typeof (obj) === \"string\") {\n            try {\n                return FallbackFragment.from(lex(obj));\n            }\n            catch (error) {\n                assertArgument(false, \"invalid fallback fragment\", \"obj\", obj);\n            }\n        }\n        else if (obj instanceof TokenString) {\n            const errorObj = obj.toString();\n            const topIsValid = obj.peekKeyword(setify([\"fallback\", \"receive\"]));\n            assertArgument(topIsValid, \"type must be fallback or receive\", \"obj\", errorObj);\n            const type = obj.popKeyword(setify([\"fallback\", \"receive\"]));\n            // receive()\n            if (type === \"receive\") {\n                const inputs = consumeParams(obj);\n                assertArgument(inputs.length === 0, `receive cannot have arguments`, \"obj.inputs\", inputs);\n                consumeKeywords(obj, setify([\"payable\"]));\n                consumeEoi(obj);\n                return new FallbackFragment(_guard, [], true);\n            }\n            // fallback() [payable]\n            // fallback(bytes) [payable] returns (bytes)\n            let inputs = consumeParams(obj);\n            if (inputs.length) {\n                assertArgument(inputs.length === 1 && inputs[0].type === \"bytes\", \"invalid fallback inputs\", \"obj.inputs\", inputs.map((i) => i.format(\"minimal\")).join(\", \"));\n            }\n            else {\n                inputs = [ParamType.from(\"bytes\")];\n            }\n            const mutability = consumeMutability(obj);\n            assertArgument(mutability === \"nonpayable\" || mutability === \"payable\", \"fallback cannot be constants\", \"obj.stateMutability\", mutability);\n            if (consumeKeywords(obj, setify([\"returns\"])).has(\"returns\")) {\n                const outputs = consumeParams(obj);\n                assertArgument(outputs.length === 1 && outputs[0].type === \"bytes\", \"invalid fallback outputs\", \"obj.outputs\", outputs.map((i) => i.format(\"minimal\")).join(\", \"));\n            }\n            consumeEoi(obj);\n            return new FallbackFragment(_guard, inputs, mutability === \"payable\");\n        }\n        if (obj.type === \"receive\") {\n            return new FallbackFragment(_guard, [], true);\n        }\n        if (obj.type === \"fallback\") {\n            const inputs = [ParamType.from(\"bytes\")];\n            const payable = (obj.stateMutability === \"payable\");\n            return new FallbackFragment(_guard, inputs, payable);\n        }\n        assertArgument(false, \"invalid fallback description\", \"obj\", obj);\n    }\n    /**\n     *  Returns ``true`` and provides a type guard if %%value%% is a\n     *  **FallbackFragment**.\n     */\n    static isFragment(value) {\n        return (value && value[internal] === FallbackFragmentInternal);\n    }\n}\n/**\n *  A Fragment which represents a method.\n */\nexport class FunctionFragment extends NamedFragment {\n    /**\n     *  If the function is constant (e.g. ``pure`` or ``view`` functions).\n     */\n    constant;\n    /**\n     *  The returned types for the result of calling this function.\n     */\n    outputs;\n    /**\n     *  The state mutability (e.g. ``payable``, ``nonpayable``, ``view``\n     *  or ``pure``)\n     */\n    stateMutability;\n    /**\n     *  If the function can be sent value during invocation.\n     */\n    payable;\n    /**\n     *  The recommended gas limit to send when calling this function.\n     */\n    gas;\n    /**\n     *  @private\n     */\n    constructor(guard, name, stateMutability, inputs, outputs, gas) {\n        super(guard, \"function\", name, inputs);\n        Object.defineProperty(this, internal, { value: FunctionFragmentInternal });\n        outputs = Object.freeze(outputs.slice());\n        const constant = (stateMutability === \"view\" || stateMutability === \"pure\");\n        const payable = (stateMutability === \"payable\");\n        defineProperties(this, { constant, gas, outputs, payable, stateMutability });\n    }\n    /**\n     *  The Function selector.\n     */\n    get selector() {\n        return id(this.format(\"sighash\")).substring(0, 10);\n    }\n    /**\n     *  Returns a string representation of this function as %%format%%.\n     */\n    format(format) {\n        if (format == null) {\n            format = \"sighash\";\n        }\n        if (format === \"json\") {\n            return JSON.stringify({\n                type: \"function\",\n                name: this.name,\n                constant: this.constant,\n                stateMutability: ((this.stateMutability !== \"nonpayable\") ? this.stateMutability : undefined),\n                payable: this.payable,\n                gas: ((this.gas != null) ? this.gas : undefined),\n                inputs: this.inputs.map((i) => JSON.parse(i.format(format))),\n                outputs: this.outputs.map((o) => JSON.parse(o.format(format))),\n            });\n        }\n        const result = [];\n        if (format !== \"sighash\") {\n            result.push(\"function\");\n        }\n        result.push(this.name + joinParams(format, this.inputs));\n        if (format !== \"sighash\") {\n            if (this.stateMutability !== \"nonpayable\") {\n                result.push(this.stateMutability);\n            }\n            if (this.outputs && this.outputs.length) {\n                result.push(\"returns\");\n                result.push(joinParams(format, this.outputs));\n            }\n            if (this.gas != null) {\n                result.push(`@${this.gas.toString()}`);\n            }\n        }\n        return result.join(\" \");\n    }\n    /**\n     *  Return the selector for a function with %%name%% and %%params%%.\n     */\n    static getSelector(name, params) {\n        params = (params || []).map((p) => ParamType.from(p));\n        const fragment = new FunctionFragment(_guard, name, \"view\", params, [], null);\n        return fragment.selector;\n    }\n    /**\n     *  Returns a new **FunctionFragment** for %%obj%%.\n     */\n    static from(obj) {\n        if (FunctionFragment.isFragment(obj)) {\n            return obj;\n        }\n        if (typeof (obj) === \"string\") {\n            try {\n                return FunctionFragment.from(lex(obj));\n            }\n            catch (error) {\n                assertArgument(false, \"invalid function fragment\", \"obj\", obj);\n            }\n        }\n        else if (obj instanceof TokenString) {\n            const name = consumeName(\"function\", obj);\n            const inputs = consumeParams(obj);\n            const mutability = consumeMutability(obj);\n            let outputs = [];\n            if (consumeKeywords(obj, setify([\"returns\"])).has(\"returns\")) {\n                outputs = consumeParams(obj);\n            }\n            const gas = consumeGas(obj);\n            consumeEoi(obj);\n            return new FunctionFragment(_guard, name, mutability, inputs, outputs, gas);\n        }\n        let stateMutability = obj.stateMutability;\n        // Use legacy Solidity ABI logic if stateMutability is missing\n        if (stateMutability == null) {\n            stateMutability = \"payable\";\n            if (typeof (obj.constant) === \"boolean\") {\n                stateMutability = \"view\";\n                if (!obj.constant) {\n                    stateMutability = \"payable\";\n                    if (typeof (obj.payable) === \"boolean\" && !obj.payable) {\n                        stateMutability = \"nonpayable\";\n                    }\n                }\n            }\n            else if (typeof (obj.payable) === \"boolean\" && !obj.payable) {\n                stateMutability = \"nonpayable\";\n            }\n        }\n        // @TODO: verifyState for stateMutability (e.g. throw if\n        //        payable: false but stateMutability is \"nonpayable\")\n        return new FunctionFragment(_guard, obj.name, stateMutability, obj.inputs ? obj.inputs.map(ParamType.from) : [], obj.outputs ? obj.outputs.map(ParamType.from) : [], (obj.gas != null) ? obj.gas : null);\n    }\n    /**\n     *  Returns ``true`` and provides a type guard if %%value%% is a\n     *  **FunctionFragment**.\n     */\n    static isFragment(value) {\n        return (value && value[internal] === FunctionFragmentInternal);\n    }\n}\n/**\n *  A Fragment which represents a structure.\n */\nexport class StructFragment extends NamedFragment {\n    /**\n     *  @private\n     */\n    constructor(guard, name, inputs) {\n        super(guard, \"struct\", name, inputs);\n        Object.defineProperty(this, internal, { value: StructFragmentInternal });\n    }\n    /**\n     *  Returns a string representation of this struct as %%format%%.\n     */\n    format() {\n        throw new Error(\"@TODO\");\n    }\n    /**\n     *  Returns a new **StructFragment** for %%obj%%.\n     */\n    static from(obj) {\n        if (typeof (obj) === \"string\") {\n            try {\n                return StructFragment.from(lex(obj));\n            }\n            catch (error) {\n                assertArgument(false, \"invalid struct fragment\", \"obj\", obj);\n            }\n        }\n        else if (obj instanceof TokenString) {\n            const name = consumeName(\"struct\", obj);\n            const inputs = consumeParams(obj);\n            consumeEoi(obj);\n            return new StructFragment(_guard, name, inputs);\n        }\n        return new StructFragment(_guard, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);\n    }\n    // @TODO: fix this return type\n    /**\n     *  Returns ``true`` and provides a type guard if %%value%% is a\n     *  **StructFragment**.\n     */\n    static isFragment(value) {\n        return (value && value[internal] === StructFragmentInternal);\n    }\n}\n//# sourceMappingURL=fragments.js.map","/**\n *  When sending values to or receiving values from a [[Contract]], the\n *  data is generally encoded using the [ABI standard](link-solc-abi).\n *\n *  The AbiCoder provides a utility to encode values to ABI data and\n *  decode values from ABI data.\n *\n *  Most of the time, developers should favour the [[Contract]] class,\n *  which further abstracts a lot of the finer details of ABI data.\n *\n *  @_section api/abi/abi-coder:ABI Encoding\n */\n// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI\nimport { assertArgumentCount, assertArgument } from \"../utils/index.js\";\nimport { Reader, Writer } from \"./coders/abstract-coder.js\";\nimport { AddressCoder } from \"./coders/address.js\";\nimport { ArrayCoder } from \"./coders/array.js\";\nimport { BooleanCoder } from \"./coders/boolean.js\";\nimport { BytesCoder } from \"./coders/bytes.js\";\nimport { FixedBytesCoder } from \"./coders/fixed-bytes.js\";\nimport { NullCoder } from \"./coders/null.js\";\nimport { NumberCoder } from \"./coders/number.js\";\nimport { StringCoder } from \"./coders/string.js\";\nimport { TupleCoder } from \"./coders/tuple.js\";\nimport { ParamType } from \"./fragments.js\";\nimport { getAddress } from \"../address/index.js\";\nimport { getBytes, hexlify, makeError } from \"../utils/index.js\";\n// https://docs.soliditylang.org/en/v0.8.17/control-structures.html\nconst PanicReasons = new Map();\nPanicReasons.set(0x00, \"GENERIC_PANIC\");\nPanicReasons.set(0x01, \"ASSERT_FALSE\");\nPanicReasons.set(0x11, \"OVERFLOW\");\nPanicReasons.set(0x12, \"DIVIDE_BY_ZERO\");\nPanicReasons.set(0x21, \"ENUM_RANGE_ERROR\");\nPanicReasons.set(0x22, \"BAD_STORAGE_DATA\");\nPanicReasons.set(0x31, \"STACK_UNDERFLOW\");\nPanicReasons.set(0x32, \"ARRAY_RANGE_ERROR\");\nPanicReasons.set(0x41, \"OUT_OF_MEMORY\");\nPanicReasons.set(0x51, \"UNINITIALIZED_FUNCTION_CALL\");\nconst paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);\nconst paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);\nlet defaultCoder = null;\nlet defaultMaxInflation = 1024;\nfunction getBuiltinCallException(action, tx, data, abiCoder) {\n    let message = \"missing revert data\";\n    let reason = null;\n    const invocation = null;\n    let revert = null;\n    if (data) {\n        message = \"execution reverted\";\n        const bytes = getBytes(data);\n        data = hexlify(data);\n        if (bytes.length === 0) {\n            message += \" (no data present; likely require(false) occurred\";\n            reason = \"require(false)\";\n        }\n        else if (bytes.length % 32 !== 4) {\n            message += \" (could not decode reason; invalid data length)\";\n        }\n        else if (hexlify(bytes.slice(0, 4)) === \"0x08c379a0\") {\n            // Error(string)\n            try {\n                reason = abiCoder.decode([\"string\"], bytes.slice(4))[0];\n                revert = {\n                    signature: \"Error(string)\",\n                    name: \"Error\",\n                    args: [reason]\n                };\n                message += `: ${JSON.stringify(reason)}`;\n            }\n            catch (error) {\n                message += \" (could not decode reason; invalid string data)\";\n            }\n        }\n        else if (hexlify(bytes.slice(0, 4)) === \"0x4e487b71\") {\n            // Panic(uint256)\n            try {\n                const code = Number(abiCoder.decode([\"uint256\"], bytes.slice(4))[0]);\n                revert = {\n                    signature: \"Panic(uint256)\",\n                    name: \"Panic\",\n                    args: [code]\n                };\n                reason = `Panic due to ${PanicReasons.get(code) || \"UNKNOWN\"}(${code})`;\n                message += `: ${reason}`;\n            }\n            catch (error) {\n                message += \" (could not decode panic code)\";\n            }\n        }\n        else {\n            message += \" (unknown custom error)\";\n        }\n    }\n    const transaction = {\n        to: (tx.to ? getAddress(tx.to) : null),\n        data: (tx.data || \"0x\")\n    };\n    if (tx.from) {\n        transaction.from = getAddress(tx.from);\n    }\n    return makeError(message, \"CALL_EXCEPTION\", {\n        action, data, reason, transaction, invocation, revert\n    });\n}\n/**\n *  The **AbiCoder** is a low-level class responsible for encoding JavaScript\n *  values into binary data and decoding binary data into JavaScript values.\n */\nexport class AbiCoder {\n    #getCoder(param) {\n        if (param.isArray()) {\n            return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name);\n        }\n        if (param.isTuple()) {\n            return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name);\n        }\n        switch (param.baseType) {\n            case \"address\":\n                return new AddressCoder(param.name);\n            case \"bool\":\n                return new BooleanCoder(param.name);\n            case \"string\":\n                return new StringCoder(param.name);\n            case \"bytes\":\n                return new BytesCoder(param.name);\n            case \"\":\n                return new NullCoder(param.name);\n        }\n        // u?int[0-9]*\n        let match = param.type.match(paramTypeNumber);\n        if (match) {\n            let size = parseInt(match[2] || \"256\");\n            assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, \"invalid \" + match[1] + \" bit length\", \"param\", param);\n            return new NumberCoder(size / 8, (match[1] === \"int\"), param.name);\n        }\n        // bytes[0-9]+\n        match = param.type.match(paramTypeBytes);\n        if (match) {\n            let size = parseInt(match[1]);\n            assertArgument(size !== 0 && size <= 32, \"invalid bytes length\", \"param\", param);\n            return new FixedBytesCoder(size, param.name);\n        }\n        assertArgument(false, \"invalid type\", \"type\", param.type);\n    }\n    /**\n     *  Get the default values for the given %%types%%.\n     *\n     *  For example, a ``uint`` is by default ``0`` and ``bool``\n     *  is by default ``false``.\n     */\n    getDefaultValue(types) {\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.defaultValue();\n    }\n    /**\n     *  Encode the %%values%% as the %%types%% into ABI data.\n     *\n     *  @returns DataHexstring\n     */\n    encode(types, values) {\n        assertArgumentCount(values.length, types.length, \"types/values length mismatch\");\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = (new TupleCoder(coders, \"_\"));\n        const writer = new Writer();\n        coder.encode(writer, values);\n        return writer.data;\n    }\n    /**\n     *  Decode the ABI %%data%% as the %%types%% into values.\n     *\n     *  If %%loose%% decoding is enabled, then strict padding is\n     *  not enforced. Some older versions of Solidity incorrectly\n     *  padded event data emitted from ``external`` functions.\n     */\n    decode(types, data, loose) {\n        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));\n        const coder = new TupleCoder(coders, \"_\");\n        return coder.decode(new Reader(data, loose, defaultMaxInflation));\n    }\n    static _setDefaultMaxInflation(value) {\n        assertArgument(typeof (value) === \"number\" && Number.isInteger(value), \"invalid defaultMaxInflation factor\", \"value\", value);\n        defaultMaxInflation = value;\n    }\n    /**\n     *  Returns the shared singleton instance of a default [[AbiCoder]].\n     *\n     *  On the first call, the instance is created internally.\n     */\n    static defaultAbiCoder() {\n        if (defaultCoder == null) {\n            defaultCoder = new AbiCoder();\n        }\n        return defaultCoder;\n    }\n    /**\n     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given\n     *  result %%data%% for the [[CallExceptionAction]] %%action%% against\n     *  the Transaction %%tx%%.\n     */\n    static getBuiltinCallException(action, tx, data) {\n        return getBuiltinCallException(action, tx, data, AbiCoder.defaultAbiCoder());\n    }\n}\n//# sourceMappingURL=abi-coder.js.map","/**\n *  The Interface class is a low-level class that accepts an\n *  ABI and provides all the necessary functionality to encode\n *  and decode paramaters to and results from methods, events\n *  and errors.\n *\n *  It also provides several convenience methods to automatically\n *  search and find matching transactions and events to parse them.\n *\n *  @_subsection api/abi:Interfaces  [interfaces]\n */\nimport { keccak256 } from \"../crypto/index.js\";\nimport { id } from \"../hash/index.js\";\nimport { concat, dataSlice, getBigInt, getBytes, getBytesCopy, hexlify, zeroPadBytes, zeroPadValue, isHexString, defineProperties, assertArgument, toBeHex, assert } from \"../utils/index.js\";\nimport { AbiCoder } from \"./abi-coder.js\";\nimport { checkResultErrors, Result } from \"./coders/abstract-coder.js\";\nimport { ConstructorFragment, ErrorFragment, EventFragment, Fragment, FunctionFragment, ParamType } from \"./fragments.js\";\nimport { Typed } from \"./typed.js\";\nexport { checkResultErrors, Result };\n/**\n *  When using the [[Interface-parseLog]] to automatically match a Log to its event\n *  for parsing, a **LogDescription** is returned.\n */\nexport class LogDescription {\n    /**\n     *  The matching fragment for the ``topic0``.\n     */\n    fragment;\n    /**\n     *  The name of the Event.\n     */\n    name;\n    /**\n     *  The full Event signature.\n     */\n    signature;\n    /**\n     *  The topic hash for the Event.\n     */\n    topic;\n    /**\n     *  The arguments passed into the Event with ``emit``.\n     */\n    args;\n    /**\n     *  @_ignore:\n     */\n    constructor(fragment, topic, args) {\n        const name = fragment.name, signature = fragment.format();\n        defineProperties(this, {\n            fragment, name, signature, topic, args\n        });\n    }\n}\n/**\n *  When using the [[Interface-parseTransaction]] to automatically match\n *  a transaction data to its function for parsing,\n *  a **TransactionDescription** is returned.\n */\nexport class TransactionDescription {\n    /**\n     *  The matching fragment from the transaction ``data``.\n     */\n    fragment;\n    /**\n     *  The name of the Function from the transaction ``data``.\n     */\n    name;\n    /**\n     *  The arguments passed to the Function from the transaction ``data``.\n     */\n    args;\n    /**\n     *  The full Function signature from the transaction ``data``.\n     */\n    signature;\n    /**\n     *  The selector for the Function from the transaction ``data``.\n     */\n    selector;\n    /**\n     *  The ``value`` (in wei) from the transaction.\n     */\n    value;\n    /**\n     *  @_ignore:\n     */\n    constructor(fragment, selector, args, value) {\n        const name = fragment.name, signature = fragment.format();\n        defineProperties(this, {\n            fragment, name, args, signature, selector, value\n        });\n    }\n}\n/**\n *  When using the [[Interface-parseError]] to automatically match an\n *  error for a call result for parsing, an **ErrorDescription** is returned.\n */\nexport class ErrorDescription {\n    /**\n     *  The matching fragment.\n     */\n    fragment;\n    /**\n     *  The name of the Error.\n     */\n    name;\n    /**\n     *  The arguments passed to the Error with ``revert``.\n     */\n    args;\n    /**\n     *  The full Error signature.\n     */\n    signature;\n    /**\n     *  The selector for the Error.\n     */\n    selector;\n    /**\n     *  @_ignore:\n     */\n    constructor(fragment, selector, args) {\n        const name = fragment.name, signature = fragment.format();\n        defineProperties(this, {\n            fragment, name, args, signature, selector\n        });\n    }\n}\n/**\n *  An **Indexed** is used as a value when a value that does not\n *  fit within a topic (i.e. not a fixed-length, 32-byte type). It\n *  is the ``keccak256`` of the value, and used for types such as\n *  arrays, tuples, bytes and strings.\n */\nexport class Indexed {\n    /**\n     *  The ``keccak256`` of the value logged.\n     */\n    hash;\n    /**\n     *  @_ignore:\n     */\n    _isIndexed;\n    /**\n     *  Returns ``true`` if %%value%% is an **Indexed**.\n     *\n     *  This provides a Type Guard for property access.\n     */\n    static isIndexed(value) {\n        return !!(value && value._isIndexed);\n    }\n    /**\n     *  @_ignore:\n     */\n    constructor(hash) {\n        defineProperties(this, { hash, _isIndexed: true });\n    }\n}\n// https://docs.soliditylang.org/en/v0.8.13/control-structures.html?highlight=panic#panic-via-assert-and-error-via-require\nconst PanicReasons = {\n    \"0\": \"generic panic\",\n    \"1\": \"assert(false)\",\n    \"17\": \"arithmetic overflow\",\n    \"18\": \"division or modulo by zero\",\n    \"33\": \"enum overflow\",\n    \"34\": \"invalid encoded storage byte array accessed\",\n    \"49\": \"out-of-bounds array access; popping on an empty array\",\n    \"50\": \"out-of-bounds access of an array or bytesN\",\n    \"65\": \"out of memory\",\n    \"81\": \"uninitialized function\",\n};\nconst BuiltinErrors = {\n    \"0x08c379a0\": {\n        signature: \"Error(string)\",\n        name: \"Error\",\n        inputs: [\"string\"],\n        reason: (message) => {\n            return `reverted with reason string ${JSON.stringify(message)}`;\n        }\n    },\n    \"0x4e487b71\": {\n        signature: \"Panic(uint256)\",\n        name: \"Panic\",\n        inputs: [\"uint256\"],\n        reason: (code) => {\n            let reason = \"unknown panic code\";\n            if (code >= 0 && code <= 0xff && PanicReasons[code.toString()]) {\n                reason = PanicReasons[code.toString()];\n            }\n            return `reverted with panic code 0x${code.toString(16)} (${reason})`;\n        }\n    }\n};\n/**\n *  An Interface abstracts many of the low-level details for\n *  encoding and decoding the data on the blockchain.\n *\n *  An ABI provides information on how to encode data to send to\n *  a Contract, how to decode the results and events and how to\n *  interpret revert errors.\n *\n *  The ABI can be specified by [any supported format](InterfaceAbi).\n */\nexport class Interface {\n    /**\n     *  All the Contract ABI members (i.e. methods, events, errors, etc).\n     */\n    fragments;\n    /**\n     *  The Contract constructor.\n     */\n    deploy;\n    /**\n     *  The Fallback method, if any.\n     */\n    fallback;\n    /**\n     *  If receiving ether is supported.\n     */\n    receive;\n    #errors;\n    #events;\n    #functions;\n    //    #structs: Map<string, StructFragment>;\n    #abiCoder;\n    /**\n     *  Create a new Interface for the %%fragments%%.\n     */\n    constructor(fragments) {\n        let abi = [];\n        if (typeof (fragments) === \"string\") {\n            abi = JSON.parse(fragments);\n        }\n        else {\n            abi = fragments;\n        }\n        this.#functions = new Map();\n        this.#errors = new Map();\n        this.#events = new Map();\n        //        this.#structs = new Map();\n        const frags = [];\n        for (const a of abi) {\n            try {\n                frags.push(Fragment.from(a));\n            }\n            catch (error) {\n                console.log(`[Warning] Invalid Fragment ${JSON.stringify(a)}:`, error.message);\n            }\n        }\n        defineProperties(this, {\n            fragments: Object.freeze(frags)\n        });\n        let fallback = null;\n        let receive = false;\n        this.#abiCoder = this.getAbiCoder();\n        // Add all fragments by their signature\n        this.fragments.forEach((fragment, index) => {\n            let bucket;\n            switch (fragment.type) {\n                case \"constructor\":\n                    if (this.deploy) {\n                        console.log(\"duplicate definition - constructor\");\n                        return;\n                    }\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    defineProperties(this, { deploy: fragment });\n                    return;\n                case \"fallback\":\n                    if (fragment.inputs.length === 0) {\n                        receive = true;\n                    }\n                    else {\n                        assertArgument(!fallback || fragment.payable !== fallback.payable, \"conflicting fallback fragments\", `fragments[${index}]`, fragment);\n                        fallback = fragment;\n                        receive = fallback.payable;\n                    }\n                    return;\n                case \"function\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    //checkNames(fragment, \"output\", (<FunctionFragment>fragment).outputs);\n                    bucket = this.#functions;\n                    break;\n                case \"event\":\n                    //checkNames(fragment, \"input\", fragment.inputs);\n                    bucket = this.#events;\n                    break;\n                case \"error\":\n                    bucket = this.#errors;\n                    break;\n                default:\n                    return;\n            }\n            // Two identical entries; ignore it\n            const signature = fragment.format();\n            if (bucket.has(signature)) {\n                return;\n            }\n            bucket.set(signature, fragment);\n        });\n        // If we do not have a constructor add a default\n        if (!this.deploy) {\n            defineProperties(this, {\n                deploy: ConstructorFragment.from(\"constructor()\")\n            });\n        }\n        defineProperties(this, { fallback, receive });\n    }\n    /**\n     *  Returns the entire Human-Readable ABI, as an array of\n     *  signatures, optionally as %%minimal%% strings, which\n     *  removes parameter names and unneceesary spaces.\n     */\n    format(minimal) {\n        const format = (minimal ? \"minimal\" : \"full\");\n        const abi = this.fragments.map((f) => f.format(format));\n        return abi;\n    }\n    /**\n     *  Return the JSON-encoded ABI. This is the format Solidiy\n     *  returns.\n     */\n    formatJson() {\n        const abi = this.fragments.map((f) => f.format(\"json\"));\n        // We need to re-bundle the JSON fragments a bit\n        return JSON.stringify(abi.map((j) => JSON.parse(j)));\n    }\n    /**\n     *  The ABI coder that will be used to encode and decode binary\n     *  data.\n     */\n    getAbiCoder() {\n        return AbiCoder.defaultAbiCoder();\n    }\n    // Find a function definition by any means necessary (unless it is ambiguous)\n    #getFunction(key, values, forceUnique) {\n        // Selector\n        if (isHexString(key)) {\n            const selector = key.toLowerCase();\n            for (const fragment of this.#functions.values()) {\n                if (selector === fragment.selector) {\n                    return fragment;\n                }\n            }\n            return null;\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (key.indexOf(\"(\") === -1) {\n            const matching = [];\n            for (const [name, fragment] of this.#functions) {\n                if (name.split(\"(\" /* fix:) */)[0] === key) {\n                    matching.push(fragment);\n                }\n            }\n            if (values) {\n                const lastValue = (values.length > 0) ? values[values.length - 1] : null;\n                let valueLength = values.length;\n                let allowOptions = true;\n                if (Typed.isTyped(lastValue) && lastValue.type === \"overrides\") {\n                    allowOptions = false;\n                    valueLength--;\n                }\n                // Remove all matches that don't have a compatible length. The args\n                // may contain an overrides, so the match may have n or n - 1 parameters\n                for (let i = matching.length - 1; i >= 0; i--) {\n                    const inputs = matching[i].inputs.length;\n                    if (inputs !== valueLength && (!allowOptions || inputs !== valueLength - 1)) {\n                        matching.splice(i, 1);\n                    }\n                }\n                // Remove all matches that don't match the Typed signature\n                for (let i = matching.length - 1; i >= 0; i--) {\n                    const inputs = matching[i].inputs;\n                    for (let j = 0; j < values.length; j++) {\n                        // Not a typed value\n                        if (!Typed.isTyped(values[j])) {\n                            continue;\n                        }\n                        // We are past the inputs\n                        if (j >= inputs.length) {\n                            if (values[j].type === \"overrides\") {\n                                continue;\n                            }\n                            matching.splice(i, 1);\n                            break;\n                        }\n                        // Make sure the value type matches the input type\n                        if (values[j].type !== inputs[j].baseType) {\n                            matching.splice(i, 1);\n                            break;\n                        }\n                    }\n                }\n            }\n            // We found a single matching signature with an overrides, but the\n            // last value is something that cannot possibly be an options\n            if (matching.length === 1 && values && values.length !== matching[0].inputs.length) {\n                const lastArg = values[values.length - 1];\n                if (lastArg == null || Array.isArray(lastArg) || typeof (lastArg) !== \"object\") {\n                    matching.splice(0, 1);\n                }\n            }\n            if (matching.length === 0) {\n                return null;\n            }\n            if (matching.length > 1 && forceUnique) {\n                const matchStr = matching.map((m) => JSON.stringify(m.format())).join(\", \");\n                assertArgument(false, `ambiguous function description (i.e. matches ${matchStr})`, \"key\", key);\n            }\n            return matching[0];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.#functions.get(FunctionFragment.from(key).format());\n        if (result) {\n            return result;\n        }\n        return null;\n    }\n    /**\n     *  Get the function name for %%key%%, which may be a function selector,\n     *  function name or function signature that belongs to the ABI.\n     */\n    getFunctionName(key) {\n        const fragment = this.#getFunction(key, null, false);\n        assertArgument(fragment, \"no matching function\", \"key\", key);\n        return fragment.name;\n    }\n    /**\n     *  Returns true if %%key%% (a function selector, function name or\n     *  function signature) is present in the ABI.\n     *\n     *  In the case of a function name, the name may be ambiguous, so\n     *  accessing the [[FunctionFragment]] may require refinement.\n     */\n    hasFunction(key) {\n        return !!this.#getFunction(key, null, false);\n    }\n    /**\n     *  Get the [[FunctionFragment]] for %%key%%, which may be a function\n     *  selector, function name or function signature that belongs to the ABI.\n     *\n     *  If %%values%% is provided, it will use the Typed API to handle\n     *  ambiguous cases where multiple functions match by name.\n     *\n     *  If the %%key%% and %%values%% do not refine to a single function in\n     *  the ABI, this will throw.\n     */\n    getFunction(key, values) {\n        return this.#getFunction(key, values || null, true);\n    }\n    /**\n     *  Iterate over all functions, calling %%callback%%, sorted by their name.\n     */\n    forEachFunction(callback) {\n        const names = Array.from(this.#functions.keys());\n        names.sort((a, b) => a.localeCompare(b));\n        for (let i = 0; i < names.length; i++) {\n            const name = names[i];\n            callback((this.#functions.get(name)), i);\n        }\n    }\n    // Find an event definition by any means necessary (unless it is ambiguous)\n    #getEvent(key, values, forceUnique) {\n        // EventTopic\n        if (isHexString(key)) {\n            const eventTopic = key.toLowerCase();\n            for (const fragment of this.#events.values()) {\n                if (eventTopic === fragment.topicHash) {\n                    return fragment;\n                }\n            }\n            return null;\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (key.indexOf(\"(\") === -1) {\n            const matching = [];\n            for (const [name, fragment] of this.#events) {\n                if (name.split(\"(\" /* fix:) */)[0] === key) {\n                    matching.push(fragment);\n                }\n            }\n            if (values) {\n                // Remove all matches that don't have a compatible length.\n                for (let i = matching.length - 1; i >= 0; i--) {\n                    if (matching[i].inputs.length < values.length) {\n                        matching.splice(i, 1);\n                    }\n                }\n                // Remove all matches that don't match the Typed signature\n                for (let i = matching.length - 1; i >= 0; i--) {\n                    const inputs = matching[i].inputs;\n                    for (let j = 0; j < values.length; j++) {\n                        // Not a typed value\n                        if (!Typed.isTyped(values[j])) {\n                            continue;\n                        }\n                        // Make sure the value type matches the input type\n                        if (values[j].type !== inputs[j].baseType) {\n                            matching.splice(i, 1);\n                            break;\n                        }\n                    }\n                }\n            }\n            if (matching.length === 0) {\n                return null;\n            }\n            if (matching.length > 1 && forceUnique) {\n                const matchStr = matching.map((m) => JSON.stringify(m.format())).join(\", \");\n                assertArgument(false, `ambiguous event description (i.e. matches ${matchStr})`, \"key\", key);\n            }\n            return matching[0];\n        }\n        // Normalize the signature and lookup the function\n        const result = this.#events.get(EventFragment.from(key).format());\n        if (result) {\n            return result;\n        }\n        return null;\n    }\n    /**\n     *  Get the event name for %%key%%, which may be a topic hash,\n     *  event name or event signature that belongs to the ABI.\n     */\n    getEventName(key) {\n        const fragment = this.#getEvent(key, null, false);\n        assertArgument(fragment, \"no matching event\", \"key\", key);\n        return fragment.name;\n    }\n    /**\n     *  Returns true if %%key%% (an event topic hash, event name or\n     *  event signature) is present in the ABI.\n     *\n     *  In the case of an event name, the name may be ambiguous, so\n     *  accessing the [[EventFragment]] may require refinement.\n     */\n    hasEvent(key) {\n        return !!this.#getEvent(key, null, false);\n    }\n    /**\n     *  Get the [[EventFragment]] for %%key%%, which may be a topic hash,\n     *  event name or event signature that belongs to the ABI.\n     *\n     *  If %%values%% is provided, it will use the Typed API to handle\n     *  ambiguous cases where multiple events match by name.\n     *\n     *  If the %%key%% and %%values%% do not refine to a single event in\n     *  the ABI, this will throw.\n     */\n    getEvent(key, values) {\n        return this.#getEvent(key, values || null, true);\n    }\n    /**\n     *  Iterate over all events, calling %%callback%%, sorted by their name.\n     */\n    forEachEvent(callback) {\n        const names = Array.from(this.#events.keys());\n        names.sort((a, b) => a.localeCompare(b));\n        for (let i = 0; i < names.length; i++) {\n            const name = names[i];\n            callback((this.#events.get(name)), i);\n        }\n    }\n    /**\n     *  Get the [[ErrorFragment]] for %%key%%, which may be an error\n     *  selector, error name or error signature that belongs to the ABI.\n     *\n     *  If %%values%% is provided, it will use the Typed API to handle\n     *  ambiguous cases where multiple errors match by name.\n     *\n     *  If the %%key%% and %%values%% do not refine to a single error in\n     *  the ABI, this will throw.\n     */\n    getError(key, values) {\n        if (isHexString(key)) {\n            const selector = key.toLowerCase();\n            if (BuiltinErrors[selector]) {\n                return ErrorFragment.from(BuiltinErrors[selector].signature);\n            }\n            for (const fragment of this.#errors.values()) {\n                if (selector === fragment.selector) {\n                    return fragment;\n                }\n            }\n            return null;\n        }\n        // It is a bare name, look up the function (will return null if ambiguous)\n        if (key.indexOf(\"(\") === -1) {\n            const matching = [];\n            for (const [name, fragment] of this.#errors) {\n                if (name.split(\"(\" /* fix:) */)[0] === key) {\n                    matching.push(fragment);\n                }\n            }\n            if (matching.length === 0) {\n                if (key === \"Error\") {\n                    return ErrorFragment.from(\"error Error(string)\");\n                }\n                if (key === \"Panic\") {\n                    return ErrorFragment.from(\"error Panic(uint256)\");\n                }\n                return null;\n            }\n            else if (matching.length > 1) {\n                const matchStr = matching.map((m) => JSON.stringify(m.format())).join(\", \");\n                assertArgument(false, `ambiguous error description (i.e. ${matchStr})`, \"name\", key);\n            }\n            return matching[0];\n        }\n        // Normalize the signature and lookup the function\n        key = ErrorFragment.from(key).format();\n        if (key === \"Error(string)\") {\n            return ErrorFragment.from(\"error Error(string)\");\n        }\n        if (key === \"Panic(uint256)\") {\n            return ErrorFragment.from(\"error Panic(uint256)\");\n        }\n        const result = this.#errors.get(key);\n        if (result) {\n            return result;\n        }\n        return null;\n    }\n    /**\n     *  Iterate over all errors, calling %%callback%%, sorted by their name.\n     */\n    forEachError(callback) {\n        const names = Array.from(this.#errors.keys());\n        names.sort((a, b) => a.localeCompare(b));\n        for (let i = 0; i < names.length; i++) {\n            const name = names[i];\n            callback((this.#errors.get(name)), i);\n        }\n    }\n    // Get the 4-byte selector used by Solidity to identify a function\n    /*\ngetSelector(fragment: ErrorFragment | FunctionFragment): string {\n    if (typeof(fragment) === \"string\") {\n        const matches: Array<Fragment> = [ ];\n\n        try { matches.push(this.getFunction(fragment)); } catch (error) { }\n        try { matches.push(this.getError(<string>fragment)); } catch (_) { }\n\n        if (matches.length === 0) {\n            logger.throwArgumentError(\"unknown fragment\", \"key\", fragment);\n        } else if (matches.length > 1) {\n            logger.throwArgumentError(\"ambiguous fragment matches function and error\", \"key\", fragment);\n        }\n\n        fragment = matches[0];\n    }\n\n    return dataSlice(id(fragment.format()), 0, 4);\n}\n    */\n    // Get the 32-byte topic hash used by Solidity to identify an event\n    /*\n    getEventTopic(fragment: EventFragment): string {\n        //if (typeof(fragment) === \"string\") { fragment = this.getEvent(eventFragment); }\n        return id(fragment.format());\n    }\n    */\n    _decodeParams(params, data) {\n        return this.#abiCoder.decode(params, data);\n    }\n    _encodeParams(params, values) {\n        return this.#abiCoder.encode(params, values);\n    }\n    /**\n     *  Encodes a ``tx.data`` object for deploying the Contract with\n     *  the %%values%% as the constructor arguments.\n     */\n    encodeDeploy(values) {\n        return this._encodeParams(this.deploy.inputs, values || []);\n    }\n    /**\n     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the\n     *  specified error (see [[getError]] for valid values for\n     *  %%key%%).\n     *\n     *  Most developers should prefer the [[parseCallResult]] method instead,\n     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the\n     *  corresponding error.\n     */\n    decodeErrorResult(fragment, data) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getError(fragment);\n            assertArgument(f, \"unknown error\", \"fragment\", fragment);\n            fragment = f;\n        }\n        assertArgument(dataSlice(data, 0, 4) === fragment.selector, `data signature does not match error ${fragment.name}.`, \"data\", data);\n        return this._decodeParams(fragment.inputs, dataSlice(data, 4));\n    }\n    /**\n     *  Encodes the transaction revert data for a call result that\n     *  reverted from the the Contract with the sepcified %%error%%\n     *  (see [[getError]] for valid values for %%fragment%%) with the %%values%%.\n     *\n     *  This is generally not used by most developers, unless trying to mock\n     *  a result from a Contract.\n     */\n    encodeErrorResult(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getError(fragment);\n            assertArgument(f, \"unknown error\", \"fragment\", fragment);\n            fragment = f;\n        }\n        return concat([\n            fragment.selector,\n            this._encodeParams(fragment.inputs, values || [])\n        ]);\n    }\n    /**\n     *  Decodes the %%data%% from a transaction ``tx.data`` for\n     *  the function specified (see [[getFunction]] for valid values\n     *  for %%fragment%%).\n     *\n     *  Most developers should prefer the [[parseTransaction]] method\n     *  instead, which will automatically detect the fragment.\n     */\n    decodeFunctionData(fragment, data) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getFunction(fragment);\n            assertArgument(f, \"unknown function\", \"fragment\", fragment);\n            fragment = f;\n        }\n        assertArgument(dataSlice(data, 0, 4) === fragment.selector, `data signature does not match function ${fragment.name}.`, \"data\", data);\n        return this._decodeParams(fragment.inputs, dataSlice(data, 4));\n    }\n    /**\n     *  Encodes the ``tx.data`` for a transaction that calls the function\n     *  specified (see [[getFunction]] for valid values for %%fragment%%) with\n     *  the %%values%%.\n     */\n    encodeFunctionData(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getFunction(fragment);\n            assertArgument(f, \"unknown function\", \"fragment\", fragment);\n            fragment = f;\n        }\n        return concat([\n            fragment.selector,\n            this._encodeParams(fragment.inputs, values || [])\n        ]);\n    }\n    /**\n     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the\n     *  specified function (see [[getFunction]] for valid values for\n     *  %%key%%).\n     *\n     *  Most developers should prefer the [[parseCallResult]] method instead,\n     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the\n     *  corresponding error.\n     */\n    decodeFunctionResult(fragment, data) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getFunction(fragment);\n            assertArgument(f, \"unknown function\", \"fragment\", fragment);\n            fragment = f;\n        }\n        let message = \"invalid length for result data\";\n        const bytes = getBytesCopy(data);\n        if ((bytes.length % 32) === 0) {\n            try {\n                return this.#abiCoder.decode(fragment.outputs, bytes);\n            }\n            catch (error) {\n                message = \"could not decode result data\";\n            }\n        }\n        // Call returned data with no error, but the data is junk\n        assert(false, message, \"BAD_DATA\", {\n            value: hexlify(bytes),\n            info: { method: fragment.name, signature: fragment.format() }\n        });\n    }\n    makeError(_data, tx) {\n        const data = getBytes(_data, \"data\");\n        const error = AbiCoder.getBuiltinCallException(\"call\", tx, data);\n        // Not a built-in error; try finding a custom error\n        const customPrefix = \"execution reverted (unknown custom error)\";\n        if (error.message.startsWith(customPrefix)) {\n            const selector = hexlify(data.slice(0, 4));\n            const ef = this.getError(selector);\n            if (ef) {\n                try {\n                    const args = this.#abiCoder.decode(ef.inputs, data.slice(4));\n                    error.revert = {\n                        name: ef.name, signature: ef.format(), args\n                    };\n                    error.reason = error.revert.signature;\n                    error.message = `execution reverted: ${error.reason}`;\n                }\n                catch (e) {\n                    error.message = `execution reverted (coult not decode custom error)`;\n                }\n            }\n        }\n        // Add the invocation, if available\n        const parsed = this.parseTransaction(tx);\n        if (parsed) {\n            error.invocation = {\n                method: parsed.name,\n                signature: parsed.signature,\n                args: parsed.args\n            };\n        }\n        return error;\n    }\n    /**\n     *  Encodes the result data (e.g. from an ``eth_call``) for the\n     *  specified function (see [[getFunction]] for valid values\n     *  for %%fragment%%) with %%values%%.\n     *\n     *  This is generally not used by most developers, unless trying to mock\n     *  a result from a Contract.\n     */\n    encodeFunctionResult(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getFunction(fragment);\n            assertArgument(f, \"unknown function\", \"fragment\", fragment);\n            fragment = f;\n        }\n        return hexlify(this.#abiCoder.encode(fragment.outputs, values || []));\n    }\n    /*\n        spelunk(inputs: Array<ParamType>, values: ReadonlyArray<any>, processfunc: (type: string, value: any) => Promise<any>): Promise<Array<any>> {\n            const promises: Array<Promise<>> = [ ];\n            const process = function(type: ParamType, value: any): any {\n                if (type.baseType === \"array\") {\n                    return descend(type.child\n                }\n                if (type. === \"address\") {\n                }\n            };\n    \n            const descend = function (inputs: Array<ParamType>, values: ReadonlyArray<any>) {\n                if (inputs.length !== values.length) { throw new Error(\"length mismatch\"); }\n                \n            };\n    \n            const result: Array<any> = [ ];\n            values.forEach((value, index) => {\n                if (value == null) {\n                    topics.push(null);\n                } else if (param.baseType === \"array\" || param.baseType === \"tuple\") {\n                    logger.throwArgumentError(\"filtering with tuples or arrays not supported\", (\"contract.\" + param.name), value);\n                } else if (Array.isArray(value)) {\n                    topics.push(value.map((value) => encodeTopic(param, value)));\n                } else {\n                    topics.push(encodeTopic(param, value));\n                }\n            });\n        }\n    */\n    // Create the filter for the event with search criteria (e.g. for eth_filterLog)\n    encodeFilterTopics(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getEvent(fragment);\n            assertArgument(f, \"unknown event\", \"eventFragment\", fragment);\n            fragment = f;\n        }\n        assert(values.length <= fragment.inputs.length, `too many arguments for ${fragment.format()}`, \"UNEXPECTED_ARGUMENT\", { count: values.length, expectedCount: fragment.inputs.length });\n        const topics = [];\n        if (!fragment.anonymous) {\n            topics.push(fragment.topicHash);\n        }\n        // @TODO: Use the coders for this; to properly support tuples, etc.\n        const encodeTopic = (param, value) => {\n            if (param.type === \"string\") {\n                return id(value);\n            }\n            else if (param.type === \"bytes\") {\n                return keccak256(hexlify(value));\n            }\n            if (param.type === \"bool\" && typeof (value) === \"boolean\") {\n                value = (value ? \"0x01\" : \"0x00\");\n            }\n            else if (param.type.match(/^u?int/)) {\n                value = toBeHex(value); // @TODO: Should this toTwos??\n            }\n            else if (param.type.match(/^bytes/)) {\n                value = zeroPadBytes(value, 32);\n            }\n            else if (param.type === \"address\") {\n                // Check addresses are valid\n                this.#abiCoder.encode([\"address\"], [value]);\n            }\n            return zeroPadValue(hexlify(value), 32);\n        };\n        values.forEach((value, index) => {\n            const param = fragment.inputs[index];\n            if (!param.indexed) {\n                assertArgument(value == null, \"cannot filter non-indexed parameters; must be null\", (\"contract.\" + param.name), value);\n                return;\n            }\n            if (value == null) {\n                topics.push(null);\n            }\n            else if (param.baseType === \"array\" || param.baseType === \"tuple\") {\n                assertArgument(false, \"filtering with tuples or arrays not supported\", (\"contract.\" + param.name), value);\n            }\n            else if (Array.isArray(value)) {\n                topics.push(value.map((value) => encodeTopic(param, value)));\n            }\n            else {\n                topics.push(encodeTopic(param, value));\n            }\n        });\n        // Trim off trailing nulls\n        while (topics.length && topics[topics.length - 1] === null) {\n            topics.pop();\n        }\n        return topics;\n    }\n    encodeEventLog(fragment, values) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getEvent(fragment);\n            assertArgument(f, \"unknown event\", \"eventFragment\", fragment);\n            fragment = f;\n        }\n        const topics = [];\n        const dataTypes = [];\n        const dataValues = [];\n        if (!fragment.anonymous) {\n            topics.push(fragment.topicHash);\n        }\n        assertArgument(values.length === fragment.inputs.length, \"event arguments/values mismatch\", \"values\", values);\n        fragment.inputs.forEach((param, index) => {\n            const value = values[index];\n            if (param.indexed) {\n                if (param.type === \"string\") {\n                    topics.push(id(value));\n                }\n                else if (param.type === \"bytes\") {\n                    topics.push(keccak256(value));\n                }\n                else if (param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    // @TODO\n                    throw new Error(\"not implemented\");\n                }\n                else {\n                    topics.push(this.#abiCoder.encode([param.type], [value]));\n                }\n            }\n            else {\n                dataTypes.push(param);\n                dataValues.push(value);\n            }\n        });\n        return {\n            data: this.#abiCoder.encode(dataTypes, dataValues),\n            topics: topics\n        };\n    }\n    // Decode a filter for the event and the search criteria\n    decodeEventLog(fragment, data, topics) {\n        if (typeof (fragment) === \"string\") {\n            const f = this.getEvent(fragment);\n            assertArgument(f, \"unknown event\", \"eventFragment\", fragment);\n            fragment = f;\n        }\n        if (topics != null && !fragment.anonymous) {\n            const eventTopic = fragment.topicHash;\n            assertArgument(isHexString(topics[0], 32) && topics[0].toLowerCase() === eventTopic, \"fragment/topic mismatch\", \"topics[0]\", topics[0]);\n            topics = topics.slice(1);\n        }\n        const indexed = [];\n        const nonIndexed = [];\n        const dynamic = [];\n        fragment.inputs.forEach((param, index) => {\n            if (param.indexed) {\n                if (param.type === \"string\" || param.type === \"bytes\" || param.baseType === \"tuple\" || param.baseType === \"array\") {\n                    indexed.push(ParamType.from({ type: \"bytes32\", name: param.name }));\n                    dynamic.push(true);\n                }\n                else {\n                    indexed.push(param);\n                    dynamic.push(false);\n                }\n            }\n            else {\n                nonIndexed.push(param);\n                dynamic.push(false);\n            }\n        });\n        const resultIndexed = (topics != null) ? this.#abiCoder.decode(indexed, concat(topics)) : null;\n        const resultNonIndexed = this.#abiCoder.decode(nonIndexed, data, true);\n        //const result: (Array<any> & { [ key: string ]: any }) = [ ];\n        const values = [];\n        const keys = [];\n        let nonIndexedIndex = 0, indexedIndex = 0;\n        fragment.inputs.forEach((param, index) => {\n            let value = null;\n            if (param.indexed) {\n                if (resultIndexed == null) {\n                    value = new Indexed(null);\n                }\n                else if (dynamic[index]) {\n                    value = new Indexed(resultIndexed[indexedIndex++]);\n                }\n                else {\n                    try {\n                        value = resultIndexed[indexedIndex++];\n                    }\n                    catch (error) {\n                        value = error;\n                    }\n                }\n            }\n            else {\n                try {\n                    value = resultNonIndexed[nonIndexedIndex++];\n                }\n                catch (error) {\n                    value = error;\n                }\n            }\n            values.push(value);\n            keys.push(param.name || null);\n        });\n        return Result.fromItems(values, keys);\n    }\n    /**\n     *  Parses a transaction, finding the matching function and extracts\n     *  the parameter values along with other useful function details.\n     *\n     *  If the matching function cannot be found, return null.\n     */\n    parseTransaction(tx) {\n        const data = getBytes(tx.data, \"tx.data\");\n        const value = getBigInt((tx.value != null) ? tx.value : 0, \"tx.value\");\n        const fragment = this.getFunction(hexlify(data.slice(0, 4)));\n        if (!fragment) {\n            return null;\n        }\n        const args = this.#abiCoder.decode(fragment.inputs, data.slice(4));\n        return new TransactionDescription(fragment, fragment.selector, args, value);\n    }\n    parseCallResult(data) {\n        throw new Error(\"@TODO\");\n    }\n    /**\n     *  Parses a receipt log, finding the matching event and extracts\n     *  the parameter values along with other useful event details.\n     *\n     *  If the matching event cannot be found, returns null.\n     */\n    parseLog(log) {\n        const fragment = this.getEvent(log.topics[0]);\n        if (!fragment || fragment.anonymous) {\n            return null;\n        }\n        // @TODO: If anonymous, and the only method, and the input count matches, should we parse?\n        //        Probably not, because just because it is the only event in the ABI does\n        //        not mean we have the full ABI; maybe just a fragment?\n        return new LogDescription(fragment, fragment.topicHash, this.decodeEventLog(fragment, log.data, log.topics));\n    }\n    /**\n     *  Parses a revert data, finding the matching error and extracts\n     *  the parameter values along with other useful error details.\n     *\n     *  If the matching error cannot be found, returns null.\n     */\n    parseError(data) {\n        const hexData = hexlify(data);\n        const fragment = this.getError(dataSlice(hexData, 0, 4));\n        if (!fragment) {\n            return null;\n        }\n        const args = this.#abiCoder.decode(fragment.inputs, dataSlice(hexData, 4));\n        return new ErrorDescription(fragment, fragment.selector, args);\n    }\n    /**\n     *  Creates a new [[Interface]] from the ABI %%value%%.\n     *\n     *  The %%value%% may be provided as an existing [[Interface]] object,\n     *  a JSON-encoded ABI or any Human-Readable ABI format.\n     */\n    static from(value) {\n        // Already an Interface, which is immutable\n        if (value instanceof Interface) {\n            return value;\n        }\n        // JSON\n        if (typeof (value) === \"string\") {\n            return new Interface(JSON.parse(value));\n        }\n        // Maybe an interface from an older version, or from a symlinked copy\n        if (typeof (value.format) === \"function\") {\n            return new Interface(value.format(\"json\"));\n        }\n        // Array of fragments\n        return new Interface(value);\n    }\n}\n//# sourceMappingURL=interface.js.map","//import { resolveAddress } from \"@ethersproject/address\";\nimport { defineProperties, getBigInt, getNumber, hexlify, isBytesLike, resolveProperties, assert, assertArgument, isError, makeError } from \"../utils/index.js\";\nimport { accessListify } from \"../transaction/index.js\";\nconst BN_0 = BigInt(0);\n// -----------------------\nfunction getValue(value) {\n    if (value == null) {\n        return null;\n    }\n    return value;\n}\nfunction toJson(value) {\n    if (value == null) {\n        return null;\n    }\n    return value.toString();\n}\n// @TODO? <T extends FeeData = { }> implements Required<T>\n/**\n *  A **FeeData** wraps all the fee-related values associated with\n *  the network.\n */\nexport class FeeData {\n    /**\n     *  The gas price for legacy networks.\n     */\n    gasPrice;\n    /**\n     *  The maximum fee to pay per gas.\n     *\n     *  The base fee per gas is defined by the network and based on\n     *  congestion, increasing the cost during times of heavy load\n     *  and lowering when less busy.\n     *\n     *  The actual fee per gas will be the base fee for the block\n     *  and the priority fee, up to the max fee per gas.\n     *\n     *  This will be ``null`` on legacy networks (i.e. [pre-EIP-1559](link-eip-1559))\n     */\n    maxFeePerGas;\n    /**\n     *  The additional amout to pay per gas to encourage a validator\n     *  to include the transaction.\n     *\n     *  The purpose of this is to compensate the validator for the\n     *  adjusted risk for including a given transaction.\n     *\n     *  This will be ``null`` on legacy networks (i.e. [pre-EIP-1559](link-eip-1559))\n     */\n    maxPriorityFeePerGas;\n    /**\n     *  Creates a new FeeData for %%gasPrice%%, %%maxFeePerGas%% and\n     *  %%maxPriorityFeePerGas%%.\n     */\n    constructor(gasPrice, maxFeePerGas, maxPriorityFeePerGas) {\n        defineProperties(this, {\n            gasPrice: getValue(gasPrice),\n            maxFeePerGas: getValue(maxFeePerGas),\n            maxPriorityFeePerGas: getValue(maxPriorityFeePerGas)\n        });\n    }\n    /**\n     *  Returns a JSON-friendly value.\n     */\n    toJSON() {\n        const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this;\n        return {\n            _type: \"FeeData\",\n            gasPrice: toJson(gasPrice),\n            maxFeePerGas: toJson(maxFeePerGas),\n            maxPriorityFeePerGas: toJson(maxPriorityFeePerGas),\n        };\n    }\n}\n;\n/**\n *  Returns a copy of %%req%% with all properties coerced to their strict\n *  types.\n */\nexport function copyRequest(req) {\n    const result = {};\n    // These could be addresses, ENS names or Addressables\n    if (req.to) {\n        result.to = req.to;\n    }\n    if (req.from) {\n        result.from = req.from;\n    }\n    if (req.data) {\n        result.data = hexlify(req.data);\n    }\n    const bigIntKeys = \"chainId,gasLimit,gasPrice,maxFeePerBlobGas,maxFeePerGas,maxPriorityFeePerGas,value\".split(/,/);\n    for (const key of bigIntKeys) {\n        if (!(key in req) || req[key] == null) {\n            continue;\n        }\n        result[key] = getBigInt(req[key], `request.${key}`);\n    }\n    const numberKeys = \"type,nonce\".split(/,/);\n    for (const key of numberKeys) {\n        if (!(key in req) || req[key] == null) {\n            continue;\n        }\n        result[key] = getNumber(req[key], `request.${key}`);\n    }\n    if (req.accessList) {\n        result.accessList = accessListify(req.accessList);\n    }\n    if (\"blockTag\" in req) {\n        result.blockTag = req.blockTag;\n    }\n    if (\"enableCcipRead\" in req) {\n        result.enableCcipRead = !!req.enableCcipRead;\n    }\n    if (\"customData\" in req) {\n        result.customData = req.customData;\n    }\n    if (\"blobVersionedHashes\" in req && req.blobVersionedHashes) {\n        result.blobVersionedHashes = req.blobVersionedHashes.slice();\n    }\n    if (\"kzg\" in req) {\n        result.kzg = req.kzg;\n    }\n    if (\"blobs\" in req && req.blobs) {\n        result.blobs = req.blobs.map((b) => {\n            if (isBytesLike(b)) {\n                return hexlify(b);\n            }\n            return Object.assign({}, b);\n        });\n    }\n    return result;\n}\n/**\n *  A **Block** represents the data associated with a full block on\n *  Ethereum.\n */\nexport class Block {\n    /**\n     *  The provider connected to the block used to fetch additional details\n     *  if necessary.\n     */\n    provider;\n    /**\n     *  The block number, sometimes called the block height. This is a\n     *  sequential number that is one higher than the parent block.\n     */\n    number;\n    /**\n     *  The block hash.\n     *\n     *  This hash includes all properties, so can be safely used to identify\n     *  an exact set of block properties.\n     */\n    hash;\n    /**\n     *  The timestamp for this block, which is the number of seconds since\n     *  epoch that this block was included.\n     */\n    timestamp;\n    /**\n     *  The block hash of the parent block.\n     */\n    parentHash;\n    /**\n     *  The hash tree root of the parent beacon block for the given\n     *  execution block. See [[link-eip-4788]].\n     */\n    parentBeaconBlockRoot;\n    /**\n     *  The nonce.\n     *\n     *  On legacy networks, this is the random number inserted which\n     *  permitted the difficulty target to be reached.\n     */\n    nonce;\n    /**\n     *  The difficulty target.\n     *\n     *  On legacy networks, this is the proof-of-work target required\n     *  for a block to meet the protocol rules to be included.\n     *\n     *  On modern networks, this is a random number arrived at using\n     *  randao.  @TODO: Find links?\n     */\n    difficulty;\n    /**\n     *  The total gas limit for this block.\n     */\n    gasLimit;\n    /**\n     *  The total gas used in this block.\n     */\n    gasUsed;\n    /**\n     *  The root hash for the global state after applying changes\n     *  in this block.\n     */\n    stateRoot;\n    /**\n     *  The hash of the transaction receipts trie.\n     */\n    receiptsRoot;\n    /**\n     *  The total amount of blob gas consumed by the transactions\n     *  within the block. See [[link-eip-4844]].\n     */\n    blobGasUsed;\n    /**\n     *  The running total of blob gas consumed in excess of the\n     *  target, prior to the block. See [[link-eip-4844]].\n     */\n    excessBlobGas;\n    /**\n     *  The miner coinbase address, wihch receives any subsidies for\n     *  including this block.\n     */\n    miner;\n    /**\n     *  The latest RANDAO mix of the post beacon state of\n     *  the previous block.\n     */\n    prevRandao;\n    /**\n     *  Any extra data the validator wished to include.\n     */\n    extraData;\n    /**\n     *  The base fee per gas that all transactions in this block were\n     *  charged.\n     *\n     *  This adjusts after each block, depending on how congested the network\n     *  is.\n     */\n    baseFeePerGas;\n    #transactions;\n    /**\n     *  Create a new **Block** object.\n     *\n     *  This should generally not be necessary as the unless implementing a\n     *  low-level library.\n     */\n    constructor(block, provider) {\n        this.#transactions = block.transactions.map((tx) => {\n            if (typeof (tx) !== \"string\") {\n                return new TransactionResponse(tx, provider);\n            }\n            return tx;\n        });\n        defineProperties(this, {\n            provider,\n            hash: getValue(block.hash),\n            number: block.number,\n            timestamp: block.timestamp,\n            parentHash: block.parentHash,\n            parentBeaconBlockRoot: block.parentBeaconBlockRoot,\n            nonce: block.nonce,\n            difficulty: block.difficulty,\n            gasLimit: block.gasLimit,\n            gasUsed: block.gasUsed,\n            blobGasUsed: block.blobGasUsed,\n            excessBlobGas: block.excessBlobGas,\n            miner: block.miner,\n            prevRandao: getValue(block.prevRandao),\n            extraData: block.extraData,\n            baseFeePerGas: getValue(block.baseFeePerGas),\n            stateRoot: block.stateRoot,\n            receiptsRoot: block.receiptsRoot,\n        });\n    }\n    /**\n     *  Returns the list of transaction hashes, in the order\n     *  they were executed within the block.\n     */\n    get transactions() {\n        return this.#transactions.map((tx) => {\n            if (typeof (tx) === \"string\") {\n                return tx;\n            }\n            return tx.hash;\n        });\n    }\n    /**\n     *  Returns the complete transactions, in the order they\n     *  were executed within the block.\n     *\n     *  This is only available for blocks which prefetched\n     *  transactions, by passing ``true`` to %%prefetchTxs%%\n     *  into [[Provider-getBlock]].\n     */\n    get prefetchedTransactions() {\n        const txs = this.#transactions.slice();\n        // Doesn't matter...\n        if (txs.length === 0) {\n            return [];\n        }\n        // Make sure we prefetched the transactions\n        assert(typeof (txs[0]) === \"object\", \"transactions were not prefetched with block request\", \"UNSUPPORTED_OPERATION\", {\n            operation: \"transactionResponses()\"\n        });\n        return txs;\n    }\n    /**\n     *  Returns a JSON-friendly value.\n     */\n    toJSON() {\n        const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, prevRandao, nonce, number, parentHash, parentBeaconBlockRoot, stateRoot, receiptsRoot, timestamp, transactions } = this;\n        return {\n            _type: \"Block\",\n            baseFeePerGas: toJson(baseFeePerGas),\n            difficulty: toJson(difficulty),\n            extraData,\n            gasLimit: toJson(gasLimit),\n            gasUsed: toJson(gasUsed),\n            blobGasUsed: toJson(this.blobGasUsed),\n            excessBlobGas: toJson(this.excessBlobGas),\n            hash, miner, prevRandao, nonce, number, parentHash, timestamp,\n            parentBeaconBlockRoot, stateRoot, receiptsRoot,\n            transactions,\n        };\n    }\n    [Symbol.iterator]() {\n        let index = 0;\n        const txs = this.transactions;\n        return {\n            next: () => {\n                if (index < this.length) {\n                    return {\n                        value: txs[index++], done: false\n                    };\n                }\n                return { value: undefined, done: true };\n            }\n        };\n    }\n    /**\n     *  The number of transactions in this block.\n     */\n    get length() { return this.#transactions.length; }\n    /**\n     *  The [[link-js-date]] this block was included at.\n     */\n    get date() {\n        if (this.timestamp == null) {\n            return null;\n        }\n        return new Date(this.timestamp * 1000);\n    }\n    /**\n     *  Get the transaction at %%indexe%% within this block.\n     */\n    async getTransaction(indexOrHash) {\n        // Find the internal value by its index or hash\n        let tx = undefined;\n        if (typeof (indexOrHash) === \"number\") {\n            tx = this.#transactions[indexOrHash];\n        }\n        else {\n            const hash = indexOrHash.toLowerCase();\n            for (const v of this.#transactions) {\n                if (typeof (v) === \"string\") {\n                    if (v !== hash) {\n                        continue;\n                    }\n                    tx = v;\n                    break;\n                }\n                else {\n                    if (v.hash === hash) {\n                        continue;\n                    }\n                    tx = v;\n                    break;\n                }\n            }\n        }\n        if (tx == null) {\n            throw new Error(\"no such tx\");\n        }\n        if (typeof (tx) === \"string\") {\n            return (await this.provider.getTransaction(tx));\n        }\n        else {\n            return tx;\n        }\n    }\n    /**\n     *  If a **Block** was fetched with a request to include the transactions\n     *  this will allow synchronous access to those transactions.\n     *\n     *  If the transactions were not prefetched, this will throw.\n     */\n    getPrefetchedTransaction(indexOrHash) {\n        const txs = this.prefetchedTransactions;\n        if (typeof (indexOrHash) === \"number\") {\n            return txs[indexOrHash];\n        }\n        indexOrHash = indexOrHash.toLowerCase();\n        for (const tx of txs) {\n            if (tx.hash === indexOrHash) {\n                return tx;\n            }\n        }\n        assertArgument(false, \"no matching transaction\", \"indexOrHash\", indexOrHash);\n    }\n    /**\n     *  Returns true if this block been mined. This provides a type guard\n     *  for all properties on a [[MinedBlock]].\n     */\n    isMined() { return !!this.hash; }\n    /**\n     *  Returns true if this block is an [[link-eip-2930]] block.\n     */\n    isLondon() {\n        return !!this.baseFeePerGas;\n    }\n    /**\n     *  @_ignore:\n     */\n    orphanedEvent() {\n        if (!this.isMined()) {\n            throw new Error(\"\");\n        }\n        return createOrphanedBlockFilter(this);\n    }\n}\n//////////////////////\n// Log\n/**\n *  A **Log** in Ethereum represents an event that has been included in a\n *  transaction using the ``LOG*`` opcodes, which are most commonly used by\n *  Solidity's emit for announcing events.\n */\nexport class Log {\n    /**\n     *  The provider connected to the log used to fetch additional details\n     *  if necessary.\n     */\n    provider;\n    /**\n     *  The transaction hash of the transaction this log occurred in. Use the\n     *  [[Log-getTransaction]] to get the [[TransactionResponse]].\n     */\n    transactionHash;\n    /**\n     *  The block hash of the block this log occurred in. Use the\n     *  [[Log-getBlock]] to get the [[Block]].\n     */\n    blockHash;\n    /**\n     *  The block number of the block this log occurred in. It is preferred\n     *  to use the [[Block-hash]] when fetching the related [[Block]],\n     *  since in the case of an orphaned block, the block at that height may\n     *  have changed.\n     */\n    blockNumber;\n    /**\n     *  If the **Log** represents a block that was removed due to an orphaned\n     *  block, this will be true.\n     *\n     *  This can only happen within an orphan event listener.\n     */\n    removed;\n    /**\n     *  The address of the contract that emitted this log.\n     */\n    address;\n    /**\n     *  The data included in this log when it was emitted.\n     */\n    data;\n    /**\n     *  The indexed topics included in this log when it was emitted.\n     *\n     *  All topics are included in the bloom filters, so they can be\n     *  efficiently filtered using the [[Provider-getLogs]] method.\n     */\n    topics;\n    /**\n     *  The index within the block this log occurred at. This is generally\n     *  not useful to developers, but can be used with the various roots\n     *  to proof inclusion within a block.\n     */\n    index;\n    /**\n     *  The index within the transaction of this log.\n     */\n    transactionIndex;\n    /**\n     *  @_ignore:\n     */\n    constructor(log, provider) {\n        this.provider = provider;\n        const topics = Object.freeze(log.topics.slice());\n        defineProperties(this, {\n            transactionHash: log.transactionHash,\n            blockHash: log.blockHash,\n            blockNumber: log.blockNumber,\n            removed: log.removed,\n            address: log.address,\n            data: log.data,\n            topics,\n            index: log.index,\n            transactionIndex: log.transactionIndex,\n        });\n    }\n    /**\n     *  Returns a JSON-compatible object.\n     */\n    toJSON() {\n        const { address, blockHash, blockNumber, data, index, removed, topics, transactionHash, transactionIndex } = this;\n        return {\n            _type: \"log\",\n            address, blockHash, blockNumber, data, index,\n            removed, topics, transactionHash, transactionIndex\n        };\n    }\n    /**\n     *  Returns the block that this log occurred in.\n     */\n    async getBlock() {\n        const block = await this.provider.getBlock(this.blockHash);\n        assert(!!block, \"failed to find transaction\", \"UNKNOWN_ERROR\", {});\n        return block;\n    }\n    /**\n     *  Returns the transaction that this log occurred in.\n     */\n    async getTransaction() {\n        const tx = await this.provider.getTransaction(this.transactionHash);\n        assert(!!tx, \"failed to find transaction\", \"UNKNOWN_ERROR\", {});\n        return tx;\n    }\n    /**\n     *  Returns the transaction receipt fot the transaction that this\n     *  log occurred in.\n     */\n    async getTransactionReceipt() {\n        const receipt = await this.provider.getTransactionReceipt(this.transactionHash);\n        assert(!!receipt, \"failed to find transaction receipt\", \"UNKNOWN_ERROR\", {});\n        return receipt;\n    }\n    /**\n     *  @_ignore:\n     */\n    removedEvent() {\n        return createRemovedLogFilter(this);\n    }\n}\n//////////////////////\n// Transaction Receipt\n/*\nexport interface LegacyTransactionReceipt {\n    byzantium: false;\n    status: null;\n    root: string;\n}\n\nexport interface ByzantiumTransactionReceipt {\n    byzantium: true;\n    status: number;\n    root: null;\n}\n*/\n/**\n *  A **TransactionReceipt** includes additional information about a\n *  transaction that is only available after it has been mined.\n */\nexport class TransactionReceipt {\n    /**\n     *  The provider connected to the log used to fetch additional details\n     *  if necessary.\n     */\n    provider;\n    /**\n     *  The address the transaction was sent to.\n     */\n    to;\n    /**\n     *  The sender of the transaction.\n     */\n    from;\n    /**\n     *  The address of the contract if the transaction was directly\n     *  responsible for deploying one.\n     *\n     *  This is non-null **only** if the ``to`` is empty and the ``data``\n     *  was successfully executed as initcode.\n     */\n    contractAddress;\n    /**\n     *  The transaction hash.\n     */\n    hash;\n    /**\n     *  The index of this transaction within the block transactions.\n     */\n    index;\n    /**\n     *  The block hash of the [[Block]] this transaction was included in.\n     */\n    blockHash;\n    /**\n     *  The block number of the [[Block]] this transaction was included in.\n     */\n    blockNumber;\n    /**\n     *  The bloom filter bytes that represent all logs that occurred within\n     *  this transaction. This is generally not useful for most developers,\n     *  but can be used to validate the included logs.\n     */\n    logsBloom;\n    /**\n     *  The actual amount of gas used by this transaction.\n     *\n     *  When creating a transaction, the amount of gas that will be used can\n     *  only be approximated, but the sender must pay the gas fee for the\n     *  entire gas limit. After the transaction, the difference is refunded.\n     */\n    gasUsed;\n    /**\n     *  The gas used for BLObs. See [[link-eip-4844]].\n     */\n    blobGasUsed;\n    /**\n     *  The amount of gas used by all transactions within the block for this\n     *  and all transactions with a lower ``index``.\n     *\n     *  This is generally not useful for developers but can be used to\n     *  validate certain aspects of execution.\n     */\n    cumulativeGasUsed;\n    /**\n     *  The actual gas price used during execution.\n     *\n     *  Due to the complexity of [[link-eip-1559]] this value can only\n     *  be caluclated after the transaction has been mined, snce the base\n     *  fee is protocol-enforced.\n     */\n    gasPrice;\n    /**\n     *  The price paid per BLOB in gas. See [[link-eip-4844]].\n     */\n    blobGasPrice;\n    /**\n     *  The [[link-eip-2718]] transaction type.\n     */\n    type;\n    //readonly byzantium!: boolean;\n    /**\n     *  The status of this transaction, indicating success (i.e. ``1``) or\n     *  a revert (i.e. ``0``).\n     *\n     *  This is available in post-byzantium blocks, but some backends may\n     *  backfill this value.\n     */\n    status;\n    /**\n     *  The root hash of this transaction.\n     *\n     *  This is no present and was only included in pre-byzantium blocks, but\n     *  could be used to validate certain parts of the receipt.\n     */\n    root;\n    #logs;\n    /**\n     *  @_ignore:\n     */\n    constructor(tx, provider) {\n        this.#logs = Object.freeze(tx.logs.map((log) => {\n            return new Log(log, provider);\n        }));\n        let gasPrice = BN_0;\n        if (tx.effectiveGasPrice != null) {\n            gasPrice = tx.effectiveGasPrice;\n        }\n        else if (tx.gasPrice != null) {\n            gasPrice = tx.gasPrice;\n        }\n        defineProperties(this, {\n            provider,\n            to: tx.to,\n            from: tx.from,\n            contractAddress: tx.contractAddress,\n            hash: tx.hash,\n            index: tx.index,\n            blockHash: tx.blockHash,\n            blockNumber: tx.blockNumber,\n            logsBloom: tx.logsBloom,\n            gasUsed: tx.gasUsed,\n            cumulativeGasUsed: tx.cumulativeGasUsed,\n            blobGasUsed: tx.blobGasUsed,\n            gasPrice,\n            blobGasPrice: tx.blobGasPrice,\n            type: tx.type,\n            //byzantium: tx.byzantium,\n            status: tx.status,\n            root: tx.root\n        });\n    }\n    /**\n     *  The logs for this transaction.\n     */\n    get logs() { return this.#logs; }\n    /**\n     *  Returns a JSON-compatible representation.\n     */\n    toJSON() {\n        const { to, from, contractAddress, hash, index, blockHash, blockNumber, logsBloom, logs, //byzantium, \n        status, root } = this;\n        return {\n            _type: \"TransactionReceipt\",\n            blockHash, blockNumber,\n            //byzantium, \n            contractAddress,\n            cumulativeGasUsed: toJson(this.cumulativeGasUsed),\n            from,\n            gasPrice: toJson(this.gasPrice),\n            blobGasUsed: toJson(this.blobGasUsed),\n            blobGasPrice: toJson(this.blobGasPrice),\n            gasUsed: toJson(this.gasUsed),\n            hash, index, logs, logsBloom, root, status, to\n        };\n    }\n    /**\n     *  @_ignore:\n     */\n    get length() { return this.logs.length; }\n    [Symbol.iterator]() {\n        let index = 0;\n        return {\n            next: () => {\n                if (index < this.length) {\n                    return { value: this.logs[index++], done: false };\n                }\n                return { value: undefined, done: true };\n            }\n        };\n    }\n    /**\n     *  The total fee for this transaction, in wei.\n     */\n    get fee() {\n        return this.gasUsed * this.gasPrice;\n    }\n    /**\n     *  Resolves to the block this transaction occurred in.\n     */\n    async getBlock() {\n        const block = await this.provider.getBlock(this.blockHash);\n        if (block == null) {\n            throw new Error(\"TODO\");\n        }\n        return block;\n    }\n    /**\n     *  Resolves to the transaction this transaction occurred in.\n     */\n    async getTransaction() {\n        const tx = await this.provider.getTransaction(this.hash);\n        if (tx == null) {\n            throw new Error(\"TODO\");\n        }\n        return tx;\n    }\n    /**\n     *  Resolves to the return value of the execution of this transaction.\n     *\n     *  Support for this feature is limited, as it requires an archive node\n     *  with the ``debug_`` or ``trace_`` API enabled.\n     */\n    async getResult() {\n        return (await this.provider.getTransactionResult(this.hash));\n    }\n    /**\n     *  Resolves to the number of confirmations this transaction has.\n     */\n    async confirmations() {\n        return (await this.provider.getBlockNumber()) - this.blockNumber + 1;\n    }\n    /**\n     *  @_ignore:\n     */\n    removedEvent() {\n        return createRemovedTransactionFilter(this);\n    }\n    /**\n     *  @_ignore:\n     */\n    reorderedEvent(other) {\n        assert(!other || other.isMined(), \"unmined 'other' transction cannot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"reorderedEvent(other)\" });\n        return createReorderedTransactionFilter(this, other);\n    }\n}\n/**\n *  A **TransactionResponse** includes all properties about a transaction\n *  that was sent to the network, which may or may not be included in a\n *  block.\n *\n *  The [[TransactionResponse-isMined]] can be used to check if the\n *  transaction has been mined as well as type guard that the otherwise\n *  possibly ``null`` properties are defined.\n */\nexport class TransactionResponse {\n    /**\n     *  The provider this is connected to, which will influence how its\n     *  methods will resolve its async inspection methods.\n     */\n    provider;\n    /**\n     *  The block number of the block that this transaction was included in.\n     *\n     *  This is ``null`` for pending transactions.\n     */\n    blockNumber;\n    /**\n     *  The blockHash of the block that this transaction was included in.\n     *\n     *  This is ``null`` for pending transactions.\n     */\n    blockHash;\n    /**\n     *  The index within the block that this transaction resides at.\n     */\n    index;\n    /**\n     *  The transaction hash.\n     */\n    hash;\n    /**\n     *  The [[link-eip-2718]] transaction envelope type. This is\n     *  ``0`` for legacy transactions types.\n     */\n    type;\n    /**\n     *  The receiver of this transaction.\n     *\n     *  If ``null``, then the transaction is an initcode transaction.\n     *  This means the result of executing the [[data]] will be deployed\n     *  as a new contract on chain (assuming it does not revert) and the\n     *  address may be computed using [[getCreateAddress]].\n     */\n    to;\n    /**\n     *  The sender of this transaction. It is implicitly computed\n     *  from the transaction pre-image hash (as the digest) and the\n     *  [[signature]] using ecrecover.\n     */\n    from;\n    /**\n     *  The nonce, which is used to prevent replay attacks and offer\n     *  a method to ensure transactions from a given sender are explicitly\n     *  ordered.\n     *\n     *  When sending a transaction, this must be equal to the number of\n     *  transactions ever sent by [[from]].\n     */\n    nonce;\n    /**\n     *  The maximum units of gas this transaction can consume. If execution\n     *  exceeds this, the entries transaction is reverted and the sender\n     *  is charged for the full amount, despite not state changes being made.\n     */\n    gasLimit;\n    /**\n     *  The gas price can have various values, depending on the network.\n     *\n     *  In modern networks, for transactions that are included this is\n     *  the //effective gas price// (the fee per gas that was actually\n     *  charged), while for transactions that have not been included yet\n     *  is the [[maxFeePerGas]].\n     *\n     *  For legacy transactions, or transactions on legacy networks, this\n     *  is the fee that will be charged per unit of gas the transaction\n     *  consumes.\n     */\n    gasPrice;\n    /**\n     *  The maximum priority fee (per unit of gas) to allow a\n     *  validator to charge the sender. This is inclusive of the\n     *  [[maxFeeFeePerGas]].\n     */\n    maxPriorityFeePerGas;\n    /**\n     *  The maximum fee (per unit of gas) to allow this transaction\n     *  to charge the sender.\n     */\n    maxFeePerGas;\n    /**\n     *  The [[link-eip-4844]] max fee per BLOb gas.\n     */\n    maxFeePerBlobGas;\n    /**\n     *  The data.\n     */\n    data;\n    /**\n     *  The value, in wei. Use [[formatEther]] to format this value\n     *  as ether.\n     */\n    value;\n    /**\n     *  The chain ID.\n     */\n    chainId;\n    /**\n     *  The signature.\n     */\n    signature;\n    /**\n     *  The [[link-eip-2930]] access list for transaction types that\n     *  support it, otherwise ``null``.\n     */\n    accessList;\n    /**\n     *  The [[link-eip-4844]] BLOb versioned hashes.\n     */\n    blobVersionedHashes;\n    #startBlock;\n    /**\n     *  @_ignore:\n     */\n    constructor(tx, provider) {\n        this.provider = provider;\n        this.blockNumber = (tx.blockNumber != null) ? tx.blockNumber : null;\n        this.blockHash = (tx.blockHash != null) ? tx.blockHash : null;\n        this.hash = tx.hash;\n        this.index = tx.index;\n        this.type = tx.type;\n        this.from = tx.from;\n        this.to = tx.to || null;\n        this.gasLimit = tx.gasLimit;\n        this.nonce = tx.nonce;\n        this.data = tx.data;\n        this.value = tx.value;\n        this.gasPrice = tx.gasPrice;\n        this.maxPriorityFeePerGas = (tx.maxPriorityFeePerGas != null) ? tx.maxPriorityFeePerGas : null;\n        this.maxFeePerGas = (tx.maxFeePerGas != null) ? tx.maxFeePerGas : null;\n        this.maxFeePerBlobGas = (tx.maxFeePerBlobGas != null) ? tx.maxFeePerBlobGas : null;\n        this.chainId = tx.chainId;\n        this.signature = tx.signature;\n        this.accessList = (tx.accessList != null) ? tx.accessList : null;\n        this.blobVersionedHashes = (tx.blobVersionedHashes != null) ? tx.blobVersionedHashes : null;\n        this.#startBlock = -1;\n    }\n    /**\n     *  Returns a JSON-compatible representation of this transaction.\n     */\n    toJSON() {\n        const { blockNumber, blockHash, index, hash, type, to, from, nonce, data, signature, accessList, blobVersionedHashes } = this;\n        return {\n            _type: \"TransactionResponse\",\n            accessList, blockNumber, blockHash,\n            blobVersionedHashes,\n            chainId: toJson(this.chainId),\n            data, from,\n            gasLimit: toJson(this.gasLimit),\n            gasPrice: toJson(this.gasPrice),\n            hash,\n            maxFeePerGas: toJson(this.maxFeePerGas),\n            maxPriorityFeePerGas: toJson(this.maxPriorityFeePerGas),\n            maxFeePerBlobGas: toJson(this.maxFeePerBlobGas),\n            nonce, signature, to, index, type,\n            value: toJson(this.value),\n        };\n    }\n    /**\n     *  Resolves to the Block that this transaction was included in.\n     *\n     *  This will return null if the transaction has not been included yet.\n     */\n    async getBlock() {\n        let blockNumber = this.blockNumber;\n        if (blockNumber == null) {\n            const tx = await this.getTransaction();\n            if (tx) {\n                blockNumber = tx.blockNumber;\n            }\n        }\n        if (blockNumber == null) {\n            return null;\n        }\n        const block = this.provider.getBlock(blockNumber);\n        if (block == null) {\n            throw new Error(\"TODO\");\n        }\n        return block;\n    }\n    /**\n     *  Resolves to this transaction being re-requested from the\n     *  provider. This can be used if you have an unmined transaction\n     *  and wish to get an up-to-date populated instance.\n     */\n    async getTransaction() {\n        return this.provider.getTransaction(this.hash);\n    }\n    /**\n     *  Resolve to the number of confirmations this transaction has.\n     */\n    async confirmations() {\n        if (this.blockNumber == null) {\n            const { tx, blockNumber } = await resolveProperties({\n                tx: this.getTransaction(),\n                blockNumber: this.provider.getBlockNumber()\n            });\n            // Not mined yet...\n            if (tx == null || tx.blockNumber == null) {\n                return 0;\n            }\n            return blockNumber - tx.blockNumber + 1;\n        }\n        const blockNumber = await this.provider.getBlockNumber();\n        return blockNumber - this.blockNumber + 1;\n    }\n    /**\n     *  Resolves once this transaction has been mined and has\n     *  %%confirms%% blocks including it (default: ``1``) with an\n     *  optional %%timeout%%.\n     *\n     *  This can resolve to ``null`` only if %%confirms%% is ``0``\n     *  and the transaction has not been mined, otherwise this will\n     *  wait until enough confirmations have completed.\n     */\n    async wait(_confirms, _timeout) {\n        const confirms = (_confirms == null) ? 1 : _confirms;\n        const timeout = (_timeout == null) ? 0 : _timeout;\n        let startBlock = this.#startBlock;\n        let nextScan = -1;\n        let stopScanning = (startBlock === -1) ? true : false;\n        const checkReplacement = async () => {\n            // Get the current transaction count for this sender\n            if (stopScanning) {\n                return null;\n            }\n            const { blockNumber, nonce } = await resolveProperties({\n                blockNumber: this.provider.getBlockNumber(),\n                nonce: this.provider.getTransactionCount(this.from)\n            });\n            // No transaction or our nonce has not been mined yet; but we\n            // can start scanning later when we do start\n            if (nonce < this.nonce) {\n                startBlock = blockNumber;\n                return;\n            }\n            // We were mined; no replacement\n            if (stopScanning) {\n                return null;\n            }\n            const mined = await this.getTransaction();\n            if (mined && mined.blockNumber != null) {\n                return;\n            }\n            // We were replaced; start scanning for that transaction\n            // Starting to scan; look back a few extra blocks for safety\n            if (nextScan === -1) {\n                nextScan = startBlock - 3;\n                if (nextScan < this.#startBlock) {\n                    nextScan = this.#startBlock;\n                }\n            }\n            while (nextScan <= blockNumber) {\n                // Get the next block to scan\n                if (stopScanning) {\n                    return null;\n                }\n                const block = await this.provider.getBlock(nextScan, true);\n                // This should not happen; but we'll try again shortly\n                if (block == null) {\n                    return;\n                }\n                // We were mined; no replacement\n                for (const hash of block) {\n                    if (hash === this.hash) {\n                        return;\n                    }\n                }\n                // Search for the transaction that replaced us\n                for (let i = 0; i < block.length; i++) {\n                    const tx = await block.getTransaction(i);\n                    if (tx.from === this.from && tx.nonce === this.nonce) {\n                        // Get the receipt\n                        if (stopScanning) {\n                            return null;\n                        }\n                        const receipt = await this.provider.getTransactionReceipt(tx.hash);\n                        // This should not happen; but we'll try again shortly\n                        if (receipt == null) {\n                            return;\n                        }\n                        // We will retry this on the next block (this case could be optimized)\n                        if ((blockNumber - receipt.blockNumber + 1) < confirms) {\n                            return;\n                        }\n                        // The reason we were replaced\n                        let reason = \"replaced\";\n                        if (tx.data === this.data && tx.to === this.to && tx.value === this.value) {\n                            reason = \"repriced\";\n                        }\n                        else if (tx.data === \"0x\" && tx.from === tx.to && tx.value === BN_0) {\n                            reason = \"cancelled\";\n                        }\n                        assert(false, \"transaction was replaced\", \"TRANSACTION_REPLACED\", {\n                            cancelled: (reason === \"replaced\" || reason === \"cancelled\"),\n                            reason,\n                            replacement: tx.replaceableTransaction(startBlock),\n                            hash: tx.hash,\n                            receipt\n                        });\n                    }\n                }\n                nextScan++;\n            }\n            return;\n        };\n        const checkReceipt = (receipt) => {\n            if (receipt == null || receipt.status !== 0) {\n                return receipt;\n            }\n            assert(false, \"transaction execution reverted\", \"CALL_EXCEPTION\", {\n                action: \"sendTransaction\",\n                data: null, reason: null, invocation: null, revert: null,\n                transaction: {\n                    to: receipt.to,\n                    from: receipt.from,\n                    data: \"\" // @TODO: in v7, split out sendTransaction properties\n                }, receipt\n            });\n        };\n        const receipt = await this.provider.getTransactionReceipt(this.hash);\n        if (confirms === 0) {\n            return checkReceipt(receipt);\n        }\n        if (receipt) {\n            if ((await receipt.confirmations()) >= confirms) {\n                return checkReceipt(receipt);\n            }\n        }\n        else {\n            // Check for a replacement; throws if a replacement was found\n            await checkReplacement();\n            // Allow null only when the confirms is 0\n            if (confirms === 0) {\n                return null;\n            }\n        }\n        const waiter = new Promise((resolve, reject) => {\n            // List of things to cancel when we have a result (one way or the other)\n            const cancellers = [];\n            const cancel = () => { cancellers.forEach((c) => c()); };\n            // On cancel, stop scanning for replacements\n            cancellers.push(() => { stopScanning = true; });\n            // Set up any timeout requested\n            if (timeout > 0) {\n                const timer = setTimeout(() => {\n                    cancel();\n                    reject(makeError(\"wait for transaction timeout\", \"TIMEOUT\"));\n                }, timeout);\n                cancellers.push(() => { clearTimeout(timer); });\n            }\n            const txListener = async (receipt) => {\n                // Done; return it!\n                if ((await receipt.confirmations()) >= confirms) {\n                    cancel();\n                    try {\n                        resolve(checkReceipt(receipt));\n                    }\n                    catch (error) {\n                        reject(error);\n                    }\n                }\n            };\n            cancellers.push(() => { this.provider.off(this.hash, txListener); });\n            this.provider.on(this.hash, txListener);\n            // We support replacement detection; start checking\n            if (startBlock >= 0) {\n                const replaceListener = async () => {\n                    try {\n                        // Check for a replacement; this throws only if one is found\n                        await checkReplacement();\n                    }\n                    catch (error) {\n                        // We were replaced (with enough confirms); re-throw the error\n                        if (isError(error, \"TRANSACTION_REPLACED\")) {\n                            cancel();\n                            reject(error);\n                            return;\n                        }\n                    }\n                    // Rescheudle a check on the next block\n                    if (!stopScanning) {\n                        this.provider.once(\"block\", replaceListener);\n                    }\n                };\n                cancellers.push(() => { this.provider.off(\"block\", replaceListener); });\n                this.provider.once(\"block\", replaceListener);\n            }\n        });\n        return await waiter;\n    }\n    /**\n     *  Returns ``true`` if this transaction has been included.\n     *\n     *  This is effective only as of the time the TransactionResponse\n     *  was instantiated. To get up-to-date information, use\n     *  [[getTransaction]].\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  non-null property values for properties that are null for\n     *  unmined transactions.\n     */\n    isMined() {\n        return (this.blockHash != null);\n    }\n    /**\n     *  Returns true if the transaction is a legacy (i.e. ``type == 0``)\n     *  transaction.\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  the ``null``-ness for hardfork-specific properties set correctly.\n     */\n    isLegacy() {\n        return (this.type === 0);\n    }\n    /**\n     *  Returns true if the transaction is a Berlin (i.e. ``type == 1``)\n     *  transaction. See [[link-eip-2070]].\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  the ``null``-ness for hardfork-specific properties set correctly.\n     */\n    isBerlin() {\n        return (this.type === 1);\n    }\n    /**\n     *  Returns true if the transaction is a London (i.e. ``type == 2``)\n     *  transaction. See [[link-eip-1559]].\n     *\n     *  This provides a Type Guard that this transaction will have\n     *  the ``null``-ness for hardfork-specific properties set correctly.\n     */\n    isLondon() {\n        return (this.type === 2);\n    }\n    /**\n     *  Returns true if hte transaction is a Cancun (i.e. ``type == 3``)\n     *  transaction. See [[link-eip-4844]].\n     */\n    isCancun() {\n        return (this.type === 3);\n    }\n    /**\n     *  Returns a filter which can be used to listen for orphan events\n     *  that evict this transaction.\n     */\n    removedEvent() {\n        assert(this.isMined(), \"unmined transaction canot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"removeEvent()\" });\n        return createRemovedTransactionFilter(this);\n    }\n    /**\n     *  Returns a filter which can be used to listen for orphan events\n     *  that re-order this event against %%other%%.\n     */\n    reorderedEvent(other) {\n        assert(this.isMined(), \"unmined transaction canot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"removeEvent()\" });\n        assert(!other || other.isMined(), \"unmined 'other' transaction canot be orphaned\", \"UNSUPPORTED_OPERATION\", { operation: \"removeEvent()\" });\n        return createReorderedTransactionFilter(this, other);\n    }\n    /**\n     *  Returns a new TransactionResponse instance which has the ability to\n     *  detect (and throw an error) if the transaction is replaced, which\n     *  will begin scanning at %%startBlock%%.\n     *\n     *  This should generally not be used by developers and is intended\n     *  primarily for internal use. Setting an incorrect %%startBlock%% can\n     *  have devastating performance consequences if used incorrectly.\n     */\n    replaceableTransaction(startBlock) {\n        assertArgument(Number.isInteger(startBlock) && startBlock >= 0, \"invalid startBlock\", \"startBlock\", startBlock);\n        const tx = new TransactionResponse(this, this.provider);\n        tx.#startBlock = startBlock;\n        return tx;\n    }\n}\nfunction createOrphanedBlockFilter(block) {\n    return { orphan: \"drop-block\", hash: block.hash, number: block.number };\n}\nfunction createReorderedTransactionFilter(tx, other) {\n    return { orphan: \"reorder-transaction\", tx, other };\n}\nfunction createRemovedTransactionFilter(tx) {\n    return { orphan: \"drop-transaction\", tx };\n}\nfunction createRemovedLogFilter(log) {\n    return { orphan: \"drop-log\", log: {\n            transactionHash: log.transactionHash,\n            blockHash: log.blockHash,\n            blockNumber: log.blockNumber,\n            address: log.address,\n            data: log.data,\n            topics: Object.freeze(log.topics.slice()),\n            index: log.index\n        } };\n}\n//# sourceMappingURL=provider.js.map","// import from provider.ts instead of index.ts to prevent circular dep\n// from EtherscanProvider\nimport { Log, TransactionReceipt, TransactionResponse } from \"../providers/provider.js\";\nimport { defineProperties, EventPayload } from \"../utils/index.js\";\n/**\n *  An **EventLog** contains additional properties parsed from the [[Log]].\n */\nexport class EventLog extends Log {\n    /**\n     *  The Contract Interface.\n     */\n    interface;\n    /**\n     *  The matching event.\n     */\n    fragment;\n    /**\n     *  The parsed arguments passed to the event by ``emit``.\n     */\n    args;\n    /**\n     * @_ignore:\n     */\n    constructor(log, iface, fragment) {\n        super(log, log.provider);\n        const args = iface.decodeEventLog(fragment, log.data, log.topics);\n        defineProperties(this, { args, fragment, interface: iface });\n    }\n    /**\n     *  The name of the event.\n     */\n    get eventName() { return this.fragment.name; }\n    /**\n     *  The signature of the event.\n     */\n    get eventSignature() { return this.fragment.format(); }\n}\n/**\n *  An **EventLog** contains additional properties parsed from the [[Log]].\n */\nexport class UndecodedEventLog extends Log {\n    /**\n     *  The error encounted when trying to decode the log.\n     */\n    error;\n    /**\n     * @_ignore:\n     */\n    constructor(log, error) {\n        super(log, log.provider);\n        defineProperties(this, { error });\n    }\n}\n/**\n *  A **ContractTransactionReceipt** includes the parsed logs from a\n *  [[TransactionReceipt]].\n */\nexport class ContractTransactionReceipt extends TransactionReceipt {\n    #iface;\n    /**\n     *  @_ignore:\n     */\n    constructor(iface, provider, tx) {\n        super(tx, provider);\n        this.#iface = iface;\n    }\n    /**\n     *  The parsed logs for any [[Log]] which has a matching event in the\n     *  Contract ABI.\n     */\n    get logs() {\n        return super.logs.map((log) => {\n            const fragment = log.topics.length ? this.#iface.getEvent(log.topics[0]) : null;\n            if (fragment) {\n                try {\n                    return new EventLog(log, this.#iface, fragment);\n                }\n                catch (error) {\n                    return new UndecodedEventLog(log, error);\n                }\n            }\n            return log;\n        });\n    }\n}\n/**\n *  A **ContractTransactionResponse** will return a\n *  [[ContractTransactionReceipt]] when waited on.\n */\nexport class ContractTransactionResponse extends TransactionResponse {\n    #iface;\n    /**\n     *  @_ignore:\n     */\n    constructor(iface, provider, tx) {\n        super(tx, provider);\n        this.#iface = iface;\n    }\n    /**\n     *  Resolves once this transaction has been mined and has\n     *  %%confirms%% blocks including it (default: ``1``) with an\n     *  optional %%timeout%%.\n     *\n     *  This can resolve to ``null`` only if %%confirms%% is ``0``\n     *  and the transaction has not been mined, otherwise this will\n     *  wait until enough confirmations have completed.\n     */\n    async wait(confirms, timeout) {\n        const receipt = await super.wait(confirms, timeout);\n        if (receipt == null) {\n            return null;\n        }\n        return new ContractTransactionReceipt(this.#iface, this.provider, receipt);\n    }\n}\n/**\n *  A **ContractUnknownEventPayload** is included as the last parameter to\n *  Contract Events when the event does not match any events in the ABI.\n */\nexport class ContractUnknownEventPayload extends EventPayload {\n    /**\n     *  The log with no matching events.\n     */\n    log;\n    /**\n     *  @_event:\n     */\n    constructor(contract, listener, filter, log) {\n        super(contract, listener, filter);\n        defineProperties(this, { log });\n    }\n    /**\n     *  Resolves to the block the event occured in.\n     */\n    async getBlock() {\n        return await this.log.getBlock();\n    }\n    /**\n     *  Resolves to the transaction the event occured in.\n     */\n    async getTransaction() {\n        return await this.log.getTransaction();\n    }\n    /**\n     *  Resolves to the transaction receipt the event occured in.\n     */\n    async getTransactionReceipt() {\n        return await this.log.getTransactionReceipt();\n    }\n}\n/**\n *  A **ContractEventPayload** is included as the last parameter to\n *  Contract Events when the event is known.\n */\nexport class ContractEventPayload extends ContractUnknownEventPayload {\n    /**\n     *  @_ignore:\n     */\n    constructor(contract, listener, filter, fragment, _log) {\n        super(contract, listener, filter, new EventLog(_log, contract.interface, fragment));\n        const args = contract.interface.decodeEventLog(fragment, this.log.data, this.log.topics);\n        defineProperties(this, { args, fragment });\n    }\n    /**\n     *  The event name.\n     */\n    get eventName() {\n        return this.fragment.name;\n    }\n    /**\n     *  The event signature.\n     */\n    get eventSignature() {\n        return this.fragment.format();\n    }\n}\n//# sourceMappingURL=wrappers.js.map","import { Interface, Typed } from \"../abi/index.js\";\nimport { isAddressable, resolveAddress } from \"../address/index.js\";\n// import from provider.ts instead of index.ts to prevent circular dep\n// from EtherscanProvider\nimport { copyRequest, Log } from \"../providers/provider.js\";\nimport { defineProperties, getBigInt, isCallException, isHexString, resolveProperties, isError, makeError, assert, assertArgument } from \"../utils/index.js\";\nimport { ContractEventPayload, ContractUnknownEventPayload, ContractTransactionResponse, EventLog, UndecodedEventLog } from \"./wrappers.js\";\nconst BN_0 = BigInt(0);\nfunction canCall(value) {\n    return (value && typeof (value.call) === \"function\");\n}\nfunction canEstimate(value) {\n    return (value && typeof (value.estimateGas) === \"function\");\n}\nfunction canResolve(value) {\n    return (value && typeof (value.resolveName) === \"function\");\n}\nfunction canSend(value) {\n    return (value && typeof (value.sendTransaction) === \"function\");\n}\nfunction getResolver(value) {\n    if (value != null) {\n        if (canResolve(value)) {\n            return value;\n        }\n        if (value.provider) {\n            return value.provider;\n        }\n    }\n    return undefined;\n}\nclass PreparedTopicFilter {\n    #filter;\n    fragment;\n    constructor(contract, fragment, args) {\n        defineProperties(this, { fragment });\n        if (fragment.inputs.length < args.length) {\n            throw new Error(\"too many arguments\");\n        }\n        // Recursively descend into args and resolve any addresses\n        const runner = getRunner(contract.runner, \"resolveName\");\n        const resolver = canResolve(runner) ? runner : null;\n        this.#filter = (async function () {\n            const resolvedArgs = await Promise.all(fragment.inputs.map((param, index) => {\n                const arg = args[index];\n                if (arg == null) {\n                    return null;\n                }\n                return param.walkAsync(args[index], (type, value) => {\n                    if (type === \"address\") {\n                        if (Array.isArray(value)) {\n                            return Promise.all(value.map((v) => resolveAddress(v, resolver)));\n                        }\n                        return resolveAddress(value, resolver);\n                    }\n                    return value;\n                });\n            }));\n            return contract.interface.encodeFilterTopics(fragment, resolvedArgs);\n        })();\n    }\n    getTopicFilter() {\n        return this.#filter;\n    }\n}\n// A = Arguments passed in as a tuple\n// R = The result type of the call (i.e. if only one return type,\n//     the qualified type, otherwise Result)\n// D = The type the default call will return (i.e. R for view/pure,\n//     TransactionResponse otherwise)\n//export interface ContractMethod<A extends Array<any> = Array<any>, R = any, D extends R | ContractTransactionResponse = ContractTransactionResponse> {\nfunction getRunner(value, feature) {\n    if (value == null) {\n        return null;\n    }\n    if (typeof (value[feature]) === \"function\") {\n        return value;\n    }\n    if (value.provider && typeof (value.provider[feature]) === \"function\") {\n        return value.provider;\n    }\n    return null;\n}\nfunction getProvider(value) {\n    if (value == null) {\n        return null;\n    }\n    return value.provider || null;\n}\n/**\n *  @_ignore:\n */\nexport async function copyOverrides(arg, allowed) {\n    // Make sure the overrides passed in are a valid overrides object\n    const _overrides = Typed.dereference(arg, \"overrides\");\n    assertArgument(typeof (_overrides) === \"object\", \"invalid overrides parameter\", \"overrides\", arg);\n    // Create a shallow copy (we'll deep-ify anything needed during normalizing)\n    const overrides = copyRequest(_overrides);\n    assertArgument(overrides.to == null || (allowed || []).indexOf(\"to\") >= 0, \"cannot override to\", \"overrides.to\", overrides.to);\n    assertArgument(overrides.data == null || (allowed || []).indexOf(\"data\") >= 0, \"cannot override data\", \"overrides.data\", overrides.data);\n    // Resolve any from\n    if (overrides.from) {\n        overrides.from = overrides.from;\n    }\n    return overrides;\n}\n/**\n *  @_ignore:\n */\nexport async function resolveArgs(_runner, inputs, args) {\n    // Recursively descend into args and resolve any addresses\n    const runner = getRunner(_runner, \"resolveName\");\n    const resolver = canResolve(runner) ? runner : null;\n    return await Promise.all(inputs.map((param, index) => {\n        return param.walkAsync(args[index], (type, value) => {\n            value = Typed.dereference(value, type);\n            if (type === \"address\") {\n                return resolveAddress(value, resolver);\n            }\n            return value;\n        });\n    }));\n}\nfunction buildWrappedFallback(contract) {\n    const populateTransaction = async function (overrides) {\n        // If an overrides was passed in, copy it and normalize the values\n        const tx = (await copyOverrides(overrides, [\"data\"]));\n        tx.to = await contract.getAddress();\n        if (tx.from) {\n            tx.from = await resolveAddress(tx.from, getResolver(contract.runner));\n        }\n        const iface = contract.interface;\n        const noValue = (getBigInt((tx.value || BN_0), \"overrides.value\") === BN_0);\n        const noData = ((tx.data || \"0x\") === \"0x\");\n        if (iface.fallback && !iface.fallback.payable && iface.receive && !noData && !noValue) {\n            assertArgument(false, \"cannot send data to receive or send value to non-payable fallback\", \"overrides\", overrides);\n        }\n        assertArgument(iface.fallback || noData, \"cannot send data to receive-only contract\", \"overrides.data\", tx.data);\n        // Only allow payable contracts to set non-zero value\n        const payable = iface.receive || (iface.fallback && iface.fallback.payable);\n        assertArgument(payable || noValue, \"cannot send value to non-payable fallback\", \"overrides.value\", tx.value);\n        // Only allow fallback contracts to set non-empty data\n        assertArgument(iface.fallback || noData, \"cannot send data to receive-only contract\", \"overrides.data\", tx.data);\n        return tx;\n    };\n    const staticCall = async function (overrides) {\n        const runner = getRunner(contract.runner, \"call\");\n        assert(canCall(runner), \"contract runner does not support calling\", \"UNSUPPORTED_OPERATION\", { operation: \"call\" });\n        const tx = await populateTransaction(overrides);\n        try {\n            return await runner.call(tx);\n        }\n        catch (error) {\n            if (isCallException(error) && error.data) {\n                throw contract.interface.makeError(error.data, tx);\n            }\n            throw error;\n        }\n    };\n    const send = async function (overrides) {\n        const runner = contract.runner;\n        assert(canSend(runner), \"contract runner does not support sending transactions\", \"UNSUPPORTED_OPERATION\", { operation: \"sendTransaction\" });\n        const tx = await runner.sendTransaction(await populateTransaction(overrides));\n        const provider = getProvider(contract.runner);\n        // @TODO: the provider can be null; make a custom dummy provider that will throw a\n        // meaningful error\n        return new ContractTransactionResponse(contract.interface, provider, tx);\n    };\n    const estimateGas = async function (overrides) {\n        const runner = getRunner(contract.runner, \"estimateGas\");\n        assert(canEstimate(runner), \"contract runner does not support gas estimation\", \"UNSUPPORTED_OPERATION\", { operation: \"estimateGas\" });\n        return await runner.estimateGas(await populateTransaction(overrides));\n    };\n    const method = async (overrides) => {\n        return await send(overrides);\n    };\n    defineProperties(method, {\n        _contract: contract,\n        estimateGas,\n        populateTransaction,\n        send, staticCall\n    });\n    return method;\n}\nfunction buildWrappedMethod(contract, key) {\n    const getFragment = function (...args) {\n        const fragment = contract.interface.getFunction(key, args);\n        assert(fragment, \"no matching fragment\", \"UNSUPPORTED_OPERATION\", {\n            operation: \"fragment\",\n            info: { key, args }\n        });\n        return fragment;\n    };\n    const populateTransaction = async function (...args) {\n        const fragment = getFragment(...args);\n        // If an overrides was passed in, copy it and normalize the values\n        let overrides = {};\n        if (fragment.inputs.length + 1 === args.length) {\n            overrides = await copyOverrides(args.pop());\n            if (overrides.from) {\n                overrides.from = await resolveAddress(overrides.from, getResolver(contract.runner));\n            }\n        }\n        if (fragment.inputs.length !== args.length) {\n            throw new Error(\"internal error: fragment inputs doesn't match arguments; should not happen\");\n        }\n        const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args);\n        return Object.assign({}, overrides, await resolveProperties({\n            to: contract.getAddress(),\n            data: contract.interface.encodeFunctionData(fragment, resolvedArgs)\n        }));\n    };\n    const staticCall = async function (...args) {\n        const result = await staticCallResult(...args);\n        if (result.length === 1) {\n            return result[0];\n        }\n        return result;\n    };\n    const send = async function (...args) {\n        const runner = contract.runner;\n        assert(canSend(runner), \"contract runner does not support sending transactions\", \"UNSUPPORTED_OPERATION\", { operation: \"sendTransaction\" });\n        const tx = await runner.sendTransaction(await populateTransaction(...args));\n        const provider = getProvider(contract.runner);\n        // @TODO: the provider can be null; make a custom dummy provider that will throw a\n        // meaningful error\n        return new ContractTransactionResponse(contract.interface, provider, tx);\n    };\n    const estimateGas = async function (...args) {\n        const runner = getRunner(contract.runner, \"estimateGas\");\n        assert(canEstimate(runner), \"contract runner does not support gas estimation\", \"UNSUPPORTED_OPERATION\", { operation: \"estimateGas\" });\n        return await runner.estimateGas(await populateTransaction(...args));\n    };\n    const staticCallResult = async function (...args) {\n        const runner = getRunner(contract.runner, \"call\");\n        assert(canCall(runner), \"contract runner does not support calling\", \"UNSUPPORTED_OPERATION\", { operation: \"call\" });\n        const tx = await populateTransaction(...args);\n        let result = \"0x\";\n        try {\n            result = await runner.call(tx);\n        }\n        catch (error) {\n            if (isCallException(error) && error.data) {\n                throw contract.interface.makeError(error.data, tx);\n            }\n            throw error;\n        }\n        const fragment = getFragment(...args);\n        return contract.interface.decodeFunctionResult(fragment, result);\n    };\n    const method = async (...args) => {\n        const fragment = getFragment(...args);\n        if (fragment.constant) {\n            return await staticCall(...args);\n        }\n        return await send(...args);\n    };\n    defineProperties(method, {\n        name: contract.interface.getFunctionName(key),\n        _contract: contract, _key: key,\n        getFragment,\n        estimateGas,\n        populateTransaction,\n        send, staticCall, staticCallResult,\n    });\n    // Only works on non-ambiguous keys (refined fragment is always non-ambiguous)\n    Object.defineProperty(method, \"fragment\", {\n        configurable: false,\n        enumerable: true,\n        get: () => {\n            const fragment = contract.interface.getFunction(key);\n            assert(fragment, \"no matching fragment\", \"UNSUPPORTED_OPERATION\", {\n                operation: \"fragment\",\n                info: { key }\n            });\n            return fragment;\n        }\n    });\n    return method;\n}\nfunction buildWrappedEvent(contract, key) {\n    const getFragment = function (...args) {\n        const fragment = contract.interface.getEvent(key, args);\n        assert(fragment, \"no matching fragment\", \"UNSUPPORTED_OPERATION\", {\n            operation: \"fragment\",\n            info: { key, args }\n        });\n        return fragment;\n    };\n    const method = function (...args) {\n        return new PreparedTopicFilter(contract, getFragment(...args), args);\n    };\n    defineProperties(method, {\n        name: contract.interface.getEventName(key),\n        _contract: contract, _key: key,\n        getFragment\n    });\n    // Only works on non-ambiguous keys (refined fragment is always non-ambiguous)\n    Object.defineProperty(method, \"fragment\", {\n        configurable: false,\n        enumerable: true,\n        get: () => {\n            const fragment = contract.interface.getEvent(key);\n            assert(fragment, \"no matching fragment\", \"UNSUPPORTED_OPERATION\", {\n                operation: \"fragment\",\n                info: { key }\n            });\n            return fragment;\n        }\n    });\n    return method;\n}\n// The combination of TypeScrype, Private Fields and Proxies makes\n// the world go boom; so we hide variables with some trickery keeping\n// a symbol attached to each BaseContract which its sub-class (even\n// via a Proxy) can reach and use to look up its internal values.\nconst internal = Symbol.for(\"_ethersInternal_contract\");\nconst internalValues = new WeakMap();\nfunction setInternal(contract, values) {\n    internalValues.set(contract[internal], values);\n}\nfunction getInternal(contract) {\n    return internalValues.get(contract[internal]);\n}\nfunction isDeferred(value) {\n    return (value && typeof (value) === \"object\" && (\"getTopicFilter\" in value) &&\n        (typeof (value.getTopicFilter) === \"function\") && value.fragment);\n}\nasync function getSubInfo(contract, event) {\n    let topics;\n    let fragment = null;\n    // Convert named events to topicHash and get the fragment for\n    // events which need deconstructing.\n    if (Array.isArray(event)) {\n        const topicHashify = function (name) {\n            if (isHexString(name, 32)) {\n                return name;\n            }\n            const fragment = contract.interface.getEvent(name);\n            assertArgument(fragment, \"unknown fragment\", \"name\", name);\n            return fragment.topicHash;\n        };\n        // Array of Topics and Names; e.g. `[ \"0x1234...89ab\", \"Transfer(address)\" ]`\n        topics = event.map((e) => {\n            if (e == null) {\n                return null;\n            }\n            if (Array.isArray(e)) {\n                return e.map(topicHashify);\n            }\n            return topicHashify(e);\n        });\n    }\n    else if (event === \"*\") {\n        topics = [null];\n    }\n    else if (typeof (event) === \"string\") {\n        if (isHexString(event, 32)) {\n            // Topic Hash\n            topics = [event];\n        }\n        else {\n            // Name or Signature; e.g. `\"Transfer\", `\"Transfer(address)\"`\n            fragment = contract.interface.getEvent(event);\n            assertArgument(fragment, \"unknown fragment\", \"event\", event);\n            topics = [fragment.topicHash];\n        }\n    }\n    else if (isDeferred(event)) {\n        // Deferred Topic Filter; e.g. `contract.filter.Transfer(from)`\n        topics = await event.getTopicFilter();\n    }\n    else if (\"fragment\" in event) {\n        // ContractEvent; e.g. `contract.filter.Transfer`\n        fragment = event.fragment;\n        topics = [fragment.topicHash];\n    }\n    else {\n        assertArgument(false, \"unknown event name\", \"event\", event);\n    }\n    // Normalize topics and sort TopicSets\n    topics = topics.map((t) => {\n        if (t == null) {\n            return null;\n        }\n        if (Array.isArray(t)) {\n            const items = Array.from(new Set(t.map((t) => t.toLowerCase())).values());\n            if (items.length === 1) {\n                return items[0];\n            }\n            items.sort();\n            return items;\n        }\n        return t.toLowerCase();\n    });\n    const tag = topics.map((t) => {\n        if (t == null) {\n            return \"null\";\n        }\n        if (Array.isArray(t)) {\n            return t.join(\"|\");\n        }\n        return t;\n    }).join(\"&\");\n    return { fragment, tag, topics };\n}\nasync function hasSub(contract, event) {\n    const { subs } = getInternal(contract);\n    return subs.get((await getSubInfo(contract, event)).tag) || null;\n}\nasync function getSub(contract, operation, event) {\n    // Make sure our runner can actually subscribe to events\n    const provider = getProvider(contract.runner);\n    assert(provider, \"contract runner does not support subscribing\", \"UNSUPPORTED_OPERATION\", { operation });\n    const { fragment, tag, topics } = await getSubInfo(contract, event);\n    const { addr, subs } = getInternal(contract);\n    let sub = subs.get(tag);\n    if (!sub) {\n        const address = (addr ? addr : contract);\n        const filter = { address, topics };\n        const listener = (log) => {\n            let foundFragment = fragment;\n            if (foundFragment == null) {\n                try {\n                    foundFragment = contract.interface.getEvent(log.topics[0]);\n                }\n                catch (error) { }\n            }\n            // If fragment is null, we do not deconstruct the args to emit\n            if (foundFragment) {\n                const _foundFragment = foundFragment;\n                const args = fragment ? contract.interface.decodeEventLog(fragment, log.data, log.topics) : [];\n                emit(contract, event, args, (listener) => {\n                    return new ContractEventPayload(contract, listener, event, _foundFragment, log);\n                });\n            }\n            else {\n                emit(contract, event, [], (listener) => {\n                    return new ContractUnknownEventPayload(contract, listener, event, log);\n                });\n            }\n        };\n        let starting = [];\n        const start = () => {\n            if (starting.length) {\n                return;\n            }\n            starting.push(provider.on(filter, listener));\n        };\n        const stop = async () => {\n            if (starting.length == 0) {\n                return;\n            }\n            let started = starting;\n            starting = [];\n            await Promise.all(started);\n            provider.off(filter, listener);\n        };\n        sub = { tag, listeners: [], start, stop };\n        subs.set(tag, sub);\n    }\n    return sub;\n}\n// We use this to ensure one emit resolves before firing the next to\n// ensure correct ordering (note this cannot throw and just adds the\n// notice to the event queu using setTimeout).\nlet lastEmit = Promise.resolve();\nasync function _emit(contract, event, args, payloadFunc) {\n    await lastEmit;\n    const sub = await hasSub(contract, event);\n    if (!sub) {\n        return false;\n    }\n    const count = sub.listeners.length;\n    sub.listeners = sub.listeners.filter(({ listener, once }) => {\n        const passArgs = Array.from(args);\n        if (payloadFunc) {\n            passArgs.push(payloadFunc(once ? null : listener));\n        }\n        try {\n            listener.call(contract, ...passArgs);\n        }\n        catch (error) { }\n        return !once;\n    });\n    if (sub.listeners.length === 0) {\n        sub.stop();\n        getInternal(contract).subs.delete(sub.tag);\n    }\n    return (count > 0);\n}\nasync function emit(contract, event, args, payloadFunc) {\n    try {\n        await lastEmit;\n    }\n    catch (error) { }\n    const resultPromise = _emit(contract, event, args, payloadFunc);\n    lastEmit = resultPromise;\n    return await resultPromise;\n}\nconst passProperties = [\"then\"];\nexport class BaseContract {\n    /**\n     *  The target to connect to.\n     *\n     *  This can be an address, ENS name or any [[Addressable]], such as\n     *  another contract. To get the resovled address, use the ``getAddress``\n     *  method.\n     */\n    target;\n    /**\n     *  The contract Interface.\n     */\n    interface;\n    /**\n     *  The connected runner. This is generally a [[Provider]] or a\n     *  [[Signer]], which dictates what operations are supported.\n     *\n     *  For example, a **Contract** connected to a [[Provider]] may\n     *  only execute read-only operations.\n     */\n    runner;\n    /**\n     *  All the Events available on this contract.\n     */\n    filters;\n    /**\n     *  @_ignore:\n     */\n    [internal];\n    /**\n     *  The fallback or receive function if any.\n     */\n    fallback;\n    /**\n     *  Creates a new contract connected to %%target%% with the %%abi%% and\n     *  optionally connected to a %%runner%% to perform operations on behalf\n     *  of.\n     */\n    constructor(target, abi, runner, _deployTx) {\n        assertArgument(typeof (target) === \"string\" || isAddressable(target), \"invalid value for Contract target\", \"target\", target);\n        if (runner == null) {\n            runner = null;\n        }\n        const iface = Interface.from(abi);\n        defineProperties(this, { target, runner, interface: iface });\n        Object.defineProperty(this, internal, { value: {} });\n        let addrPromise;\n        let addr = null;\n        let deployTx = null;\n        if (_deployTx) {\n            const provider = getProvider(runner);\n            // @TODO: the provider can be null; make a custom dummy provider that will throw a\n            // meaningful error\n            deployTx = new ContractTransactionResponse(this.interface, provider, _deployTx);\n        }\n        let subs = new Map();\n        // Resolve the target as the address\n        if (typeof (target) === \"string\") {\n            if (isHexString(target)) {\n                addr = target;\n                addrPromise = Promise.resolve(target);\n            }\n            else {\n                const resolver = getRunner(runner, \"resolveName\");\n                if (!canResolve(resolver)) {\n                    throw makeError(\"contract runner does not support name resolution\", \"UNSUPPORTED_OPERATION\", {\n                        operation: \"resolveName\"\n                    });\n                }\n                addrPromise = resolver.resolveName(target).then((addr) => {\n                    if (addr == null) {\n                        throw makeError(\"an ENS name used for a contract target must be correctly configured\", \"UNCONFIGURED_NAME\", {\n                            value: target\n                        });\n                    }\n                    getInternal(this).addr = addr;\n                    return addr;\n                });\n            }\n        }\n        else {\n            addrPromise = target.getAddress().then((addr) => {\n                if (addr == null) {\n                    throw new Error(\"TODO\");\n                }\n                getInternal(this).addr = addr;\n                return addr;\n            });\n        }\n        // Set our private values\n        setInternal(this, { addrPromise, addr, deployTx, subs });\n        // Add the event filters\n        const filters = new Proxy({}, {\n            get: (target, prop, receiver) => {\n                // Pass important checks (like `then` for Promise) through\n                if (typeof (prop) === \"symbol\" || passProperties.indexOf(prop) >= 0) {\n                    return Reflect.get(target, prop, receiver);\n                }\n                try {\n                    return this.getEvent(prop);\n                }\n                catch (error) {\n                    if (!isError(error, \"INVALID_ARGUMENT\") || error.argument !== \"key\") {\n                        throw error;\n                    }\n                }\n                return undefined;\n            },\n            has: (target, prop) => {\n                // Pass important checks (like `then` for Promise) through\n                if (passProperties.indexOf(prop) >= 0) {\n                    return Reflect.has(target, prop);\n                }\n                return Reflect.has(target, prop) || this.interface.hasEvent(String(prop));\n            }\n        });\n        defineProperties(this, { filters });\n        defineProperties(this, {\n            fallback: ((iface.receive || iface.fallback) ? (buildWrappedFallback(this)) : null)\n        });\n        // Return a Proxy that will respond to functions\n        return new Proxy(this, {\n            get: (target, prop, receiver) => {\n                if (typeof (prop) === \"symbol\" || prop in target || passProperties.indexOf(prop) >= 0) {\n                    return Reflect.get(target, prop, receiver);\n                }\n                // Undefined properties should return undefined\n                try {\n                    return target.getFunction(prop);\n                }\n                catch (error) {\n                    if (!isError(error, \"INVALID_ARGUMENT\") || error.argument !== \"key\") {\n                        throw error;\n                    }\n                }\n                return undefined;\n            },\n            has: (target, prop) => {\n                if (typeof (prop) === \"symbol\" || prop in target || passProperties.indexOf(prop) >= 0) {\n                    return Reflect.has(target, prop);\n                }\n                return target.interface.hasFunction(prop);\n            }\n        });\n    }\n    /**\n     *  Return a new Contract instance with the same target and ABI, but\n     *  a different %%runner%%.\n     */\n    connect(runner) {\n        return new BaseContract(this.target, this.interface, runner);\n    }\n    /**\n     *  Return a new Contract instance with the same ABI and runner, but\n     *  a different %%target%%.\n     */\n    attach(target) {\n        return new BaseContract(target, this.interface, this.runner);\n    }\n    /**\n     *  Return the resolved address of this Contract.\n     */\n    async getAddress() { return await getInternal(this).addrPromise; }\n    /**\n     *  Return the deployed bytecode or null if no bytecode is found.\n     */\n    async getDeployedCode() {\n        const provider = getProvider(this.runner);\n        assert(provider, \"runner does not support .provider\", \"UNSUPPORTED_OPERATION\", { operation: \"getDeployedCode\" });\n        const code = await provider.getCode(await this.getAddress());\n        if (code === \"0x\") {\n            return null;\n        }\n        return code;\n    }\n    /**\n     *  Resolve to this Contract once the bytecode has been deployed, or\n     *  resolve immediately if already deployed.\n     */\n    async waitForDeployment() {\n        // We have the deployement transaction; just use that (throws if deployement fails)\n        const deployTx = this.deploymentTransaction();\n        if (deployTx) {\n            await deployTx.wait();\n            return this;\n        }\n        // Check for code\n        const code = await this.getDeployedCode();\n        if (code != null) {\n            return this;\n        }\n        // Make sure we can subscribe to a provider event\n        const provider = getProvider(this.runner);\n        assert(provider != null, \"contract runner does not support .provider\", \"UNSUPPORTED_OPERATION\", { operation: \"waitForDeployment\" });\n        return new Promise((resolve, reject) => {\n            const checkCode = async () => {\n                try {\n                    const code = await this.getDeployedCode();\n                    if (code != null) {\n                        return resolve(this);\n                    }\n                    provider.once(\"block\", checkCode);\n                }\n                catch (error) {\n                    reject(error);\n                }\n            };\n            checkCode();\n        });\n    }\n    /**\n     *  Return the transaction used to deploy this contract.\n     *\n     *  This is only available if this instance was returned from a\n     *  [[ContractFactory]].\n     */\n    deploymentTransaction() {\n        return getInternal(this).deployTx;\n    }\n    /**\n     *  Return the function for a given name. This is useful when a contract\n     *  method name conflicts with a JavaScript name such as ``prototype`` or\n     *  when using a Contract programatically.\n     */\n    getFunction(key) {\n        if (typeof (key) !== \"string\") {\n            key = key.format();\n        }\n        const func = buildWrappedMethod(this, key);\n        return func;\n    }\n    /**\n     *  Return the event for a given name. This is useful when a contract\n     *  event name conflicts with a JavaScript name such as ``prototype`` or\n     *  when using a Contract programatically.\n     */\n    getEvent(key) {\n        if (typeof (key) !== \"string\") {\n            key = key.format();\n        }\n        return buildWrappedEvent(this, key);\n    }\n    /**\n     *  @_ignore:\n     */\n    async queryTransaction(hash) {\n        throw new Error(\"@TODO\");\n    }\n    /*\n    // @TODO: this is a non-backwards compatible change, but will be added\n    //        in v7 and in a potential SmartContract class in an upcoming\n    //        v6 release\n    async getTransactionReceipt(hash: string): Promise<null | ContractTransactionReceipt> {\n        const provider = getProvider(this.runner);\n        assert(provider, \"contract runner does not have a provider\",\n            \"UNSUPPORTED_OPERATION\", { operation: \"queryTransaction\" });\n\n        const receipt = await provider.getTransactionReceipt(hash);\n        if (receipt == null) { return null; }\n\n        return new ContractTransactionReceipt(this.interface, provider, receipt);\n    }\n    */\n    /**\n     *  Provide historic access to event data for %%event%% in the range\n     *  %%fromBlock%% (default: ``0``) to %%toBlock%% (default: ``\"latest\"``)\n     *  inclusive.\n     */\n    async queryFilter(event, fromBlock, toBlock) {\n        if (fromBlock == null) {\n            fromBlock = 0;\n        }\n        if (toBlock == null) {\n            toBlock = \"latest\";\n        }\n        const { addr, addrPromise } = getInternal(this);\n        const address = (addr ? addr : (await addrPromise));\n        const { fragment, topics } = await getSubInfo(this, event);\n        const filter = { address, topics, fromBlock, toBlock };\n        const provider = getProvider(this.runner);\n        assert(provider, \"contract runner does not have a provider\", \"UNSUPPORTED_OPERATION\", { operation: \"queryFilter\" });\n        return (await provider.getLogs(filter)).map((log) => {\n            let foundFragment = fragment;\n            if (foundFragment == null) {\n                try {\n                    foundFragment = this.interface.getEvent(log.topics[0]);\n                }\n                catch (error) { }\n            }\n            if (foundFragment) {\n                try {\n                    return new EventLog(log, this.interface, foundFragment);\n                }\n                catch (error) {\n                    return new UndecodedEventLog(log, error);\n                }\n            }\n            return new Log(log, provider);\n        });\n    }\n    /**\n     *  Add an event %%listener%% for the %%event%%.\n     */\n    async on(event, listener) {\n        const sub = await getSub(this, \"on\", event);\n        sub.listeners.push({ listener, once: false });\n        sub.start();\n        return this;\n    }\n    /**\n     *  Add an event %%listener%% for the %%event%%, but remove the listener\n     *  after it is fired once.\n     */\n    async once(event, listener) {\n        const sub = await getSub(this, \"once\", event);\n        sub.listeners.push({ listener, once: true });\n        sub.start();\n        return this;\n    }\n    /**\n     *  Emit an %%event%% calling all listeners with %%args%%.\n     *\n     *  Resolves to ``true`` if any listeners were called.\n     */\n    async emit(event, ...args) {\n        return await emit(this, event, args, null);\n    }\n    /**\n     *  Resolves to the number of listeners of %%event%% or the total number\n     *  of listeners if unspecified.\n     */\n    async listenerCount(event) {\n        if (event) {\n            const sub = await hasSub(this, event);\n            if (!sub) {\n                return 0;\n            }\n            return sub.listeners.length;\n        }\n        const { subs } = getInternal(this);\n        let total = 0;\n        for (const { listeners } of subs.values()) {\n            total += listeners.length;\n        }\n        return total;\n    }\n    /**\n     *  Resolves to the listeners subscribed to %%event%% or all listeners\n     *  if unspecified.\n     */\n    async listeners(event) {\n        if (event) {\n            const sub = await hasSub(this, event);\n            if (!sub) {\n                return [];\n            }\n            return sub.listeners.map(({ listener }) => listener);\n        }\n        const { subs } = getInternal(this);\n        let result = [];\n        for (const { listeners } of subs.values()) {\n            result = result.concat(listeners.map(({ listener }) => listener));\n        }\n        return result;\n    }\n    /**\n     *  Remove the %%listener%% from the listeners for %%event%% or remove\n     *  all listeners if unspecified.\n     */\n    async off(event, listener) {\n        const sub = await hasSub(this, event);\n        if (!sub) {\n            return this;\n        }\n        if (listener) {\n            const index = sub.listeners.map(({ listener }) => listener).indexOf(listener);\n            if (index >= 0) {\n                sub.listeners.splice(index, 1);\n            }\n        }\n        if (listener == null || sub.listeners.length === 0) {\n            sub.stop();\n            getInternal(this).subs.delete(sub.tag);\n        }\n        return this;\n    }\n    /**\n     *  Remove all the listeners for %%event%% or remove all listeners if\n     *  unspecified.\n     */\n    async removeAllListeners(event) {\n        if (event) {\n            const sub = await hasSub(this, event);\n            if (!sub) {\n                return this;\n            }\n            sub.stop();\n            getInternal(this).subs.delete(sub.tag);\n        }\n        else {\n            const { subs } = getInternal(this);\n            for (const { tag, stop } of subs.values()) {\n                stop();\n                subs.delete(tag);\n            }\n        }\n        return this;\n    }\n    /**\n     *  Alias for [on].\n     */\n    async addListener(event, listener) {\n        return await this.on(event, listener);\n    }\n    /**\n     *  Alias for [off].\n     */\n    async removeListener(event, listener) {\n        return await this.off(event, listener);\n    }\n    /**\n     *  Create a new Class for the %%abi%%.\n     */\n    static buildClass(abi) {\n        class CustomContract extends BaseContract {\n            constructor(address, runner = null) {\n                super(address, abi, runner);\n            }\n        }\n        return CustomContract;\n    }\n    ;\n    /**\n     *  Create a new BaseContract with a specified Interface.\n     */\n    static from(target, abi, runner) {\n        if (runner == null) {\n            runner = null;\n        }\n        const contract = new this(target, abi, runner);\n        return contract;\n    }\n}\nfunction _ContractBase() {\n    return BaseContract;\n}\n/**\n *  A [[BaseContract]] with no type guards on its methods or events.\n */\nexport class Contract extends _ContractBase() {\n}\n//# sourceMappingURL=contract.js.map"],"names":["EventPayload","emitter","listener","filter","__publicField","__privateAdd","_listener","__privateSet","defineProperties","__privateGet","errorFunc","reason","offset","bytes","output","badCodepoint","assertArgument","ignoreFunc","o","replaceFunc","Utf8ErrorFuncs","getUtf8CodePoints","_bytes","onError","getBytes","result","i","c","extraLength","overlongMask","res","j","nextChar","toUtf8Bytes","str","form","assertNormalize","c2","pair","_toUtf8String","codePoints","codePoint","toUtf8String","toUtf8CodePoints","WordSize","Padding","passProperties","_guard","throwError","name","error","wrapped","_Result","args","guard","items","names","wrap","_names","item","index","nameCounts","accum","target","prop","receiver","getNumber","value","deep","assert","child","start","end","callback","thisArg","keys","Result","checkResultErrors","errors","checkErrors","path","object","key","childPath","getValue","toBeArray","getBytesCopy","concat","Coder","type","localName","dynamic","message","Writer","_writeData","_data","_dataLength","writer","__privateMethod","writeData_fn","paddingOffset","data","_Reader","allowLoose","maxInflation","_incrementBytesRead","_peekBytes","_offset","_bytesRead","_parent","_maxInflation","hexlify","reader","length","loose","peekBytes_fn","incrementBytesRead_fn","toBigInt","toNumber","count","_a","alignedLength","Reader","number","n","b","lengths","hash","exists","instance","checkFinished","out","min","crypto","u8a","a","u32","arr","createView","rotr","word","shift","isLE","nextTick","asyncLoop","iters","tick","cb","ts","diff","utf8ToBytes","toBytes","concatBytes","arrays","r","sum","pad","Hash","toStr","checkOpts","defaults","opts","wrapConstructor","hashCons","hashC","msg","tmp","randomBytes","bytesLength","U32_MASK64","_32n","fromBig","le","split","lst","Ah","Al","h","l","toBig","shrSH","_l","s","shrSL","rotrSH","rotrSL","rotrBH","rotrBL","rotr32H","_h","rotr32L","rotlSH","rotlSL","rotlBH","rotlBL","add","Bh","Bl","add3L","Cl","add3H","low","Ch","add4L","Dl","add4H","Dh","add5L","El","add5H","Eh","u64","SHA3_PI","SHA3_ROTL","_SHA3_IOTA","_0n","_1n","_2n","_7n","_256n","_0x71n","round","R","x","y","t","SHA3_IOTA_H","SHA3_IOTA_L","rotlH","rotlL","keccakP","rounds","B","idx1","idx0","B0","B1","Th","Tl","curH","curL","PI","Keccak","blockLen","suffix","outputLen","enableXOF","state","len","pos","take","bufferOut","to","gen","keccak_256","locked","_keccak256","__keccak256","keccak256","func","BN_0","BN_36","getChecksumAddress","address","chars","expanded","hashed","ibanLookup","safeDigits","ibanChecksum","block","checksum","Base36","fromBase36","getAddress","getIcapAddress","base36","isAddressable","isAddress","checkAddress","promise","resolveAddress","resolver","_gaurd","width","signed","Typed","size","_typedSymbol","_Typed","gaurd","options","_options","assertPrivate","v","AddressCoder","_value","toBeHex","AnonymousCoder","coder","pack","coders","values","arrayValues","unique","staticWriter","dynamicWriter","updateFuncs","dynamicOffset","updateFunc","baseOffset","unpack","baseReader","offsetReader","isError","ArrayCoder","defaultChild","assertArgumentCount","BooleanCoder","DynamicBytesCoder","BytesCoder","FixedBytesCoder","Empty","NullCoder","BN_1","BN_MAX_UINT256","NumberCoder","getBigInt","maxUintValue","mask","bounds","toTwos","fromTwos","StringCoder","TupleCoder","types","uniqueNames","id","accessSetify","addr","storageKeys","storageKey","isHexString","accessListify","set","setify","k","_kwVisibDeploy","KwVisibDeploy","_kwVisib","KwVisib","_kwTypes","KwTypes","_kwModifiers","KwModifiers","_kwOther","_keywords","Keywords","SimpleTokens","regexWhitespacePrefix","regexNumberPrefix","regexIdPrefix","regexId","regexType","_TokenString","tokens","_subTokenString","_tokens","allowed","top","subTokenString_fn","link","__privateWrapper","token","from","TokenString","lex","text","brackets","commas","cur","match","allowSingle","included","consumeName","keyword","consumeKeywords","keywords","consumeMutability","modifiers","consumeParams","allowIndexed","ParamType","consumeGas","consumeEoi","regexArrayType","verifyBasicType","internal","ParamTypeInternal","ErrorFragmentInternal","EventFragmentInternal","ConstructorFragmentInternal","FallbackFragmentInternal","FunctionFragmentInternal","StructFragmentInternal","_ParamType","baseType","indexed","components","arrayLength","arrayChildren","_walkAsync","format","comp","process","_this","promises","walkAsync_fn","obj","comps","bracket","arrayMatch","setValue","childType","param","Fragment","inputs","ConstructorFragment","ErrorFragment","EventFragment","FallbackFragment","FunctionFragment","StructFragment","NamedFragment","joinParams","params","p","input","anonymous","payable","gas","stateMutability","errorObj","topIsValid","mutability","outputs","PanicReasons","paramTypeBytes","paramTypeNumber","defaultCoder","defaultMaxInflation","getBuiltinCallException","action","tx","abiCoder","invocation","revert","code","transaction","makeError","_AbiCoder","_getCoder","getCoder_fn","AbiCoder","LogDescription","fragment","topic","signature","TransactionDescription","selector","ErrorDescription","Indexed","BuiltinErrors","_Interface","fragments","_getFunction","_getEvent","_errors","_events","_functions","_abiCoder","abi","frags","fallback","receive","bucket","minimal","f","getFunction_fn","getEvent_fn","matching","matchStr","m","dataSlice","ef","parsed","topics","encodeTopic","zeroPadBytes","zeroPadValue","dataTypes","dataValues","eventTopic","nonIndexed","resultIndexed","resultNonIndexed","nonIndexedIndex","indexedIndex","log","hexData","forceUnique","lastValue","valueLength","allowOptions","lastArg","Interface","toJson","FeeData","gasPrice","maxFeePerGas","maxPriorityFeePerGas","copyRequest","req","bigIntKeys","numberKeys","isBytesLike","Block","provider","_transactions","TransactionResponse","txs","baseFeePerGas","difficulty","extraData","gasLimit","gasUsed","miner","prevRandao","nonce","parentHash","parentBeaconBlockRoot","stateRoot","receiptsRoot","timestamp","transactions","indexOrHash","createOrphanedBlockFilter","Log","blockHash","blockNumber","removed","transactionHash","transactionIndex","receipt","createRemovedLogFilter","TransactionReceipt","_logs","contractAddress","logsBloom","logs","status","root","createRemovedTransactionFilter","other","createReorderedTransactionFilter","_TransactionResponse","_startBlock","accessList","blobVersionedHashes","resolveProperties","_confirms","_timeout","confirms","timeout","startBlock","nextScan","stopScanning","checkReplacement","mined","checkReceipt","resolve","reject","cancellers","cancel","timer","txListener","replaceListener","EventLog","iface","UndecodedEventLog","ContractTransactionReceipt","_iface","ContractTransactionResponse","ContractUnknownEventPayload","contract","ContractEventPayload","_log","canCall","canEstimate","canResolve","canSend","getResolver","PreparedTopicFilter","_filter","runner","getRunner","resolvedArgs","feature","getProvider","copyOverrides","arg","_overrides","overrides","resolveArgs","_runner","buildWrappedFallback","populateTransaction","noValue","noData","staticCall","isCallException","send","estimateGas","method","buildWrappedMethod","getFragment","staticCallResult","buildWrappedEvent","internalValues","setInternal","getInternal","isDeferred","getSubInfo","event","topicHashify","e","tag","hasSub","subs","getSub","operation","sub","foundFragment","_foundFragment","emit","starting","started","lastEmit","_emit","payloadFunc","once","passArgs","resultPromise","_BaseContract","_deployTx","addrPromise","deployTx","filters","checkCode","fromBlock","toBlock","total","listeners","stop","CustomContract","BaseContract","_ContractBase","Contract"],"mappings":"2qCAaO,MAAMA,EAAa,CActB,YAAYC,EAASC,EAAUC,EAAQ,CAVvCC,EAAA,eAIAA,EAAA,gBACAC,EAAA,KAAAC,GAAA,QAMIC,EAAA,KAAKD,GAAYJ,GACjBM,EAAiB,KAAM,CAAE,QAAAP,EAAS,OAAAE,CAAQ,CAAA,CAC7C,CAID,MAAM,gBAAiB,CACfM,EAAA,KAAKH,KAAa,MAGtB,MAAM,KAAK,QAAQ,IAAI,KAAK,OAAQG,EAAA,KAAKH,GAAS,CACrD,CACL,CAlBIA,GAAA,YCZJ,SAASI,GAAUC,EAAQC,EAAQC,EAAOC,EAAQC,EAAc,CAC5DC,EAAe,GAAO,+BAA+BJ,CAAM,KAAKD,CAAM,GAAI,QAASE,CAAK,CAC5F,CACA,SAASI,GAAWN,EAAQC,EAAQC,EAAOC,EAAQC,EAAc,CAE7D,GAAIJ,IAAW,cAAgBA,IAAW,sBAAuB,CAC7D,IAAI,EAAI,EACR,QAASO,EAAIN,EAAS,EAAGM,EAAIL,EAAM,QAC3BA,EAAMK,CAAC,GAAK,IAAM,EADiBA,IAIvC,IAEJ,OAAO,CACV,CAGD,OAAIP,IAAW,UACJE,EAAM,OAASD,EAAS,EAG5B,CACX,CACA,SAASO,GAAYR,EAAQC,EAAQC,EAAOC,EAAQC,EAAc,CAE9D,OAAIJ,IAAW,YACXK,EAAe,OAAQD,GAAkB,SAAU,yCAA0C,eAAgBA,CAAY,EACzHD,EAAO,KAAKC,CAAY,EACjB,IAGXD,EAAO,KAAK,KAAM,EAEXG,GAAWN,EAAQC,EAAQC,CAA2B,EACjE,CAgBY,MAACO,GAAiB,OAAO,OAAO,CACxC,MAAOV,GACP,OAAQO,GACR,QAASE,EACb,CAAC,EAED,SAASE,GAAkBC,EAAQC,EAAS,CACpCA,GAAW,OACXA,EAAUH,GAAe,OAE7B,MAAMP,EAAQW,GAASF,EAAQ,OAAO,EAChCG,EAAS,CAAA,EACf,IAAIC,EAAI,EAER,KAAOA,EAAIb,EAAM,QAAQ,CACrB,MAAMc,EAAId,EAAMa,GAAG,EAEnB,GAAI,EAAAC,GAAK,GAAS,CACdF,EAAO,KAAKE,CAAC,EACb,QACH,CAED,IAAIC,EAAc,KACdC,EAAe,KAEnB,IAAKF,EAAI,OAAU,IACfC,EAAc,EACdC,EAAe,aAGTF,EAAI,OAAU,IACpBC,EAAc,EACdC,EAAe,cAGTF,EAAI,OAAU,IACpBC,EAAc,EACdC,EAAe,UAEd,EACIF,EAAI,OAAU,IACfD,GAAKH,EAAQ,sBAAuBG,EAAI,EAAGb,EAAOY,CAAM,EAGxDC,GAAKH,EAAQ,aAAcG,EAAI,EAAGb,EAAOY,CAAM,EAEnD,QACH,CAED,GAAIC,EAAI,EAAIE,GAAef,EAAM,OAAQ,CACrCa,GAAKH,EAAQ,UAAWG,EAAI,EAAGb,EAAOY,CAAM,EAC5C,QACH,CAED,IAAIK,EAAMH,GAAM,GAAM,EAAIC,EAAc,GAAM,EAC9C,QAASG,EAAI,EAAGA,EAAIH,EAAaG,IAAK,CAClC,IAAIC,EAAWnB,EAAMa,CAAC,EAEtB,IAAKM,EAAW,MAAS,IAAM,CAC3BN,GAAKH,EAAQ,mBAAoBG,EAAGb,EAAOY,CAAM,EACjDK,EAAM,KACN,KACH,CAEDA,EAAOA,GAAO,EAAME,EAAW,GAC/BN,GACH,CAED,GAAII,IAAQ,KAIZ,IAAIA,EAAM,QAAU,CAChBJ,GAAKH,EAAQ,eAAgBG,EAAI,EAAIE,EAAaf,EAAOY,EAAQK,CAAG,EACpE,QACH,CAED,GAAIA,GAAO,OAAUA,GAAO,MAAQ,CAChCJ,GAAKH,EAAQ,kBAAmBG,EAAI,EAAIE,EAAaf,EAAOY,EAAQK,CAAG,EACvE,QACH,CAED,GAAIA,GAAOD,EAAc,CACrBH,GAAKH,EAAQ,WAAYG,EAAI,EAAIE,EAAaf,EAAOY,EAAQK,CAAG,EAChE,QACH,CACDL,EAAO,KAAKK,CAAG,EAClB,CACD,OAAOL,CACX,CAOO,SAASQ,GAAYC,EAAKC,EAAM,CACnCnB,EAAe,OAAQkB,GAAS,SAAU,uBAAwB,MAAOA,CAAG,EACxEC,GAAQ,OACRC,GAAgBD,CAAI,EACpBD,EAAMA,EAAI,UAAUC,CAAI,GAE5B,IAAIV,EAAS,CAAA,EACb,QAASC,EAAI,EAAGA,EAAIQ,EAAI,OAAQR,IAAK,CACjC,MAAMC,EAAIO,EAAI,WAAWR,CAAC,EAC1B,GAAIC,EAAI,IACJF,EAAO,KAAKE,CAAC,UAERA,EAAI,KACTF,EAAO,KAAME,GAAK,EAAK,GAAI,EAC3BF,EAAO,KAAME,EAAI,GAAQ,GAAI,WAEvBA,EAAI,QAAW,MAAQ,CAC7BD,IACA,MAAMW,EAAKH,EAAI,WAAWR,CAAC,EAC3BV,EAAeU,EAAIQ,EAAI,SAAYG,EAAK,SAAY,MAAS,yBAA0B,MAAOH,CAAG,EAEjG,MAAMI,EAAO,QAAYX,EAAI,OAAW,KAAOU,EAAK,MACpDZ,EAAO,KAAMa,GAAQ,GAAM,GAAI,EAC/Bb,EAAO,KAAOa,GAAQ,GAAM,GAAQ,GAAI,EACxCb,EAAO,KAAOa,GAAQ,EAAK,GAAQ,GAAI,EACvCb,EAAO,KAAMa,EAAO,GAAQ,GAAI,CACnC,MAEGb,EAAO,KAAME,GAAK,GAAM,GAAI,EAC5BF,EAAO,KAAOE,GAAK,EAAK,GAAQ,GAAI,EACpCF,EAAO,KAAME,EAAI,GAAQ,GAAI,CAEpC,CACD,OAAO,IAAI,WAAWF,CAAM,CAChC,CAGA,SAASc,GAAcC,EAAY,CAC/B,OAAOA,EAAW,IAAKC,GACfA,GAAa,MACN,OAAO,aAAaA,CAAS,GAExCA,GAAa,MACN,OAAO,cAAgBA,GAAa,GAAM,MAAS,OAAWA,EAAY,MAAS,KAAM,EACnG,EAAE,KAAK,EAAE,CACd,CAQO,SAASC,GAAa7B,EAAOU,EAAS,CACzC,OAAOgB,GAAclB,GAAkBR,EAAOU,CAAO,CAAC,CAC1D,CAMO,SAASoB,GAAiBT,EAAKC,EAAM,CACxC,OAAOd,GAAkBY,GAAYC,EAAKC,CAAI,CAAC,CACnD,CCvNO,MAAMS,EAAW,GAClBC,GAAU,IAAI,WAAWD,CAAQ,EAGjCE,GAAiB,CAAC,MAAM,EACxBC,GAAS,CAAA,EACf,SAASC,GAAWC,EAAMC,EAAO,CAC7B,MAAMC,EAAU,IAAI,MAAM,0DAA0DF,CAAI,EAAE,EAC1F,MAAAE,EAAQ,MAAQD,EACVC,CACV,QAQO,MAAMC,GAAN,MAAMA,WAAe,KAAM,CAK9B,eAAeC,EAAM,CAOjB,MAAMC,EAAQD,EAAK,CAAC,EACpB,IAAIE,EAAQF,EAAK,CAAC,EACdG,GAASH,EAAK,CAAC,GAAK,CAAA,GAAI,QACxBI,EAAO,GACPH,IAAUP,KACVQ,EAAQF,EACRG,EAAQ,CAAA,EACRC,EAAO,IAIX,MAAMF,EAAM,MAAM,EAtBtBlD,EAAA,KAAAqD,GAAA,QAuBIH,EAAM,QAAQ,CAACI,EAAMC,IAAU,CAAE,KAAKA,CAAK,EAAID,CAAK,CAAE,EAEtD,MAAME,EAAaL,EAAM,OAAO,CAACM,EAAOb,KAChC,OAAQA,GAAU,UAClBa,EAAM,IAAIb,GAAOa,EAAM,IAAIb,CAAI,GAAK,GAAK,CAAC,EAEvCa,GACP,IAAI,KASR,GAPAvD,EAAA,KAAKmD,GAAS,OAAO,OAAOH,EAAM,IAAI,CAACI,EAAMC,IAAU,CACnD,MAAMX,EAAOO,EAAMI,CAAK,EACxB,OAAIX,GAAQ,MAAQY,EAAW,IAAIZ,CAAI,IAAM,EAClCA,EAEJ,IACV,CAAA,CAAC,GACE,EAACQ,EAIL,cAAO,OAAO,IAAI,EAEX,IAAI,MAAM,KAAM,CACnB,IAAK,CAACM,EAAQC,EAAMC,IAAa,CAC7B,GAAI,OAAQD,GAAU,SAAU,CAE5B,GAAIA,EAAK,MAAM,UAAU,EAAG,CACxB,MAAMJ,EAAQM,GAAUF,EAAM,QAAQ,EACtC,GAAIJ,EAAQ,GAAKA,GAAS,KAAK,OAC3B,MAAM,IAAI,WAAW,qBAAqB,EAE9C,MAAMD,EAAOI,EAAOH,CAAK,EACzB,OAAID,aAAgB,OAChBX,GAAW,SAASY,CAAK,GAAID,CAAI,EAE9BA,CACV,CAED,GAAIb,GAAe,QAAQkB,CAAI,GAAK,EAChC,OAAO,QAAQ,IAAID,EAAQC,EAAMC,CAAQ,EAE7C,MAAME,EAAQJ,EAAOC,CAAI,EACzB,GAAIG,aAAiB,SAGjB,OAAO,YAAad,EAAM,CACtB,OAAOc,EAAM,MAAO,OAASF,EAAYF,EAAS,KAAMV,CAAI,CACxF,EAEyB,GAAI,EAAEW,KAAQD,GAEf,OAAOA,EAAO,SAAS,MAAO,OAASE,EAAYF,EAAS,KAAM,CAACC,CAAI,CAAC,CAE/E,CACD,OAAO,QAAQ,IAAID,EAAQC,EAAMC,CAAQ,CAC5C,CACb,CAAS,CACJ,CAQD,QAAQG,EAAM,CACV,MAAM3C,EAAS,CAAA,EACf,YAAK,QAAQ,CAACkC,EAAMC,IAAU,CACtBD,aAAgB,OAChBX,GAAW,SAASY,CAAK,GAAID,CAAI,EAEjCS,GAAQT,aAAgBP,KACxBO,EAAOA,EAAK,QAAQS,CAAI,GAE5B3C,EAAO,KAAKkC,CAAI,CAC5B,CAAS,EACMlC,CACV,CASD,SAAS2C,EAAM,CACX,OAAO3D,EAAA,KAAKiD,IAAO,OAAO,CAACI,EAAOb,EAAMW,IAAU,CAK9C,GAJAS,EAAOpB,GAAQ,KAAM,oCAAqC,wBAAyB,CAC/E,UAAW,YAC3B,CAAa,EAEG,EAAEA,KAAQa,GAAQ,CAClB,IAAIQ,EAAQ,KAAK,SAASrB,CAAI,EAC1BmB,GAAQE,aAAiBlB,KACzBkB,EAAQA,EAAM,SAASF,CAAI,GAE/BN,EAAMb,CAAI,EAAIqB,CACjB,CACD,OAAOR,CACV,EAAE,CAAE,CAAA,CACR,CAID,MAAMS,EAAOC,EAAK,CACVD,GAAS,OACTA,EAAQ,GAERA,EAAQ,IACRA,GAAS,KAAK,OACVA,EAAQ,IACRA,EAAQ,IAGZC,GAAO,OACPA,EAAM,KAAK,QAEXA,EAAM,IACNA,GAAO,KAAK,OACRA,EAAM,IACNA,EAAM,IAGVA,EAAM,KAAK,SACXA,EAAM,KAAK,QAEf,MAAM/C,EAAS,CAAA,EAAI+B,EAAQ,GAC3B,QAAS9B,EAAI6C,EAAO7C,EAAI8C,EAAK9C,IACzBD,EAAO,KAAK,KAAKC,CAAC,CAAC,EACnB8B,EAAM,KAAK/C,EAAA,KAAKiD,IAAOhC,CAAC,CAAC,EAE7B,OAAO,IAAI0B,GAAOL,GAAQtB,EAAQ+B,CAAK,CAC1C,CAID,OAAOiB,EAAUC,EAAS,CACtB,MAAMjD,EAAS,CAAA,EAAI+B,EAAQ,GAC3B,QAAS9B,EAAI,EAAGA,EAAI,KAAK,OAAQA,IAAK,CAClC,MAAMiC,EAAO,KAAKjC,CAAC,EACfiC,aAAgB,OAChBX,GAAW,SAAStB,CAAC,GAAIiC,CAAI,EAE7Bc,EAAS,KAAKC,EAASf,EAAMjC,EAAG,IAAI,IACpCD,EAAO,KAAKkC,CAAI,EAChBH,EAAM,KAAK/C,EAAA,KAAKiD,IAAOhC,CAAC,CAAC,EAEhC,CACD,OAAO,IAAI0B,GAAOL,GAAQtB,EAAQ+B,CAAK,CAC1C,CAID,IAAIiB,EAAUC,EAAS,CACnB,MAAMjD,EAAS,CAAA,EACf,QAAS,EAAI,EAAG,EAAI,KAAK,OAAQ,IAAK,CAClC,MAAMkC,EAAO,KAAK,CAAC,EACfA,aAAgB,OAChBX,GAAW,SAAS,CAAC,GAAIW,CAAI,EAEjClC,EAAO,KAAKgD,EAAS,KAAKC,EAASf,EAAM,EAAG,IAAI,CAAC,CACpD,CACD,OAAOlC,CACV,CASD,SAASwB,EAAM,CACX,MAAMW,EAAQnD,EAAA,KAAKiD,IAAO,QAAQT,CAAI,EACtC,GAAIW,IAAU,GACV,OAEJ,MAAMO,EAAQ,KAAKP,CAAK,EACxB,OAAIO,aAAiB,OACjBnB,GAAW,YAAY,KAAK,UAAUC,CAAI,CAAC,GAAIkB,EAAM,KAAK,EAEvDA,CACV,CAKD,OAAO,UAAUZ,EAAOoB,EAAM,CAC1B,OAAO,IAAIvB,GAAOL,GAAQQ,EAAOoB,CAAI,CACxC,CACL,EAtNIjB,GAAA,YADG,IAAMkB,GAANxB,GAqOA,SAASyB,GAAkBpD,EAAQ,CAEtC,MAAMqD,EAAS,CAAA,EACTC,EAAc,SAAUC,EAAMC,EAAQ,CACxC,GAAK,MAAM,QAAQA,CAAM,EAGzB,QAASC,KAAOD,EAAQ,CACpB,MAAME,EAAYH,EAAK,QACvBG,EAAU,KAAKD,CAAG,EAClB,GAAI,CACAH,EAAYI,EAAWF,EAAOC,CAAG,CAAC,CACrC,OACMhC,EAAO,CACV4B,EAAO,KAAK,CAAE,KAAMK,EAAW,MAAOjC,CAAK,CAAE,CAChD,CACJ,CACT,EACI,OAAA6B,EAAY,CAAA,EAAItD,CAAM,EACfqD,CACX,CACA,SAASM,GAASjB,EAAO,CACrB,IAAItD,EAAQwE,GAAUlB,CAAK,EAC3B,OAAAE,EAAOxD,EAAM,QAAU+B,EAAU,sBAAuB,iBAAkB,CAAE,OAAQ/B,EAAO,OAAQ+B,EAAU,OAAQ/B,EAAM,MAAQ,CAAA,EAC/HA,EAAM,SAAW+B,IACjB/B,EAAQyE,EAAaC,GAAO,CAAC1C,GAAQ,MAAMhC,EAAM,OAAS+B,CAAQ,EAAG/B,CAAK,CAAC,CAAC,GAEzEA,CACX,CAIO,MAAM2E,EAAM,CAcf,YAAYvC,EAAMwC,EAAMC,EAAWC,EAAS,CAX5CvF,EAAA,aAGAA,EAAA,aAGAA,EAAA,kBAIAA,EAAA,gBAEII,EAAiB,KAAM,CAAE,KAAAyC,EAAM,KAAAwC,EAAM,UAAAC,EAAW,QAAAC,GAAW,CACvD,KAAM,SAAU,KAAM,SAAU,UAAW,SAAU,QAAS,SAC1E,CAAS,CACJ,CACD,YAAYC,EAASzB,EAAO,CACxBnD,EAAe,GAAO4E,EAAS,KAAK,UAAWzB,CAAK,CACvD,CACL,iBAIO,MAAM0B,EAAO,CAIhB,aAAc,CAQdxF,EAAA,KAAAyF,IAVAzF,EAAA,KAAA0F,GAAA,QACA1F,EAAA,KAAA2F,GAAA,QAEIzF,EAAA,KAAKwF,GAAQ,IACbxF,EAAA,KAAKyF,GAAc,EACtB,CACD,IAAI,MAAO,CACP,OAAOT,GAAO9E,EAAA,KAAKsF,GAAK,CAC3B,CACD,IAAI,QAAS,CAAE,OAAOtF,EAAA,KAAKuF,GAAc,CAMzC,aAAaC,EAAQ,CACjB,OAAOC,EAAA,KAAKJ,GAAAK,IAAL,UAAgBb,EAAaW,EAAO,IAAI,EAClD,CAED,WAAW9B,EAAO,CACd,IAAItD,EAAQyE,EAAanB,CAAK,EAC9B,MAAMiC,EAAgBvF,EAAM,OAAS+B,EACrC,OAAIwD,IACAvF,EAAQyE,EAAaC,GAAO,CAAC1E,EAAOgC,GAAQ,MAAMuD,CAAa,CAAC,CAAC,CAAC,GAE/DF,EAAA,KAAKJ,GAAAK,IAAL,UAAgBtF,EAC1B,CAED,WAAWsD,EAAO,CACd,OAAO+B,EAAA,KAAKJ,GAAAK,IAAL,UAAgBf,GAASjB,CAAK,EACxC,CAGD,qBAAsB,CAClB,MAAMvD,EAASH,EAAA,KAAKsF,IAAM,OAC1B,OAAAtF,EAAA,KAAKsF,IAAM,KAAKlD,EAAO,EACvBtC,EAAA,KAAKyF,GAALvF,EAAA,KAAKuF,IAAepD,GACZuB,GAAU,CACd1D,EAAA,KAAKsF,IAAMnF,CAAM,EAAIwE,GAASjB,CAAK,CAC/C,CACK,CACL,CAzCI4B,GAAA,YACAC,GAAA,YASAF,GAAA,YAAAK,GAAU,SAACE,EAAM,CACb,OAAA5F,EAAA,KAAKsF,IAAM,KAAKM,CAAI,EACpB9F,EAAA,KAAKyF,GAALvF,EAAA,KAAKuF,IAAeK,EAAK,QAClBA,EAAK,MACf,+BA+BE,MAAMC,GAAN,MAAMA,EAAO,CAWhB,YAAYD,EAAME,EAAYC,EAAc,CAY5CnG,EAAA,KAAAoG,IAcApG,EAAA,KAAAqG,IAhCAtG,EAAA,mBACAC,EAAA,KAAA0F,EAAA,QACA1F,EAAA,KAAAsG,EAAA,QACAtG,EAAA,KAAAuG,GAAA,QACAvG,EAAA,KAAAwG,GAAA,QACAxG,EAAA,KAAAyG,GAAA,QAEItG,EAAiB,KAAM,CAAE,WAAY,CAAC,CAAC+F,CAAY,CAAA,EACnDhG,EAAA,KAAKwF,EAAQT,EAAae,CAAI,GAC9B9F,EAAA,KAAKqG,GAAa,GAClBrG,EAAA,KAAKsG,GAAU,MACftG,EAAA,KAAKuG,GAAiBN,GAAuC,MAC7DjG,EAAA,KAAKoG,EAAU,EAClB,CACD,IAAI,MAAO,CAAE,OAAOI,EAAQtG,EAAA,KAAKsF,EAAK,CAAI,CAC1C,IAAI,YAAa,CAAE,OAAOtF,EAAA,KAAKsF,GAAM,MAAS,CAC9C,IAAI,UAAW,CAAE,OAAOtF,EAAA,KAAKkG,EAAU,CACvC,IAAI,OAAQ,CAAE,OAAO,IAAI,WAAWlG,EAAA,KAAKsF,EAAK,CAAI,CAgClD,UAAUnF,EAAQ,CACd,MAAMoG,EAAS,IAAIV,GAAO7F,EAAA,KAAKsF,GAAM,MAAMtF,EAAA,KAAKkG,GAAU/F,CAAM,EAAG,KAAK,WAAYH,EAAA,KAAKqG,GAAa,EACtG,OAAAvG,EAAAyG,EAAOH,GAAU,MACVG,CACV,CAED,UAAUC,EAAQC,EAAO,CACrB,IAAIrG,EAAQqF,EAAA,KAAKQ,GAAAS,IAAL,UAAgB,EAAGF,EAAQ,CAAC,CAACC,GACzC,OAAAhB,EAAA,KAAKO,GAAAW,IAAL,UAAyBH,GACzB1G,EAAA,KAAKoG,EAALlG,EAAA,KAAKkG,GAAW9F,EAAM,QAEfA,EAAM,MAAM,EAAGoG,CAAM,CAC/B,CAED,WAAY,CACR,OAAOI,GAAS,KAAK,UAAUzE,CAAQ,CAAC,CAC3C,CACD,WAAY,CACR,OAAO0E,GAAS,KAAK,UAAU1E,CAAQ,CAAC,CAC3C,CACL,EApEImD,EAAA,YACAY,EAAA,YACAC,GAAA,YACAC,GAAA,YACAC,GAAA,YAaAL,GAAA,YAAAW,GAAmB,SAACG,EAAO,OACvB,GAAI9G,EAAA,KAAKoG,IACL,OAAOX,EAAAsB,EAAA/G,EAAA,KAAKoG,IAAQJ,GAAAW,IAAb,KAAAI,EAAiCD,GAE5ChH,EAAA,KAAKqG,GAALnG,EAAA,KAAKmG,IAAcW,GAEnBlD,EAAO5D,EAAA,KAAKqG,IAAgB,GAAKrG,EAAA,KAAKmG,KAAcnG,EAAA,KAAKqG,IAAgB,KAAK,WAAY,kDAAkDrG,EAAA,KAAKqG,GAAa,+DAAiE,iBAAkB,CAC7O,OAAQxB,EAAa7E,EAAA,KAAKsF,EAAK,EAAG,OAAQtF,EAAA,KAAKkG,GAC/C,OAAQY,EAAO,KAAM,CACjB,UAAW9G,EAAA,KAAKmG,IAChB,WAAY,KAAK,UACpB,CACb,CAAS,CACJ,EACDF,GAAA,YAAAS,GAAU,SAACvG,EAAQqG,EAAQC,EAAO,CAC9B,IAAIO,EAAgB,KAAK,KAAKR,EAASrE,CAAQ,EAAIA,EACnD,OAAInC,EAAA,KAAKkG,GAAUc,EAAgBhH,EAAA,KAAKsF,GAAM,SACtC,KAAK,YAAcmB,GAASzG,EAAA,KAAKkG,GAAUM,GAAUxG,EAAA,KAAKsF,GAAM,OAChE0B,EAAgBR,EAGhB5C,EAAO,GAAO,qBAAsB,iBAAkB,CAClD,OAAQiB,EAAa7E,EAAA,KAAKsF,EAAK,EAC/B,OAAQtF,EAAA,KAAKsF,GAAM,OACnB,OAAQtF,EAAA,KAAKkG,GAAUc,CAC3C,CAAiB,GAGFhH,EAAA,KAAKsF,GAAM,MAAMtF,EAAA,KAAKkG,GAASlG,EAAA,KAAKkG,GAAUc,CAAa,CACrE,EApDE,IAAMC,GAANpB,GCpWP,SAASqB,GAAOC,EAAG,CACf,GAAI,CAAC,OAAO,cAAcA,CAAC,GAAKA,EAAI,EAChC,MAAM,IAAI,MAAM,2BAA2BA,CAAC,EAAE,CACtD,CAKA,SAAS/G,GAAMgH,KAAMC,EAAS,CAC1B,GAAI,EAAED,aAAa,YACf,MAAM,IAAI,MAAM,qBAAqB,EACzC,GAAIC,EAAQ,OAAS,GAAK,CAACA,EAAQ,SAASD,EAAE,MAAM,EAChD,MAAM,IAAI,MAAM,iCAAiCC,CAAO,mBAAmBD,EAAE,MAAM,EAAE,CAC7F,CACA,SAASE,GAAKA,EAAM,CAChB,GAAI,OAAOA,GAAS,YAAc,OAAOA,EAAK,QAAW,WACrD,MAAM,IAAI,MAAM,iDAAiD,EACrEJ,GAAOI,EAAK,SAAS,EACrBJ,GAAOI,EAAK,QAAQ,CACxB,CACA,SAASC,GAAOC,EAAUC,EAAgB,GAAM,CAC5C,GAAID,EAAS,UACT,MAAM,IAAI,MAAM,kCAAkC,EACtD,GAAIC,GAAiBD,EAAS,SAC1B,MAAM,IAAI,MAAM,uCAAuC,CAC/D,CACA,SAASnH,GAAOqH,EAAKF,EAAU,CAC3BpH,GAAMsH,CAAG,EACT,MAAMC,EAAMH,EAAS,UACrB,GAAIE,EAAI,OAASC,EACb,MAAM,IAAI,MAAM,yDAAyDA,CAAG,EAAE,CAEtF,CChCO,MAAMC,GAAS,OAAO,YAAe,UAAY,WAAY,WAAa,WAAW,OAAS,OCArG,sEAQA,MAAMC,GAAOC,GAAMA,aAAa,WAGnBC,GAAOC,GAAQ,IAAI,YAAYA,EAAI,OAAQA,EAAI,WAAY,KAAK,MAAMA,EAAI,WAAa,CAAC,CAAC,EAEzFC,GAAcD,GAAQ,IAAI,SAASA,EAAI,OAAQA,EAAI,WAAYA,EAAI,UAAU,EAE7EE,GAAO,CAACC,EAAMC,IAAWD,GAAS,GAAKC,EAAWD,IAASC,EAG3DC,GAAO,IAAI,WAAW,IAAI,YAAY,CAAC,SAAU,CAAC,EAAE,MAAM,EAAE,CAAC,IAAM,GAChF,GAAI,CAACA,GACD,MAAM,IAAI,MAAM,6CAA6C,EAsC1D,MAAMC,GAAW,SAAY,CAAA,EAE7B,eAAeC,GAAUC,EAAOC,EAAMC,EAAI,CAC7C,IAAIC,EAAK,KAAK,MACd,QAAS1H,EAAI,EAAGA,EAAIuH,EAAOvH,IAAK,CAC5ByH,EAAGzH,CAAC,EAEJ,MAAM2H,EAAO,KAAK,IAAG,EAAKD,EACtBC,GAAQ,GAAKA,EAAOH,IAExB,MAAMH,GAAQ,EACdK,GAAMC,EACT,CACL,CAIO,SAASC,GAAYpH,EAAK,CAC7B,GAAI,OAAOA,GAAQ,SACf,MAAM,IAAI,MAAM,oCAAoC,OAAOA,CAAG,EAAE,EACpE,OAAO,IAAI,WAAW,IAAI,YAAa,EAAC,OAAOA,CAAG,CAAC,CACvD,CAMO,SAASqH,GAAQlD,EAAM,CAG1B,GAFI,OAAOA,GAAS,WAChBA,EAAOiD,GAAYjD,CAAI,GACvB,CAACiC,GAAIjC,CAAI,EACT,MAAM,IAAI,MAAM,4BAA4B,OAAOA,CAAI,EAAE,EAC7D,OAAOA,CACX,CAIO,SAASmD,MAAeC,EAAQ,CACnC,MAAMC,EAAI,IAAI,WAAWD,EAAO,OAAO,CAACE,EAAKpB,IAAMoB,EAAMpB,EAAE,OAAQ,CAAC,CAAC,EACrE,IAAIqB,EAAM,EACV,OAAAH,EAAO,QAASlB,GAAM,CAClB,GAAI,CAACD,GAAIC,CAAC,EACN,MAAM,IAAI,MAAM,qBAAqB,EACzCmB,EAAE,IAAInB,EAAGqB,CAAG,EACZA,GAAOrB,EAAE,MACjB,CAAK,EACMmB,CACX,CAEO,MAAMG,EAAK,CAEd,OAAQ,CACJ,OAAO,KAAK,YACf,CACL,CACA,MAAMC,GAAQ,CAAE,EAAC,SACV,SAASC,GAAUC,EAAUC,EAAM,CACtC,GAAIA,IAAS,QAAaH,GAAM,KAAKG,CAAI,IAAM,kBAC3C,MAAM,IAAI,MAAM,uCAAuC,EAE3D,OADe,OAAO,OAAOD,EAAUC,CAAI,CAE/C,CACO,SAASC,GAAgBC,EAAU,CACtC,MAAMC,EAASC,GAAQF,EAAU,EAAC,OAAOZ,GAAQc,CAAG,CAAC,EAAE,SACjDC,EAAMH,IACZ,OAAAC,EAAM,UAAYE,EAAI,UACtBF,EAAM,SAAWE,EAAI,SACrBF,EAAM,OAAS,IAAMD,IACdC,CACX,CAoBO,SAASG,GAAYC,EAAc,GAAI,CAC1C,GAAInC,IAAU,OAAOA,GAAO,iBAAoB,WAC5C,OAAOA,GAAO,gBAAgB,IAAI,WAAWmC,CAAW,CAAC,EAE7D,MAAM,IAAI,MAAM,wCAAwC,CAC5D,CCxJA,MAAMC,GAA6B,OAAO,GAAK,GAAK,CAAC,EAC/CC,GAAuB,OAAO,EAAE,EAEtC,SAASC,GAAQ/C,EAAGgD,EAAK,GAAO,CAC5B,OAAIA,EACO,CAAE,EAAG,OAAOhD,EAAI6C,EAAU,EAAG,EAAG,OAAQ7C,GAAK8C,GAAQD,EAAU,CAAC,EACpE,CAAE,EAAG,OAAQ7C,GAAK8C,GAAQD,EAAU,EAAI,EAAG,EAAG,OAAO7C,EAAI6C,EAAU,EAAI,CAAC,CACnF,CACA,SAASI,GAAMC,EAAKF,EAAK,GAAO,CAC5B,IAAIG,EAAK,IAAI,YAAYD,EAAI,MAAM,EAC/BE,EAAK,IAAI,YAAYF,EAAI,MAAM,EACnC,QAASpJ,EAAI,EAAGA,EAAIoJ,EAAI,OAAQpJ,IAAK,CACjC,KAAM,CAAE,EAAAuJ,EAAG,EAAAC,GAAMP,GAAQG,EAAIpJ,CAAC,EAAGkJ,CAAE,EACnC,CAACG,EAAGrJ,CAAC,EAAGsJ,EAAGtJ,CAAC,CAAC,EAAI,CAACuJ,EAAGC,CAAC,CACzB,CACD,MAAO,CAACH,EAAIC,CAAE,CAClB,CACA,MAAMG,GAAQ,CAACF,EAAGC,IAAO,OAAOD,IAAM,CAAC,GAAKP,GAAQ,OAAOQ,IAAM,CAAC,EAE5DE,GAAQ,CAACH,EAAGI,EAAIC,IAAML,IAAMK,EAC5BC,GAAQ,CAACN,EAAGC,EAAGI,IAAOL,GAAM,GAAKK,EAAOJ,IAAMI,EAE9CE,GAAS,CAACP,EAAGC,EAAGI,IAAOL,IAAMK,EAAMJ,GAAM,GAAKI,EAC9CG,GAAS,CAACR,EAAGC,EAAGI,IAAOL,GAAM,GAAKK,EAAOJ,IAAMI,EAE/CI,GAAS,CAACT,EAAGC,EAAGI,IAAOL,GAAM,GAAKK,EAAOJ,IAAOI,EAAI,GACpDK,GAAS,CAACV,EAAGC,EAAGI,IAAOL,IAAOK,EAAI,GAAQJ,GAAM,GAAKI,EAErDM,GAAU,CAACC,EAAIX,IAAMA,EACrBY,GAAU,CAACb,EAAGI,IAAOJ,EAErBc,GAAS,CAACd,EAAGC,EAAGI,IAAOL,GAAKK,EAAMJ,IAAO,GAAKI,EAC9CU,GAAS,CAACf,EAAGC,EAAGI,IAAOJ,GAAKI,EAAML,IAAO,GAAKK,EAE9CW,GAAS,CAAChB,EAAGC,EAAGI,IAAOJ,GAAMI,EAAI,GAAQL,IAAO,GAAKK,EACrDY,GAAS,CAACjB,EAAGC,EAAGI,IAAOL,GAAMK,EAAI,GAAQJ,IAAO,GAAKI,EAG3D,SAASa,GAAIpB,EAAIC,EAAIoB,EAAIC,EAAI,CACzB,MAAMnB,GAAKF,IAAO,IAAMqB,IAAO,GAC/B,MAAO,CAAE,EAAItB,EAAKqB,GAAOlB,EAAI,GAAK,GAAM,GAAM,EAAG,EAAGA,EAAI,CAAC,CAC7D,CAEA,MAAMoB,GAAQ,CAACtB,EAAIqB,EAAIE,KAAQvB,IAAO,IAAMqB,IAAO,IAAME,IAAO,GAC1DC,GAAQ,CAACC,EAAK1B,EAAIqB,EAAIM,IAAQ3B,EAAKqB,EAAKM,GAAOD,EAAM,GAAK,GAAM,GAAM,EACtEE,GAAQ,CAAC3B,EAAIqB,EAAIE,EAAIK,KAAQ5B,IAAO,IAAMqB,IAAO,IAAME,IAAO,IAAMK,IAAO,GAC3EC,GAAQ,CAACJ,EAAK1B,EAAIqB,EAAIM,EAAII,IAAQ/B,EAAKqB,EAAKM,EAAKI,GAAOL,EAAM,GAAK,GAAM,GAAM,EAC/EM,GAAQ,CAAC/B,EAAIqB,EAAIE,EAAIK,EAAII,KAAQhC,IAAO,IAAMqB,IAAO,IAAME,IAAO,IAAMK,IAAO,IAAMI,IAAO,GAC5FC,GAAQ,CAACR,EAAK1B,EAAIqB,EAAIM,EAAII,EAAII,IAAQnC,EAAKqB,EAAKM,EAAKI,EAAKI,GAAOT,EAAM,GAAK,GAAM,GAAM,EAIxFU,GAAM,CACR,QAAAxC,GAAS,MAAAE,GAAO,MAAAM,GAChB,MAAAC,GAAO,MAAAG,GACP,OAAAC,GAAQ,OAAAC,GAAQ,OAAAC,GAAQ,OAAAC,GACxB,QAAAC,GAAS,QAAAE,GACT,OAAAC,GAAQ,OAAAC,GAAQ,OAAAC,GAAQ,OAAAC,GACxB,IAAAC,GAAK,MAAAG,GAAO,MAAAE,GAAO,MAAAG,GAAO,MAAAE,GAAO,MAAAI,GAAO,MAAAF,EAC5C,ECrDM,CAACK,GAASC,GAAWC,EAAU,EAAI,CAAC,GAAI,CAAA,EAAI,CAAA,CAAE,EAC9CC,GAAsB,OAAO,CAAC,EAC9BC,GAAsB,OAAO,CAAC,EAC9BC,GAAsB,OAAO,CAAC,EAC9BC,GAAsB,OAAO,CAAC,EAC9BC,GAAwB,OAAO,GAAG,EAClCC,GAAyB,OAAO,GAAI,EAC1C,QAASC,EAAQ,EAAGC,EAAIN,GAAKO,EAAI,EAAGC,EAAI,EAAGH,EAAQ,GAAIA,IAAS,CAE5D,CAACE,EAAGC,CAAC,EAAI,CAACA,GAAI,EAAID,EAAI,EAAIC,GAAK,CAAC,EAChCZ,GAAQ,KAAK,GAAK,EAAIY,EAAID,EAAE,EAE5BV,GAAU,MAAQQ,EAAQ,IAAMA,EAAQ,GAAM,EAAK,EAAE,EAErD,IAAII,EAAIV,GACR,QAASxL,EAAI,EAAGA,EAAI,EAAGA,IACnB+L,GAAMA,GAAKN,IAASM,GAAKJ,IAAOE,IAAWD,GACvCG,EAAIL,KACJQ,GAAKT,KAASA,IAAuB,OAAOzL,CAAC,GAAKyL,IAE1DF,GAAW,KAAKW,CAAC,CACrB,CACA,KAAM,CAACC,GAAaC,EAAW,EAAoBtD,GAAMyC,GAAY,EAAI,EAEnEc,GAAQ,CAACnD,EAAGC,EAAGI,IAAOA,EAAI,GAAKW,GAAOhB,EAAGC,EAAGI,CAAC,EAAIS,GAAOd,EAAGC,EAAGI,CAAC,EAC/D+C,GAAQ,CAACpD,EAAGC,EAAGI,IAAOA,EAAI,GAAKY,GAAOjB,EAAGC,EAAGI,CAAC,EAAIU,GAAOf,EAAGC,EAAGI,CAAC,EAE9D,SAASgD,GAAQhD,EAAGiD,EAAS,GAAI,CACpC,MAAMC,EAAI,IAAI,YAAY,EAAK,EAE/B,QAASX,EAAQ,GAAKU,EAAQV,EAAQ,GAAIA,IAAS,CAE/C,QAASE,EAAI,EAAGA,EAAI,GAAIA,IACpBS,EAAET,CAAC,EAAIzC,EAAEyC,CAAC,EAAIzC,EAAEyC,EAAI,EAAE,EAAIzC,EAAEyC,EAAI,EAAE,EAAIzC,EAAEyC,EAAI,EAAE,EAAIzC,EAAEyC,EAAI,EAAE,EAC9D,QAASA,EAAI,EAAGA,EAAI,GAAIA,GAAK,EAAG,CAC5B,MAAMU,GAAQV,EAAI,GAAK,GACjBW,GAAQX,EAAI,GAAK,GACjBY,EAAKH,EAAEE,CAAI,EACXE,EAAKJ,EAAEE,EAAO,CAAC,EACfG,EAAKT,GAAMO,EAAIC,EAAI,CAAC,EAAIJ,EAAEC,CAAI,EAC9BK,EAAKT,GAAMM,EAAIC,EAAI,CAAC,EAAIJ,EAAEC,EAAO,CAAC,EACxC,QAAST,EAAI,EAAGA,EAAI,GAAIA,GAAK,GACzB1C,EAAEyC,EAAIC,CAAC,GAAKa,EACZvD,EAAEyC,EAAIC,EAAI,CAAC,GAAKc,CAEvB,CAED,IAAIC,EAAOzD,EAAE,CAAC,EACV0D,EAAO1D,EAAE,CAAC,EACd,QAAS2C,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,MAAMpF,EAAQwE,GAAUY,CAAC,EACnBY,EAAKT,GAAMW,EAAMC,EAAMnG,CAAK,EAC5BiG,EAAKT,GAAMU,EAAMC,EAAMnG,CAAK,EAC5BoG,EAAK7B,GAAQa,CAAC,EACpBc,EAAOzD,EAAE2D,CAAE,EACXD,EAAO1D,EAAE2D,EAAK,CAAC,EACf3D,EAAE2D,CAAE,EAAIJ,EACRvD,EAAE2D,EAAK,CAAC,EAAIH,CACf,CAED,QAASd,EAAI,EAAGA,EAAI,GAAIA,GAAK,GAAI,CAC7B,QAASD,EAAI,EAAGA,EAAI,GAAIA,IACpBS,EAAET,CAAC,EAAIzC,EAAE0C,EAAID,CAAC,EAClB,QAASA,EAAI,EAAGA,EAAI,GAAIA,IACpBzC,EAAE0C,EAAID,CAAC,GAAK,CAACS,GAAGT,EAAI,GAAK,EAAE,EAAIS,GAAGT,EAAI,GAAK,EAAE,CACpD,CAEDzC,EAAE,CAAC,GAAK4C,GAAYL,CAAK,EACzBvC,EAAE,CAAC,GAAK6C,GAAYN,CAAK,CAC5B,CACDW,EAAE,KAAK,CAAC,CACZ,CACO,MAAMU,WAAerF,EAAK,CAE7B,YAAYsF,EAAUC,EAAQC,EAAWC,EAAY,GAAOf,EAAS,GAAI,CAcrE,GAbA,QACA,KAAK,SAAWY,EAChB,KAAK,OAASC,EACd,KAAK,UAAYC,EACjB,KAAK,UAAYC,EACjB,KAAK,OAASf,EACd,KAAK,IAAM,EACX,KAAK,OAAS,EACd,KAAK,SAAW,GAChB,KAAK,UAAY,GAEjB5G,GAAO0H,CAAS,EAEZ,GAAK,KAAK,UAAY,KAAK,UAAY,IACvC,MAAM,IAAI,MAAM,0CAA0C,EAC9D,KAAK,MAAQ,IAAI,WAAW,GAAG,EAC/B,KAAK,QAAU7G,GAAI,KAAK,KAAK,CAChC,CACD,QAAS,CACL8F,GAAQ,KAAK,QAAS,KAAK,MAAM,EACjC,KAAK,OAAS,EACd,KAAK,IAAM,CACd,CACD,OAAOjI,EAAM,CACT2B,GAAO,IAAI,EACX,KAAM,CAAE,SAAAmH,EAAU,MAAAI,CAAO,EAAG,KAC5BlJ,EAAOkD,GAAQlD,CAAI,EACnB,MAAMmJ,EAAMnJ,EAAK,OACjB,QAASoJ,EAAM,EAAGA,EAAMD,GAAM,CAC1B,MAAME,EAAO,KAAK,IAAIP,EAAW,KAAK,IAAKK,EAAMC,CAAG,EACpD,QAAS/N,EAAI,EAAGA,EAAIgO,EAAMhO,IACtB6N,EAAM,KAAK,KAAK,GAAKlJ,EAAKoJ,GAAK,EAC/B,KAAK,MAAQN,GACb,KAAK,OAAM,CAClB,CACD,OAAO,IACV,CACD,QAAS,CACL,GAAI,KAAK,SACL,OACJ,KAAK,SAAW,GAChB,KAAM,CAAE,MAAAI,EAAO,OAAAH,EAAQ,IAAAK,EAAK,SAAAN,CAAQ,EAAK,KAEzCI,EAAME,CAAG,GAAKL,EACTA,EAAS,KAAeK,IAAQN,EAAW,GAC5C,KAAK,OAAM,EACfI,EAAMJ,EAAW,CAAC,GAAK,IACvB,KAAK,OAAM,CACd,CACD,UAAUhH,EAAK,CACXH,GAAO,KAAM,EAAK,EAClBnH,GAAMsH,CAAG,EACT,KAAK,OAAM,EACX,MAAMwH,EAAY,KAAK,MACjB,CAAE,SAAAR,CAAU,EAAG,KACrB,QAASM,EAAM,EAAGD,EAAMrH,EAAI,OAAQsH,EAAMD,GAAM,CACxC,KAAK,QAAUL,GACf,KAAK,OAAM,EACf,MAAMO,EAAO,KAAK,IAAIP,EAAW,KAAK,OAAQK,EAAMC,CAAG,EACvDtH,EAAI,IAAIwH,EAAU,SAAS,KAAK,OAAQ,KAAK,OAASD,CAAI,EAAGD,CAAG,EAChE,KAAK,QAAUC,EACfD,GAAOC,CACV,CACD,OAAOvH,CACV,CACD,QAAQA,EAAK,CAET,GAAI,CAAC,KAAK,UACN,MAAM,IAAI,MAAM,uCAAuC,EAC3D,OAAO,KAAK,UAAUA,CAAG,CAC5B,CACD,IAAItH,EAAO,CACP,OAAA8G,GAAO9G,CAAK,EACL,KAAK,QAAQ,IAAI,WAAWA,CAAK,CAAC,CAC5C,CACD,WAAWsH,EAAK,CAEZ,GADArH,GAAOqH,EAAK,IAAI,EACZ,KAAK,SACL,MAAM,IAAI,MAAM,6BAA6B,EACjD,YAAK,UAAUA,CAAG,EAClB,KAAK,QAAO,EACLA,CACV,CACD,QAAS,CACL,OAAO,KAAK,WAAW,IAAI,WAAW,KAAK,SAAS,CAAC,CACxD,CACD,SAAU,CACN,KAAK,UAAY,GACjB,KAAK,MAAM,KAAK,CAAC,CACpB,CACD,WAAWyH,EAAI,CACX,KAAM,CAAE,SAAAT,EAAU,OAAAC,EAAQ,UAAAC,EAAW,OAAAd,EAAQ,UAAAe,CAAW,EAAG,KAC3D,OAAAM,IAAOA,EAAK,IAAIV,GAAOC,EAAUC,EAAQC,EAAWC,EAAWf,CAAM,GACrEqB,EAAG,QAAQ,IAAI,KAAK,OAAO,EAC3BA,EAAG,IAAM,KAAK,IACdA,EAAG,OAAS,KAAK,OACjBA,EAAG,SAAW,KAAK,SACnBA,EAAG,OAASrB,EAEZqB,EAAG,OAASR,EACZQ,EAAG,UAAYP,EACfO,EAAG,UAAYN,EACfM,EAAG,UAAY,KAAK,UACbA,CACV,CACL,CACA,MAAMC,GAAM,CAACT,EAAQD,EAAUE,IAAcnF,GAAgB,IAAM,IAAIgF,GAAOC,EAAUC,EAAQC,CAAS,CAAC,EAc7FS,GAA6BD,GAAI,EAAM,IAAK,IAAM,CAAC,EClMhE,IAAIE,GAAS,GACb,MAAMC,GAAa,SAAU3J,EAAM,CAC/B,OAAOyJ,GAAWzJ,CAAI,CAC1B,EACA,IAAI4J,GAAcD,GAuBX,SAASE,GAAUnK,EAAO,CAC7B,MAAMM,EAAO7E,GAASuE,EAAO,MAAM,EACnC,OAAOgB,EAAQkJ,GAAY5J,CAAI,CAAC,CACpC,CACA6J,GAAU,EAAIF,GACdE,GAAU,KAAO,UAAY,CAAEH,GAAS,EAAK,EAC7CG,GAAU,SAAW,SAAUC,EAAM,CACjC,GAAIJ,GACA,MAAM,IAAI,UAAU,qBAAqB,EAE7CE,GAAcE,CAClB,EACA,OAAO,OAAOD,EAAS,EC5CvB,MAAME,GAAO,OAAO,CAAC,EACfC,GAAQ,OAAO,EAAE,EACvB,SAASC,GAAmBC,EAAS,CAIjCA,EAAUA,EAAQ,cAClB,MAAMC,EAAQD,EAAQ,UAAU,CAAC,EAAE,MAAM,EAAE,EACrCE,EAAW,IAAI,WAAW,EAAE,EAClC,QAAS/O,EAAI,EAAGA,EAAI,GAAIA,IACpB+O,EAAS/O,CAAC,EAAI8O,EAAM9O,CAAC,EAAE,WAAW,CAAC,EAEvC,MAAMgP,EAASlP,GAAS0O,GAAUO,CAAQ,CAAC,EAC3C,QAAS/O,EAAI,EAAGA,EAAI,GAAIA,GAAK,EACpBgP,EAAOhP,GAAK,CAAC,GAAK,GAAM,IACzB8O,EAAM9O,CAAC,EAAI8O,EAAM9O,CAAC,EAAE,YAAW,IAE9BgP,EAAOhP,GAAK,CAAC,EAAI,KAAS,IAC3B8O,EAAM9O,EAAI,CAAC,EAAI8O,EAAM9O,EAAI,CAAC,EAAE,eAGpC,MAAO,KAAO8O,EAAM,KAAK,EAAE,CAC/B,CAGA,MAAMG,GAAa,CAAA,EACnB,QAASjP,EAAI,EAAGA,EAAI,GAAIA,IACpBiP,GAAW,OAAOjP,CAAC,CAAC,EAAI,OAAOA,CAAC,EAEpC,QAASA,EAAI,EAAGA,EAAI,GAAIA,IACpBiP,GAAW,OAAO,aAAa,GAAKjP,CAAC,CAAC,EAAI,OAAO,GAAKA,CAAC,EAI3D,MAAMkP,GAAa,GACnB,SAASC,GAAaN,EAAS,CAC3BA,EAAUA,EAAQ,cAClBA,EAAUA,EAAQ,UAAU,CAAC,EAAIA,EAAQ,UAAU,EAAG,CAAC,EAAI,KAC3D,IAAIE,EAAWF,EAAQ,MAAM,EAAE,EAAE,IAAK5O,GAAegP,GAAWhP,CAAC,CAAI,EAAE,KAAK,EAAE,EAE9E,KAAO8O,EAAS,QAAUG,IAAY,CAClC,IAAIE,EAAQL,EAAS,UAAU,EAAGG,EAAU,EAC5CH,EAAW,SAASK,EAAO,EAAE,EAAI,GAAKL,EAAS,UAAUK,EAAM,MAAM,CACxE,CACD,IAAIC,EAAW,OAAO,GAAM,SAASN,EAAU,EAAE,EAAI,EAAG,EACxD,KAAOM,EAAS,OAAS,GACrBA,EAAW,IAAMA,EAErB,OAAOA,CACX,CAEA,MAAMC,GAAU,UAAY,CAExB,MAAMvP,EAAS,CAAA,EACf,QAASC,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,MAAMwD,EAAM,uCAAuCxD,CAAC,EACpDD,EAAOyD,CAAG,EAAI,OAAOxD,CAAC,CACzB,CACD,OAAOD,CACX,IACA,SAASwP,GAAW9M,EAAO,CACvBA,EAAQA,EAAM,cACd,IAAI1C,EAAS2O,GACb,QAAS1O,EAAI,EAAGA,EAAIyC,EAAM,OAAQzC,IAC9BD,EAASA,EAAS4O,GAAQW,GAAO7M,EAAMzC,CAAC,CAAC,EAE7C,OAAOD,CACX,CAoCO,SAASyP,GAAWX,EAAS,CAEhC,GADAvP,EAAe,OAAQuP,GAAa,SAAU,kBAAmB,UAAWA,CAAO,EAC/EA,EAAQ,MAAM,wBAAwB,EAAG,CAEpCA,EAAQ,WAAW,IAAI,IACxBA,EAAU,KAAOA,GAErB,MAAM9O,EAAS6O,GAAmBC,CAAO,EAEzC,OAAAvP,EAAe,CAACuP,EAAQ,MAAM,+BAA+B,GAAK9O,IAAW8O,EAAS,uBAAwB,UAAWA,CAAO,EACzH9O,CACV,CAED,GAAI8O,EAAQ,MAAM,gCAAgC,EAAG,CAEjDvP,EAAeuP,EAAQ,UAAU,EAAG,CAAC,IAAMM,GAAaN,CAAO,EAAG,oBAAqB,UAAWA,CAAO,EACzG,IAAI9O,EAASwP,GAAWV,EAAQ,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,EACzD,KAAO9O,EAAO,OAAS,IACnBA,EAAS,IAAMA,EAEnB,OAAO6O,GAAmB,KAAO7O,CAAM,CAC1C,CACDT,EAAe,GAAO,kBAAmB,UAAWuP,CAAO,CAC/D,CAmBO,SAASY,GAAeZ,EAAS,CAEpC,IAAIa,EAAS,OAAOF,GAAWX,CAAO,CAAC,EAAE,SAAS,EAAE,EAAE,cACtD,KAAOa,EAAO,OAAS,IACnBA,EAAS,IAAMA,EAEnB,MAAO,KAAOP,GAAa,OAASO,CAAM,EAAIA,CAClD,CC1IO,SAASC,GAAclN,EAAO,CACjC,OAAQA,GAAS,OAAQA,EAAM,YAAgB,UACnD,CA0BO,SAASmN,GAAUnN,EAAO,CAC7B,GAAI,CACA,OAAA+M,GAAW/M,CAAK,EACT,EACV,MACa,CAAG,CACjB,MAAO,EACX,CACA,eAAeoN,GAAaxN,EAAQyN,EAAS,CACzC,MAAM/P,EAAS,MAAM+P,EACrB,OAAI/P,GAAU,MAAQA,IAAW,gDAC7B4C,EAAO,OAAQN,GAAY,SAAU,oBAAqB,oBAAqB,CAAE,MAAOA,CAAM,CAAE,EAChG/C,EAAe,GAAO,gEAAiE,SAAU+C,CAAM,GAEpGmN,GAAWzP,CAAM,CAC5B,CAsCO,SAASgQ,GAAe1N,EAAQ2N,EAAU,CAC7C,GAAI,OAAQ3N,GAAY,SACpB,OAAIA,EAAO,MAAM,mBAAmB,EACzBmN,GAAWnN,CAAM,GAE5BM,EAAOqN,GAAY,KAAM,qCAAsC,wBAAyB,CAAE,UAAW,aAAa,CAAE,EAC7GH,GAAaxN,EAAQ2N,EAAS,YAAY3N,CAAM,CAAC,GAEvD,GAAIsN,GAActN,CAAM,EACzB,OAAOwN,GAAaxN,EAAQA,EAAO,WAAY,CAAA,EAE9C,GAAIA,GAAU,OAAQA,EAAO,MAAU,WACxC,OAAOwN,GAAaxN,EAAQA,CAAM,EAEtC/C,EAAe,GAAO,gCAAiC,SAAU+C,CAAM,CAC3E,CCjGA,MAAM4N,EAAS,CAAA,EACf,SAAS/J,EAAEzD,EAAOyN,EAAO,CACrB,IAAIC,EAAS,GACb,OAAID,EAAQ,IACRC,EAAS,GACTD,GAAS,IAGN,IAAIE,EAAMH,EAAQ,GAAGE,EAAS,GAAK,GAAG,MAAMD,CAAK,GAAIzN,EAAO,CAAE,OAAA0N,EAAQ,MAAAD,CAAO,CAAA,CACxF,CACA,SAAS/J,EAAE1D,EAAO4N,EAAM,CAEpB,OAAO,IAAID,EAAMH,EAAQ,QAASI,GAAe,EAAE,GAAI5N,EAAO,CAAE,KAAA4N,CAAM,CAAA,CAC1E,CACA,MAAMC,GAAe,OAAO,IAAI,eAAe,SAIxC,MAAMC,GAAN,MAAMA,EAAM,CAiBf,YAAYC,EAAOzM,EAAMtB,EAAOgO,EAAS,CAbzC/R,EAAA,aAIAA,EAAA,cACAC,EAAA,KAAA+R,GAAA,QAIAhS,EAAA,qBAKQ+R,GAAW,OACXA,EAAU,MAEdE,GAAcV,EAAQO,EAAO,OAAO,EACpC1R,EAAiB,KAAM,CAAE,aAAAwR,GAAc,KAAAvM,EAAM,MAAAtB,CAAO,CAAA,EACpD5D,EAAA,KAAK6R,GAAWD,GAEhB,KAAK,OAAM,CACd,CAID,QAAS,CACL,GAAI,KAAK,OAAS,QACd,MAAM,IAAI,MAAM,EAAE,EAEjB,GAAI,KAAK,OAAS,eACnB,MAAM,IAAI,MAAM,EAAE,EAEjB,OAAI,KAAK,OAAS,QACZ,SAAS,KAAK,MAAM,IAAKG,GAAMA,EAAE,OAAQ,CAAA,EAAE,KAAK,GAAG,CAAC,IAExD,KAAK,IACf,CAID,cAAe,CACX,MAAO,EACV,CAID,UAAW,CACP,MAAO,EACV,CAID,UAAW,CACP,MAAO,EACV,CAID,UAAW,CACP,MAAO,CAAC,CAAE,KAAK,KAAK,MAAM,eAAe,CAC5C,CAID,QAAS,CACL,OAAO,KAAK,KAAK,WAAW,OAAO,CACtC,CAID,UAAW,CACP,OAAQ,KAAK,OAAS,QACzB,CAID,IAAI,WAAY,CACZ,GAAI,KAAK,OAAS,QACd,MAAM,UAAU,aAAa,EAEjC,OAAO7R,EAAA,KAAK2R,GACf,CAUD,IAAI,aAAc,CACd,GAAI,KAAK,OAAS,QACd,MAAM,UAAU,cAAc,EAElC,OAAI3R,EAAA,KAAK2R,MAAa,GACX,GAEP3R,EAAA,KAAK2R,MAAa,GACV,KAAK,MAAO,OAEjB,IACV,CAID,OAAO,KAAK3M,EAAMtB,EAAO,CACrB,OAAO,IAAI8N,GAAMN,EAAQlM,EAAMtB,CAAK,CACvC,CAID,OAAO,MAAMmO,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,CAAC,CAAI,CAInC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAIrC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,QAAQA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIvC,OAAO,KAAKA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIpC,OAAO,KAAKA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,EAAE,CAAI,CAInC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,MAAMA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,GAAG,CAAI,CAIrC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,OAAOA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIvC,OAAO,IAAIA,EAAG,CAAE,OAAO1K,EAAE0K,EAAG,IAAI,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,OAAOA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,CAAC,CAAI,CAIpC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAOzK,EAAEyK,EAAG,EAAE,CAAI,CAItC,OAAO,QAAQA,EAAG,CAAE,OAAO,IAAIL,GAAMN,EAAQ,UAAWW,CAAC,CAAI,CAI7D,OAAO,KAAKA,EAAG,CAAE,OAAO,IAAIL,GAAMN,EAAQ,OAAQ,CAAC,CAACW,CAAC,CAAI,CAIzD,OAAO,MAAMA,EAAG,CAAE,OAAO,IAAIL,GAAMN,EAAQ,QAASW,CAAC,CAAI,CAIzD,OAAO,OAAOA,EAAG,CAAE,OAAO,IAAIL,GAAMN,EAAQ,SAAUW,CAAC,CAAI,CAI3D,OAAO,MAAMA,EAAG3M,EAAS,CACrB,MAAM,IAAI,MAAM,qBAAqB,CAExC,CAID,OAAO,MAAM2M,EAAGrP,EAAM,CAClB,MAAM,IAAI,MAAM,qBAAqB,CAExC,CAID,OAAO,UAAUqP,EAAG,CAChB,OAAO,IAAIL,GAAMN,EAAQ,YAAa,OAAO,OAAO,CAAA,EAAIW,CAAC,CAAC,CAC7D,CAID,OAAO,QAAQnO,EAAO,CAClB,OAAQA,GACD,OAAQA,GAAW,UACnB,iBAAkBA,GAClBA,EAAM,eAAiB6N,EACjC,CAQD,OAAO,YAAY7N,EAAOsB,EAAM,CAC5B,GAAIwM,GAAM,QAAQ9N,CAAK,EAAG,CACtB,GAAIA,EAAM,OAASsB,EACf,MAAM,IAAI,MAAM,0BAA0BA,CAAI,SAAStB,EAAM,IAAI,EAAE,EAEvE,OAAOA,EAAM,KAChB,CACD,OAAOA,CACV,CACL,EA9iBIiO,GAAA,YATG,IAAMN,EAANG,GC1BA,MAAMM,WAAqB/M,EAAM,CACpC,YAAYE,EAAW,CACnB,MAAM,UAAW,UAAWA,EAAW,EAAK,CAC/C,CACD,cAAe,CACX,MAAO,4CACV,CACD,OAAOO,EAAQuM,EAAQ,CACnB,IAAIrO,EAAQ2N,EAAM,YAAYU,EAAQ,QAAQ,EAC9C,GAAI,CACArO,EAAQ+M,GAAW/M,CAAK,CAC3B,OACMjB,EAAO,CACV,OAAO,KAAK,YAAYA,EAAM,QAASsP,CAAM,CAChD,CACD,OAAOvM,EAAO,WAAW9B,CAAK,CACjC,CACD,OAAO6C,EAAQ,CACX,OAAOkK,GAAWuB,GAAQzL,EAAO,UAAW,EAAE,EAAE,CAAC,CACpD,CACL,CCrBO,MAAM0L,WAAuBlN,EAAM,CAEtC,YAAYmN,EAAO,CACf,MAAMA,EAAM,KAAMA,EAAM,KAAM,IAAKA,EAAM,OAAO,EAFpDvS,EAAA,cAGI,KAAK,MAAQuS,CAChB,CACD,cAAe,CACX,OAAO,KAAK,MAAM,cACrB,CACD,OAAO1M,EAAQ9B,EAAO,CAClB,OAAO,KAAK,MAAM,OAAO8B,EAAQ9B,CAAK,CACzC,CACD,OAAO6C,EAAQ,CACX,OAAO,KAAK,MAAM,OAAOA,CAAM,CAClC,CACL,CCdO,SAAS4L,GAAK3M,EAAQ4M,EAAQC,EAAQ,CACzC,IAAIC,EAAc,CAAA,EAClB,GAAI,MAAM,QAAQD,CAAM,EACpBC,EAAcD,UAETA,GAAU,OAAQA,GAAY,SAAU,CAC7C,IAAIE,EAAS,CAAA,EACbD,EAAcF,EAAO,IAAKF,GAAU,CAChC,MAAM1P,EAAO0P,EAAM,UACnB,OAAAtO,EAAOpB,EAAM,wDAAyD,mBAAoB,CAAE,SAAU,SAAU,KAAM,CAAE,MAAA0P,CAAO,EAAE,MAAOG,CAAQ,CAAA,EAChJzO,EAAO,CAAC2O,EAAO/P,CAAI,EAAG,0DAA2D,mBAAoB,CAAE,SAAU,SAAU,KAAM,CAAE,MAAA0P,CAAK,EAAI,MAAOG,CAAQ,CAAA,EAC3JE,EAAO/P,CAAI,EAAI,GACR6P,EAAO7P,CAAI,CAC9B,CAAS,CACJ,MAEGjC,EAAe,GAAO,sBAAuB,QAAS8R,CAAM,EAEhE9R,EAAe6R,EAAO,SAAWE,EAAY,OAAQ,8BAA+B,QAASD,CAAM,EACnG,IAAIG,EAAe,IAAIpN,GACnBqN,EAAgB,IAAIrN,GACpBsN,EAAc,CAAA,EAClBN,EAAO,QAAQ,CAACF,EAAO/O,IAAU,CAC7B,IAAIO,EAAQ4O,EAAYnP,CAAK,EAC7B,GAAI+O,EAAM,QAAS,CAEf,IAAIS,EAAgBF,EAAc,OAElCP,EAAM,OAAOO,EAAe/O,CAAK,EAEjC,IAAIkP,EAAaJ,EAAa,sBAC9BE,EAAY,KAAMG,GAAe,CAC7BD,EAAWC,EAAaF,CAAa,CACrD,CAAa,CACJ,MAEGT,EAAM,OAAOM,EAAc9O,CAAK,CAE5C,CAAK,EAEDgP,EAAY,QAAShD,GAAS,CAAEA,EAAK8C,EAAa,MAAM,CAAE,CAAE,EAC5D,IAAIhM,EAAShB,EAAO,aAAagN,CAAY,EAC7C,OAAAhM,GAAUhB,EAAO,aAAaiN,CAAa,EACpCjM,CACX,CAIO,SAASsM,GAAOvM,EAAQ6L,EAAQ,CACnC,IAAIC,EAAS,CAAA,EACTnO,EAAO,CAAA,EAEP6O,EAAaxM,EAAO,UAAU,CAAC,EACnC,OAAA6L,EAAO,QAASF,GAAU,CACtB,IAAIxO,EAAQ,KACZ,GAAIwO,EAAM,QAAS,CACf,IAAI/R,EAASoG,EAAO,YAChByM,EAAeD,EAAW,UAAU5S,CAAM,EAC9C,GAAI,CACAuD,EAAQwO,EAAM,OAAOc,CAAY,CACpC,OACMvQ,EAAO,CAEV,GAAIwQ,GAAQxQ,EAAO,gBAAgB,EAC/B,MAAMA,EAEViB,EAAQjB,EACRiB,EAAM,SAAWwO,EAAM,KACvBxO,EAAM,KAAOwO,EAAM,UACnBxO,EAAM,KAAOwO,EAAM,IACtB,CACJ,KAEG,IAAI,CACAxO,EAAQwO,EAAM,OAAO3L,CAAM,CAC9B,OACM9D,EAAO,CAEV,GAAIwQ,GAAQxQ,EAAO,gBAAgB,EAC/B,MAAMA,EAEViB,EAAQjB,EACRiB,EAAM,SAAWwO,EAAM,KACvBxO,EAAM,KAAOwO,EAAM,UACnBxO,EAAM,KAAOwO,EAAM,IACtB,CAEL,GAAIxO,GAAS,KACT,MAAM,IAAI,MAAM,aAAa,EAEjC2O,EAAO,KAAK3O,CAAK,EACjBQ,EAAK,KAAKgO,EAAM,WAAa,IAAI,CACzC,CAAK,EACM/N,GAAO,UAAUkO,EAAQnO,CAAI,CACxC,CAIO,MAAMgP,WAAmBnO,EAAM,CAGlC,YAAYmN,EAAO1L,EAAQvB,EAAW,CAClC,MAAMD,EAAQkN,EAAM,KAAO,KAAO1L,GAAU,EAAIA,EAAS,IAAM,IACzDtB,EAAWsB,IAAW,IAAM0L,EAAM,QACxC,MAAM,QAASlN,EAAMC,EAAWC,CAAO,EAL3CvF,EAAA,cACAA,EAAA,eAKII,EAAiB,KAAM,CAAE,MAAAmS,EAAO,OAAA1L,CAAQ,CAAA,CAC3C,CACD,cAAe,CAEX,MAAM2M,EAAe,KAAK,MAAM,aAAY,EACtCnS,EAAS,CAAA,EACf,QAASC,EAAI,EAAGA,EAAI,KAAK,OAAQA,IAC7BD,EAAO,KAAKmS,CAAY,EAE5B,OAAOnS,CACV,CACD,OAAOwE,EAAQuM,EAAQ,CACnB,MAAMrO,EAAQ2N,EAAM,YAAYU,EAAQ,OAAO,EAC1C,MAAM,QAAQrO,CAAK,GACpB,KAAK,YAAY,uBAAwBA,CAAK,EAElD,IAAIoD,EAAQ,KAAK,OACbA,IAAU,KACVA,EAAQpD,EAAM,OACd8B,EAAO,WAAW9B,EAAM,MAAM,GAElC0P,GAAoB1P,EAAM,OAAQoD,EAAO,eAAiB,KAAK,UAAa,IAAM,KAAK,UAAa,GAAG,EACvG,IAAIsL,EAAS,CAAA,EACb,QAASnR,EAAI,EAAGA,EAAIyC,EAAM,OAAQzC,IAC9BmR,EAAO,KAAK,KAAK,KAAK,EAE1B,OAAOD,GAAK3M,EAAQ4M,EAAQ1O,CAAK,CACpC,CACD,OAAO6C,EAAQ,CACX,IAAIO,EAAQ,KAAK,OACbA,IAAU,KACVA,EAAQP,EAAO,YAMf3C,EAAOkD,EAAQ3E,GAAYoE,EAAO,WAAY,2BAA4B,iBAAkB,CAAE,OAAQA,EAAO,MAAO,OAAQO,EAAQ3E,EAAU,OAAQoE,EAAO,UAAU,CAAE,GAE7K,IAAI6L,EAAS,CAAA,EACb,QAAS,EAAI,EAAG,EAAItL,EAAO,IACvBsL,EAAO,KAAK,IAAIH,GAAe,KAAK,KAAK,CAAC,EAE9C,OAAOa,GAAOvM,EAAQ6L,CAAM,CAC/B,CACL,CCxJO,MAAMiB,WAAqBtO,EAAM,CACpC,YAAYE,EAAW,CACnB,MAAM,OAAQ,OAAQA,EAAW,EAAK,CACzC,CACD,cAAe,CACX,MAAO,EACV,CACD,OAAOO,EAAQuM,EAAQ,CACnB,MAAMrO,EAAQ2N,EAAM,YAAYU,EAAQ,MAAM,EAC9C,OAAOvM,EAAO,WAAW9B,EAAQ,EAAI,CAAC,CACzC,CACD,OAAO6C,EAAQ,CACX,MAAO,CAAC,CAACA,EAAO,WACnB,CACL,CCdO,MAAM+M,WAA0BvO,EAAM,CACzC,YAAYC,EAAMC,EAAW,CACzB,MAAMD,EAAMA,EAAMC,EAAW,EAAI,CACpC,CACD,cAAe,CACX,MAAO,IACV,CACD,OAAOO,EAAQ9B,EAAO,CAClBA,EAAQmB,EAAanB,CAAK,EAC1B,IAAI8C,EAAShB,EAAO,WAAW9B,EAAM,MAAM,EAC3C,OAAA8C,GAAUhB,EAAO,WAAW9B,CAAK,EAC1B8C,CACV,CACD,OAAOD,EAAQ,CACX,OAAOA,EAAO,UAAUA,EAAO,UAAW,EAAE,EAAI,CACnD,CACL,CAIO,MAAMgN,WAAmBD,EAAkB,CAC9C,YAAYrO,EAAW,CACnB,MAAM,QAASA,CAAS,CAC3B,CACD,OAAOsB,EAAQ,CACX,OAAOD,EAAQ,MAAM,OAAOC,CAAM,CAAC,CACtC,CACL,CC1BO,MAAMiN,WAAwBzO,EAAM,CAEvC,YAAYuM,EAAMrM,EAAW,CACzB,IAAIzC,EAAO,QAAU,OAAO8O,CAAI,EAChC,MAAM9O,EAAMA,EAAMyC,EAAW,EAAK,EAHtCtF,EAAA,aAIII,EAAiB,KAAM,CAAE,KAAAuR,CAAI,EAAI,CAAE,KAAM,QAAQ,CAAE,CACtD,CACD,cAAe,CACX,MAAQ,qEAAsE,UAAU,EAAG,EAAI,KAAK,KAAO,CAAC,CAC/G,CACD,OAAO9L,EAAQuM,EAAQ,CACnB,IAAInM,EAAOf,EAAawM,EAAM,YAAYU,EAAQ,KAAK,IAAI,CAAC,EAC5D,OAAInM,EAAK,SAAW,KAAK,MACrB,KAAK,YAAY,wBAAyBmM,CAAM,EAE7CvM,EAAO,WAAWI,CAAI,CAChC,CACD,OAAOW,EAAQ,CACX,OAAOD,EAAQC,EAAO,UAAU,KAAK,IAAI,CAAC,CAC7C,CACL,CCzBA,MAAMkN,GAAQ,IAAI,WAAW,CAAA,CAAE,EAIxB,MAAMC,WAAkB3O,EAAM,CACjC,YAAYE,EAAW,CACnB,MAAM,OAAQ,GAAIA,EAAW,EAAK,CACrC,CACD,cAAe,CACX,OAAO,IACV,CACD,OAAOO,EAAQ9B,EAAO,CAClB,OAAIA,GAAS,MACT,KAAK,YAAY,WAAYA,CAAK,EAE/B8B,EAAO,WAAWiO,EAAK,CACjC,CACD,OAAOlN,EAAQ,CACX,OAAAA,EAAO,UAAU,CAAC,EACX,IACV,CACL,CCnBA,MAAMoJ,GAAO,OAAO,CAAC,EACfgE,GAAO,OAAO,CAAC,EACfC,GAAiB,OAAO,oEAAoE,EAI3F,MAAMC,WAAoB9O,EAAM,CAGnC,YAAYuM,EAAMF,EAAQnM,EAAW,CACjC,MAAMzC,GAAS4O,EAAS,MAAQ,QAAWE,EAAO,EAClD,MAAM9O,EAAMA,EAAMyC,EAAW,EAAK,EAJtCtF,EAAA,aACAA,EAAA,eAIII,EAAiB,KAAM,CAAE,KAAAuR,EAAM,OAAAF,CAAQ,EAAE,CAAE,KAAM,SAAU,OAAQ,SAAS,CAAE,CACjF,CACD,cAAe,CACX,MAAO,EACV,CACD,OAAO5L,EAAQuM,EAAQ,CACnB,IAAIrO,EAAQoQ,GAAUzC,EAAM,YAAYU,EAAQ,KAAK,IAAI,CAAC,EAEtDgC,EAAeC,GAAKJ,GAAgBzR,EAAW,CAAC,EACpD,GAAI,KAAK,OAAQ,CACb,IAAI8R,EAASD,GAAKD,EAAe,KAAK,KAAO,EAAK,CAAC,GAC/CrQ,EAAQuQ,GAAUvQ,EAAQ,EAAEuQ,EAASN,MACrC,KAAK,YAAY,sBAAuB5B,CAAM,EAElDrO,EAAQwQ,GAAOxQ,EAAO,EAAIvB,CAAQ,CACrC,MACQuB,EAAQiM,IAAQjM,EAAQsQ,GAAKD,EAAc,KAAK,KAAO,CAAC,IAC7D,KAAK,YAAY,sBAAuBhC,CAAM,EAElD,OAAOvM,EAAO,WAAW9B,CAAK,CACjC,CACD,OAAO6C,EAAQ,CACX,IAAI7C,EAAQsQ,GAAKzN,EAAO,UAAW,EAAE,KAAK,KAAO,CAAC,EAClD,OAAI,KAAK,SACL7C,EAAQyQ,GAASzQ,EAAO,KAAK,KAAO,CAAC,GAElCA,CACV,CACL,CCrCO,MAAM0Q,WAAoBd,EAAkB,CAC/C,YAAYrO,EAAW,CACnB,MAAM,SAAUA,CAAS,CAC5B,CACD,cAAe,CACX,MAAO,EACV,CACD,OAAOO,EAAQuM,EAAQ,CACnB,OAAO,MAAM,OAAOvM,EAAQhE,GAAY6P,EAAM,YAAYU,EAAQ,QAAQ,CAAC,CAAC,CAC/E,CACD,OAAOxL,EAAQ,CACX,OAAOtE,GAAa,MAAM,OAAOsE,CAAM,CAAC,CAC3C,CACL,CCZO,MAAM8N,WAAmBtP,EAAM,CAElC,YAAYqN,EAAQnN,EAAW,CAC3B,IAAIC,EAAU,GACd,MAAMoP,EAAQ,CAAA,EACdlC,EAAO,QAASF,GAAU,CAClBA,EAAM,UACNhN,EAAU,IAEdoP,EAAM,KAAKpC,EAAM,IAAI,CACjC,CAAS,EACD,MAAMlN,EAAQ,SAAWsP,EAAM,KAAK,GAAG,EAAI,IAC3C,MAAM,QAAStP,EAAMC,EAAWC,CAAO,EAX3CvF,EAAA,eAYII,EAAiB,KAAM,CAAE,OAAQ,OAAO,OAAOqS,EAAO,OAAO,CAAC,CAAE,CACnE,CACD,cAAe,CACX,MAAMC,EAAS,CAAA,EACf,KAAK,OAAO,QAASH,GAAU,CAC3BG,EAAO,KAAKH,EAAM,aAAc,CAAA,CAC5C,CAAS,EAED,MAAMqC,EAAc,KAAK,OAAO,OAAO,CAAClR,EAAO6O,IAAU,CACrD,MAAM1P,EAAO0P,EAAM,UACnB,OAAI1P,IACKa,EAAMb,CAAI,IACXa,EAAMb,CAAI,EAAI,GAElBa,EAAMb,CAAI,KAEPa,CACV,EAAE,CAAE,CAAA,EAEL,YAAK,OAAO,QAAQ,CAAC6O,EAAO/O,IAAU,CAClC,IAAIX,EAAO0P,EAAM,UACb,CAAC1P,GAAQ+R,EAAY/R,CAAI,IAAM,IAG/BA,IAAS,WACTA,EAAO,WAEP6P,EAAO7P,CAAI,GAAK,OAGpB6P,EAAO7P,CAAI,EAAI6P,EAAOlP,CAAK,GACvC,CAAS,EACM,OAAO,OAAOkP,CAAM,CAC9B,CACD,OAAO7M,EAAQuM,EAAQ,CACnB,MAAMrO,EAAQ2N,EAAM,YAAYU,EAAQ,OAAO,EAC/C,OAAOI,GAAK3M,EAAQ,KAAK,OAAQ9B,CAAK,CACzC,CACD,OAAO6C,EAAQ,CACX,OAAOuM,GAAOvM,EAAQ,KAAK,MAAM,CACpC,CACL,CChDO,SAASiO,GAAG9Q,EAAO,CACtB,OAAO+L,GAAUjO,GAAYkC,CAAK,CAAC,CACvC,CCbA,SAAS+Q,GAAaC,EAAMC,EAAa,CACrC,MAAO,CACH,QAASlE,GAAWiE,CAAI,EACxB,YAAaC,EAAY,IAAI,CAACC,EAAYzR,KACtC5C,EAAesU,GAAYD,EAAY,EAAE,EAAG,eAAgB,eAAezR,CAAK,IAAKyR,CAAU,EACxFA,EAAW,cACrB,CACT,CACA,CAIO,SAASE,GAAcpR,EAAO,CACjC,GAAI,MAAM,QAAQA,CAAK,EACnB,OAAOA,EAAM,IAAI,CAACqR,EAAK5R,IACf,MAAM,QAAQ4R,CAAG,GACjBxU,EAAewU,EAAI,SAAW,EAAG,mBAAoB,SAAS5R,CAAK,IAAK4R,CAAG,EACpEN,GAAaM,EAAI,CAAC,EAAGA,EAAI,CAAC,CAAC,IAEtCxU,EAAewU,GAAO,MAAQ,OAAQA,GAAS,SAAU,2BAA4B,QAASrR,CAAK,EAC5F+Q,GAAaM,EAAI,QAASA,EAAI,WAAW,EACnD,EAELxU,EAAemD,GAAS,MAAQ,OAAQA,GAAW,SAAU,sBAAuB,QAASA,CAAK,EAClG,MAAM1C,EAAS,OAAO,KAAK0C,CAAK,EAAE,IAAKgR,GAAS,CAC5C,MAAMC,EAAcjR,EAAMgR,CAAI,EAAE,OAAO,CAACrR,EAAOuR,KAC3CvR,EAAMuR,CAAU,EAAI,GACbvR,GACR,CAAE,CAAA,EACL,OAAOoR,GAAaC,EAAM,OAAO,KAAKC,CAAW,EAAE,KAAI,CAAE,CACjE,CAAK,EACD,OAAA3T,EAAO,KAAK,CAAC8G,EAAGV,IAAOU,EAAE,QAAQ,cAAcV,EAAE,OAAO,CAAE,EACnDpG,CACX,CCpBA,SAASgU,EAAOlS,EAAO,CACnB,MAAM9B,EAAS,IAAI,IACnB,OAAA8B,EAAM,QAASmS,GAAMjU,EAAO,IAAIiU,CAAC,CAAC,EAC3B,OAAO,OAAOjU,CAAM,CAC/B,CACA,MAAMkU,GAAiB,mCACjBC,GAAgBH,EAAOE,GAAe,MAAM,GAAG,CAAC,EAEhDE,GAAW,uEACXC,GAAUL,EAAOI,GAAS,MAAM,GAAG,CAAC,EACpCE,GAAW,2DACXC,GAAUP,EAAOM,GAAS,MAAM,GAAG,CAAC,EACpCE,GAAe,0CACfC,GAAcT,EAAOQ,GAAa,MAAM,GAAG,CAAC,EAC5CE,GAAW,gBAEXC,GAAY,CAACL,GAAUE,GAAcE,GAAUN,EAAQ,EAAE,KAAK,GAAG,EACjEQ,GAAWZ,EAAOW,GAAU,MAAM,GAAG,CAAC,EAEtCE,GAAe,CACjB,IAAK,aAAc,IAAK,cACxB,IAAK,eAAgB,IAAK,gBAC1B,IAAK,QAAS,IAAK,IACvB,EAEMC,GAAwB,IAAI,OAAO,SAAS,EAC5CC,GAAoB,IAAI,OAAO,WAAW,EAC1CC,GAAgB,IAAI,OAAO,6BAA6B,EAExDC,GAAU,IAAI,OAAO,8BAA8B,EACnDC,GAAY,IAAI,OAAO,qDAAqD,gBAClF,MAAMC,GAAN,MAAMA,EAAY,CAKd,YAAYC,EAAQ,CAMpBxW,EAAA,KAAAyW,IAVAzW,EAAA,KAAAsG,EAAA,QACAtG,EAAA,KAAA0W,EAAA,QAIIxW,EAAA,KAAKoG,EAAU,GACfpG,EAAA,KAAKwW,EAAUF,EAAO,QACzB,CALD,IAAI,QAAS,CAAE,OAAOpW,EAAA,KAAKkG,EAAU,CACrC,IAAI,QAAS,CAAE,OAAOlG,EAAA,KAAKsW,GAAQ,OAAStW,EAAA,KAAKkG,EAAU,CAK3D,OAAQ,CAAE,OAAO,IAAIiQ,GAAYnW,EAAA,KAAKsW,EAAO,CAAI,CACjD,OAAQ,CAAExW,EAAA,KAAKoG,EAAU,EAAI,CAW7B,WAAWqQ,EAAS,CAChB,MAAMC,EAAM,KAAK,OACjB,GAAIA,EAAI,OAAS,WAAa,CAACD,EAAQ,IAAIC,EAAI,IAAI,EAC/C,MAAM,IAAI,MAAM,oBAAoBA,EAAI,IAAI,EAAE,EAElD,OAAO,KAAK,IAAK,EAAC,IACrB,CAED,QAAQxR,EAAM,CACV,GAAI,KAAK,OAAO,OAASA,EAAM,CAC3B,MAAMwR,EAAM,KAAK,OACjB,MAAM,IAAI,MAAM,YAAYxR,CAAI,SAASwR,EAAI,IAAI,IAAI,KAAK,UAAUA,EAAI,IAAI,CAAC,EAAE,CAClF,CACD,OAAO,KAAK,IAAK,EAAC,IACrB,CAED,UAAW,CACP,MAAMA,EAAM,KAAK,OACjB,GAAIA,EAAI,OAAS,aACb,MAAM,IAAI,MAAM,WAAW,EAE/B,MAAMxV,EAASyE,EAAA,KAAK4Q,GAAAI,IAAL,UAAqBzW,EAAA,KAAKkG,GAAU,EAAGsQ,EAAI,MAAQ,GAClE,OAAA1W,EAAA,KAAKoG,EAAUsQ,EAAI,MAAQ,GACpBxV,CACV,CAED,WAAY,CACR,MAAMwV,EAAM,KAAK,OACjB,GAAIA,EAAI,OAAS,aACb,MAAM,IAAI,MAAM,WAAW,EAE/B,MAAMxV,EAAS,CAAA,EACf,KAAOhB,EAAA,KAAKkG,GAAUsQ,EAAI,MAAQ,GAAG,CACjC,MAAME,EAAO,KAAK,KAAI,EAAG,SACzB1V,EAAO,KAAKyE,EAAA,KAAK4Q,GAAAI,IAAL,UAAqBzW,EAAA,KAAKkG,GAAU,EAAGwQ,EAAK,EACxD5W,EAAA,KAAKoG,EAAUwQ,EAClB,CACD,OAAA5W,EAAA,KAAKoG,EAAUsQ,EAAI,MAAQ,GACpBxV,CACV,CAED,MAAO,CACH,GAAIhB,EAAA,KAAKkG,IAAWlG,EAAA,KAAKsW,GAAQ,OAC7B,MAAM,IAAI,MAAM,eAAe,EAEnC,OAAOtW,EAAA,KAAKsW,GAAQtW,EAAA,KAAKkG,EAAO,CACnC,CAED,YAAYqQ,EAAS,CACjB,MAAMC,EAAM,KAAK,SAAS,SAAS,EACnC,OAAQA,GAAO,MAAQD,EAAQ,IAAIC,CAAG,EAAKA,EAAM,IACpD,CAED,SAASxR,EAAM,CACX,GAAI,KAAK,SAAW,EAChB,OAAO,KAEX,MAAMwR,EAAM,KAAK,OACjB,OAAQA,EAAI,OAASxR,EAAQwR,EAAI,KAAO,IAC3C,CAED,KAAM,CACF,MAAMxV,EAAS,KAAK,OACpB,OAAA2V,GAAA,KAAKzQ,GAAL,IACOlF,CACV,CACD,UAAW,CACP,MAAMoV,EAAS,CAAA,EACf,QAASnV,EAAIjB,EAAA,KAAKkG,GAASjF,EAAIjB,EAAA,KAAKsW,GAAQ,OAAQrV,IAAK,CACrD,MAAM2V,EAAQ5W,EAAA,KAAKsW,GAAQrV,CAAC,EAC5BmV,EAAO,KAAK,GAAGQ,EAAM,IAAI,IAAIA,EAAM,IAAI,EAAE,CAC5C,CACD,MAAO,gBAAgBR,EAAO,KAAK,GAAG,CAAC,GAC1C,CACL,EA9FIlQ,EAAA,YACAoQ,EAAA,YASAD,GAAA,YAAAI,GAAe,SAACI,EAAO,EAAG1H,EAAK,EAAG,CAC9B,OAAO,IAAIgH,GAAYnW,EAAA,KAAKsW,GAAQ,MAAMO,EAAM1H,CAAE,EAAE,IAAK3B,GAC9C,OAAO,OAAO,OAAO,OAAO,CAAA,EAAIA,EAAG,CACtC,MAAQA,EAAE,MAAQqJ,EAClB,SAAWrJ,EAAE,SAAWqJ,EACxB,SAAWrJ,EAAE,SAAWqJ,CAC3B,CAAA,CAAC,CACL,CAAC,CACL,EAnBL,IAAMC,EAANX,GAgGA,SAASY,GAAIC,EAAM,CACf,MAAMZ,EAAS,CAAA,EACT7T,EAAc4C,GAAY,CAC5B,MAAMyR,EAASzW,EAAS6W,EAAK,OAAU,KAAK,UAAUA,EAAK7W,CAAM,CAAC,EAAI,OACtE,MAAM,IAAI,MAAM,iBAAiByW,CAAK,OAAOzW,CAAM,KAAKgF,CAAO,EAAE,CACzE,EACI,IAAI8R,EAAW,CAAA,EACXC,EAAS,CAAA,EACT/W,EAAS,EACb,KAAOA,EAAS6W,EAAK,QAAQ,CAEzB,IAAIG,EAAMH,EAAK,UAAU7W,CAAM,EAC3BiX,EAAQD,EAAI,MAAMrB,EAAqB,EACvCsB,IACAjX,GAAUiX,EAAM,CAAC,EAAE,OACnBD,EAAMH,EAAK,UAAU7W,CAAM,GAE/B,MAAMyW,EAAQ,CAAE,MAAOK,EAAS,OAAQ,SAAU,GAAI,SAAU,GAAI,MAAO,GAAI,KAAM,GAAI,KAAM,GAAI,OAAA9W,EAAQ,MAAO,IAClHiW,EAAO,KAAKQ,CAAK,EACjB,IAAI5R,EAAQ6Q,GAAasB,EAAI,CAAC,CAAC,GAAK,GACpC,GAAInS,EAAM,CAIN,GAHA4R,EAAM,KAAO5R,EACb4R,EAAM,KAAOO,EAAI,CAAC,EAClBhX,IACI6E,IAAS,aACTiS,EAAS,KAAKb,EAAO,OAAS,CAAC,EAC/Bc,EAAO,KAAKd,EAAO,OAAS,CAAC,UAExBpR,GAAQ,cACTiS,EAAS,SAAW,GACpB1U,EAAW,0BAA0B,EAEzCqU,EAAM,MAAQK,EAAS,MACtBb,EAAOQ,EAAM,KAAK,EAAG,MAAQR,EAAO,OAAS,EAC9CQ,EAAM,QACNA,EAAM,SAAWM,EAAO,MACvBd,EAAOQ,EAAM,QAAQ,EAAG,SAAWR,EAAO,OAAS,UAE/CpR,IAAS,QACd4R,EAAM,SAAWM,EAAO,MACvBd,EAAOQ,EAAM,QAAQ,EAAG,SAAWR,EAAO,OAAS,EACpDc,EAAO,KAAKd,EAAO,OAAS,CAAC,UAExBpR,IAAS,eACd4R,EAAM,KAAO,kBAER5R,IAAS,gBAAiB,CAE/B,IAAI2J,EAASyH,EAAO,IAAG,EAAG,KAC1B,GAAIA,EAAO,OAAS,GAAKA,EAAOA,EAAO,OAAS,CAAC,EAAE,OAAS,SAAU,CAClE,MAAM1S,EAAQ0S,EAAO,IAAG,EAAG,KAC3BzH,EAASjL,EAAQiL,EAChByH,EAAOA,EAAO,OAAS,CAAC,EAAG,MAAQ3S,GAAUC,CAAK,CACtD,CACD,GAAI0S,EAAO,SAAW,GAAKA,EAAOA,EAAO,OAAS,CAAC,EAAE,OAAS,UAC1D,MAAM,IAAI,MAAM,yBAAyB,EAE5CA,EAAOA,EAAO,OAAS,CAAC,EAAG,MAAQzH,CACvC,CACD,QACH,CAED,GADAyI,EAAQD,EAAI,MAAMnB,EAAa,EAC3BoB,EAAO,CAGP,GAFAR,EAAM,KAAOQ,EAAM,CAAC,EACpBjX,GAAUyW,EAAM,KAAK,OACjBhB,GAAS,IAAIgB,EAAM,IAAI,EAAG,CAC1BA,EAAM,KAAO,UACb,QACH,CACD,GAAIA,EAAM,KAAK,MAAMV,EAAS,EAAG,CAC7BU,EAAM,KAAO,OACb,QACH,CACDA,EAAM,KAAO,KACb,QACH,CAED,GADAQ,EAAQD,EAAI,MAAMpB,EAAiB,EAC/BqB,EAAO,CACPR,EAAM,KAAOQ,EAAM,CAAC,EACpBR,EAAM,KAAO,SACbzW,GAAUyW,EAAM,KAAK,OACrB,QACH,CACD,MAAM,IAAI,MAAM,oBAAoB,KAAK,UAAUO,EAAI,CAAC,CAAC,CAAC,gBAAgBhX,CAAM,EAAE,CACrF,CACD,OAAO,IAAI2W,EAAYV,EAAO,IAAK5I,GAAM,OAAO,OAAOA,CAAC,CAAC,CAAC,CAC9D,CAEA,SAAS6J,GAAYtC,EAAKwB,EAAS,CAC/B,IAAIe,EAAW,CAAA,EACf,UAAW7S,KAAO8R,EAAQ,OAClBxB,EAAI,IAAItQ,CAAG,GACX6S,EAAS,KAAK7S,CAAG,EAGzB,GAAI6S,EAAS,OAAS,EAClB,MAAM,IAAI,MAAM,sBAAsBA,EAAS,KAAK,IAAI,CAAC,EAAE,CAEnE,CAGA,SAASC,GAAYvS,EAAMoR,EAAQ,CAC/B,GAAIA,EAAO,YAAYb,EAAO,EAAG,CAC7B,MAAMiC,EAAUpB,EAAO,IAAG,EAAG,KAC7B,GAAIoB,IAAYxS,EACZ,MAAM,IAAI,MAAM,YAAYA,CAAI,SAASwS,CAAO,EAAE,CAEzD,CACD,OAAOpB,EAAO,QAAQ,IAAI,CAC9B,CAEA,SAASqB,GAAgBrB,EAAQG,EAAS,CACtC,MAAMmB,EAAW,IAAI,IACrB,OAAa,CACT,MAAMF,EAAUpB,EAAO,SAAS,SAAS,EACzC,GAAIoB,GAAW,MAASjB,GAAW,CAACA,EAAQ,IAAIiB,CAAO,EACnD,MAGJ,GADApB,EAAO,IAAG,EACNsB,EAAS,IAAIF,CAAO,EACpB,MAAM,IAAI,MAAM,uBAAuB,KAAK,UAAUA,CAAO,CAAC,EAAE,EAEpEE,EAAS,IAAIF,CAAO,CACvB,CACD,OAAO,OAAO,OAAOE,CAAQ,CACjC,CAEA,SAASC,GAAkBvB,EAAQ,CAC/B,IAAIwB,EAAYH,GAAgBrB,EAAQf,EAAO,EAK/C,OAHAgC,GAAYO,EAAW5C,EAAO,8BAA8B,MAAM,GAAG,CAAC,CAAC,EACvEqC,GAAYO,EAAW5C,EAAO,+BAA+B,MAAM,GAAG,CAAC,CAAC,EAEpE4C,EAAU,IAAI,MAAM,EACb,OAEPA,EAAU,IAAI,MAAM,EACb,OAEPA,EAAU,IAAI,SAAS,EAChB,UAEPA,EAAU,IAAI,YAAY,EACnB,aAGPA,EAAU,IAAI,UAAU,EACjB,OAEJ,YACX,CAEA,SAASC,GAAczB,EAAQ0B,EAAc,CACzC,OAAO1B,EAAO,YAAY,IAAK5I,GAAMuK,EAAU,KAAKvK,EAAGsK,CAAY,CAAC,CACxE,CAEA,SAASE,GAAW5B,EAAQ,CACxB,GAAIA,EAAO,SAAS,IAAI,EAAG,CAEvB,GADAA,EAAO,IAAG,EACNA,EAAO,SAAS,QAAQ,EACxB,OAAOtC,GAAUsC,EAAO,IAAK,EAAC,IAAI,EAEtC,MAAM,IAAI,MAAM,aAAa,CAChC,CACD,OAAO,IACX,CACA,SAAS6B,GAAW7B,EAAQ,CACxB,GAAIA,EAAO,OACP,MAAM,IAAI,MAAM,+BAA+BA,EAAO,MAAM,KAAKA,EAAO,UAAU,EAAE,CAE5F,CACA,MAAM8B,GAAiB,IAAI,OAAO,oBAAoB,EACtD,SAASC,GAAgBnT,EAAM,CAC3B,MAAMoS,EAAQpS,EAAK,MAAMkR,EAAS,EAElC,GADA3V,EAAe6W,EAAO,eAAgB,OAAQpS,CAAI,EAC9CA,IAAS,OACT,MAAO,UAEX,GAAIA,IAAS,MACT,MAAO,SAEX,GAAIoS,EAAM,CAAC,EAAG,CAEV,MAAM5Q,EAAS,SAAS4Q,EAAM,CAAC,CAAC,EAChC7W,EAAeiG,IAAW,GAAKA,GAAU,GAAI,uBAAwB,OAAQxB,CAAI,CACpF,SACQoS,EAAM,CAAC,EAAG,CAEf,MAAM9F,EAAO,SAAS8F,EAAM,CAAC,CAAC,EAC9B7W,EAAe+Q,IAAS,GAAKA,GAAQ,KAAQA,EAAO,IAAO,EAAG,wBAAyB,OAAQtM,CAAI,CACtG,CACD,OAAOA,CACX,CAEA,MAAM1C,EAAS,CAAA,EACT8V,EAAW,OAAO,IAAI,kBAAkB,EACxCC,GAAoB,qBACpBC,GAAwB,iBACxBC,GAAwB,iBACxBC,GAA8B,uBAC9BC,GAA2B,oBAC3BC,GAA2B,oBAC3BC,GAAyB,4BAIxB,MAAMC,EAAN,MAAMA,CAAU,CAyCnB,YAAY/V,EAAOL,EAAMwC,EAAM6T,EAAUC,EAASC,EAAYC,EAAaC,EAAe,CA2I1FrZ,EAAA,KAAAsZ,IAhLAvZ,EAAA,aAKAA,EAAA,aAIAA,EAAA,iBAMAA,EAAA,gBAMAA,EAAA,mBAMAA,EAAA,oBAMAA,EAAA,sBAUI,GALAiS,GAAc/O,EAAOP,EAAQ,WAAW,EACxC,OAAO,eAAe,KAAM8V,EAAU,CAAE,MAAOC,EAAiB,CAAE,EAC9DU,IACAA,EAAa,OAAO,OAAOA,EAAW,MAAO,CAAA,GAE7CF,IAAa,SACb,GAAIG,GAAe,MAAQC,GAAiB,KACxC,MAAM,IAAI,MAAM,EAAE,UAGjBD,GAAe,MAAQC,GAAiB,KAC7C,MAAM,IAAI,MAAM,EAAE,EAEtB,GAAIJ,IAAa,SACb,GAAIE,GAAc,KACd,MAAM,IAAI,MAAM,EAAE,UAGjBA,GAAc,KACnB,MAAM,IAAI,MAAM,EAAE,EAEtBhZ,EAAiB,KAAM,CACnB,KAAAyC,EAAM,KAAAwC,EAAM,SAAA6T,EAAU,QAAAC,EAAS,WAAAC,EAAY,YAAAC,EAAa,cAAAC,CACpE,CAAS,CACJ,CAYD,OAAOE,EAAQ,CAIX,GAHIA,GAAU,OACVA,EAAS,WAETA,IAAW,OAAQ,CACnB,MAAM3W,EAAO,KAAK,MAAQ,GAC1B,GAAI,KAAK,UAAW,CAChB,MAAMxB,EAAS,KAAK,MAAM,KAAK,cAAc,OAAO,MAAM,CAAC,EAC3D,OAAAA,EAAO,KAAOwB,EACdxB,EAAO,MAAQ,IAAK,KAAK,YAAc,EAAI,GAAK,OAAO,KAAK,WAAW,CAAC,IACjE,KAAK,UAAUA,CAAM,CAC/B,CACD,MAAMA,EAAS,CACX,KAAQ,KAAK,WAAa,QAAW,QAAU,KAAK,KACpD,KAAAwB,CAChB,EACY,OAAI,OAAQ,KAAK,SAAa,YAC1BxB,EAAO,QAAU,KAAK,SAEtB,KAAK,YACLA,EAAO,WAAa,KAAK,WAAW,IAAKE,GAAM,KAAK,MAAMA,EAAE,OAAOiY,CAAM,CAAC,CAAC,GAExE,KAAK,UAAUnY,CAAM,CAC/B,CACD,IAAIA,EAAS,GAEb,OAAI,KAAK,WACLA,GAAU,KAAK,cAAc,OAAOmY,CAAM,EAC1CnY,GAAU,IAAK,KAAK,YAAc,EAAI,GAAK,OAAO,KAAK,WAAW,CAAC,KAG/D,KAAK,UACLA,GAAU,IAAM,KAAK,WAAW,IAAKoY,GAASA,EAAK,OAAOD,CAAM,CAAC,EAAE,KAAMA,IAAW,OAAU,KAAO,GAAG,EAAI,IAG5GnY,GAAU,KAAK,KAGnBmY,IAAW,YACP,KAAK,UAAY,KACjBnY,GAAU,YAEVmY,IAAW,QAAU,KAAK,OAC1BnY,GAAU,IAAM,KAAK,OAGtBA,CACV,CAOD,SAAU,CACN,OAAQ,KAAK,WAAa,OAC7B,CAOD,SAAU,CACN,OAAQ,KAAK,WAAa,OAC7B,CAOD,aAAc,CACV,OAAQ,KAAK,SAAW,IAC3B,CAKD,KAAK0C,EAAO2V,EAAS,CACjB,GAAI,KAAK,UAAW,CAChB,GAAI,CAAC,MAAM,QAAQ3V,CAAK,EACpB,MAAM,IAAI,MAAM,qBAAqB,EAEzC,GAAI,KAAK,cAAgB,IAAMA,EAAM,SAAW,KAAK,YACjD,MAAM,IAAI,MAAM,uBAAuB,EAE3C,MAAM4V,EAAQ,KACd,OAAO5V,EAAM,IAAKmO,GAAOyH,EAAM,cAAc,KAAKzH,EAAGwH,CAAO,CAAE,CACjE,CACD,GAAI,KAAK,UAAW,CAChB,GAAI,CAAC,MAAM,QAAQ3V,CAAK,EACpB,MAAM,IAAI,MAAM,qBAAqB,EAEzC,GAAIA,EAAM,SAAW,KAAK,WAAW,OACjC,MAAM,IAAI,MAAM,uBAAuB,EAE3C,MAAM4V,EAAQ,KACd,OAAO5V,EAAM,IAAI,CAACmO,EAAG,IAAOyH,EAAM,WAAW,CAAC,EAAE,KAAKzH,EAAGwH,CAAO,CAAE,CACpE,CACD,OAAOA,EAAQ,KAAK,KAAM3V,CAAK,CAClC,CAkED,MAAM,UAAUA,EAAO2V,EAAS,CAC5B,MAAME,EAAW,CAAA,EACXvY,EAAS,CAAC0C,CAAK,EACrB,OAAA+B,EAAA,KAAKyT,GAAAM,IAAL,UAAgBD,EAAU7V,EAAO2V,EAAU3V,GAAU,CACjD1C,EAAO,CAAC,EAAI0C,CACxB,GACY6V,EAAS,QACT,MAAM,QAAQ,IAAIA,CAAQ,EAEvBvY,EAAO,CAAC,CAClB,CAOD,OAAO,KAAKyY,EAAK3B,EAAc,CAC3B,GAAIc,EAAU,YAAYa,CAAG,EACzB,OAAOA,EAEX,GAAI,OAAQA,GAAS,SACjB,GAAI,CACA,OAAOb,EAAU,KAAK7B,GAAI0C,CAAG,EAAG3B,CAAY,CAC/C,MACa,CACVvX,EAAe,GAAO,qBAAsB,MAAOkZ,CAAG,CACzD,SAEIA,aAAe3C,EAAa,CACjC,IAAI9R,EAAO,GAAI6T,EAAW,GACtBa,EAAQ,KACRjC,GAAgBgC,EAAKzE,EAAO,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,OAAO,GAAKyE,EAAI,SAAS,YAAY,GAEjFZ,EAAW,QACXa,EAAQD,EAAI,UAAS,EAAG,IAAKjM,GAAMoL,EAAU,KAAKpL,CAAC,CAAC,EACpDxI,EAAO,SAAS0U,EAAM,IAAKxY,GAAMA,EAAE,OAAQ,CAAA,EAAE,KAAK,GAAG,CAAC,MAItD8D,EAAOmT,GAAgBsB,EAAI,QAAQ,MAAM,CAAC,EAC1CZ,EAAW7T,GAGf,IAAIiU,EAAgB,KAChBD,EAAc,KAClB,KAAOS,EAAI,QAAUA,EAAI,SAAS,SAAS,GAAG,CAC1C,MAAME,EAAUF,EAAI,MACpBR,EAAgB,IAAIL,EAAUtW,EAAQ,GAAI0C,EAAM6T,EAAU,KAAMa,EAAOV,EAAaC,CAAa,EACjGD,EAAcW,EAAQ,MACtB3U,GAAQ2U,EAAQ,KAChBd,EAAW,QACXa,EAAQ,IACX,CACD,IAAIZ,EAAU,KAEd,GADiBrB,GAAgBgC,EAAKhE,EAAW,EACpC,IAAI,SAAS,EAAG,CACzB,GAAI,CAACqC,EACD,MAAM,IAAI,MAAM,EAAE,EAEtBgB,EAAU,EACb,CACD,MAAMtW,EAAQiX,EAAI,SAAS,IAAI,EAAIA,EAAI,IAAK,EAAC,KAAO,GACpD,GAAIA,EAAI,OACJ,MAAM,IAAI,MAAM,iBAAiB,EAErC,OAAO,IAAIb,EAAUtW,EAAQE,EAAMwC,EAAM6T,EAAUC,EAASY,EAAOV,EAAaC,CAAa,CAChG,CACD,MAAMzW,EAAOiX,EAAI,KACjBlZ,EAAe,CAACiC,GAAS,OAAQA,GAAU,UAAYA,EAAK,MAAMyT,EAAO,EAAI,eAAgB,WAAYzT,CAAI,EAC7G,IAAIsW,EAAUW,EAAI,QACdX,GAAW,OACXvY,EAAeuX,EAAc,8BAA+B,cAAe2B,EAAI,OAAO,EACtFX,EAAU,CAAC,CAACA,GAEhB,IAAI9T,EAAOyU,EAAI,KACXG,EAAa5U,EAAK,MAAMkT,EAAc,EAC1C,GAAI0B,EAAY,CACZ,MAAMZ,EAAc,SAASY,EAAW,CAAC,GAAK,IAAI,EAC5CX,EAAgBL,EAAU,KAAK,CACjC,KAAMgB,EAAW,CAAC,EAClB,WAAYH,EAAI,UAChC,CAAa,EACD,OAAO,IAAIb,EAAUtW,EAAQE,GAAQ,GAAIwC,EAAM,QAAS8T,EAAS,KAAME,EAAaC,CAAa,CACpG,CACD,GAAIjU,IAAS,SAAWA,EAAK,WAAW,QAAQ,GAAkBA,EAAK,WAAW,KAAmB,CACjG,MAAM0U,EAASD,EAAI,YAAc,KAAQA,EAAI,WAAW,IAAKvY,GAAM0X,EAAU,KAAK1X,CAAC,CAAC,EAAI,KAGxF,OAFc,IAAI0X,EAAUtW,EAAQE,GAAQ,GAAIwC,EAAM,QAAS8T,EAASY,EAAO,KAAM,IAAI,CAG5F,CACD,OAAA1U,EAAOmT,GAAgBsB,EAAI,IAAI,EACxB,IAAIb,EAAUtW,EAAQE,GAAQ,GAAIwC,EAAMA,EAAM8T,EAAS,KAAM,KAAM,IAAI,CACjF,CAID,OAAO,YAAYpV,EAAO,CACtB,OAAQA,GAASA,EAAM0U,CAAQ,IAAMC,EACxC,CACL,EArKIa,GAAA,YAAAM,GAAU,SAACD,EAAU7V,EAAO2V,EAASQ,EAAU,CAC3C,GAAI,KAAK,UAAW,CAChB,GAAI,CAAC,MAAM,QAAQnW,CAAK,EACpB,MAAM,IAAI,MAAM,qBAAqB,EAEzC,GAAI,KAAK,cAAgB,IAAMA,EAAM,SAAW,KAAK,YACjD,MAAM,IAAI,MAAM,uBAAuB,EAE3C,MAAMoW,EAAY,KAAK,cACjB9Y,EAAS0C,EAAM,QACrB1C,EAAO,QAAQ,CAAC0C,EAAOP,IAAU,OAC7BsC,EAAAsB,EAAA+S,EAAUZ,GAAAM,IAAV,KAAAzS,EAAqBwS,EAAU7V,EAAO2V,EAAU3V,GAAU,CACtD1C,EAAOmC,CAAK,EAAIO,CACpC,EACA,CAAa,EACDmW,EAAS7Y,CAAM,EACf,MACH,CACD,GAAI,KAAK,UAAW,CAChB,MAAM+X,EAAa,KAAK,WAExB,IAAI/X,EACJ,GAAI,MAAM,QAAQ0C,CAAK,EACnB1C,EAAS0C,EAAM,YAEd,CACD,GAAIA,GAAS,MAAQ,OAAQA,GAAW,SACpC,MAAM,IAAI,MAAM,qBAAqB,EAEzC1C,EAAS+X,EAAW,IAAKgB,GAAU,CAC/B,GAAI,CAACA,EAAM,KACP,MAAM,IAAI,MAAM,iDAAiD,EAErE,GAAI,EAAEA,EAAM,QAAQrW,GAChB,MAAM,IAAI,MAAM,+BAA+BqW,EAAM,IAAI,EAAE,EAE/D,OAAOrW,EAAMqW,EAAM,IAAI,CAC3C,CAAiB,CACJ,CACD,GAAI/Y,EAAO,SAAW,KAAK,WAAW,OAClC,MAAM,IAAI,MAAM,uBAAuB,EAE3CA,EAAO,QAAQ,CAAC0C,EAAOP,IAAU,OAC7BsC,EAAAsB,EAAAgS,EAAW5V,CAAK,EAAE+V,GAAAM,IAAlB,KAAAzS,EAA6BwS,EAAU7V,EAAO2V,EAAU3V,GAAU,CAC9D1C,EAAOmC,CAAK,EAAIO,CACpC,EACA,CAAa,EACDmW,EAAS7Y,CAAM,EACf,MACH,CACD,MAAMA,EAASqY,EAAQ,KAAK,KAAM3V,CAAK,EACnC1C,EAAO,KACPuY,EAAS,KAAM,gBAAkB,CAAEM,EAAS,MAAM7Y,CAAM,CAAI,EAAA,CAAG,EAG/D6Y,EAAS7Y,CAAM,CAEtB,EA7OE,IAAM+W,EAANa,EA6VA,MAAMoB,EAAS,CAYlB,YAAYnX,EAAOmC,EAAMiV,EAAQ,CARjCta,EAAA,aAIAA,EAAA,eAKIiS,GAAc/O,EAAOP,EAAQ,UAAU,EACvC2X,EAAS,OAAO,OAAOA,EAAO,MAAO,CAAA,EACrCla,EAAiB,KAAM,CAAE,KAAAiF,EAAM,OAAAiV,CAAQ,CAAA,CAC1C,CAKD,OAAO,KAAKR,EAAK,CACb,GAAI,OAAQA,GAAS,SAAU,CAE3B,GAAI,CACAO,GAAS,KAAK,KAAK,MAAMP,CAAG,CAAC,CAChC,MACS,CAAG,CAEb,OAAOO,GAAS,KAAKjD,GAAI0C,CAAG,CAAC,CAChC,CACD,GAAIA,aAAe3C,EAGf,OADa2C,EAAI,YAAYlE,EAAO,EACxB,CACR,IAAK,cAAe,OAAO2E,GAAoB,KAAKT,CAAG,EACvD,IAAK,QAAS,OAAOU,EAAc,KAAKV,CAAG,EAC3C,IAAK,QAAS,OAAOW,EAAc,KAAKX,CAAG,EAC3C,IAAK,WACL,IAAK,UACD,OAAOY,GAAiB,KAAKZ,CAAG,EACpC,IAAK,WAAY,OAAOa,EAAiB,KAAKb,CAAG,EACjD,IAAK,SAAU,OAAOc,GAAe,KAAKd,CAAG,CAChD,SAEI,OAAQA,GAAS,SAAU,CAEhC,OAAQA,EAAI,KAAI,CACZ,IAAK,cAAe,OAAOS,GAAoB,KAAKT,CAAG,EACvD,IAAK,QAAS,OAAOU,EAAc,KAAKV,CAAG,EAC3C,IAAK,QAAS,OAAOW,EAAc,KAAKX,CAAG,EAC3C,IAAK,WACL,IAAK,UACD,OAAOY,GAAiB,KAAKZ,CAAG,EACpC,IAAK,WAAY,OAAOa,EAAiB,KAAKb,CAAG,EACjD,IAAK,SAAU,OAAOc,GAAe,KAAKd,CAAG,CAChD,CACD7V,EAAO,GAAO,qBAAqB6V,EAAI,IAAI,GAAI,wBAAyB,CACpE,UAAW,eAC3B,CAAa,CACJ,CACDlZ,EAAe,GAAO,8BAA+B,MAAOkZ,CAAG,CAClE,CAID,OAAO,cAAc/V,EAAO,CACxB,OAAOwW,GAAoB,WAAWxW,CAAK,CAC9C,CAID,OAAO,QAAQA,EAAO,CAClB,OAAOyW,EAAc,WAAWzW,CAAK,CACxC,CAID,OAAO,QAAQA,EAAO,CAClB,OAAO0W,EAAc,WAAW1W,CAAK,CACxC,CAID,OAAO,WAAWA,EAAO,CACrB,OAAO4W,EAAiB,WAAW5W,CAAK,CAC3C,CAID,OAAO,SAASA,EAAO,CACnB,OAAO6W,GAAe,WAAW7W,CAAK,CACzC,CACL,CAKO,MAAM8W,WAAsBR,EAAS,CAQxC,YAAYnX,EAAOmC,EAAMxC,EAAMyX,EAAQ,CACnC,MAAMpX,EAAOmC,EAAMiV,CAAM,EAL7Bta,EAAA,aAMIY,EAAe,OAAQiC,GAAU,UAAYA,EAAK,MAAMyT,EAAO,EAAG,qBAAsB,OAAQzT,CAAI,EACpGyX,EAAS,OAAO,OAAOA,EAAO,MAAO,CAAA,EACrCla,EAAiB,KAAM,CAAE,KAAAyC,CAAI,CAAE,CAClC,CACL,CACA,SAASiY,GAAWtB,EAAQuB,EAAQ,CAChC,MAAO,IAAMA,EAAO,IAAKC,GAAMA,EAAE,OAAOxB,CAAM,CAAC,EAAE,KAAMA,IAAW,OAAU,KAAO,GAAG,EAAI,GAC9F,CAIO,MAAMgB,UAAsBK,EAAc,CAI7C,YAAY3X,EAAOL,EAAMyX,EAAQ,CAC7B,MAAMpX,EAAO,QAASL,EAAMyX,CAAM,EAClC,OAAO,eAAe,KAAM7B,EAAU,CAAE,MAAOE,EAAqB,CAAE,CACzE,CAID,IAAI,UAAW,CACX,OAAO9D,GAAG,KAAK,OAAO,SAAS,CAAC,EAAE,UAAU,EAAG,EAAE,CACpD,CAID,OAAO2E,EAAQ,CAIX,GAHIA,GAAU,OACVA,EAAS,WAETA,IAAW,OACX,OAAO,KAAK,UAAU,CAClB,KAAM,QACN,KAAM,KAAK,KACX,OAAQ,KAAK,OAAO,IAAKyB,GAAU,KAAK,MAAMA,EAAM,OAAOzB,CAAM,CAAC,CAAC,CACnF,CAAa,EAEL,MAAMnY,EAAS,CAAA,EACf,OAAImY,IAAW,WACXnY,EAAO,KAAK,OAAO,EAEvBA,EAAO,KAAK,KAAK,KAAOyZ,GAAWtB,EAAQ,KAAK,MAAM,CAAC,EAChDnY,EAAO,KAAK,GAAG,CACzB,CAID,OAAO,KAAKyY,EAAK,CACb,GAAIU,EAAc,WAAWV,CAAG,EAC5B,OAAOA,EAEX,GAAI,OAAQA,GAAS,SACjB,OAAOU,EAAc,KAAKpD,GAAI0C,CAAG,CAAC,EAEjC,GAAIA,aAAe3C,EAAa,CACjC,MAAMtU,EAAO+U,GAAY,QAASkC,CAAG,EAC/BQ,EAASpC,GAAc4B,CAAG,EAChC,OAAAxB,GAAWwB,CAAG,EACP,IAAIU,EAAc7X,EAAQE,EAAMyX,CAAM,CAChD,CACD,OAAO,IAAIE,EAAc7X,EAAQmX,EAAI,KAAMA,EAAI,OAASA,EAAI,OAAO,IAAI1B,EAAU,IAAI,EAAI,CAAE,CAAA,CAC9F,CAKD,OAAO,WAAWrU,EAAO,CACrB,OAAQA,GAASA,EAAM0U,CAAQ,IAAME,EACxC,CACL,CAIO,MAAM8B,UAAsBI,EAAc,CAQ7C,YAAY3X,EAAOL,EAAMyX,EAAQY,EAAW,CACxC,MAAMhY,EAAO,QAASL,EAAMyX,CAAM,EALtCta,EAAA,kBAMI,OAAO,eAAe,KAAMyY,EAAU,CAAE,MAAOG,EAAqB,CAAE,EACtExY,EAAiB,KAAM,CAAE,UAAA8a,CAAS,CAAE,CACvC,CAID,IAAI,WAAY,CACZ,OAAOrG,GAAG,KAAK,OAAO,SAAS,CAAC,CACnC,CAID,OAAO2E,EAAQ,CAIX,GAHIA,GAAU,OACVA,EAAS,WAETA,IAAW,OACX,OAAO,KAAK,UAAU,CAClB,KAAM,QACN,UAAW,KAAK,UAChB,KAAM,KAAK,KACX,OAAQ,KAAK,OAAO,IAAKlY,GAAM,KAAK,MAAMA,EAAE,OAAOkY,CAAM,CAAC,CAAC,CAC3E,CAAa,EAEL,MAAMnY,EAAS,CAAA,EACf,OAAImY,IAAW,WACXnY,EAAO,KAAK,OAAO,EAEvBA,EAAO,KAAK,KAAK,KAAOyZ,GAAWtB,EAAQ,KAAK,MAAM,CAAC,EACnDA,IAAW,WAAa,KAAK,WAC7BnY,EAAO,KAAK,WAAW,EAEpBA,EAAO,KAAK,GAAG,CACzB,CAID,OAAO,aAAawB,EAAMkY,EAAQ,CAC9B,OAAAA,GAAUA,GAAU,CAAA,GAAI,IAAKC,GAAM5C,EAAU,KAAK4C,CAAC,CAAC,EACnC,IAAIP,EAAc9X,EAAQE,EAAMkY,EAAQ,EAAK,EAC9C,SACnB,CAID,OAAO,KAAKjB,EAAK,CACb,GAAIW,EAAc,WAAWX,CAAG,EAC5B,OAAOA,EAEX,GAAI,OAAQA,GAAS,SACjB,GAAI,CACA,OAAOW,EAAc,KAAKrD,GAAI0C,CAAG,CAAC,CACrC,MACa,CACVlZ,EAAe,GAAO,yBAA0B,MAAOkZ,CAAG,CAC7D,SAEIA,aAAe3C,EAAa,CACjC,MAAMtU,EAAO+U,GAAY,QAASkC,CAAG,EAC/BQ,EAASpC,GAAc4B,EAAK,EAAI,EAChCoB,EAAY,CAAC,CAACpD,GAAgBgC,EAAKzE,EAAO,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,WAAW,EAC/E,OAAAiD,GAAWwB,CAAG,EACP,IAAIW,EAAc9X,EAAQE,EAAMyX,EAAQY,CAAS,CAC3D,CACD,OAAO,IAAIT,EAAc9X,EAAQmX,EAAI,KAAMA,EAAI,OAASA,EAAI,OAAO,IAAKkB,GAAM5C,EAAU,KAAK4C,EAAG,EAAI,CAAC,EAAI,CAAA,EAAI,CAAC,CAAClB,EAAI,SAAS,CAC/H,CAKD,OAAO,WAAW/V,EAAO,CACrB,OAAQA,GAASA,EAAM0U,CAAQ,IAAMG,EACxC,CACL,CAIO,MAAM2B,WAA4BF,EAAS,CAY9C,YAAYnX,EAAOmC,EAAMiV,EAAQa,EAASC,EAAK,CAC3C,MAAMlY,EAAOmC,EAAMiV,CAAM,EAT7Bta,EAAA,gBAIAA,EAAA,YAMI,OAAO,eAAe,KAAMyY,EAAU,CAAE,MAAOI,EAA2B,CAAE,EAC5EzY,EAAiB,KAAM,CAAE,QAAA+a,EAAS,IAAAC,CAAK,CAAA,CAC1C,CAID,OAAO5B,EAAQ,CAEX,GADAvV,EAAOuV,GAAU,MAAQA,IAAW,UAAW,0CAA2C,wBAAyB,CAAE,UAAW,iBAAiB,CAAE,EAC/IA,IAAW,OACX,OAAO,KAAK,UAAU,CAClB,KAAM,cACN,gBAAkB,KAAK,QAAU,UAAY,YAC7C,QAAS,KAAK,QACd,IAAO,KAAK,KAAO,KAAQ,KAAK,IAAM,OACtC,OAAQ,KAAK,OAAO,IAAKlY,GAAM,KAAK,MAAMA,EAAE,OAAOkY,CAAM,CAAC,CAAC,CAC3E,CAAa,EAEL,MAAMnY,EAAS,CAAC,cAAcyZ,GAAWtB,EAAQ,KAAK,MAAM,CAAC,EAAE,EAC/D,OAAI,KAAK,SACLnY,EAAO,KAAK,SAAS,EAErB,KAAK,KAAO,MACZA,EAAO,KAAK,IAAI,KAAK,IAAI,SAAQ,CAAE,EAAE,EAElCA,EAAO,KAAK,GAAG,CACzB,CAID,OAAO,KAAKyY,EAAK,CACb,GAAIS,GAAoB,WAAWT,CAAG,EAClC,OAAOA,EAEX,GAAI,OAAQA,GAAS,SACjB,GAAI,CACA,OAAOS,GAAoB,KAAKnD,GAAI0C,CAAG,CAAC,CAC3C,MACa,CACVlZ,EAAe,GAAO,8BAA+B,MAAOkZ,CAAG,CAClE,SAEIA,aAAe3C,EAAa,CACjCW,GAAgBgC,EAAKzE,EAAO,CAAC,aAAa,CAAC,CAAC,EAC5C,MAAMiF,EAASpC,GAAc4B,CAAG,EAC1BqB,EAAU,CAAC,CAACrD,GAAgBgC,EAAKtE,EAAa,EAAE,IAAI,SAAS,EAC7D4F,EAAM/C,GAAWyB,CAAG,EAC1B,OAAAxB,GAAWwB,CAAG,EACP,IAAIS,GAAoB5X,EAAQ,cAAe2X,EAAQa,EAASC,CAAG,CAC7E,CACD,OAAO,IAAIb,GAAoB5X,EAAQ,cAAemX,EAAI,OAASA,EAAI,OAAO,IAAI1B,EAAU,IAAI,EAAI,CAAE,EAAE,CAAC,CAAC0B,EAAI,QAAUA,EAAI,KAAO,KAAQA,EAAI,IAAM,IAAI,CAC5J,CAKD,OAAO,WAAW/V,EAAO,CACrB,OAAQA,GAASA,EAAM0U,CAAQ,IAAMI,EACxC,CACL,CAIO,MAAM6B,WAAyBL,EAAS,CAK3C,YAAYnX,EAAOoX,EAAQa,EAAS,CAChC,MAAMjY,EAAO,WAAYoX,CAAM,EAFnCta,EAAA,gBAGI,OAAO,eAAe,KAAMyY,EAAU,CAAE,MAAOK,EAAwB,CAAE,EACzE1Y,EAAiB,KAAM,CAAE,QAAA+a,CAAO,CAAE,CACrC,CAID,OAAO3B,EAAQ,CACX,MAAMnU,EAAS,KAAK,OAAO,SAAW,EAAK,UAAY,WACvD,GAAImU,IAAW,OAAQ,CACnB,MAAM6B,EAAmB,KAAK,QAAU,UAAY,aACpD,OAAO,KAAK,UAAU,CAAE,KAAAhW,EAAM,gBAAAgW,CAAiB,CAAA,CAClD,CACD,MAAO,GAAGhW,CAAI,KAAK,KAAK,QAAU,WAAa,EAAE,EACpD,CAID,OAAO,KAAKyU,EAAK,CACb,GAAIY,GAAiB,WAAWZ,CAAG,EAC/B,OAAOA,EAEX,GAAI,OAAQA,GAAS,SACjB,GAAI,CACA,OAAOY,GAAiB,KAAKtD,GAAI0C,CAAG,CAAC,CACxC,MACa,CACVlZ,EAAe,GAAO,4BAA6B,MAAOkZ,CAAG,CAChE,SAEIA,aAAe3C,EAAa,CACjC,MAAMmE,EAAWxB,EAAI,WACfyB,EAAazB,EAAI,YAAYzE,EAAO,CAAC,WAAY,SAAS,CAAC,CAAC,EAIlE,GAHAzU,EAAe2a,EAAY,mCAAoC,MAAOD,CAAQ,EACjExB,EAAI,WAAWzE,EAAO,CAAC,WAAY,SAAS,CAAC,CAAC,IAE9C,UAAW,CACpB,MAAMiF,EAASpC,GAAc4B,CAAG,EAChC,OAAAlZ,EAAe0Z,EAAO,SAAW,EAAG,gCAAiC,aAAcA,CAAM,EACzFxC,GAAgBgC,EAAKzE,EAAO,CAAC,SAAS,CAAC,CAAC,EACxCiD,GAAWwB,CAAG,EACP,IAAIY,GAAiB/X,EAAQ,CAAE,EAAE,EAAI,CAC/C,CAGD,IAAI2X,EAASpC,GAAc4B,CAAG,EAC1BQ,EAAO,OACP1Z,EAAe0Z,EAAO,SAAW,GAAKA,EAAO,CAAC,EAAE,OAAS,QAAS,0BAA2B,aAAcA,EAAO,IAAKhZ,GAAMA,EAAE,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC,EAG5JgZ,EAAS,CAAClC,EAAU,KAAK,OAAO,CAAC,EAErC,MAAMoD,EAAaxD,GAAkB8B,CAAG,EAExC,GADAlZ,EAAe4a,IAAe,cAAgBA,IAAe,UAAW,+BAAgC,sBAAuBA,CAAU,EACrI1D,GAAgBgC,EAAKzE,EAAO,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,SAAS,EAAG,CAC1D,MAAMoG,EAAUvD,GAAc4B,CAAG,EACjClZ,EAAe6a,EAAQ,SAAW,GAAKA,EAAQ,CAAC,EAAE,OAAS,QAAS,2BAA4B,cAAeA,EAAQ,IAAKna,GAAMA,EAAE,OAAO,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC,CACpK,CACD,OAAAgX,GAAWwB,CAAG,EACP,IAAIY,GAAiB/X,EAAQ2X,EAAQkB,IAAe,SAAS,CACvE,CACD,GAAI1B,EAAI,OAAS,UACb,OAAO,IAAIY,GAAiB/X,EAAQ,CAAE,EAAE,EAAI,EAEhD,GAAImX,EAAI,OAAS,WAAY,CACzB,MAAMQ,EAAS,CAAClC,EAAU,KAAK,OAAO,CAAC,EACjC+C,EAAWrB,EAAI,kBAAoB,UACzC,OAAO,IAAIY,GAAiB/X,EAAQ2X,EAAQa,CAAO,CACtD,CACDva,EAAe,GAAO,+BAAgC,MAAOkZ,CAAG,CACnE,CAKD,OAAO,WAAW/V,EAAO,CACrB,OAAQA,GAASA,EAAM0U,CAAQ,IAAMK,EACxC,CACL,CAIO,MAAM6B,UAAyBE,EAAc,CAyBhD,YAAY3X,EAAOL,EAAMwY,EAAiBf,EAAQmB,EAASL,EAAK,CAC5D,MAAMlY,EAAO,WAAYL,EAAMyX,CAAM,EAtBzCta,EAAA,iBAIAA,EAAA,gBAKAA,EAAA,wBAIAA,EAAA,gBAIAA,EAAA,YAMI,OAAO,eAAe,KAAMyY,EAAU,CAAE,MAAOM,EAAwB,CAAE,EACzE0C,EAAU,OAAO,OAAOA,EAAQ,MAAO,CAAA,EAGvCrb,EAAiB,KAAM,CAAE,SAFPib,IAAoB,QAAUA,IAAoB,OAEjC,IAAAD,EAAK,QAAAK,EAAS,QADhCJ,IAAoB,UACqB,gBAAAA,CAAe,CAAE,CAC9E,CAID,IAAI,UAAW,CACX,OAAOxG,GAAG,KAAK,OAAO,SAAS,CAAC,EAAE,UAAU,EAAG,EAAE,CACpD,CAID,OAAO2E,EAAQ,CAIX,GAHIA,GAAU,OACVA,EAAS,WAETA,IAAW,OACX,OAAO,KAAK,UAAU,CAClB,KAAM,WACN,KAAM,KAAK,KACX,SAAU,KAAK,SACf,gBAAmB,KAAK,kBAAoB,aAAgB,KAAK,gBAAkB,OACnF,QAAS,KAAK,QACd,IAAO,KAAK,KAAO,KAAQ,KAAK,IAAM,OACtC,OAAQ,KAAK,OAAO,IAAKlY,GAAM,KAAK,MAAMA,EAAE,OAAOkY,CAAM,CAAC,CAAC,EAC3D,QAAS,KAAK,QAAQ,IAAK1Y,GAAM,KAAK,MAAMA,EAAE,OAAO0Y,CAAM,CAAC,CAAC,CAC7E,CAAa,EAEL,MAAMnY,EAAS,CAAA,EACf,OAAImY,IAAW,WACXnY,EAAO,KAAK,UAAU,EAE1BA,EAAO,KAAK,KAAK,KAAOyZ,GAAWtB,EAAQ,KAAK,MAAM,CAAC,EACnDA,IAAW,YACP,KAAK,kBAAoB,cACzBnY,EAAO,KAAK,KAAK,eAAe,EAEhC,KAAK,SAAW,KAAK,QAAQ,SAC7BA,EAAO,KAAK,SAAS,EACrBA,EAAO,KAAKyZ,GAAWtB,EAAQ,KAAK,OAAO,CAAC,GAE5C,KAAK,KAAO,MACZnY,EAAO,KAAK,IAAI,KAAK,IAAI,SAAQ,CAAE,EAAE,GAGtCA,EAAO,KAAK,GAAG,CACzB,CAID,OAAO,YAAYwB,EAAMkY,EAAQ,CAC7B,OAAAA,GAAUA,GAAU,CAAA,GAAI,IAAKC,GAAM5C,EAAU,KAAK4C,CAAC,CAAC,EACnC,IAAIL,EAAiBhY,EAAQE,EAAM,OAAQkY,EAAQ,GAAI,IAAI,EAC5D,QACnB,CAID,OAAO,KAAKjB,EAAK,CACb,GAAIa,EAAiB,WAAWb,CAAG,EAC/B,OAAOA,EAEX,GAAI,OAAQA,GAAS,SACjB,GAAI,CACA,OAAOa,EAAiB,KAAKvD,GAAI0C,CAAG,CAAC,CACxC,MACa,CACVlZ,EAAe,GAAO,4BAA6B,MAAOkZ,CAAG,CAChE,SAEIA,aAAe3C,EAAa,CACjC,MAAMtU,EAAO+U,GAAY,WAAYkC,CAAG,EAClCQ,EAASpC,GAAc4B,CAAG,EAC1B0B,EAAaxD,GAAkB8B,CAAG,EACxC,IAAI2B,EAAU,CAAA,EACV3D,GAAgBgC,EAAKzE,EAAO,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,SAAS,IACvDoG,EAAUvD,GAAc4B,CAAG,GAE/B,MAAMsB,EAAM/C,GAAWyB,CAAG,EAC1B,OAAAxB,GAAWwB,CAAG,EACP,IAAIa,EAAiBhY,EAAQE,EAAM2Y,EAAYlB,EAAQmB,EAASL,CAAG,CAC7E,CACD,IAAIC,EAAkBvB,EAAI,gBAE1B,OAAIuB,GAAmB,OACnBA,EAAkB,UACd,OAAQvB,EAAI,UAAc,WAC1BuB,EAAkB,OACbvB,EAAI,WACLuB,EAAkB,UACd,OAAQvB,EAAI,SAAa,WAAa,CAACA,EAAI,UAC3CuB,EAAkB,gBAIrB,OAAQvB,EAAI,SAAa,WAAa,CAACA,EAAI,UAChDuB,EAAkB,eAKnB,IAAIV,EAAiBhY,EAAQmX,EAAI,KAAMuB,EAAiBvB,EAAI,OAASA,EAAI,OAAO,IAAI1B,EAAU,IAAI,EAAI,CAAE,EAAE0B,EAAI,QAAUA,EAAI,QAAQ,IAAI1B,EAAU,IAAI,EAAI,CAAA,EAAK0B,EAAI,KAAO,KAAQA,EAAI,IAAM,IAAI,CAC1M,CAKD,OAAO,WAAW/V,EAAO,CACrB,OAAQA,GAASA,EAAM0U,CAAQ,IAAMM,EACxC,CACL,CAIO,MAAM6B,WAAuBC,EAAc,CAI9C,YAAY3X,EAAOL,EAAMyX,EAAQ,CAC7B,MAAMpX,EAAO,SAAUL,EAAMyX,CAAM,EACnC,OAAO,eAAe,KAAM7B,EAAU,CAAE,MAAOO,EAAsB,CAAE,CAC1E,CAID,QAAS,CACL,MAAM,IAAI,MAAM,OAAO,CAC1B,CAID,OAAO,KAAKc,EAAK,CACb,GAAI,OAAQA,GAAS,SACjB,GAAI,CACA,OAAOc,GAAe,KAAKxD,GAAI0C,CAAG,CAAC,CACtC,MACa,CACVlZ,EAAe,GAAO,0BAA2B,MAAOkZ,CAAG,CAC9D,SAEIA,aAAe3C,EAAa,CACjC,MAAMtU,EAAO+U,GAAY,SAAUkC,CAAG,EAChCQ,EAASpC,GAAc4B,CAAG,EAChC,OAAAxB,GAAWwB,CAAG,EACP,IAAIc,GAAejY,EAAQE,EAAMyX,CAAM,CACjD,CACD,OAAO,IAAIM,GAAejY,EAAQmX,EAAI,KAAMA,EAAI,OAASA,EAAI,OAAO,IAAI1B,EAAU,IAAI,EAAI,CAAE,CAAA,CAC/F,CAMD,OAAO,WAAWrU,EAAO,CACrB,OAAQA,GAASA,EAAM0U,CAAQ,IAAMO,EACxC,CACL,CCzwCA,MAAM0C,EAAe,IAAI,IACzBA,EAAa,IAAI,EAAM,eAAe,EACtCA,EAAa,IAAI,EAAM,cAAc,EACrCA,EAAa,IAAI,GAAM,UAAU,EACjCA,EAAa,IAAI,GAAM,gBAAgB,EACvCA,EAAa,IAAI,GAAM,kBAAkB,EACzCA,EAAa,IAAI,GAAM,kBAAkB,EACzCA,EAAa,IAAI,GAAM,iBAAiB,EACxCA,EAAa,IAAI,GAAM,mBAAmB,EAC1CA,EAAa,IAAI,GAAM,eAAe,EACtCA,EAAa,IAAI,GAAM,6BAA6B,EACpD,MAAMC,GAAiB,IAAI,OAAO,iBAAiB,EAC7CC,GAAkB,IAAI,OAAO,mBAAmB,EACtD,IAAIC,GAAe,KACfC,GAAsB,KAC1B,SAASC,GAAwBC,EAAQC,EAAIhW,EAAMiW,EAAU,CACzD,IAAI1W,EAAU,sBACVjF,EAAS,KACb,MAAM4b,EAAa,KACnB,IAAIC,EAAS,KACb,GAAInW,EAAM,CACNT,EAAU,qBACV,MAAM/E,EAAQW,GAAS6E,CAAI,EAE3B,GADAA,EAAOU,EAAQV,CAAI,EACfxF,EAAM,SAAW,EACjB+E,GAAW,oDACXjF,EAAS,yBAEJE,EAAM,OAAS,KAAO,EAC3B+E,GAAW,0DAENmB,EAAQlG,EAAM,MAAM,EAAG,CAAC,CAAC,IAAM,aAEpC,GAAI,CACAF,EAAS2b,EAAS,OAAO,CAAC,QAAQ,EAAGzb,EAAM,MAAM,CAAC,CAAC,EAAE,CAAC,EACtD2b,EAAS,CACL,UAAW,gBACX,KAAM,QACN,KAAM,CAAC7b,CAAM,CACjC,EACgBiF,GAAW,KAAK,KAAK,UAAUjF,CAAM,CAAC,EACzC,MACa,CACViF,GAAW,iDACd,SAEImB,EAAQlG,EAAM,MAAM,EAAG,CAAC,CAAC,IAAM,aAEpC,GAAI,CACA,MAAM4b,EAAO,OAAOH,EAAS,OAAO,CAAC,SAAS,EAAGzb,EAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EACnE2b,EAAS,CACL,UAAW,iBACX,KAAM,QACN,KAAM,CAACC,CAAI,CAC/B,EACgB9b,EAAS,gBAAgBmb,EAAa,IAAIW,CAAI,GAAK,SAAS,IAAIA,CAAI,IACpE7W,GAAW,KAAKjF,CAAM,EACzB,MACa,CACViF,GAAW,gCACd,MAGDA,GAAW,yBAElB,CACD,MAAM8W,EAAc,CAChB,GAAKL,EAAG,GAAKnL,GAAWmL,EAAG,EAAE,EAAI,KACjC,KAAOA,EAAG,MAAQ,IAC1B,EACI,OAAIA,EAAG,OACHK,EAAY,KAAOxL,GAAWmL,EAAG,IAAI,GAElCM,GAAU/W,EAAS,iBAAkB,CACxC,OAAAwW,EAAQ,KAAA/V,EAAM,OAAA1F,EAAQ,YAAA+b,EAAa,WAAAH,EAAY,OAAAC,CACvD,CAAK,CACL,WAKO,MAAMI,GAAN,MAAMA,EAAS,CAAf,cACHvc,EAAA,KAAAwc,IAyCA,gBAAgB9H,EAAO,CACnB,MAAMlC,EAASkC,EAAM,IAAKtP,GAASS,EAAA,KAAK2W,GAAAC,IAAL,UAAetE,EAAU,KAAK/S,CAAI,EAAE,EAEvE,OADc,IAAIqP,GAAWjC,EAAQ,GAAG,EAC3B,cAChB,CAMD,OAAOkC,EAAOjC,EAAQ,CAClBe,GAAoBf,EAAO,OAAQiC,EAAM,OAAQ,8BAA8B,EAC/E,MAAMlC,EAASkC,EAAM,IAAKtP,GAASS,EAAA,KAAK2W,GAAAC,IAAL,UAAetE,EAAU,KAAK/S,CAAI,EAAE,EACjEkN,EAAS,IAAImC,GAAWjC,EAAQ,GAAG,EACnC5M,EAAS,IAAIJ,GACnB,OAAA8M,EAAM,OAAO1M,EAAQ6M,CAAM,EACpB7M,EAAO,IACjB,CAQD,OAAO8O,EAAO1O,EAAMa,EAAO,CACvB,MAAM2L,EAASkC,EAAM,IAAKtP,GAASS,EAAA,KAAK2W,GAAAC,IAAL,UAAetE,EAAU,KAAK/S,CAAI,EAAE,EAEvE,OADc,IAAIqP,GAAWjC,EAAQ,GAAG,EAC3B,OAAO,IAAInL,GAAOrB,EAAMa,EAAOgV,EAAmB,CAAC,CACnE,CACD,OAAO,wBAAwB/X,EAAO,CAClCnD,EAAe,OAAQmD,GAAW,UAAY,OAAO,UAAUA,CAAK,EAAG,qCAAsC,QAASA,CAAK,EAC3H+X,GAAsB/X,CACzB,CAMD,OAAO,iBAAkB,CACrB,OAAI8X,IAAgB,OAChBA,GAAe,IAAIW,IAEhBX,EACV,CAMD,OAAO,wBAAwBG,EAAQC,EAAIhW,EAAM,CAC7C,OAAO8V,GAAwBC,EAAQC,EAAIhW,EAAMuW,GAAS,gBAAe,CAAE,CAC9E,CACL,EA9FIC,GAAA,YAAAC,GAAS,SAACtC,EAAO,CACb,GAAIA,EAAM,UACN,OAAO,IAAI7G,GAAWzN,EAAA,KAAK2W,GAAAC,IAAL,UAAetC,EAAM,eAAgBA,EAAM,YAAaA,EAAM,IAAI,EAE5F,GAAIA,EAAM,UACN,OAAO,IAAI1F,GAAW0F,EAAM,WAAW,IAAK7Y,GAAMuE,EAAA,KAAK2W,GAAAC,IAAL,UAAenb,EAAE,EAAG6Y,EAAM,IAAI,EAEpF,OAAQA,EAAM,SAAQ,CAClB,IAAK,UACD,OAAO,IAAIjI,GAAaiI,EAAM,IAAI,EACtC,IAAK,OACD,OAAO,IAAI1G,GAAa0G,EAAM,IAAI,EACtC,IAAK,SACD,OAAO,IAAI3F,GAAY2F,EAAM,IAAI,EACrC,IAAK,QACD,OAAO,IAAIxG,GAAWwG,EAAM,IAAI,EACpC,IAAK,GACD,OAAO,IAAIrG,GAAUqG,EAAM,IAAI,CACtC,CAED,IAAI3C,EAAQ2C,EAAM,KAAK,MAAMwB,EAAe,EAC5C,GAAInE,EAAO,CACP,IAAI9F,EAAO,SAAS8F,EAAM,CAAC,GAAK,KAAK,EACrC,OAAA7W,EAAe+Q,IAAS,GAAKA,GAAQ,KAAQA,EAAO,IAAO,EAAG,WAAa8F,EAAM,CAAC,EAAI,cAAe,QAAS2C,CAAK,EAC5G,IAAIlG,GAAYvC,EAAO,EAAI8F,EAAM,CAAC,IAAM,MAAQ2C,EAAM,IAAI,CACpE,CAGD,GADA3C,EAAQ2C,EAAM,KAAK,MAAMuB,EAAc,EACnClE,EAAO,CACP,IAAI9F,EAAO,SAAS8F,EAAM,CAAC,CAAC,EAC5B,OAAA7W,EAAe+Q,IAAS,GAAKA,GAAQ,GAAI,uBAAwB,QAASyI,CAAK,EACxE,IAAIvG,GAAgBlC,EAAMyI,EAAM,IAAI,CAC9C,CACDxZ,EAAe,GAAO,eAAgB,OAAQwZ,EAAM,IAAI,CAC3D,EAnCE,IAAMuC,GAANH,GCtFA,MAAMI,EAAe,CAwBxB,YAAYC,EAAUC,EAAO7Z,EAAM,CApBnCjD,EAAA,iBAIAA,EAAA,aAIAA,EAAA,kBAIAA,EAAA,cAIAA,EAAA,aAKI,MAAM6C,EAAOga,EAAS,KAAME,EAAYF,EAAS,SACjDzc,EAAiB,KAAM,CACnB,SAAAyc,EAAU,KAAAha,EAAM,UAAAka,EAAW,MAAAD,EAAO,KAAA7Z,CAC9C,CAAS,CACJ,CACL,CAMO,MAAM+Z,EAAuB,CA4BhC,YAAYH,EAAUI,EAAUha,EAAMc,EAAO,CAxB7C/D,EAAA,iBAIAA,EAAA,aAIAA,EAAA,aAIAA,EAAA,kBAIAA,EAAA,iBAIAA,EAAA,cAKI,MAAM6C,EAAOga,EAAS,KAAME,EAAYF,EAAS,SACjDzc,EAAiB,KAAM,CACnB,SAAAyc,EAAU,KAAAha,EAAM,KAAAI,EAAM,UAAA8Z,EAAW,SAAAE,EAAU,MAAAlZ,CACvD,CAAS,CACJ,CACL,CAKO,MAAMmZ,EAAiB,CAwB1B,YAAYL,EAAUI,EAAUha,EAAM,CApBtCjD,EAAA,iBAIAA,EAAA,aAIAA,EAAA,aAIAA,EAAA,kBAIAA,EAAA,iBAKI,MAAM6C,EAAOga,EAAS,KAAME,EAAYF,EAAS,SACjDzc,EAAiB,KAAM,CACnB,SAAAyc,EAAU,KAAAha,EAAM,KAAAI,EAAM,UAAA8Z,EAAW,SAAAE,CAC7C,CAAS,CACJ,CACL,CAOO,MAAME,EAAQ,CAoBjB,YAAYxV,EAAM,CAhBlB3H,EAAA,aAIAA,EAAA,mBAaII,EAAiB,KAAM,CAAE,KAAAuH,EAAM,WAAY,EAAM,CAAA,CACpD,CARD,OAAO,UAAU5D,EAAO,CACpB,MAAO,CAAC,EAAEA,GAASA,EAAM,WAC5B,CAOL,CAEA,MAAM2X,GAAe,CACjB,EAAK,gBACL,EAAK,gBACL,GAAM,sBACN,GAAM,6BACN,GAAM,gBACN,GAAM,8CACN,GAAM,wDACN,GAAM,6CACN,GAAM,gBACN,GAAM,wBACV,EACM0B,GAAgB,CAClB,aAAc,CACV,UAAW,gBACX,KAAM,QACN,OAAQ,CAAC,QAAQ,EACjB,OAAS5X,GACE,+BAA+B,KAAK,UAAUA,CAAO,CAAC,EAEpE,EACD,aAAc,CACV,UAAW,iBACX,KAAM,QACN,OAAQ,CAAC,SAAS,EAClB,OAAS6W,GAAS,CACd,IAAI9b,EAAS,qBACb,OAAI8b,GAAQ,GAAKA,GAAQ,KAAQX,GAAaW,EAAK,SAAQ,CAAE,IACzD9b,EAASmb,GAAaW,EAAK,SAAU,CAAA,GAElC,8BAA8BA,EAAK,SAAS,EAAE,CAAC,KAAK9b,CAAM,GACpE,CACJ,CACL,0BAWO,MAAM8c,GAAN,MAAMA,EAAU,CAyBnB,YAAYC,EAAW,CA0GvBrd,EAAA,KAAAsd,IA+HAtd,EAAA,KAAAud,IA9PAxd,EAAA,kBAIAA,EAAA,eAIAA,EAAA,iBAIAA,EAAA,gBACAC,EAAA,KAAAwd,EAAA,QACAxd,EAAA,KAAAyd,EAAA,QACAzd,EAAA,KAAA0d,EAAA,QAEA1d,EAAA,KAAA2d,EAAA,QAKI,IAAIC,EAAM,CAAA,EACN,OAAQP,GAAe,SACvBO,EAAM,KAAK,MAAMP,CAAS,EAG1BO,EAAMP,EAEVnd,EAAA,KAAKwd,EAAa,IAAI,KACtBxd,EAAA,KAAKsd,EAAU,IAAI,KACnBtd,EAAA,KAAKud,EAAU,IAAI,KAEnB,MAAMI,EAAQ,CAAA,EACd,UAAW,KAAKD,EACZ,GAAI,CACAC,EAAM,KAAKzD,GAAS,KAAK,CAAC,CAAC,CAC9B,OACMvX,EAAO,CACV,QAAQ,IAAI,8BAA8B,KAAK,UAAU,CAAC,CAAC,IAAKA,EAAM,OAAO,CAChF,CAEL1C,EAAiB,KAAM,CACnB,UAAW,OAAO,OAAO0d,CAAK,CAC1C,CAAS,EACD,IAAIC,EAAW,KACXC,EAAU,GACd7d,EAAA,KAAKyd,EAAY,KAAK,eAEtB,KAAK,UAAU,QAAQ,CAACf,EAAUrZ,IAAU,CACxC,IAAIya,EACJ,OAAQpB,EAAS,KAAI,CACjB,IAAK,cACD,GAAI,KAAK,OAAQ,CACb,QAAQ,IAAI,oCAAoC,EAChD,MACH,CAEDzc,EAAiB,KAAM,CAAE,OAAQyc,CAAU,CAAA,EAC3C,OACJ,IAAK,WACGA,EAAS,OAAO,SAAW,EAC3BmB,EAAU,IAGVpd,EAAe,CAACmd,GAAYlB,EAAS,UAAYkB,EAAS,QAAS,iCAAkC,aAAava,CAAK,IAAKqZ,CAAQ,EACpIkB,EAAWlB,EACXmB,EAAUD,EAAS,SAEvB,OACJ,IAAK,WAGDE,EAAS5d,EAAA,KAAKsd,GACd,MACJ,IAAK,QAEDM,EAAS5d,EAAA,KAAKqd,GACd,MACJ,IAAK,QACDO,EAAS5d,EAAA,KAAKod,GACd,MACJ,QACI,MACP,CAED,MAAMV,EAAYF,EAAS,SACvBoB,EAAO,IAAIlB,CAAS,GAGxBkB,EAAO,IAAIlB,EAAWF,CAAQ,CAC1C,CAAS,EAEI,KAAK,QACNzc,EAAiB,KAAM,CACnB,OAAQma,GAAoB,KAAK,eAAe,CAChE,CAAa,EAELna,EAAiB,KAAM,CAAE,SAAA2d,EAAU,QAAAC,CAAS,CAAA,CAC/C,CAMD,OAAOE,EAAS,CACZ,MAAM1E,EAAU0E,EAAU,UAAY,OAEtC,OADY,KAAK,UAAU,IAAKC,GAAMA,EAAE,OAAO3E,CAAM,CAAC,CAEzD,CAKD,YAAa,CACT,MAAMqE,EAAM,KAAK,UAAU,IAAKM,GAAMA,EAAE,OAAO,MAAM,CAAC,EAEtD,OAAO,KAAK,UAAUN,EAAI,IAAKlc,GAAM,KAAK,MAAMA,CAAC,CAAC,CAAC,CACtD,CAKD,aAAc,CACV,OAAOgb,GAAS,iBACnB,CAyFD,gBAAgB7X,EAAK,CACjB,MAAM+X,EAAW/W,EAAA,KAAKyX,GAAAa,IAAL,UAAkBtZ,EAAK,KAAM,IAC9C,OAAAlE,EAAeic,EAAU,uBAAwB,MAAO/X,CAAG,EACpD+X,EAAS,IACnB,CAQD,YAAY/X,EAAK,CACb,MAAO,CAAC,CAACgB,EAAA,KAAKyX,GAAAa,IAAL,UAAkBtZ,EAAK,KAAM,GACzC,CAWD,YAAYA,EAAK4N,EAAQ,CACrB,OAAO5M,EAAA,KAAKyX,GAAAa,IAAL,UAAkBtZ,EAAK4N,GAAU,KAAM,GACjD,CAID,gBAAgBrO,EAAU,CACtB,MAAMjB,EAAQ,MAAM,KAAK/C,EAAA,KAAKsd,GAAW,KAAI,CAAE,EAC/Cva,EAAM,KAAK,CAAC+E,EAAGV,IAAMU,EAAE,cAAcV,CAAC,CAAC,EACvC,QAASnG,EAAI,EAAGA,EAAI8B,EAAM,OAAQ9B,IAAK,CACnC,MAAMuB,EAAOO,EAAM9B,CAAC,EACpB+C,EAAUhE,EAAA,KAAKsd,GAAW,IAAI9a,CAAI,EAAIvB,CAAC,CAC1C,CACJ,CAgED,aAAawD,EAAK,CACd,MAAM+X,EAAW/W,EAAA,KAAK0X,GAAAa,IAAL,UAAevZ,EAAK,KAAM,IAC3C,OAAAlE,EAAeic,EAAU,oBAAqB,MAAO/X,CAAG,EACjD+X,EAAS,IACnB,CAQD,SAAS/X,EAAK,CACV,MAAO,CAAC,CAACgB,EAAA,KAAK0X,GAAAa,IAAL,UAAevZ,EAAK,KAAM,GACtC,CAWD,SAASA,EAAK4N,EAAQ,CAClB,OAAO5M,EAAA,KAAK0X,GAAAa,IAAL,UAAevZ,EAAK4N,GAAU,KAAM,GAC9C,CAID,aAAarO,EAAU,CACnB,MAAMjB,EAAQ,MAAM,KAAK/C,EAAA,KAAKqd,GAAQ,KAAI,CAAE,EAC5Cta,EAAM,KAAK,CAAC+E,EAAGV,IAAMU,EAAE,cAAcV,CAAC,CAAC,EACvC,QAASnG,EAAI,EAAGA,EAAI8B,EAAM,OAAQ9B,IAAK,CACnC,MAAMuB,EAAOO,EAAM9B,CAAC,EACpB+C,EAAUhE,EAAA,KAAKqd,GAAQ,IAAI7a,CAAI,EAAIvB,CAAC,CACvC,CACJ,CAWD,SAASwD,EAAK4N,EAAQ,CAClB,GAAIwC,GAAYpQ,CAAG,EAAG,CAClB,MAAMmY,EAAWnY,EAAI,cACrB,GAAIsY,GAAcH,CAAQ,EACtB,OAAOzC,EAAc,KAAK4C,GAAcH,CAAQ,EAAE,SAAS,EAE/D,UAAWJ,KAAYxc,EAAA,KAAKod,GAAQ,OAAM,EACtC,GAAIR,IAAaJ,EAAS,SACtB,OAAOA,EAGf,OAAO,IACV,CAED,GAAI/X,EAAI,QAAQ,GAAG,IAAM,GAAI,CACzB,MAAMwZ,EAAW,CAAA,EACjB,SAAW,CAACzb,EAAMga,CAAQ,IAAKxc,EAAA,KAAKod,GAC5B5a,EAAK,MAAM,GAAgB,EAAC,CAAC,IAAMiC,GACnCwZ,EAAS,KAAKzB,CAAQ,EAG9B,GAAIyB,EAAS,SAAW,EACpB,OAAIxZ,IAAQ,QACD0V,EAAc,KAAK,qBAAqB,EAE/C1V,IAAQ,QACD0V,EAAc,KAAK,sBAAsB,EAE7C,KAEN,GAAI8D,EAAS,OAAS,EAAG,CAC1B,MAAMC,EAAWD,EAAS,IAAKE,GAAM,KAAK,UAAUA,EAAE,OAAQ,CAAA,CAAC,EAAE,KAAK,IAAI,EAC1E5d,EAAe,GAAO,qCAAqC2d,CAAQ,IAAK,OAAQzZ,CAAG,CACtF,CACD,OAAOwZ,EAAS,CAAC,CACpB,CAGD,GADAxZ,EAAM0V,EAAc,KAAK1V,CAAG,EAAE,OAAM,EAChCA,IAAQ,gBACR,OAAO0V,EAAc,KAAK,qBAAqB,EAEnD,GAAI1V,IAAQ,iBACR,OAAO0V,EAAc,KAAK,sBAAsB,EAEpD,MAAMnZ,EAAShB,EAAA,KAAKod,GAAQ,IAAI3Y,CAAG,EACnC,OAAIzD,GAGG,IACV,CAID,aAAagD,EAAU,CACnB,MAAMjB,EAAQ,MAAM,KAAK/C,EAAA,KAAKod,GAAQ,KAAI,CAAE,EAC5Cra,EAAM,KAAK,CAAC+E,EAAGV,IAAMU,EAAE,cAAcV,CAAC,CAAC,EACvC,QAASnG,EAAI,EAAGA,EAAI8B,EAAM,OAAQ9B,IAAK,CACnC,MAAMuB,EAAOO,EAAM9B,CAAC,EACpB+C,EAAUhE,EAAA,KAAKod,GAAQ,IAAI5a,CAAI,EAAIvB,CAAC,CACvC,CACJ,CA6BD,cAAcyZ,EAAQ9U,EAAM,CACxB,OAAO5F,EAAA,KAAKud,GAAU,OAAO7C,EAAQ9U,CAAI,CAC5C,CACD,cAAc8U,EAAQrI,EAAQ,CAC1B,OAAOrS,EAAA,KAAKud,GAAU,OAAO7C,EAAQrI,CAAM,CAC9C,CAKD,aAAaA,EAAQ,CACjB,OAAO,KAAK,cAAc,KAAK,OAAO,OAAQA,GAAU,CAAA,CAAE,CAC7D,CAUD,kBAAkBmK,EAAU5W,EAAM,CAC9B,GAAI,OAAQ4W,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,SAAStB,CAAQ,EAChCjc,EAAeud,EAAG,gBAAiB,WAAYtB,CAAQ,EACvDA,EAAWsB,CACd,CACD,OAAAvd,EAAe6d,GAAUxY,EAAM,EAAG,CAAC,IAAM4W,EAAS,SAAU,uCAAuCA,EAAS,IAAI,IAAK,OAAQ5W,CAAI,EAC1H,KAAK,cAAc4W,EAAS,OAAQ4B,GAAUxY,EAAM,CAAC,CAAC,CAChE,CASD,kBAAkB4W,EAAUnK,EAAQ,CAChC,GAAI,OAAQmK,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,SAAStB,CAAQ,EAChCjc,EAAeud,EAAG,gBAAiB,WAAYtB,CAAQ,EACvDA,EAAWsB,CACd,CACD,OAAOhZ,GAAO,CACV0X,EAAS,SACT,KAAK,cAAcA,EAAS,OAAQnK,GAAU,CAAA,CAAE,CAC5D,CAAS,CACJ,CASD,mBAAmBmK,EAAU5W,EAAM,CAC/B,GAAI,OAAQ4W,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,YAAYtB,CAAQ,EACnCjc,EAAeud,EAAG,mBAAoB,WAAYtB,CAAQ,EAC1DA,EAAWsB,CACd,CACD,OAAAvd,EAAe6d,GAAUxY,EAAM,EAAG,CAAC,IAAM4W,EAAS,SAAU,0CAA0CA,EAAS,IAAI,IAAK,OAAQ5W,CAAI,EAC7H,KAAK,cAAc4W,EAAS,OAAQ4B,GAAUxY,EAAM,CAAC,CAAC,CAChE,CAMD,mBAAmB4W,EAAUnK,EAAQ,CACjC,GAAI,OAAQmK,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,YAAYtB,CAAQ,EACnCjc,EAAeud,EAAG,mBAAoB,WAAYtB,CAAQ,EAC1DA,EAAWsB,CACd,CACD,OAAOhZ,GAAO,CACV0X,EAAS,SACT,KAAK,cAAcA,EAAS,OAAQnK,GAAU,CAAA,CAAE,CAC5D,CAAS,CACJ,CAUD,qBAAqBmK,EAAU5W,EAAM,CACjC,GAAI,OAAQ4W,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,YAAYtB,CAAQ,EACnCjc,EAAeud,EAAG,mBAAoB,WAAYtB,CAAQ,EAC1DA,EAAWsB,CACd,CACD,IAAI3Y,EAAU,iCACd,MAAM/E,EAAQyE,EAAae,CAAI,EAC/B,GAAKxF,EAAM,OAAS,KAAQ,EACxB,GAAI,CACA,OAAOJ,EAAA,KAAKud,GAAU,OAAOf,EAAS,QAASpc,CAAK,CACvD,MACa,CACV+E,EAAU,8BACb,CAGLvB,EAAO,GAAOuB,EAAS,WAAY,CAC/B,MAAOmB,EAAQlG,CAAK,EACpB,KAAM,CAAE,OAAQoc,EAAS,KAAM,UAAWA,EAAS,QAAU,CACzE,CAAS,CACJ,CACD,UAAUlX,EAAOsW,EAAI,CACjB,MAAMhW,EAAO7E,GAASuE,EAAO,MAAM,EAC7B7C,EAAQ6Z,GAAS,wBAAwB,OAAQV,EAAIhW,CAAI,EAG/D,GAAInD,EAAM,QAAQ,WADG,2CACoB,EAAG,CACxC,MAAMma,EAAWtW,EAAQV,EAAK,MAAM,EAAG,CAAC,CAAC,EACnCyY,EAAK,KAAK,SAASzB,CAAQ,EACjC,GAAIyB,EACA,GAAI,CACA,MAAMzb,EAAO5C,EAAA,KAAKud,GAAU,OAAOc,EAAG,OAAQzY,EAAK,MAAM,CAAC,CAAC,EAC3DnD,EAAM,OAAS,CACX,KAAM4b,EAAG,KAAM,UAAWA,EAAG,OAAM,EAAI,KAAAzb,CAC/D,EACoBH,EAAM,OAASA,EAAM,OAAO,UAC5BA,EAAM,QAAU,uBAAuBA,EAAM,MAAM,EACtD,MACS,CACNA,EAAM,QAAU,oDACnB,CAER,CAED,MAAM6b,EAAS,KAAK,iBAAiB1C,CAAE,EACvC,OAAI0C,IACA7b,EAAM,WAAa,CACf,OAAQ6b,EAAO,KACf,UAAWA,EAAO,UAClB,KAAMA,EAAO,IAC7B,GAEe7b,CACV,CASD,qBAAqB+Z,EAAUnK,EAAQ,CACnC,GAAI,OAAQmK,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,YAAYtB,CAAQ,EACnCjc,EAAeud,EAAG,mBAAoB,WAAYtB,CAAQ,EAC1DA,EAAWsB,CACd,CACD,OAAOxX,EAAQtG,EAAA,KAAKud,GAAU,OAAOf,EAAS,QAASnK,GAAU,CAAE,CAAA,CAAC,CACvE,CAgCD,mBAAmBmK,EAAUnK,EAAQ,CACjC,GAAI,OAAQmK,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,SAAStB,CAAQ,EAChCjc,EAAeud,EAAG,gBAAiB,gBAAiBtB,CAAQ,EAC5DA,EAAWsB,CACd,CACDla,EAAOyO,EAAO,QAAUmK,EAAS,OAAO,OAAQ,0BAA0BA,EAAS,OAAQ,CAAA,GAAI,sBAAuB,CAAE,MAAOnK,EAAO,OAAQ,cAAemK,EAAS,OAAO,MAAM,CAAE,EACrL,MAAM+B,EAAS,CAAA,EACV/B,EAAS,WACV+B,EAAO,KAAK/B,EAAS,SAAS,EAGlC,MAAMgC,EAAc,CAACzE,EAAOrW,IACpBqW,EAAM,OAAS,SACRvF,GAAG9Q,CAAK,EAEVqW,EAAM,OAAS,QACbtK,GAAUnJ,EAAQ5C,CAAK,CAAC,GAE/BqW,EAAM,OAAS,QAAU,OAAQrW,GAAW,UAC5CA,EAASA,EAAQ,OAAS,OAErBqW,EAAM,KAAK,MAAM,QAAQ,EAC9BrW,EAAQsO,GAAQtO,CAAK,EAEhBqW,EAAM,KAAK,MAAM,QAAQ,EAC9BrW,EAAQ+a,GAAa/a,EAAO,EAAE,EAEzBqW,EAAM,OAAS,WAEpB/Z,EAAA,KAAKud,GAAU,OAAO,CAAC,SAAS,EAAG,CAAC7Z,CAAK,CAAC,EAEvCgb,GAAapY,EAAQ5C,CAAK,EAAG,EAAE,GAsB1C,IApBA2O,EAAO,QAAQ,CAAC3O,EAAOP,IAAU,CAC7B,MAAM4W,EAAQyC,EAAS,OAAOrZ,CAAK,EACnC,GAAI,CAAC4W,EAAM,QAAS,CAChBxZ,EAAemD,GAAS,KAAM,qDAAuD,YAAcqW,EAAM,KAAOrW,CAAK,EACrH,MACH,CACGA,GAAS,KACT6a,EAAO,KAAK,IAAI,EAEXxE,EAAM,WAAa,SAAWA,EAAM,WAAa,QACtDxZ,EAAe,GAAO,gDAAkD,YAAcwZ,EAAM,KAAOrW,CAAK,EAEnG,MAAM,QAAQA,CAAK,EACxB6a,EAAO,KAAK7a,EAAM,IAAKA,GAAU8a,EAAYzE,EAAOrW,CAAK,CAAC,CAAC,EAG3D6a,EAAO,KAAKC,EAAYzE,EAAOrW,CAAK,CAAC,CAErD,CAAS,EAEM6a,EAAO,QAAUA,EAAOA,EAAO,OAAS,CAAC,IAAM,MAClDA,EAAO,IAAG,EAEd,OAAOA,CACV,CACD,eAAe/B,EAAUnK,EAAQ,CAC7B,GAAI,OAAQmK,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,SAAStB,CAAQ,EAChCjc,EAAeud,EAAG,gBAAiB,gBAAiBtB,CAAQ,EAC5DA,EAAWsB,CACd,CACD,MAAMS,EAAS,CAAA,EACTI,EAAY,CAAA,EACZC,EAAa,CAAA,EACnB,OAAKpC,EAAS,WACV+B,EAAO,KAAK/B,EAAS,SAAS,EAElCjc,EAAe8R,EAAO,SAAWmK,EAAS,OAAO,OAAQ,kCAAmC,SAAUnK,CAAM,EAC5GmK,EAAS,OAAO,QAAQ,CAACzC,EAAO5W,IAAU,CACtC,MAAMO,EAAQ2O,EAAOlP,CAAK,EAC1B,GAAI4W,EAAM,QACN,GAAIA,EAAM,OAAS,SACfwE,EAAO,KAAK/J,GAAG9Q,CAAK,CAAC,UAEhBqW,EAAM,OAAS,QACpBwE,EAAO,KAAK9O,GAAU/L,CAAK,CAAC,MAE3B,IAAIqW,EAAM,WAAa,SAAWA,EAAM,WAAa,QAEtD,MAAM,IAAI,MAAM,iBAAiB,EAGjCwE,EAAO,KAAKve,EAAA,KAAKud,GAAU,OAAO,CAACxD,EAAM,IAAI,EAAG,CAACrW,CAAK,CAAC,CAAC,OAI5Dib,EAAU,KAAK5E,CAAK,EACpB6E,EAAW,KAAKlb,CAAK,CAErC,CAAS,EACM,CACH,KAAM1D,EAAA,KAAKud,GAAU,OAAOoB,EAAWC,CAAU,EACjD,OAAQL,CACpB,CACK,CAED,eAAe/B,EAAU5W,EAAM2Y,EAAQ,CACnC,GAAI,OAAQ/B,GAAc,SAAU,CAChC,MAAMsB,EAAI,KAAK,SAAStB,CAAQ,EAChCjc,EAAeud,EAAG,gBAAiB,gBAAiBtB,CAAQ,EAC5DA,EAAWsB,CACd,CACD,GAAIS,GAAU,MAAQ,CAAC/B,EAAS,UAAW,CACvC,MAAMqC,EAAarC,EAAS,UAC5Bjc,EAAesU,GAAY0J,EAAO,CAAC,EAAG,EAAE,GAAKA,EAAO,CAAC,EAAE,YAAW,IAAOM,EAAY,0BAA2B,YAAaN,EAAO,CAAC,CAAC,EACtIA,EAASA,EAAO,MAAM,CAAC,CAC1B,CACD,MAAMzF,EAAU,CAAA,EACVgG,EAAa,CAAA,EACb5Z,EAAU,CAAA,EAChBsX,EAAS,OAAO,QAAQ,CAACzC,EAAO5W,IAAU,CAClC4W,EAAM,QACFA,EAAM,OAAS,UAAYA,EAAM,OAAS,SAAWA,EAAM,WAAa,SAAWA,EAAM,WAAa,SACtGjB,EAAQ,KAAKf,EAAU,KAAK,CAAE,KAAM,UAAW,KAAMgC,EAAM,IAAI,CAAE,CAAC,EAClE7U,EAAQ,KAAK,EAAI,IAGjB4T,EAAQ,KAAKiB,CAAK,EAClB7U,EAAQ,KAAK,EAAK,IAItB4Z,EAAW,KAAK/E,CAAK,EACrB7U,EAAQ,KAAK,EAAK,EAElC,CAAS,EACD,MAAM6Z,EAAiBR,GAAU,KAAQve,EAAA,KAAKud,GAAU,OAAOzE,EAAShU,GAAOyZ,CAAM,CAAC,EAAI,KACpFS,EAAmBhf,EAAA,KAAKud,GAAU,OAAOuB,EAAYlZ,EAAM,EAAI,EAE/DyM,EAAS,CAAA,EACTnO,EAAO,CAAA,EACb,IAAI+a,EAAkB,EAAGC,EAAe,EACxC,OAAA1C,EAAS,OAAO,QAAQ,CAACzC,EAAO5W,IAAU,CACtC,IAAIO,EAAQ,KACZ,GAAIqW,EAAM,QACN,GAAIgF,GAAiB,KACjBrb,EAAQ,IAAIoZ,GAAQ,IAAI,UAEnB5X,EAAQ/B,CAAK,EAClBO,EAAQ,IAAIoZ,GAAQiC,EAAcG,GAAc,CAAC,MAGjD,IAAI,CACAxb,EAAQqb,EAAcG,GAAc,CACvC,OACMzc,EAAO,CACViB,EAAQjB,CACX,KAIL,IAAI,CACAiB,EAAQsb,EAAiBC,GAAiB,CAC7C,OACMxc,EAAO,CACViB,EAAQjB,CACX,CAEL4P,EAAO,KAAK3O,CAAK,EACjBQ,EAAK,KAAK6V,EAAM,MAAQ,IAAI,CACxC,CAAS,EACM5V,GAAO,UAAUkO,EAAQnO,CAAI,CACvC,CAOD,iBAAiB0X,EAAI,CACjB,MAAMhW,EAAO7E,GAAS6a,EAAG,KAAM,SAAS,EAClClY,EAAQoQ,GAAW8H,EAAG,OAAS,KAAQA,EAAG,MAAQ,EAAG,UAAU,EAC/DY,EAAW,KAAK,YAAYlW,EAAQV,EAAK,MAAM,EAAG,CAAC,CAAC,CAAC,EAC3D,GAAI,CAAC4W,EACD,OAAO,KAEX,MAAM5Z,EAAO5C,EAAA,KAAKud,GAAU,OAAOf,EAAS,OAAQ5W,EAAK,MAAM,CAAC,CAAC,EACjE,OAAO,IAAI+W,GAAuBH,EAAUA,EAAS,SAAU5Z,EAAMc,CAAK,CAC7E,CACD,gBAAgBkC,EAAM,CAClB,MAAM,IAAI,MAAM,OAAO,CAC1B,CAOD,SAASuZ,EAAK,CACV,MAAM3C,EAAW,KAAK,SAAS2C,EAAI,OAAO,CAAC,CAAC,EAC5C,MAAI,CAAC3C,GAAYA,EAAS,UACf,KAKJ,IAAID,GAAeC,EAAUA,EAAS,UAAW,KAAK,eAAeA,EAAU2C,EAAI,KAAMA,EAAI,MAAM,CAAC,CAC9G,CAOD,WAAWvZ,EAAM,CACb,MAAMwZ,EAAU9Y,EAAQV,CAAI,EACtB4W,EAAW,KAAK,SAAS4B,GAAUgB,EAAS,EAAG,CAAC,CAAC,EACvD,GAAI,CAAC5C,EACD,OAAO,KAEX,MAAM5Z,EAAO5C,EAAA,KAAKud,GAAU,OAAOf,EAAS,OAAQ4B,GAAUgB,EAAS,CAAC,CAAC,EACzE,OAAO,IAAIvC,GAAiBL,EAAUA,EAAS,SAAU5Z,CAAI,CAChE,CAOD,OAAO,KAAKc,EAAO,CAEf,OAAIA,aAAiBsZ,GACVtZ,EAGP,OAAQA,GAAW,SACZ,IAAIsZ,GAAU,KAAK,MAAMtZ,CAAK,CAAC,EAGtC,OAAQA,EAAM,QAAY,WACnB,IAAIsZ,GAAUtZ,EAAM,OAAO,MAAM,CAAC,EAGtC,IAAIsZ,GAAUtZ,CAAK,CAC7B,CACL,EA12BI0Z,EAAA,YACAC,EAAA,YACAC,EAAA,YAEAC,EAAA,YA8GAL,GAAA,YAAAa,GAAY,SAACtZ,EAAK4N,EAAQgN,EAAa,CAEnC,GAAIxK,GAAYpQ,CAAG,EAAG,CAClB,MAAMmY,EAAWnY,EAAI,cACrB,UAAW+X,KAAYxc,EAAA,KAAKsd,GAAW,OAAM,EACzC,GAAIV,IAAaJ,EAAS,SACtB,OAAOA,EAGf,OAAO,IACV,CAED,GAAI/X,EAAI,QAAQ,GAAG,IAAM,GAAI,CACzB,MAAMwZ,EAAW,CAAA,EACjB,SAAW,CAACzb,EAAMga,CAAQ,IAAKxc,EAAA,KAAKsd,GAC5B9a,EAAK,MAAM,GAAgB,EAAC,CAAC,IAAMiC,GACnCwZ,EAAS,KAAKzB,CAAQ,EAG9B,GAAInK,EAAQ,CACR,MAAMiN,EAAajN,EAAO,OAAS,EAAKA,EAAOA,EAAO,OAAS,CAAC,EAAI,KACpE,IAAIkN,EAAclN,EAAO,OACrBmN,EAAe,GACfnO,EAAM,QAAQiO,CAAS,GAAKA,EAAU,OAAS,cAC/CE,EAAe,GACfD,KAIJ,QAASte,EAAIgd,EAAS,OAAS,EAAGhd,GAAK,EAAGA,IAAK,CAC3C,MAAMgZ,EAASgE,EAAShd,CAAC,EAAE,OAAO,OAC9BgZ,IAAWsF,IAAgB,CAACC,GAAgBvF,IAAWsF,EAAc,IACrEtB,EAAS,OAAOhd,EAAG,CAAC,CAE3B,CAED,QAASA,EAAIgd,EAAS,OAAS,EAAGhd,GAAK,EAAGA,IAAK,CAC3C,MAAMgZ,EAASgE,EAAShd,CAAC,EAAE,OAC3B,QAASK,EAAI,EAAGA,EAAI+Q,EAAO,OAAQ/Q,IAE/B,GAAK+P,EAAM,QAAQgB,EAAO/Q,CAAC,CAAC,EAI5B,IAAIA,GAAK2Y,EAAO,OAAQ,CACpB,GAAI5H,EAAO/Q,CAAC,EAAE,OAAS,YACnB,SAEJ2c,EAAS,OAAOhd,EAAG,CAAC,EACpB,KACH,CAED,GAAIoR,EAAO/Q,CAAC,EAAE,OAAS2Y,EAAO3Y,CAAC,EAAE,SAAU,CACvC2c,EAAS,OAAOhd,EAAG,CAAC,EACpB,KACH,EAER,CACJ,CAGD,GAAIgd,EAAS,SAAW,GAAK5L,GAAUA,EAAO,SAAW4L,EAAS,CAAC,EAAE,OAAO,OAAQ,CAChF,MAAMwB,EAAUpN,EAAOA,EAAO,OAAS,CAAC,GACpCoN,GAAW,MAAQ,MAAM,QAAQA,CAAO,GAAK,OAAQA,GAAa,WAClExB,EAAS,OAAO,EAAG,CAAC,CAE3B,CACD,GAAIA,EAAS,SAAW,EACpB,OAAO,KAEX,GAAIA,EAAS,OAAS,GAAKoB,EAAa,CACpC,MAAMnB,EAAWD,EAAS,IAAKE,GAAM,KAAK,UAAUA,EAAE,OAAQ,CAAA,CAAC,EAAE,KAAK,IAAI,EAC1E5d,EAAe,GAAO,gDAAgD2d,CAAQ,IAAK,MAAOzZ,CAAG,CAChG,CACD,OAAOwZ,EAAS,CAAC,CACpB,CAED,MAAMjd,EAAShB,EAAA,KAAKsd,GAAW,IAAIhD,EAAiB,KAAK7V,CAAG,EAAE,OAAM,CAAE,EACtE,OAAIzD,GAGG,IACV,EA6CDmc,GAAA,YAAAa,GAAS,SAACvZ,EAAK4N,EAAQgN,EAAa,CAEhC,GAAIxK,GAAYpQ,CAAG,EAAG,CAClB,MAAMoa,EAAapa,EAAI,cACvB,UAAW+X,KAAYxc,EAAA,KAAKqd,GAAQ,OAAM,EACtC,GAAIwB,IAAerC,EAAS,UACxB,OAAOA,EAGf,OAAO,IACV,CAED,GAAI/X,EAAI,QAAQ,GAAG,IAAM,GAAI,CACzB,MAAMwZ,EAAW,CAAA,EACjB,SAAW,CAACzb,EAAMga,CAAQ,IAAKxc,EAAA,KAAKqd,GAC5B7a,EAAK,MAAM,GAAgB,EAAC,CAAC,IAAMiC,GACnCwZ,EAAS,KAAKzB,CAAQ,EAG9B,GAAInK,EAAQ,CAER,QAASpR,EAAIgd,EAAS,OAAS,EAAGhd,GAAK,EAAGA,IAClCgd,EAAShd,CAAC,EAAE,OAAO,OAASoR,EAAO,QACnC4L,EAAS,OAAOhd,EAAG,CAAC,EAI5B,QAASA,EAAIgd,EAAS,OAAS,EAAGhd,GAAK,EAAGA,IAAK,CAC3C,MAAMgZ,EAASgE,EAAShd,CAAC,EAAE,OAC3B,QAASK,EAAI,EAAGA,EAAI+Q,EAAO,OAAQ/Q,IAE/B,GAAK+P,EAAM,QAAQgB,EAAO/Q,CAAC,CAAC,GAIxB+Q,EAAO/Q,CAAC,EAAE,OAAS2Y,EAAO3Y,CAAC,EAAE,SAAU,CACvC2c,EAAS,OAAOhd,EAAG,CAAC,EACpB,KACH,CAER,CACJ,CACD,GAAIgd,EAAS,SAAW,EACpB,OAAO,KAEX,GAAIA,EAAS,OAAS,GAAKoB,EAAa,CACpC,MAAMnB,EAAWD,EAAS,IAAKE,GAAM,KAAK,UAAUA,EAAE,OAAQ,CAAA,CAAC,EAAE,KAAK,IAAI,EAC1E5d,EAAe,GAAO,6CAA6C2d,CAAQ,IAAK,MAAOzZ,CAAG,CAC7F,CACD,OAAOwZ,EAAS,CAAC,CACpB,CAED,MAAMjd,EAAShB,EAAA,KAAKqd,GAAQ,IAAIjD,EAAc,KAAK3V,CAAG,EAAE,OAAM,CAAE,EAChE,OAAIzD,GAGG,IACV,EA3TE,IAAM0e,GAAN1C,GCzMP,MAAMrN,GAAO,OAAO,CAAC,EAErB,SAAShL,GAASjB,EAAO,CACrB,OAAIA,GACO,IAGf,CACA,SAASic,EAAOjc,EAAO,CACnB,OAAIA,GAAS,KACF,KAEJA,EAAM,UACjB,CAMO,MAAMkc,EAAQ,CAgCjB,YAAYC,EAAUC,EAAcC,EAAsB,CA5B1DpgB,EAAA,iBAaAA,EAAA,qBAUAA,EAAA,6BAMII,EAAiB,KAAM,CACnB,SAAU4E,GAASkb,CAAQ,EAC3B,aAAclb,GAASmb,CAAY,EACnC,qBAAsBnb,GAASob,CAAoB,CAC/D,CAAS,CACJ,CAID,QAAS,CACL,KAAM,CAAE,SAAAF,EAAU,aAAAC,EAAc,qBAAAC,CAAoB,EAAK,KACzD,MAAO,CACH,MAAO,UACP,SAAUJ,EAAOE,CAAQ,EACzB,aAAcF,EAAOG,CAAY,EACjC,qBAAsBH,EAAOI,CAAoB,CAC7D,CACK,CACL,CAMO,SAASC,GAAYC,EAAK,CAC7B,MAAMjf,EAAS,CAAA,EAEXif,EAAI,KACJjf,EAAO,GAAKif,EAAI,IAEhBA,EAAI,OACJjf,EAAO,KAAOif,EAAI,MAElBA,EAAI,OACJjf,EAAO,KAAOsF,EAAQ2Z,EAAI,IAAI,GAElC,MAAMC,EAAa,qFAAqF,MAAM,GAAG,EACjH,UAAWzb,KAAOyb,EACV,EAAEzb,KAAOwb,IAAQA,EAAIxb,CAAG,GAAK,OAGjCzD,EAAOyD,CAAG,EAAIqP,GAAUmM,EAAIxb,CAAG,EAAG,WAAWA,CAAG,EAAE,GAEtD,MAAM0b,EAAa,aAAa,MAAM,GAAG,EACzC,UAAW1b,KAAO0b,EACV,EAAE1b,KAAOwb,IAAQA,EAAIxb,CAAG,GAAK,OAGjCzD,EAAOyD,CAAG,EAAIhB,GAAUwc,EAAIxb,CAAG,EAAG,WAAWA,CAAG,EAAE,GAEtD,OAAIwb,EAAI,aACJjf,EAAO,WAAa8T,GAAcmL,EAAI,UAAU,GAEhD,aAAcA,IACdjf,EAAO,SAAWif,EAAI,UAEtB,mBAAoBA,IACpBjf,EAAO,eAAiB,CAAC,CAACif,EAAI,gBAE9B,eAAgBA,IAChBjf,EAAO,WAAaif,EAAI,YAExB,wBAAyBA,GAAOA,EAAI,sBACpCjf,EAAO,oBAAsBif,EAAI,oBAAoB,MAAK,GAE1D,QAASA,IACTjf,EAAO,IAAMif,EAAI,KAEjB,UAAWA,GAAOA,EAAI,QACtBjf,EAAO,MAAQif,EAAI,MAAM,IAAK7Y,GACtBgZ,GAAYhZ,CAAC,EACNd,EAAQc,CAAC,EAEb,OAAO,OAAO,CAAE,EAAEA,CAAC,CAC7B,GAEEpG,CACX,QAKO,MAAMqf,EAAM,CAyGf,YAAYhQ,EAAOiQ,EAAU,CApG7B3gB,EAAA,iBAKAA,EAAA,eAOAA,EAAA,aAKAA,EAAA,kBAIAA,EAAA,mBAKAA,EAAA,8BAOAA,EAAA,cAUAA,EAAA,mBAIAA,EAAA,iBAIAA,EAAA,gBAKAA,EAAA,kBAIAA,EAAA,qBAKAA,EAAA,oBAKAA,EAAA,sBAKAA,EAAA,cAKAA,EAAA,mBAIAA,EAAA,kBAQAA,EAAA,sBACAC,EAAA,KAAA2gB,GAAA,QAQIzgB,EAAA,KAAKygB,GAAgBlQ,EAAM,aAAa,IAAKuL,GACrC,OAAQA,GAAQ,SACT,IAAI4E,GAAoB5E,EAAI0E,CAAQ,EAExC1E,CACV,GACD7b,EAAiB,KAAM,CACnB,SAAAugB,EACA,KAAM3b,GAAS0L,EAAM,IAAI,EACzB,OAAQA,EAAM,OACd,UAAWA,EAAM,UACjB,WAAYA,EAAM,WAClB,sBAAuBA,EAAM,sBAC7B,MAAOA,EAAM,MACb,WAAYA,EAAM,WAClB,SAAUA,EAAM,SAChB,QAASA,EAAM,QACf,YAAaA,EAAM,YACnB,cAAeA,EAAM,cACrB,MAAOA,EAAM,MACb,WAAY1L,GAAS0L,EAAM,UAAU,EACrC,UAAWA,EAAM,UACjB,cAAe1L,GAAS0L,EAAM,aAAa,EAC3C,UAAWA,EAAM,UACjB,aAAcA,EAAM,YAChC,CAAS,CACJ,CAKD,IAAI,cAAe,CACf,OAAOrQ,EAAA,KAAKugB,IAAc,IAAK3E,GACvB,OAAQA,GAAQ,SACTA,EAEJA,EAAG,IACb,CACJ,CASD,IAAI,wBAAyB,CACzB,MAAM6E,EAAMzgB,EAAA,KAAKugB,IAAc,MAAK,EAEpC,OAAIE,EAAI,SAAW,EACR,IAGX7c,EAAO,OAAQ6c,EAAI,CAAC,GAAO,SAAU,sDAAuD,wBAAyB,CACjH,UAAW,wBACvB,CAAS,EACMA,EACV,CAID,QAAS,CACL,KAAM,CAAE,cAAAC,EAAe,WAAAC,EAAY,UAAAC,EAAW,SAAAC,EAAU,QAAAC,EAAS,KAAAxZ,EAAM,MAAAyZ,EAAO,WAAAC,EAAY,MAAAC,EAAO,OAAA/Z,EAAQ,WAAAga,EAAY,sBAAAC,EAAuB,UAAAC,EAAW,aAAAC,EAAc,UAAAC,EAAW,aAAAC,CAAc,EAAG,KACjM,MAAO,CACH,MAAO,QACP,cAAe5B,EAAOe,CAAa,EACnC,WAAYf,EAAOgB,CAAU,EAC7B,UAAAC,EACA,SAAUjB,EAAOkB,CAAQ,EACzB,QAASlB,EAAOmB,CAAO,EACvB,YAAanB,EAAO,KAAK,WAAW,EACpC,cAAeA,EAAO,KAAK,aAAa,EACxC,KAAArY,EAAM,MAAAyZ,EAAO,WAAAC,EAAY,MAAAC,EAAO,OAAA/Z,EAAQ,WAAAga,EAAY,UAAAI,EACpD,sBAAAH,EAAuB,UAAAC,EAAW,aAAAC,EAClC,aAAAE,CACZ,CACK,CACD,CAAC,OAAO,QAAQ,GAAI,CAChB,IAAIpe,EAAQ,EACZ,MAAMsd,EAAM,KAAK,aACjB,MAAO,CACH,KAAM,IACEtd,EAAQ,KAAK,OACN,CACH,MAAOsd,EAAItd,GAAO,EAAG,KAAM,EACnD,EAEuB,CAAE,MAAO,OAAW,KAAM,EAAI,CAErD,CACK,CAID,IAAI,QAAS,CAAE,OAAOnD,EAAA,KAAKugB,IAAc,MAAS,CAIlD,IAAI,MAAO,CACP,OAAI,KAAK,WAAa,KACX,KAEJ,IAAI,KAAK,KAAK,UAAY,GAAI,CACxC,CAID,MAAM,eAAeiB,EAAa,CAE9B,IAAI5F,EACJ,GAAI,OAAQ4F,GAAiB,SACzB5F,EAAK5b,EAAA,KAAKugB,IAAciB,CAAW,MAElC,CACD,MAAMla,EAAOka,EAAY,cACzB,UAAW3P,KAAK7R,EAAA,KAAKugB,IACjB,GAAI,OAAQ1O,GAAO,SAAU,CACzB,GAAIA,IAAMvK,EACN,SAEJsU,EAAK/J,EACL,KACH,KACI,CACD,GAAIA,EAAE,OAASvK,EACX,SAEJsU,EAAK/J,EACL,KACH,CAER,CACD,GAAI+J,GAAM,KACN,MAAM,IAAI,MAAM,YAAY,EAEhC,OAAI,OAAQA,GAAQ,SACR,MAAM,KAAK,SAAS,eAAeA,CAAE,EAGtCA,CAEd,CAOD,yBAAyB4F,EAAa,CAClC,MAAMf,EAAM,KAAK,uBACjB,GAAI,OAAQe,GAAiB,SACzB,OAAOf,EAAIe,CAAW,EAE1BA,EAAcA,EAAY,cAC1B,UAAW5F,KAAM6E,EACb,GAAI7E,EAAG,OAAS4F,EACZ,OAAO5F,EAGfrb,EAAe,GAAO,0BAA2B,cAAeihB,CAAW,CAC9E,CAKD,SAAU,CAAE,MAAO,CAAC,CAAC,KAAK,IAAO,CAIjC,UAAW,CACP,MAAO,CAAC,CAAC,KAAK,aACjB,CAID,eAAgB,CACZ,GAAI,CAAC,KAAK,UACN,MAAM,IAAI,MAAM,EAAE,EAEtB,OAAOC,GAA0B,IAAI,CACxC,CACL,CA9LIlB,GAAA,YAsMG,MAAMmB,EAAI,CA0Db,YAAYvC,EAAKmB,EAAU,CArD3B3gB,EAAA,iBAKAA,EAAA,wBAKAA,EAAA,kBAOAA,EAAA,oBAOAA,EAAA,gBAIAA,EAAA,gBAIAA,EAAA,aAOAA,EAAA,eAMAA,EAAA,cAIAA,EAAA,yBAKI,KAAK,SAAW2gB,EAChB,MAAM/B,EAAS,OAAO,OAAOY,EAAI,OAAO,MAAK,CAAE,EAC/Cpf,EAAiB,KAAM,CACnB,gBAAiBof,EAAI,gBACrB,UAAWA,EAAI,UACf,YAAaA,EAAI,YACjB,QAASA,EAAI,QACb,QAASA,EAAI,QACb,KAAMA,EAAI,KACV,OAAAZ,EACA,MAAOY,EAAI,MACX,iBAAkBA,EAAI,gBAClC,CAAS,CACJ,CAID,QAAS,CACL,KAAM,CAAE,QAAArP,EAAS,UAAA6R,EAAW,YAAAC,EAAa,KAAAhc,EAAM,MAAAzC,EAAO,QAAA0e,EAAS,OAAAtD,EAAQ,gBAAAuD,EAAiB,iBAAAC,CAAgB,EAAK,KAC7G,MAAO,CACH,MAAO,MACP,QAAAjS,EAAS,UAAA6R,EAAW,YAAAC,EAAa,KAAAhc,EAAM,MAAAzC,EACvC,QAAA0e,EAAS,OAAAtD,EAAQ,gBAAAuD,EAAiB,iBAAAC,CAC9C,CACK,CAID,MAAM,UAAW,CACb,MAAM1R,EAAQ,MAAM,KAAK,SAAS,SAAS,KAAK,SAAS,EACzD,OAAAzM,EAAO,CAAC,CAACyM,EAAO,6BAA8B,gBAAiB,CAAE,CAAA,EAC1DA,CACV,CAID,MAAM,gBAAiB,CACnB,MAAMuL,EAAK,MAAM,KAAK,SAAS,eAAe,KAAK,eAAe,EAClE,OAAAhY,EAAO,CAAC,CAACgY,EAAI,6BAA8B,gBAAiB,CAAE,CAAA,EACvDA,CACV,CAKD,MAAM,uBAAwB,CAC1B,MAAMoG,EAAU,MAAM,KAAK,SAAS,sBAAsB,KAAK,eAAe,EAC9E,OAAApe,EAAO,CAAC,CAACoe,EAAS,qCAAsC,gBAAiB,CAAE,CAAA,EACpEA,CACV,CAID,cAAe,CACX,OAAOC,GAAuB,IAAI,CACrC,CACL,QAoBO,MAAMC,EAAmB,CAoG5B,YAAYtG,EAAI0E,EAAU,CA/F1B3gB,EAAA,iBAIAA,EAAA,WAIAA,EAAA,aAQAA,EAAA,wBAIAA,EAAA,aAIAA,EAAA,cAIAA,EAAA,kBAIAA,EAAA,oBAMAA,EAAA,kBAQAA,EAAA,gBAIAA,EAAA,oBAQAA,EAAA,0BAQAA,EAAA,iBAIAA,EAAA,qBAIAA,EAAA,aASAA,EAAA,eAOAA,EAAA,aACAC,EAAA,KAAAuiB,GAAA,QAKIriB,EAAA,KAAKqiB,GAAQ,OAAO,OAAOvG,EAAG,KAAK,IAAKuD,GAC7B,IAAIuC,GAAIvC,EAAKmB,CAAQ,CAC/B,CAAC,GACF,IAAIT,EAAWlQ,GACXiM,EAAG,mBAAqB,KACxBiE,EAAWjE,EAAG,kBAETA,EAAG,UAAY,OACpBiE,EAAWjE,EAAG,UAElB7b,EAAiB,KAAM,CACnB,SAAAugB,EACA,GAAI1E,EAAG,GACP,KAAMA,EAAG,KACT,gBAAiBA,EAAG,gBACpB,KAAMA,EAAG,KACT,MAAOA,EAAG,MACV,UAAWA,EAAG,UACd,YAAaA,EAAG,YAChB,UAAWA,EAAG,UACd,QAASA,EAAG,QACZ,kBAAmBA,EAAG,kBACtB,YAAaA,EAAG,YAChB,SAAAiE,EACA,aAAcjE,EAAG,aACjB,KAAMA,EAAG,KAET,OAAQA,EAAG,OACX,KAAMA,EAAG,IACrB,CAAS,CACJ,CAID,IAAI,MAAO,CAAE,OAAO5b,EAAA,KAAKmiB,GAAQ,CAIjC,QAAS,CACL,KAAM,CAAE,GAAAhT,EAAI,KAAA0H,EAAM,gBAAAuL,EAAiB,KAAA9a,EAAM,MAAAnE,EAAO,UAAAwe,EAAW,YAAAC,EAAa,UAAAS,EAAW,KAAAC,EACnF,OAAAC,EAAQ,KAAAC,CAAM,EAAG,KACjB,MAAO,CACH,MAAO,qBACP,UAAAb,EAAW,YAAAC,EAEX,gBAAAQ,EACA,kBAAmBzC,EAAO,KAAK,iBAAiB,EAChD,KAAA9I,EACA,SAAU8I,EAAO,KAAK,QAAQ,EAC9B,YAAaA,EAAO,KAAK,WAAW,EACpC,aAAcA,EAAO,KAAK,YAAY,EACtC,QAASA,EAAO,KAAK,OAAO,EAC5B,KAAArY,EAAM,MAAAnE,EAAO,KAAAmf,EAAM,UAAAD,EAAW,KAAAG,EAAM,OAAAD,EAAQ,GAAApT,CACxD,CACK,CAID,IAAI,QAAS,CAAE,OAAO,KAAK,KAAK,MAAS,CACzC,CAAC,OAAO,QAAQ,GAAI,CAChB,IAAIhM,EAAQ,EACZ,MAAO,CACH,KAAM,IACEA,EAAQ,KAAK,OACN,CAAE,MAAO,KAAK,KAAKA,GAAO,EAAG,KAAM,IAEvC,CAAE,MAAO,OAAW,KAAM,EAAI,CAErD,CACK,CAID,IAAI,KAAM,CACN,OAAO,KAAK,QAAU,KAAK,QAC9B,CAID,MAAM,UAAW,CACb,MAAMkN,EAAQ,MAAM,KAAK,SAAS,SAAS,KAAK,SAAS,EACzD,GAAIA,GAAS,KACT,MAAM,IAAI,MAAM,MAAM,EAE1B,OAAOA,CACV,CAID,MAAM,gBAAiB,CACnB,MAAMuL,EAAK,MAAM,KAAK,SAAS,eAAe,KAAK,IAAI,EACvD,GAAIA,GAAM,KACN,MAAM,IAAI,MAAM,MAAM,EAE1B,OAAOA,CACV,CAOD,MAAM,WAAY,CACd,OAAQ,MAAM,KAAK,SAAS,qBAAqB,KAAK,IAAI,CAC7D,CAID,MAAM,eAAgB,CAClB,OAAQ,MAAM,KAAK,SAAS,eAAc,EAAM,KAAK,YAAc,CACtE,CAID,cAAe,CACX,OAAO6G,GAA+B,IAAI,CAC7C,CAID,eAAeC,EAAO,CAClB,OAAA9e,EAAO,CAAC8e,GAASA,EAAM,QAAS,EAAE,gDAAiD,wBAAyB,CAAE,UAAW,uBAAuB,CAAE,EAC3IC,GAAiC,KAAMD,CAAK,CACtD,CACL,CAjIIP,GAAA,mBA2IG,MAAMS,GAAN,MAAMA,EAAoB,CAuH7B,YAAYhH,EAAI0E,EAAU,CAlH1B3gB,EAAA,iBAMAA,EAAA,oBAMAA,EAAA,kBAIAA,EAAA,cAIAA,EAAA,aAKAA,EAAA,aASAA,EAAA,WAMAA,EAAA,aASAA,EAAA,cAMAA,EAAA,iBAaAA,EAAA,iBAMAA,EAAA,6BAKAA,EAAA,qBAIAA,EAAA,yBAIAA,EAAA,aAKAA,EAAA,cAIAA,EAAA,gBAIAA,EAAA,kBAKAA,EAAA,mBAIAA,EAAA,4BACAC,EAAA,KAAAijB,GAAA,QAKI,KAAK,SAAWvC,EAChB,KAAK,YAAe1E,EAAG,aAAe,KAAQA,EAAG,YAAc,KAC/D,KAAK,UAAaA,EAAG,WAAa,KAAQA,EAAG,UAAY,KACzD,KAAK,KAAOA,EAAG,KACf,KAAK,MAAQA,EAAG,MAChB,KAAK,KAAOA,EAAG,KACf,KAAK,KAAOA,EAAG,KACf,KAAK,GAAKA,EAAG,IAAM,KACnB,KAAK,SAAWA,EAAG,SACnB,KAAK,MAAQA,EAAG,MAChB,KAAK,KAAOA,EAAG,KACf,KAAK,MAAQA,EAAG,MAChB,KAAK,SAAWA,EAAG,SACnB,KAAK,qBAAwBA,EAAG,sBAAwB,KAAQA,EAAG,qBAAuB,KAC1F,KAAK,aAAgBA,EAAG,cAAgB,KAAQA,EAAG,aAAe,KAClE,KAAK,iBAAoBA,EAAG,kBAAoB,KAAQA,EAAG,iBAAmB,KAC9E,KAAK,QAAUA,EAAG,QAClB,KAAK,UAAYA,EAAG,UACpB,KAAK,WAAcA,EAAG,YAAc,KAAQA,EAAG,WAAa,KAC5D,KAAK,oBAAuBA,EAAG,qBAAuB,KAAQA,EAAG,oBAAsB,KACvF9b,EAAA,KAAK+iB,GAAc,GACtB,CAID,QAAS,CACL,KAAM,CAAE,YAAAjB,EAAa,UAAAD,EAAW,MAAAxe,EAAO,KAAAmE,EAAM,KAAAtC,EAAM,GAAAmK,EAAI,KAAA0H,EAAM,MAAAoK,EAAO,KAAArb,EAAM,UAAA8W,EAAW,WAAAoG,EAAY,oBAAAC,CAAmB,EAAK,KACzH,MAAO,CACH,MAAO,sBACP,WAAAD,EAAY,YAAAlB,EAAa,UAAAD,EACzB,oBAAAoB,EACA,QAASpD,EAAO,KAAK,OAAO,EAC5B,KAAA/Z,EAAM,KAAAiR,EACN,SAAU8I,EAAO,KAAK,QAAQ,EAC9B,SAAUA,EAAO,KAAK,QAAQ,EAC9B,KAAArY,EACA,aAAcqY,EAAO,KAAK,YAAY,EACtC,qBAAsBA,EAAO,KAAK,oBAAoB,EACtD,iBAAkBA,EAAO,KAAK,gBAAgB,EAC9C,MAAAsB,EAAO,UAAAvE,EAAW,GAAAvN,EAAI,MAAAhM,EAAO,KAAA6B,EAC7B,MAAO2a,EAAO,KAAK,KAAK,CACpC,CACK,CAMD,MAAM,UAAW,CACb,IAAIiC,EAAc,KAAK,YACvB,GAAIA,GAAe,KAAM,CACrB,MAAMhG,EAAK,MAAM,KAAK,iBAClBA,IACAgG,EAAchG,EAAG,YAExB,CACD,GAAIgG,GAAe,KACf,OAAO,KAEX,MAAMvR,EAAQ,KAAK,SAAS,SAASuR,CAAW,EAChD,GAAIvR,GAAS,KACT,MAAM,IAAI,MAAM,MAAM,EAE1B,OAAOA,CACV,CAMD,MAAM,gBAAiB,CACnB,OAAO,KAAK,SAAS,eAAe,KAAK,IAAI,CAChD,CAID,MAAM,eAAgB,CAClB,GAAI,KAAK,aAAe,KAAM,CAC1B,KAAM,CAAE,GAAAuL,EAAI,YAAAgG,CAAa,EAAG,MAAMoB,GAAkB,CAChD,GAAI,KAAK,eAAgB,EACzB,YAAa,KAAK,SAAS,eAAgB,CAC3D,CAAa,EAED,OAAIpH,GAAM,MAAQA,EAAG,aAAe,KACzB,EAEJgG,EAAchG,EAAG,YAAc,CACzC,CAED,OADoB,MAAM,KAAK,SAAS,eAAc,EACjC,KAAK,YAAc,CAC3C,CAUD,MAAM,KAAKqH,EAAWC,EAAU,CAC5B,MAAMC,EAAYF,GAAqB,EACjCG,EAAWF,GAAoB,EACrC,IAAIG,EAAarjB,EAAA,KAAK6iB,IAClBS,EAAW,GACXC,EAAgBF,IAAe,GACnC,MAAMG,EAAmB,SAAY,CAEjC,GAAID,EACA,OAAO,KAEX,KAAM,CAAE,YAAA3B,EAAa,MAAAX,CAAO,EAAG,MAAM+B,GAAkB,CACnD,YAAa,KAAK,SAAS,eAAgB,EAC3C,MAAO,KAAK,SAAS,oBAAoB,KAAK,IAAI,CAClE,CAAa,EAGD,GAAI/B,EAAQ,KAAK,MAAO,CACpBoC,EAAazB,EACb,MACH,CAED,GAAI2B,EACA,OAAO,KAEX,MAAME,EAAQ,MAAM,KAAK,iBACzB,GAAI,EAAAA,GAASA,EAAM,aAAe,MAWlC,IANIH,IAAa,KACbA,EAAWD,EAAa,EACpBC,EAAWtjB,EAAA,KAAK6iB,MAChBS,EAAWtjB,EAAA,KAAK6iB,MAGjBS,GAAY1B,GAAa,CAE5B,GAAI2B,EACA,OAAO,KAEX,MAAMlT,EAAQ,MAAM,KAAK,SAAS,SAASiT,EAAU,EAAI,EAEzD,GAAIjT,GAAS,KACT,OAGJ,UAAW/I,KAAQ+I,EACf,GAAI/I,IAAS,KAAK,KACd,OAIR,QAASrG,EAAI,EAAGA,EAAIoP,EAAM,OAAQpP,IAAK,CACnC,MAAM2a,EAAK,MAAMvL,EAAM,eAAepP,CAAC,EACvC,GAAI2a,EAAG,OAAS,KAAK,MAAQA,EAAG,QAAU,KAAK,MAAO,CAElD,GAAI2H,EACA,OAAO,KAEX,MAAMvB,EAAU,MAAM,KAAK,SAAS,sBAAsBpG,EAAG,IAAI,EAMjE,GAJIoG,GAAW,MAIVJ,EAAcI,EAAQ,YAAc,EAAKmB,EAC1C,OAGJ,IAAIjjB,GAAS,WACT0b,EAAG,OAAS,KAAK,MAAQA,EAAG,KAAO,KAAK,IAAMA,EAAG,QAAU,KAAK,MAChE1b,GAAS,WAEJ0b,EAAG,OAAS,MAAQA,EAAG,OAASA,EAAG,IAAMA,EAAG,QAAUjM,KAC3DzP,GAAS,aAEb0D,EAAO,GAAO,2BAA4B,uBAAwB,CAC9D,UAAY1D,KAAW,YAAcA,KAAW,YAChD,OAAAA,GACA,YAAa0b,EAAG,uBAAuByH,CAAU,EACjD,KAAMzH,EAAG,KACT,QAAAoG,CAC5B,CAAyB,CACJ,CACJ,CACDsB,GACH,CAEb,EACcI,EAAgB1B,GAAY,CAC9B,GAAIA,GAAW,MAAQA,EAAQ,SAAW,EACtC,OAAOA,EAEXpe,EAAO,GAAO,iCAAkC,iBAAkB,CAC9D,OAAQ,kBACR,KAAM,KAAM,OAAQ,KAAM,WAAY,KAAM,OAAQ,KACpD,YAAa,CACT,GAAIoe,EAAQ,GACZ,KAAMA,EAAQ,KACd,KAAM,EAC1B,EAAmB,QAAAA,CACnB,CAAa,CACb,EACcA,EAAU,MAAM,KAAK,SAAS,sBAAsB,KAAK,IAAI,EACnE,GAAImB,IAAa,EACb,OAAOO,EAAa1B,CAAO,EAE/B,GAAIA,GACA,GAAK,MAAMA,EAAQ,cAAa,GAAOmB,EACnC,OAAOO,EAAa1B,CAAO,UAK/B,MAAMwB,EAAgB,EAElBL,IAAa,EACb,OAAO,KAuDf,OAAO,MApDQ,IAAI,QAAQ,CAACQ,EAASC,IAAW,CAE5C,MAAMC,EAAa,CAAA,EACbC,EAAS,IAAM,CAAED,EAAW,QAAS3iB,GAAMA,GAAG,GAIpD,GAFA2iB,EAAW,KAAK,IAAM,CAAEN,EAAe,EAAO,CAAA,EAE1CH,EAAU,EAAG,CACb,MAAMW,EAAQ,WAAW,IAAM,CAC3BD,IACAF,EAAO1H,GAAU,+BAAgC,SAAS,CAAC,CAC9D,EAAEkH,CAAO,EACVS,EAAW,KAAK,IAAM,CAAE,aAAaE,CAAK,CAAE,CAAE,CACjD,CACD,MAAMC,EAAa,MAAOhC,GAAY,CAElC,GAAK,MAAMA,EAAQ,cAAa,GAAOmB,EAAU,CAC7CW,IACA,GAAI,CACAH,EAAQD,EAAa1B,CAAO,CAAC,CAChC,OACMvf,EAAO,CACVmhB,EAAOnhB,CAAK,CACf,CACJ,CACjB,EAIY,GAHAohB,EAAW,KAAK,IAAM,CAAE,KAAK,SAAS,IAAI,KAAK,KAAMG,CAAU,CAAI,CAAA,EACnE,KAAK,SAAS,GAAG,KAAK,KAAMA,CAAU,EAElCX,GAAc,EAAG,CACjB,MAAMY,EAAkB,SAAY,CAChC,GAAI,CAEA,MAAMT,EAAgB,CACzB,OACM/gB,EAAO,CAEV,GAAIwQ,GAAQxQ,EAAO,sBAAsB,EAAG,CACxCqhB,IACAF,EAAOnhB,CAAK,EACZ,MACH,CACJ,CAEI8gB,GACD,KAAK,SAAS,KAAK,QAASU,CAAe,CAEnE,EACgBJ,EAAW,KAAK,IAAM,CAAE,KAAK,SAAS,IAAI,QAASI,CAAe,CAAE,CAAE,EACtE,KAAK,SAAS,KAAK,QAASA,CAAe,CAC9C,CACb,CAAS,CAEJ,CAYD,SAAU,CACN,OAAQ,KAAK,WAAa,IAC7B,CAQD,UAAW,CACP,OAAQ,KAAK,OAAS,CACzB,CAQD,UAAW,CACP,OAAQ,KAAK,OAAS,CACzB,CAQD,UAAW,CACP,OAAQ,KAAK,OAAS,CACzB,CAKD,UAAW,CACP,OAAQ,KAAK,OAAS,CACzB,CAKD,cAAe,CACX,OAAArgB,EAAO,KAAK,UAAW,wCAAyC,wBAAyB,CAAE,UAAW,eAAe,CAAE,EAChH6e,GAA+B,IAAI,CAC7C,CAKD,eAAeC,EAAO,CAClB,OAAA9e,EAAO,KAAK,UAAW,wCAAyC,wBAAyB,CAAE,UAAW,eAAe,CAAE,EACvHA,EAAO,CAAC8e,GAASA,EAAM,QAAS,EAAE,gDAAiD,wBAAyB,CAAE,UAAW,eAAe,CAAE,EACnIC,GAAiC,KAAMD,CAAK,CACtD,CAUD,uBAAuBW,EAAY,CAC/B9iB,EAAe,OAAO,UAAU8iB,CAAU,GAAKA,GAAc,EAAG,qBAAsB,aAAcA,CAAU,EAC9G,MAAMzH,EAAK,IAAIgH,GAAoB,KAAM,KAAK,QAAQ,EACtD,OAAA9iB,EAAA8b,EAAGiH,GAAcQ,GACVzH,CACV,CACL,EA5WIiH,GAAA,YAnHG,IAAMrC,GAANoC,GAgeP,SAASnB,GAA0BpR,EAAO,CACtC,MAAO,CAAE,OAAQ,aAAc,KAAMA,EAAM,KAAM,OAAQA,EAAM,OACnE,CACA,SAASsS,GAAiC/G,EAAI8G,EAAO,CACjD,MAAO,CAAE,OAAQ,sBAAuB,GAAA9G,EAAI,MAAA8G,CAAK,CACrD,CACA,SAASD,GAA+B7G,EAAI,CACxC,MAAO,CAAE,OAAQ,mBAAoB,GAAAA,EACzC,CACA,SAASqG,GAAuB9C,EAAK,CACjC,MAAO,CAAE,OAAQ,WAAY,IAAK,CAC1B,gBAAiBA,EAAI,gBACrB,UAAWA,EAAI,UACf,YAAaA,EAAI,YACjB,QAASA,EAAI,QACb,KAAMA,EAAI,KACV,OAAQ,OAAO,OAAOA,EAAI,OAAO,MAAK,CAAE,EACxC,MAAOA,EAAI,KACvB,EACA,CC/wCO,MAAM+E,WAAiBxC,EAAI,CAgB9B,YAAYvC,EAAKgF,EAAO3H,EAAU,CAC9B,MAAM2C,EAAKA,EAAI,QAAQ,EAb3Bxf,EAAA,kBAIAA,EAAA,iBAIAA,EAAA,aAMI,MAAMiD,EAAOuhB,EAAM,eAAe3H,EAAU2C,EAAI,KAAMA,EAAI,MAAM,EAChEpf,EAAiB,KAAM,CAAE,KAAA6C,EAAM,SAAA4Z,EAAU,UAAW2H,CAAK,CAAE,CAC9D,CAID,IAAI,WAAY,CAAE,OAAO,KAAK,SAAS,IAAO,CAI9C,IAAI,gBAAiB,CAAE,OAAO,KAAK,SAAS,OAAQ,CAAG,CAC3D,CAIO,MAAMC,WAA0B1C,EAAI,CAQvC,YAAYvC,EAAK1c,EAAO,CACpB,MAAM0c,EAAKA,EAAI,QAAQ,EAL3Bxf,EAAA,cAMII,EAAiB,KAAM,CAAE,MAAA0C,CAAK,CAAE,CACnC,CACL,QAKO,MAAM4hB,WAAmCnC,EAAmB,CAK/D,YAAYiC,EAAO7D,EAAU1E,EAAI,CAC7B,MAAMA,EAAI0E,CAAQ,EALtB1gB,EAAA,KAAA0kB,GAAA,QAMIxkB,EAAA,KAAKwkB,GAASH,EACjB,CAKD,IAAI,MAAO,CACP,OAAO,MAAM,KAAK,IAAKhF,GAAQ,CAC3B,MAAM3C,EAAW2C,EAAI,OAAO,OAASnf,EAAA,KAAKskB,IAAO,SAASnF,EAAI,OAAO,CAAC,CAAC,EAAI,KAC3E,GAAI3C,EACA,GAAI,CACA,OAAO,IAAI0H,GAAS/E,EAAKnf,EAAA,KAAKskB,IAAQ9H,CAAQ,CACjD,OACM/Z,EAAO,CACV,OAAO,IAAI2hB,GAAkBjF,EAAK1c,CAAK,CAC1C,CAEL,OAAO0c,CACnB,CAAS,CACJ,CACL,CA1BImF,GAAA,mBA+BG,MAAMC,WAAoC/D,EAAoB,CAKjE,YAAY2D,EAAO7D,EAAU1E,EAAI,CAC7B,MAAMA,EAAI0E,CAAQ,EALtB1gB,EAAA,KAAA0kB,GAAA,QAMIxkB,EAAA,KAAKwkB,GAASH,EACjB,CAUD,MAAM,KAAKhB,EAAUC,EAAS,CAC1B,MAAMpB,EAAU,MAAM,MAAM,KAAKmB,EAAUC,CAAO,EAClD,OAAIpB,GAAW,KACJ,KAEJ,IAAIqC,GAA2BrkB,EAAA,KAAKskB,IAAQ,KAAK,SAAUtC,CAAO,CAC5E,CACL,CAxBIsC,GAAA,YA6BG,MAAME,WAAoCjlB,EAAa,CAQ1D,YAAYklB,EAAUhlB,EAAUC,EAAQyf,EAAK,CACzC,MAAMsF,EAAUhlB,EAAUC,CAAM,EALpCC,EAAA,YAMII,EAAiB,KAAM,CAAE,IAAAof,CAAG,CAAE,CACjC,CAID,MAAM,UAAW,CACb,OAAO,MAAM,KAAK,IAAI,UACzB,CAID,MAAM,gBAAiB,CACnB,OAAO,MAAM,KAAK,IAAI,gBACzB,CAID,MAAM,uBAAwB,CAC1B,OAAO,MAAM,KAAK,IAAI,uBACzB,CACL,CAKO,MAAMuF,WAA6BF,EAA4B,CAIlE,YAAYC,EAAUhlB,EAAUC,EAAQ8c,EAAUmI,EAAM,CACpD,MAAMF,EAAUhlB,EAAUC,EAAQ,IAAIwkB,GAASS,EAAMF,EAAS,UAAWjI,CAAQ,CAAC,EAClF,MAAM5Z,EAAO6hB,EAAS,UAAU,eAAejI,EAAU,KAAK,IAAI,KAAM,KAAK,IAAI,MAAM,EACvFzc,EAAiB,KAAM,CAAE,KAAA6C,EAAM,SAAA4Z,CAAU,CAAA,CAC5C,CAID,IAAI,WAAY,CACZ,OAAO,KAAK,SAAS,IACxB,CAID,IAAI,gBAAiB,CACjB,OAAO,KAAK,SAAS,QACxB,CACL,CCxKA,MAAM7M,GAAO,OAAO,CAAC,EACrB,SAASiV,GAAQlhB,EAAO,CACpB,OAAQA,GAAS,OAAQA,EAAM,MAAU,UAC7C,CACA,SAASmhB,GAAYnhB,EAAO,CACxB,OAAQA,GAAS,OAAQA,EAAM,aAAiB,UACpD,CACA,SAASohB,GAAWphB,EAAO,CACvB,OAAQA,GAAS,OAAQA,EAAM,aAAiB,UACpD,CACA,SAASqhB,GAAQrhB,EAAO,CACpB,OAAQA,GAAS,OAAQA,EAAM,iBAAqB,UACxD,CACA,SAASshB,GAAYthB,EAAO,CACxB,GAAIA,GAAS,KAAM,CACf,GAAIohB,GAAWphB,CAAK,EAChB,OAAOA,EAEX,GAAIA,EAAM,SACN,OAAOA,EAAM,QAEpB,CAEL,QACA,MAAMuhB,EAAoB,CAGtB,YAAYR,EAAUjI,EAAU5Z,EAAM,CAFtChD,EAAA,KAAAslB,GAAA,QACAvlB,EAAA,iBAGI,GADAI,EAAiB,KAAM,CAAE,SAAAyc,CAAQ,CAAE,EAC/BA,EAAS,OAAO,OAAS5Z,EAAK,OAC9B,MAAM,IAAI,MAAM,oBAAoB,EAGxC,MAAMuiB,EAASC,GAAUX,EAAS,OAAQ,aAAa,EACjDxT,EAAW6T,GAAWK,CAAM,EAAIA,EAAS,KAC/CrlB,EAAA,KAAKolB,GAAW,gBAAkB,CAC9B,MAAMG,EAAe,MAAM,QAAQ,IAAI7I,EAAS,OAAO,IAAI,CAACzC,EAAO5W,IACnDP,EAAKO,CAAK,GACX,KACA,KAEJ4W,EAAM,UAAUnX,EAAKO,CAAK,EAAG,CAAC6B,EAAMtB,IACnCsB,IAAS,UACL,MAAM,QAAQtB,CAAK,EACZ,QAAQ,IAAIA,EAAM,IAAKmO,GAAMb,GAAea,EAAGZ,CAAQ,CAAC,CAAC,EAE7DD,GAAetN,EAAOuN,CAAQ,EAElCvN,CACV,CACJ,CAAC,EACF,OAAO+gB,EAAS,UAAU,mBAAmBjI,EAAU6I,CAAY,CAC/E,IACK,CACD,gBAAiB,CACb,OAAOrlB,EAAA,KAAKklB,GACf,CACL,CAhCIA,GAAA,YAuCJ,SAASE,GAAU1hB,EAAO4hB,EAAS,CAC/B,OAAI5hB,GAAS,KACF,KAEP,OAAQA,EAAM4hB,CAAO,GAAO,WACrB5hB,EAEPA,EAAM,UAAY,OAAQA,EAAM,SAAS4hB,CAAO,GAAO,WAChD5hB,EAAM,SAEV,IACX,CACA,SAAS6hB,GAAY7hB,EAAO,CACxB,OAAIA,GAAS,KACF,KAEJA,EAAM,UAAY,IAC7B,CAIO,eAAe8hB,GAAcC,EAAKlP,EAAS,CAE9C,MAAMmP,EAAarU,EAAM,YAAYoU,EAAK,WAAW,EACrDllB,EAAe,OAAQmlB,GAAgB,SAAU,8BAA+B,YAAaD,CAAG,EAEhG,MAAME,EAAY3F,GAAY0F,CAAU,EACxC,OAAAnlB,EAAeolB,EAAU,IAAM,OAASpP,GAAW,CAAA,GAAI,QAAQ,IAAI,GAAK,EAAG,qBAAsB,eAAgBoP,EAAU,EAAE,EAC7HplB,EAAeolB,EAAU,MAAQ,OAASpP,GAAW,CAAA,GAAI,QAAQ,MAAM,GAAK,EAAG,uBAAwB,iBAAkBoP,EAAU,IAAI,EAEnIA,EAAU,OACVA,EAAU,KAAOA,EAAU,MAExBA,CACX,CAIO,eAAeC,GAAYC,EAAS5L,EAAQrX,EAAM,CAErD,MAAMuiB,EAASC,GAAUS,EAAS,aAAa,EACzC5U,EAAW6T,GAAWK,CAAM,EAAIA,EAAS,KAC/C,OAAO,MAAM,QAAQ,IAAIlL,EAAO,IAAI,CAACF,EAAO5W,IACjC4W,EAAM,UAAUnX,EAAKO,CAAK,EAAG,CAAC6B,EAAMtB,KACvCA,EAAQ2N,EAAM,YAAY3N,EAAOsB,CAAI,EACjCA,IAAS,UACFgM,GAAetN,EAAOuN,CAAQ,EAElCvN,EACV,CACJ,CAAC,CACN,CACA,SAASoiB,GAAqBrB,EAAU,CACpC,MAAMsB,EAAsB,eAAgBJ,EAAW,CAEnD,MAAM/J,EAAM,MAAM4J,GAAcG,EAAW,CAAC,MAAM,CAAC,EACnD/J,EAAG,GAAK,MAAM6I,EAAS,WAAU,EAC7B7I,EAAG,OACHA,EAAG,KAAO,MAAM5K,GAAe4K,EAAG,KAAMoJ,GAAYP,EAAS,MAAM,CAAC,GAExE,MAAMN,EAAQM,EAAS,UACjBuB,EAAWlS,GAAW8H,EAAG,OAASjM,GAAO,iBAAiB,IAAMA,GAChEsW,GAAWrK,EAAG,MAAQ,QAAU,KAClCuI,EAAM,UAAY,CAACA,EAAM,SAAS,SAAWA,EAAM,SAAW,CAAC8B,GAAU,CAACD,GAC1EzlB,EAAe,GAAO,oEAAqE,YAAaolB,CAAS,EAErHplB,EAAe4jB,EAAM,UAAY8B,EAAQ,4CAA6C,iBAAkBrK,EAAG,IAAI,EAE/G,MAAMd,EAAUqJ,EAAM,SAAYA,EAAM,UAAYA,EAAM,SAAS,QACnE,OAAA5jB,EAAeua,GAAWkL,EAAS,4CAA6C,kBAAmBpK,EAAG,KAAK,EAE3Grb,EAAe4jB,EAAM,UAAY8B,EAAQ,4CAA6C,iBAAkBrK,EAAG,IAAI,EACxGA,CACf,EACUsK,EAAa,eAAgBP,EAAW,CAC1C,MAAMR,EAASC,GAAUX,EAAS,OAAQ,MAAM,EAChD7gB,EAAOghB,GAAQO,CAAM,EAAG,2CAA4C,wBAAyB,CAAE,UAAW,MAAM,CAAE,EAClH,MAAMvJ,EAAK,MAAMmK,EAAoBJ,CAAS,EAC9C,GAAI,CACA,OAAO,MAAMR,EAAO,KAAKvJ,CAAE,CAC9B,OACMnZ,EAAO,CACV,MAAI0jB,GAAgB1jB,CAAK,GAAKA,EAAM,KAC1BgiB,EAAS,UAAU,UAAUhiB,EAAM,KAAMmZ,CAAE,EAE/CnZ,CACT,CACT,EACU2jB,EAAO,eAAgBT,EAAW,CACpC,MAAMR,EAASV,EAAS,OACxB7gB,EAAOmhB,GAAQI,CAAM,EAAG,wDAAyD,wBAAyB,CAAE,UAAW,iBAAiB,CAAE,EAC1I,MAAMvJ,EAAK,MAAMuJ,EAAO,gBAAgB,MAAMY,EAAoBJ,CAAS,CAAC,EACtErF,EAAWiF,GAAYd,EAAS,MAAM,EAG5C,OAAO,IAAIF,GAA4BE,EAAS,UAAWnE,EAAU1E,CAAE,CAC/E,EACUyK,EAAc,eAAgBV,EAAW,CAC3C,MAAMR,EAASC,GAAUX,EAAS,OAAQ,aAAa,EACvD,OAAA7gB,EAAOihB,GAAYM,CAAM,EAAG,kDAAmD,wBAAyB,CAAE,UAAW,aAAa,CAAE,EAC7H,MAAMA,EAAO,YAAY,MAAMY,EAAoBJ,CAAS,CAAC,CAC5E,EACUW,EAAS,MAAOX,GACX,MAAMS,EAAKT,CAAS,EAE/B,OAAA5lB,EAAiBumB,EAAQ,CACrB,UAAW7B,EACX,YAAA4B,EACA,oBAAAN,EACA,KAAAK,EAAM,WAAAF,CACd,CAAK,EACMI,CACX,CACA,SAASC,GAAmB9B,EAAUhgB,EAAK,CACvC,MAAM+hB,EAAc,YAAa5jB,EAAM,CACnC,MAAM4Z,EAAWiI,EAAS,UAAU,YAAYhgB,EAAK7B,CAAI,EACzD,OAAAgB,EAAO4Y,EAAU,uBAAwB,wBAAyB,CAC9D,UAAW,WACX,KAAM,CAAE,IAAA/X,EAAK,KAAA7B,CAAM,CAC/B,CAAS,EACM4Z,CACf,EACUuJ,EAAsB,kBAAmBnjB,EAAM,CACjD,MAAM4Z,EAAWgK,EAAY,GAAG5jB,CAAI,EAEpC,IAAI+iB,EAAY,CAAA,EAOhB,GANInJ,EAAS,OAAO,OAAS,IAAM5Z,EAAK,SACpC+iB,EAAY,MAAMH,GAAc5iB,EAAK,IAAK,CAAA,EACtC+iB,EAAU,OACVA,EAAU,KAAO,MAAM3U,GAAe2U,EAAU,KAAMX,GAAYP,EAAS,MAAM,CAAC,IAGtFjI,EAAS,OAAO,SAAW5Z,EAAK,OAChC,MAAM,IAAI,MAAM,4EAA4E,EAEhG,MAAMyiB,EAAe,MAAMO,GAAYnB,EAAS,OAAQjI,EAAS,OAAQ5Z,CAAI,EAC7E,OAAO,OAAO,OAAO,CAAE,EAAE+iB,EAAW,MAAM3C,GAAkB,CACxD,GAAIyB,EAAS,WAAY,EACzB,KAAMA,EAAS,UAAU,mBAAmBjI,EAAU6I,CAAY,CACrE,CAAA,CAAC,CACV,EACUa,EAAa,kBAAmBtjB,EAAM,CACxC,MAAM5B,EAAS,MAAMylB,EAAiB,GAAG7jB,CAAI,EAC7C,OAAI5B,EAAO,SAAW,EACXA,EAAO,CAAC,EAEZA,CACf,EACUolB,EAAO,kBAAmBxjB,EAAM,CAClC,MAAMuiB,EAASV,EAAS,OACxB7gB,EAAOmhB,GAAQI,CAAM,EAAG,wDAAyD,wBAAyB,CAAE,UAAW,iBAAiB,CAAE,EAC1I,MAAMvJ,EAAK,MAAMuJ,EAAO,gBAAgB,MAAMY,EAAoB,GAAGnjB,CAAI,CAAC,EACpE0d,EAAWiF,GAAYd,EAAS,MAAM,EAG5C,OAAO,IAAIF,GAA4BE,EAAS,UAAWnE,EAAU1E,CAAE,CAC/E,EACUyK,EAAc,kBAAmBzjB,EAAM,CACzC,MAAMuiB,EAASC,GAAUX,EAAS,OAAQ,aAAa,EACvD,OAAA7gB,EAAOihB,GAAYM,CAAM,EAAG,kDAAmD,wBAAyB,CAAE,UAAW,aAAa,CAAE,EAC7H,MAAMA,EAAO,YAAY,MAAMY,EAAoB,GAAGnjB,CAAI,CAAC,CAC1E,EACU6jB,EAAmB,kBAAmB7jB,EAAM,CAC9C,MAAMuiB,EAASC,GAAUX,EAAS,OAAQ,MAAM,EAChD7gB,EAAOghB,GAAQO,CAAM,EAAG,2CAA4C,wBAAyB,CAAE,UAAW,MAAM,CAAE,EAClH,MAAMvJ,EAAK,MAAMmK,EAAoB,GAAGnjB,CAAI,EAC5C,IAAI5B,EAAS,KACb,GAAI,CACAA,EAAS,MAAMmkB,EAAO,KAAKvJ,CAAE,CAChC,OACMnZ,EAAO,CACV,MAAI0jB,GAAgB1jB,CAAK,GAAKA,EAAM,KAC1BgiB,EAAS,UAAU,UAAUhiB,EAAM,KAAMmZ,CAAE,EAE/CnZ,CACT,CACD,MAAM+Z,EAAWgK,EAAY,GAAG5jB,CAAI,EACpC,OAAO6hB,EAAS,UAAU,qBAAqBjI,EAAUxb,CAAM,CACvE,EACUslB,EAAS,SAAU1jB,IACJ4jB,EAAY,GAAG5jB,CAAI,EACvB,SACF,MAAMsjB,EAAW,GAAGtjB,CAAI,EAE5B,MAAMwjB,EAAK,GAAGxjB,CAAI,EAE7B,OAAA7C,EAAiBumB,EAAQ,CACrB,KAAM7B,EAAS,UAAU,gBAAgBhgB,CAAG,EAC5C,UAAWggB,EAAU,KAAMhgB,EAC3B,YAAA+hB,EACA,YAAAH,EACA,oBAAAN,EACA,KAAAK,EAAM,WAAAF,EAAY,iBAAAO,CAC1B,CAAK,EAED,OAAO,eAAeH,EAAQ,WAAY,CACtC,aAAc,GACd,WAAY,GACZ,IAAK,IAAM,CACP,MAAM9J,EAAWiI,EAAS,UAAU,YAAYhgB,CAAG,EACnD,OAAAb,EAAO4Y,EAAU,uBAAwB,wBAAyB,CAC9D,UAAW,WACX,KAAM,CAAE,IAAA/X,CAAK,CAC7B,CAAa,EACM+X,CACV,CACT,CAAK,EACM8J,CACX,CACA,SAASI,GAAkBjC,EAAUhgB,EAAK,CACtC,MAAM+hB,EAAc,YAAa5jB,EAAM,CACnC,MAAM4Z,EAAWiI,EAAS,UAAU,SAAShgB,EAAK7B,CAAI,EACtD,OAAAgB,EAAO4Y,EAAU,uBAAwB,wBAAyB,CAC9D,UAAW,WACX,KAAM,CAAE,IAAA/X,EAAK,KAAA7B,CAAM,CAC/B,CAAS,EACM4Z,CACf,EACU8J,EAAS,YAAa1jB,EAAM,CAC9B,OAAO,IAAIqiB,GAAoBR,EAAU+B,EAAY,GAAG5jB,CAAI,EAAGA,CAAI,CAC3E,EACI,OAAA7C,EAAiBumB,EAAQ,CACrB,KAAM7B,EAAS,UAAU,aAAahgB,CAAG,EACzC,UAAWggB,EAAU,KAAMhgB,EAC3B,YAAA+hB,CACR,CAAK,EAED,OAAO,eAAeF,EAAQ,WAAY,CACtC,aAAc,GACd,WAAY,GACZ,IAAK,IAAM,CACP,MAAM9J,EAAWiI,EAAS,UAAU,SAAShgB,CAAG,EAChD,OAAAb,EAAO4Y,EAAU,uBAAwB,wBAAyB,CAC9D,UAAW,WACX,KAAM,CAAE,IAAA/X,CAAK,CAC7B,CAAa,EACM+X,CACV,CACT,CAAK,EACM8J,CACX,CAKA,MAAMlO,GAAW,OAAO,IAAI,0BAA0B,EAChDuO,GAAiB,IAAI,QAC3B,SAASC,GAAYnC,EAAUpS,EAAQ,CACnCsU,GAAe,IAAIlC,EAASrM,EAAQ,EAAG/F,CAAM,CACjD,CACA,SAASwU,EAAYpC,EAAU,CAC3B,OAAOkC,GAAe,IAAIlC,EAASrM,EAAQ,CAAC,CAChD,CACA,SAAS0O,GAAWpjB,EAAO,CACvB,OAAQA,GAAS,OAAQA,GAAW,UAAa,mBAAoBA,GAChE,OAAQA,EAAM,gBAAoB,YAAeA,EAAM,QAChE,CACA,eAAeqjB,GAAWtC,EAAUuC,EAAO,CACvC,IAAIzI,EACA/B,EAAW,KAGf,GAAI,MAAM,QAAQwK,CAAK,EAAG,CACtB,MAAMC,EAAe,SAAUzkB,EAAM,CACjC,GAAIqS,GAAYrS,EAAM,EAAE,EACpB,OAAOA,EAEX,MAAMga,EAAWiI,EAAS,UAAU,SAASjiB,CAAI,EACjD,OAAAjC,EAAeic,EAAU,mBAAoB,OAAQha,CAAI,EAClDga,EAAS,SAC5B,EAEQ+B,EAASyI,EAAM,IAAKE,GACZA,GAAK,KACE,KAEP,MAAM,QAAQA,CAAC,EACRA,EAAE,IAAID,CAAY,EAEtBA,EAAaC,CAAC,CACxB,CACJ,MACQF,IAAU,IACfzI,EAAS,CAAC,IAAI,EAET,OAAQyI,GAAW,SACpBnS,GAAYmS,EAAO,EAAE,EAErBzI,EAAS,CAACyI,CAAK,GAIfxK,EAAWiI,EAAS,UAAU,SAASuC,CAAK,EAC5CzmB,EAAeic,EAAU,mBAAoB,QAASwK,CAAK,EAC3DzI,EAAS,CAAC/B,EAAS,SAAS,GAG3BsK,GAAWE,CAAK,EAErBzI,EAAS,MAAMyI,EAAM,iBAEhB,aAAcA,GAEnBxK,EAAWwK,EAAM,SACjBzI,EAAS,CAAC/B,EAAS,SAAS,GAG5Bjc,EAAe,GAAO,qBAAsB,QAASymB,CAAK,EAG9DzI,EAASA,EAAO,IAAK/Q,GAAM,CACvB,GAAIA,GAAK,KACL,OAAO,KAEX,GAAI,MAAM,QAAQA,CAAC,EAAG,CAClB,MAAM1K,EAAQ,MAAM,KAAK,IAAI,IAAI0K,EAAE,IAAKA,GAAMA,EAAE,YAAW,CAAE,CAAC,EAAE,OAAQ,CAAA,EACxE,OAAI1K,EAAM,SAAW,EACVA,EAAM,CAAC,GAElBA,EAAM,KAAI,EACHA,EACV,CACD,OAAO0K,EAAE,aACjB,CAAK,EACD,MAAM2Z,EAAM5I,EAAO,IAAK/Q,GAChBA,GAAK,KACE,OAEP,MAAM,QAAQA,CAAC,EACRA,EAAE,KAAK,GAAG,EAEdA,CACV,EAAE,KAAK,GAAG,EACX,MAAO,CAAE,SAAAgP,EAAU,IAAA2K,EAAK,OAAA5I,EAC5B,CACA,eAAe6I,GAAO3C,EAAUuC,EAAO,CACnC,KAAM,CAAE,KAAAK,CAAI,EAAKR,EAAYpC,CAAQ,EACrC,OAAO4C,EAAK,KAAK,MAAMN,GAAWtC,EAAUuC,CAAK,GAAG,GAAG,GAAK,IAChE,CACA,eAAeM,GAAO7C,EAAU8C,EAAWP,EAAO,CAE9C,MAAM1G,EAAWiF,GAAYd,EAAS,MAAM,EAC5C7gB,EAAO0c,EAAU,+CAAgD,wBAAyB,CAAE,UAAAiH,CAAW,CAAA,EACvG,KAAM,CAAE,SAAA/K,EAAU,IAAA2K,EAAK,OAAA5I,CAAM,EAAK,MAAMwI,GAAWtC,EAAUuC,CAAK,EAC5D,CAAE,KAAAtS,EAAM,KAAA2S,CAAM,EAAGR,EAAYpC,CAAQ,EAC3C,IAAI+C,EAAMH,EAAK,IAAIF,CAAG,EACtB,GAAI,CAACK,EAAK,CAEN,MAAM9nB,EAAS,CAAE,QADAgV,GAAc+P,EACL,OAAAlG,GACpB9e,EAAY0f,GAAQ,CACtB,IAAIsI,EAAgBjL,EACpB,GAAIiL,GAAiB,KACjB,GAAI,CACAA,EAAgBhD,EAAS,UAAU,SAAStF,EAAI,OAAO,CAAC,CAAC,CAC5D,MACa,CAAG,CAGrB,GAAIsI,EAAe,CACf,MAAMC,EAAiBD,EACjB7kB,GAAO4Z,EAAWiI,EAAS,UAAU,eAAejI,EAAU2C,EAAI,KAAMA,EAAI,MAAM,EAAI,CAAA,EAC5FwI,GAAKlD,EAAUuC,EAAOpkB,GAAOnD,IAClB,IAAIilB,GAAqBD,EAAUhlB,GAAUunB,EAAOU,EAAgBvI,CAAG,CACjF,CACJ,MAEGwI,GAAKlD,EAAUuC,EAAO,CAAE,EAAGvnB,GAChB,IAAI+kB,GAA4BC,EAAUhlB,EAAUunB,EAAO7H,CAAG,CACxE,CAEjB,EACQ,IAAIyI,EAAW,CAAA,EAgBfJ,EAAM,CAAE,IAAAL,EAAK,UAAW,CAAA,EAAI,MAfd,IAAM,CACZS,EAAS,QAGbA,EAAS,KAAKtH,EAAS,GAAG5gB,EAAQD,CAAQ,CAAC,CACvD,EAU2C,KATtB,SAAY,CACrB,GAAImoB,EAAS,QAAU,EACnB,OAEJ,IAAIC,EAAUD,EACdA,EAAW,CAAA,EACX,MAAM,QAAQ,IAAIC,CAAO,EACzBvH,EAAS,IAAI5gB,EAAQD,CAAQ,CACzC,GAEQ4nB,EAAK,IAAIF,EAAKK,CAAG,CACpB,CACD,OAAOA,CACX,CAIA,IAAIM,GAAW,QAAQ,UACvB,eAAeC,GAAMtD,EAAUuC,EAAOpkB,EAAMolB,EAAa,CACrD,MAAMF,GACN,MAAMN,EAAM,MAAMJ,GAAO3C,EAAUuC,CAAK,EACxC,GAAI,CAACQ,EACD,MAAO,GAEX,MAAM1gB,EAAQ0gB,EAAI,UAAU,OAC5B,OAAAA,EAAI,UAAYA,EAAI,UAAU,OAAO,CAAC,CAAE,SAAA/nB,EAAU,KAAAwoB,KAAW,CACzD,MAAMC,EAAW,MAAM,KAAKtlB,CAAI,EAC5BolB,GACAE,EAAS,KAAKF,EAAYC,EAAO,KAAOxoB,CAAQ,CAAC,EAErD,GAAI,CACAA,EAAS,KAAKglB,EAAU,GAAGyD,CAAQ,CACtC,MACa,CAAG,CACjB,MAAO,CAACD,CAChB,CAAK,EACGT,EAAI,UAAU,SAAW,IACzBA,EAAI,KAAI,EACRX,EAAYpC,CAAQ,EAAE,KAAK,OAAO+C,EAAI,GAAG,GAErC1gB,EAAQ,CACpB,CACA,eAAe6gB,GAAKlD,EAAUuC,EAAOpkB,EAAMolB,EAAa,CACpD,GAAI,CACA,MAAMF,EACT,MACa,CAAG,CACjB,MAAMK,EAAgBJ,GAAMtD,EAAUuC,EAAOpkB,EAAMolB,CAAW,EAC9D,OAAAF,GAAWK,EACJ,MAAMA,CACjB,CACA,MAAM9lB,GAAiB,CAAC,MAAM,SACvB,MAAM+lB,GAAN,MAAMA,EAAa,CAsCtB,YAAY9kB,EAAQka,EAAK2H,EAAQkD,EAAW,CA9B5C1oB,EAAA,eAIAA,EAAA,kBAQAA,EAAA,eAIAA,EAAA,gBAIAA,EAAA,KAACoH,IAIDpH,EAAA,iBAOIY,EAAe,OAAQ+C,GAAY,UAAYsN,GAActN,CAAM,EAAG,oCAAqC,SAAUA,CAAM,EACvH6hB,GAAU,OACVA,EAAS,MAEb,MAAMhB,EAAQzE,GAAU,KAAKlC,CAAG,EAChCzd,EAAiB,KAAM,CAAE,OAAAuD,EAAQ,OAAA6hB,EAAQ,UAAWhB,CAAK,CAAE,EAC3D,OAAO,eAAe,KAAM/L,GAAU,CAAE,MAAO,CAAE,CAAA,CAAE,EACnD,IAAIkQ,EACA5T,EAAO,KACP6T,EAAW,KACf,GAAIF,EAAW,CACX,MAAM/H,EAAWiF,GAAYJ,CAAM,EAGnCoD,EAAW,IAAIhE,GAA4B,KAAK,UAAWjE,EAAU+H,CAAS,CACjF,CACD,IAAIhB,EAAO,IAAI,IAEf,GAAI,OAAQ/jB,GAAY,SACpB,GAAIuR,GAAYvR,CAAM,EAClBoR,EAAOpR,EACPglB,EAAc,QAAQ,QAAQhlB,CAAM,MAEnC,CACD,MAAM2N,EAAWmU,GAAUD,EAAQ,aAAa,EAChD,GAAI,CAACL,GAAW7T,CAAQ,EACpB,MAAMiL,GAAU,mDAAoD,wBAAyB,CACzF,UAAW,aACnC,CAAqB,EAELoM,EAAcrX,EAAS,YAAY3N,CAAM,EAAE,KAAMoR,GAAS,CACtD,GAAIA,GAAQ,KACR,MAAMwH,GAAU,sEAAuE,oBAAqB,CACxG,MAAO5Y,CACnC,CAAyB,EAEL,OAAAujB,EAAY,IAAI,EAAE,KAAOnS,EAClBA,CAC3B,CAAiB,CACJ,MAGD4T,EAAchlB,EAAO,WAAY,EAAC,KAAMoR,GAAS,CAC7C,GAAIA,GAAQ,KACR,MAAM,IAAI,MAAM,MAAM,EAE1B,OAAAmS,EAAY,IAAI,EAAE,KAAOnS,EAClBA,CACvB,CAAa,EAGLkS,GAAY,KAAM,CAAE,YAAA0B,EAAa,KAAA5T,EAAM,SAAA6T,EAAU,KAAAlB,CAAI,CAAE,EAEvD,MAAMmB,EAAU,IAAI,MAAM,GAAI,CAC1B,IAAK,CAACllB,EAAQC,EAAMC,IAAa,CAE7B,GAAI,OAAQD,GAAU,UAAYlB,GAAe,QAAQkB,CAAI,GAAK,EAC9D,OAAO,QAAQ,IAAID,EAAQC,EAAMC,CAAQ,EAE7C,GAAI,CACA,OAAO,KAAK,SAASD,CAAI,CAC5B,OACMd,EAAO,CACV,GAAI,CAACwQ,GAAQxQ,EAAO,kBAAkB,GAAKA,EAAM,WAAa,MAC1D,MAAMA,CAEb,CAEJ,EACD,IAAK,CAACa,EAAQC,IAENlB,GAAe,QAAQkB,CAAI,GAAK,EACzB,QAAQ,IAAID,EAAQC,CAAI,EAE5B,QAAQ,IAAID,EAAQC,CAAI,GAAK,KAAK,UAAU,SAAS,OAAOA,CAAI,CAAC,CAExF,CAAS,EACD,OAAAxD,EAAiB,KAAM,CAAE,QAAAyoB,CAAO,CAAE,EAClCzoB,EAAiB,KAAM,CACnB,SAAYokB,EAAM,SAAWA,EAAM,SAAa2B,GAAqB,IAAI,EAAK,IAC1F,CAAS,EAEM,IAAI,MAAM,KAAM,CACnB,IAAK,CAACxiB,EAAQC,EAAMC,IAAa,CAC7B,GAAI,OAAQD,GAAU,UAAYA,KAAQD,GAAUjB,GAAe,QAAQkB,CAAI,GAAK,EAChF,OAAO,QAAQ,IAAID,EAAQC,EAAMC,CAAQ,EAG7C,GAAI,CACA,OAAOF,EAAO,YAAYC,CAAI,CACjC,OACMd,EAAO,CACV,GAAI,CAACwQ,GAAQxQ,EAAO,kBAAkB,GAAKA,EAAM,WAAa,MAC1D,MAAMA,CAEb,CAEJ,EACD,IAAK,CAACa,EAAQC,IACN,OAAQA,GAAU,UAAYA,KAAQD,GAAUjB,GAAe,QAAQkB,CAAI,GAAK,EACzE,QAAQ,IAAID,EAAQC,CAAI,EAE5BD,EAAO,UAAU,YAAYC,CAAI,CAExD,CAAS,CACJ,CAKD,QAAQ4hB,EAAQ,CACZ,OAAO,IAAIiD,GAAa,KAAK,OAAQ,KAAK,UAAWjD,CAAM,CAC9D,CAKD,OAAO7hB,EAAQ,CACX,OAAO,IAAI8kB,GAAa9kB,EAAQ,KAAK,UAAW,KAAK,MAAM,CAC9D,CAID,MAAM,YAAa,CAAE,OAAO,MAAMujB,EAAY,IAAI,EAAE,WAAc,CAIlE,MAAM,iBAAkB,CACpB,MAAMvG,EAAWiF,GAAY,KAAK,MAAM,EACxC3hB,EAAO0c,EAAU,oCAAqC,wBAAyB,CAAE,UAAW,iBAAiB,CAAE,EAC/G,MAAMtE,EAAO,MAAMsE,EAAS,QAAQ,MAAM,KAAK,WAAU,CAAE,EAC3D,OAAItE,IAAS,KACF,KAEJA,CACV,CAKD,MAAM,mBAAoB,CAEtB,MAAMuM,EAAW,KAAK,wBACtB,GAAIA,EACA,aAAMA,EAAS,OACR,KAIX,GADa,MAAM,KAAK,mBACZ,KACR,OAAO,KAGX,MAAMjI,EAAWiF,GAAY,KAAK,MAAM,EACxC,OAAA3hB,EAAO0c,GAAY,KAAM,6CAA8C,wBAAyB,CAAE,UAAW,mBAAmB,CAAE,EAC3H,IAAI,QAAQ,CAACqD,EAASC,IAAW,CACpC,MAAM6E,EAAY,SAAY,CAC1B,GAAI,CAEA,GADa,MAAM,KAAK,mBACZ,KACR,OAAO9E,EAAQ,IAAI,EAEvBrD,EAAS,KAAK,QAASmI,CAAS,CACnC,OACMhmB,EAAO,CACVmhB,EAAOnhB,CAAK,CACf,CACjB,EACYgmB,GACZ,CAAS,CACJ,CAOD,uBAAwB,CACpB,OAAO5B,EAAY,IAAI,EAAE,QAC5B,CAMD,YAAYpiB,EAAK,CACb,OAAI,OAAQA,GAAS,WACjBA,EAAMA,EAAI,UAED8hB,GAAmB,KAAM9hB,CAAG,CAE5C,CAMD,SAASA,EAAK,CACV,OAAI,OAAQA,GAAS,WACjBA,EAAMA,EAAI,UAEPiiB,GAAkB,KAAMjiB,CAAG,CACrC,CAID,MAAM,iBAAiB6C,EAAM,CACzB,MAAM,IAAI,MAAM,OAAO,CAC1B,CAqBD,MAAM,YAAY0f,EAAO0B,EAAWC,EAAS,CACrCD,GAAa,OACbA,EAAY,GAEZC,GAAW,OACXA,EAAU,UAEd,KAAM,CAAE,KAAAjU,EAAM,YAAA4T,CAAa,EAAGzB,EAAY,IAAI,EACxC/W,EAAW4E,GAAe,MAAM4T,EAChC,CAAE,SAAA9L,EAAU,OAAA+B,CAAQ,EAAG,MAAMwI,GAAW,KAAMC,CAAK,EACnDtnB,EAAS,CAAE,QAAAoQ,EAAS,OAAAyO,EAAQ,UAAAmK,EAAW,QAAAC,CAAO,EAC9CrI,EAAWiF,GAAY,KAAK,MAAM,EACxC,OAAA3hB,EAAO0c,EAAU,2CAA4C,wBAAyB,CAAE,UAAW,aAAa,CAAE,GAC1G,MAAMA,EAAS,QAAQ5gB,CAAM,GAAG,IAAKyf,GAAQ,CACjD,IAAIsI,EAAgBjL,EACpB,GAAIiL,GAAiB,KACjB,GAAI,CACAA,EAAgB,KAAK,UAAU,SAAStI,EAAI,OAAO,CAAC,CAAC,CACxD,MACa,CAAG,CAErB,GAAIsI,EACA,GAAI,CACA,OAAO,IAAIvD,GAAS/E,EAAK,KAAK,UAAWsI,CAAa,CACzD,OACMhlB,EAAO,CACV,OAAO,IAAI2hB,GAAkBjF,EAAK1c,CAAK,CAC1C,CAEL,OAAO,IAAIif,GAAIvC,EAAKmB,CAAQ,CACxC,CAAS,CACJ,CAID,MAAM,GAAG0G,EAAOvnB,EAAU,CACtB,MAAM+nB,EAAM,MAAMF,GAAO,KAAM,KAAMN,CAAK,EAC1C,OAAAQ,EAAI,UAAU,KAAK,CAAE,SAAA/nB,EAAU,KAAM,EAAK,CAAE,EAC5C+nB,EAAI,MAAK,EACF,IACV,CAKD,MAAM,KAAKR,EAAOvnB,EAAU,CACxB,MAAM+nB,EAAM,MAAMF,GAAO,KAAM,OAAQN,CAAK,EAC5C,OAAAQ,EAAI,UAAU,KAAK,CAAE,SAAA/nB,EAAU,KAAM,EAAI,CAAE,EAC3C+nB,EAAI,MAAK,EACF,IACV,CAMD,MAAM,KAAKR,KAAUpkB,EAAM,CACvB,OAAO,MAAM+kB,GAAK,KAAMX,EAAOpkB,EAAM,IAAI,CAC5C,CAKD,MAAM,cAAcokB,EAAO,CACvB,GAAIA,EAAO,CACP,MAAMQ,EAAM,MAAMJ,GAAO,KAAMJ,CAAK,EACpC,OAAKQ,EAGEA,EAAI,UAAU,OAFV,CAGd,CACD,KAAM,CAAE,KAAAH,CAAI,EAAKR,EAAY,IAAI,EACjC,IAAI+B,EAAQ,EACZ,SAAW,CAAE,UAAAC,CAAS,IAAMxB,EAAK,OAAM,EACnCuB,GAASC,EAAU,OAEvB,OAAOD,CACV,CAKD,MAAM,UAAU5B,EAAO,CACnB,GAAIA,EAAO,CACP,MAAMQ,EAAM,MAAMJ,GAAO,KAAMJ,CAAK,EACpC,OAAKQ,EAGEA,EAAI,UAAU,IAAI,CAAC,CAAE,SAAA/nB,CAAQ,IAAOA,CAAQ,EAFxC,EAGd,CACD,KAAM,CAAE,KAAA4nB,CAAI,EAAKR,EAAY,IAAI,EACjC,IAAI7lB,EAAS,CAAA,EACb,SAAW,CAAE,UAAA6nB,CAAS,IAAMxB,EAAK,OAAM,EACnCrmB,EAASA,EAAO,OAAO6nB,EAAU,IAAI,CAAC,CAAE,SAAAppB,CAAQ,IAAOA,CAAQ,CAAC,EAEpE,OAAOuB,CACV,CAKD,MAAM,IAAIgmB,EAAOvnB,EAAU,CACvB,MAAM+nB,EAAM,MAAMJ,GAAO,KAAMJ,CAAK,EACpC,GAAI,CAACQ,EACD,OAAO,KAEX,GAAI/nB,EAAU,CACV,MAAM0D,EAAQqkB,EAAI,UAAU,IAAI,CAAC,CAAE,SAAA/nB,CAAQ,IAAOA,CAAQ,EAAE,QAAQA,CAAQ,EACxE0D,GAAS,GACTqkB,EAAI,UAAU,OAAOrkB,EAAO,CAAC,CAEpC,CACD,OAAI1D,GAAY,MAAQ+nB,EAAI,UAAU,SAAW,KAC7CA,EAAI,KAAI,EACRX,EAAY,IAAI,EAAE,KAAK,OAAOW,EAAI,GAAG,GAElC,IACV,CAKD,MAAM,mBAAmBR,EAAO,CAC5B,GAAIA,EAAO,CACP,MAAMQ,EAAM,MAAMJ,GAAO,KAAMJ,CAAK,EACpC,GAAI,CAACQ,EACD,OAAO,KAEXA,EAAI,KAAI,EACRX,EAAY,IAAI,EAAE,KAAK,OAAOW,EAAI,GAAG,CACxC,KACI,CACD,KAAM,CAAE,KAAAH,CAAI,EAAKR,EAAY,IAAI,EACjC,SAAW,CAAE,IAAAM,EAAK,KAAA2B,CAAM,IAAIzB,EAAK,OAAM,EACnCyB,IACAzB,EAAK,OAAOF,CAAG,CAEtB,CACD,OAAO,IACV,CAID,MAAM,YAAYH,EAAOvnB,EAAU,CAC/B,OAAO,MAAM,KAAK,GAAGunB,EAAOvnB,CAAQ,CACvC,CAID,MAAM,eAAeunB,EAAOvnB,EAAU,CAClC,OAAO,MAAM,KAAK,IAAIunB,EAAOvnB,CAAQ,CACxC,CAID,OAAO,WAAW+d,EAAK,CACnB,MAAMuL,UAAuBX,EAAa,CACtC,YAAYtY,EAASqV,EAAS,KAAM,CAChC,MAAMrV,EAAS0N,EAAK2H,CAAM,CAC7B,CACJ,CACD,OAAO4D,CACV,CAKD,OAAO,KAAKzlB,EAAQka,EAAK2H,EAAQ,CAC7B,OAAIA,GAAU,OACVA,EAAS,MAEI,IAAI,KAAK7hB,EAAQka,EAAK2H,CAAM,CAEhD,CACL,EA9ZKpe,GAAAqR,GA5BE,IAAM4Q,GAANZ,GA2bP,SAASa,IAAgB,CACrB,OAAOD,EACX,CAIO,MAAME,WAAiBD,GAAa,CAAG,CAC9C","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29]}