@woosh/meep-engine 3.14.3 → 3.14.4

package/src/shade/playground/skinned_mesh_soup/verify_clone_vertices.js

@@ -0,0 +1,409 @@
+/**
+ * Read a clone's deformed vertex region back and hold it against an answer the CPU knows.
+ *
+ * The page can be looked at, and soup is not subtle. What looking at it cannot say is *which*
+ * vertices went wrong and in what pattern, and that is the whole difference between "skinning is
+ * broken" and a bug you can name: every vertex past the 64th of its meshlet is the workgroup stride
+ * loop, every vertex of some meshlets and none of others is the per-meshlet addressing, a scatter
+ * with no pattern is the joint palette.
+ *
+ * This runs in the **bind pose** — `?skin=bind`, no clip registered — because that is the one pose
+ * whose answer needs no GPU. At bind, `joint.global × inverse_bind` is the identity for every joint
+ * (verified on the CPU for Michelle: every one of her 19 106 vertices lands back on its rest
+ * position to the bit), so the blend collapses whatever the weights are and the shader's output is
+ * just its input under the mesh-local fold:
+ *
+ * ```
+ * clone_position = inverse(mesh.transform_global) × source_position
+ * ```
+ *
+ * — the leftmost factor of the glTF skinning formula, which `chunk_skin_blend_mesh_local` folds
+ * into each joint matrix so the rasterizer can re-apply `mesh.global` afterwards. Nothing about
+ * that expression involves the pose, so a disagreement here is the skinning *machinery* — the
+ * addressing, the layout, the matrix range — and not the animation.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+import { assert } from "../../../core/assert.js";
+import {
+    MESHLET_METADATA_STRUCT
+} from "../../renderer/geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import {
+    GEOMETRY_METADATA_STRUCT
+} from "../../renderer/geometry/GEOMETRY_METADATA_STRUCT.js";
+
+/**
+ * Copy a slice of a GPU buffer back to the CPU.
+ *
+ * @param {GPUDevice} device
+ * @param {GPUBuffer} buffer
+ * @param {number} offset in bytes, a multiple of 4
+ * @param {number} size in bytes, a multiple of 4
+ * @returns {Promise<ArrayBuffer>}
+ */
+async function read_back(device, buffer, offset, size) {
+    const staging = device.createBuffer({
+        label: 'soup/readback',
+        size,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+    });
+
+    const encoder = device.createCommandEncoder({ label: 'soup/readback' });
+
+    encoder.copyBufferToBuffer(buffer, offset, staging, 0, size);
+
+    device.queue.submit([encoder.finish()]);
+
+    await staging.mapAsync(GPUMapMode.READ);
+
+    const copy = staging.getMappedRange().slice(0);
+
+    staging.unmap();
+    staging.destroy();
+
+    return copy;
+}
+
+/**
+ * Transform a point by a column-major 4×4.
+ *
+ * @param {ArrayLike<number>} m
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number[]}
+ */
+function transform_point(m, x, y, z) {
+    return [
+        m[0] * x + m[4] * y + m[8] * z + m[12],
+        m[1] * x + m[5] * y + m[9] * z + m[13],
+        m[2] * x + m[6] * y + m[10] * z + m[14],
+    ];
+}
+
+/**
+ * Invert a column-major 4×4 that is an affine transform — which every node transform in this engine
+ * is. General enough for a `T · R · S` with non-uniform scale, and not for a projection.
+ *
+ * @param {ArrayLike<number>} m
+ * @returns {Float64Array}
+ */
+function affine_inverse(m) {
+    const a = m[0], b = m[4], c = m[8];
+    const d = m[1], e = m[5], f = m[9];
+    const g = m[2], h = m[6], i = m[10];
+
+    const det = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
+
+    assert.notEqual(det, 0, 'transform is singular');
+
+    const s = 1 / det;
+
+    const r = new Float64Array(16);
+
+    r[0] = (e * i - f * h) * s;
+    r[1] = (f * g - d * i) * s;
+    r[2] = (d * h - e * g) * s;
+
+    r[4] = (c * h - b * i) * s;
+    r[5] = (a * i - c * g) * s;
+    r[6] = (b * g - a * h) * s;
+
+    r[8] = (b * f - c * e) * s;
+    r[9] = (c * d - a * f) * s;
+    r[10] = (a * e - b * d) * s;
+
+    const tx = m[12], ty = m[13], tz = m[14];
+
+    r[12] = -(r[0] * tx + r[4] * ty + r[8] * tz);
+    r[13] = -(r[1] * tx + r[5] * ty + r[9] * tz);
+    r[14] = -(r[2] * tx + r[6] * ty + r[10] * tz);
+
+    r[15] = 1;
+
+    return r;
+}
+
+/**
+ * Contiguous runs of a sorted list of integers, as `[first, last]` pairs.
+ *
+ * @param {number[]} values
+ * @returns {number[][]}
+ */
+function runs_of(values) {
+    const runs = [];
+
+    for (const value of values) {
+        const last = runs[runs.length - 1];
+
+        if (last !== undefined && last[1] === value - 1) {
+            last[1] = value;
+        } else {
+            runs.push([value, value]);
+        }
+    }
+
+    return runs;
+}
+
+/**
+ * The clone's deformed vertices, against `inverse(mesh.global) × rest`.
+ *
+ * Reads the GPU's own answer to "where does this geometry id's data live" rather than reconstructing
+ * it from the host records: the geometry metadata row, then the clone's meshlet metadata rows, then
+ * the data those rows address. That is the same chain the rasterizer and the intersector walk, so a
+ * clone whose *addressing* is wrong is caught here rather than being read around.
+ *
+ * @param {object} options
+ * @param {Renderer} options.renderer
+ * @param {Scene} options.scene
+ * @param {SkinnedMesh} options.mesh
+ * @param {number} [options.tolerance] in mesh-local units — the space the clone is written in,
+ *        which for a glTF character carrying a centimetre scale is a hundred times its world size
+ * @returns {Promise<object>}
+ */
+export async function verify_clone_vertices({ renderer, scene, mesh, tolerance = 1e-3 }) {
+    assert.defined(mesh, 'mesh');
+    assert.equal(mesh.isSkinnedMesh, true, 'mesh.isSkinnedMesh !== true');
+
+    const graphics = renderer.graphics;
+    const device = graphics.device;
+    const geometries = graphics.geometries;
+
+    const scene_context = renderer.scenes.obtain(scene);
+
+    const geometry_index = scene_context.skinning.obtain_geometry_index(mesh);
+
+    // ---- where the clone's meshlets are, as the GPU has it -------------------------------------
+
+    const geometry_row = new DataView(await read_back(
+        device,
+        geometries.buffer_metadata,
+        geometry_index * GEOMETRY_METADATA_STRUCT.size,
+        GEOMETRY_METADATA_STRUCT.size
+    ));
+
+    const meshlets_address = geometry_row.getUint32(
+        GEOMETRY_METADATA_STRUCT.get('meshlets_address').offset, true
+    );
+    const meshlets_count = geometry_row.getUint32(
+        GEOMETRY_METADATA_STRUCT.get('meshlets_count').offset, true
+    );
+
+    const source_batch = mesh.geometry.meshlets;
+
+    if (meshlets_count !== source_batch.count) {
+        return {
+            geometry_index,
+            verdict: `FAIL — the clone's geometry row claims ${meshlets_count} meshlets, `
+                + `its source has ${source_batch.count}`,
+        };
+    }
+
+    const meshlet_stride = MESHLET_METADATA_STRUCT.aligned_size;
+
+    const clone_metadata = new DataView(await read_back(
+        device,
+        geometries.meshlets.buffer_metadata,
+        meshlets_address * meshlet_stride,
+        meshlets_count * meshlet_stride
+    ));
+
+    const ADDRESS_OFFSET = MESHLET_METADATA_STRUCT.get('address').offset;
+    const VERTEX_COUNT_OFFSET = MESHLET_METADATA_STRUCT.get('vertex_count').offset;
+    const PRIMITIVE_COUNT_OFFSET = MESHLET_METADATA_STRUCT.get('primitive_count').offset;
+
+    // ---- and where the source's are, to say the clone is somewhere else --------------------------
+
+    /*
+     A clone is a fresh vertex region plus a patch pass that adds `clone.data.offset -
+     source.data.offset` to every one of its meshlet records. If that patch does not land, the
+     clone's records still address the *source's* data: the skinning pass then deforms the shared
+     rest-pose vertices in place, every instance of the model deforms on top of every other, and the
+     source no rasterizer ever wanted deformed goes with them. The addresses differing by one
+     constant is the whole contract, and it is checkable before a single vertex is compared.
+    */
+    const source_record = geometries.get_metadata(mesh.geometry);
+
+    const source_metadata = new DataView(await read_back(
+        device,
+        geometries.meshlets.buffer_metadata,
+        source_record.meshlets.metadata.offset * meshlet_stride,
+        meshlets_count * meshlet_stride
+    ));
+
+    // ---- the clone's vertex data, in one read ---------------------------------------------------
+
+    /*
+     Position is the first attribute of the section and is never collapsed to a shared slot (see
+     ENCODED_ORDERED_ATTRIBUTES and MESHLET_ATTRIBUTE_COMPRESSION_FLAGS), so a meshlet's positions
+     start where its attribute section does and the furthest word this needs is the last position
+     word of the furthest meshlet. That is a span, not a set of holes, so it comes back in one copy
+     rather than in `meshlets_count` of them — two hundred round trips through `mapAsync` is a
+     diagnostic nobody runs twice.
+    */
+    const position_word_of = new Uint32Array(meshlets_count);
+
+    let data_low = Infinity;
+    let data_high = 0;
+
+    /** every distinct `clone address − source address`; one entry is the contract */
+    const address_deltas = new Set();
+
+    for (let m = 0; m < meshlets_count; m++) {
+        const row = m * meshlet_stride;
+
+        const address = clone_metadata.getUint32(row + ADDRESS_OFFSET, true);
+        const primitive_count = clone_metadata.getUint32(row + PRIMITIVE_COUNT_OFFSET, true);
+        const vertex_count = clone_metadata.getUint32(row + VERTEX_COUNT_OFFSET, true);
+
+        address_deltas.add(address - source_metadata.getUint32(row + ADDRESS_OFFSET, true));
+
+        const position_word = address + ((primitive_count * 3 + 3) >> 2);
+
+        position_word_of[m] = position_word;
+
+        data_low = Math.min(data_low, position_word);
+        data_high = Math.max(data_high, position_word + vertex_count * 3);
+    }
+
+    if (address_deltas.size !== 1 || address_deltas.has(0)) {
+        return {
+            geometry_index,
+            address_deltas: [...address_deltas].slice(0, 8),
+            verdict: address_deltas.has(0) && address_deltas.size === 1
+                ? `FAIL — every one of the clone's ${meshlets_count} meshlet records addresses the `
+                    + `source's vertex data. The address patch did not run, so the skinning pass is `
+                    + `deforming the shared rest-pose region in place.`
+                : `FAIL — the clone's meshlet records sit at ${address_deltas.size} different `
+                    + `offsets from the source's; a clone is one contiguous region and its patch is `
+                    + `one delta.`,
+        };
+    }
+
+    const data = new Float32Array(await read_back(
+        device,
+        geometries.meshlets.buffer_data,
+        data_low * 4,
+        (data_high - data_low) * 4
+    ));
+
+    // ---- the answer the CPU knows ---------------------------------------------------------------
+
+    const to_mesh_local = affine_inverse(mesh.transform_global.matrix);
+
+    // ---- and the comparison ---------------------------------------------------------------------
+
+    let vertices = 0;
+    let wrong = 0;
+    let worst = 0;
+    let worst_where = null;
+
+    /** meshlets with at least one wrong vertex */
+    const wrong_meshlets = [];
+
+    /** per-vertex-slot tally: how many meshlets got slot `v` wrong */
+    const wrong_by_slot = new Map();
+
+    const examples = [];
+
+    for (let m = 0; m < meshlets_count; m++) {
+        const source_header = source_batch.read_header(m);
+        const source = source_batch.read_meshlet(m);
+
+        const row = m * meshlet_stride;
+
+        const clone_vertex_count = clone_metadata.getUint32(row + VERTEX_COUNT_OFFSET, true);
+        const clone_primitive_count = clone_metadata.getUint32(row + PRIMITIVE_COUNT_OFFSET, true);
+
+        if (clone_vertex_count !== source_header.vertex_count
+            || clone_primitive_count !== source_header.primitive_count) {
+            return {
+                geometry_index,
+                verdict: `FAIL — clone meshlet ${m} says `
+                    + `${clone_vertex_count} vertices / ${clone_primitive_count} triangles, `
+                    + `its source says ${source_header.vertex_count} / ${source_header.primitive_count}. `
+                    + `The metadata copy or its address patch is wrong, before any skinning ran.`,
+            };
+        }
+
+        const positions = data.subarray(
+            position_word_of[m] - data_low,
+            position_word_of[m] - data_low + clone_vertex_count * 3
+        );
+
+        let meshlet_wrong = 0;
+
+        for (let v = 0; v < clone_vertex_count; v++) {
+            vertices++;
+
+            const expected = transform_point(
+                to_mesh_local,
+                source.attribute_position[v * 3],
+                source.attribute_position[v * 3 + 1],
+                source.attribute_position[v * 3 + 2],
+            );
+
+            const error = Math.max(
+                Math.abs(positions[v * 3] - expected[0]),
+                Math.abs(positions[v * 3 + 1] - expected[1]),
+                Math.abs(positions[v * 3 + 2] - expected[2]),
+            );
+
+            if (error > worst) {
+                worst = error;
+                worst_where = { meshlet: m, vertex: v };
+            }
+
+            if (error > tolerance) {
+                wrong++;
+                meshlet_wrong++;
+
+                wrong_by_slot.set(v, (wrong_by_slot.get(v) ?? 0) + 1);
+
+                if (examples.length < 8) {
+                    examples.push({
+                        meshlet: m,
+                        vertex: v,
+                        got: [positions[v * 3], positions[v * 3 + 1], positions[v * 3 + 2]],
+                        expected,
+                    });
+                }
+            }
+        }
+
+        if (meshlet_wrong > 0) {
+            wrong_meshlets.push(m);
+        }
+    }
+
+    // The two shapes worth telling apart, named rather than left to be read out of the runs: a
+    // stride-loop bug wrongs every slot at or past the workgroup size and nothing below it, and an
+    // addressing bug wrongs whole meshlets.
+    const slots = [...wrong_by_slot.keys()].sort((a, b) => a - b);
+
+    const lowest_wrong_slot = slots.length > 0 ? slots[0] : null;
+
+    return {
+        geometry_index,
+        meshlets: meshlets_count,
+        address_delta: [...address_deltas][0],
+        vertices,
+        wrong,
+        worst,
+        worst_where,
+        wrong_meshlets: wrong_meshlets.length,
+        wrong_meshlet_runs: runs_of(wrong_meshlets).slice(0, 20),
+        lowest_wrong_slot,
+        highest_correct_slot: slots.length > 0 ? lowest_wrong_slot - 1 : null,
+        wrong_slot_runs: runs_of(slots).slice(0, 20),
+        examples,
+        verdict: wrong === 0
+            ? `pass — all ${vertices} of the clone's vertices are the bind pose, worst error ${worst}`
+            : `FAIL — ${wrong} of ${vertices} vertices in ${wrong_meshlets.length} of `
+                + `${meshlets_count} meshlets are not the bind pose (worst ${worst}); `
+                + `lowest wrong vertex slot ${lowest_wrong_slot}`,
+    };
+}

package/src/shade/renderer/particles/cull/chunk_particle_cull.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_cull.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/cull/chunk_particle_cull.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,kCAFU,SAAS,CAwBhB;0BAnCuB,oCAAoC"}
+{"version":3,"file":"chunk_particle_cull.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/cull/chunk_particle_cull.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,kCAFU,SAAS,CA0BhB;0BArCuB,oCAAoC"}

package/src/shade/renderer/particles/cull/chunk_particle_cull.js

@@ -11,7 +11,9 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_cull = CodeChunk.from(/* wgsl */ `
+export const chunk_particle_cull = CodeChunk.from(
+    /* language=wgsl */
+    `
 // A sphere is on the inside (or straddling) a plane if its centre is no more than 'radius' behind it.
 fn particle_plane_sphere_visible(plane : vec4<f32>, center : vec3<f32>, radius : f32) -> bool {
     return dot(plane.xyz, center) + plane.w >= -radius;

package/src/shade/renderer/particles/data/chunk_particle_emitter.js

@@ -13,7 +13,7 @@ const F = EMITTER_FIELD;
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_emitter = CodeChunk.from(/* wgsl */ `
+export const chunk_particle_emitter = CodeChunk.from(/* language=wgsl */ `
 const PARTICLE_EMITTER_STRIDE : u32 = ${EMITTER_STRIDE}u;
 const EMITTER_BLEND_SHIFT : u32 = ${EMITTER_FLAG_ENCODING.BLEND_SHIFT}u;
 const EMITTER_BLEND_MASK : u32 = ${EMITTER_FLAG_ENCODING.BLEND_MASK}u;

package/src/shade/renderer/particles/graph/compile_particle_graph.d.ts

@@ -15,7 +15,7 @@
  * @param {ParticleAssembler} asm assembler owning the shared constant pool
  * @param {import("../layout/ParticleLayout.js").ParticleLayout} layout attribute schema
  */
-export function compile_particle_graph(graph: import("./ParticleGraph.js").ParticleGraph, stream: import("../isa/ParticleAssembler.js").InstructionStream, asm: ParticleAssembler, layout: import("../layout/ParticleLayout.js").ParticleLayout): void;
+export function compile_particle_graph(graph: import("./ParticleGraph.js").ParticleGraph, stream: any, asm: ParticleAssembler, layout: import("../layout/ParticleLayout.js").ParticleLayout): void;
 /**
  * Compile a full effect (SPAWN + UPDATE) into a {@link ../isa/ParticleProgram.js}.
  *

package/src/shade/renderer/particles/graph/compile_particle_graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/compile_particle_graph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,8CALW,OAAO,oBAAoB,EAAE,aAAa,UAC1C,OAAO,6BAA6B,EAAE,iBAAiB,OACvD,iBAAiB,UACjB,OAAO,6BAA6B,EAAE,cAAc,QAqD9D;AAED;;;;;;;;GAQG;AACH;IAL+D,KAAK,GAAzD,OAAO,oBAAoB,EAAE,aAAa;IACU,MAAM,GAA1D,OAAO,oBAAoB,EAAE,aAAa;IACmB,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IAClD,OAAO,2BAA2B,EAAE,eAAe,CAa/D;kCA7FiC,6BAA6B"}
+{"version":3,"file":"compile_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/compile_particle_graph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,8CALW,OAAO,oBAAoB,EAAE,aAAa,oBAE1C,iBAAiB,UACjB,OAAO,6BAA6B,EAAE,cAAc,QAqD9D;AAED;;;;;;;;GAQG;AACH;IAL+D,KAAK,GAAzD,OAAO,oBAAoB,EAAE,aAAa;IACU,MAAM,GAA1D,OAAO,oBAAoB,EAAE,aAAa;IACmB,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IAClD,OAAO,2BAA2B,EAAE,eAAe,CAa/D;kCA7FiC,6BAA6B"}

package/src/shade/renderer/particles/isa/InstructionStream.d.ts

@@ -0,0 +1,89 @@
+/**
+ * A single VM instruction stream (a SPAWN or UPDATE section). Instructions are appended in order;
+ * {@link toWords} flattens them to the packed `Uint32Array` the program consumes.
+ *
+ * Register usage is tracked as instructions are emitted so the assembler can report how many
+ * registers the program touches without a separate pass.
+ */
+export class InstructionStream {
+    /** @type {number[][]} */
+    instructions: number[][];
+    /** @type {number} highest register index referenced, plus one */
+    register_count: number;
+    /**
+     * Emit a raw instruction. Validates the opcode and tracks register usage. Prefer the typed
+     * helpers below where they exist — they document the non-obvious operand packing.
+     *
+     * @param {number} op
+     * @param {number} [dst]
+     * @param {number} [s0]
+     * @param {number} [s1]
+     * @param {number} [s2]
+     * @returns {InstructionStream} this, for chaining
+     */
+    emit(op: number, dst?: number, s0?: number, s1?: number, s2?: number): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} src
+     * @returns {InstructionStream}
+     */
+    mov(dst: number, src: number): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} constant_index
+     * @returns {InstructionStream}
+     */
+    loadConst(dst: number, constant_index: number): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} word_offset
+     * @param {number} component_count
+     * @returns {InstructionStream}
+     */
+    loadAttr(dst: number, word_offset: number, component_count: number): InstructionStream;
+    /**
+     * @param {number} src_register
+     * @param {number} word_offset
+     * @param {number} component_count
+     * @returns {InstructionStream}
+     */
+    storeAttr(src_register: number, word_offset: number, component_count: number): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} builtin_id
+     * @returns {InstructionStream}
+     */
+    loadBuiltin(dst: number, builtin_id: number): InstructionStream;
+    /**
+     * @param {number} condition_register
+     * @returns {InstructionStream}
+     */
+    kill(condition_register: number): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} mode
+     * @returns {InstructionStream}
+     */
+    random(dst: number, mode: number): InstructionStream;
+    /**
+     * @param {number} dst
+     * @param {number} curve_handle
+     * @param {number} t_register
+     * @returns {InstructionStream}
+     */
+    curve(dst: number, curve_handle: number, t_register: number): InstructionStream;
+    /**
+     * @returns {InstructionStream}
+     */
+    halt(): InstructionStream;
+    /**
+     * @returns {number}
+     */
+    get instruction_count(): number;
+    /**
+     * @returns {Uint32Array}
+     */
+    toWords(): Uint32Array;
+    #private;
+}
+//# sourceMappingURL=InstructionStream.d.ts.map

package/src/shade/renderer/particles/isa/InstructionStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstructionStream.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/InstructionStream.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH;IACI,yBAAyB;IACzB,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAUnB;;;;;;;;;;OAUG;IACH,SAPW,MAAM,QACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,iBAAiB,CAsB7B;IAID;;;;OAIG;IACH,SAJW,MAAM,OACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;OAIG;IACH,eAJW,MAAM,kBACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,cALW,MAAM,eACN,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,wBALW,MAAM,eACN,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;OAIG;IACH,iBAJW,MAAM,cACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;OAIG;IACH,YAJW,MAAM,QACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,WALW,MAAM,gBACN,MAAM,cACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;OAEG;IACH,QAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,WAFa,WAAW,CAWvB;;CACJ"}