gaussian-splat-lite 0.1.11 → 0.1.13

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.13] - 2026-08-31
+
+### Added
+
+- Added `tan`, `asin`, `atan`, and vector-aware `atan2(y, x)` operations to the experimental post-decode expression API.
+
+## [0.1.12] - 2026-08-31
+
+### Changed
+
+- Short-circuited arbitrary nested post-decode `when` expressions per worker block, routing only matching Splats through each AND/OR/NOT branch and compacting survivors before evaluating patch outputs.
+- Reworked post-decode flow compilation with logical constant folding, iterative condition traversal, and reusable generation-based register maps, avoiding call-stack limits and repeated register-map allocation for deeply nested or shared condition graphs.
+- Reduced post-decode condition-flow compilation scratch memory by allocating its traversal stack only for logical branches, storing only pending AND/OR continuations, and remapping emitted flow nodes directly without reachability or ordering passes.
+- Enforced fixed 4096-instruction and 4096-flow-node post-decode limits, rejecting oversized programs instead of falling back to eager condition evaluation.
+- Specialized post-decode unary, binary, ordered-comparison, and vector-construction block loops so opcode and vector-width dispatch no longer runs once per Splat.
+- Reduced decode-worker setup and execution overhead with packed `Uint16Array` bytecode, stage-indexed register carry events, precomputed instruction and output-write plans, and field-major patch and spherical-harmonic writeback.
+
 ## [0.1.11] - 2026-08-30
 
 ### Changed
@@ -144,7 +161,9 @@ and this project follows [Semantic Versioning](https://semver.org/).
 
 - Initial public release of the Three.js Gaussian Splatting renderer.
 
-[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.11...HEAD
+[Unreleased]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.13...HEAD
+[0.1.13]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.12...v0.1.13
+[0.1.12]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.11...v0.1.12
 [0.1.11]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.10...v0.1.11
 [0.1.10]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.9...v0.1.10
 [0.1.9]: https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite/compare/v0.1.8...v0.1.9

package/README.md

@@ -147,8 +147,9 @@ const splat = new SplatMesh({
 });
 ```
 
-Decoded values can be transformed in the worker with a serializable, per-Splat
-expression. The library continues to own packed arrays and encoding:
+**`Experimental`** Decoded values can be transformed in the worker with a
+serializable, per-Splat expression. The library continues to own packed arrays
+and encoding:
 
 ```js
 import { postDecode } from "gaussian-splat-lite";
@@ -201,7 +202,7 @@ await splat.initialized;
 | [`SplatEdit`](docs/SplatEdit.md) / [`SplatEditSdf`](docs/SplatEdit.md) | SDF-region RGBA editing objects |
 | [`SplatAccumulator`](docs/SplatAccumulator.md) | A low-level generation buffer used by the renderer; normally internal |
 | [`SplatFileType`](docs/SplatFileType.md) | File type enum containing `PLY` and `SPZ` |
-| [`postDecode`](docs/PostDecode.md) | Serializable per-Splat expressions executed inside the decode worker |
+| [`postDecode`](docs/PostDecode.md) | **`Experimental`** Serializable per-Splat expressions executed inside the decode worker |
 
 ## Large world coordinates / GIS / ECEF
 

package/dist/assets/worker-C26a7h-J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-C26a7h-J.js","sources":["../rust/gaussian-splat-rs/pkg/gaussian_splat_rs.js","../src/float16.ts","../src/postDecode.ts","../src/splatCodec.ts","../src/postDecodeRuntime.ts","../src/transferable.ts","../src/worker.ts"],"sourcesContent":["/* @ts-self-types=\"./gaussian_splat_rs.d.ts\" */\n\nexport class ChunkDecoder {\n    static __wrap(ptr) {\n        ptr = ptr >>> 0;\n        const obj = Object.create(ChunkDecoder.prototype);\n        obj.__wbg_ptr = ptr;\n        ChunkDecoderFinalization.register(obj, obj.__wbg_ptr, obj);\n        return obj;\n    }\n    __destroy_into_raw() {\n        const ptr = this.__wbg_ptr;\n        this.__wbg_ptr = 0;\n        ChunkDecoderFinalization.unregister(this);\n        return ptr;\n    }\n    free() {\n        const ptr = this.__destroy_into_raw();\n        wasm.__wbg_chunkdecoder_free(ptr, 0);\n    }\n    /**\n     * @returns {any}\n     */\n    finish() {\n        const ptr = this.__destroy_into_raw();\n        const ret = wasm.chunkdecoder_finish(ptr);\n        if (ret[2]) {\n            throw takeFromExternrefTable0(ret[1]);\n        }\n        return takeFromExternrefTable0(ret[0]);\n    }\n    /**\n     * @param {Uint8Array} bytes\n     */\n    push(bytes) {\n        const ret = wasm.chunkdecoder_push(this.__wbg_ptr, bytes);\n        if (ret[1]) {\n            throw takeFromExternrefTable0(ret[0]);\n        }\n    }\n    /**\n     * @param {number} size\n     */\n    set_expected_input_size(size) {\n        const ret = wasm.chunkdecoder_set_expected_input_size(this.__wbg_ptr, size);\n        if (ret[1]) {\n            throw takeFromExternrefTable0(ret[0]);\n        }\n    }\n}\nif (Symbol.dispose) ChunkDecoder.prototype[Symbol.dispose] = ChunkDecoder.prototype.free;\n\n/**\n * @param {string | null} [file_type]\n * @param {string | null} [path_name]\n * @returns {ChunkDecoder}\n */\nexport function decode_to_splats(file_type, path_name) {\n    var ptr0 = isLikeNone(file_type) ? 0 : passStringToWasm0(file_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);\n    var len0 = WASM_VECTOR_LEN;\n    var ptr1 = isLikeNone(path_name) ? 0 : passStringToWasm0(path_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);\n    var len1 = WASM_VECTOR_LEN;\n    const ret = wasm.decode_to_splats(ptr0, len0, ptr1, len1);\n    if (ret[2]) {\n        throw takeFromExternrefTable0(ret[1]);\n    }\n    return ChunkDecoder.__wrap(ret[0]);\n}\n\n/**\n * @returns {Uint32Array}\n */\nexport function get_raycast_buffer() {\n    const ret = wasm.get_raycast_buffer();\n    return ret;\n}\n\n/**\n * @returns {Uint32Array}\n */\nexport function get_raycast_buffer2() {\n    const ret = wasm.get_raycast_buffer2();\n    return ret;\n}\n\n/**\n * @param {number} origin_x\n * @param {number} origin_y\n * @param {number} origin_z\n * @param {number} dir_x\n * @param {number} dir_y\n * @param {number} dir_z\n * @param {number} min_opacity\n * @param {number} near\n * @param {number} far\n * @param {number} count\n * @returns {Float32Array}\n */\nexport function raycast_splat_buffers(origin_x, origin_y, origin_z, dir_x, dir_y, dir_z, min_opacity, near, far, count) {\n    const ret = wasm.raycast_splat_buffers(origin_x, origin_y, origin_z, dir_x, dir_y, dir_z, min_opacity, near, far, count);\n    return ret;\n}\n\n/**\n * @param {Uint32Array} center_update_range_indices\n * @param {Float32Array} update_centers\n * @param {Uint32Array} matrix_update_range_indices\n * @param {Float64Array} update_matrices\n * @param {Uint32Array} range_mesh_ids\n * @param {Uint32Array} range_bases\n * @param {Uint32Array} range_counts\n */\nexport function set_sort_center_state(center_update_range_indices, update_centers, matrix_update_range_indices, update_matrices, range_mesh_ids, range_bases, range_counts) {\n    wasm.set_sort_center_state(center_update_range_indices, update_centers, matrix_update_range_indices, update_matrices, range_mesh_ids, range_bases, range_counts);\n}\n\n/**\n * @param {number} num_splats\n * @param {number} camera_x\n * @param {number} camera_y\n * @param {number} camera_z\n * @param {number} direction_x\n * @param {number} direction_y\n * @param {number} direction_z\n * @param {boolean} radial\n * @param {Uint32Array} ordering\n * @returns {number}\n */\nexport function sort32_centers(num_splats, camera_x, camera_y, camera_z, direction_x, direction_y, direction_z, radial, ordering) {\n    const ret = wasm.sort32_centers(num_splats, camera_x, camera_y, camera_z, direction_x, direction_y, direction_z, radial, ordering);\n    return ret >>> 0;\n}\n\nexport function wasm_start() {\n    wasm.wasm_start();\n}\n\nfunction __wbg_get_imports() {\n    const import0 = {\n        __proto__: null,\n        __wbg___wbindgen_debug_string_dd5d2d07ce9e6c57: function(arg0, arg1) {\n            const ret = debugString(arg1);\n            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);\n            const len1 = WASM_VECTOR_LEN;\n            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);\n            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);\n        },\n        __wbg___wbindgen_throw_81fc77679af83bc6: function(arg0, arg1) {\n            throw new Error(getStringFromWasm0(arg0, arg1));\n        },\n        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {\n            let deferred0_0;\n            let deferred0_1;\n            try {\n                deferred0_0 = arg0;\n                deferred0_1 = arg1;\n                console.error(getStringFromWasm0(arg0, arg1));\n            } finally {\n                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);\n            }\n        },\n        __wbg_get_index_983d655608220248: function(arg0, arg1) {\n            const ret = arg0[arg1 >>> 0];\n            return ret;\n        },\n        __wbg_length_0c32cb8543c8e4c8: function(arg0) {\n            const ret = arg0.length;\n            return ret;\n        },\n        __wbg_length_1e701798fdcaa3b4: function(arg0) {\n            const ret = arg0.length;\n            return ret;\n        },\n        __wbg_length_526c0f6e4ebae15d: function(arg0) {\n            const ret = arg0.length;\n            return ret;\n        },\n        __wbg_length_fd4646b401926788: function(arg0) {\n            const ret = arg0.length;\n            return ret;\n        },\n        __wbg_new_227d7c05414eb861: function() {\n            const ret = new Error();\n            return ret;\n        },\n        __wbg_new_4f9fafbb3909af72: function() {\n            const ret = new Object();\n            return ret;\n        },\n        __wbg_new_with_length_26bffbe236bf73f9: function(arg0) {\n            const ret = new Float32Array(arg0 >>> 0);\n            return ret;\n        },\n        __wbg_new_with_length_41a22191b9bdfd66: function(arg0) {\n            const ret = new Uint32Array(arg0 >>> 0);\n            return ret;\n        },\n        __wbg_prototypesetcall_021fd89d67217368: function(arg0, arg1, arg2) {\n            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);\n        },\n        __wbg_prototypesetcall_3e05eb9545565046: function(arg0, arg1, arg2) {\n            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);\n        },\n        __wbg_prototypesetcall_66c8e1fb820946be: function(arg0, arg1, arg2) {\n            Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);\n        },\n        __wbg_prototypesetcall_e42275e601e14eeb: function(arg0, arg1, arg2) {\n            Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);\n        },\n        __wbg_set_448126769bf7c181: function(arg0, arg1, arg2) {\n            arg0.set(getArrayU32FromWasm0(arg1, arg2));\n        },\n        __wbg_set_8ee2d34facb8466e: function() { return handleError(function (arg0, arg1, arg2) {\n            const ret = Reflect.set(arg0, arg1, arg2);\n            return ret;\n        }, arguments); },\n        __wbg_set_a98c8da6557e63de: function(arg0, arg1, arg2) {\n            arg0.set(getArrayF32FromWasm0(arg1, arg2));\n        },\n        __wbg_set_index_a561936dd7004b5a: function(arg0, arg1, arg2) {\n            arg0[arg1 >>> 0] = arg2;\n        },\n        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {\n            const ret = arg1.stack;\n            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);\n            const len1 = WASM_VECTOR_LEN;\n            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);\n            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);\n        },\n        __wbg_subarray_0f98d3fb634508ad: function(arg0, arg1, arg2) {\n            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);\n            return ret;\n        },\n        __wbg_subarray_1230568a23d546e8: function(arg0, arg1, arg2) {\n            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);\n            return ret;\n        },\n        __wbg_subarray_4342405c1ffc86d6: function(arg0, arg1, arg2) {\n            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);\n            return ret;\n        },\n        __wbg_subarray_d51e89458b3fdbf6: function(arg0, arg1, arg2) {\n            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);\n            return ret;\n        },\n        __wbindgen_cast_0000000000000001: function(arg0) {\n            // Cast intrinsic for `F64 -> Externref`.\n            const ret = arg0;\n            return ret;\n        },\n        __wbindgen_cast_0000000000000002: function(arg0, arg1) {\n            // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref(\"Float32Array\")`.\n            const ret = getArrayF32FromWasm0(arg0, arg1);\n            return ret;\n        },\n        __wbindgen_cast_0000000000000003: function(arg0, arg1) {\n            // Cast intrinsic for `Ref(Slice(U32)) -> NamedExternref(\"Uint32Array\")`.\n            const ret = getArrayU32FromWasm0(arg0, arg1);\n            return ret;\n        },\n        __wbindgen_cast_0000000000000004: function(arg0, arg1) {\n            // Cast intrinsic for `Ref(String) -> Externref`.\n            const ret = getStringFromWasm0(arg0, arg1);\n            return ret;\n        },\n        __wbindgen_init_externref_table: function() {\n            const table = wasm.__wbindgen_externrefs;\n            const offset = table.grow(4);\n            table.set(0, undefined);\n            table.set(offset + 0, undefined);\n            table.set(offset + 1, null);\n            table.set(offset + 2, true);\n            table.set(offset + 3, false);\n        },\n    };\n    return {\n        __proto__: null,\n        \"./gaussian_splat_rs_bg.js\": import0,\n    };\n}\n\nconst ChunkDecoderFinalization = (typeof FinalizationRegistry === 'undefined')\n    ? { register: () => {}, unregister: () => {} }\n    : new FinalizationRegistry(ptr => wasm.__wbg_chunkdecoder_free(ptr >>> 0, 1));\n\nfunction addToExternrefTable0(obj) {\n    const idx = wasm.__externref_table_alloc();\n    wasm.__wbindgen_externrefs.set(idx, obj);\n    return idx;\n}\n\nfunction debugString(val) {\n    // primitive types\n    const type = typeof val;\n    if (type == 'number' || type == 'boolean' || val == null) {\n        return  `${val}`;\n    }\n    if (type == 'string') {\n        return `\"${val}\"`;\n    }\n    if (type == 'symbol') {\n        const description = val.description;\n        if (description == null) {\n            return 'Symbol';\n        } else {\n            return `Symbol(${description})`;\n        }\n    }\n    if (type == 'function') {\n        const name = val.name;\n        if (typeof name == 'string' && name.length > 0) {\n            return `Function(${name})`;\n        } else {\n            return 'Function';\n        }\n    }\n    // objects\n    if (Array.isArray(val)) {\n        const length = val.length;\n        let debug = '[';\n        if (length > 0) {\n            debug += debugString(val[0]);\n        }\n        for(let i = 1; i < length; i++) {\n            debug += ', ' + debugString(val[i]);\n        }\n        debug += ']';\n        return debug;\n    }\n    // Test for built-in\n    const builtInMatches = /\\[object ([^\\]]+)\\]/.exec(toString.call(val));\n    let className;\n    if (builtInMatches && builtInMatches.length > 1) {\n        className = builtInMatches[1];\n    } else {\n        // Failed to match the standard '[object ClassName]'\n        return toString.call(val);\n    }\n    if (className == 'Object') {\n        // we're a user defined class or Object\n        // JSON.stringify avoids problems with cycles, and is generally much\n        // easier than looping through ownProperties of `val`.\n        try {\n            return 'Object(' + JSON.stringify(val) + ')';\n        } catch (_) {\n            return 'Object';\n        }\n    }\n    // errors\n    if (val instanceof Error) {\n        return `${val.name}: ${val.message}\\n${val.stack}`;\n    }\n    // TODO we could test for more things here, like `Set`s and `Map`s.\n    return className;\n}\n\nfunction getArrayF32FromWasm0(ptr, len) {\n    ptr = ptr >>> 0;\n    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);\n}\n\nfunction getArrayF64FromWasm0(ptr, len) {\n    ptr = ptr >>> 0;\n    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);\n}\n\nfunction getArrayU32FromWasm0(ptr, len) {\n    ptr = ptr >>> 0;\n    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);\n}\n\nfunction getArrayU8FromWasm0(ptr, len) {\n    ptr = ptr >>> 0;\n    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);\n}\n\nlet cachedDataViewMemory0 = null;\nfunction getDataViewMemory0() {\n    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {\n        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);\n    }\n    return cachedDataViewMemory0;\n}\n\nlet cachedFloat32ArrayMemory0 = null;\nfunction getFloat32ArrayMemory0() {\n    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {\n        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);\n    }\n    return cachedFloat32ArrayMemory0;\n}\n\nlet cachedFloat64ArrayMemory0 = null;\nfunction getFloat64ArrayMemory0() {\n    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {\n        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);\n    }\n    return cachedFloat64ArrayMemory0;\n}\n\nfunction getStringFromWasm0(ptr, len) {\n    ptr = ptr >>> 0;\n    return decodeText(ptr, len);\n}\n\nlet cachedUint32ArrayMemory0 = null;\nfunction getUint32ArrayMemory0() {\n    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {\n        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);\n    }\n    return cachedUint32ArrayMemory0;\n}\n\nlet cachedUint8ArrayMemory0 = null;\nfunction getUint8ArrayMemory0() {\n    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {\n        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);\n    }\n    return cachedUint8ArrayMemory0;\n}\n\nfunction handleError(f, args) {\n    try {\n        return f.apply(this, args);\n    } catch (e) {\n        const idx = addToExternrefTable0(e);\n        wasm.__wbindgen_exn_store(idx);\n    }\n}\n\nfunction isLikeNone(x) {\n    return x === undefined || x === null;\n}\n\nfunction passStringToWasm0(arg, malloc, realloc) {\n    if (realloc === undefined) {\n        const buf = cachedTextEncoder.encode(arg);\n        const ptr = malloc(buf.length, 1) >>> 0;\n        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);\n        WASM_VECTOR_LEN = buf.length;\n        return ptr;\n    }\n\n    let len = arg.length;\n    let ptr = malloc(len, 1) >>> 0;\n\n    const mem = getUint8ArrayMemory0();\n\n    let offset = 0;\n\n    for (; offset < len; offset++) {\n        const code = arg.charCodeAt(offset);\n        if (code > 0x7F) break;\n        mem[ptr + offset] = code;\n    }\n    if (offset !== len) {\n        if (offset !== 0) {\n            arg = arg.slice(offset);\n        }\n        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;\n        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);\n        const ret = cachedTextEncoder.encodeInto(arg, view);\n\n        offset += ret.written;\n        ptr = realloc(ptr, len, offset, 1) >>> 0;\n    }\n\n    WASM_VECTOR_LEN = offset;\n    return ptr;\n}\n\nfunction takeFromExternrefTable0(idx) {\n    const value = wasm.__wbindgen_externrefs.get(idx);\n    wasm.__externref_table_dealloc(idx);\n    return value;\n}\n\nlet cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });\ncachedTextDecoder.decode();\nconst MAX_SAFARI_DECODE_BYTES = 2146435072;\nlet numBytesDecoded = 0;\nfunction decodeText(ptr, len) {\n    numBytesDecoded += len;\n    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {\n        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });\n        cachedTextDecoder.decode();\n        numBytesDecoded = len;\n    }\n    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));\n}\n\nconst cachedTextEncoder = new TextEncoder();\n\nif (!('encodeInto' in cachedTextEncoder)) {\n    cachedTextEncoder.encodeInto = function (arg, view) {\n        const buf = cachedTextEncoder.encode(arg);\n        view.set(buf);\n        return {\n            read: arg.length,\n            written: buf.length\n        };\n    };\n}\n\nlet WASM_VECTOR_LEN = 0;\n\nlet wasmModule, wasm;\nfunction __wbg_finalize_init(instance, module) {\n    wasm = instance.exports;\n    wasmModule = module;\n    cachedDataViewMemory0 = null;\n    cachedFloat32ArrayMemory0 = null;\n    cachedFloat64ArrayMemory0 = null;\n    cachedUint32ArrayMemory0 = null;\n    cachedUint8ArrayMemory0 = null;\n    wasm.__wbindgen_start();\n    return wasm;\n}\n\nasync function __wbg_load(module, imports) {\n    if (typeof Response === 'function' && module instanceof Response) {\n        if (typeof WebAssembly.instantiateStreaming === 'function') {\n            try {\n                return await WebAssembly.instantiateStreaming(module, imports);\n            } catch (e) {\n                const validResponse = module.ok && expectedResponseType(module.type);\n\n                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {\n                    console.warn(\"`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n\", e);\n\n                } else { throw e; }\n            }\n        }\n\n        const bytes = await module.arrayBuffer();\n        return await WebAssembly.instantiate(bytes, imports);\n    } else {\n        const instance = await WebAssembly.instantiate(module, imports);\n\n        if (instance instanceof WebAssembly.Instance) {\n            return { instance, module };\n        } else {\n            return instance;\n        }\n    }\n\n    function expectedResponseType(type) {\n        switch (type) {\n            case 'basic': case 'cors': case 'default': return true;\n        }\n        return false;\n    }\n}\n\nfunction initSync(module) {\n    if (wasm !== undefined) return wasm;\n\n\n    if (module !== undefined) {\n        if (Object.getPrototypeOf(module) === Object.prototype) {\n            ({module} = module)\n        } else {\n            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')\n        }\n    }\n\n    const imports = __wbg_get_imports();\n    if (!(module instanceof WebAssembly.Module)) {\n        module = new WebAssembly.Module(module);\n    }\n    const instance = new WebAssembly.Instance(module, imports);\n    return __wbg_finalize_init(instance, module);\n}\n\nasync function __wbg_init(module_or_path) {\n    if (wasm !== undefined) return wasm;\n\n\n    if (module_or_path !== undefined) {\n        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {\n            ({module_or_path} = module_or_path)\n        } else {\n            console.warn('using deprecated parameters for the initialization function; pass a single object instead')\n        }\n    }\n\n\n    const imports = __wbg_get_imports();\n\n    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {\n        module_or_path = fetch(module_or_path);\n    }\n\n    const { instance, module } = await __wbg_load(await module_or_path, imports);\n\n    return __wbg_finalize_init(instance, module);\n}\n\nexport { initSync, __wbg_init as default };\n","const f32 = new Float32Array(1);\nconst u32 = new Uint32Array(f32.buffer);\nconst supportsFloat16Array = \"Float16Array\" in globalThis;\nconst f16 = supportsFloat16Array\n  ? new globalThis[\"Float16Array\" as keyof typeof globalThis](1)\n  : null;\nconst u16 = new Uint16Array(f16?.buffer);\n\nfunction toHalfNative(value: number): number {\n  f16[0] = value;\n  return u16[0];\n}\n\nfunction toHalfJs(value: number): number {\n  f32[0] = value;\n  const bits = u32[0];\n  const sign = (bits >>> 16) & 0x8000;\n  const exponent = (bits >>> 23) & 0xff;\n  const fraction = bits & 0x7f_ffff;\n\n  if (exponent === 0xff) {\n    return sign | (fraction === 0 ? 0x7c00 : 0x7fff);\n  }\n\n  const halfExponent = exponent - 127 + 15;\n  if (halfExponent >= 0x1f) return sign | 0x7c00;\n  if (halfExponent <= 0) {\n    if (halfExponent < -10) return sign;\n    return sign | ((fraction | 0x80_0000) >>> (1 - halfExponent + 13));\n  }\n  return sign | (halfExponent << 10) | (fraction >>> 13);\n}\n\nfunction fromHalfNative(value: number): number {\n  u16[0] = value;\n  return f16[0];\n}\n\nfunction fromHalfJs(value: number): number {\n  const sign = (value >>> 15) & 1;\n  const exponent = (value >>> 10) & 0x1f;\n  const fraction = value & 0x3ff;\n  let bits: number;\n\n  if (exponent === 0) {\n    if (fraction === 0) {\n      bits = sign << 31;\n    } else {\n      let mantissa = fraction;\n      let adjustedExponent = -14;\n      while ((mantissa & 0x400) === 0) {\n        mantissa <<= 1;\n        adjustedExponent -= 1;\n      }\n      bits =\n        (sign << 31) |\n        ((adjustedExponent + 127) << 23) |\n        ((mantissa & 0x3ff) << 13);\n    }\n  } else if (exponent === 0x1f) {\n    bits = (sign << 31) | (fraction === 0 ? 0x7f80_0000 : 0x7fc0_0000);\n  } else {\n    bits = (sign << 31) | ((exponent - 15 + 127) << 23) | (fraction << 13);\n  }\n\n  u32[0] = bits;\n  return f32[0];\n}\n\nexport const toHalf = supportsFloat16Array ? toHalfNative : toHalfJs;\nexport const fromHalf = supportsFloat16Array ? fromHalfNative : fromHalfJs;\n","/** @internal */\nexport enum Opcode {\n  Constant = 1,\n  InputField = 2,\n  InputAttribute = 3,\n  Negate = 10,\n  Abs = 11,\n  Sqrt = 12,\n  Log = 13,\n  Exp = 14,\n  Floor = 15,\n  Ceil = 16,\n  Round = 17,\n  Normalize = 18,\n  Length = 19,\n  IsFinite = 20,\n  Not = 22,\n  Sin = 23,\n  Cos = 24,\n  Acos = 25,\n  Tan = 26,\n  Asin = 27,\n  Atan = 28,\n  Add = 30,\n  Subtract = 31,\n  Multiply = 32,\n  Divide = 33,\n  Min = 34,\n  Max = 35,\n  Pow = 36,\n  Dot = 37,\n  Cross = 38,\n  Equal = 39,\n  NotEqual = 40,\n  Less = 41,\n  LessEqual = 42,\n  Greater = 43,\n  GreaterEqual = 44,\n  And = 45,\n  Or = 46,\n  QuaternionMultiply = 47,\n  RotateVector = 48,\n  Atan2 = 49,\n  Select = 60,\n  Clamp = 61,\n  Mix = 62,\n  Vec2 = 70,\n  Vec3 = 71,\n  Vec4 = 72,\n  Component = 74,\n  MaxComponentIndex = 75,\n}\n\n/** @internal */\nexport enum InputField {\n  Position = 1,\n  Scale = 2,\n  Quaternion = 3,\n  Opacity = 4,\n  Alpha = 5,\n  Color = 6,\n  Sh0 = 7,\n}\n\n/** @internal */\nexport const SH_COEFFICIENT_COUNT = 15;\n\n/** @internal */\nexport type SplatPostDecodeValueType =\n  | \"float\"\n  | \"bool\"\n  | \"vec2\"\n  | \"vec3\"\n  | \"vec4\"\n  | \"quaternion\";\n\ntype NumericValueType = \"float\" | \"vec2\" | \"vec3\" | \"vec4\";\ntype VectorValueType = \"vec2\" | \"vec3\" | \"vec4\";\n\n/** @internal */\nexport const TYPE_WIDTHS: Record<SplatPostDecodeValueType, number> = {\n  float: 1,\n  bool: 1,\n  vec2: 2,\n  vec3: 3,\n  vec4: 4,\n  quaternion: 4,\n};\n\nclass SplatPostDecodeValue<T extends SplatPostDecodeValueType> {\n  /** @internal */\n  constructor(\n    readonly type: T,\n    /** @internal */ readonly register: number,\n    /** @internal */ readonly owner: ProgramBuilder,\n  ) {}\n}\n\ntype FloatValue = SplatPostDecodeValue<\"float\">;\ntype BoolValue = SplatPostDecodeValue<\"bool\">;\ntype Vec2Value = SplatPostDecodeValue<\"vec2\">;\ntype Vec3Value = SplatPostDecodeValue<\"vec3\">;\ntype Vec4Value = SplatPostDecodeValue<\"vec4\">;\ntype QuaternionValue = SplatPostDecodeValue<\"quaternion\">;\ntype FloatLike = number | FloatValue;\ntype BoolLike = boolean | BoolValue;\ntype Vec2Literal = readonly [number, number];\ntype Vec3Literal = readonly [number, number, number];\ntype Vec4Literal = readonly [number, number, number, number];\ntype Vec2Like = Vec2Literal | Vec2Value;\ntype Vec3Like = Vec3Literal | Vec3Value;\ntype Vec4Like = Vec4Literal | Vec4Value;\ntype QuaternionLike = Vec4Literal | QuaternionValue;\n\ntype LiteralFor<T extends SplatPostDecodeValueType> = T extends \"float\"\n  ? number\n  : T extends \"bool\"\n    ? boolean\n    : T extends \"vec2\"\n      ? Vec2Literal\n      : T extends \"vec3\"\n        ? Vec3Literal\n        : Vec4Literal;\ntype ValueLike<T extends SplatPostDecodeValueType> =\n  | LiteralFor<T>\n  | SplatPostDecodeValue<T>;\ntype AnyValueLike = ValueLike<SplatPostDecodeValueType>;\ntype BroadcastLike<T extends NumericValueType> = ValueLike<T> | FloatLike;\n\n/** @internal */\nexport type SplatPostDecodeInstruction = {\n  opcode: Opcode;\n  type: SplatPostDecodeValueType;\n  args: readonly number[];\n  immediate: number;\n};\n\n/** @internal */\nexport const SPLAT_POST_DECODE_INSTRUCTION_OPCODE = 0;\n/** @internal */\nexport const SPLAT_POST_DECODE_INSTRUCTION_WIDTH = 1;\n/** @internal */\nexport const SPLAT_POST_DECODE_INSTRUCTION_IMMEDIATE = 2;\n/** @internal */\nexport const SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_0 = 3;\n/** @internal */\nexport const SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_COUNT = 4;\n/** @internal */\nexport const SPLAT_POST_DECODE_INSTRUCTION_STRIDE = 7;\n/** @internal */\nexport const SPLAT_POST_DECODE_MISSING_ARGUMENT = 0xffff;\n\n/** @internal */\nexport type SplatPostDecodeAttributeFormat =\n  | \"f32\"\n  | \"f16\"\n  | \"u8\"\n  | \"unorm8\"\n  | \"i8\"\n  | \"snorm8\"\n  | \"u16\"\n  | \"unorm16\"\n  | \"i16\"\n  | \"snorm16\"\n  | \"u32\"\n  | \"i32\";\n\n/** @internal */\nexport const ATTRIBUTE_FORMAT_BYTES: Record<\n  SplatPostDecodeAttributeFormat,\n  number\n> = {\n  f32: 4,\n  f16: 2,\n  u8: 1,\n  unorm8: 1,\n  i8: 1,\n  snorm8: 1,\n  u16: 2,\n  unorm16: 2,\n  i16: 2,\n  snorm16: 2,\n  u32: 4,\n  i32: 4,\n};\n\ntype AttributeComponents = 1 | 2 | 3 | 4;\ntype SplatPostDecodeAttributeOptions<\n  Components extends AttributeComponents = 1,\n> = {\n  data: ArrayBufferView;\n  format: SplatPostDecodeAttributeFormat;\n  count: number;\n  components?: Components;\n  /** Byte offset relative to the supplied data view. */\n  byteOffset?: number;\n  byteStride?: number;\n};\ntype AttributeValue<Components extends AttributeComponents> =\n  Components extends 1\n    ? FloatValue\n    : Components extends 2\n      ? Vec2Value\n      : Components extends 3\n        ? Vec3Value\n        : Vec4Value;\ntype AttributeBinding = {\n  data: ArrayBufferView;\n  format: SplatPostDecodeAttributeFormat;\n  count: number;\n  components: AttributeComponents;\n  byteOffset: number;\n  byteStride: number;\n};\n\ntype SplatShCoefficientContext = {\n  index: number;\n  degree: 1 | 2 | 3;\n  order: number;\n};\n\nclass SplatPostDecodeShPatch {\n  /** @internal */\n  constructor(\n    /** @internal */ readonly owner: ProgramBuilder,\n    /** @internal */ readonly coefficients: readonly Vec3Value[],\n  ) {}\n}\n\nclass SplatPostDecodeShValue {\n  /** @internal */\n  constructor(private readonly owner: ProgramBuilder) {}\n\n  coefficient(index: number): Vec3Value {\n    if (\n      !Number.isInteger(index) ||\n      index < 0 ||\n      index >= SH_COEFFICIENT_COUNT\n    ) {\n      throw new Error(\"SH coefficient index must be between 0 and 14\");\n    }\n    return this.owner.inputField(\"vec3\", InputField.Sh0 + index);\n  }\n\n  map(\n    transform: (\n      coefficient: Vec3Value,\n      context: SplatShCoefficientContext,\n    ) => Vec3Like,\n  ): SplatPostDecodeShPatch {\n    const coefficients: Vec3Value[] = [];\n    let index = 0;\n    for (let degree = 1 as 1 | 2 | 3; degree <= 3; degree += 1) {\n      for (let order = -degree; order <= degree; order += 1) {\n        coefficients.push(\n          this.owner.coerce(\n            transform(this.coefficient(index), { index, degree, order }),\n            \"vec3\",\n          ),\n        );\n        index += 1;\n      }\n    }\n    return new SplatPostDecodeShPatch(this.owner, coefficients);\n  }\n}\n\ntype SplatPostDecodeInput = {\n  readonly position: Vec3Value;\n  readonly scale: Vec3Value;\n  readonly quaternion: QuaternionValue;\n  /** Semantic opacity in the [0, 1000] range. */\n  readonly opacity: FloatValue;\n  /** Standard alpha in the [0, 1] range. */\n  readonly alpha: FloatValue;\n  readonly color: Vec3Value;\n  readonly sh: SplatPostDecodeShValue;\n};\ntype SplatPostDecodePatch = {\n  /** If false, this splat's packed values are left byte-for-byte unchanged. */\n  when?: BoolLike;\n  position?: Vec3Like;\n  scale?: Vec3Like;\n  quaternion?: QuaternionLike;\n  /** Semantic opacity, clamped to [0, 1000] and encoded by the library. */\n  opacity?: FloatLike;\n  /**\n   * Standard alpha, clamped to [0, 1] and independent from semantic opacity.\n   * Cannot be output with opacity in the same patch.\n   */\n  alpha?: FloatLike;\n  color?: Vec3Like;\n  sh?: SplatPostDecodeShPatch;\n};\n\ntype VariadicNumericOperation = <T extends NumericValueType>(\n  first: ValueLike<T>,\n  ...rest: BroadcastLike<T>[]\n) => SplatPostDecodeValue<T>;\ntype BinaryNumericOperation = <T extends NumericValueType>(\n  left: ValueLike<T>,\n  right: BroadcastLike<T>,\n) => SplatPostDecodeValue<T>;\ntype UnaryNumericOperation = <T extends NumericValueType>(\n  value: ValueLike<T>,\n) => SplatPostDecodeValue<T>;\n\ntype SplatPostDecodeOperations = {\n  add: VariadicNumericOperation;\n  sub: BinaryNumericOperation;\n  mul: VariadicNumericOperation;\n  div: BinaryNumericOperation;\n  min: BinaryNumericOperation;\n  max: BinaryNumericOperation;\n  pow: BinaryNumericOperation;\n  clamp<T extends NumericValueType>(\n    value: ValueLike<T>,\n    min: BroadcastLike<T>,\n    max: BroadcastLike<T>,\n  ): SplatPostDecodeValue<T>;\n  mix<T extends NumericValueType>(\n    left: ValueLike<T>,\n    right: ValueLike<T>,\n    amount: BroadcastLike<T>,\n  ): SplatPostDecodeValue<T>;\n  neg: UnaryNumericOperation;\n  abs: UnaryNumericOperation;\n  sqrt: UnaryNumericOperation;\n  log: UnaryNumericOperation;\n  exp: UnaryNumericOperation;\n  floor: UnaryNumericOperation;\n  ceil: UnaryNumericOperation;\n  round: UnaryNumericOperation;\n  sin: UnaryNumericOperation;\n  cos: UnaryNumericOperation;\n  acos: UnaryNumericOperation;\n  tan: UnaryNumericOperation;\n  asin: UnaryNumericOperation;\n  atan: UnaryNumericOperation;\n  atan2: BinaryNumericOperation;\n  normalize<T extends VectorValueType | \"quaternion\">(\n    value: ValueLike<T>,\n  ): SplatPostDecodeValue<T>;\n  length(value: Vec2Like | Vec3Like | Vec4Like): FloatValue;\n  isFinite(\n    value: FloatLike | Vec2Like | Vec3Like | Vec4Like | QuaternionLike,\n  ): BoolValue;\n  not(value: BoolLike): BoolValue;\n  eq<T extends SplatPostDecodeValueType>(\n    left: ValueLike<T>,\n    right: ValueLike<T>,\n  ): BoolValue;\n  ne<T extends SplatPostDecodeValueType>(\n    left: ValueLike<T>,\n    right: ValueLike<T>,\n  ): BoolValue;\n  lt(left: FloatLike, right: FloatLike): BoolValue;\n  lte(left: FloatLike, right: FloatLike): BoolValue;\n  gt(left: FloatLike, right: FloatLike): BoolValue;\n  gte(left: FloatLike, right: FloatLike): BoolValue;\n  and(first: BoolLike, ...rest: BoolLike[]): BoolValue;\n  or(first: BoolLike, ...rest: BoolLike[]): BoolValue;\n  select<T extends SplatPostDecodeValueType>(\n    condition: BoolLike,\n    whenTrue: ValueLike<T>,\n    whenFalse: ValueLike<T>,\n  ): SplatPostDecodeValue<T>;\n  dot(\n    left: Vec2Like | Vec3Like | Vec4Like,\n    right: Vec2Like | Vec3Like | Vec4Like,\n  ): FloatValue;\n  cross(left: Vec3Like, right: Vec3Like): Vec3Value;\n  vec2(x: FloatLike, y: FloatLike): Vec2Value;\n  vec3(x: FloatLike, y: FloatLike, z: FloatLike): Vec3Value;\n  vec4(x: FloatLike, y: FloatLike, z: FloatLike, w: FloatLike): Vec4Value;\n  quaternion(\n    x: FloatLike,\n    y: FloatLike,\n    z: FloatLike,\n    w: FloatLike,\n  ): QuaternionValue;\n  component(\n    value: Vec2Like | Vec3Like | Vec4Like | QuaternionLike,\n    index: number,\n  ): FloatValue;\n  maxComponentIndex(value: Vec2Like | Vec3Like | Vec4Like): FloatValue;\n  quatMul(left: QuaternionLike, right: QuaternionLike): QuaternionValue;\n  rotateVector(quaternion: QuaternionLike, vector: Vec3Like): Vec3Value;\n};\n\ntype SplatPostDecodeContext = {\n  splat: SplatPostDecodeInput;\n  op: SplatPostDecodeOperations;\n  attribute<Components extends AttributeComponents = 1>(\n    options: SplatPostDecodeAttributeOptions<Components>,\n  ): AttributeValue<Components>;\n};\n\n/** @internal */\nexport type SerializedSplatPostDecodeAttribute = {\n  format: SplatPostDecodeAttributeFormat;\n  components: AttributeComponents;\n  byteOffset: number;\n  byteStride: number;\n  count: number;\n};\n\n/** @internal */\nexport type SplatPostDecodeOutputs = {\n  when?: number;\n  position?: number;\n  scale?: number;\n  quaternion?: number;\n  opacity?: number;\n  alpha?: number;\n  color?: number;\n  sh?: readonly number[];\n};\n\n/** @internal */\nexport const SPLAT_POST_DECODE_FLOW_STAGE_START = 0;\n/** @internal */\nexport const SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION = 1;\n/** @internal */\nexport const SPLAT_POST_DECODE_FLOW_STAGE_REGISTER = 2;\n/** @internal */\nexport const SPLAT_POST_DECODE_FLOW_STAGE_ON_TRUE = 3;\n/** @internal */\nexport const SPLAT_POST_DECODE_FLOW_STAGE_ON_FALSE = 4;\n/** @internal */\nexport const SPLAT_POST_DECODE_FLOW_STAGE_STRIDE = 5;\n\n/** @internal */\nexport type SerializedSplatPostDecodeCondition = {\n  mode: \"flow\";\n  /** Packed start/instruction/register/onTrue/onFalse Uint16 records. */\n  stages: Uint16Array;\n};\n\n/** @internal */\nexport type SerializedSplatPostDecode = {\n  /** Packed opcode/width/immediate/arg0/arg1/arg2/arg3 Uint16 records. */\n  instructions: Uint16Array;\n  constants: Float32Array;\n  outputs: Omit<SplatPostDecodeOutputs, \"when\">;\n  condition?: SerializedSplatPostDecodeCondition;\n  attributeData: Uint8Array;\n  attributes: readonly SerializedSplatPostDecodeAttribute[];\n};\n\nconst SPLAT_POST_DECODE_PROGRAM = Symbol(\"SplatPostDecodeProgram\");\nexport type SplatPostDecodeProgram = {\n  readonly [SPLAT_POST_DECODE_PROGRAM]: true;\n};\n\nconst COMPONENT_TYPES = [\"float\", \"vec2\", \"vec3\", \"vec4\"] as const;\n\nfunction inferLiteralType(value: unknown): SplatPostDecodeValueType {\n  if (typeof value === \"boolean\") return \"bool\";\n  if (typeof value === \"number\") return \"float\";\n  if (Array.isArray(value) && value.length >= 2 && value.length <= 4) {\n    return COMPONENT_TYPES[value.length - 1];\n  }\n  throw new Error(\"Unsupported postDecode literal\");\n}\n\nfunction constantKey(\n  type: SplatPostDecodeValueType,\n  values: readonly number[],\n) {\n  return `${type}:${values\n    .map((value) => (Object.is(value, -0) ? \"-0\" : value))\n    .join(\":\")}`;\n}\n\nclass ProgramBuilder {\n  readonly instructions: SplatPostDecodeInstruction[] = [];\n  readonly constants: number[] = [];\n  readonly attributes: AttributeBinding[] = [];\n  readonly op: SplatPostDecodeOperations;\n  readonly splat: SplatPostDecodeInput;\n\n  readonly constantRegisters = new Map<\n    string,\n    SplatPostDecodeValue<SplatPostDecodeValueType>\n  >();\n  readonly inputRegisters = new Map<\n    number,\n    SplatPostDecodeValue<SplatPostDecodeValueType>\n  >();\n\n  constructor() {\n    this.op = this.createOperations();\n    const builder = this;\n    const sh = new SplatPostDecodeShValue(this);\n    this.splat = {\n      get position() {\n        return builder.inputField(\"vec3\", InputField.Position);\n      },\n      get scale() {\n        return builder.inputField(\"vec3\", InputField.Scale);\n      },\n      get quaternion() {\n        return builder.inputField(\"quaternion\", InputField.Quaternion);\n      },\n      get opacity() {\n        return builder.inputField(\"float\", InputField.Opacity);\n      },\n      get alpha() {\n        return builder.inputField(\"float\", InputField.Alpha);\n      },\n      get color() {\n        return builder.inputField(\"vec3\", InputField.Color);\n      },\n      sh,\n    };\n  }\n\n  private instruction<T extends SplatPostDecodeValueType>(\n    type: T,\n    opcode: Opcode,\n    args: readonly number[] = [],\n    immediate = 0,\n  ): SplatPostDecodeValue<T> {\n    if (this.instructions.length >= 4096) {\n      throw new Error(\"postDecode program exceeds 4096 instructions\");\n    }\n    const register = this.instructions.length;\n    this.instructions.push({ opcode, type, args, immediate });\n    return new SplatPostDecodeValue(type, register, this);\n  }\n\n  inputField<T extends SplatPostDecodeValueType>(\n    type: T,\n    field: InputField,\n  ): SplatPostDecodeValue<T> {\n    const existing = this.inputRegisters.get(field);\n    if (existing) return existing as SplatPostDecodeValue<T>;\n    const value = this.instruction(type, Opcode.InputField, [], field);\n    this.inputRegisters.set(field, value);\n    return value;\n  }\n\n  attribute<Components extends AttributeComponents = 1>(\n    options: SplatPostDecodeAttributeOptions<Components>,\n  ): AttributeValue<Components> {\n    if (!ArrayBuffer.isView(options.data)) {\n      throw new Error(\"postDecode attribute data must be an ArrayBuffer view\");\n    }\n    const componentBytes = ATTRIBUTE_FORMAT_BYTES[options.format];\n    if (!componentBytes) {\n      throw new Error(`Unknown postDecode format: ${options.format}`);\n    }\n    const count = options.count;\n    const components = options.components ?? 1;\n    const byteOffset = options.byteOffset ?? 0;\n    const packedBytes = componentBytes * components;\n    const byteStride = options.byteStride ?? packedBytes;\n    if (!Number.isSafeInteger(count) || count < 0) {\n      throw new Error(\"postDecode attribute count must be non-negative\");\n    }\n    if (!Number.isInteger(components) || components < 1 || components > 4) {\n      throw new Error(\n        \"postDecode attribute components must be between 1 and 4\",\n      );\n    }\n    if (\n      !Number.isSafeInteger(byteOffset) ||\n      byteOffset < 0 ||\n      !Number.isSafeInteger(byteStride) ||\n      byteStride < packedBytes\n    ) {\n      throw new Error(\"Invalid postDecode attribute byteOffset or byteStride\");\n    }\n    const requiredBytes =\n      count === 0\n        ? byteOffset\n        : byteOffset + (count - 1) * byteStride + packedBytes;\n    if (\n      !Number.isSafeInteger(requiredBytes) ||\n      requiredBytes > options.data.byteLength\n    ) {\n      throw new Error(\"postDecode attribute data is too small\");\n    }\n\n    const index = this.attributes.length;\n    this.attributes.push({\n      data: options.data,\n      format: options.format,\n      count,\n      components,\n      byteOffset,\n      byteStride,\n    });\n    return this.instruction(\n      COMPONENT_TYPES[components - 1],\n      Opcode.InputAttribute,\n      [],\n      index,\n    ) as AttributeValue<Components>;\n  }\n\n  coerce<T extends SplatPostDecodeValueType>(\n    value: ValueLike<T>,\n    expectedType?: T,\n  ): SplatPostDecodeValue<T> {\n    if (value instanceof SplatPostDecodeValue) {\n      if (value.owner !== this) {\n        throw new Error(\n          \"Cannot combine values from different postDecode programs\",\n        );\n      }\n      if (expectedType && value.type !== expectedType) {\n        const vec4Quaternion =\n          (expectedType === \"quaternion\" && value.type === \"vec4\") ||\n          (expectedType === \"vec4\" && value.type === \"quaternion\");\n        if (!vec4Quaternion) {\n          throw new Error(`Expected ${expectedType}, received ${value.type}`);\n        }\n      }\n      return value as SplatPostDecodeValue<T>;\n    }\n\n    const type = expectedType ?? inferLiteralType(value);\n    const numeric =\n      typeof value === \"boolean\"\n        ? [value ? 1 : 0]\n        : typeof value === \"number\"\n          ? [value]\n          : [...(value as readonly number[])];\n    const width = TYPE_WIDTHS[type];\n    if (numeric.length !== width) {\n      throw new Error(`Expected ${width} values for ${type}`);\n    }\n    const values = numeric.map(Math.fround);\n    if (!values.every(Number.isFinite)) {\n      throw new Error(\"postDecode constants must be finite\");\n    }\n    const key = constantKey(type, values);\n    const existing = this.constantRegisters.get(key);\n    if (existing) return existing as SplatPostDecodeValue<T>;\n\n    const immediate = this.constants.length;\n    this.constants.push(...values);\n    const result = this.instruction(type as T, Opcode.Constant, [], immediate);\n    this.constantRegisters.set(key, result);\n    return result;\n  }\n\n  private unary(\n    opcode: Opcode,\n    value: AnyValueLike,\n    outputType?: SplatPostDecodeValueType,\n  ) {\n    const input = this.coerce(value);\n    return this.instruction(outputType ?? input.type, opcode, [input.register]);\n  }\n\n  private binary(\n    opcode: Opcode,\n    leftValue: AnyValueLike,\n    rightValue: AnyValueLike,\n    outputType?: SplatPostDecodeValueType,\n  ) {\n    const left = this.coerce(leftValue);\n    const right = this.coerceForBinary(rightValue, left.type);\n    return this.instruction(outputType ?? left.type, opcode, [\n      left.register,\n      right.register,\n    ]);\n  }\n\n  private ternary(\n    opcode: Opcode,\n    firstValue: AnyValueLike,\n    secondValue: AnyValueLike,\n    thirdValue: AnyValueLike,\n  ) {\n    const first = this.coerce(firstValue);\n    const second = this.coerceForBinary(secondValue, first.type);\n    const third = this.coerceForBinary(thirdValue, first.type);\n    return this.instruction(first.type, opcode, [\n      first.register,\n      second.register,\n      third.register,\n    ]);\n  }\n\n  private coerceForBinary(\n    value: AnyValueLike,\n    targetType: SplatPostDecodeValueType,\n  ) {\n    if (value instanceof SplatPostDecodeValue) {\n      return value.type === \"float\" && TYPE_WIDTHS[targetType] > 1\n        ? this.coerce(value)\n        : this.coerce(value, targetType);\n    }\n    return this.coerce(\n      value,\n      typeof value === \"number\" && TYPE_WIDTHS[targetType] > 1\n        ? \"float\"\n        : targetType,\n    );\n  }\n\n  private createOperations(): SplatPostDecodeOperations {\n    const reduceNumeric =\n      (opcode: Opcode): VariadicNumericOperation =>\n      <T extends NumericValueType>(\n        first: ValueLike<T>,\n        ...rest: BroadcastLike<T>[]\n      ) => {\n        let result = this.coerce(first);\n        for (const right of rest) {\n          result = this.binary(\n            opcode,\n            result,\n            right,\n          ) as SplatPostDecodeValue<T>;\n        }\n        return result;\n      };\n    const binaryNumeric =\n      (opcode: Opcode): BinaryNumericOperation =>\n      <T extends NumericValueType>(\n        left: ValueLike<T>,\n        right: BroadcastLike<T>,\n      ) =>\n        this.binary(opcode, left, right) as SplatPostDecodeValue<T>;\n    const unaryNumeric =\n      (opcode: Opcode): UnaryNumericOperation =>\n      <T extends NumericValueType>(value: ValueLike<T>) =>\n        this.unary(opcode, value) as SplatPostDecodeValue<T>;\n    const compare =\n      (opcode: Opcode) => (left: AnyValueLike, right: AnyValueLike) =>\n        this.binary(opcode, left, right, \"bool\") as BoolValue;\n    const reduceBoolean =\n      (opcode: Opcode) =>\n      (first: BoolLike, ...rest: BoolLike[]): BoolValue => {\n        let result = this.coerce(first, \"bool\");\n        for (const right of rest) {\n          result = this.binary(opcode, result, right, \"bool\") as BoolValue;\n        }\n        return result;\n      };\n    const construct = <T extends VectorValueType | \"quaternion\">(\n      opcode: Opcode,\n      type: T,\n      values: FloatLike[],\n    ) =>\n      this.instruction(\n        type,\n        opcode,\n        values.map((value) => this.coerce(value, \"float\").register),\n      );\n\n    return {\n      add: reduceNumeric(Opcode.Add),\n      sub: binaryNumeric(Opcode.Subtract),\n      mul: reduceNumeric(Opcode.Multiply),\n      div: binaryNumeric(Opcode.Divide),\n      min: binaryNumeric(Opcode.Min),\n      max: binaryNumeric(Opcode.Max),\n      pow: binaryNumeric(Opcode.Pow),\n      clamp: (value, min, max) =>\n        this.ternary(Opcode.Clamp, value, min, max) as never,\n      mix: (left, right, amount) =>\n        this.ternary(Opcode.Mix, left, right, amount) as never,\n      neg: unaryNumeric(Opcode.Negate),\n      abs: unaryNumeric(Opcode.Abs),\n      sqrt: unaryNumeric(Opcode.Sqrt),\n      log: unaryNumeric(Opcode.Log),\n      exp: unaryNumeric(Opcode.Exp),\n      floor: unaryNumeric(Opcode.Floor),\n      ceil: unaryNumeric(Opcode.Ceil),\n      round: unaryNumeric(Opcode.Round),\n      sin: unaryNumeric(Opcode.Sin),\n      cos: unaryNumeric(Opcode.Cos),\n      acos: unaryNumeric(Opcode.Acos),\n      tan: unaryNumeric(Opcode.Tan),\n      asin: unaryNumeric(Opcode.Asin),\n      atan: unaryNumeric(Opcode.Atan),\n      atan2: binaryNumeric(Opcode.Atan2),\n      normalize: (value) => this.unary(Opcode.Normalize, value) as never,\n      length: (value) =>\n        this.unary(Opcode.Length, value, \"float\") as FloatValue,\n      isFinite: (value) =>\n        this.unary(Opcode.IsFinite, value, \"bool\") as BoolValue,\n      not: (value) =>\n        this.unary(Opcode.Not, this.coerce(value, \"bool\"), \"bool\") as BoolValue,\n      eq: compare(Opcode.Equal),\n      ne: compare(Opcode.NotEqual),\n      lt: compare(Opcode.Less),\n      lte: compare(Opcode.LessEqual),\n      gt: compare(Opcode.Greater),\n      gte: compare(Opcode.GreaterEqual),\n      and: reduceBoolean(Opcode.And),\n      or: reduceBoolean(Opcode.Or),\n      select: (condition, whenTrue, whenFalse) => {\n        const trueValue = this.coerce(whenTrue);\n        const falseValue = this.coerce(whenFalse, trueValue.type);\n        return this.instruction(trueValue.type, Opcode.Select, [\n          this.coerce(condition, \"bool\").register,\n          trueValue.register,\n          falseValue.register,\n        ]) as never;\n      },\n      dot: (left, right) =>\n        this.binary(Opcode.Dot, left, right, \"float\") as FloatValue,\n      cross: (left, right) =>\n        this.binary(Opcode.Cross, left, right) as Vec3Value,\n      vec2: (x, y) => construct(Opcode.Vec2, \"vec2\", [x, y]),\n      vec3: (x, y, z) => construct(Opcode.Vec3, \"vec3\", [x, y, z]),\n      vec4: (x, y, z, w) => construct(Opcode.Vec4, \"vec4\", [x, y, z, w]),\n      quaternion: (x, y, z, w) =>\n        construct(Opcode.Vec4, \"quaternion\", [x, y, z, w]),\n      component: (value, index) => {\n        const input = this.coerce(value as AnyValueLike);\n        if (\n          !Number.isInteger(index) ||\n          index < 0 ||\n          index >= TYPE_WIDTHS[input.type]\n        ) {\n          throw new Error(\"postDecode component index is out of bounds\");\n        }\n        return this.instruction(\n          \"float\",\n          Opcode.Component,\n          [input.register],\n          index,\n        );\n      },\n      maxComponentIndex: (value) =>\n        this.unary(Opcode.MaxComponentIndex, value, \"float\") as FloatValue,\n      quatMul: (left, right) => {\n        const a = this.coerce(left, \"quaternion\");\n        const b = this.coerce(right, \"quaternion\");\n        return this.instruction(\"quaternion\", Opcode.QuaternionMultiply, [\n          a.register,\n          b.register,\n        ]);\n      },\n      rotateVector: (quaternion, vector) => {\n        const q = this.coerce(quaternion, \"quaternion\");\n        const v = this.coerce(vector, \"vec3\");\n        return this.instruction(\"vec3\", Opcode.RotateVector, [\n          q.register,\n          v.register,\n        ]);\n      },\n    };\n  }\n}\n\nclass GenerationRegisterMap {\n  private readonly values: Int32Array;\n  private readonly generations: Uint32Array;\n  private generation = 1;\n\n  constructor(size: number) {\n    this.values = new Int32Array(size);\n    this.generations = new Uint32Array(size);\n  }\n\n  clear() {\n    if (this.generation === 0xffff_ffff) {\n      this.generations.fill(0);\n      this.generation = 1;\n    } else {\n      this.generation += 1;\n    }\n  }\n\n  has(source: number) {\n    return this.generations[source] === this.generation;\n  }\n\n  get(source: number) {\n    return this.has(source) ? this.values[source] : undefined;\n  }\n\n  set(source: number, target: number) {\n    this.generations[source] = this.generation;\n    this.values[source] = target;\n  }\n\n  delete(source: number) {\n    this.generations[source] = 0;\n  }\n}\n\ntype CompiledProgram = {\n  instructions: SplatPostDecodeInstruction[];\n  constants: number[];\n  outputs: Omit<SplatPostDecodeOutputs, \"when\">;\n  condition?: SerializedSplatPostDecodeCondition;\n  attributes: AttributeBinding[];\n};\n\nfunction markDependencies(\n  builder: ProgramBuilder,\n  roots: readonly (number | undefined)[],\n  marked: Uint8Array,\n) {\n  const pending: number[] = [];\n  for (const root of roots) {\n    if (root === undefined || marked[root]) continue;\n    marked[root] = 1;\n    pending.push(root);\n  }\n  while (pending.length !== 0) {\n    const register = pending.pop();\n    if (register === undefined) break;\n    for (const argument of builder.instructions[register].args) {\n      if (marked[argument]) continue;\n      marked[argument] = 1;\n      pending.push(argument);\n    }\n  }\n}\n\n/**\n * Serializes source instructions while remapping only live registers. A\n * generation map represents the current straight-line path. Branch merges\n * advance its generation in O(1), while unique predecessors reuse it. One\n * generation array is also shared by every dependency walk.\n */\nclass InstructionSerializer {\n  readonly instructions: SplatPostDecodeInstruction[] = [];\n  readonly constants: number[] = [];\n  readonly attributes: AttributeBinding[] = [];\n\n  private readonly constantMap = new Map<number, number>();\n  private readonly attributeMap = new Map<number, number>();\n  private readonly dependencyMarks: Uint32Array;\n  private dependencyGeneration = 0;\n\n  constructor(private readonly builder: ProgramBuilder) {\n    this.dependencyMarks = new Uint32Array(builder.instructions.length);\n  }\n\n  appendDependencies(\n    roots: readonly (number | undefined)[],\n    registers: GenerationRegisterMap,\n    forceRoots = false,\n  ) {\n    if (forceRoots) {\n      for (const root of roots) {\n        if (\n          root !== undefined &&\n          this.builder.instructions[root].opcode !== Opcode.Constant\n        ) {\n          registers.delete(root);\n        }\n      }\n    }\n\n    this.dependencyGeneration += 1;\n    const generation = this.dependencyGeneration;\n    const pending: number[] = [];\n    const sourceOrder: number[] = [];\n    for (const root of roots) {\n      if (root !== undefined && !registers.has(root)) pending.push(root);\n    }\n    while (pending.length !== 0) {\n      const source = pending.pop();\n      if (\n        source === undefined ||\n        registers.has(source) ||\n        this.dependencyMarks[source] === generation\n      ) {\n        continue;\n      }\n      this.dependencyMarks[source] = generation;\n      sourceOrder.push(source);\n      for (const argument of this.builder.instructions[source].args) {\n        if (!registers.has(argument)) pending.push(argument);\n      }\n    }\n\n    sourceOrder.sort((left, right) => left - right);\n    this.append(sourceOrder, registers);\n    return registers;\n  }\n\n  append(sourceOrder: readonly number[], registers: GenerationRegisterMap) {\n    for (const sourceIndex of sourceOrder) {\n      const source = this.builder.instructions[sourceIndex];\n      if (source.opcode === Opcode.Constant) {\n        let target = this.constantMap.get(sourceIndex);\n        if (target === undefined) {\n          this.reserveInstruction();\n          target = this.instructions.length;\n          this.constantMap.set(sourceIndex, target);\n          const immediate = this.constants.length;\n          this.constants.push(\n            ...this.builder.constants.slice(\n              source.immediate,\n              source.immediate + TYPE_WIDTHS[source.type],\n            ),\n          );\n          this.instructions.push({ ...source, immediate });\n        }\n        registers.set(sourceIndex, target);\n        continue;\n      }\n\n      this.reserveInstruction();\n      let immediate = source.immediate;\n      if (source.opcode === Opcode.InputAttribute) {\n        let target = this.attributeMap.get(immediate);\n        if (target === undefined) {\n          target = this.attributes.length;\n          this.attributeMap.set(immediate, target);\n          this.attributes.push(this.builder.attributes[immediate]);\n        }\n        immediate = target;\n      }\n      const args = source.args.map((argument) => {\n        const target = registers.get(argument);\n        if (target === undefined) {\n          throw new Error(\"Invalid postDecode instruction dependency\");\n        }\n        return target;\n      });\n      registers.set(sourceIndex, this.instructions.length);\n      this.instructions.push({ ...source, args, immediate });\n    }\n  }\n\n  private reserveInstruction() {\n    if (this.instructions.length >= 4096) {\n      throw new Error(\"postDecode compiled program exceeds 4096 instructions\");\n    }\n  }\n}\n\nfunction emptyCompiledProgram(): CompiledProgram {\n  return {\n    instructions: [],\n    constants: [],\n    outputs: {},\n    condition: undefined,\n    attributes: [],\n  };\n}\n\nfunction remapOutputs(\n  outputs: SplatPostDecodeOutputs,\n  registers: GenerationRegisterMap,\n): Omit<SplatPostDecodeOutputs, \"when\"> {\n  const remap = (register: number | undefined) =>\n    register === undefined ? undefined : registers.get(register);\n  return {\n    position: remap(outputs.position),\n    scale: remap(outputs.scale),\n    quaternion: remap(outputs.quaternion),\n    opacity: remap(outputs.opacity),\n    alpha: remap(outputs.alpha),\n    color: remap(outputs.color),\n    sh: outputs.sh?.map((register) => {\n      const target = registers.get(register);\n      if (target === undefined) {\n        throw new Error(\"Invalid postDecode output dependency\");\n      }\n      return target;\n    }),\n  };\n}\n\ntype FlowNode = {\n  register: number;\n  onTrue: number;\n  onFalse: number;\n};\n\nfunction compileConditionFlow(\n  builder: ProgramBuilder,\n  outputs: SplatPostDecodeOutputs,\n  outputRoots: readonly (number | undefined)[],\n  whenRegister: number,\n): CompiledProgram | undefined {\n  const FLOW_ACCEPT = -1;\n  const FLOW_REJECT = -2;\n  const FLOW_DYNAMIC = 0;\n  const FLOW_CONSTANT_FALSE = 1;\n  const FLOW_CONSTANT_TRUE = 2;\n  const constantValues = new Uint8Array(whenRegister + 1);\n  for (let register = 0; register <= whenRegister; register += 1) {\n    const instruction = builder.instructions[register];\n    if (instruction.opcode === Opcode.Constant && instruction.type === \"bool\") {\n      constantValues[register] = builder.constants[instruction.immediate]\n        ? FLOW_CONSTANT_TRUE\n        : FLOW_CONSTANT_FALSE;\n      continue;\n    }\n    const left = constantValues[instruction.args[0]];\n    if (instruction.opcode === Opcode.Not) {\n      constantValues[register] =\n        left === FLOW_CONSTANT_TRUE\n          ? FLOW_CONSTANT_FALSE\n          : left === FLOW_CONSTANT_FALSE\n            ? FLOW_CONSTANT_TRUE\n            : FLOW_DYNAMIC;\n    } else if (instruction.opcode === Opcode.And) {\n      const right = constantValues[instruction.args[1]];\n      constantValues[register] =\n        left === FLOW_CONSTANT_FALSE || right === FLOW_CONSTANT_FALSE\n          ? FLOW_CONSTANT_FALSE\n          : left === FLOW_CONSTANT_TRUE && right === FLOW_CONSTANT_TRUE\n            ? FLOW_CONSTANT_TRUE\n            : FLOW_DYNAMIC;\n    } else if (instruction.opcode === Opcode.Or) {\n      const right = constantValues[instruction.args[1]];\n      constantValues[register] =\n        left === FLOW_CONSTANT_TRUE || right === FLOW_CONSTANT_TRUE\n          ? FLOW_CONSTANT_TRUE\n          : left === FLOW_CONSTANT_FALSE && right === FLOW_CONSTANT_FALSE\n            ? FLOW_CONSTANT_FALSE\n            : FLOW_DYNAMIC;\n    }\n  }\n\n  const reverseNodes: FlowNode[] = [];\n  const FLOW_AND_LEFT = 0;\n  const FLOW_OR_LEFT = 1;\n  const FLOW_CONTINUATION_SIZE = 3;\n  let continuations: Int32Array | undefined;\n  let continuationEnd = 0;\n  let register = whenRegister;\n  let onTrue = FLOW_ACCEPT;\n  let onFalse = FLOW_REJECT;\n  let compiledTarget = FLOW_REJECT;\n  while (true) {\n    const constant = constantValues[register];\n    if (constant !== FLOW_DYNAMIC) {\n      compiledTarget = constant === FLOW_CONSTANT_TRUE ? onTrue : onFalse;\n    } else {\n      const instruction = builder.instructions[register];\n      if (instruction.opcode === Opcode.Not) {\n        register = instruction.args[0];\n        const target = onTrue;\n        onTrue = onFalse;\n        onFalse = target;\n        continue;\n      }\n      if (\n        instruction.opcode === Opcode.And ||\n        instruction.opcode === Opcode.Or\n      ) {\n        continuations ??= new Int32Array(\n          (whenRegister + 1) * FLOW_CONTINUATION_SIZE,\n        );\n        if (continuationEnd === continuations.length) {\n          throw new Error(\"Invalid postDecode condition depth\");\n        }\n        const isAnd = instruction.opcode === Opcode.And;\n        continuations[continuationEnd] = isAnd ? FLOW_AND_LEFT : FLOW_OR_LEFT;\n        continuations[continuationEnd + 1] = instruction.args[0];\n        continuations[continuationEnd + 2] = isAnd ? onFalse : onTrue;\n        continuationEnd += FLOW_CONTINUATION_SIZE;\n        register = instruction.args[1];\n        continue;\n      }\n      if (reverseNodes.length >= 4096) {\n        throw new Error(\"postDecode condition exceeds 4096 flow nodes\");\n      }\n      compiledTarget = reverseNodes.length;\n      reverseNodes.push({ register, onTrue, onFalse });\n    }\n\n    if (continuationEnd === 0) break;\n    continuationEnd -= FLOW_CONTINUATION_SIZE;\n    if (!continuations) {\n      throw new Error(\"Invalid postDecode condition continuation\");\n    }\n    const type = continuations[continuationEnd];\n    register = continuations[continuationEnd + 1];\n    const target = continuations[continuationEnd + 2];\n    if (type === FLOW_AND_LEFT) {\n      onTrue = compiledTarget;\n      onFalse = target;\n    } else {\n      onTrue = target;\n      onFalse = compiledTarget;\n    }\n  }\n\n  const entry = compiledTarget;\n  if (entry === FLOW_REJECT) return emptyCompiledProgram();\n  if (entry === FLOW_ACCEPT) {\n    outputs.when = undefined;\n    return undefined;\n  }\n\n  const stageCount = reverseNodes.length;\n  if (entry !== stageCount - 1) {\n    throw new Error(\"Invalid postDecode condition flow\");\n  }\n\n  const acceptTarget = stageCount;\n  const rejectTarget = acceptTarget + 1;\n  const stages = new Uint16Array(\n    stageCount * SPLAT_POST_DECODE_FLOW_STAGE_STRIDE,\n  );\n  const predecessors = new Int32Array(stageCount).fill(-1);\n  let acceptPredecessor = -1;\n  const recordPredecessor = (target: number, predecessor: number) => {\n    if (target === rejectTarget) return;\n    if (target === acceptTarget) {\n      acceptPredecessor =\n        acceptPredecessor === -1\n          ? predecessor\n          : acceptPredecessor === predecessor\n            ? predecessor\n            : -2;\n      return;\n    }\n    predecessors[target] =\n      predecessors[target] === -1\n        ? predecessor\n        : predecessors[target] === predecessor\n          ? predecessor\n          : -2;\n  };\n  const remapTarget = (target: number) =>\n    target === FLOW_ACCEPT\n      ? acceptTarget\n      : target === FLOW_REJECT\n        ? rejectTarget\n        : stageCount - 1 - target;\n\n  for (let stage = 0; stage < stageCount; stage += 1) {\n    const node = reverseNodes[stageCount - 1 - stage];\n    const offset = stage * SPLAT_POST_DECODE_FLOW_STAGE_STRIDE;\n    const onTrue = remapTarget(node.onTrue);\n    const onFalse = remapTarget(node.onFalse);\n    stages[offset + SPLAT_POST_DECODE_FLOW_STAGE_ON_TRUE] = onTrue;\n    stages[offset + SPLAT_POST_DECODE_FLOW_STAGE_ON_FALSE] = onFalse;\n    recordPredecessor(onTrue, stage);\n    recordPredecessor(onFalse, stage);\n  }\n\n  const serializer = new InstructionSerializer(builder);\n  const pathRegisters = new GenerationRegisterMap(builder.instructions.length);\n  for (let stage = 0; stage < stageCount; stage += 1) {\n    if (stage === 0 || predecessors[stage] !== stage - 1) {\n      pathRegisters.clear();\n    }\n    const node = reverseNodes[stageCount - 1 - stage];\n    const offset = stage * SPLAT_POST_DECODE_FLOW_STAGE_STRIDE;\n    stages[offset + SPLAT_POST_DECODE_FLOW_STAGE_START] =\n      serializer.instructions.length;\n    serializer.appendDependencies([node.register], pathRegisters, true);\n    stages[offset + SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION] =\n      serializer.instructions.length - 1;\n    const predicateRegister = pathRegisters.get(node.register);\n    if (predicateRegister === undefined) {\n      throw new Error(\"Invalid postDecode condition register\");\n    }\n    stages[offset + SPLAT_POST_DECODE_FLOW_STAGE_REGISTER] = predicateRegister;\n  }\n\n  if (acceptPredecessor !== stageCount - 1) pathRegisters.clear();\n  serializer.appendDependencies(outputRoots, pathRegisters);\n  return {\n    instructions: serializer.instructions,\n    constants: serializer.constants,\n    outputs: remapOutputs(outputs, pathRegisters),\n    condition: { mode: \"flow\", stages },\n    attributes: serializer.attributes,\n  };\n}\n\nfunction compileProgram(\n  builder: ProgramBuilder,\n  sourceOutputs: SplatPostDecodeOutputs,\n): CompiledProgram {\n  const outputs = { ...sourceOutputs };\n  if (outputs.when !== undefined) {\n    const condition = builder.instructions[outputs.when];\n    if (condition.opcode === Opcode.Constant) {\n      if (builder.constants[condition.immediate] === 0) {\n        return emptyCompiledProgram();\n      }\n      outputs.when = undefined;\n    }\n  }\n\n  const outputRoots = [\n    outputs.position,\n    outputs.scale,\n    outputs.quaternion,\n    outputs.opacity,\n    outputs.alpha,\n    outputs.color,\n    ...(outputs.sh ?? []),\n  ];\n  if (outputs.when !== undefined) {\n    const flow = compileConditionFlow(\n      builder,\n      outputs,\n      outputRoots,\n      outputs.when,\n    );\n    if (flow) return flow;\n  }\n\n  const live = new Uint8Array(builder.instructions.length);\n  markDependencies(builder, outputRoots, live);\n  const instructionOrder: number[] = [];\n  for (let register = 0; register < live.length; register += 1) {\n    if (live[register]) instructionOrder.push(register);\n  }\n\n  const serializer = new InstructionSerializer(builder);\n  const registers = new GenerationRegisterMap(builder.instructions.length);\n  serializer.append(instructionOrder, registers);\n  return {\n    instructions: serializer.instructions,\n    constants: serializer.constants,\n    outputs: remapOutputs(outputs, registers),\n    attributes: serializer.attributes,\n  };\n}\n\nfunction packInstructions(\n  instructions: readonly SplatPostDecodeInstruction[],\n): Uint16Array {\n  const packed = new Uint16Array(\n    instructions.length * SPLAT_POST_DECODE_INSTRUCTION_STRIDE,\n  );\n  packed.fill(SPLAT_POST_DECODE_MISSING_ARGUMENT);\n  for (let index = 0; index < instructions.length; index += 1) {\n    const instruction = instructions[index];\n    if (\n      instruction.args.length > SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_COUNT ||\n      !Number.isInteger(instruction.immediate) ||\n      instruction.immediate < 0 ||\n      instruction.immediate > 0xffff ||\n      instruction.args.some(\n        (argument) =>\n          !Number.isInteger(argument) ||\n          argument < 0 ||\n          argument >= SPLAT_POST_DECODE_MISSING_ARGUMENT,\n      )\n    ) {\n      throw new Error(\"postDecode instruction exceeds Uint16 bytecode limits\");\n    }\n    const offset = index * SPLAT_POST_DECODE_INSTRUCTION_STRIDE;\n    packed[offset + SPLAT_POST_DECODE_INSTRUCTION_OPCODE] = instruction.opcode;\n    packed[offset + SPLAT_POST_DECODE_INSTRUCTION_WIDTH] =\n      TYPE_WIDTHS[instruction.type];\n    packed[offset + SPLAT_POST_DECODE_INSTRUCTION_IMMEDIATE] =\n      instruction.immediate;\n    for (let argument = 0; argument < instruction.args.length; argument += 1) {\n      packed[offset + SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_0 + argument] =\n        instruction.args[argument];\n    }\n  }\n  return packed;\n}\n\ntype AttributeRegion = {\n  buffer: ArrayBufferLike;\n  start: number;\n  end: number;\n  outputOffset: number;\n};\n\nfunction snapshotAttributes(bindings: readonly AttributeBinding[]) {\n  const rangesByBuffer = new Map<\n    ArrayBufferLike,\n    { start: number; end: number }[]\n  >();\n  for (const binding of bindings) {\n    if (binding.count === 0) continue;\n    const packedBytes =\n      ATTRIBUTE_FORMAT_BYTES[binding.format] * binding.components;\n    const start = binding.data.byteOffset + binding.byteOffset;\n    const end = start + (binding.count - 1) * binding.byteStride + packedBytes;\n    const ranges = rangesByBuffer.get(binding.data.buffer) ?? [];\n    ranges.push({ start, end });\n    rangesByBuffer.set(binding.data.buffer, ranges);\n  }\n\n  const regions: AttributeRegion[] = [];\n  const regionsByBuffer = new Map<ArrayBufferLike, AttributeRegion[]>();\n  for (const [buffer, ranges] of rangesByBuffer) {\n    ranges.sort((left, right) => left.start - right.start);\n    const bufferRegions: AttributeRegion[] = [];\n    for (const range of ranges) {\n      const previous = bufferRegions[bufferRegions.length - 1];\n      if (previous && range.start <= previous.end) {\n        previous.end = Math.max(previous.end, range.end);\n      } else {\n        const region = { buffer, ...range, outputOffset: 0 };\n        bufferRegions.push(region);\n        regions.push(region);\n      }\n    }\n    regionsByBuffer.set(buffer, bufferRegions);\n  }\n\n  let byteLength = 0;\n  for (const region of regions) {\n    region.outputOffset = byteLength;\n    byteLength += region.end - region.start;\n  }\n  const data = new Uint8Array(byteLength);\n  for (const region of regions) {\n    data.set(\n      new Uint8Array(region.buffer, region.start, region.end - region.start),\n      region.outputOffset,\n    );\n  }\n\n  const attributes: SerializedSplatPostDecodeAttribute[] = bindings.map(\n    (binding) => {\n      let byteOffset = 0;\n      if (binding.count !== 0) {\n        const sourceOffset = binding.data.byteOffset + binding.byteOffset;\n        const region = regionsByBuffer\n          .get(binding.data.buffer)\n          ?.find(\n            (candidate) =>\n              sourceOffset >= candidate.start && sourceOffset < candidate.end,\n          );\n        if (!region) {\n          throw new Error(\"postDecode attribute view was not serialized\");\n        }\n        byteOffset = region.outputOffset + sourceOffset - region.start;\n      }\n      return {\n        format: binding.format,\n        components: binding.components,\n        byteOffset,\n        byteStride: binding.byteStride,\n        count: binding.count,\n      };\n    },\n  );\n  return { data, attributes };\n}\n\nclass SplatPostDecodeProgramImpl implements SplatPostDecodeProgram {\n  readonly [SPLAT_POST_DECODE_PROGRAM] = true as const;\n\n  constructor(\n    private readonly builder: ProgramBuilder,\n    private readonly outputs: SplatPostDecodeOutputs,\n  ) {}\n\n  static serialize(program: SplatPostDecodeProgram): SerializedSplatPostDecode {\n    if (!(program instanceof SplatPostDecodeProgramImpl)) {\n      throw new Error(\"Invalid postDecode program\");\n    }\n    const compiled = compileProgram(program.builder, program.outputs);\n    const snapshot = snapshotAttributes(compiled.attributes);\n    return {\n      instructions: packInstructions(compiled.instructions),\n      constants: new Float32Array(compiled.constants),\n      outputs: compiled.outputs,\n      condition: compiled.condition,\n      attributeData: snapshot.data,\n      attributes: snapshot.attributes,\n    };\n  }\n}\n\n/** @internal */\nexport function serializeSplatPostDecode(\n  program: SplatPostDecodeProgram,\n): SerializedSplatPostDecode {\n  return SplatPostDecodeProgramImpl.serialize(program);\n}\n\nfunction buildOutputs(builder: ProgramBuilder, patch: SplatPostDecodePatch) {\n  if (patch.opacity !== undefined && patch.alpha !== undefined) {\n    throw new Error(\"postDecode opacity cannot be combined with alpha\");\n  }\n  const output = <T extends SplatPostDecodeValueType>(\n    value: ValueLike<T> | undefined,\n    type: T,\n  ) => (value === undefined ? undefined : builder.coerce(value, type).register);\n  const outputs: SplatPostDecodeOutputs = {\n    when: output(patch.when, \"bool\"),\n    position: output(patch.position, \"vec3\"),\n    scale: output(patch.scale, \"vec3\"),\n    quaternion: output(patch.quaternion, \"quaternion\"),\n    opacity: output(patch.opacity, \"float\"),\n    alpha: output(patch.alpha, \"float\"),\n    color: output(patch.color, \"vec3\"),\n  };\n  if (patch.sh !== undefined) {\n    if (\n      !(patch.sh instanceof SplatPostDecodeShPatch) ||\n      patch.sh.owner !== builder\n    ) {\n      throw new Error(\n        \"postDecode SH output must be created from splat.sh.map()\",\n      );\n    }\n    outputs.sh = patch.sh.coefficients.map((value) => value.register);\n  }\n  return outputs;\n}\n\nfunction defineSplatPostDecode(\n  build: (context: SplatPostDecodeContext) => SplatPostDecodePatch,\n): SplatPostDecodeProgram {\n  const builder = new ProgramBuilder();\n  const patch = build({\n    splat: builder.splat,\n    op: builder.op,\n    attribute: (options) => builder.attribute(options),\n  });\n  if (!patch || typeof patch !== \"object\") {\n    throw new Error(\"postDecode builder must return a splat patch object\");\n  }\n  return new SplatPostDecodeProgramImpl(builder, buildOutputs(builder, patch));\n}\n\nexport const postDecode = {\n  define: defineSplatPostDecode,\n};\n","import { fromHalf, toHalf } from \"./float16\";\n\nconst MAX_SPLAT_OPACITY = 1000;\nconst F32_EPSILON = 1.192_092_895_507_812_5e-7;\nconst ENCODED_IDENTITY_QUATERNION = (512 << 10) | 1023;\n\nfunction clamp(value: number, min: number, max: number) {\n  return Math.min(max, Math.max(min, value));\n}\n\nexport function decodeSplatOpacity(word: number) {\n  const shapeAmount = fromHalf(word >>> 16);\n  if (shapeAmount > 0) {\n    const kernelShape = shapeAmount * 4 + 1;\n    return Math.min(\n      MAX_SPLAT_OPACITY,\n      Math.exp((kernelShape * kernelShape - 1) / Math.E),\n    );\n  }\n  return fromHalf(word & 0xffff);\n}\n\nexport function encodeSplatOpacity(opacity: number) {\n  if (opacity > 0 && opacity <= 1) return toHalf(opacity);\n  const value = clamp(opacity, 0, MAX_SPLAT_OPACITY);\n  if (value > 1) {\n    const shapeAmount = 0.25 * (Math.sqrt(Math.log(value) * Math.E + 1) - 1);\n    return (toHalf(1) | (toHalf(shapeAmount) << 16)) >>> 0;\n  }\n  return toHalf(value);\n}\n\ntype QuaternionOutput = Float32Array | number[];\n\nexport function decodeQuatOctXy1010R12ToArray(\n  word: number,\n  output: QuaternionOutput,\n  base = 0,\n  stride = 1,\n) {\n  const u = word & 0x3ff;\n  const v = (word >>> 10) & 0x3ff;\n  const angle = word >>> 20;\n  let x = (u / 1023) * 2 - 1;\n  let y = (v / 1023) * 2 - 1;\n  const z = 1 - Math.abs(x) - Math.abs(y);\n  const fold = Math.max(-z, 0);\n  x += x >= 0 ? -fold : fold;\n  y += y >= 0 ? -fold : fold;\n  const inverseLength = 1 / Math.sqrt(x * x + y * y + z * z);\n  const halfTheta = (angle / 4095) * 0.5 * Math.PI;\n  const sine = Math.sin(halfTheta);\n  output[base] = x * inverseLength * sine;\n  output[base + stride] = y * inverseLength * sine;\n  output[base + stride * 2] = z * inverseLength * sine;\n  output[base + stride * 3] = Math.cos(halfTheta);\n}\n\nfunction encodeQuaternion(\n  qx: number,\n  qy: number,\n  qz: number,\n  qw: number,\n  minimumLengthSquared: number,\n) {\n  const lengthSquared = qx * qx + qy * qy + qz * qz + qw * qw;\n  if (\n    !Number.isFinite(lengthSquared) ||\n    lengthSquared <= minimumLengthSquared\n  ) {\n    return undefined;\n  }\n  if (qx === 0 && qy === 0 && qz === 0) {\n    return ENCODED_IDENTITY_QUATERNION;\n  }\n\n  const inverseLength = 1 / Math.sqrt(lengthSquared);\n  let x = qx * inverseLength;\n  let y = qy * inverseLength;\n  let z = qz * inverseLength;\n  let w = qw * inverseLength;\n  if (w < 0) {\n    x = -x;\n    y = -y;\n    z = -z;\n    w = -w;\n  }\n\n  const theta = 2 * Math.acos(clamp(w, 0, 1));\n  const sine = Math.sin(theta * 0.5);\n  const axisX = Math.abs(sine) < 1e-6 ? 1 : x / sine;\n  const axisY = Math.abs(sine) < 1e-6 ? 0 : y / sine;\n  const axisZ = Math.abs(sine) < 1e-6 ? 0 : z / sine;\n  const sum = Math.abs(axisX) + Math.abs(axisY) + Math.abs(axisZ);\n  let octX = axisX / sum;\n  let octY = axisY / sum;\n  if (axisZ < 0) {\n    const previousX = octX;\n    octX = (1 - Math.abs(octY)) * (octX >= 0 ? 1 : -1);\n    octY = (1 - Math.abs(previousX)) * (octY >= 0 ? 1 : -1);\n  }\n\n  const u = Math.round(clamp((octX * 0.5 + 0.5) * 1023, 0, 1023));\n  const v = Math.round(clamp((octY * 0.5 + 0.5) * 1023, 0, 1023));\n  const angle = Math.round(clamp((theta / Math.PI) * 4095, 0, 4095));\n  return ((angle << 20) | (v << 10) | u) >>> 0;\n}\n\nexport function encodeQuatOctXy1010R12(\n  qx: number,\n  qy: number,\n  qz: number,\n  qw: number,\n): number {\n  return (encodeQuaternion(qx, qy, qz, qw, 0) ?? 0) | 0;\n}\n\nexport function tryEncodeQuatOctXy1010R12(\n  qx: number,\n  qy: number,\n  qz: number,\n  qw: number,\n) {\n  return encodeQuaternion(qx, qy, qz, qw, F32_EPSILON);\n}\n","import { fromHalf, toHalf } from \"./float16\";\nimport {\n  ATTRIBUTE_FORMAT_BYTES,\n  InputField,\n  Opcode,\n  SH_COEFFICIENT_COUNT,\n  SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION,\n  SPLAT_POST_DECODE_FLOW_STAGE_ON_FALSE,\n  SPLAT_POST_DECODE_FLOW_STAGE_ON_TRUE,\n  SPLAT_POST_DECODE_FLOW_STAGE_REGISTER,\n  SPLAT_POST_DECODE_FLOW_STAGE_START,\n  SPLAT_POST_DECODE_FLOW_STAGE_STRIDE,\n  SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_0,\n  SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_COUNT,\n  SPLAT_POST_DECODE_INSTRUCTION_IMMEDIATE,\n  SPLAT_POST_DECODE_INSTRUCTION_OPCODE,\n  SPLAT_POST_DECODE_INSTRUCTION_STRIDE,\n  SPLAT_POST_DECODE_INSTRUCTION_WIDTH,\n  SPLAT_POST_DECODE_MISSING_ARGUMENT,\n  type SerializedSplatPostDecode,\n  type SerializedSplatPostDecodeAttribute,\n} from \"./postDecode\";\nimport {\n  decodeQuatOctXy1010R12ToArray,\n  decodeSplatOpacity,\n  encodeSplatOpacity,\n  tryEncodeQuatOctXy1010R12,\n} from \"./splatCodec\";\n\nexport type PostDecodeSplatData = {\n  numSplats: number;\n  splat0: Uint32Array;\n  splat1: Uint32Array;\n  sortCenters: Float32Array;\n  sh1?: Uint32Array;\n  sh2?: Uint32Array;\n  sh3a?: Uint32Array;\n  sh3b?: Uint32Array;\n};\n\nconst MAX_BLOCK_SIZE = 512;\nconst MAX_REGISTER_BYTES = 4 * 1024 ** 2;\nconst CONDITION_CARRY_EVENT_OFFSET_MASK = 0x7fff_ffff;\nconst CONDITION_CARRY_EVENT_REMOVAL = 0x8000_0000;\n\nfunction getInstructionCount(instructions: Uint16Array) {\n  const count = instructions.length / SPLAT_POST_DECODE_INSTRUCTION_STRIDE;\n  if (!Number.isInteger(count)) {\n    throw new Error(\"Invalid packed postDecode instructions\");\n  }\n  return count;\n}\n\nfunction instructionWidth(instructions: Uint16Array, index: number) {\n  return instructions[\n    index * SPLAT_POST_DECODE_INSTRUCTION_STRIDE +\n      SPLAT_POST_DECODE_INSTRUCTION_WIDTH\n  ];\n}\n\nfunction getBlockSize(registerValueCount: number, processCount: number) {\n  const bytesPerSplat = registerValueCount * Float32Array.BYTES_PER_ELEMENT;\n  return Math.min(\n    processCount,\n    MAX_BLOCK_SIZE,\n    Math.max(1, Math.floor(MAX_REGISTER_BYTES / bytesPerSplat)),\n  );\n}\n\ntype FreeRegisterRange = {\n  offset: number;\n  width: number;\n};\n\n/** @internal */\nexport function allocateSplatPostDecodeRegisters(\n  program: SerializedSplatPostDecode,\n) {\n  const { instructions, outputs, condition } = program;\n  const instructionCount = getInstructionCount(instructions);\n  const lastUses = new Uint32Array(instructionCount);\n  for (let index = 0; index < instructionCount; index += 1) {\n    lastUses[index] = index;\n    const instructionOffset = index * SPLAT_POST_DECODE_INSTRUCTION_STRIDE;\n    for (\n      let argumentIndex = 0;\n      argumentIndex < SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_COUNT;\n      argumentIndex += 1\n    ) {\n      const argument =\n        instructions[\n          instructionOffset +\n            SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_0 +\n            argumentIndex\n        ];\n      if (argument === SPLAT_POST_DECODE_MISSING_ARGUMENT) break;\n      lastUses[argument] = index;\n    }\n  }\n  const packedConditionStages = condition?.stages;\n  if (packedConditionStages) {\n    for (\n      let stageOffset = 0;\n      stageOffset < packedConditionStages.length;\n      stageOffset += SPLAT_POST_DECODE_FLOW_STAGE_STRIDE\n    ) {\n      const register =\n        packedConditionStages[\n          stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_REGISTER\n        ];\n      const instruction =\n        packedConditionStages[\n          stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION\n        ];\n      lastUses[register] = Math.max(lastUses[register], instruction);\n    }\n  }\n\n  const programEnd = instructionCount;\n  for (const output of [\n    outputs.position,\n    outputs.scale,\n    outputs.quaternion,\n    outputs.opacity,\n    outputs.alpha,\n    outputs.color,\n    ...(outputs.sh ?? []),\n  ]) {\n    if (output !== undefined) lastUses[output] = programEnd;\n  }\n\n  const registerOffsets = new Uint32Array(instructionCount);\n  const constantRegisters = new Uint8Array(instructionCount);\n  let registerValueCount = 0;\n  for (let index = 0; index < instructionCount; index += 1) {\n    const instructionOffset = index * SPLAT_POST_DECODE_INSTRUCTION_STRIDE;\n    if (\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_OPCODE] ===\n      Opcode.Constant\n    ) {\n      constantRegisters[index] = 1;\n      lastUses[index] = programEnd;\n      registerOffsets[index] = registerValueCount;\n      registerValueCount +=\n        instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_WIDTH];\n    }\n  }\n\n  const releaseHeads = new Int32Array(instructionCount + 1).fill(-1);\n  const releaseNext = new Int32Array(instructionCount).fill(-1);\n  const freeRanges: FreeRegisterRange[] = [];\n\n  const release = (releasedOffset: number, releasedWidth: number) => {\n    let offset = releasedOffset;\n    let width = releasedWidth;\n    let insertIndex = 0;\n    while (\n      insertIndex < freeRanges.length &&\n      freeRanges[insertIndex].offset < offset\n    ) {\n      insertIndex += 1;\n    }\n\n    const previous = freeRanges[insertIndex - 1];\n    if (previous && previous.offset + previous.width === offset) {\n      offset = previous.offset;\n      width += previous.width;\n      freeRanges.splice(insertIndex - 1, 1);\n      insertIndex -= 1;\n    }\n    const next = freeRanges[insertIndex];\n    if (next && offset + width === next.offset) {\n      width += next.width;\n      freeRanges.splice(insertIndex, 1);\n    }\n    freeRanges.splice(insertIndex, 0, { offset, width });\n  };\n\n  const allocate = (width: number) => {\n    let bestIndex = -1;\n    for (let index = 0; index < freeRanges.length; index += 1) {\n      const range = freeRanges[index];\n      if (\n        range.width >= width &&\n        (bestIndex === -1 || range.width < freeRanges[bestIndex].width)\n      ) {\n        bestIndex = index;\n      }\n    }\n    if (bestIndex === -1) {\n      const offset = registerValueCount;\n      registerValueCount += width;\n      return offset;\n    }\n\n    const range = freeRanges[bestIndex];\n    const offset = range.offset;\n    if (range.width === width) freeRanges.splice(bestIndex, 1);\n    else {\n      range.offset += width;\n      range.width -= width;\n    }\n    return offset;\n  };\n\n  for (let index = 0; index < instructionCount; index += 1) {\n    for (\n      let released = releaseHeads[index];\n      released !== -1;\n      released = releaseNext[released]\n    ) {\n      release(\n        registerOffsets[released],\n        instructionWidth(instructions, released),\n      );\n    }\n    if (constantRegisters[index]) continue;\n    const width = instructionWidth(instructions, index);\n    const offset = allocate(width);\n    registerOffsets[index] = offset;\n    const releaseIndex = lastUses[index] + 1;\n    if (releaseIndex <= instructionCount) {\n      releaseNext[index] = releaseHeads[releaseIndex];\n      releaseHeads[releaseIndex] = index;\n    }\n  }\n  const conditionStageCount = packedConditionStages\n    ? packedConditionStages.length / SPLAT_POST_DECODE_FLOW_STAGE_STRIDE\n    : 0;\n  if (!Number.isInteger(conditionStageCount)) {\n    throw new Error(\"Invalid packed postDecode condition flow\");\n  }\n  let conditionCarryStageStarts = new Uint32Array();\n  let conditionCarryEvents = new Uint32Array();\n  if (packedConditionStages && conditionStageCount !== 0) {\n    if (registerValueCount > 0x1_0000) {\n      throw new Error(\"postDecode register offsets exceed Uint16 capacity\");\n    }\n\n    const stageBoundaries = new Uint16Array(conditionStageCount);\n    for (let stage = 0; stage < conditionStageCount; stage += 1) {\n      const boundary =\n        packedConditionStages[\n          stage * SPLAT_POST_DECODE_FLOW_STAGE_STRIDE +\n            SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION\n        ] + 1;\n      if (\n        boundary > instructionCount ||\n        (stage !== 0 && boundary <= stageBoundaries[stage - 1])\n      ) {\n        throw new Error(\"Invalid postDecode condition stage boundary\");\n      }\n      stageBoundaries[stage] = boundary;\n    }\n\n    const stageAfterInstruction = (instruction: number) => {\n      let start = 0;\n      let end = conditionStageCount;\n      while (start < end) {\n        const middle = (start + end) >>> 1;\n        if (stageBoundaries[middle] <= instruction) start = middle + 1;\n        else end = middle;\n      }\n      return start;\n    };\n    const firstStages = new Uint16Array(instructionCount);\n    const endStages = new Uint16Array(instructionCount);\n    const eventCounts = new Uint32Array(conditionStageCount);\n    const removalCounts = new Uint32Array(conditionStageCount);\n    for (let index = 0; index < instructionCount; index += 1) {\n      if (constantRegisters[index]) continue;\n      const firstStage = stageAfterInstruction(index);\n      const endStage = stageAfterInstruction(lastUses[index]);\n      if (firstStage >= endStage) continue;\n      firstStages[index] = firstStage;\n      endStages[index] = endStage;\n      const width =\n        instructions[\n          index * SPLAT_POST_DECODE_INSTRUCTION_STRIDE +\n            SPLAT_POST_DECODE_INSTRUCTION_WIDTH\n        ];\n      eventCounts[firstStage] += width;\n      if (endStage < conditionStageCount) {\n        eventCounts[endStage] += width;\n        removalCounts[endStage] += width;\n      }\n    }\n    const eventStarts = new Uint32Array(conditionStageCount + 1);\n    for (let stage = 0; stage < conditionStageCount; stage += 1) {\n      eventStarts[stage + 1] = eventStarts[stage] + eventCounts[stage];\n    }\n    conditionCarryStageStarts = eventStarts;\n\n    conditionCarryEvents = new Uint32Array(eventStarts[conditionStageCount]);\n    const removalCursors = new Uint32Array(\n      eventStarts.subarray(0, conditionStageCount),\n    );\n    const additionCursors = new Uint32Array(conditionStageCount);\n    for (let stage = 0; stage < conditionStageCount; stage += 1) {\n      additionCursors[stage] = eventStarts[stage] + removalCounts[stage];\n    }\n    for (let index = 0; index < instructionCount; index += 1) {\n      const firstStage = firstStages[index];\n      const endStage = endStages[index];\n      if (firstStage >= endStage) continue;\n      const width =\n        instructions[\n          index * SPLAT_POST_DECODE_INSTRUCTION_STRIDE +\n            SPLAT_POST_DECODE_INSTRUCTION_WIDTH\n        ];\n      const offset = registerOffsets[index];\n      for (let lane = 0; lane < width; lane += 1) {\n        const carryOffset = offset + lane;\n        if (endStage < conditionStageCount) {\n          conditionCarryEvents[removalCursors[endStage]] =\n            CONDITION_CARRY_EVENT_REMOVAL | carryOffset;\n          removalCursors[endStage] += 1;\n        }\n        conditionCarryEvents[additionCursors[firstStage]] = carryOffset;\n        additionCursors[firstStage] += 1;\n      }\n    }\n  }\n\n  return {\n    registerOffsets,\n    registerValueCount,\n    conditionCarryStageStarts,\n    conditionCarryEvents,\n  };\n}\n\nfunction rustMin(left: number, right: number) {\n  if (Number.isNaN(left)) return right;\n  if (Number.isNaN(right)) return left;\n  return Math.min(left, right);\n}\n\nfunction rustMax(left: number, right: number) {\n  if (Number.isNaN(left)) return right;\n  if (Number.isNaN(right)) return left;\n  return Math.max(left, right);\n}\n\nfunction roundAwayFromZero(value: number) {\n  return value < 0 ? -Math.round(-value) : Math.round(value);\n}\n\nfunction clamp(value: number, min: number, max: number) {\n  return Math.min(max, Math.max(min, value));\n}\n\nconst ATTRIBUTE_READERS = {\n  f32: (data, offset) => data.getFloat32(offset, true),\n  f16: (data, offset) => fromHalf(data.getUint16(offset, true)),\n  u8: (data, offset) => data.getUint8(offset),\n  unorm8: (data, offset) => data.getUint8(offset) / 0xff,\n  i8: (data, offset) => data.getInt8(offset),\n  snorm8: (data, offset) => Math.max(-1, data.getInt8(offset) / 0x7f),\n  u16: (data, offset) => data.getUint16(offset, true),\n  unorm16: (data, offset) => data.getUint16(offset, true) / 0xffff,\n  i16: (data, offset) => data.getInt16(offset, true),\n  snorm16: (data, offset) => Math.max(-1, data.getInt16(offset, true) / 0x7fff),\n  u32: (data, offset) => data.getUint32(offset, true),\n  i32: (data, offset) => data.getInt32(offset, true),\n} satisfies Record<\n  SerializedSplatPostDecodeAttribute[\"format\"],\n  (data: DataView, offset: number) => number\n>;\n\nfunction readAttributeBlock(\n  data: DataView,\n  attribute: SerializedSplatPostDecodeAttribute,\n  blockStart: number,\n  blockCount: number,\n  blockSize: number,\n  registers: Float32Array,\n  outputBase: number,\n  sourceIndices?: Uint16Array,\n) {\n  const componentBytes = ATTRIBUTE_FORMAT_BYTES[attribute.format];\n  const read = ATTRIBUTE_READERS[attribute.format];\n  for (let component = 0; component < attribute.components; component += 1) {\n    const componentOutput = outputBase + component * blockSize;\n    if (sourceIndices) {\n      for (let index = 0; index < blockCount; index += 1) {\n        const inputOffset =\n          attribute.byteOffset +\n          (blockStart + sourceIndices[index]) * attribute.byteStride +\n          component * componentBytes;\n        registers[componentOutput + index] = read(data, inputOffset);\n      }\n    } else {\n      let inputOffset =\n        attribute.byteOffset +\n        blockStart * attribute.byteStride +\n        component * componentBytes;\n      for (let index = 0; index < blockCount; index += 1) {\n        registers[componentOutput + index] = read(data, inputOffset);\n        inputOffset += attribute.byteStride;\n      }\n    }\n  }\n}\n\nfunction encodeQuaternion(\n  registers: Float32Array,\n  base: number,\n  stride: number,\n) {\n  return tryEncodeQuatOctXy1010R12(\n    registers[base],\n    registers[base + stride],\n    registers[base + stride * 2],\n    registers[base + stride * 3],\n  );\n}\n\nfunction decodeSh(\n  word: number,\n  output: Float32Array,\n  base: number,\n  stride: number,\n) {\n  const exponentAndSigns = word >>> 24;\n  const multiplier = 2 ** ((exponentAndSigns >>> 3) - 15) / 255;\n  for (let component = 0; component < 3; component += 1) {\n    const magnitude = ((word >>> (component * 8)) & 0xff) * multiplier;\n    output[base + component * stride] =\n      exponentAndSigns & (1 << component) ? -magnitude : magnitude;\n  }\n}\n\nfunction encodeSh(registers: Float32Array, base: number, stride: number) {\n  const red = registers[base];\n  const green = registers[base + stride];\n  const blue = registers[base + stride * 2];\n  const maxAbsolute = rustMax(\n    Math.abs(red),\n    rustMax(Math.abs(green), Math.abs(blue)),\n  );\n  const exponent = roundAwayFromZero(\n    clamp(Math.floor(Math.log2(maxAbsolute)) + 15, 0, 31),\n  );\n  const divisor = 2 ** (exponent - 15) / 255;\n  const encodeComponent = (value: number) =>\n    roundAwayFromZero(clamp(Math.abs(value) / divisor, 0, 255));\n  const signs = (red < 0 ? 1 : 0) | (green < 0 ? 2 : 0) | (blue < 0 ? 4 : 0);\n  return (\n    (encodeComponent(red) |\n      (encodeComponent(green) << 8) |\n      (encodeComponent(blue) << 16) |\n      (((exponent << 3) | signs) << 24)) >>>\n    0\n  );\n}\n\nfunction shWord(\n  data: PostDecodeSplatData,\n  coefficient: number,\n): [Uint32Array, number] | undefined {\n  if (coefficient <= 2 && data.sh1) return [data.sh1, coefficient];\n  if (coefficient === 3 && data.sh1 && data.sh2) return [data.sh1, 3];\n  if (coefficient <= 7 && data.sh2) return [data.sh2, coefficient - 4];\n  if (coefficient <= 11 && data.sh3a) return [data.sh3a, coefficient - 8];\n  if (coefficient <= 14 && data.sh3b) return [data.sh3b, coefficient - 12];\n  return undefined;\n}\n\nconst OUTPUT_POSITION = 0;\nconst OUTPUT_SCALE = 1;\nconst OUTPUT_QUATERNION = 2;\nconst OUTPUT_OPACITY = 3;\nconst OUTPUT_ALPHA = 4;\nconst OUTPUT_COLOR = 5;\nconst OUTPUT_COUNT = 6;\nconst MISSING_OUTPUT_BASE = 0xffff_ffff;\n\ntype OutputWritePlan = {\n  outputBases: Uint32Array;\n  shTargetArrays: readonly Uint32Array[];\n  shWordOffsets: Uint8Array;\n  shRegisterBases: Uint32Array;\n  updatesSortCenter: boolean;\n  writesOutputs: boolean;\n};\n\nfunction createOutputWritePlan(\n  data: PostDecodeSplatData,\n  program: SerializedSplatPostDecode,\n  registerBases: Uint32Array,\n): OutputWritePlan {\n  const { outputs } = program;\n  const outputBases = new Uint32Array(OUTPUT_COUNT);\n  outputBases.fill(MISSING_OUTPUT_BASE);\n  let outputFieldCount = 0;\n  const setOutputBase = (slot: number, register: number | undefined) => {\n    if (register !== undefined) {\n      outputBases[slot] = registerBases[register];\n      outputFieldCount += 1;\n    }\n  };\n  setOutputBase(OUTPUT_POSITION, outputs.position);\n  setOutputBase(OUTPUT_SCALE, outputs.scale);\n  setOutputBase(OUTPUT_QUATERNION, outputs.quaternion);\n  setOutputBase(OUTPUT_OPACITY, outputs.opacity);\n  setOutputBase(OUTPUT_ALPHA, outputs.alpha);\n  setOutputBase(OUTPUT_COLOR, outputs.color);\n\n  const shTargetArrays: Uint32Array[] = [];\n  const shWordOffsets: number[] = [];\n  const shRegisterBases: number[] = [];\n  if (outputs.sh) {\n    for (\n      let coefficient = 0;\n      coefficient < SH_COEFFICIENT_COUNT;\n      coefficient += 1\n    ) {\n      const location = shWord(data, coefficient);\n      if (!location) continue;\n      shTargetArrays.push(location[0]);\n      shWordOffsets.push(location[1]);\n      shRegisterBases.push(registerBases[outputs.sh[coefficient]]);\n    }\n  }\n\n  return {\n    outputBases,\n    shTargetArrays,\n    shWordOffsets: new Uint8Array(shWordOffsets),\n    shRegisterBases: new Uint32Array(shRegisterBases),\n    updatesSortCenter:\n      outputs.position !== undefined || outputs.scale !== undefined,\n    writesOutputs: outputFieldCount !== 0 || shTargetArrays.length !== 0,\n  };\n}\n\nfunction evaluateInputFieldBlock(\n  field: number,\n  blockStart: number,\n  blockCount: number,\n  blockSize: number,\n  data: PostDecodeSplatData,\n  splat0Float: Float32Array,\n  registers: Float32Array,\n  outputBase: number,\n  sourceIndices?: Uint16Array,\n) {\n  switch (field) {\n    case InputField.Position:\n      for (let index = 0; index < blockCount; index += 1) {\n        const sourceIndex = sourceIndices?.[index] ?? index;\n        const wordBase = (blockStart + sourceIndex) * 4;\n        registers[outputBase + index] = splat0Float[wordBase];\n        registers[outputBase + blockSize + index] = splat0Float[wordBase + 1];\n        registers[outputBase + blockSize * 2 + index] =\n          splat0Float[wordBase + 2];\n      }\n      break;\n    case InputField.Scale:\n      for (let index = 0; index < blockCount; index += 1) {\n        const sourceIndex = sourceIndices?.[index] ?? index;\n        const wordBase = (blockStart + sourceIndex) * 4;\n        const word1 = data.splat1[wordBase + 1];\n        const word2 = data.splat1[wordBase + 2];\n        registers[outputBase + index] = Math.exp(fromHalf(word1 >>> 16));\n        registers[outputBase + blockSize + index] = Math.exp(\n          fromHalf(word2 & 0xffff),\n        );\n        registers[outputBase + blockSize * 2 + index] = Math.exp(\n          fromHalf(word2 >>> 16),\n        );\n      }\n      break;\n    case InputField.Quaternion:\n      for (let index = 0; index < blockCount; index += 1) {\n        const sourceIndex = sourceIndices?.[index] ?? index;\n        const wordBase = (blockStart + sourceIndex) * 4;\n        decodeQuatOctXy1010R12ToArray(\n          data.splat1[wordBase + 3],\n          registers,\n          outputBase + index,\n          blockSize,\n        );\n      }\n      break;\n    case InputField.Opacity:\n      for (let index = 0; index < blockCount; index += 1) {\n        const sourceIndex = sourceIndices?.[index] ?? index;\n        registers[outputBase + index] = decodeSplatOpacity(\n          data.splat0[(blockStart + sourceIndex) * 4 + 3],\n        );\n      }\n      break;\n    case InputField.Alpha:\n      for (let index = 0; index < blockCount; index += 1) {\n        const sourceIndex = sourceIndices?.[index] ?? index;\n        registers[outputBase + index] = fromHalf(\n          data.splat0[(blockStart + sourceIndex) * 4 + 3] & 0xffff,\n        );\n      }\n      break;\n    case InputField.Color:\n      for (let index = 0; index < blockCount; index += 1) {\n        const sourceIndex = sourceIndices?.[index] ?? index;\n        const wordBase = (blockStart + sourceIndex) * 4;\n        const word0 = data.splat1[wordBase];\n        const word1 = data.splat1[wordBase + 1];\n        registers[outputBase + index] = fromHalf(word0 & 0xffff);\n        registers[outputBase + blockSize + index] = fromHalf(word0 >>> 16);\n        registers[outputBase + blockSize * 2 + index] = fromHalf(\n          word1 & 0xffff,\n        );\n      }\n      break;\n    default: {\n      const coefficient = field - InputField.Sh0;\n      const location = shWord(data, coefficient);\n      if (location) {\n        for (let index = 0; index < blockCount; index += 1) {\n          const sourceIndex = sourceIndices?.[index] ?? index;\n          decodeSh(\n            location[0][(blockStart + sourceIndex) * 4 + location[1]],\n            registers,\n            outputBase + index,\n            blockSize,\n          );\n        }\n      } else {\n        registers.fill(0, outputBase, outputBase + blockCount);\n        registers.fill(\n          0,\n          outputBase + blockSize,\n          outputBase + blockSize + blockCount,\n        );\n        registers.fill(\n          0,\n          outputBase + blockSize * 2,\n          outputBase + blockSize * 2 + blockCount,\n        );\n      }\n    }\n  }\n}\n\ntype RuntimePlan = {\n  outputPlan: OutputWritePlan;\n  registerBases: Uint32Array;\n  conditionStages?: Uint16Array;\n  conditionStageCount: number;\n  outputInstructionStart: number;\n  conditionCarryStageStarts: Uint32Array;\n  conditionCarryEvents: Uint32Array;\n  blockSize: number;\n  registerValueCount: number;\n};\n\nfunction prepareProgram(\n  data: PostDecodeSplatData,\n  program: SerializedSplatPostDecode,\n  processCount: number,\n): RuntimePlan {\n  const {\n    registerOffsets: registerBases,\n    registerValueCount,\n    conditionCarryStageStarts,\n    conditionCarryEvents,\n  } = allocateSplatPostDecodeRegisters(program);\n  const blockSize = getBlockSize(registerValueCount, processCount);\n  for (let index = 0; index < registerBases.length; index += 1) {\n    registerBases[index] *= blockSize;\n  }\n  const conditionStages = program.condition?.stages;\n  const conditionStageCount =\n    (conditionStages?.length ?? 0) / SPLAT_POST_DECODE_FLOW_STAGE_STRIDE;\n  const outputInstructionStart =\n    (conditionStages?.[\n      conditionStages.length -\n        SPLAT_POST_DECODE_FLOW_STAGE_STRIDE +\n        SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION\n    ] ?? -1) + 1;\n  return {\n    outputPlan: createOutputWritePlan(data, program, registerBases),\n    registerBases,\n    conditionStages,\n    conditionStageCount,\n    outputInstructionStart,\n    conditionCarryStageStarts,\n    conditionCarryEvents,\n    blockSize,\n    registerValueCount,\n  };\n}\n\nfunction compactRegisterBlock(\n  registers: Float32Array,\n  activeOffsets: Uint16Array,\n  activeCount: number,\n  laneIndices: Uint16Array,\n  nextCount: number,\n  blockSize: number,\n) {\n  for (let carryIndex = 0; carryIndex < activeCount; carryIndex += 1) {\n    const offset = activeOffsets[carryIndex];\n    const base = offset * blockSize;\n    // Ascending lanes make this forward in-place copy safe.\n    for (let index = 0; index < nextCount; index += 1) {\n      registers[base + index] = registers[base + laneIndices[index]];\n    }\n  }\n}\n\ntype ConditionCarryState = {\n  stageStarts: Uint32Array;\n  events: Uint32Array;\n  nextStage: number;\n  activeOffsets: Uint16Array;\n  activePositions: Int32Array;\n  activeCount: number;\n};\n\nfunction applyConditionCarryEvents(carry: ConditionCarryState, stage: number) {\n  while (carry.nextStage <= stage) {\n    const eventStart = carry.stageStarts[carry.nextStage];\n    const eventEnd = carry.stageStarts[carry.nextStage + 1];\n    for (let eventIndex = eventStart; eventIndex < eventEnd; eventIndex += 1) {\n      const event = carry.events[eventIndex];\n      const offset = event & CONDITION_CARRY_EVENT_OFFSET_MASK;\n      if (event & CONDITION_CARRY_EVENT_REMOVAL) {\n        const position = carry.activePositions[offset];\n        if (position === -1) {\n          throw new Error(\"Invalid postDecode condition carry removal\");\n        }\n        const lastPosition = carry.activeCount - 1;\n        const lastOffset = carry.activeOffsets[lastPosition];\n        if (position !== lastPosition) {\n          carry.activeOffsets[position] = lastOffset;\n          carry.activePositions[lastOffset] = position;\n        }\n        carry.activePositions[offset] = -1;\n        carry.activeCount = lastPosition;\n      } else {\n        if (carry.activePositions[offset] !== -1) {\n          throw new Error(\"Invalid postDecode condition carry addition\");\n        }\n        carry.activePositions[offset] = carry.activeCount;\n        carry.activeOffsets[carry.activeCount] = offset;\n        carry.activeCount += 1;\n      }\n    }\n    carry.nextStage += 1;\n  }\n}\n\nfunction collectConditionFlowBlock(\n  heads: Int32Array,\n  nextIndices: Int32Array,\n  sourceIndices: Uint16Array,\n  stage: number,\n  initialCount = 0,\n) {\n  let count = initialCount;\n  let sourceIndex = heads[stage];\n  while (sourceIndex !== -1) {\n    sourceIndices[count] = sourceIndex;\n    count += 1;\n    sourceIndex = nextIndices[sourceIndex];\n  }\n  heads[stage] = -1;\n  return count;\n}\n\nfunction enqueueConditionFlowBlock(\n  heads: Int32Array,\n  nextIndices: Int32Array,\n  stage: number,\n  sourceIndex: number,\n) {\n  if (stage < 0 || stage >= heads.length) return;\n  nextIndices[sourceIndex] = heads[stage];\n  heads[stage] = sourceIndex;\n}\n\nfunction evaluateUnaryBlock(\n  opcode: Opcode,\n  registers: Float32Array,\n  outputBase: number,\n  inputBase: number,\n  width: number,\n  blockSize: number,\n  blockCount: number,\n) {\n  for (let component = 0; component < width; component += 1) {\n    const output = outputBase + component * blockSize;\n    const input = inputBase + component * blockSize;\n    switch (opcode) {\n      case Opcode.Negate:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = -registers[input + lane];\n        }\n        break;\n      case Opcode.Abs:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.abs(registers[input + lane]);\n        }\n        break;\n      case Opcode.Log:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.log(registers[input + lane]);\n        }\n        break;\n      case Opcode.Exp:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.exp(registers[input + lane]);\n        }\n        break;\n      case Opcode.Floor:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.floor(registers[input + lane]);\n        }\n        break;\n      case Opcode.Ceil:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.ceil(registers[input + lane]);\n        }\n        break;\n      case Opcode.Round:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = roundAwayFromZero(registers[input + lane]);\n        }\n        break;\n      case Opcode.Sin:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.sin(registers[input + lane]);\n        }\n        break;\n      case Opcode.Cos:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.cos(registers[input + lane]);\n        }\n        break;\n      case Opcode.Acos:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.acos(registers[input + lane]);\n        }\n        break;\n      case Opcode.Tan:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.tan(registers[input + lane]);\n        }\n        break;\n      case Opcode.Asin:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.asin(registers[input + lane]);\n        }\n        break;\n      case Opcode.Atan:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.atan(registers[input + lane]);\n        }\n        break;\n    }\n  }\n}\n\nfunction evaluateBinaryBlock(\n  opcode: Opcode,\n  registers: Float32Array,\n  outputBase: number,\n  arg0: number,\n  arg1: number,\n  width: number,\n  arg1Width: number,\n  blockSize: number,\n  blockCount: number,\n) {\n  for (let component = 0; component < width; component += 1) {\n    const output = outputBase + component * blockSize;\n    const left = arg0 + component * blockSize;\n    const right = arg1 + (arg1Width === 1 ? 0 : component * blockSize);\n    switch (opcode) {\n      case Opcode.Add:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] =\n            registers[left + lane] + registers[right + lane];\n        }\n        break;\n      case Opcode.Subtract:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] =\n            registers[left + lane] - registers[right + lane];\n        }\n        break;\n      case Opcode.Multiply:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] =\n            registers[left + lane] * registers[right + lane];\n        }\n        break;\n      case Opcode.Divide:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] =\n            registers[left + lane] / registers[right + lane];\n        }\n        break;\n      case Opcode.Pow:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] =\n            registers[left + lane] ** registers[right + lane];\n        }\n        break;\n      case Opcode.Min:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = rustMin(\n            registers[left + lane],\n            registers[right + lane],\n          );\n        }\n        break;\n      case Opcode.Max:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = rustMax(\n            registers[left + lane],\n            registers[right + lane],\n          );\n        }\n        break;\n      case Opcode.Atan2:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[output + lane] = Math.atan2(\n            registers[left + lane],\n            registers[right + lane],\n          );\n        }\n        break;\n    }\n  }\n}\n\nfunction executeRange(\n  data: PostDecodeSplatData,\n  program: SerializedSplatPostDecode,\n  attributeData: DataView,\n  splat0Float: Float32Array,\n  registers: Float32Array,\n  registerBases: Uint32Array,\n  instructionStart: number,\n  instructionEnd: number,\n  blockStart: number,\n  blockCount: number,\n  blockSize: number,\n  sourceIndices?: Uint16Array,\n) {\n  const { attributes, instructions } = program;\n  for (\n    let instructionIndex = instructionStart;\n    instructionIndex < instructionEnd;\n    instructionIndex += 1\n  ) {\n    const instructionOffset =\n      instructionIndex * SPLAT_POST_DECODE_INSTRUCTION_STRIDE;\n    const opcode =\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_OPCODE];\n    if (opcode === Opcode.Constant) continue;\n    const width =\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_WIDTH];\n    const immediate =\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_IMMEDIATE];\n    const outputBase = registerBases[instructionIndex];\n    const argumentOffset =\n      instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_0;\n    const arg0Register = instructions[argumentOffset];\n    const arg1Register = instructions[argumentOffset + 1];\n    const arg2Register = instructions[argumentOffset + 2];\n    const arg3Register = instructions[argumentOffset + 3];\n    const arg0 =\n      arg0Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : registerBases[arg0Register];\n    const arg1 =\n      arg1Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : registerBases[arg1Register];\n    const arg2 =\n      arg2Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : registerBases[arg2Register];\n    const arg3 =\n      arg3Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : registerBases[arg3Register];\n    const arg0Width =\n      arg0Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : instructionWidth(instructions, arg0Register);\n    const arg1Width =\n      arg1Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : instructionWidth(instructions, arg1Register);\n    const arg2Width =\n      arg2Register === SPLAT_POST_DECODE_MISSING_ARGUMENT\n        ? 0\n        : instructionWidth(instructions, arg2Register);\n\n    switch (opcode) {\n      case Opcode.InputField:\n        evaluateInputFieldBlock(\n          immediate,\n          blockStart,\n          blockCount,\n          blockSize,\n          data,\n          splat0Float,\n          registers,\n          outputBase,\n          sourceIndices,\n        );\n        break;\n      case Opcode.InputAttribute:\n        readAttributeBlock(\n          attributeData,\n          attributes[immediate],\n          blockStart,\n          blockCount,\n          blockSize,\n          registers,\n          outputBase,\n          sourceIndices,\n        );\n        break;\n      case Opcode.Negate:\n      case Opcode.Abs:\n      case Opcode.Log:\n      case Opcode.Exp:\n      case Opcode.Floor:\n      case Opcode.Ceil:\n      case Opcode.Round:\n      case Opcode.Sin:\n      case Opcode.Cos:\n      case Opcode.Acos:\n      case Opcode.Tan:\n      case Opcode.Asin:\n      case Opcode.Atan:\n        evaluateUnaryBlock(\n          opcode,\n          registers,\n          outputBase,\n          arg0,\n          width,\n          blockSize,\n          blockCount,\n        );\n        break;\n      case Opcode.Sqrt:\n        for (let component = 0; component < width; component += 1) {\n          const output = outputBase + component * blockSize;\n          const input = arg0 + component * blockSize;\n          for (let lane = 0; lane < blockCount; lane += 1) {\n            registers[output + lane] = Math.sqrt(registers[input + lane]);\n          }\n        }\n        break;\n      case Opcode.Normalize:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          let lengthSquared = 0;\n          for (let component = 0; component < width; component += 1) {\n            const value = registers[arg0 + component * blockSize + lane];\n            lengthSquared += value * value;\n          }\n          const length = Math.sqrt(lengthSquared);\n          for (let component = 0; component < width; component += 1) {\n            const input = registers[arg0 + component * blockSize + lane];\n            registers[outputBase + component * blockSize + lane] =\n              length === 0 || !Number.isFinite(length) ? input : input / length;\n          }\n        }\n        break;\n      case Opcode.Length:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          let lengthSquared = 0;\n          for (let component = 0; component < arg0Width; component += 1) {\n            const value = registers[arg0 + component * blockSize + lane];\n            lengthSquared += value * value;\n          }\n          registers[outputBase + lane] = Math.sqrt(lengthSquared);\n        }\n        break;\n      case Opcode.IsFinite:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          let finite = true;\n          for (let component = 0; component < arg0Width; component += 1) {\n            finite &&= Number.isFinite(\n              registers[arg0 + component * blockSize + lane],\n            );\n          }\n          registers[outputBase + lane] = finite ? 1 : 0;\n        }\n        break;\n      case Opcode.Not:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] = registers[arg0 + lane] === 0 ? 1 : 0;\n        }\n        break;\n      case Opcode.Add:\n      case Opcode.Subtract:\n      case Opcode.Multiply:\n      case Opcode.Divide:\n      case Opcode.Pow:\n      case Opcode.Min:\n      case Opcode.Max:\n      case Opcode.Atan2:\n        evaluateBinaryBlock(\n          opcode,\n          registers,\n          outputBase,\n          arg0,\n          arg1,\n          width,\n          arg1Width,\n          blockSize,\n          blockCount,\n        );\n        break;\n      case Opcode.Dot:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          let dot = 0;\n          for (let component = 0; component < arg0Width; component += 1) {\n            dot +=\n              registers[arg0 + component * blockSize + lane] *\n              registers[arg1 + component * blockSize + lane];\n          }\n          registers[outputBase + lane] = dot;\n        }\n        break;\n      case Opcode.Cross:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] =\n            registers[arg0 + blockSize + lane] *\n              registers[arg1 + blockSize * 2 + lane] -\n            registers[arg0 + blockSize * 2 + lane] *\n              registers[arg1 + blockSize + lane];\n          registers[outputBase + blockSize + lane] =\n            registers[arg0 + blockSize * 2 + lane] * registers[arg1 + lane] -\n            registers[arg0 + lane] * registers[arg1 + blockSize * 2 + lane];\n          registers[outputBase + blockSize * 2 + lane] =\n            registers[arg0 + lane] * registers[arg1 + blockSize + lane] -\n            registers[arg0 + blockSize + lane] * registers[arg1 + lane];\n        }\n        break;\n      case Opcode.Equal:\n      case Opcode.NotEqual:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          let equal = true;\n          for (let component = 0; component < arg0Width; component += 1) {\n            equal &&=\n              registers[arg0 + component * blockSize + lane] ===\n              registers[arg1 + component * blockSize + lane];\n          }\n          registers[outputBase + lane] = (\n            opcode === Opcode.Equal\n              ? equal\n              : !equal\n          )\n            ? 1\n            : 0;\n        }\n        break;\n      case Opcode.Less:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] =\n            registers[arg0 + lane] < registers[arg1 + lane] ? 1 : 0;\n        }\n        break;\n      case Opcode.LessEqual:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] =\n            registers[arg0 + lane] <= registers[arg1 + lane] ? 1 : 0;\n        }\n        break;\n      case Opcode.Greater:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] =\n            registers[arg0 + lane] > registers[arg1 + lane] ? 1 : 0;\n        }\n        break;\n      case Opcode.GreaterEqual:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] =\n            registers[arg0 + lane] >= registers[arg1 + lane] ? 1 : 0;\n        }\n        break;\n      case Opcode.And:\n      case Opcode.Or:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          const result =\n            opcode === Opcode.And\n              ? registers[arg0 + lane] !== 0 && registers[arg1 + lane] !== 0\n              : registers[arg0 + lane] !== 0 || registers[arg1 + lane] !== 0;\n          registers[outputBase + lane] = result ? 1 : 0;\n        }\n        break;\n      case Opcode.QuaternionMultiply:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          const leftX = registers[arg0 + lane];\n          const leftY = registers[arg0 + blockSize + lane];\n          const leftZ = registers[arg0 + blockSize * 2 + lane];\n          const leftW = registers[arg0 + blockSize * 3 + lane];\n          const rightX = registers[arg1 + lane];\n          const rightY = registers[arg1 + blockSize + lane];\n          const rightZ = registers[arg1 + blockSize * 2 + lane];\n          const rightW = registers[arg1 + blockSize * 3 + lane];\n          registers[outputBase + lane] =\n            leftW * rightX + leftX * rightW + leftY * rightZ - leftZ * rightY;\n          registers[outputBase + blockSize + lane] =\n            leftW * rightY - leftX * rightZ + leftY * rightW + leftZ * rightX;\n          registers[outputBase + blockSize * 2 + lane] =\n            leftW * rightZ + leftX * rightY - leftY * rightX + leftZ * rightW;\n          registers[outputBase + blockSize * 3 + lane] =\n            leftW * rightW - leftX * rightX - leftY * rightY - leftZ * rightZ;\n        }\n        break;\n      case Opcode.RotateVector:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          const quaternionX = registers[arg0 + lane];\n          const quaternionY = registers[arg0 + blockSize + lane];\n          const quaternionZ = registers[arg0 + blockSize * 2 + lane];\n          const quaternionW = registers[arg0 + blockSize * 3 + lane];\n          const vectorX = registers[arg1 + lane];\n          const vectorY = registers[arg1 + blockSize + lane];\n          const vectorZ = registers[arg1 + blockSize * 2 + lane];\n          const crossX = 2 * (quaternionY * vectorZ - quaternionZ * vectorY);\n          const crossY = 2 * (quaternionZ * vectorX - quaternionX * vectorZ);\n          const crossZ = 2 * (quaternionX * vectorY - quaternionY * vectorX);\n          registers[outputBase + lane] =\n            vectorX +\n            quaternionW * crossX +\n            quaternionY * crossZ -\n            quaternionZ * crossY;\n          registers[outputBase + blockSize + lane] =\n            vectorY +\n            quaternionW * crossY +\n            quaternionZ * crossX -\n            quaternionX * crossZ;\n          registers[outputBase + blockSize * 2 + lane] =\n            vectorZ +\n            quaternionW * crossZ +\n            quaternionX * crossY -\n            quaternionY * crossX;\n        }\n        break;\n      case Opcode.Select:\n        for (let component = 0; component < width; component += 1) {\n          const output = outputBase + component * blockSize;\n          const whenTrue = arg1 + component * blockSize;\n          const whenFalse = arg2 + component * blockSize;\n          for (let lane = 0; lane < blockCount; lane += 1) {\n            registers[output + lane] =\n              registers[arg0 + lane] !== 0\n                ? registers[whenTrue + lane]\n                : registers[whenFalse + lane];\n          }\n        }\n        break;\n      case Opcode.Clamp:\n        for (let component = 0; component < width; component += 1) {\n          const output = outputBase + component * blockSize;\n          const value = arg0 + component * blockSize;\n          const min = arg1 + (arg1Width === 1 ? 0 : component * blockSize);\n          const max = arg2 + (arg2Width === 1 ? 0 : component * blockSize);\n          for (let lane = 0; lane < blockCount; lane += 1) {\n            registers[output + lane] = rustMin(\n              rustMax(registers[value + lane], registers[min + lane]),\n              registers[max + lane],\n            );\n          }\n        }\n        break;\n      case Opcode.Mix:\n        for (let component = 0; component < width; component += 1) {\n          const output = outputBase + component * blockSize;\n          const left = arg0 + component * blockSize;\n          const right = arg1 + (arg1Width === 1 ? 0 : component * blockSize);\n          const amount = arg2 + (arg2Width === 1 ? 0 : component * blockSize);\n          for (let lane = 0; lane < blockCount; lane += 1) {\n            const leftValue = registers[left + lane];\n            registers[output + lane] =\n              leftValue +\n              (registers[right + lane] - leftValue) * registers[amount + lane];\n          }\n        }\n        break;\n      case Opcode.Vec2:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] = registers[arg0 + lane];\n          registers[outputBase + blockSize + lane] = registers[arg1 + lane];\n        }\n        break;\n      case Opcode.Vec3:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] = registers[arg0 + lane];\n          registers[outputBase + blockSize + lane] = registers[arg1 + lane];\n          registers[outputBase + blockSize * 2 + lane] = registers[arg2 + lane];\n        }\n        break;\n      case Opcode.Vec4:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] = registers[arg0 + lane];\n          registers[outputBase + blockSize + lane] = registers[arg1 + lane];\n          registers[outputBase + blockSize * 2 + lane] = registers[arg2 + lane];\n          registers[outputBase + blockSize * 3 + lane] = registers[arg3 + lane];\n        }\n        break;\n      case Opcode.Component:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          registers[outputBase + lane] =\n            registers[arg0 + immediate * blockSize + lane];\n        }\n        break;\n      case Opcode.MaxComponentIndex:\n        for (let lane = 0; lane < blockCount; lane += 1) {\n          let largest = 0;\n          let largestValue = registers[arg0 + lane];\n          for (let component = 1; component < arg0Width; component += 1) {\n            const value = registers[arg0 + component * blockSize + lane];\n            if (value > largestValue) {\n              largest = component;\n              largestValue = value;\n            }\n          }\n          registers[outputBase + lane] = largest;\n        }\n        break;\n      default:\n        throw new Error(`Unknown postDecode opcode: ${opcode}`);\n    }\n  }\n}\n\nfunction runProgram(\n  data: PostDecodeSplatData,\n  program: SerializedSplatPostDecode,\n  plan: RuntimePlan,\n  attributeData: DataView,\n  splat0Float: Float32Array,\n  registers: Float32Array,\n  processCount: number,\n) {\n  const { constants, instructions } = program;\n  const {\n    registerBases,\n    conditionStages: packedStages,\n    conditionStageCount,\n    outputInstructionStart,\n    conditionCarryStageStarts,\n    conditionCarryEvents,\n    blockSize,\n    outputPlan,\n  } = plan;\n  const instructionCount = getInstructionCount(instructions);\n\n  const flow = packedStages\n    ? {\n        stages: packedStages,\n        sourceIndices: new Uint16Array(blockSize),\n        laneIndices: new Uint16Array(blockSize),\n        nextIndices: new Int32Array(blockSize).fill(-1),\n        heads: new Int32Array(conditionStageCount + 1).fill(-1),\n      }\n    : undefined;\n  const carry =\n    conditionCarryEvents.length === 0\n      ? undefined\n      : {\n          stageStarts: conditionCarryStageStarts,\n          events: conditionCarryEvents,\n          nextStage: 0,\n          activeOffsets: new Uint16Array(registers.length / blockSize),\n          activePositions: new Int32Array(registers.length / blockSize).fill(\n            -1,\n          ),\n          activeCount: 0,\n        };\n  const outputWordBases = outputPlan.writesOutputs\n    ? new Uint32Array(blockSize)\n    : undefined;\n\n  for (let instruction = 0; instruction < instructionCount; instruction += 1) {\n    const instructionOffset =\n      instruction * SPLAT_POST_DECODE_INSTRUCTION_STRIDE;\n    if (\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_OPCODE] !==\n      Opcode.Constant\n    ) {\n      continue;\n    }\n    const outputBase = registerBases[instruction];\n    const width =\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_WIDTH];\n    const immediate =\n      instructions[instructionOffset + SPLAT_POST_DECODE_INSTRUCTION_IMMEDIATE];\n    for (let lane = 0; lane < width; lane += 1) {\n      registers.fill(\n        constants[immediate + lane],\n        outputBase + lane * blockSize,\n        outputBase + (lane + 1) * blockSize,\n      );\n    }\n  }\n\n  for (let blockStart = 0; blockStart < processCount; blockStart += blockSize) {\n    let blockCount = Math.min(blockSize, processCount - blockStart);\n    let sourceIndices: Uint16Array | undefined;\n    if (carry) {\n      carry.nextStage = 0;\n      carry.activeCount = 0;\n    }\n\n    for (\n      let rangeIndex = 0;\n      rangeIndex <= conditionStageCount;\n      rangeIndex += 1\n    ) {\n      const isConditionStage = rangeIndex < conditionStageCount;\n      if (flow && flow.heads[rangeIndex] !== -1) {\n        if (sourceIndices !== flow.sourceIndices) {\n          if (sourceIndices) {\n            flow.sourceIndices.set(sourceIndices.subarray(0, blockCount), 0);\n          } else {\n            for (let index = 0; index < blockCount; index += 1) {\n              flow.sourceIndices[index] = index;\n            }\n          }\n        }\n        blockCount = collectConditionFlowBlock(\n          flow.heads,\n          flow.nextIndices,\n          flow.sourceIndices,\n          rangeIndex,\n          blockCount,\n        );\n        sourceIndices = flow.sourceIndices;\n      }\n\n      const stageOffset = rangeIndex * SPLAT_POST_DECODE_FLOW_STAGE_STRIDE;\n      const instructionStart =\n        flow && isConditionStage\n          ? flow.stages[stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_START]\n          : outputInstructionStart;\n      const instructionEnd =\n        flow && isConditionStage\n          ? flow.stages[\n              stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION\n            ] + 1\n          : instructionCount;\n\n      if (blockCount !== 0) {\n        executeRange(\n          data,\n          program,\n          attributeData,\n          splat0Float,\n          registers,\n          registerBases,\n          instructionStart,\n          instructionEnd,\n          blockStart,\n          blockCount,\n          blockSize,\n          sourceIndices,\n        );\n      }\n      if (flow && isConditionStage && blockCount !== 0) {\n        const conditionRegister =\n          flow.stages[stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_REGISTER];\n        const conditionBase = registerBases[conditionRegister];\n        const nextStage = rangeIndex + 1;\n        const currentSourceIndices = sourceIndices;\n        const previousCount = blockCount;\n        let nextStageCount = 0;\n        const onTrue =\n          flow.stages[stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_ON_TRUE];\n        const onFalse =\n          flow.stages[stageOffset + SPLAT_POST_DECODE_FLOW_STAGE_ON_FALSE];\n        const directOnTrue = onTrue === nextStage;\n        const directOnFalse = onFalse === nextStage;\n        const rejectTarget = flow.heads.length;\n        if (\n          (directOnTrue && onFalse === rejectTarget) ||\n          (directOnFalse && onTrue === rejectTarget)\n        ) {\n          for (let index = 0; index < blockCount; index += 1) {\n            const truthy = registers[conditionBase + index] !== 0;\n            if (truthy !== directOnTrue) continue;\n            const sourceIndex = currentSourceIndices?.[index];\n            flow.laneIndices[nextStageCount] = index;\n            if (sourceIndex !== undefined) {\n              flow.sourceIndices[nextStageCount] = sourceIndex;\n            }\n            nextStageCount += 1;\n          }\n        } else {\n          for (let index = 0; index < blockCount; index += 1) {\n            const sourceIndex = currentSourceIndices?.[index] ?? index;\n            const target =\n              registers[conditionBase + index] !== 0 ? onTrue : onFalse;\n            if (target === nextStage) {\n              flow.laneIndices[nextStageCount] = index;\n              if (currentSourceIndices) {\n                flow.sourceIndices[nextStageCount] = sourceIndex;\n              }\n              nextStageCount += 1;\n            } else {\n              enqueueConditionFlowBlock(\n                flow.heads,\n                flow.nextIndices,\n                target,\n                sourceIndex,\n              );\n            }\n          }\n        }\n        if (nextStageCount !== 0 && nextStageCount !== previousCount) {\n          if (carry) {\n            applyConditionCarryEvents(carry, rangeIndex);\n            compactRegisterBlock(\n              registers,\n              carry.activeOffsets,\n              carry.activeCount,\n              flow.laneIndices,\n              nextStageCount,\n              blockSize,\n            );\n          }\n        }\n        if (\n          nextStageCount !== previousCount ||\n          currentSourceIndices === flow.laneIndices\n        ) {\n          // laneIndices may be the first compacted source map; routing then\n          // switches to the separately preserved sourceIndices map.\n          sourceIndices =\n            nextStageCount === 0\n              ? undefined\n              : currentSourceIndices\n                ? flow.sourceIndices\n                : flow.laneIndices;\n        }\n        blockCount = nextStageCount;\n      }\n    }\n    if (outputWordBases && blockCount !== 0) {\n      if (sourceIndices) {\n        for (let index = 0; index < blockCount; index += 1) {\n          outputWordBases[index] = (blockStart + sourceIndices[index]) * 4;\n        }\n      } else {\n        let wordBase = blockStart * 4;\n        for (let index = 0; index < blockCount; index += 1) {\n          outputWordBases[index] = wordBase;\n          wordBase += 4;\n        }\n      }\n      writeOutputBlock(\n        data,\n        splat0Float,\n        registers,\n        outputPlan,\n        outputWordBases,\n        blockSize,\n        blockCount,\n      );\n    }\n    if (carry) {\n      for (let index = 0; index < carry.activeCount; index += 1) {\n        carry.activePositions[carry.activeOffsets[index]] = -1;\n      }\n    }\n  }\n}\n\nfunction writeOutputBlock(\n  data: PostDecodeSplatData,\n  splat0Float: Float32Array,\n  registers: Float32Array,\n  plan: OutputWritePlan,\n  outputWordBases: Uint32Array,\n  blockSize: number,\n  blockCount: number,\n) {\n  const { outputBases } = plan;\n  const positionBase = outputBases[OUTPUT_POSITION];\n  if (positionBase !== MISSING_OUTPUT_BASE) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      const registerBase = positionBase + blockIndex;\n      splat0Float[wordBase] = registers[registerBase];\n      splat0Float[wordBase + 1] = registers[registerBase + blockSize];\n      splat0Float[wordBase + 2] = registers[registerBase + blockSize * 2];\n    }\n  }\n\n  const scaleBase = outputBases[OUTPUT_SCALE];\n  if (scaleBase !== MISSING_OUTPUT_BASE) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      const registerBase = scaleBase + blockIndex;\n      const first = data.splat1[wordBase + 1] & 0xffff;\n      data.splat1[wordBase + 1] =\n        (first | (toHalf(Math.log(registers[registerBase])) << 16)) >>> 0;\n      data.splat1[wordBase + 2] =\n        (toHalf(Math.log(registers[registerBase + blockSize])) |\n          (toHalf(Math.log(registers[registerBase + blockSize * 2])) << 16)) >>>\n        0;\n    }\n  }\n\n  const quaternionBase = outputBases[OUTPUT_QUATERNION];\n  if (quaternionBase !== MISSING_OUTPUT_BASE) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      const encoded = encodeQuaternion(\n        registers,\n        quaternionBase + blockIndex,\n        blockSize,\n      );\n      if (encoded !== undefined) data.splat1[wordBase + 3] = encoded;\n    }\n  }\n\n  const opacityBase = outputBases[OUTPUT_OPACITY];\n  if (opacityBase !== MISSING_OUTPUT_BASE) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      data.splat0[wordBase + 3] = encodeSplatOpacity(\n        registers[opacityBase + blockIndex],\n      );\n    }\n  }\n\n  const alphaBase = outputBases[OUTPUT_ALPHA];\n  if (alphaBase !== MISSING_OUTPUT_BASE) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordIndex = outputWordBases[blockIndex] + 3;\n      data.splat0[wordIndex] =\n        ((data.splat0[wordIndex] & 0xffff_0000) |\n          toHalf(clamp(registers[alphaBase + blockIndex], 0, 1))) >>>\n        0;\n    }\n  }\n\n  const colorBase = outputBases[OUTPUT_COLOR];\n  if (colorBase !== MISSING_OUTPUT_BASE) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      const registerBase = colorBase + blockIndex;\n      data.splat1[wordBase] =\n        (toHalf(registers[registerBase]) |\n          (toHalf(registers[registerBase + blockSize]) << 16)) >>>\n        0;\n      data.splat1[wordBase + 1] =\n        ((data.splat1[wordBase + 1] & 0xffff_0000) |\n          toHalf(registers[registerBase + blockSize * 2])) >>>\n        0;\n    }\n  }\n\n  for (let shIndex = 0; shIndex < plan.shTargetArrays.length; shIndex += 1) {\n    const target = plan.shTargetArrays[shIndex];\n    const wordOffset = plan.shWordOffsets[shIndex];\n    const shRegisterBase = plan.shRegisterBases[shIndex];\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      target[wordBase + wordOffset] = encodeSh(\n        registers,\n        shRegisterBase + blockIndex,\n        blockSize,\n      );\n    }\n  }\n\n  if (plan.updatesSortCenter) {\n    for (let blockIndex = 0; blockIndex < blockCount; blockIndex += 1) {\n      const wordBase = outputWordBases[blockIndex];\n      const disabled =\n        data.splat1[wordBase + 1] >>> 16 === 0xfc00 &&\n        (data.splat1[wordBase + 2] & 0xffff) === 0xfc00 &&\n        data.splat1[wordBase + 2] >>> 16 === 0xfc00;\n      const centerBase = (wordBase >>> 2) * 3;\n      if (disabled) {\n        data.sortCenters[centerBase] = Number.NaN;\n        data.sortCenters[centerBase + 1] = Number.NaN;\n        data.sortCenters[centerBase + 2] = Number.NaN;\n      } else {\n        data.sortCenters[centerBase] = splat0Float[wordBase];\n        data.sortCenters[centerBase + 1] = splat0Float[wordBase + 1];\n        data.sortCenters[centerBase + 2] = splat0Float[wordBase + 2];\n      }\n    }\n  }\n}\n\nexport function applySplatPostDecode(\n  data: PostDecodeSplatData,\n  program: SerializedSplatPostDecode,\n) {\n  let processCount = data.numSplats;\n  for (const attribute of program.attributes) {\n    processCount = Math.min(processCount, attribute.count);\n  }\n  if (processCount === 0 || program.instructions.length === 0) return;\n\n  const plan = prepareProgram(data, program, processCount);\n  const registers = new Float32Array(plan.registerValueCount * plan.blockSize);\n  const attributeData = new DataView(\n    program.attributeData.buffer,\n    program.attributeData.byteOffset,\n    program.attributeData.byteLength,\n  );\n  const splat0Float = new Float32Array(\n    data.splat0.buffer,\n    data.splat0.byteOffset,\n    data.splat0.length,\n  );\n\n  runProgram(\n    data,\n    program,\n    plan,\n    attributeData,\n    splat0Float,\n    registers,\n    processCount,\n  );\n}\n","// Recursively finds all ArrayBuffers in an object for structured-clone transfer.\nexport function getTransferable(ctx: unknown): Transferable[] {\n  const buffers = new Set<Transferable>();\n  const seen = new Set();\n\n  function traverse(obj: unknown) {\n    if (!obj || typeof obj !== \"object\" || seen.has(obj)) return;\n    seen.add(obj);\n\n    if (obj instanceof ArrayBuffer) {\n      buffers.add(obj);\n    } else if (ArrayBuffer.isView(obj)) {\n      buffers.add(obj.buffer as ArrayBuffer);\n    } else {\n      Object.values(obj).forEach(traverse);\n    }\n  }\n\n  traverse(ctx);\n  return [...buffers];\n}\n","import init_wasm, {\n  type ChunkDecoder,\n  decode_to_splats,\n  set_sort_center_state,\n  sort32_centers,\n} from \"gaussian-splat-rs\";\nimport type { SplatResult } from \"./defines\";\nimport type { SerializedSplatPostDecode } from \"./postDecode\";\nimport {\n  type PostDecodeSplatData,\n  applySplatPostDecode,\n} from \"./postDecodeRuntime\";\nimport { getTransferable } from \"./transferable\";\n\nconst rpcHandlers = {\n  setSortCenterState,\n  sortCenters32,\n  loadSplats,\n  nextChunk,\n};\nexport type RpcHandlers = typeof rpcHandlers;\n\nlet wasmMemory: WebAssembly.Memory | undefined;\n\nfunction getWasmMemoryBytes() {\n  return wasmMemory?.buffer.byteLength ?? 0;\n}\n\nfunction setSortCenterState({\n  centerUpdateRangeIndices,\n  updateCenters,\n  matrixUpdateRangeIndices,\n  updateMatrices,\n  rangeMeshIds,\n  rangeBases,\n  rangeCounts,\n}: {\n  centerUpdateRangeIndices: Uint32Array;\n  updateCenters: Float32Array;\n  matrixUpdateRangeIndices: Uint32Array;\n  updateMatrices: Float64Array;\n  rangeMeshIds: Uint32Array;\n  rangeBases: Uint32Array;\n  rangeCounts: Uint32Array;\n}) {\n  set_sort_center_state(\n    centerUpdateRangeIndices,\n    updateCenters,\n    matrixUpdateRangeIndices,\n    updateMatrices,\n    rangeMeshIds,\n    rangeBases,\n    rangeCounts,\n  );\n}\n\nfunction sortCenters32({\n  numSplats,\n  cameraPosition,\n  direction,\n  radial,\n  ordering,\n}: {\n  numSplats: number;\n  cameraPosition: [number, number, number];\n  direction: [number, number, number];\n  radial: boolean;\n  ordering: Uint32Array;\n}) {\n  const activeSplats = sort32_centers(\n    numSplats,\n    cameraPosition[0],\n    cameraPosition[1],\n    cameraPosition[2],\n    direction[0],\n    direction[1],\n    direction[2],\n    radial,\n    ordering,\n  );\n  return { activeSplats, ordering };\n}\n\nasync function onMessage(event: MessageEvent) {\n  const {\n    id,\n    name,\n    args,\n  }: { id: unknown; name: keyof typeof rpcHandlers; args: unknown } =\n    event.data;\n  try {\n    const handler = rpcHandlers[name] as (\n      args: unknown,\n      options: { sendStatus: (data: unknown) => void },\n    ) => unknown | Promise<unknown>;\n    if (!handler) {\n      throw new Error(`Unknown worker RPC: ${name}`);\n    }\n\n    const sendStatus = (data: unknown) => {\n      self.postMessage(\n        { id, status: data },\n        { transfer: getTransferable(data) },\n      );\n    };\n    const result = await handler(args, { sendStatus });\n    self.postMessage(\n      { id, result, wasmMemoryBytes: getWasmMemoryBytes() },\n      { transfer: getTransferable(result) },\n    );\n  } catch (error) {\n    console.warn(`Worker error: ${error}`);\n    self.postMessage(\n      { id, error, wasmMemoryBytes: getWasmMemoryBytes() },\n      { transfer: getTransferable(error) },\n    );\n  }\n}\n\nasync function decodeBytesUrl({\n  decoder,\n  fileBytes,\n  url,\n  requestHeader,\n  withCredentials,\n  chunked,\n  chunkedLength,\n  sendStatus,\n}: {\n  decoder: ChunkDecoder;\n  fileBytes?: Uint8Array;\n  url?: string;\n  requestHeader?: Record<string, string>;\n  withCredentials?: boolean;\n  chunked?: boolean;\n  chunkedLength?: number;\n  sendStatus: (data: unknown) => void;\n}) {\n  if (fileBytes) {\n    const byteLength = fileBytes.length;\n    if (byteLength > 0) {\n      decoder.set_expected_input_size(byteLength);\n    }\n    sendStatus({ loaded: byteLength, total: byteLength });\n    decoder.push(fileBytes);\n    return decoder.finish();\n  }\n\n  const suppliedInputLength = chunkedLength ?? 0;\n  if (!Number.isSafeInteger(suppliedInputLength) || suppliedInputLength < 0) {\n    throw new Error(\"streamLength must be a non-negative integer\");\n  }\n  let streamLength = suppliedInputLength;\n  let expectedInputLength = 0;\n  let responseBody: ReadableStream<Uint8Array> | undefined;\n\n  if (url) {\n    const request = new Request(url, {\n      headers: requestHeader ? new Headers(requestHeader) : undefined,\n      credentials: withCredentials ? \"include\" : \"same-origin\",\n    });\n\n    const response = await fetch(request);\n    if (!response.ok || !response.body) {\n      throw new Error(\n        `Failed to fetch \"${url}\": ${response.status} ${response.statusText}`,\n      );\n    }\n    responseBody = response.body;\n    const contentLength = Number(response.headers.get(\"Content-Length\") || \"0\");\n    const responseLength =\n      Number.isSafeInteger(contentLength) && contentLength > 0\n        ? contentLength\n        : 0;\n    streamLength ||= responseLength;\n    const contentEncoding = response.headers.get(\"Content-Encoding\");\n    // A CORS-filtered response can hide Content-Encoding while exposing\n    // Content-Length, so only use the response length for decoder validation\n    // when every response header is visible.\n    const hasIdentityEncoding =\n      !contentEncoding || contentEncoding.toLowerCase() === \"identity\";\n    if (response.type === \"basic\" && hasIdentityEncoding) {\n      expectedInputLength = responseLength;\n    }\n  } else if (!chunked) {\n    throw new Error(\"No url or fileBytes provided\");\n  }\n\n  const streamReader = responseBody?.getReader();\n  const readInputChunk = async () => {\n    if (streamReader) {\n      const { done, value } = await streamReader.read();\n      return done ? undefined : value;\n    }\n\n    const chunk = await new Promise<Uint8Array>((resolve) => {\n      nextChunkWaiter = resolve;\n      sendStatus({ nextChunk: true });\n    });\n    return chunk.length === 0 ? undefined : chunk;\n  };\n\n  let loaded = 0;\n  try {\n    if (expectedInputLength > 0) {\n      decoder.set_expected_input_size(expectedInputLength);\n    }\n\n    while (true) {\n      const value = await readInputChunk();\n      if (!value) break;\n\n      loaded += value.length;\n      if (expectedInputLength > 0 && loaded > expectedInputLength) {\n        throw new Error(\n          `Input length exceeds the expected ${expectedInputLength} bytes`,\n        );\n      }\n      sendStatus({ loaded, total: streamLength });\n      decoder.push(value);\n    }\n\n    if (expectedInputLength > 0 && loaded !== expectedInputLength) {\n      throw new Error(\n        `Input length mismatch: expected ${expectedInputLength} bytes, received ${loaded}`,\n      );\n    }\n\n    if (chunked && streamLength === 0) {\n      sendStatus({ loaded, total: loaded });\n    }\n\n    return decoder.finish();\n  } catch (error) {\n    try {\n      await streamReader?.cancel(error);\n    } catch {\n      // Preserve the decoding error if stream cancellation itself fails.\n    }\n    throw error;\n  } finally {\n    streamReader?.releaseLock();\n  }\n}\n\nfunction toSplatResult(decoded: PostDecodeSplatData): SplatResult {\n  return {\n    numSplats: decoded.numSplats,\n    splatArrays: [decoded.splat0, decoded.splat1],\n    sortCenters: decoded.sortCenters,\n    extra: {\n      sh1: decoded.sh1,\n      sh2: decoded.sh2,\n      sh3a: decoded.sh3a,\n      sh3b: decoded.sh3b,\n    },\n  };\n}\n\nasync function loadSplats(\n  {\n    url,\n    requestHeader,\n    withCredentials,\n    fileBytes,\n    fileType,\n    pathName,\n    chunked,\n    chunkedLength,\n    postDecode,\n  }: {\n    url?: string;\n    requestHeader?: Record<string, string>;\n    withCredentials?: boolean;\n    fileBytes?: Uint8Array;\n    fileType?: string;\n    pathName?: string;\n    chunked?: boolean;\n    chunkedLength?: number;\n    postDecode?: SerializedSplatPostDecode;\n  },\n  { sendStatus }: { sendStatus: (data: unknown) => void },\n) {\n  const decoder = decode_to_splats(fileType, pathName ?? url);\n  const decoded = (await decodeBytesUrl({\n    decoder,\n    fileBytes,\n    url,\n    requestHeader,\n    withCredentials,\n    chunked,\n    chunkedLength,\n    sendStatus,\n  })) as PostDecodeSplatData;\n  if (postDecode) applySplatPostDecode(decoded, postDecode);\n  return toSplatResult(decoded);\n}\n\nlet nextChunkWaiter = (_chunk: Uint8Array) => {};\n\nasync function nextChunk({ chunk }: { chunk: Uint8Array }) {\n  nextChunkWaiter(chunk);\n}\n\nasync function initialize() {\n  let resolveWaitForModule: (value: WebAssembly.Module) => void;\n  const waitForModule = new Promise<WebAssembly.Module>((resolve) => {\n    resolveWaitForModule = resolve;\n  });\n\n  const pending: MessageEvent[] = [];\n  const bufferMessage = (event: MessageEvent) => {\n    if (event.data.name === \"init-wasm\") {\n      resolveWaitForModule(event.data.module as WebAssembly.Module);\n      return;\n    }\n    pending.push(event);\n  };\n  self.addEventListener(\"message\", bufferMessage);\n\n  const wasm = await init_wasm({ module_or_path: await waitForModule });\n  wasmMemory = wasm.memory;\n\n  self.removeEventListener(\"message\", bufferMessage);\n  self.addEventListener(\"message\", onMessage);\n\n  for (const event of pending) {\n    onMessage(event);\n  }\n  pending.length = 0;\n}\n\ninitialize().catch(console.error);\n"],"names":["ChunkDecoder","ptr","obj","ChunkDecoderFinalization","wasm","ret","takeFromExternrefTable0","bytes","size","decode_to_splats","file_type","path_name","ptr0","isLikeNone","passStringToWasm0","len0","WASM_VECTOR_LEN","ptr1","len1","set_sort_center_state","center_update_range_indices","update_centers","matrix_update_range_indices","update_matrices","range_mesh_ids","range_bases","range_counts","sort32_centers","num_splats","camera_x","camera_y","camera_z","direction_x","direction_y","direction_z","radial","ordering","__wbg_get_imports","arg0","arg1","debugString","getDataViewMemory0","getStringFromWasm0","deferred0_0","deferred0_1","arg2","getArrayF64FromWasm0","getArrayU8FromWasm0","getArrayF32FromWasm0","getArrayU32FromWasm0","handleError","table","offset","addToExternrefTable0","idx","val","type","description","name","length","debug","i","builtInMatches","className","len","getFloat32ArrayMemory0","getFloat64ArrayMemory0","getUint32ArrayMemory0","getUint8ArrayMemory0","cachedDataViewMemory0","cachedFloat32ArrayMemory0","cachedFloat64ArrayMemory0","decodeText","cachedUint32ArrayMemory0","cachedUint8ArrayMemory0","f","args","e","x","arg","malloc","realloc","buf","cachedTextEncoder","mem","code","view","value","cachedTextDecoder","MAX_SAFARI_DECODE_BYTES","numBytesDecoded","__wbg_finalize_init","instance","module","__wbg_load","imports","expectedResponseType","__wbg_init","module_or_path","f32","u32","supportsFloat16Array","f16","u16","toHalfNative","toHalfJs","bits","sign","exponent","fraction","halfExponent","fromHalfNative","fromHalfJs","mantissa","adjustedExponent","toHalf","fromHalf","Opcode","InputField","SH_COEFFICIENT_COUNT","SPLAT_POST_DECODE_INSTRUCTION_OPCODE","SPLAT_POST_DECODE_INSTRUCTION_WIDTH","SPLAT_POST_DECODE_INSTRUCTION_IMMEDIATE","SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_0","SPLAT_POST_DECODE_INSTRUCTION_ARGUMENT_COUNT","SPLAT_POST_DECODE_INSTRUCTION_STRIDE","SPLAT_POST_DECODE_MISSING_ARGUMENT","ATTRIBUTE_FORMAT_BYTES","SPLAT_POST_DECODE_FLOW_STAGE_START","SPLAT_POST_DECODE_FLOW_STAGE_INSTRUCTION","SPLAT_POST_DECODE_FLOW_STAGE_REGISTER","SPLAT_POST_DECODE_FLOW_STAGE_ON_TRUE","SPLAT_POST_DECODE_FLOW_STAGE_ON_FALSE","SPLAT_POST_DECODE_FLOW_STAGE_STRIDE","MAX_SPLAT_OPACITY","F32_EPSILON","ENCODED_IDENTITY_QUATERNION","clamp","min","max","decodeSplatOpacity","word","shapeAmount","kernelShape","encodeSplatOpacity","opacity","decodeQuatOctXy1010R12ToArray","output","base","stride","u","v","angle","y","z","fold","inverseLength","halfTheta","sine","encodeQuaternion","qx","qy","qz","qw","minimumLengthSquared","lengthSquared","w","theta","axisX","axisY","axisZ","sum","octX","octY","previousX","tryEncodeQuatOctXy1010R12","MAX_BLOCK_SIZE","MAX_REGISTER_BYTES","CONDITION_CARRY_EVENT_OFFSET_MASK","CONDITION_CARRY_EVENT_REMOVAL","getInstructionCount","instructions","count","instructionWidth","index","getBlockSize","registerValueCount","processCount","bytesPerSplat","allocateSplatPostDecodeRegisters","program","outputs","condition","instructionCount","lastUses","instructionOffset","argumentIndex","argument","packedConditionStages","stageOffset","register","instruction","programEnd","registerOffsets","constantRegisters","releaseHeads","releaseNext","freeRanges","release","releasedOffset","releasedWidth","width","insertIndex","previous","next","allocate","bestIndex","range","released","releaseIndex","conditionStageCount","conditionCarryStageStarts","conditionCarryEvents","stageBoundaries","stage","boundary","stageAfterInstruction","start","end","middle","firstStages","endStages","eventCounts","removalCounts","firstStage","endStage","eventStarts","removalCursors","additionCursors","lane","carryOffset","rustMin","left","right","rustMax","roundAwayFromZero","ATTRIBUTE_READERS","data","readAttributeBlock","attribute","blockStart","blockCount","blockSize","registers","outputBase","sourceIndices","componentBytes","read","component","componentOutput","inputOffset","decodeSh","exponentAndSigns","multiplier","magnitude","encodeSh","red","green","blue","maxAbsolute","divisor","encodeComponent","signs","shWord","coefficient","OUTPUT_POSITION","OUTPUT_SCALE","OUTPUT_QUATERNION","OUTPUT_OPACITY","OUTPUT_ALPHA","OUTPUT_COLOR","OUTPUT_COUNT","MISSING_OUTPUT_BASE","createOutputWritePlan","registerBases","outputBases","outputFieldCount","setOutputBase","slot","shTargetArrays","shWordOffsets","shRegisterBases","location","evaluateInputFieldBlock","field","splat0Float","sourceIndex","wordBase","word1","word2","word0","prepareProgram","conditionStages","_a","outputInstructionStart","compactRegisterBlock","activeOffsets","activeCount","laneIndices","nextCount","carryIndex","applyConditionCarryEvents","carry","eventStart","eventEnd","eventIndex","event","position","lastPosition","lastOffset","collectConditionFlowBlock","heads","nextIndices","initialCount","enqueueConditionFlowBlock","evaluateUnaryBlock","opcode","inputBase","input","evaluateBinaryBlock","arg1Width","executeRange","attributeData","instructionStart","instructionEnd","attributes","instructionIndex","immediate","argumentOffset","arg0Register","arg1Register","arg2Register","arg3Register","arg3","arg0Width","arg2Width","finite","dot","equal","result","leftX","leftY","leftZ","leftW","rightX","rightY","rightZ","rightW","quaternionX","quaternionY","quaternionZ","quaternionW","vectorX","vectorY","vectorZ","crossX","crossY","crossZ","whenTrue","whenFalse","amount","leftValue","largest","largestValue","runProgram","plan","constants","packedStages","outputPlan","flow","outputWordBases","rangeIndex","isConditionStage","conditionRegister","conditionBase","nextStage","currentSourceIndices","previousCount","nextStageCount","onTrue","onFalse","directOnTrue","directOnFalse","rejectTarget","target","writeOutputBlock","positionBase","blockIndex","registerBase","scaleBase","first","quaternionBase","encoded","opacityBase","alphaBase","wordIndex","colorBase","shIndex","wordOffset","shRegisterBase","disabled","centerBase","applySplatPostDecode","getTransferable","ctx","buffers","seen","traverse","rpcHandlers","setSortCenterState","sortCenters32","loadSplats","nextChunk","wasmMemory","getWasmMemoryBytes","centerUpdateRangeIndices","updateCenters","matrixUpdateRangeIndices","updateMatrices","rangeMeshIds","rangeBases","rangeCounts","numSplats","cameraPosition","direction","onMessage","id","handler","error","decodeBytesUrl","decoder","fileBytes","url","requestHeader","withCredentials","chunked","chunkedLength","sendStatus","byteLength","suppliedInputLength","streamLength","expectedInputLength","responseBody","request","response","contentLength","responseLength","contentEncoding","hasIdentityEncoding","streamReader","readInputChunk","done","chunk","resolve","nextChunkWaiter","loaded","toSplatResult","decoded","fileType","pathName","postDecode","_chunk","initialize","resolveWaitForModule","waitForModule","pending","bufferMessage","init_wasm"],"mappings":"yBAEO,MAAMA,EAAa,CACtB,OAAO,OAAOC,EAAK,CACfA,EAAMA,IAAQ,EACd,MAAMC,EAAM,OAAO,OAAOF,GAAa,SAAS,EAChD,OAAAE,EAAI,UAAYD,EAChBE,GAAyB,SAASD,EAAKA,EAAI,UAAWA,CAAG,EAClDA,CACX,CACA,oBAAqB,CACjB,MAAMD,EAAM,KAAK,UACjB,YAAK,UAAY,EACjBE,GAAyB,WAAW,IAAI,EACjCF,CACX,CACA,MAAO,CACH,MAAMA,EAAM,KAAK,mBAAkB,EACnCG,EAAK,wBAAwBH,EAAK,CAAC,CACvC,CAIA,QAAS,CACL,MAAMA,EAAM,KAAK,mBAAkB,EAC7BI,EAAMD,EAAK,oBAAoBH,CAAG,EACxC,GAAII,EAAI,CAAC,EACL,MAAMC,GAAwBD,EAAI,CAAC,CAAC,EAExC,OAAOC,GAAwBD,EAAI,CAAC,CAAC,CACzC,CAIA,KAAKE,EAAO,CACR,MAAMF,EAAMD,EAAK,kBAAkB,KAAK,UAAWG,CAAK,EACxD,GAAIF,EAAI,CAAC,EACL,MAAMC,GAAwBD,EAAI,CAAC,CAAC,CAE5C,CAIA,wBAAwBG,EAAM,CAC1B,MAAMH,EAAMD,EAAK,qCAAqC,KAAK,UAAWI,CAAI,EAC1E,GAAIH,EAAI,CAAC,EACL,MAAMC,GAAwBD,EAAI,CAAC,CAAC,CAE5C,CACJ,CACI,OAAO,UAASL,GAAa,UAAU,OAAO,OAAO,EAAIA,GAAa,UAAU,MAO7E,SAASS,GAAiBC,EAAWC,EAAW,CACnD,IAAIC,EAAOC,GAAWH,CAAS,EAAI,EAAII,GAAkBJ,EAAWN,EAAK,kBAAmBA,EAAK,kBAAkB,EAC/GW,EAAOC,EACPC,EAAOJ,GAAWF,CAAS,EAAI,EAAIG,GAAkBH,EAAWP,EAAK,kBAAmBA,EAAK,kBAAkB,EAC/Gc,EAAOF,EACX,MAAMX,EAAMD,EAAK,iBAAiBQ,EAAMG,EAAME,EAAMC,CAAI,EACxD,GAAIb,EAAI,CAAC,EACL,MAAMC,GAAwBD,EAAI,CAAC,CAAC,EAExC,OAAOL,GAAa,OAAOK,EAAI,CAAC,CAAC,CACrC,CA6CO,SAASc,GAAsBC,EAA6BC,EAAgBC,EAA6BC,EAAiBC,EAAgBC,EAAaC,EAAc,CACxKtB,EAAK,sBAAsBgB,EAA6BC,EAAgBC,EAA6BC,EAAiBC,EAAgBC,EAAaC,CAAY,CACnK,CAcO,SAASC,GAAeC,EAAYC,EAAUC,EAAUC,EAAUC,EAAaC,EAAaC,EAAaC,EAAQC,EAAU,CAE9H,OADYhC,EAAK,eAAewB,EAAYC,EAAUC,EAAUC,EAAUC,EAAaC,EAAaC,EAAaC,EAAQC,CAAQ,IAClH,CACnB,CAMA,SAASC,IAAoB,CA0IzB,MAAO,CACH,UAAW,KACX,4BA3IY,CACZ,UAAW,KACX,+CAAgD,SAASC,EAAMC,EAAM,CACjE,MAAMlC,EAAMmC,GAAYD,CAAI,EACtBtB,EAAOH,GAAkBT,EAAKD,EAAK,kBAAmBA,EAAK,kBAAkB,EAC7Ec,EAAOF,EACbyB,GAAkB,EAAG,SAASH,EAAO,EAAOpB,EAAM,EAAI,EACtDuB,GAAkB,EAAG,SAASH,EAAO,EAAOrB,EAAM,EAAI,CAC1D,EACA,wCAAyC,SAASqB,EAAMC,EAAM,CAC1D,MAAM,IAAI,MAAMG,GAAmBJ,EAAMC,CAAI,CAAC,CAClD,EACA,6BAA8B,SAASD,EAAMC,EAAM,CAC/C,IAAII,EACAC,EACJ,GAAI,CACAD,EAAcL,EACdM,EAAcL,EACd,QAAQ,MAAMG,GAAmBJ,EAAMC,CAAI,CAAC,CAChD,QAAC,CACGnC,EAAK,gBAAgBuC,EAAaC,EAAa,CAAC,CACpD,CACJ,EACA,iCAAkC,SAASN,EAAMC,EAAM,CAEnD,OADYD,EAAKC,IAAS,CAAC,CAE/B,EACA,8BAA+B,SAASD,EAAM,CAE1C,OADYA,EAAK,MAErB,EACA,8BAA+B,SAASA,EAAM,CAE1C,OADYA,EAAK,MAErB,EACA,8BAA+B,SAASA,EAAM,CAE1C,OADYA,EAAK,MAErB,EACA,8BAA+B,SAASA,EAAM,CAE1C,OADYA,EAAK,MAErB,EACA,2BAA4B,UAAW,CAEnC,OADY,IAAI,KAEpB,EACA,2BAA4B,UAAW,CAEnC,OADY,IAAI,MAEpB,EACA,uCAAwC,SAASA,EAAM,CAEnD,OADY,IAAI,aAAaA,IAAS,CAAC,CAE3C,EACA,uCAAwC,SAASA,EAAM,CAEnD,OADY,IAAI,YAAYA,IAAS,CAAC,CAE1C,EACA,wCAAyC,SAASA,EAAMC,EAAMM,EAAM,CAChE,aAAa,UAAU,IAAI,KAAKC,GAAqBR,EAAMC,CAAI,EAAGM,CAAI,CAC1E,EACA,wCAAyC,SAASP,EAAMC,EAAMM,EAAM,CAChE,WAAW,UAAU,IAAI,KAAKE,GAAoBT,EAAMC,CAAI,EAAGM,CAAI,CACvE,EACA,wCAAyC,SAASP,EAAMC,EAAMM,EAAM,CAChE,aAAa,UAAU,IAAI,KAAKG,GAAqBV,EAAMC,CAAI,EAAGM,CAAI,CAC1E,EACA,wCAAyC,SAASP,EAAMC,EAAMM,EAAM,CAChE,YAAY,UAAU,IAAI,KAAKI,GAAqBX,EAAMC,CAAI,EAAGM,CAAI,CACzE,EACA,2BAA4B,SAASP,EAAMC,EAAMM,EAAM,CACnDP,EAAK,IAAIW,GAAqBV,EAAMM,CAAI,CAAC,CAC7C,EACA,2BAA4B,UAAW,CAAE,OAAOK,GAAY,SAAUZ,EAAMC,EAAMM,EAAM,CAEpF,OADY,QAAQ,IAAIP,EAAMC,EAAMM,CAAI,CAE5C,EAAG,SAAS,CAAG,EACf,2BAA4B,SAASP,EAAMC,EAAMM,EAAM,CACnDP,EAAK,IAAIU,GAAqBT,EAAMM,CAAI,CAAC,CAC7C,EACA,iCAAkC,SAASP,EAAMC,EAAMM,EAAM,CACzDP,EAAKC,IAAS,CAAC,EAAIM,CACvB,EACA,6BAA8B,SAASP,EAAMC,EAAM,CAC/C,MAAMlC,EAAMkC,EAAK,MACXtB,EAAOH,GAAkBT,EAAKD,EAAK,kBAAmBA,EAAK,kBAAkB,EAC7Ec,EAAOF,EACbyB,GAAkB,EAAG,SAASH,EAAO,EAAOpB,EAAM,EAAI,EACtDuB,GAAkB,EAAG,SAASH,EAAO,EAAOrB,EAAM,EAAI,CAC1D,EACA,gCAAiC,SAASqB,EAAMC,EAAMM,EAAM,CAExD,OADYP,EAAK,SAASC,IAAS,EAAGM,IAAS,CAAC,CAEpD,EACA,gCAAiC,SAASP,EAAMC,EAAMM,EAAM,CAExD,OADYP,EAAK,SAASC,IAAS,EAAGM,IAAS,CAAC,CAEpD,EACA,gCAAiC,SAASP,EAAMC,EAAMM,EAAM,CAExD,OADYP,EAAK,SAASC,IAAS,EAAGM,IAAS,CAAC,CAEpD,EACA,gCAAiC,SAASP,EAAMC,EAAMM,EAAM,CAExD,OADYP,EAAK,SAASC,IAAS,EAAGM,IAAS,CAAC,CAEpD,EACA,iCAAkC,SAASP,EAAM,CAG7C,OADYA,CAEhB,EACA,iCAAkC,SAASA,EAAMC,EAAM,CAGnD,OADYS,GAAqBV,EAAMC,CAAI,CAE/C,EACA,iCAAkC,SAASD,EAAMC,EAAM,CAGnD,OADYU,GAAqBX,EAAMC,CAAI,CAE/C,EACA,iCAAkC,SAASD,EAAMC,EAAM,CAGnD,OADYG,GAAmBJ,EAAMC,CAAI,CAE7C,EACA,gCAAiC,UAAW,CACxC,MAAMY,EAAQ/C,EAAK,sBACbgD,EAASD,EAAM,KAAK,CAAC,EAC3BA,EAAM,IAAI,EAAG,MAAS,EACtBA,EAAM,IAAIC,EAAS,EAAG,MAAS,EAC/BD,EAAM,IAAIC,EAAS,EAAG,IAAI,EAC1BD,EAAM,IAAIC,EAAS,EAAG,EAAI,EAC1BD,EAAM,IAAIC,EAAS,EAAG,EAAK,CAC/B,CACR,CAIA,CACA,CAEA,MAAMjD,GAA4B,OAAO,qBAAyB,IAC5D,CAAE,SAAU,IAAM,CAAC,EAAG,WAAY,IAAM,CAAC,CAAC,EAC1C,IAAI,qBAAqBF,GAAOG,EAAK,wBAAwBH,IAAQ,EAAG,CAAC,CAAC,EAEhF,SAASoD,GAAqBnD,EAAK,CAC/B,MAAMoD,EAAMlD,EAAK,wBAAuB,EACxC,OAAAA,EAAK,sBAAsB,IAAIkD,EAAKpD,CAAG,EAChCoD,CACX,CAEA,SAASd,GAAYe,EAAK,CAEtB,MAAMC,EAAO,OAAOD,EACpB,GAAIC,GAAQ,UAAYA,GAAQ,WAAaD,GAAO,KAChD,MAAQ,GAAGA,CAAG,GAElB,GAAIC,GAAQ,SACR,MAAO,IAAID,CAAG,IAElB,GAAIC,GAAQ,SAAU,CAClB,MAAMC,EAAcF,EAAI,YACxB,OAAIE,GAAe,KACR,SAEA,UAAUA,CAAW,GAEpC,CACA,GAAID,GAAQ,WAAY,CACpB,MAAME,EAAOH,EAAI,KACjB,OAAI,OAAOG,GAAQ,UAAYA,EAAK,OAAS,EAClC,YAAYA,CAAI,IAEhB,UAEf,CAEA,GAAI,MAAM,QAAQH,CAAG,EAAG,CACpB,MAAMI,EAASJ,EAAI,OACnB,IAAIK,EAAQ,IACRD,EAAS,IACTC,GAASpB,GAAYe,EAAI,CAAC,CAAC,GAE/B,QAAQM,EAAI,EAAGA,EAAIF,EAAQE,IACvBD,GAAS,KAAOpB,GAAYe,EAAIM,CAAC,CAAC,EAEtC,OAAAD,GAAS,IACFA,CACX,CAEA,MAAME,EAAiB,sBAAsB,KAAK,SAAS,KAAKP,CAAG,CAAC,EACpE,IAAIQ,EACJ,GAAID,GAAkBA,EAAe,OAAS,EAC1CC,EAAYD,EAAe,CAAC,MAG5B,QAAO,SAAS,KAAKP,CAAG,EAE5B,GAAIQ,GAAa,SAIb,GAAI,CACA,MAAO,UAAY,KAAK,UAAUR,CAAG,EAAI,GAC7C,MAAY,CACR,MAAO,QACX,CAGJ,OAAIA,aAAe,MACR,GAAGA,EAAI,IAAI,KAAKA,EAAI,OAAO;AAAA,EAAKA,EAAI,KAAK,GAG7CQ,CACX,CAEA,SAASf,GAAqB/C,EAAK+D,EAAK,CACpC,OAAA/D,EAAMA,IAAQ,EACPgE,GAAsB,EAAG,SAAShE,EAAM,EAAGA,EAAM,EAAI+D,CAAG,CACnE,CAEA,SAASlB,GAAqB7C,EAAK+D,EAAK,CACpC,OAAA/D,EAAMA,IAAQ,EACPiE,GAAsB,EAAG,SAASjE,EAAM,EAAGA,EAAM,EAAI+D,CAAG,CACnE,CAEA,SAASf,GAAqBhD,EAAK+D,EAAK,CACpC,OAAA/D,EAAMA,IAAQ,EACPkE,GAAqB,EAAG,SAASlE,EAAM,EAAGA,EAAM,EAAI+D,CAAG,CAClE,CAEA,SAASjB,GAAoB9C,EAAK+D,EAAK,CACnC,OAAA/D,EAAMA,IAAQ,EACPmE,GAAoB,EAAG,SAASnE,EAAM,EAAGA,EAAM,EAAI+D,CAAG,CACjE,CAEA,IAAIK,EAAwB,KAC5B,SAAS5B,IAAqB,CAC1B,OAAI4B,IAA0B,MAAQA,EAAsB,OAAO,WAAa,IAASA,EAAsB,OAAO,WAAa,QAAaA,EAAsB,SAAWjE,EAAK,OAAO,UACzLiE,EAAwB,IAAI,SAASjE,EAAK,OAAO,MAAM,GAEpDiE,CACX,CAEA,IAAIC,GAA4B,KAChC,SAASL,IAAyB,CAC9B,OAAIK,KAA8B,MAAQA,GAA0B,aAAe,KAC/EA,GAA4B,IAAI,aAAalE,EAAK,OAAO,MAAM,GAE5DkE,EACX,CAEA,IAAIC,GAA4B,KAChC,SAASL,IAAyB,CAC9B,OAAIK,KAA8B,MAAQA,GAA0B,aAAe,KAC/EA,GAA4B,IAAI,aAAanE,EAAK,OAAO,MAAM,GAE5DmE,EACX,CAEA,SAAS7B,GAAmBzC,EAAK+D,EAAK,CAClC,OAAA/D,EAAMA,IAAQ,EACPuE,GAAWvE,EAAK+D,CAAG,CAC9B,CAEA,IAAIS,GAA2B,KAC/B,SAASN,IAAwB,CAC7B,OAAIM,KAA6B,MAAQA,GAAyB,aAAe,KAC7EA,GAA2B,IAAI,YAAYrE,EAAK,OAAO,MAAM,GAE1DqE,EACX,CAEA,IAAIC,GAA0B,KAC9B,SAASN,IAAuB,CAC5B,OAAIM,KAA4B,MAAQA,GAAwB,aAAe,KAC3EA,GAA0B,IAAI,WAAWtE,EAAK,OAAO,MAAM,GAExDsE,EACX,CAEA,SAASxB,GAAYyB,EAAGC,EAAM,CAC1B,GAAI,CACA,OAAOD,EAAE,MAAM,KAAMC,CAAI,CAC7B,OAASC,EAAG,CACR,MAAMvB,EAAMD,GAAqBwB,CAAC,EAClCzE,EAAK,qBAAqBkD,CAAG,CACjC,CACJ,CAEA,SAASzC,GAAWiE,EAAG,CACnB,OAA0BA,GAAM,IACpC,CAEA,SAAShE,GAAkBiE,EAAKC,EAAQC,EAAS,CAC7C,GAAIA,IAAY,OAAW,CACvB,MAAMC,EAAMC,GAAkB,OAAOJ,CAAG,EAClC9E,EAAM+E,EAAOE,EAAI,OAAQ,CAAC,IAAM,EACtC,OAAAd,GAAoB,EAAG,SAASnE,EAAKA,EAAMiF,EAAI,MAAM,EAAE,IAAIA,CAAG,EAC9DlE,EAAkBkE,EAAI,OACfjF,CACX,CAEA,IAAI+D,EAAMe,EAAI,OACV9E,EAAM+E,EAAOhB,EAAK,CAAC,IAAM,EAE7B,MAAMoB,EAAMhB,GAAoB,EAEhC,IAAIhB,EAAS,EAEb,KAAOA,EAASY,EAAKZ,IAAU,CAC3B,MAAMiC,EAAON,EAAI,WAAW3B,CAAM,EAClC,GAAIiC,EAAO,IAAM,MACjBD,EAAInF,EAAMmD,CAAM,EAAIiC,CACxB,CACA,GAAIjC,IAAWY,EAAK,CACZZ,IAAW,IACX2B,EAAMA,EAAI,MAAM3B,CAAM,GAE1BnD,EAAMgF,EAAQhF,EAAK+D,EAAKA,EAAMZ,EAAS2B,EAAI,OAAS,EAAG,CAAC,IAAM,EAC9D,MAAMO,EAAOlB,KAAuB,SAASnE,EAAMmD,EAAQnD,EAAM+D,CAAG,EAC9D3D,EAAM8E,GAAkB,WAAWJ,EAAKO,CAAI,EAElDlC,GAAU/C,EAAI,QACdJ,EAAMgF,EAAQhF,EAAK+D,EAAKZ,EAAQ,CAAC,IAAM,CAC3C,CAEA,OAAApC,EAAkBoC,EACXnD,CACX,CAEA,SAASK,GAAwBgD,EAAK,CAClC,MAAMiC,EAAQnF,EAAK,sBAAsB,IAAIkD,CAAG,EAChD,OAAAlD,EAAK,0BAA0BkD,CAAG,EAC3BiC,CACX,CAEA,IAAIC,GAAoB,IAAI,YAAY,QAAS,CAAE,UAAW,GAAM,MAAO,GAAM,EACjFA,GAAkB,OAAM,EACxB,MAAMC,GAA0B,WAChC,IAAIC,GAAkB,EACtB,SAASlB,GAAWvE,EAAK+D,EAAK,CAC1B,OAAA0B,IAAmB1B,EACf0B,IAAmBD,KACnBD,GAAoB,IAAI,YAAY,QAAS,CAAE,UAAW,GAAM,MAAO,GAAM,EAC7EA,GAAkB,OAAM,EACxBE,GAAkB1B,GAEfwB,GAAkB,OAAOpB,GAAoB,EAAG,SAASnE,EAAKA,EAAM+D,CAAG,CAAC,CACnF,CAEA,MAAMmB,GAAoB,IAAI,YAExB,eAAgBA,KAClBA,GAAkB,WAAa,SAAUJ,EAAKO,EAAM,CAChD,MAAMJ,EAAMC,GAAkB,OAAOJ,CAAG,EACxC,OAAAO,EAAK,IAAIJ,CAAG,EACL,CACH,KAAMH,EAAI,OACV,QAASG,EAAI,MACzB,CACI,GAGJ,IAAIlE,EAAkB,EAENZ,EAChB,SAASuF,GAAoBC,EAAUC,EAAQ,CAC3C,OAAAzF,EAAOwF,EAAS,QAEhBvB,EAAwB,KACxBC,GAA4B,KAC5BC,GAA4B,KAC5BE,GAA2B,KAC3BC,GAA0B,KAC1BtE,EAAK,iBAAgB,EACdA,CACX,CAEA,eAAe0F,GAAWD,EAAQE,EAAS,CACvC,GAAI,OAAO,UAAa,YAAcF,aAAkB,SAAU,CAC9D,GAAI,OAAO,YAAY,sBAAyB,WAC5C,GAAI,CACA,OAAO,MAAM,YAAY,qBAAqBA,EAAQE,CAAO,CACjE,OAAS,EAAG,CAGR,GAFsBF,EAAO,IAAMG,EAAqBH,EAAO,IAAI,GAE9CA,EAAO,QAAQ,IAAI,cAAc,IAAM,mBACxD,QAAQ,KAAK,oMAAqM,CAAC,MAE9M,OAAM,CACnB,CAGJ,MAAMtF,EAAQ,MAAMsF,EAAO,YAAW,EACtC,OAAO,MAAM,YAAY,YAAYtF,EAAOwF,CAAO,CACvD,KAAO,CACH,MAAMH,EAAW,MAAM,YAAY,YAAYC,EAAQE,CAAO,EAE9D,OAAIH,aAAoB,YAAY,SACzB,CAAE,SAAAA,EAAU,OAAAC,CAAM,EAElBD,CAEf,CAEA,SAASI,EAAqBxC,EAAM,CAChC,OAAQA,EAAI,CACR,IAAK,QAAS,IAAK,OAAQ,IAAK,UAAW,MAAO,EAC9D,CACQ,MAAO,EACX,CACJ,CAsBA,eAAeyC,GAAWC,EAAgB,CACtC,GAAI9F,IAAS,OAAW,OAAOA,EAG3B8F,IAAmB,SACf,OAAO,eAAeA,CAAc,IAAM,OAAO,UAChD,CAAC,eAAAA,CAAc,EAAIA,EAEpB,QAAQ,KAAK,2FAA2F,GAKhH,MAAMH,EAAU1D,GAAiB,GAE7B,OAAO6D,GAAmB,UAAa,OAAO,SAAY,YAAcA,aAA0B,SAAa,OAAO,KAAQ,YAAcA,aAA0B,OACtKA,EAAiB,MAAMA,CAAc,GAGzC,KAAM,CAAE,SAAAN,CAAiB,EAAI,MAAME,GAAW,MAAMI,EAAgBH,CAAO,EAE3E,OAAOJ,GAAoBC,CAAgB,CAC/C,CCplBA,MAAMO,GAAM,IAAI,aAAa,CAAC,EACxBC,GAAM,IAAI,YAAYD,GAAI,MAAM,EAChCE,GAAuB,iBAAkB,WACzCC,GAAMD,GACR,IAAI,WAAW,aAA2C,CAAC,EAC3D,KACEE,GAAM,IAAI,YAAYD,IAAA,YAAAA,GAAK,MAAM,EAEvC,SAASE,GAAajB,EAAuB,CAC3C,OAAAe,GAAI,CAAC,EAAIf,EACFgB,GAAI,CAAC,CACd,CAEA,SAASE,GAASlB,EAAuB,CACvCY,GAAI,CAAC,EAAIZ,EACT,MAAMmB,EAAON,GAAI,CAAC,EACZO,EAAQD,IAAS,GAAM,MACvBE,EAAYF,IAAS,GAAM,IAC3BG,EAAWH,EAAO,QAExB,GAAIE,IAAa,IACf,OAAOD,GAAQE,IAAa,EAAI,MAAS,OAG3C,MAAMC,EAAeF,EAAW,IAAM,GACtC,OAAIE,GAAgB,GAAaH,EAAO,MACpCG,GAAgB,EACdA,EAAe,IAAYH,EACxBA,GAASE,EAAW,WAAgB,EAAIC,EAAe,GAEzDH,EAAQG,GAAgB,GAAOD,IAAa,EACrD,CAEA,SAASE,GAAexB,EAAuB,CAC7C,OAAAgB,GAAI,CAAC,EAAIhB,EACFe,GAAI,CAAC,CACd,CAEA,SAASU,GAAWzB,EAAuB,CACzC,MAAMoB,EAAQpB,IAAU,GAAM,EACxBqB,EAAYrB,IAAU,GAAM,GAC5BsB,EAAWtB,EAAQ,KACzB,IAAImB,EAEJ,GAAIE,IAAa,EACf,GAAIC,IAAa,EACfH,EAAOC,GAAQ,OACV,CACL,IAAIM,EAAWJ,EACXK,EAAmB,IACvB,MAAQD,EAAW,QAAW,GAC5BA,IAAa,EACbC,GAAoB,EAEtBR,EACGC,GAAQ,GACPO,EAAmB,KAAQ,IAC3BD,EAAW,OAAU,EAC3B,MACSL,IAAa,GACtBF,EAAQC,GAAQ,IAAOE,IAAa,EAAI,WAAc,YAEtDH,EAAQC,GAAQ,GAAQC,EAAW,GAAK,KAAQ,GAAOC,GAAY,GAGrE,OAAAT,GAAI,CAAC,EAAIM,EACFP,GAAI,CAAC,CACd,CAEO,MAAMgB,EAASd,GAAuBG,GAAeC,GAC/CW,EAAWf,GAAuBU,GAAiBC,GCrEzD,IAAKK,GAAAA,IACVA,EAAAA,EAAA,SAAW,CAAA,EAAX,WACAA,EAAAA,EAAA,WAAa,CAAA,EAAb,aACAA,EAAAA,EAAA,eAAiB,CAAA,EAAjB,iBACAA,EAAAA,EAAA,OAAS,EAAA,EAAT,SACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,MAAQ,EAAA,EAAR,QACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,MAAQ,EAAA,EAAR,QACAA,EAAAA,EAAA,UAAY,EAAA,EAAZ,YACAA,EAAAA,EAAA,OAAS,EAAA,EAAT,SACAA,EAAAA,EAAA,SAAW,EAAA,EAAX,WACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,SAAW,EAAA,EAAX,WACAA,EAAAA,EAAA,SAAW,EAAA,EAAX,WACAA,EAAAA,EAAA,OAAS,EAAA,EAAT,SACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,MAAQ,EAAA,EAAR,QACAA,EAAAA,EAAA,MAAQ,EAAA,EAAR,QACAA,EAAAA,EAAA,SAAW,EAAA,EAAX,WACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,UAAY,EAAA,EAAZ,YACAA,EAAAA,EAAA,QAAU,EAAA,EAAV,UACAA,EAAAA,EAAA,aAAe,EAAA,EAAf,eACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,GAAK,EAAA,EAAL,KACAA,EAAAA,EAAA,mBAAqB,EAAA,EAArB,qBACAA,EAAAA,EAAA,aAAe,EAAA,EAAf,eACAA,EAAAA,EAAA,MAAQ,EAAA,EAAR,QACAA,EAAAA,EAAA,OAAS,EAAA,EAAT,SACAA,EAAAA,EAAA,MAAQ,EAAA,EAAR,QACAA,EAAAA,EAAA,IAAM,EAAA,EAAN,MACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,KAAO,EAAA,EAAP,OACAA,EAAAA,EAAA,UAAY,EAAA,EAAZ,YACAA,EAAAA,EAAA,kBAAoB,EAAA,EAApB,oBAjDUA,IAAAA,GAAA,CAAA,CAAA,EAqDAC,GAAAA,IACVA,EAAAA,EAAA,SAAW,CAAA,EAAX,WACAA,EAAAA,EAAA,MAAQ,CAAA,EAAR,QACAA,EAAAA,EAAA,WAAa,CAAA,EAAb,aACAA,EAAAA,EAAA,QAAU,CAAA,EAAV,UACAA,EAAAA,EAAA,MAAQ,CAAA,EAAR,QACAA,EAAAA,EAAA,MAAQ,CAAA,EAAR,QACAA,EAAAA,EAAA,IAAM,CAAA,EAAN,MAPUA,IAAAA,GAAA,CAAA,CAAA,EAWL,MAAMC,GAAuB,GAyEvBC,GAAuC,EAEvCC,EAAsC,EAEtCC,GAA0C,EAE1CC,GAA2C,EAE3CC,GAA+C,EAE/CC,EAAuC,EAEvCC,EAAqC,MAkBrCC,GAGT,CACF,IAAK,EACL,IAAK,EACL,GAAI,EACJ,OAAQ,EACR,GAAI,EACJ,OAAQ,EACR,IAAK,EACL,QAAS,EACT,IAAK,EACL,QAAS,EACT,IAAK,EACL,IAAK,CACP,EA4OaC,GAAqC,EAErCC,GAA2C,EAE3CC,GAAwC,EAExCC,GAAuC,EAEvCC,GAAwC,EAExCC,GAAsC,EC5a7CC,GAAoB,IACpBC,GAAc,sBACdC,GAA+B,OAErC,SAASC,GAAMlD,EAAemD,EAAaC,EAAa,CACtD,OAAO,KAAK,IAAIA,EAAK,KAAK,IAAID,EAAKnD,CAAK,CAAC,CAC3C,CAEO,SAASqD,GAAmBC,EAAc,CAC/C,MAAMC,EAAc1B,EAASyB,IAAS,EAAE,EACxC,GAAIC,EAAc,EAAG,CACnB,MAAMC,EAAcD,EAAc,EAAI,EACtC,OAAO,KAAK,IACVR,GACA,KAAK,KAAKS,EAAcA,EAAc,GAAK,KAAK,CAAC,CAAA,CAErD,CACA,OAAO3B,EAASyB,EAAO,KAAM,CAC/B,CAEO,SAASG,GAAmBC,EAAiB,CAClD,GAAIA,EAAU,GAAKA,GAAW,EAAG,OAAO9B,EAAO8B,CAAO,EACtD,MAAM1D,EAAQkD,GAAMQ,EAAS,EAAGX,EAAiB,EACjD,GAAI/C,EAAQ,EAAG,CACb,MAAMuD,EAAc,KAAQ,KAAK,KAAK,KAAK,IAAIvD,CAAK,EAAI,KAAK,EAAI,CAAC,EAAI,GACtE,OAAQ4B,EAAO,CAAC,EAAKA,EAAO2B,CAAW,GAAK,MAAS,CACvD,CACA,OAAO3B,EAAO5B,CAAK,CACrB,CAIO,SAAS2D,GACdL,EACAM,EACAC,EAAO,EACPC,EAAS,EACT,CACA,MAAMC,EAAIT,EAAO,KACXU,EAAKV,IAAS,GAAM,KACpBW,EAAQX,IAAS,GACvB,IAAI/D,EAAKwE,EAAI,KAAQ,EAAI,EACrBG,EAAKF,EAAI,KAAQ,EAAI,EACzB,MAAMG,EAAI,EAAI,KAAK,IAAI5E,CAAC,EAAI,KAAK,IAAI2E,CAAC,EAChCE,EAAO,KAAK,IAAI,CAACD,EAAG,CAAC,EAC3B5E,GAAKA,GAAK,EAAI,CAAC6E,EAAOA,EACtBF,GAAKA,GAAK,EAAI,CAACE,EAAOA,EACtB,MAAMC,EAAgB,EAAI,KAAK,KAAK9E,EAAIA,EAAI2E,EAAIA,EAAIC,EAAIA,CAAC,EACnDG,EAAaL,EAAQ,KAAQ,GAAM,KAAK,GACxCM,EAAO,KAAK,IAAID,CAAS,EAC/BV,EAAOC,CAAI,EAAItE,EAAI8E,EAAgBE,EACnCX,EAAOC,EAAOC,CAAM,EAAII,EAAIG,EAAgBE,EAC5CX,EAAOC,EAAOC,EAAS,CAAC,EAAIK,EAAIE,EAAgBE,EAChDX,EAAOC,EAAOC,EAAS,CAAC,EAAI,KAAK,IAAIQ,CAAS,CAChD,CAEA,SAASE,GACPC,EACAC,EACAC,EACAC,EACAC,EACA,CACA,MAAMC,EAAgBL,EAAKA,EAAKC,EAAKA,EAAKC,EAAKA,EAAKC,EAAKA,EACzD,GACE,CAAC,OAAO,SAASE,CAAa,GAC9BA,GAAiBD,EAEjB,OAEF,GAAIJ,IAAO,GAAKC,IAAO,GAAKC,IAAO,EACjC,OAAO1B,GAGT,MAAMoB,EAAgB,EAAI,KAAK,KAAKS,CAAa,EACjD,IAAIvF,EAAIkF,EAAKJ,EACTH,EAAIQ,EAAKL,EACTF,EAAIQ,EAAKN,EACTU,EAAIH,EAAKP,EACTU,EAAI,IACNxF,EAAI,CAACA,EACL2E,EAAI,CAACA,EACLC,EAAI,CAACA,EACLY,EAAI,CAACA,GAGP,MAAMC,EAAQ,EAAI,KAAK,KAAK9B,GAAM6B,EAAG,EAAG,CAAC,CAAC,EACpCR,EAAO,KAAK,IAAIS,EAAQ,EAAG,EAC3BC,EAAQ,KAAK,IAAIV,CAAI,EAAI,KAAO,EAAIhF,EAAIgF,EACxCW,EAAQ,KAAK,IAAIX,CAAI,EAAI,KAAO,EAAIL,EAAIK,EACxCY,EAAQ,KAAK,IAAIZ,CAAI,EAAI,KAAO,EAAIJ,EAAII,EACxCa,EAAM,KAAK,IAAIH,CAAK,EAAI,KAAK,IAAIC,CAAK,EAAI,KAAK,IAAIC,CAAK,EAC9D,IAAIE,EAAOJ,EAAQG,EACfE,EAAOJ,EAAQE,EACnB,GAAID,EAAQ,EAAG,CACb,MAAMI,EAAYF,EAClBA,GAAQ,EAAI,KAAK,IAAIC,CAAI,IAAMD,GAAQ,EAAI,EAAI,IAC/CC,GAAQ,EAAI,KAAK,IAAIC,CAAS,IAAMD,GAAQ,EAAI,EAAI,GACtD,CAEA,MAAM,EAAI,KAAK,MAAMpC,IAAOmC,EAAO,GAAM,IAAO,KAAM,EAAG,IAAI,CAAC,EACxDrB,EAAI,KAAK,MAAMd,IAAOoC,EAAO,GAAM,IAAO,KAAM,EAAG,IAAI,CAAC,EAE9D,OADc,KAAK,MAAMpC,GAAO8B,EAAQ,KAAK,GAAM,KAAM,EAAG,IAAI,CAAC,GAC/C,GAAOhB,GAAK,GAAM,KAAO,CAC7C,CAWO,SAASwB,GACdf,EACAC,EACAC,EACAC,EACA,CACA,OAAOJ,GAAiBC,EAAIC,EAAIC,EAAIC,EAAI5B,EAAW,CACrD,CCpFA,MAAMyC,GAAiB,IACjBC,GAAqB,EAAI,MAAQ,EACjCC,GAAoC,WACpCC,GAAgC,WAEtC,SAASC,GAAoBC,EAA2B,CACtD,MAAMC,EAAQD,EAAa,OAASxD,EACpC,GAAI,CAAC,OAAO,UAAUyD,CAAK,EACzB,MAAM,IAAI,MAAM,wCAAwC,EAE1D,OAAOA,CACT,CAEA,SAASC,GAAiBF,EAA2BG,EAAe,CAClE,OAAOH,EACLG,EAAQ3D,EACNJ,CACJ,CACF,CAEA,SAASgE,GAAaC,EAA4BC,EAAsB,CACtE,MAAMC,EAAgBF,EAAqB,aAAa,kBACxD,OAAO,KAAK,IACVC,EACAX,GACA,KAAK,IAAI,EAAG,KAAK,MAAMC,GAAqBW,CAAa,CAAC,CAAA,CAE9D,CAQO,SAASC,GACdC,EACA,CACA,KAAM,CAAE,aAAAT,EAAc,QAAAU,EAAS,UAAAC,CAAA,EAAcF,EACvCG,EAAmBb,GAAoBC,CAAY,EACnDa,EAAW,IAAI,YAAYD,CAAgB,EACjD,QAAST,EAAQ,EAAGA,EAAQS,EAAkBT,GAAS,EAAG,CACxDU,EAASV,CAAK,EAAIA,EAClB,MAAMW,EAAoBX,EAAQ3D,EAClC,QACMuE,EAAgB,EACpBA,EAAgBxE,GAChBwE,GAAiB,EACjB,CACA,MAAMC,EACJhB,EACEc,EACExE,GACAyE,CACJ,EACF,GAAIC,IAAavE,EAAoC,MACrDoE,EAASG,CAAQ,EAAIb,CACvB,CACF,CACA,MAAMc,EAAwBN,GAAA,YAAAA,EAAW,OACzC,GAAIM,EACF,QACMC,EAAc,EAClBA,EAAcD,EAAsB,OACpCC,GAAelE,GACf,CACA,MAAMmE,EACJF,EACEC,EAAcrE,EAChB,EACIuE,EACJH,EACEC,EAActE,EAChB,EACFiE,EAASM,CAAQ,EAAI,KAAK,IAAIN,EAASM,CAAQ,EAAGC,CAAW,CAC/D,CAGF,MAAMC,EAAaT,EACnB,UAAW9C,IAAU,CACnB4C,EAAQ,SACRA,EAAQ,MACRA,EAAQ,WACRA,EAAQ,QACRA,EAAQ,MACRA,EAAQ,MACR,GAAIA,EAAQ,IAAM,CAAA,CAAC,EAEf5C,IAAW,SAAW+C,EAAS/C,CAAM,EAAIuD,GAG/C,MAAMC,EAAkB,IAAI,YAAYV,CAAgB,EAClDW,EAAoB,IAAI,WAAWX,CAAgB,EACzD,IAAIP,EAAqB,EACzB,QAASF,EAAQ,EAAGA,EAAQS,EAAkBT,GAAS,EAAG,CACxD,MAAMW,EAAoBX,EAAQ3D,EAEhCwD,EAAac,EAAoB3E,EAAoC,IACrEH,EAAO,WAEPuF,EAAkBpB,CAAK,EAAI,EAC3BU,EAASV,CAAK,EAAIkB,EAClBC,EAAgBnB,CAAK,EAAIE,EACzBA,GACEL,EAAac,EAAoB1E,CAAmC,EAE1E,CAEA,MAAMoF,EAAe,IAAI,WAAWZ,EAAmB,CAAC,EAAE,KAAK,EAAE,EAC3Da,EAAc,IAAI,WAAWb,CAAgB,EAAE,KAAK,EAAE,EACtDc,EAAkC,CAAA,EAElCC,EAAU,CAACC,EAAwBC,IAA0B,CACjE,IAAI9J,EAAS6J,EACTE,EAAQD,EACRE,EAAc,EAClB,KACEA,EAAcL,EAAW,QACzBA,EAAWK,CAAW,EAAE,OAAShK,GAEjCgK,GAAe,EAGjB,MAAMC,EAAWN,EAAWK,EAAc,CAAC,EACvCC,GAAYA,EAAS,OAASA,EAAS,QAAUjK,IACnDA,EAASiK,EAAS,OAClBF,GAASE,EAAS,MAClBN,EAAW,OAAOK,EAAc,EAAG,CAAC,EACpCA,GAAe,GAEjB,MAAME,EAAOP,EAAWK,CAAW,EAC/BE,GAAQlK,EAAS+J,IAAUG,EAAK,SAClCH,GAASG,EAAK,MACdP,EAAW,OAAOK,EAAa,CAAC,GAElCL,EAAW,OAAOK,EAAa,EAAG,CAAE,OAAAhK,EAAQ,MAAA+J,EAAO,CACrD,EAEMI,EAAYJ,GAAkB,CAClC,IAAIK,EAAY,GAChB,QAAShC,EAAQ,EAAGA,EAAQuB,EAAW,OAAQvB,GAAS,EAAG,CACzD,MAAMiC,EAAQV,EAAWvB,CAAK,EAE5BiC,EAAM,OAASN,IACdK,IAAc,IAAMC,EAAM,MAAQV,EAAWS,CAAS,EAAE,SAEzDA,EAAYhC,EAEhB,CACA,GAAIgC,IAAc,GAAI,CACpB,MAAMpK,EAASsI,EACf,OAAAA,GAAsByB,EACf/J,CACT,CAEA,MAAMqK,EAAQV,EAAWS,CAAS,EAC5BpK,EAASqK,EAAM,OACrB,OAAIA,EAAM,QAAUN,EAAOJ,EAAW,OAAOS,EAAW,CAAC,GAEvDC,EAAM,QAAUN,EAChBM,EAAM,OAASN,GAEV/J,CACT,EAEA,QAASoI,EAAQ,EAAGA,EAAQS,EAAkBT,GAAS,EAAG,CACxD,QACMkC,EAAWb,EAAarB,CAAK,EACjCkC,IAAa,GACbA,EAAWZ,EAAYY,CAAQ,EAE/BV,EACEL,EAAgBe,CAAQ,EACxBnC,GAAiBF,EAAcqC,CAAQ,CAAA,EAG3C,GAAId,EAAkBpB,CAAK,EAAG,SAC9B,MAAM2B,EAAQ5B,GAAiBF,EAAcG,CAAK,EAC5CpI,EAASmK,EAASJ,CAAK,EAC7BR,EAAgBnB,CAAK,EAAIpI,EACzB,MAAMuK,EAAezB,EAASV,CAAK,EAAI,EACnCmC,GAAgB1B,IAClBa,EAAYtB,CAAK,EAAIqB,EAAac,CAAY,EAC9Cd,EAAac,CAAY,EAAInC,EAEjC,CACA,MAAMoC,EAAsBtB,EACxBA,EAAsB,OAASjE,GAC/B,EACJ,GAAI,CAAC,OAAO,UAAUuF,CAAmB,EACvC,MAAM,IAAI,MAAM,0CAA0C,EAE5D,IAAIC,EAA4B,IAAI,YAChCC,EAAuB,IAAI,YAC/B,GAAIxB,GAAyBsB,IAAwB,EAAG,CACtD,GAAIlC,EAAqB,MACvB,MAAM,IAAI,MAAM,oDAAoD,EAGtE,MAAMqC,EAAkB,IAAI,YAAYH,CAAmB,EAC3D,QAASI,EAAQ,EAAGA,EAAQJ,EAAqBI,GAAS,EAAG,CAC3D,MAAMC,EACJ3B,EACE0B,EAAQ3F,GACNJ,EACJ,EAAI,EACN,GACEgG,EAAWhC,GACV+B,IAAU,GAAKC,GAAYF,EAAgBC,EAAQ,CAAC,EAErD,MAAM,IAAI,MAAM,6CAA6C,EAE/DD,EAAgBC,CAAK,EAAIC,CAC3B,CAEA,MAAMC,EAAyBzB,GAAwB,CACrD,IAAI0B,EAAQ,EACRC,EAAMR,EACV,KAAOO,EAAQC,GAAK,CAClB,MAAMC,EAAUF,EAAQC,IAAS,EAC7BL,EAAgBM,CAAM,GAAK5B,IAAqB4B,EAAS,EACxDD,EAAMC,CACb,CACA,OAAOF,CACT,EACMG,EAAc,IAAI,YAAYrC,CAAgB,EAC9CsC,EAAY,IAAI,YAAYtC,CAAgB,EAC5CuC,EAAc,IAAI,YAAYZ,CAAmB,EACjDa,EAAgB,IAAI,YAAYb,CAAmB,EACzD,QAASpC,EAAQ,EAAGA,EAAQS,EAAkBT,GAAS,EAAG,CACxD,GAAIoB,EAAkBpB,CAAK,EAAG,SAC9B,MAAMkD,EAAaR,EAAsB1C,CAAK,EACxCmD,EAAWT,EAAsBhC,EAASV,CAAK,CAAC,EACtD,GAAIkD,GAAcC,EAAU,SAC5BL,EAAY9C,CAAK,EAAIkD,EACrBH,EAAU/C,CAAK,EAAImD,EACnB,MAAMxB,EACJ9B,EACEG,EAAQ3D,EACNJ,CACJ,EACF+G,EAAYE,CAAU,GAAKvB,EACvBwB,EAAWf,IACbY,EAAYG,CAAQ,GAAKxB,EACzBsB,EAAcE,CAAQ,GAAKxB,EAE/B,CACA,MAAMyB,EAAc,IAAI,YAAYhB,EAAsB,CAAC,EAC3D,QAASI,EAAQ,EAAGA,EAAQJ,EAAqBI,GAAS,EACxDY,EAAYZ,EAAQ,CAAC,EAAIY,EAAYZ,CAAK,EAAIQ,EAAYR,CAAK,EAEjEH,EAA4Be,EAE5Bd,EAAuB,IAAI,YAAYc,EAAYhB,CAAmB,CAAC,EACvE,MAAMiB,EAAiB,IAAI,YACzBD,EAAY,SAAS,EAAGhB,CAAmB,CAAA,EAEvCkB,EAAkB,IAAI,YAAYlB,CAAmB,EAC3D,QAASI,EAAQ,EAAGA,EAAQJ,EAAqBI,GAAS,EACxDc,EAAgBd,CAAK,EAAIY,EAAYZ,CAAK,EAAIS,EAAcT,CAAK,EAEnE,QAASxC,EAAQ,EAAGA,EAAQS,EAAkBT,GAAS,EAAG,CACxD,MAAMkD,EAAaJ,EAAY9C,CAAK,EAC9BmD,EAAWJ,EAAU/C,CAAK,EAChC,GAAIkD,GAAcC,EAAU,SAC5B,MAAMxB,EACJ9B,EACEG,EAAQ3D,EACNJ,CACJ,EACIrE,EAASuJ,EAAgBnB,CAAK,EACpC,QAASuD,EAAO,EAAGA,EAAO5B,EAAO4B,GAAQ,EAAG,CAC1C,MAAMC,EAAc5L,EAAS2L,EACzBJ,EAAWf,IACbE,EAAqBe,EAAeF,CAAQ,CAAC,EAC3CxD,GAAgC6D,EAClCH,EAAeF,CAAQ,GAAK,GAE9Bb,EAAqBgB,EAAgBJ,CAAU,CAAC,EAAIM,EACpDF,EAAgBJ,CAAU,GAAK,CACjC,CACF,CACF,CAEA,MAAO,CACL,gBAAA/B,EACA,mBAAAjB,EACA,0BAAAmC,EACA,qBAAAC,CAAA,CAEJ,CAEA,SAASmB,GAAQC,EAAcC,EAAe,CAC5C,OAAI,OAAO,MAAMD,CAAI,EAAUC,EAC3B,OAAO,MAAMA,CAAK,EAAUD,EACzB,KAAK,IAAIA,EAAMC,CAAK,CAC7B,CAEA,SAASC,GAAQF,EAAcC,EAAe,CAC5C,OAAI,OAAO,MAAMD,CAAI,EAAUC,EAC3B,OAAO,MAAMA,CAAK,EAAUD,EACzB,KAAK,IAAIA,EAAMC,CAAK,CAC7B,CAEA,SAASE,GAAkB9J,EAAe,CACxC,OAAOA,EAAQ,EAAI,CAAC,KAAK,MAAM,CAACA,CAAK,EAAI,KAAK,MAAMA,CAAK,CAC3D,CAEA,SAASkD,GAAMlD,EAAemD,EAAaC,EAAa,CACtD,OAAO,KAAK,IAAIA,EAAK,KAAK,IAAID,EAAKnD,CAAK,CAAC,CAC3C,CAEA,MAAM+J,GAAoB,CACxB,IAAK,CAACC,EAAMnM,IAAWmM,EAAK,WAAWnM,EAAQ,EAAI,EACnD,IAAK,CAACmM,EAAMnM,IAAWgE,EAASmI,EAAK,UAAUnM,EAAQ,EAAI,CAAC,EAC5D,GAAI,CAACmM,EAAMnM,IAAWmM,EAAK,SAASnM,CAAM,EAC1C,OAAQ,CAACmM,EAAMnM,IAAWmM,EAAK,SAASnM,CAAM,EAAI,IAClD,GAAI,CAACmM,EAAMnM,IAAWmM,EAAK,QAAQnM,CAAM,EACzC,OAAQ,CAACmM,EAAMnM,IAAW,KAAK,IAAI,GAAImM,EAAK,QAAQnM,CAAM,EAAI,GAAI,EAClE,IAAK,CAACmM,EAAMnM,IAAWmM,EAAK,UAAUnM,EAAQ,EAAI,EAClD,QAAS,CAACmM,EAAMnM,IAAWmM,EAAK,UAAUnM,EAAQ,EAAI,EAAI,MAC1D,IAAK,CAACmM,EAAMnM,IAAWmM,EAAK,SAASnM,EAAQ,EAAI,EACjD,QAAS,CAACmM,EAAMnM,IAAW,KAAK,IAAI,GAAImM,EAAK,SAASnM,EAAQ,EAAI,EAAI,KAAM,EAC5E,IAAK,CAACmM,EAAMnM,IAAWmM,EAAK,UAAUnM,EAAQ,EAAI,EAClD,IAAK,CAACmM,EAAMnM,IAAWmM,EAAK,SAASnM,EAAQ,EAAI,CACnD,EAKA,SAASoM,GACPD,EACAE,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACA,CACA,MAAMC,EAAiBjI,GAAuB0H,EAAU,MAAM,EACxDQ,EAAOX,GAAkBG,EAAU,MAAM,EAC/C,QAASS,EAAY,EAAGA,EAAYT,EAAU,WAAYS,GAAa,EAAG,CACxE,MAAMC,EAAkBL,EAAaI,EAAYN,EACjD,GAAIG,EACF,QAASvE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAM4E,EACJX,EAAU,YACTC,EAAaK,EAAcvE,CAAK,GAAKiE,EAAU,WAChDS,EAAYF,EACdH,EAAUM,EAAkB3E,CAAK,EAAIyE,EAAKV,EAAMa,CAAW,CAC7D,KACK,CACL,IAAIA,EACFX,EAAU,WACVC,EAAaD,EAAU,WACvBS,EAAYF,EACd,QAASxE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAC/CqE,EAAUM,EAAkB3E,CAAK,EAAIyE,EAAKV,EAAMa,CAAW,EAC3DA,GAAeX,EAAU,UAE7B,CACF,CACF,CAEA,SAAS1F,GACP8F,EACAzG,EACAC,EACA,CACA,OAAO0B,GACL8E,EAAUzG,CAAI,EACdyG,EAAUzG,EAAOC,CAAM,EACvBwG,EAAUzG,EAAOC,EAAS,CAAC,EAC3BwG,EAAUzG,EAAOC,EAAS,CAAC,CAAA,CAE/B,CAEA,SAASgH,GACPxH,EACAM,EACAC,EACAC,EACA,CACA,MAAMiH,EAAmBzH,IAAS,GAC5B0H,EAAa,KAAOD,IAAqB,GAAK,IAAM,IAC1D,QAASJ,EAAY,EAAGA,EAAY,EAAGA,GAAa,EAAG,CACrD,MAAMM,GAAc3H,IAAUqH,EAAY,EAAM,KAAQK,EACxDpH,EAAOC,EAAO8G,EAAY7G,CAAM,EAC9BiH,EAAoB,GAAKJ,EAAa,CAACM,EAAYA,CACvD,CACF,CAEA,SAASC,GAASZ,EAAyBzG,EAAcC,EAAgB,CACvE,MAAMqH,EAAMb,EAAUzG,CAAI,EACpBuH,EAAQd,EAAUzG,EAAOC,CAAM,EAC/BuH,EAAOf,EAAUzG,EAAOC,EAAS,CAAC,EAClCwH,EAAczB,GAClB,KAAK,IAAIsB,CAAG,EACZtB,GAAQ,KAAK,IAAIuB,CAAK,EAAG,KAAK,IAAIC,CAAI,CAAC,CAAA,EAEnChK,EAAWyI,GACf5G,GAAM,KAAK,MAAM,KAAK,KAAKoI,CAAW,CAAC,EAAI,GAAI,EAAG,EAAE,CAAA,EAEhDC,EAAU,IAAMlK,EAAW,IAAM,IACjCmK,EAAmBxL,GACvB8J,GAAkB5G,GAAM,KAAK,IAAIlD,CAAK,EAAIuL,EAAS,EAAG,GAAG,CAAC,EACtDE,GAASN,EAAM,EAAI,EAAI,IAAMC,EAAQ,EAAI,EAAI,IAAMC,EAAO,EAAI,EAAI,GACxE,OACGG,EAAgBL,CAAG,EACjBK,EAAgBJ,CAAK,GAAK,EAC1BI,EAAgBH,CAAI,GAAK,IACvBhK,GAAY,EAAKoK,IAAU,MAChC,CAEJ,CAEA,SAASC,GACP1B,EACA2B,EACmC,CACnC,GAAIA,GAAe,GAAK3B,EAAK,UAAY,CAACA,EAAK,IAAK2B,CAAW,EAC/D,GAAIA,IAAgB,GAAK3B,EAAK,KAAOA,EAAK,IAAK,MAAO,CAACA,EAAK,IAAK,CAAC,EAClE,GAAI2B,GAAe,GAAK3B,EAAK,UAAY,CAACA,EAAK,IAAK2B,EAAc,CAAC,EACnE,GAAIA,GAAe,IAAM3B,EAAK,WAAa,CAACA,EAAK,KAAM2B,EAAc,CAAC,EACtE,GAAIA,GAAe,IAAM3B,EAAK,WAAa,CAACA,EAAK,KAAM2B,EAAc,EAAE,CAEzE,CAEA,MAAMC,GAAkB,EAClBC,GAAe,EACfC,GAAoB,EACpBC,GAAiB,EACjBC,GAAe,EACfC,GAAe,EACfC,GAAe,EACfC,EAAsB,WAW5B,SAASC,GACPpC,EACAzD,EACA8F,EACiB,CACjB,KAAM,CAAE,QAAA7F,GAAYD,EACd+F,EAAc,IAAI,YAAYJ,EAAY,EAChDI,EAAY,KAAKH,CAAmB,EACpC,IAAII,EAAmB,EACvB,MAAMC,EAAgB,CAACC,EAAcxF,IAAiC,CAChEA,IAAa,SACfqF,EAAYG,CAAI,EAAIJ,EAAcpF,CAAQ,EAC1CsF,GAAoB,EAExB,EACAC,EAAcZ,GAAiBpF,EAAQ,QAAQ,EAC/CgG,EAAcX,GAAcrF,EAAQ,KAAK,EACzCgG,EAAcV,GAAmBtF,EAAQ,UAAU,EACnDgG,EAAcT,GAAgBvF,EAAQ,OAAO,EAC7CgG,EAAcR,GAAcxF,EAAQ,KAAK,EACzCgG,EAAcP,GAAczF,EAAQ,KAAK,EAEzC,MAAMkG,EAAgC,CAAA,EAChCC,EAA0B,CAAA,EAC1BC,EAA4B,CAAA,EAClC,GAAIpG,EAAQ,GACV,QACMmF,EAAc,EAClBA,EAAc3J,GACd2J,GAAe,EACf,CACA,MAAMkB,EAAWnB,GAAO1B,EAAM2B,CAAW,EACpCkB,IACLH,EAAe,KAAKG,EAAS,CAAC,CAAC,EAC/BF,EAAc,KAAKE,EAAS,CAAC,CAAC,EAC9BD,EAAgB,KAAKP,EAAc7F,EAAQ,GAAGmF,CAAW,CAAC,CAAC,EAC7D,CAGF,MAAO,CACL,YAAAW,EACA,eAAAI,EACA,cAAe,IAAI,WAAWC,CAAa,EAC3C,gBAAiB,IAAI,YAAYC,CAAe,EAChD,kBACEpG,EAAQ,WAAa,QAAaA,EAAQ,QAAU,OACtD,cAAe+F,IAAqB,GAAKG,EAAe,SAAW,CAAA,CAEvE,CAEA,SAASI,GACPC,EACA5C,EACAC,EACAC,EACAL,EACAgD,EACA1C,EACAC,EACAC,EACA,CACA,OAAQuC,EAAA,CACN,KAAKhL,EAAW,SACd,QAASkE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EACxCiH,GAAY/C,EAAa8C,GAAe,EAC9C3C,EAAUC,EAAatE,CAAK,EAAI+G,EAAYE,CAAQ,EACpD5C,EAAUC,EAAaF,EAAYpE,CAAK,EAAI+G,EAAYE,EAAW,CAAC,EACpE5C,EAAUC,EAAaF,EAAY,EAAIpE,CAAK,EAC1C+G,EAAYE,EAAW,CAAC,CAC5B,CACA,MACF,KAAKnL,EAAW,MACd,QAASkE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EACxCiH,GAAY/C,EAAa8C,GAAe,EACxCE,EAAQnD,EAAK,OAAOkD,EAAW,CAAC,EAChCE,EAAQpD,EAAK,OAAOkD,EAAW,CAAC,EACtC5C,EAAUC,EAAatE,CAAK,EAAI,KAAK,IAAIpE,EAASsL,IAAU,EAAE,CAAC,EAC/D7C,EAAUC,EAAaF,EAAYpE,CAAK,EAAI,KAAK,IAC/CpE,EAASuL,EAAQ,KAAM,CAAA,EAEzB9C,EAAUC,EAAaF,EAAY,EAAIpE,CAAK,EAAI,KAAK,IACnDpE,EAASuL,IAAU,EAAE,CAAA,CAEzB,CACA,MACF,KAAKrL,EAAW,WACd,QAASkE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EACxCiH,GAAY/C,EAAa8C,GAAe,EAC9CtJ,GACEqG,EAAK,OAAOkD,EAAW,CAAC,EACxB5C,EACAC,EAAatE,EACboE,CAAA,CAEJ,CACA,MACF,KAAKtI,EAAW,QACd,QAASkE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EAC9CqE,EAAUC,EAAatE,CAAK,EAAI5C,GAC9B2G,EAAK,QAAQG,EAAa8C,GAAe,EAAI,CAAC,CAAA,CAElD,CACA,MACF,KAAKlL,EAAW,MACd,QAASkE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EAC9CqE,EAAUC,EAAatE,CAAK,EAAIpE,EAC9BmI,EAAK,QAAQG,EAAa8C,GAAe,EAAI,CAAC,EAAI,KAAA,CAEtD,CACA,MACF,KAAKlL,EAAW,MACd,QAASkE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EACxCiH,GAAY/C,EAAa8C,GAAe,EACxCI,EAAQrD,EAAK,OAAOkD,CAAQ,EAC5BC,EAAQnD,EAAK,OAAOkD,EAAW,CAAC,EACtC5C,EAAUC,EAAatE,CAAK,EAAIpE,EAASwL,EAAQ,KAAM,EACvD/C,EAAUC,EAAaF,EAAYpE,CAAK,EAAIpE,EAASwL,IAAU,EAAE,EACjE/C,EAAUC,EAAaF,EAAY,EAAIpE,CAAK,EAAIpE,EAC9CsL,EAAQ,KAAA,CAEZ,CACA,MACF,QAAS,CACP,MAAMxB,EAAcoB,EAAQhL,EAAW,IACjC8K,EAAWnB,GAAO1B,EAAM2B,CAAW,EACzC,GAAIkB,EACF,QAAS5G,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAczC,GAAA,YAAAA,EAAgBvE,KAAUA,EAC9C6E,GACE+B,EAAS,CAAC,GAAG1C,EAAa8C,GAAe,EAAIJ,EAAS,CAAC,CAAC,EACxDvC,EACAC,EAAatE,EACboE,CAAA,CAEJ,MAEAC,EAAU,KAAK,EAAGC,EAAYA,EAAaH,CAAU,EACrDE,EAAU,KACR,EACAC,EAAaF,EACbE,EAAaF,EAAYD,CAAA,EAE3BE,EAAU,KACR,EACAC,EAAaF,EAAY,EACzBE,EAAaF,EAAY,EAAID,CAAA,CAGnC,CAAA,CAEJ,CAcA,SAASkD,GACPtD,EACAzD,EACAH,EACa,OACb,KAAM,CACJ,gBAAiBiG,EACjB,mBAAAlG,EACA,0BAAAmC,EACA,qBAAAC,CAAA,EACEjC,GAAiCC,CAAO,EACtC8D,EAAYnE,GAAaC,EAAoBC,CAAY,EAC/D,QAASH,EAAQ,EAAGA,EAAQoG,EAAc,OAAQpG,GAAS,EACzDoG,EAAcpG,CAAK,GAAKoE,EAE1B,MAAMkD,GAAkBC,EAAAjH,EAAQ,YAAR,YAAAiH,EAAmB,OACrCnF,IACHkF,GAAA,YAAAA,EAAiB,SAAU,GAAKzK,GAC7B2K,IACHF,GAAA,YAAAA,EACCA,EAAgB,OACdzK,GACAJ,MACC,IAAM,EACb,MAAO,CACL,WAAY0J,GAAsBpC,EAAMzD,EAAS8F,CAAa,EAC9D,cAAAA,EACA,gBAAAkB,EACA,oBAAAlF,EACA,uBAAAoF,EACA,0BAAAnF,EACA,qBAAAC,EACA,UAAA8B,EACA,mBAAAlE,CAAA,CAEJ,CAEA,SAASuH,GACPpD,EACAqD,EACAC,EACAC,EACAC,EACAzD,EACA,CACA,QAAS0D,EAAa,EAAGA,EAAaH,EAAaG,GAAc,EAAG,CAElE,MAAMlK,EADS8J,EAAcI,CAAU,EACjB1D,EAEtB,QAASpE,EAAQ,EAAGA,EAAQ6H,EAAW7H,GAAS,EAC9CqE,EAAUzG,EAAOoC,CAAK,EAAIqE,EAAUzG,EAAOgK,EAAY5H,CAAK,CAAC,CAEjE,CACF,CAWA,SAAS+H,GAA0BC,EAA4BxF,EAAe,CAC5E,KAAOwF,EAAM,WAAaxF,GAAO,CAC/B,MAAMyF,EAAaD,EAAM,YAAYA,EAAM,SAAS,EAC9CE,EAAWF,EAAM,YAAYA,EAAM,UAAY,CAAC,EACtD,QAASG,EAAaF,EAAYE,EAAaD,EAAUC,GAAc,EAAG,CACxE,MAAMC,EAAQJ,EAAM,OAAOG,CAAU,EAC/BvQ,EAASwQ,EAAQ1I,GACvB,GAAI0I,EAAQzI,GAA+B,CACzC,MAAM0I,EAAWL,EAAM,gBAAgBpQ,CAAM,EAC7C,GAAIyQ,IAAa,GACf,MAAM,IAAI,MAAM,4CAA4C,EAE9D,MAAMC,EAAeN,EAAM,YAAc,EACnCO,EAAaP,EAAM,cAAcM,CAAY,EAC/CD,IAAaC,IACfN,EAAM,cAAcK,CAAQ,EAAIE,EAChCP,EAAM,gBAAgBO,CAAU,EAAIF,GAEtCL,EAAM,gBAAgBpQ,CAAM,EAAI,GAChCoQ,EAAM,YAAcM,CACtB,KAAO,CACL,GAAIN,EAAM,gBAAgBpQ,CAAM,IAAM,GACpC,MAAM,IAAI,MAAM,6CAA6C,EAE/DoQ,EAAM,gBAAgBpQ,CAAM,EAAIoQ,EAAM,YACtCA,EAAM,cAAcA,EAAM,WAAW,EAAIpQ,EACzCoQ,EAAM,aAAe,CACvB,CACF,CACAA,EAAM,WAAa,CACrB,CACF,CAEA,SAASQ,GACPC,EACAC,EACAnE,EACA/B,EACAmG,EAAe,EACf,CACA,IAAI7I,EAAQ6I,EACR3B,EAAcyB,EAAMjG,CAAK,EAC7B,KAAOwE,IAAgB,IACrBzC,EAAczE,CAAK,EAAIkH,EACvBlH,GAAS,EACTkH,EAAc0B,EAAY1B,CAAW,EAEvC,OAAAyB,EAAMjG,CAAK,EAAI,GACR1C,CACT,CAEA,SAAS8I,GACPH,EACAC,EACAlG,EACAwE,EACA,CACIxE,EAAQ,GAAKA,GAASiG,EAAM,SAChCC,EAAY1B,CAAW,EAAIyB,EAAMjG,CAAK,EACtCiG,EAAMjG,CAAK,EAAIwE,EACjB,CAEA,SAAS6B,GACPC,EACAzE,EACAC,EACAyE,EACApH,EACAyC,EACAD,EACA,CACA,QAASO,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM/G,EAAS2G,EAAaI,EAAYN,EAClC4E,EAAQD,EAAYrE,EAAYN,EACtC,OAAQ0E,EAAA,CACN,KAAKjN,EAAO,OACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,CAACc,EAAU2E,EAAQzF,CAAI,EAEpD,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,IAAIc,EAAU2E,EAAQzF,CAAI,CAAC,EAE7D,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,IAAIc,EAAU2E,EAAQzF,CAAI,CAAC,EAE7D,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,IAAIc,EAAU2E,EAAQzF,CAAI,CAAC,EAE7D,MACF,KAAK1H,EAAO,MACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,MAAMc,EAAU2E,EAAQzF,CAAI,CAAC,EAE/D,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,KAAKc,EAAU2E,EAAQzF,CAAI,CAAC,EAE9D,MACF,KAAK1H,EAAO,MACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAIM,GAAkBQ,EAAU2E,EAAQzF,CAAI,CAAC,EAEtE,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,IAAIc,EAAU2E,EAAQzF,CAAI,CAAC,EAE7D,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,IAAIc,EAAU2E,EAAQzF,CAAI,CAAC,EAE7D,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,KAAKc,EAAU2E,EAAQzF,CAAI,CAAC,EAE9D,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,IAAIc,EAAU2E,EAAQzF,CAAI,CAAC,EAE7D,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,KAAKc,EAAU2E,EAAQzF,CAAI,CAAC,EAE9D,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,KAAKc,EAAU2E,EAAQzF,CAAI,CAAC,EAE9D,KAAA,CAEN,CACF,CAEA,SAAS0F,GACPH,EACAzE,EACAC,EACAxN,EACAC,EACA4K,EACAuH,EACA9E,EACAD,EACA,CACA,QAASO,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM/G,EAAS2G,EAAaI,EAAYN,EAClCV,EAAO5M,EAAO4N,EAAYN,EAC1BT,EAAQ5M,GAAQmS,IAAc,EAAI,EAAIxE,EAAYN,GACxD,OAAQ0E,EAAA,CACN,KAAKjN,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EACrBc,EAAUX,EAAOH,CAAI,EAAIc,EAAUV,EAAQJ,CAAI,EAEnD,MACF,KAAK1H,EAAO,SACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EACrBc,EAAUX,EAAOH,CAAI,EAAIc,EAAUV,EAAQJ,CAAI,EAEnD,MACF,KAAK1H,EAAO,SACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EACrBc,EAAUX,EAAOH,CAAI,EAAIc,EAAUV,EAAQJ,CAAI,EAEnD,MACF,KAAK1H,EAAO,OACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EACrBc,EAAUX,EAAOH,CAAI,EAAIc,EAAUV,EAAQJ,CAAI,EAEnD,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EACrBc,EAAUX,EAAOH,CAAI,GAAKc,EAAUV,EAAQJ,CAAI,EAEpD,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAIE,GACzBY,EAAUX,EAAOH,CAAI,EACrBc,EAAUV,EAAQJ,CAAI,CAAA,EAG1B,MACF,KAAK1H,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAIK,GACzBS,EAAUX,EAAOH,CAAI,EACrBc,EAAUV,EAAQJ,CAAI,CAAA,EAG1B,MACF,KAAK1H,EAAO,MACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,MAC9Bc,EAAUX,EAAOH,CAAI,EACrBc,EAAUV,EAAQJ,CAAI,CAAA,EAG1B,KAAA,CAEN,CACF,CAEA,SAAS4F,GACPpF,EACAzD,EACA8I,EACArC,EACA1C,EACA+B,EACAiD,EACAC,EACApF,EACAC,EACAC,EACAG,EACA,CACA,KAAM,CAAE,WAAAgF,EAAY,aAAA1J,CAAA,EAAiBS,EACrC,QACMkJ,EAAmBH,EACvBG,EAAmBF,EACnBE,GAAoB,EACpB,CACA,MAAM7I,EACJ6I,EAAmBnN,EACfyM,EACJjJ,EAAac,EAAoB3E,EAAoC,EACvE,GAAI8M,IAAWjN,EAAO,SAAU,SAChC,MAAM8F,EACJ9B,EAAac,EAAoB1E,CAAmC,EAChEwN,EACJ5J,EAAac,EAAoBzE,EAAuC,EACpEoI,EAAa8B,EAAcoD,CAAgB,EAC3CE,EACJ/I,EAAoBxE,GAChBwN,EAAe9J,EAAa6J,CAAc,EAC1CE,EAAe/J,EAAa6J,EAAiB,CAAC,EAC9CG,EAAehK,EAAa6J,EAAiB,CAAC,EAC9CI,EAAejK,EAAa6J,EAAiB,CAAC,EAC9C5S,EACJ6S,IAAiBrN,EACb,EACA8J,EAAcuD,CAAY,EAC1B5S,EACJ6S,IAAiBtN,EACb,EACA8J,EAAcwD,CAAY,EAC1BvS,EACJwS,IAAiBvN,EACb,EACA8J,EAAcyD,CAAY,EAC1BE,EACJD,IAAiBxN,EACb,EACA8J,EAAc0D,CAAY,EAC1BE,EACJL,IAAiBrN,EACb,EACAyD,GAAiBF,EAAc8J,CAAY,EAC3CT,EACJU,IAAiBtN,EACb,EACAyD,GAAiBF,EAAc+J,CAAY,EAC3CK,EACJJ,IAAiBvN,EACb,EACAyD,GAAiBF,EAAcgK,CAAY,EAEjD,OAAQf,EAAA,CACN,KAAKjN,EAAO,WACVgL,GACE4C,EACAvF,EACAC,EACAC,EACAL,EACAgD,EACA1C,EACAC,EACAC,CAAA,EAEF,MACF,KAAK1I,EAAO,eACVmI,GACEoF,EACAG,EAAWE,CAAS,EACpBvF,EACAC,EACAC,EACAC,EACAC,EACAC,CAAA,EAEF,MACF,KAAK1I,EAAO,OACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,MACZ,KAAKA,EAAO,KACZ,KAAKA,EAAO,MACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,KACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,KACZ,KAAKA,EAAO,KACVgN,GACEC,EACAzE,EACAC,EACAxN,EACA6K,EACAyC,EACAD,CAAA,EAEF,MACF,KAAKtI,EAAO,KACV,QAAS6I,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM/G,EAAS2G,EAAaI,EAAYN,EAClC4E,EAAQlS,EAAO4N,EAAYN,EACjC,QAASb,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAI,KAAK,KAAKc,EAAU2E,EAAQzF,CAAI,CAAC,CAEhE,CACA,MACF,KAAK1H,EAAO,UACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,IAAI1E,EAAgB,EACpB,QAAS6F,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM3K,EAAQsK,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,EAC3D1E,GAAiB9E,EAAQA,CAC3B,CACA,MAAM5B,EAAS,KAAK,KAAK0G,CAAa,EACtC,QAAS6F,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAMsE,EAAQ3E,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,EAC3Dc,EAAUC,EAAaI,EAAYN,EAAYb,CAAI,EACjDpL,IAAW,GAAK,CAAC,OAAO,SAASA,CAAM,EAAI6Q,EAAQA,EAAQ7Q,CAC/D,CACF,CACA,MACF,KAAK0D,EAAO,OACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,IAAI1E,EAAgB,EACpB,QAAS6F,EAAY,EAAGA,EAAYsF,EAAWtF,GAAa,EAAG,CAC7D,MAAM3K,EAAQsK,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,EAC3D1E,GAAiB9E,EAAQA,CAC3B,CACAsK,EAAUC,EAAaf,CAAI,EAAI,KAAK,KAAK1E,CAAa,CACxD,CACA,MACF,KAAKhD,EAAO,SACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,IAAI2G,EAAS,GACb,QAASxF,EAAY,EAAGA,EAAYsF,EAAWtF,GAAa,EAC1DwF,MAAW,OAAO,SAChB7F,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,CAAA,GAGjDc,EAAUC,EAAaf,CAAI,EAAI2G,EAAS,EAAI,CAC9C,CACA,MACF,KAAKrO,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EAAIc,EAAUvN,EAAOyM,CAAI,IAAM,EAAI,EAAI,EAEpE,MACF,KAAK1H,EAAO,IACZ,KAAKA,EAAO,SACZ,KAAKA,EAAO,SACZ,KAAKA,EAAO,OACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,IACZ,KAAKA,EAAO,MACVoN,GACEH,EACAzE,EACAC,EACAxN,EACAC,EACA4K,EACAuH,EACA9E,EACAD,CAAA,EAEF,MACF,KAAKtI,EAAO,IACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,IAAI4G,EAAM,EACV,QAASzF,EAAY,EAAGA,EAAYsF,EAAWtF,GAAa,EAC1DyF,GACE9F,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,EAC7Cc,EAAUtN,EAAO2N,EAAYN,EAAYb,CAAI,EAEjDc,EAAUC,EAAaf,CAAI,EAAI4G,CACjC,CACA,MACF,KAAKtO,EAAO,MACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EACzBc,EAAUvN,EAAOsN,EAAYb,CAAI,EAC/Bc,EAAUtN,EAAOqN,EAAY,EAAIb,CAAI,EACvCc,EAAUvN,EAAOsN,EAAY,EAAIb,CAAI,EACnCc,EAAUtN,EAAOqN,EAAYb,CAAI,EACrCc,EAAUC,EAAaF,EAAYb,CAAI,EACrCc,EAAUvN,EAAOsN,EAAY,EAAIb,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAC9Dc,EAAUvN,EAAOyM,CAAI,EAAIc,EAAUtN,EAAOqN,EAAY,EAAIb,CAAI,EAChEc,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EACzCc,EAAUvN,EAAOyM,CAAI,EAAIc,EAAUtN,EAAOqN,EAAYb,CAAI,EAC1Dc,EAAUvN,EAAOsN,EAAYb,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAE9D,MACF,KAAK1H,EAAO,MACZ,KAAKA,EAAO,SACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,IAAI6G,EAAQ,GACZ,QAAS1F,EAAY,EAAGA,EAAYsF,EAAWtF,GAAa,EAC1D0F,MACE/F,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,IAC7Cc,EAAUtN,EAAO2N,EAAYN,EAAYb,CAAI,GAEjDc,EAAUC,EAAaf,CAAI,GACzBuF,IAAWjN,EAAO,MACduO,EACA,CAACA,GAEH,EACA,CACN,CACA,MACF,KAAKvO,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EACzBc,EAAUvN,EAAOyM,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAAI,EAAI,EAE1D,MACF,KAAK1H,EAAO,UACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EACzBc,EAAUvN,EAAOyM,CAAI,GAAKc,EAAUtN,EAAOwM,CAAI,EAAI,EAAI,EAE3D,MACF,KAAK1H,EAAO,QACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EACzBc,EAAUvN,EAAOyM,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAAI,EAAI,EAE1D,MACF,KAAK1H,EAAO,aACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EACzBc,EAAUvN,EAAOyM,CAAI,GAAKc,EAAUtN,EAAOwM,CAAI,EAAI,EAAI,EAE3D,MACF,KAAK1H,EAAO,IACZ,KAAKA,EAAO,GACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,MAAM8G,EACJvB,IAAWjN,EAAO,IACdwI,EAAUvN,EAAOyM,CAAI,IAAM,GAAKc,EAAUtN,EAAOwM,CAAI,IAAM,EAC3Dc,EAAUvN,EAAOyM,CAAI,IAAM,GAAKc,EAAUtN,EAAOwM,CAAI,IAAM,EACjEc,EAAUC,EAAaf,CAAI,EAAI8G,EAAS,EAAI,CAC9C,CACA,MACF,KAAKxO,EAAO,mBACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,MAAM+G,EAAQjG,EAAUvN,EAAOyM,CAAI,EAC7BgH,EAAQlG,EAAUvN,EAAOsN,EAAYb,CAAI,EACzCiH,EAAQnG,EAAUvN,EAAOsN,EAAY,EAAIb,CAAI,EAC7CkH,EAAQpG,EAAUvN,EAAOsN,EAAY,EAAIb,CAAI,EAC7CmH,EAASrG,EAAUtN,EAAOwM,CAAI,EAC9BoH,EAAStG,EAAUtN,EAAOqN,EAAYb,CAAI,EAC1CqH,EAASvG,EAAUtN,EAAOqN,EAAY,EAAIb,CAAI,EAC9CsH,EAASxG,EAAUtN,EAAOqN,EAAY,EAAIb,CAAI,EACpDc,EAAUC,EAAaf,CAAI,EACzBkH,EAAQC,EAASJ,EAAQO,EAASN,EAAQK,EAASJ,EAAQG,EAC7DtG,EAAUC,EAAaF,EAAYb,CAAI,EACrCkH,EAAQE,EAASL,EAAQM,EAASL,EAAQM,EAASL,EAAQE,EAC7DrG,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EACzCkH,EAAQG,EAASN,EAAQK,EAASJ,EAAQG,EAASF,EAAQK,EAC7DxG,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EACzCkH,EAAQI,EAASP,EAAQI,EAASH,EAAQI,EAASH,EAAQI,CAC/D,CACA,MACF,KAAK/O,EAAO,aACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,MAAMuH,EAAczG,EAAUvN,EAAOyM,CAAI,EACnCwH,EAAc1G,EAAUvN,EAAOsN,EAAYb,CAAI,EAC/CyH,EAAc3G,EAAUvN,EAAOsN,EAAY,EAAIb,CAAI,EACnD0H,EAAc5G,EAAUvN,EAAOsN,EAAY,EAAIb,CAAI,EACnD2H,EAAU7G,EAAUtN,EAAOwM,CAAI,EAC/B4H,EAAU9G,EAAUtN,EAAOqN,EAAYb,CAAI,EAC3C6H,EAAU/G,EAAUtN,EAAOqN,EAAY,EAAIb,CAAI,EAC/C8H,EAAS,GAAKN,EAAcK,EAAUJ,EAAcG,GACpDG,EAAS,GAAKN,EAAcE,EAAUJ,EAAcM,GACpDG,EAAS,GAAKT,EAAcK,EAAUJ,EAAcG,GAC1D7G,EAAUC,EAAaf,CAAI,EACzB2H,EACAD,EAAcI,EACdN,EAAcQ,EACdP,EAAcM,EAChBjH,EAAUC,EAAaF,EAAYb,CAAI,EACrC4H,EACAF,EAAcK,EACdN,EAAcK,EACdP,EAAcS,EAChBlH,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EACzC6H,EACAH,EAAcM,EACdT,EAAcQ,EACdP,EAAcM,CAClB,CACA,MACF,KAAKxP,EAAO,OACV,QAAS6I,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM/G,EAAS2G,EAAaI,EAAYN,EAClCoH,EAAWzU,EAAO2N,EAAYN,EAC9BqH,EAAYpU,EAAOqN,EAAYN,EACrC,QAASb,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EACrBc,EAAUvN,EAAOyM,CAAI,IAAM,EACvBc,EAAUmH,EAAWjI,CAAI,EACzBc,EAAUoH,EAAYlI,CAAI,CAEpC,CACA,MACF,KAAK1H,EAAO,MACV,QAAS6I,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM/G,EAAS2G,EAAaI,EAAYN,EAClCrK,EAAQjD,EAAO4N,EAAYN,EAC3BlH,EAAMnG,GAAQmS,IAAc,EAAI,EAAIxE,EAAYN,GAChDjH,EAAM9F,GAAQ4S,IAAc,EAAI,EAAIvF,EAAYN,GACtD,QAASb,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAU1G,EAAS4F,CAAI,EAAIE,GACzBG,GAAQS,EAAUtK,EAAQwJ,CAAI,EAAGc,EAAUnH,EAAMqG,CAAI,CAAC,EACtDc,EAAUlH,EAAMoG,CAAI,CAAA,CAG1B,CACA,MACF,KAAK1H,EAAO,IACV,QAAS6I,EAAY,EAAGA,EAAY/C,EAAO+C,GAAa,EAAG,CACzD,MAAM/G,EAAS2G,EAAaI,EAAYN,EAClCV,EAAO5M,EAAO4N,EAAYN,EAC1BT,EAAQ5M,GAAQmS,IAAc,EAAI,EAAIxE,EAAYN,GAClDsH,EAASrU,GAAQ4S,IAAc,EAAI,EAAIvF,EAAYN,GACzD,QAASb,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,MAAMoI,EAAYtH,EAAUX,EAAOH,CAAI,EACvCc,EAAU1G,EAAS4F,CAAI,EACrBoI,GACCtH,EAAUV,EAAQJ,CAAI,EAAIoI,GAAatH,EAAUqH,EAASnI,CAAI,CACnE,CACF,CACA,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EAAIc,EAAUvN,EAAOyM,CAAI,EACpDc,EAAUC,EAAaF,EAAYb,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAElE,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EAAIc,EAAUvN,EAAOyM,CAAI,EACpDc,EAAUC,EAAaF,EAAYb,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAChEc,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EAAIc,EAAUhN,EAAOkM,CAAI,EAEtE,MACF,KAAK1H,EAAO,KACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EAAIc,EAAUvN,EAAOyM,CAAI,EACpDc,EAAUC,EAAaF,EAAYb,CAAI,EAAIc,EAAUtN,EAAOwM,CAAI,EAChEc,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EAAIc,EAAUhN,EAAOkM,CAAI,EACpEc,EAAUC,EAAaF,EAAY,EAAIb,CAAI,EAAIc,EAAU0F,EAAOxG,CAAI,EAEtE,MACF,KAAK1H,EAAO,UACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAC5Cc,EAAUC,EAAaf,CAAI,EACzBc,EAAUvN,EAAO2S,EAAYrF,EAAYb,CAAI,EAEjD,MACF,KAAK1H,EAAO,kBACV,QAAS0H,EAAO,EAAGA,EAAOY,EAAYZ,GAAQ,EAAG,CAC/C,IAAIqI,EAAU,EACVC,EAAexH,EAAUvN,EAAOyM,CAAI,EACxC,QAASmB,EAAY,EAAGA,EAAYsF,EAAWtF,GAAa,EAAG,CAC7D,MAAM3K,EAAQsK,EAAUvN,EAAO4N,EAAYN,EAAYb,CAAI,EACvDxJ,EAAQ8R,IACVD,EAAUlH,EACVmH,EAAe9R,EAEnB,CACAsK,EAAUC,EAAaf,CAAI,EAAIqI,CACjC,CACA,MACF,QACE,MAAM,IAAI,MAAM,8BAA8B9C,CAAM,EAAE,CAAA,CAE5D,CACF,CAEA,SAASgD,GACP/H,EACAzD,EACAyL,EACA3C,EACArC,EACA1C,EACAlE,EACA,CACA,KAAM,CAAE,UAAA6L,EAAW,aAAAnM,CAAA,EAAiBS,EAC9B,CACJ,cAAA8F,EACA,gBAAiB6F,EACjB,oBAAA7J,EACA,uBAAAoF,EACA,0BAAAnF,EACA,qBAAAC,EACA,UAAA8B,EACA,WAAA8H,CAAA,EACEH,EACEtL,EAAmBb,GAAoBC,CAAY,EAEnDsM,EAAOF,EACT,CACE,OAAQA,EACR,cAAe,IAAI,YAAY7H,CAAS,EACxC,YAAa,IAAI,YAAYA,CAAS,EACtC,YAAa,IAAI,WAAWA,CAAS,EAAE,KAAK,EAAE,EAC9C,MAAO,IAAI,WAAWhC,EAAsB,CAAC,EAAE,KAAK,EAAE,CAAA,EAExD,OACE4F,EACJ1F,EAAqB,SAAW,EAC5B,OACA,CACE,YAAaD,EACb,OAAQC,EACR,UAAW,EACX,cAAe,IAAI,YAAY+B,EAAU,OAASD,CAAS,EAC3D,gBAAiB,IAAI,WAAWC,EAAU,OAASD,CAAS,EAAE,KAC5D,EAAA,EAEF,YAAa,CAAA,EAEfgI,EAAkBF,EAAW,cAC/B,IAAI,YAAY9H,CAAS,EACzB,OAEJ,QAASnD,EAAc,EAAGA,EAAcR,EAAkBQ,GAAe,EAAG,CAC1E,MAAMN,EACJM,EAAc5E,EAChB,GACEwD,EAAac,EAAoB3E,EAAoC,IACrEH,EAAO,SAEP,SAEF,MAAMyI,EAAa8B,EAAcnF,CAAW,EACtCU,EACJ9B,EAAac,EAAoB1E,CAAmC,EAChEwN,EACJ5J,EAAac,EAAoBzE,EAAuC,EAC1E,QAASqH,EAAO,EAAGA,EAAO5B,EAAO4B,GAAQ,EACvCc,EAAU,KACR2H,EAAUvC,EAAYlG,CAAI,EAC1Be,EAAaf,EAAOa,EACpBE,GAAcf,EAAO,GAAKa,CAAA,CAGhC,CAEA,QAASF,EAAa,EAAGA,EAAa/D,EAAc+D,GAAcE,EAAW,CAC3E,IAAID,EAAa,KAAK,IAAIC,EAAWjE,EAAe+D,CAAU,EAC1DK,EACAyD,IACFA,EAAM,UAAY,EAClBA,EAAM,YAAc,GAGtB,QACMqE,EAAa,EACjBA,GAAcjK,EACdiK,GAAc,EACd,CACA,MAAMC,EAAmBD,EAAajK,EACtC,GAAI+J,GAAQA,EAAK,MAAME,CAAU,IAAM,GAAI,CACzC,GAAI9H,IAAkB4H,EAAK,cACzB,GAAI5H,EACF4H,EAAK,cAAc,IAAI5H,EAAc,SAAS,EAAGJ,CAAU,EAAG,CAAC,MAE/D,SAASnE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAC/CmM,EAAK,cAAcnM,CAAK,EAAIA,EAIlCmE,EAAaqE,GACX2D,EAAK,MACLA,EAAK,YACLA,EAAK,cACLE,EACAlI,CAAA,EAEFI,EAAgB4H,EAAK,aACvB,CAEA,MAAMpL,EAAcsL,EAAaxP,GAC3BwM,EACJ8C,GAAQG,EACJH,EAAK,OAAOpL,EAAcvE,EAAkC,EAC5DgL,EACA8B,EACJ6C,GAAQG,EACJH,EAAK,OACHpL,EAActE,EAChB,EAAI,EACJgE,EAkBN,GAhBI0D,IAAe,GACjBgF,GACEpF,EACAzD,EACA8I,EACArC,EACA1C,EACA+B,EACAiD,EACAC,EACApF,EACAC,EACAC,EACAG,CAAA,EAGA4H,GAAQG,GAAoBnI,IAAe,EAAG,CAChD,MAAMoI,EACJJ,EAAK,OAAOpL,EAAcrE,EAAqC,EAC3D8P,EAAgBpG,EAAcmG,CAAiB,EAC/CE,EAAYJ,EAAa,EACzBK,EAAuBnI,EACvBoI,EAAgBxI,EACtB,IAAIyI,EAAiB,EACrB,MAAMC,EACJV,EAAK,OAAOpL,EAAcpE,EAAoC,EAC1DmQ,EACJX,EAAK,OAAOpL,EAAcnE,EAAqC,EAC3DmQ,EAAeF,IAAWJ,EAC1BO,EAAgBF,IAAYL,EAC5BQ,EAAed,EAAK,MAAM,OAChC,GACGY,GAAgBD,IAAYG,GAC5BD,GAAiBH,IAAWI,EAE7B,QAASjN,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAElD,GADeqE,EAAUmI,EAAgBxM,CAAK,IAAM,IACrC+M,EAAc,SAC7B,MAAM/F,EAAc0F,GAAA,YAAAA,EAAuB1M,GAC3CmM,EAAK,YAAYS,CAAc,EAAI5M,EAC/BgH,IAAgB,SAClBmF,EAAK,cAAcS,CAAc,EAAI5F,GAEvC4F,GAAkB,CACpB,KAEA,SAAS5M,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAAG,CAClD,MAAMgH,GAAc0F,GAAA,YAAAA,EAAuB1M,KAAUA,EAC/CkN,EACJ7I,EAAUmI,EAAgBxM,CAAK,IAAM,EAAI6M,EAASC,EAChDI,IAAWT,GACbN,EAAK,YAAYS,CAAc,EAAI5M,EAC/B0M,IACFP,EAAK,cAAcS,CAAc,EAAI5F,GAEvC4F,GAAkB,GAElBhE,GACEuD,EAAK,MACLA,EAAK,YACLe,EACAlG,CAAA,CAGN,CAEE4F,IAAmB,GAAKA,IAAmBD,GACzC3E,IACFD,GAA0BC,EAAOqE,CAAU,EAC3C5E,GACEpD,EACA2D,EAAM,cACNA,EAAM,YACNmE,EAAK,YACLS,EACAxI,CAAA,IAKJwI,IAAmBD,GACnBD,IAAyBP,EAAK,eAI9B5H,EACEqI,IAAmB,EACf,OACAF,EACEP,EAAK,cACLA,EAAK,aAEfhI,EAAayI,CACf,CACF,CACA,GAAIR,GAAmBjI,IAAe,EAAG,CACvC,GAAII,EACF,QAASvE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAC/CoM,EAAgBpM,CAAK,GAAKkE,EAAaK,EAAcvE,CAAK,GAAK,MAE5D,CACL,IAAIiH,EAAW/C,EAAa,EAC5B,QAASlE,EAAQ,EAAGA,EAAQmE,EAAYnE,GAAS,EAC/CoM,EAAgBpM,CAAK,EAAIiH,EACzBA,GAAY,CAEhB,CACAkG,GACEpJ,EACAgD,EACA1C,EACA6H,EACAE,EACAhI,EACAD,CAAA,CAEJ,CACA,GAAI6D,EACF,QAAShI,EAAQ,EAAGA,EAAQgI,EAAM,YAAahI,GAAS,EACtDgI,EAAM,gBAAgBA,EAAM,cAAchI,CAAK,CAAC,EAAI,EAG1D,CACF,CAEA,SAASmN,GACPpJ,EACAgD,EACA1C,EACA0H,EACAK,EACAhI,EACAD,EACA,CACA,KAAM,CAAE,YAAAkC,GAAgB0F,EAClBqB,EAAe/G,EAAYV,EAAe,EAChD,GAAIyH,IAAiBlH,EACnB,QAASmH,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EACrCC,EAAeF,EAAeC,EACpCtG,EAAYE,CAAQ,EAAI5C,EAAUiJ,CAAY,EAC9CvG,EAAYE,EAAW,CAAC,EAAI5C,EAAUiJ,EAAelJ,CAAS,EAC9D2C,EAAYE,EAAW,CAAC,EAAI5C,EAAUiJ,EAAelJ,EAAY,CAAC,CACpE,CAGF,MAAMmJ,EAAYlH,EAAYT,EAAY,EAC1C,GAAI2H,IAAcrH,EAChB,QAASmH,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EACrCC,EAAeC,EAAYF,EAC3BG,EAAQzJ,EAAK,OAAOkD,EAAW,CAAC,EAAI,MAC1ClD,EAAK,OAAOkD,EAAW,CAAC,GACrBuG,EAAS7R,EAAO,KAAK,IAAI0I,EAAUiJ,CAAY,CAAC,CAAC,GAAK,MAAS,EAClEvJ,EAAK,OAAOkD,EAAW,CAAC,GACrBtL,EAAO,KAAK,IAAI0I,EAAUiJ,EAAelJ,CAAS,CAAC,CAAC,EAClDzI,EAAO,KAAK,IAAI0I,EAAUiJ,EAAelJ,EAAY,CAAC,CAAC,CAAC,GAAK,MAChE,CACJ,CAGF,MAAMqJ,EAAiBpH,EAAYR,EAAiB,EACpD,GAAI4H,IAAmBvH,EACrB,QAASmH,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EACrCK,EAAUnP,GACd8F,EACAoJ,EAAiBJ,EACjBjJ,CAAA,EAEEsJ,IAAY,SAAW3J,EAAK,OAAOkD,EAAW,CAAC,EAAIyG,EACzD,CAGF,MAAMC,EAActH,EAAYP,EAAc,EAC9C,GAAI6H,IAAgBzH,EAClB,QAASmH,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EAC3CtJ,EAAK,OAAOkD,EAAW,CAAC,EAAIzJ,GAC1B6G,EAAUsJ,EAAcN,CAAU,CAAA,CAEtC,CAGF,MAAMO,EAAYvH,EAAYN,EAAY,EAC1C,GAAI6H,IAAc1H,EAChB,QAASmH,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMQ,EAAYzB,EAAgBiB,CAAU,EAAI,EAChDtJ,EAAK,OAAO8J,CAAS,GACjB9J,EAAK,OAAO8J,CAAS,EAAI,WACzBlS,EAAOsB,GAAMoH,EAAUuJ,EAAYP,CAAU,EAAG,EAAG,CAAC,CAAC,KACvD,CACJ,CAGF,MAAMS,EAAYzH,EAAYL,EAAY,EAC1C,GAAI8H,IAAc5H,EAChB,QAASmH,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EACrCC,EAAeQ,EAAYT,EACjCtJ,EAAK,OAAOkD,CAAQ,GACjBtL,EAAO0I,EAAUiJ,CAAY,CAAC,EAC5B3R,EAAO0I,EAAUiJ,EAAelJ,CAAS,CAAC,GAAK,MAClD,EACFL,EAAK,OAAOkD,EAAW,CAAC,GACpBlD,EAAK,OAAOkD,EAAW,CAAC,EAAI,WAC5BtL,EAAO0I,EAAUiJ,EAAelJ,EAAY,CAAC,CAAC,KAChD,CACJ,CAGF,QAAS2J,EAAU,EAAGA,EAAUhC,EAAK,eAAe,OAAQgC,GAAW,EAAG,CACxE,MAAMb,EAASnB,EAAK,eAAegC,CAAO,EACpCC,EAAajC,EAAK,cAAcgC,CAAO,EACvCE,EAAiBlC,EAAK,gBAAgBgC,CAAO,EACnD,QAASV,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EAC3CH,EAAOjG,EAAW+G,CAAU,EAAI/I,GAC9BZ,EACA4J,EAAiBZ,EACjBjJ,CAAA,CAEJ,CACF,CAEA,GAAI2H,EAAK,kBACP,QAASsB,EAAa,EAAGA,EAAalJ,EAAYkJ,GAAc,EAAG,CACjE,MAAMpG,EAAWmF,EAAgBiB,CAAU,EACrCa,EACJnK,EAAK,OAAOkD,EAAW,CAAC,IAAM,KAAO,QACpClD,EAAK,OAAOkD,EAAW,CAAC,EAAI,SAAY,OACzClD,EAAK,OAAOkD,EAAW,CAAC,IAAM,KAAO,MACjCkH,GAAclH,IAAa,GAAK,EAClCiH,GACFnK,EAAK,YAAYoK,CAAU,EAAI,OAAO,IACtCpK,EAAK,YAAYoK,EAAa,CAAC,EAAI,OAAO,IAC1CpK,EAAK,YAAYoK,EAAa,CAAC,EAAI,OAAO,MAE1CpK,EAAK,YAAYoK,CAAU,EAAIpH,EAAYE,CAAQ,EACnDlD,EAAK,YAAYoK,EAAa,CAAC,EAAIpH,EAAYE,EAAW,CAAC,EAC3DlD,EAAK,YAAYoK,EAAa,CAAC,EAAIpH,EAAYE,EAAW,CAAC,EAE/D,CAEJ,CAEO,SAASmH,GACdrK,EACAzD,EACA,CACA,IAAIH,EAAe4D,EAAK,UACxB,UAAWE,KAAa3D,EAAQ,WAC9BH,EAAe,KAAK,IAAIA,EAAc8D,EAAU,KAAK,EAEvD,GAAI9D,IAAiB,GAAKG,EAAQ,aAAa,SAAW,EAAG,OAE7D,MAAMyL,EAAO1E,GAAetD,EAAMzD,EAASH,CAAY,EACjDkE,EAAY,IAAI,aAAa0H,EAAK,mBAAqBA,EAAK,SAAS,EACrE3C,EAAgB,IAAI,SACxB9I,EAAQ,cAAc,OACtBA,EAAQ,cAAc,WACtBA,EAAQ,cAAc,UAAA,EAElByG,EAAc,IAAI,aACtBhD,EAAK,OAAO,OACZA,EAAK,OAAO,WACZA,EAAK,OAAO,MAAA,EAGd+H,GACE/H,EACAzD,EACAyL,EACA3C,EACArC,EACA1C,EACAlE,CAAA,CAEJ,CCpsDO,SAASkO,GAAgBC,EAA8B,CAC5D,MAAMC,MAAc,IACdC,MAAW,IAEjB,SAASC,EAAS/Z,EAAc,CAC1B,CAACA,GAAO,OAAOA,GAAQ,UAAY8Z,EAAK,IAAI9Z,CAAG,IACnD8Z,EAAK,IAAI9Z,CAAG,EAERA,aAAe,YACjB6Z,EAAQ,IAAI7Z,CAAG,EACN,YAAY,OAAOA,CAAG,EAC/B6Z,EAAQ,IAAI7Z,EAAI,MAAqB,EAErC,OAAO,OAAOA,CAAG,EAAE,QAAQ+Z,CAAQ,EAEvC,CAEA,OAAAA,EAASH,CAAG,EACL,CAAC,GAAGC,CAAO,CACpB,CCNA,MAAMG,GAAc,CAClB,mBAAAC,GACA,cAAAC,GACA,WAAAC,GACA,UAAAC,EACF,EAGA,IAAIC,GAEJ,SAASC,IAAqB,CAC5B,OAAOD,IAAA,YAAAA,GAAY,OAAO,aAAc,CAC1C,CAEA,SAASJ,GAAmB,CAC1B,yBAAAM,EACA,cAAAC,EACA,yBAAAC,EACA,eAAAC,EACA,aAAAC,EACA,WAAAC,EACA,YAAAC,CACF,EAQG,CACD5Z,GACEsZ,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,CAAA,CAEJ,CAEA,SAASX,GAAc,CACrB,UAAAY,EACA,eAAAC,EACA,UAAAC,EACA,OAAA/Y,EACA,SAAAC,CACF,EAMG,CAYD,MAAO,CAAE,aAXYT,GACnBqZ,EACAC,EAAe,CAAC,EAChBA,EAAe,CAAC,EAChBA,EAAe,CAAC,EAChBC,EAAU,CAAC,EACXA,EAAU,CAAC,EACXA,EAAU,CAAC,EACX/Y,EACAC,CAAA,EAEqB,SAAAA,CAAA,CACzB,CAEA,eAAe+Y,GAAUvH,EAAqB,CAC5C,KAAM,CACJ,GAAAwH,EACA,KAAA1X,EACA,KAAAkB,CAAA,EAEAgP,EAAM,KACR,GAAI,CACF,MAAMyH,EAAUnB,GAAYxW,CAAI,EAIhC,GAAI,CAAC2X,EACH,MAAM,IAAI,MAAM,uBAAuB3X,CAAI,EAAE,EAS/C,MAAMmS,EAAS,MAAMwF,EAAQzW,EAAM,CAAE,WANjB2K,GAAkB,CACpC,KAAK,YACH,CAAE,GAAA6L,EAAI,OAAQ7L,CAAA,EACd,CAAE,SAAUsK,GAAgBtK,CAAI,CAAA,CAAE,CAEtC,EACiD,EACjD,KAAK,YACH,CAAE,GAAA6L,EAAI,OAAAvF,EAAQ,gBAAiB2E,IAAmB,EAClD,CAAE,SAAUX,GAAgBhE,CAAM,CAAA,CAAE,CAExC,OAASyF,EAAO,CACd,QAAQ,KAAK,iBAAiBA,CAAK,EAAE,EACrC,KAAK,YACH,CAAE,GAAAF,EAAI,MAAAE,EAAO,gBAAiBd,IAAmB,EACjD,CAAE,SAAUX,GAAgByB,CAAK,CAAA,CAAE,CAEvC,CACF,CAEA,eAAeC,GAAe,CAC5B,QAAAC,EACA,UAAAC,EACA,IAAAC,EACA,cAAAC,EACA,gBAAAC,EACA,QAAAC,EACA,cAAAC,EACA,WAAAC,CACF,EASG,CACD,GAAIN,EAAW,CACb,MAAMO,EAAaP,EAAU,OAC7B,OAAIO,EAAa,GACfR,EAAQ,wBAAwBQ,CAAU,EAE5CD,EAAW,CAAE,OAAQC,EAAY,MAAOA,EAAY,EACpDR,EAAQ,KAAKC,CAAS,EACfD,EAAQ,OAAA,CACjB,CAEA,MAAMS,EAAsBH,GAAiB,EAC7C,GAAI,CAAC,OAAO,cAAcG,CAAmB,GAAKA,EAAsB,EACtE,MAAM,IAAI,MAAM,6CAA6C,EAE/D,IAAIC,EAAeD,EACfE,EAAsB,EACtBC,EAEJ,GAAIV,EAAK,CACP,MAAMW,EAAU,IAAI,QAAQX,EAAK,CAC/B,QAASC,EAAgB,IAAI,QAAQA,CAAa,EAAI,OACtD,YAAaC,EAAkB,UAAY,aAAA,CAC5C,EAEKU,EAAW,MAAM,MAAMD,CAAO,EACpC,GAAI,CAACC,EAAS,IAAM,CAACA,EAAS,KAC5B,MAAM,IAAI,MACR,oBAAoBZ,CAAG,MAAMY,EAAS,MAAM,IAAIA,EAAS,UAAU,EAAA,EAGvEF,EAAeE,EAAS,KACxB,MAAMC,EAAgB,OAAOD,EAAS,QAAQ,IAAI,gBAAgB,GAAK,GAAG,EACpEE,EACJ,OAAO,cAAcD,CAAa,GAAKA,EAAgB,EACnDA,EACA,EACNL,MAAiBM,GACjB,MAAMC,EAAkBH,EAAS,QAAQ,IAAI,kBAAkB,EAIzDI,EACJ,CAACD,GAAmBA,EAAgB,gBAAkB,WACpDH,EAAS,OAAS,SAAWI,IAC/BP,EAAsBK,EAE1B,SAAW,CAACX,EACV,MAAM,IAAI,MAAM,8BAA8B,EAGhD,MAAMc,EAAeP,GAAA,YAAAA,EAAc,YAC7BQ,EAAiB,SAAY,CACjC,GAAID,EAAc,CAChB,KAAM,CAAE,KAAAE,EAAM,MAAAtX,CAAA,EAAU,MAAMoX,EAAa,KAAA,EAC3C,OAAOE,EAAO,OAAYtX,CAC5B,CAEA,MAAMuX,EAAQ,MAAM,IAAI,QAAqBC,GAAY,CACvDC,GAAkBD,EAClBhB,EAAW,CAAE,UAAW,GAAM,CAChC,CAAC,EACD,OAAOe,EAAM,SAAW,EAAI,OAAYA,CAC1C,EAEA,IAAIG,EAAS,EACb,GAAI,CAKF,IAJId,EAAsB,GACxBX,EAAQ,wBAAwBW,CAAmB,IAGxC,CACX,MAAM5W,EAAQ,MAAMqX,EAAA,EACpB,GAAI,CAACrX,EAAO,MAGZ,GADA0X,GAAU1X,EAAM,OACZ4W,EAAsB,GAAKc,EAASd,EACtC,MAAM,IAAI,MACR,qCAAqCA,CAAmB,QAAA,EAG5DJ,EAAW,CAAE,OAAAkB,EAAQ,MAAOf,CAAA,CAAc,EAC1CV,EAAQ,KAAKjW,CAAK,CACpB,CAEA,GAAI4W,EAAsB,GAAKc,IAAWd,EACxC,MAAM,IAAI,MACR,mCAAmCA,CAAmB,oBAAoBc,CAAM,EAAA,EAIpF,OAAIpB,GAAWK,IAAiB,GAC9BH,EAAW,CAAE,OAAAkB,EAAQ,MAAOA,CAAA,CAAQ,EAG/BzB,EAAQ,OAAA,CACjB,OAASF,EAAO,CACd,GAAI,CACF,MAAMqB,GAAA,YAAAA,EAAc,OAAOrB,GAC7B,MAAQ,CAER,CACA,MAAMA,CACR,QAAA,CACEqB,GAAA,MAAAA,EAAc,aAChB,CACF,CAEA,SAASO,GAAcC,EAA2C,CAChE,MAAO,CACL,UAAWA,EAAQ,UACnB,YAAa,CAACA,EAAQ,OAAQA,EAAQ,MAAM,EAC5C,YAAaA,EAAQ,YACrB,MAAO,CACL,IAAKA,EAAQ,IACb,IAAKA,EAAQ,IACb,KAAMA,EAAQ,KACd,KAAMA,EAAQ,IAAA,CAChB,CAEJ,CAEA,eAAe9C,GACb,CACE,IAAAqB,EACA,cAAAC,EACA,gBAAAC,EACA,UAAAH,EACA,SAAA2B,EACA,SAAAC,EACA,QAAAxB,EACA,cAAAC,EACA,WAAAwB,CACF,EAWA,CAAE,WAAAvB,GACF,CACA,MAAMP,EAAU/a,GAAiB2c,EAAUC,GAAY3B,CAAG,EACpDyB,EAAW,MAAM5B,GAAe,CACpC,QAAAC,EACA,UAAAC,EACA,IAAAC,EACA,cAAAC,EACA,gBAAAC,EACA,QAAAC,EACA,cAAAC,EACA,WAAAC,CAAA,CACD,EACD,OAAIuB,GAAY1D,GAAqBuD,EAASG,CAAU,EACjDJ,GAAcC,CAAO,CAC9B,CAEA,IAAIH,GAAmBO,GAAuB,CAAC,EAE/C,eAAejD,GAAU,CAAE,MAAAwC,GAAgC,CACzDE,GAAgBF,CAAK,CACvB,CAEA,eAAeU,IAAa,CAC1B,IAAIC,EACJ,MAAMC,EAAgB,IAAI,QAA6BX,GAAY,CACjEU,EAAuBV,CACzB,CAAC,EAEKY,EAA0B,CAAA,EAC1BC,EAAiBhK,GAAwB,CAC7C,GAAIA,EAAM,KAAK,OAAS,YAAa,CACnC6J,EAAqB7J,EAAM,KAAK,MAA4B,EAC5D,MACF,CACA+J,EAAQ,KAAK/J,CAAK,CACpB,EACA,KAAK,iBAAiB,UAAWgK,CAAa,EAG9CrD,IADa,MAAMsD,GAAU,CAAE,eAAgB,MAAMH,EAAe,GAClD,OAElB,KAAK,oBAAoB,UAAWE,CAAa,EACjD,KAAK,iBAAiB,UAAWzC,EAAS,EAE1C,UAAWvH,KAAS+J,EAClBxC,GAAUvH,CAAK,EAEjB+J,EAAQ,OAAS,CACnB,CAEAH,KAAa,MAAM,QAAQ,KAAK"}