@woosh/meep-engine 2.138.20 → 2.140.0

package/src/engine/physics/events/ContactEventBuffer.js

@@ -0,0 +1,83 @@
+/**
+ * Event kinds emitted by the manifold diff pass.
+ * @readonly
+ * @enum {number}
+ */
+export const ContactEventKind = {
+    Begin: 0,
+    Stay: 1,
+    End: 2,
+};
+
+const DEFAULT_INITIAL_CAPACITY = 32;
+
+/**
+ * Per-event stride in the Uint32 backing array:
+ *   0 : kind (ContactEventKind)
+ *   1 : entityA
+ *   2 : entityB
+ *   3 : slot
+ * @type {number}
+ */
+const EVENT_STRIDE = 4;
+
+/**
+ * Append-only buffer of contact events produced during one fixedUpdate, ready
+ * to be dispatched (and then cleared) at end-of-step.
+ *
+ * Storage is flat Uint32Array — keeping the metadata side allocation-free; the
+ * actual contact payload (normal, depth, world point) is read on demand from
+ * the {@link ManifoldStore} by the dispatch code.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ContactEventBuffer {
+    /**
+     * @param {number} [initial_capacity] events
+     */
+    constructor(initial_capacity = DEFAULT_INITIAL_CAPACITY) {
+        this.__capacity = Math.max(1, initial_capacity);
+        this.__count = 0;
+        // Int32 so entity ids may legitimately store -1 (stale body after free).
+        this.__data = new Int32Array(this.__capacity * EVENT_STRIDE);
+    }
+
+    /**
+     * @returns {number}
+     */
+    get count() {
+        return this.__count;
+    }
+
+    clear() {
+        this.__count = 0;
+    }
+
+    /**
+     * @param {ContactEventKind|number} kind
+     * @param {number} entityA
+     * @param {number} entityB
+     * @param {number} slot manifold slot id
+     */
+    push(kind, entityA, entityB, slot) {
+        if (this.__count === this.__capacity) {
+            const new_cap = this.__capacity << 1;
+            const next = new Int32Array(new_cap * EVENT_STRIDE);
+            next.set(this.__data);
+            this.__data = next;
+            this.__capacity = new_cap;
+        }
+        const off = this.__count * EVENT_STRIDE;
+        this.__data[off] = kind;
+        this.__data[off + 1] = entityA;
+        this.__data[off + 2] = entityB;
+        this.__data[off + 3] = slot;
+        this.__count++;
+    }
+
+    kind_at(i) { return this.__data[i * EVENT_STRIDE]; }
+    entityA_at(i) { return this.__data[i * EVENT_STRIDE + 1]; }
+    entityB_at(i) { return this.__data[i * EVENT_STRIDE + 2]; }
+    slot_at(i) { return this.__data[i * EVENT_STRIDE + 3]; }
+}

package/src/engine/physics/events/diff_manifolds.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Walk every live manifold and produce a contact event for each pair whose
+ * touched state changed (or persisted) since the previous step:
+ *
+ *   touched + !prev_touched  → ContactBegin
+ *   touched +  prev_touched  → ContactStay
+ *   !touched + prev_touched  → ContactEnd
+ *   !touched + !prev_touched → no event (slot is about to be evicted by
+ *                              advance_frame's grace counter)
+ *
+ * MUST be called BEFORE {@link ManifoldStore#advance_frame} so the touched
+ * bits still reflect the just-finished step.
+ *
+ * Output is in slot-iteration order, which matches the deterministic
+ * insertion order of slots in the dense live list. That's stable for a given
+ * input sequence; not the same as `(idA, idB)` lex order, which would
+ * require a sort. For v1 callers want stable-replay determinism rather than
+ * any specific external order, so we don't sort.
+ *
+ * @param {ManifoldStore} manifolds
+ * @param {BodyStorage} storage
+ * @param {ContactEventBuffer} out_events cleared and refilled
+ */
+export function diff_manifolds(manifolds: ManifoldStore, storage: BodyStorage, out_events: ContactEventBuffer): void;
+//# sourceMappingURL=diff_manifolds.d.ts.map

package/src/engine/physics/events/diff_manifolds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff_manifolds.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/events/diff_manifolds.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qHAuBC"}

package/src/engine/physics/events/diff_manifolds.js

@@ -0,0 +1,50 @@
+import { body_id_index } from "../body/BodyStorage.js";
+import { ContactEventKind } from "./ContactEventBuffer.js";
+
+/**
+ * Walk every live manifold and produce a contact event for each pair whose
+ * touched state changed (or persisted) since the previous step:
+ *
+ *   touched + !prev_touched  → ContactBegin
+ *   touched +  prev_touched  → ContactStay
+ *   !touched + prev_touched  → ContactEnd
+ *   !touched + !prev_touched → no event (slot is about to be evicted by
+ *                              advance_frame's grace counter)
+ *
+ * MUST be called BEFORE {@link ManifoldStore#advance_frame} so the touched
+ * bits still reflect the just-finished step.
+ *
+ * Output is in slot-iteration order, which matches the deterministic
+ * insertion order of slots in the dense live list. That's stable for a given
+ * input sequence; not the same as `(idA, idB)` lex order, which would
+ * require a sort. For v1 callers want stable-replay determinism rather than
+ * any specific external order, so we don't sort.
+ *
+ * @param {ManifoldStore} manifolds
+ * @param {BodyStorage} storage
+ * @param {ContactEventBuffer} out_events cleared and refilled
+ */
+export function diff_manifolds(manifolds, storage, out_events) {
+    out_events.clear();
+
+    const live_count = manifolds.count;
+    for (let i = 0; i < live_count; i++) {
+        const slot = manifolds.live_at(i);
+        const touched = manifolds.is_touched(slot);
+        const prev = manifolds.was_touched_prev(slot);
+
+        if (!touched && !prev) continue;
+
+        let kind;
+        if (touched && !prev)       kind = ContactEventKind.Begin;
+        else if (touched && prev)   kind = ContactEventKind.Stay;
+        else                        kind = ContactEventKind.End;
+
+        const idA = manifolds.bodyA(slot);
+        const idB = manifolds.bodyB(slot);
+        const entA = storage.entity_at(body_id_index(idA));
+        const entB = storage.entity_at(body_id_index(idB));
+
+        out_events.push(kind, entA, entB, slot);
+    }
+}

package/src/engine/physics/fluid/FluidField.d.ts

@@ -1,30 +1,308 @@
 /**
- * Represents a space where fluid simulation happens
+ * Cell-centered 3D Eulerian grid for the fluid simulator.
  *
- * @see 2019 GDC talk by Runard Rupert "Wind Simulation in God of War" https://www.youtube.com/watch?v=dDgyBKkSf7A
- * @see Inspired by GDC talk "Interactive Wind and Vegetation in 'God of War'" - https://www.youtube.com/watch?v=MKX45_riWQA
+ * Holds three velocity components (x, y, z), an optional per-cell `solid` mask, and any
+ * number of user-defined passive scalar attributes that get transported by the flow.
+ *
+ * Holds only state whose value carries information across step boundaries. The
+ * simulator's transient working memory (per-step velocity snapshots, divergence,
+ * diffusion / scalar ping-pong scratch) lives on the simulator. `pressure` is the
+ * one exception: it's warm-started each step from the previous solve, so its value
+ * is genuine cross-step state and belongs here.
+ *
+ * All typed array references are STABLE for the lifetime of the field. External
+ * consumers can safely cache references returned from {@link getScalarData},
+ * {@link velocity_x}, etc.
+ *
+ * @see "Real-Time Fluid Dynamics for Games" (Stam, 2003)
+ * @see GDC 2019 talk "Wind Simulation in God of War" (Rupert Renard) for the wider
+ *      effector-driven design pattern this package is moving toward.
  */
 export class FluidField {
-    buffer: any;
-    addAttribute(name: any): number;
     /**
+     * Velocity X component, length = cell count. Cell-centered, indexed by
+     * `z * res_x * res_y + y * res_x + x`.
+     * @type {Float32Array|null}
+     */
+    velocity_x: Float32Array | null;
+    /**
+     * @type {Float32Array|null}
+     */
+    velocity_y: Float32Array | null;
+    /**
+     * @type {Float32Array|null}
+     */
+    velocity_z: Float32Array | null;
+    /**
+     * Per-cell solid flag. `0` = fluid, non-zero = solid (wall). Always allocated by
+     * {@link build} (zero-filled — every cell defaults to fluid). The solver and every
+     * effector read this unconditionally, so the array is part of the field's
+     * uniform shape, not an optional add-on.
+     * @type {Uint8Array|null}
+     */
+    solid: Uint8Array | null;
+    /**
+     * Per-cell pre-baked neighbourhood mask consumed by the pressure SOR loop.
+     * One byte per cell encoding which of the 6 cardinal neighbours are fluid:
      *
-     * @param {string} name
-     * @return {Float32Array}
+     *     bit 0 (= 1)  : -x neighbour is fluid (in-bounds AND non-solid)
+     *     bit 1 (= 2)  : +x neighbour is fluid
+     *     bit 2 (= 4)  : -y neighbour is fluid
+     *     bit 3 (= 8)  : +y neighbour is fluid
+     *     bit 4 (= 16) : -z neighbour is fluid
+     *     bit 5 (= 32) : +z neighbour is fluid
+     *
+     * Solid cells themselves are encoded as `mask = 0` so the SOR loop's
+     * `if (mask === 0) continue` skip handles both "this cell is solid" and
+     * "this fluid cell is isolated" with a single comparison instead of one
+     * solid-self-check plus six solid-neighbour-checks plus six boundary checks.
+     *
+     * Computed once by {@link recomputeSolidNeighbourMask} after every solid-mask
+     * mutation. The simulator runs that recompute at the top of every project()
+     * call so callers never have to remember to invalidate it; the per-step cost
+     * is one O(N) byte-pass against the bandwidth-bound SOR sweep that runs many
+     * iterations per call.
+     *
+     * @type {Uint8Array|null}
      */
-    getAttributeData(name: string): Float32Array;
-    getAttributeCount(): number;
+    solid_neighbour_mask: Uint8Array | null;
     /**
+     * Pressure field from the most recent projection. Owned by the field rather than
+     * the simulator because the simulator warm-starts each solve from the previous
+     * result — step N+1 depends on the value step N wrote here. If this lived on the
+     * simulator, replacing the simulator instance between steps would silently degrade
+     * convergence at the same iteration count.
+     *
+     * Storage type is {@link Float32Array} by default, or {@link Float16Array} when
+     * {@link half_precision_pressure} is enabled before build — see that field for
+     * the bandwidth-vs-quality trade-off.
      *
-     * @param {ArrayBuffer} buffer
-     * @param {number} offset
+     * Safe to read for debug visualisation. Don't mutate.
+     * @type {Float32Array|Float16Array|null}
+     */
+    pressure: Float32Array | Float16Array | null;
+    /**
+     * Allocate {@link pressure} as {@link Float16Array} instead of {@link Float32Array}.
+     *
+     * **Currently slower in V8 — keep `false`.** The intent of this option is to
+     * halve the memory bandwidth on the pressure SOR sweep (the simulator's
+     * hottest, bandwidth-bound loop). On hardware with F16C the per-cell f16↔f32
+     * conversion is ~1 cycle and the bandwidth saving wins. In V8 as of Node 24
+     * the conversion path is not yet specialized — each read of `pressure[i]`
+     * goes through a slow generic Float16 unboxing routine, and the result is
+     * the opposite of what you'd expect: bench at 64³ shows **49% slower** with
+     * f16, at 128³ **28% slower** (see `bench: half_precision_pressure on/off`
+     * in bench.spec.js). The bandwidth-savings story still holds in principle;
+     * it'll likely become a real win once V8 adds inline support for
+     * Float16Array access (the typed array landed in Node 24 / TC39 Stage 4 only
+     * recently).
+     *
+     * Cost when it does win: Float16 has ~3 decimal digits of precision. The SOR
+     * iterate rounds to f16 on every write, so iteration error can't fall below
+     * ~10⁻³ relative. Bench currently shows max|div| within 8% of the f32
+     * baseline at 64³ and 128³ — acceptable for visual sim but not for
+     * quantitative pressure use.
+     *
+     * Must be set before {@link build}.
+     *
+     * The simulator's internal divergence scratch follows this type automatically
+     * (re-allocated to match `pressure.constructor` on each project call).
+     *
+     * @type {boolean}
+     */
+    half_precision_pressure: boolean;
+    /**
+     * Set the grid dimensions in cells. Must be called before {@link build}; throws if
+     * the field is already built.
+     * @param {number} res_x positive integer
+     * @param {number} res_y positive integer
+     * @param {number} res_z positive integer
+     */
+    setResolution(res_x: number, res_y: number, res_z: number): void;
+    /**
+     * @return {[number, number, number]} A reference to the internal resolution array.
+     *                                    Do not mutate.
+     */
+    getResolution(): [number, number, number];
+    /**
+     * @return {number} `res_x * res_y * res_z`. Zero until {@link setResolution} is
+     *                  called.
+     */
+    cellCount(): number;
+    /**
+     * Register a passive scalar attribute (density, temperature, dye, etc.) that will be
+     * advected by the velocity field each step. Idempotent — re-adding an existing name
+     * returns the existing index.
+     *
+     * Must be called before {@link build}.
+     *
+     * @param {string} name
+     * @return {number} index of the attribute (use with {@link setScalarAtIndex})
+     */
+    addScalar(name: string): number;
+    /**
+     * @param {string} name
+     * @return {number} index the attribute was registered with, or -1 if not present.
+     */
+    scalarIndex(name: string): number;
+    /**
+     * @param {string} name
+     * @return {Float32Array|null} live buffer for the named scalar, or null if not
+     *                             registered.
+     */
+    getScalarData(name: string): Float32Array | null;
+    /**
+     * @return {{ name: string, data: Float32Array }[]} Live reference; do not mutate.
+     */
+    getScalarAttributes(): {
+        name: string;
+        data: Float32Array;
+    }[];
+    /**
+     * Allocate all buffers. Must be called before any read/write. After this point,
+     * resolution and attribute set are frozen.
      */
-    attachBuffer(buffer: ArrayBuffer, offset?: number): void;
-    setAttributeAt(attribute_index: any, x: any, y: any, z: any, value: any): void;
     build(): void;
-    set size(arg: any);
-    set resolution(arg: number[]);
-    get resolution(): number[];
+    /**
+     * Linear cell index for integer grid coordinates.
+     * @param {number} x integer in [0, res_x)
+     * @param {number} y integer in [0, res_y)
+     * @param {number} z integer in [0, res_z)
+     * @return {number} flat index `z * res_x * res_y + y * res_x + x`
+     */
+    cellIndex(x: number, y: number, z: number): number;
+    /**
+     * Set the velocity at an integer grid cell.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     */
+    setVelocityAt(x: number, y: number, z: number, vx: number, vy: number, vz: number): void;
+    /**
+     * Add to the velocity at an integer grid cell (impulse).
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} dvx
+     * @param {number} dvy
+     * @param {number} dvz
+     */
+    addVelocityAt(x: number, y: number, z: number, dvx: number, dvy: number, dvz: number): void;
+    /**
+     * @param {number} attribute_index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} value
+     */
+    setScalarAtIndex(attribute_index: number, x: number, y: number, z: number, value: number): void;
+    /**
+     * Mark a cell as solid (wall) or fluid.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {boolean} is_solid
+     */
+    setSolidAt(x: number, y: number, z: number, is_solid: boolean): void;
+    /**
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {boolean} true if the cell is marked solid.
+     */
+    isSolidAt(x: number, y: number, z: number): boolean;
+    /**
+     * Sample velocity at a fractional grid position (positions outside the grid are
+     * clamped). Writes into `out` and returns it.
+     * @param {Float32Array|number[]} out  Length-3 destination.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {Float32Array|number[]} `out`, for chaining.
+     */
+    sampleVelocity(out: Float32Array | number[], x: number, y: number, z: number): Float32Array | number[];
+    /**
+     * Sample a scalar attribute at a fractional grid position.
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @return {number} trilinearly-interpolated value at `(x, y, z)`.
+     */
+    sampleScalar(name: string, x: number, y: number, z: number): number;
+    /**
+     * Strict value equality. Two fields are equal iff they have the same resolution,
+     * the same set of scalar attributes (matched by name AND index), and the same
+     * buffer contents in `velocity_*`, `solid`, `pressure`, and each scalar. Pre-build
+     * fields compare by resolution + attribute names only (their buffers are null).
+     *
+     * O(N) — walks every cell. Use {@link hash} for change-detection on hot paths.
+     *
+     * @param {FluidField} other
+     * @return {boolean}
+     */
+    equals(other: FluidField): boolean;
+    /**
+     * Fast hash suitable for change-detection. Combines the resolution and a *sparse*
+     * sample of the velocity_x buffer — {@link sparse_typed_array_hash} only inspects
+     * the first ~1024 cells with stride enough to take ~31 samples, regardless of how
+     * large the field is. The hash will catch most local edits to the velocity field
+     * but is not a content-perfect fingerprint; for that, fall through to
+     * {@link equals}.
+     *
+     * Constant-time relative to grid size in the common case.
+     *
+     * @return {number}
+     */
+    hash(): number;
+    /**
+     * Rebuild {@link solid_neighbour_mask} from the current {@link solid} buffer.
+     *
+     * O(N) — one byte-write per cell, six byte-reads per cell. Called by the
+     * simulator at the top of each project so callers never have to remember to
+     * invalidate the mask after mutating solids; the cost is amortized across the
+     * SOR sweep's many iterations.
+     *
+     * Encoding: see {@link solid_neighbour_mask}.
+     */
+    recomputeSolidNeighbourMask(): void;
+    /**
+     * Translate the field's contents by `(shift_x, shift_y, shift_z)` grid cells —
+     * called when the field's world-space origin moves, so the fluid data (anchored
+     * to world space) follows. Every owned buffer (velocity_x/y/z, solid, pressure,
+     * each scalar attribute) is shifted, then the newly-exposed edges are patched
+     * via {@link v3_grid_patch_edges_uniform} (zero-gradient Neumann extrapolation —
+     * "the field is locally uniform").
+     *
+     * Direction convention matches the primitive: positive shift means the grid's
+     * world origin moved in that direction, so each cell takes the value previously
+     * at its `+shift` neighbour.
+     *
+     * `(0, 0, 0)` is a no-op; |shift| ≥ res on any axis zero-fills (no valid source
+     * left to replicate from). Pre-build fields (buffers null) are no-op'd.
+     *
+     * The solid mask is NOT migrated — it's cleared. Solids are out of scope for the
+     * shift machinery: the contract is that the caller re-voxelizes scene geometry
+     * and splats updated solid cells back into the field before the next simulation
+     * tick. Migrating the existing mask would either lie about where the walls are
+     * (if scene geometry moved) or produce double-bookkeeping problems if the caller
+     * also re-voxelizes. Clearing keeps the contract obvious: "between a shift and
+     * the next step, the field has no solids until you write them."
+     *
+     * @param {number} shift_x  integer
+     * @param {number} shift_y  integer
+     * @param {number} shift_z  integer
+     */
+    shift(shift_x: number, shift_y: number, shift_z: number): void;
+    /**
+     * Zero velocity, pressure, and all scalar attributes. Solid mask is preserved.
+     * Pressure is cleared to drop the warm-start (otherwise the next step's solve
+     * begins from a stale solution that no longer matches the zero velocity).
+     */
+    clear(): void;
     #private;
 }
 //# sourceMappingURL=FluidField.d.ts.map

package/src/engine/physics/fluid/FluidField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH;IAQI,YAAc;IAEd,gCASC;IAMD;;;;OAIG;IACH,uBAHW,MAAM,GACL,YAAY,CAIvB;IAED,4BAEC;IAED;;;;OAIG;IACH,qBAHW,WAAW,WACX,MAAM,QAkBhB;IAED,+EAQC;IAED,cAQC;IAED,mBAQC;IAED,8BAQC;IAED,2BAEC;;CACJ"}
+{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAQI;;;;OAIG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;OAEG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;OAEG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;;OAMG;IACH,OAFU,UAAU,GAAC,IAAI,CAEZ;IAEb;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,sBAFU,UAAU,GAAC,IAAI,CAEG;IAE5B;;;;;;;;;;;;;OAaG;IACH,UAFU,YAAY,kBAAc,IAAI,CAExB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAFU,OAAO,CAEe;IAShC;;;;;;OAMG;IACH,qBAJW,MAAM,SACN,MAAM,SACN,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAKnC;IAED;;;OAGG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,MAAM,CAejB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,GACL,YAAY,GAAC,IAAI,CAM5B;IAED;;OAEG;IACH,uBAFY;QAAE,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAE,EAAE,CAIjD;IAED;;;OAGG;IACH,cAmBC;IAED;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAajB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,kCANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,cALW,MAAM,KACN,MAAM,KACN,MAAM,YACN,OAAO,QAIjB;IAED;;;;;OAKG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,OAAO,CAIlB;IAED;;;;;;;;OAQG;IACH,oBANW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAUhC;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAMjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,UAAU,GACT,OAAO,CAqDlB;IAED;;;;;;;;;;;OAWG;IACH,QAFY,MAAM,CAajB;IAED;;;;;;;;;OASG;IACH,oCASC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eAJW,MAAM,WACN,MAAM,WACN,MAAM,QAyChB;IAED;;;;OAIG;IACH,cASC;;CACJ"}