@woosh/meep-engine 3.14.4 → 3.14.6

package/src/engine/sound/simulation/configureAcousticSimulation.js

@@ -19,13 +19,19 @@ import { AcousticVolumeSystem } from "./ecs/AcousticVolumeSystem.js";
  *
  * Returns the simulator so the caller can tune it (`rayCount`, `smoothing`, `random_seed`, `medium`), bake
  * against its `occluderIndex` (reverb / visibility), and enable corner-leakage (`pathing` + `setProbeField`).
- * For probe-baked reverb, pass a configured {@link ProbeReverbRenderer} as `options.probeReverb` (or assign
- * `audioEmitterSystem.probeReverb` yourself afterwards).
+ * For probe-baked reverb, pass a configured {@link ProbeReverbRenderer} as `probeReverb`. It reaches both
+ * halves: the emitter system, which drives it per frame, and {@link AcousticProbeFieldSystem}, which hands
+ * it the field on link. Assigning `audioEmitterSystem.probeReverb` yourself instead wires only the first,
+ * and a renderer with no field renders silence.
  *
  * Call once during engine configuration, after the `AudioEmitterSystem` is constructed (construct it
  * without an `acousticSim` argument — this injects it).
  *
- * @param {EngineConfiguration} configuration the config the acoustic systems are added to
+ * @param {{addManySystems: function(...System):*}} configuration whatever the systems are added to.
+ * Structural rather than {@link EngineConfiguration}, because `addManySystems` is the only method
+ * this helper calls and an application driving the {@link EntityManager} directly has no
+ * `EngineConfiguration` to hand it — `EngineConfiguration.systems` is `@private`, so the only way
+ * through was a collector object and an `as unknown as` cast (GAP-033).
  * @param {AudioEmitterSystem} audioEmitterSystem the system whose `update()` drives the simulation
  * @param {AcousticSimulator} [simulator] reuse this simulator instead of creating one (default: a fresh one)
  * @param {ProbeReverbRenderer} [probeReverb] optional probe-reverb renderer to wire (left untouched if omitted)
@@ -35,7 +41,7 @@ export function configureAcousticSimulation(configuration, audioEmitterSystem, s
     configuration.addManySystems(
         new AcousticSimulationSystem(simulator),
         new AcousticVolumeSystem(simulator),
-        new AcousticProbeFieldSystem(simulator)
+        new AcousticProbeFieldSystem(simulator, probeReverb ?? null)
     );
 
     audioEmitterSystem.acousticSim = simulator;

package/src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.d.ts

@@ -15,8 +15,10 @@
 export class AcousticProbeFieldSystem extends System<any> {
     /**
      * @param {AcousticSimulator} simulator the shared simulation engine
+     * @param {ProbeReverbRenderer} [probeReverb] renderer to hand the field to alongside the
+     * simulator. {@link configureAcousticSimulation} passes the one it is given.
      */
-    constructor(simulator: AcousticSimulator);
+    constructor(simulator: AcousticSimulator, probeReverb?: ProbeReverbRenderer);
     dependencies: (typeof AcousticProbeField)[];
     /**
      * @type {AcousticSimulator}

package/src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticProbeFieldSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;IASI;;OAEG;IACH,0CAOC;IAlBD,4CAAoC;IAchC;;OAEG;IACH,6BAA0B;IAG9B;;;OAGG;IACH,YAHW,kBAAkB,UAClB,MAAM,QAShB;IAED;;;OAGG;IACH,cAHW,kBAAkB,UAClB,MAAM,QAShB;;CACJ;uBA/DsB,wBAAwB;mCACZ,gCAAgC"}
+{"version":3,"file":"AcousticProbeFieldSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;IAuBI;;;;OAIG;IACH,6EASC;IApCD,4CAAoC;IA8BhC;;OAEG;IACH,6BAA0B;IAK9B;;;OAGG;IACH,YAHW,kBAAkB,UAClB,MAAM,QAahB;IAED;;;OAGG;IACH,cAHW,kBAAkB,UAClB,MAAM,QAahB;;CACJ;uBAzFsB,wBAAwB;mCACZ,gCAAgC"}

package/src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.js

@@ -24,16 +24,34 @@ export class AcousticProbeFieldSystem extends System {
      */
     #field = null;
 
+    /**
+     * The renderer that plays the field's baked reverberation, if there is one.
+     *
+     * Its absence was the whole of GAP-031, reported from a port. The docblock above says the
+     * field's "baked reverb feeds the probe-reverb renderer", `ProbeReverbRenderer` has its own
+     * `setProbeField`, and nothing called it: `link` handed the field to the simulator — which
+     * uses it only for corner-leak pathing — and the half that plays the reverberation kept a
+     * null field, whose `update` returns immediately. Attaching a field and hearing nothing was
+     * the default outcome, in a subsystem whose correct output is also quiet.
+     *
+     * @type {ProbeReverbRenderer|null}
+     */
+    #reverb = null;
+
     /**
      * @param {AcousticSimulator} simulator the shared simulation engine
+     * @param {ProbeReverbRenderer} [probeReverb] renderer to hand the field to alongside the
+     * simulator. {@link configureAcousticSimulation} passes the one it is given.
      */
-    constructor(simulator) {
+    constructor(simulator, probeReverb = null) {
         super();
 
         /**
          * @type {AcousticSimulator}
          */
         this.simulator = simulator;
+
+        this.#reverb = probeReverb;
     }
 
     /**
@@ -47,6 +65,10 @@ export class AcousticProbeFieldSystem extends System {
 
         this.#field = field;
         this.simulator.setProbeField(field);
+
+        if (this.#reverb !== null) {
+            this.#reverb.setProbeField(field);
+        }
     }
 
     /**
@@ -60,5 +82,9 @@ export class AcousticProbeFieldSystem extends System {
 
         this.#field = null;
         this.simulator.setProbeField(null);
+
+        if (this.#reverb !== null) {
+            this.#reverb.setProbeField(null);
+        }
     }
 }

package/src/engine/sound/simulation/render/ProbeReverbRenderer.d.ts

@@ -38,6 +38,40 @@ export class ProbeReverbRenderer {
      * @type {number}
      */
     minDecay: number;
+    set sendLevel(arg: number);
+    /**
+     * How much of the send actually comes back, 0..1.
+     *
+     * There was no level anywhere in this path. The internal wet gains crossfade between silence
+     * and **unity**, so connecting a bus output to {@link input} the way this class documents put
+     * the whole mix through the convolver at full wet — and every tunable that existed
+     * (`decayPower`, `crossfadeSeconds`, `changeThreshold`, `minDecay`) shapes the IR or the
+     * transition, not the amount. The honest wiring was the wrong-sounding one, which is a bad
+     * default to hand somebody. Reported from a port as GAP-032, worked around with a `GainNode`
+     * in front of the input.
+     *
+     * Multiplies the active wet gain, so it takes effect on the next crossfade and is applied
+     * immediately to a live one.
+     *
+     * @type {number}
+     */
+    get sendLevel(): number;
+    /**
+     * Longest impulse response this will synthesise, in seconds.
+     *
+     * `reverbImpulseResponse` sized its buffer straight from the RT60 with no ceiling. A probe
+     * measuring 8.06 s — not a bug: that is Sabine for a large hall behind hard surfaces — yields a
+     * 387,000-sample stereo `AudioBuffer` plus three scratch bands the same length, about 11 MB,
+     * synthesised **on the main thread**, every time the listener crosses into a probe cell whose
+     * decay differs by more than {@link changeThreshold}. That is a mid-match hitch triggered by
+     * walking, and it is a long way from its cause. GAP-032.
+     *
+     * Three seconds is what a `ConvolverNode` is comfortable running and is what the port clamped
+     * to when it hit this. Raise it if you have measured that you can afford to.
+     *
+     * @type {number}
+     */
+    maxDecaySeconds: number;
     /**
      * The node sources / a sopra bus send their post-fader copy into.
      * @returns {AudioNode}

package/src/engine/sound/simulation/render/ProbeReverbRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/ProbeReverbRenderer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH;IAsFI;;;OAGG;IACH,0BAHW,gBAAgB,eAChB,SAAS,EA8BnB;IArHD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAgGhB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,KACN,MAAM,QAShB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAOhB;IAED;;;;OAIG;IACH,gBAFW,YAAY,GAAC,MAAM,EAAE,QAwC/B;;CACJ"}
+{"version":3,"file":"ProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/ProbeReverbRenderer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH;IAwII;;;OAGG;IACH,0BAHW,gBAAgB,eAChB,SAAS,EA8BnB;IAvKD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAsBhB,2BAQC;IA5BD;;;;;;;;;;;;;;;OAeG;IACH,wBAEC;IAeD;;;;;;;;;;;;;;OAcG;IACH,iBAFU,MAAM,CAEI;IAgGpB;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,KACN,MAAM,QAShB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAOhB;IAED;;;;OAIG;IACH,gBAFW,YAAY,GAAC,MAAM,EAAE,QAiD/B;;CACJ"}

package/src/engine/sound/simulation/render/ProbeReverbRenderer.js

@@ -41,6 +41,56 @@ export class ProbeReverbRenderer {
      */
     minDecay = 0.05;
 
+    /**
+     * How much of the send actually comes back, 0..1.
+     *
+     * There was no level anywhere in this path. The internal wet gains crossfade between silence
+     * and **unity**, so connecting a bus output to {@link input} the way this class documents put
+     * the whole mix through the convolver at full wet — and every tunable that existed
+     * (`decayPower`, `crossfadeSeconds`, `changeThreshold`, `minDecay`) shapes the IR or the
+     * transition, not the amount. The honest wiring was the wrong-sounding one, which is a bad
+     * default to hand somebody. Reported from a port as GAP-032, worked around with a `GainNode`
+     * in front of the input.
+     *
+     * Multiplies the active wet gain, so it takes effect on the next crossfade and is applied
+     * immediately to a live one.
+     *
+     * @type {number}
+     */
+    get sendLevel() {
+        return this.#sendLevel;
+    }
+
+    set sendLevel(value) {
+        this.#sendLevel = value;
+
+        // apply to whichever convolver is currently up, so a change is audible without waiting for
+        // the listener to cross a probe cell
+        if (this.#currentWet > 0) {
+            rampGain(this.#wets[this.#active].gain, Math.max(FADE_EPSILON, value), 0.02, this.#ctx);
+        }
+    }
+
+    /** @private @type {number} */
+    #sendLevel = 1;
+
+    /**
+     * Longest impulse response this will synthesise, in seconds.
+     *
+     * `reverbImpulseResponse` sized its buffer straight from the RT60 with no ceiling. A probe
+     * measuring 8.06 s — not a bug: that is Sabine for a large hall behind hard surfaces — yields a
+     * 387,000-sample stereo `AudioBuffer` plus three scratch bands the same length, about 11 MB,
+     * synthesised **on the main thread**, every time the listener crosses into a probe cell whose
+     * decay differs by more than {@link changeThreshold}. That is a mid-match hitch triggered by
+     * walking, and it is a long way from its cause. GAP-032.
+     *
+     * Three seconds is what a `ConvolverNode` is comfortable running and is what the port clamped
+     * to when it hit this. Raise it if you have measured that you can afford to.
+     *
+     * @type {number}
+     */
+    maxDecaySeconds = 3;
+
     /**
      * @type {BaseAudioContext}
      */
@@ -215,8 +265,17 @@ export class ProbeReverbRenderer {
         const inactive = 1 - this.#active;
 
         if (targetWet > 0) {
+            // clamped here rather than at the bake, so a field that ships a long RT60 still plays
+            // at a length the convolver can run and the allocation stays bounded
+            const ceiling = this.maxDecaySeconds;
+            const clamped = [
+                Math.min(bands[0], ceiling),
+                Math.min(bands[1], ceiling),
+                Math.min(bands[2], ceiling)
+            ];
+
             this.#convolvers[inactive].buffer = reverbImpulseResponse(
-                this.#ctx, bands, this.decayPower, this.#random
+                this.#ctx, clamped, this.decayPower, this.#random
             );
         }
 
@@ -224,7 +283,7 @@ export class ProbeReverbRenderer {
         // where available, so crossing a probe cell mid-fade doesn't snap). Fade to FADE_EPSILON, never 0.
         const cf = this.crossfadeSeconds;
         rampGain(this.#wets[this.#active].gain, FADE_EPSILON, cf, this.#ctx);
-        rampGain(this.#wets[inactive].gain, targetWet > 0 ? 1 : FADE_EPSILON, cf, this.#ctx);
+        rampGain(this.#wets[inactive].gain, targetWet > 0 ? Math.max(FADE_EPSILON, this.#sendLevel) : FADE_EPSILON, cf, this.#ctx);
 
         this.#active = inactive;
     }

package/src/engine/sound/simulation/render/reverbImpulseResponse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverbImpulseResponse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM,GACf,WAAW,CA2CvB"}
+{"version":3,"file":"reverbImpulseResponse.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/reverbImpulseResponse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,2CANW,gBAAgB,cAChB,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,gBACK,MAAM,GACf,WAAW,CAoDvB"}

package/src/engine/sound/simulation/render/reverbImpulseResponse.js

@@ -39,6 +39,15 @@ export function reverbImpulseResponse(
     const ir = ctx.createBuffer(2, length, sampleRate);
 
     // band scratch, allocated once and reused for BOTH channels (they differ only in their noise stream)
+    /*
+     Float64, and it stays that way. GAP-032 suggested halving this allocation with a Float32
+     scratch on the reasoning that the bands are summed into a float32 channel anyway. They are —
+     and `reverb_band_tails` documents why that does not follow: the callers SUM AND RE-WEIGHT
+     these values, rounding each band to float32 first perturbs the sum, and there are two callers
+     (this stereo IR and the B-format directional one). The whole point of sharing the band
+     production is that both renderers agree about what the same room sounds like. The allocation
+     is bounded by `ProbeReverbRenderer.maxDecaySeconds` instead, which was the real problem.
+    */
     const bandLow = new Float64Array(length);
     const bandMid = new Float64Array(length);
     const bandHigh = new Float64Array(length);

package/src/shade/playground/particle_system/README.md

@@ -17,6 +17,10 @@ It has to be `http://localhost` rather than `file://`: WebGPU needs a secure con
 imports from `file://` are blocked by CORS anyway. The page imports nothing but meep's own relative
 ESM, so any static server rooted at the repo also serves it.
 
+**It needs `subgroups`**, and refuses to start without it. The simulate input list is bucketed by VM
+program so no wave spans two programs, and the bucket offsets come from `graph_prefix_scan_csdldf`,
+which is built on subgroup ops.
+
 **It needs immediate data**, and refuses to start without it. Emit, simulate and build-indirect each
 carry their per-dispatch state (`u_dt`, `u_time`, `u_frame`, and for emit the request count and the
 pool capacity) as an immediate block rather than as a transient uniform buffer, so an adapter whose
@@ -35,6 +39,12 @@ Four emitters sharing one 32k pool, chosen so each renderer path is visible at o
 | sparks | additive | **stretched** | short-lived, gravity-fed, stretched along velocity — the one non-billboard projection |
 | dust | alpha | billboard, soft-depth | a wide slow drift, so the ground plane and the low wall both get a soft intersection |
 
+Four distinct compiled programs, so this is also where the simulation-order bucketing has something
+to do: without it a simulate wave holds fire, smoke, spark and dust particles side by side, each
+wanting different opcodes out of the interpreter's `switch` and different registers out of its
+dynamically-indexed file. Nothing on screen changes when it is on — it is a coherence change, not a
+visual one — which is why it is pinned by specs rather than by looking.
+
 Ground plane and three boxes are drawn first into a reverse-Z `depth32float` buffer. The billboard
 pass loads that colour target and depth-tests against the same buffer read-only, so particles are
 **occluded** by the boxes and the soft-depth emitters sample the depth they were occluded by.
@@ -75,9 +85,10 @@ npx vitest run src/shade/playground/particle_system/particle_scene.spec.js
 
 That mock runs no shaders, so the spec asserts nothing about what a pass computed. What it does
 assert is that the frame is legal and wired the way the design requires — pass order and
-attachments, the alive lists ping-ponging so no frame reads the list it appends to, the immediate
-blocks written before every dispatch that declares them, and simulate and the draw both taking their
-counts from the indirect buffers. Any WebGPU validation failure anywhere in the frame arrives as an
+attachments, no frame reading the list it appends to, the immediate blocks written before every
+dispatch that declares them, simulate and the draw both taking their counts from the indirect
+buffers, and the two orderings staying in separate buffers: simulate reads the program-coherent
+list, the billboard draw reads the alive list. Any WebGPU validation failure anywhere in the frame arrives as an
 uncaptured error, which every test fails on.
 
 The picture is the browser's job; the spec cannot see it.

package/src/shade/playground/particle_system/index.html

@@ -105,6 +105,7 @@
     <div><span class="key">alive</span><span id="stat-alive">—</span></div>
     <div><span class="key">free</span><span id="stat-dead">—</span></div>
     <div><span class="key">draw instances</span><span id="stat-draw">—</span></div>
+    <div><span class="key">sim lanes</span><span id="stat-sim-lanes">—</span></div>
     <div><span class="key">sim workgroups</span><span id="stat-dispatch">—</span></div>
 </div>
 

package/src/shade/playground/particle_system/main.js

@@ -39,7 +39,17 @@ async function main() {
         return show_message("No WebGPU adapter — this browser exposes the API but has no usable GPU.");
     }
 
-    const device = await adapter.requestDevice();
+    // The coherence pass's bucket offsets come from the CSDLDF prefix scan, which is built on
+    // subgroup ops — refusing by name beats the pipeline-creation error a device without it raises.
+    if (!adapter.features.has("subgroups")) {
+        return show_message(
+            "This browser's WebGPU adapter does not offer the 'subgroups' feature.\n"
+            + "The simulate list's program-coherent bucketing scans its bin counts with the CSDLDF\n"
+            + "prefix scan, which is built on subgroup ops."
+        );
+    }
+
+    const device = await adapter.requestDevice({ requiredFeatures: ["subgroups"] });
     device.addEventListener?.("uncapturederror", (e) => console.error("WebGPU error:", e.error.message));
 
     // Every compute pass here carries its per-dispatch state as immediate data, an optional
@@ -148,7 +158,7 @@ async function main() {
 }
 
 /** Push one stats snapshot into the overlay. Absent elements are simply skipped. */
-function write_hud({ fps, alive, dead, dispatch, draw }) {
+function write_hud({ fps, alive, dead, dispatch, draw, sim_padded }) {
     const put = (id, value) => {
         const node = document.getElementById(id);
         if (node !== null) {
@@ -160,6 +170,9 @@ function write_hud({ fps, alive, dead, dispatch, draw }) {
     put("stat-alive", alive.toLocaleString());
     put("stat-dead", dead.toLocaleString());
     put("stat-draw", draw[1].toLocaleString());
+    // Padding rounds each program's run up to a whole workgroup, so this is >= alive; the gap is
+    // what wave-coherence costs in lanes.
+    put("stat-sim-lanes", sim_padded.toLocaleString());
     put("stat-dispatch", dispatch[0].toLocaleString());
 }
 

package/src/shade/playground/particle_system/particle_scene.d.ts

@@ -2,7 +2,10 @@
  * @typedef {object} ParticleSceneStats
  * @property {number} alive particles alive at the end of the captured frame
  * @property {number} dead free slots left in the pool
- * @property {number} alive_in the snapshot next frame's simulate reads as its input length
+ * @property {number} alive_in the snapshot next frame's simulate reads as its input length — the
+ *   PADDED length of the coherence list, so it is `sim_padded` from the captured frame, not `alive`
+ * @property {number} sim_padded length of the program-coherent list the coherence pass built this
+ *   frame; the gap to `alive` is the lanes padding costs to keep each wave on one VM program
  * @property {number[]} dispatch simulate's indirect dispatch args, `[x, y, z]` workgroups
  * @property {number[]} draw the billboard draw's indirect args, `[vertices, instances]`
  */
@@ -37,9 +40,15 @@ export type ParticleSceneStats = {
      */
     dead: number;
     /**
-     * the snapshot next frame's simulate reads as its input length
+     * the snapshot next frame's simulate reads as its input length — the
+     * PADDED length of the coherence list, so it is `sim_padded` from the captured frame, not `alive`
      */
     alive_in: number;
+    /**
+     * length of the program-coherent list the coherence pass built this
+     * frame; the gap to `alive` is the lanes padding costs to keep each wave on one VM program
+     */
+    sim_padded: number;
     /**
      * simulate's indirect dispatch args, `[x, y, z]` workgroups
      */

package/src/shade/playground/particle_system/particle_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_scene.js"],"names":[],"mappings":"AAwEA;;;;;;;GAOG;AAEH;;;;;;;;GAQG;AACH;IAJqC,YAAY;IACrB,QAAQ,GAAzB,MAAM;IACJ,MAAM,CA8OlB;AA3QD;;;;GAIG;AACH,0CAA2C;AAE3C,wGAAwG;AACxG,sCAAuC;;;;;WAOzB,MAAM;;;;UACN,MAAM;;;;cACN,MAAM;;;;cACN,MAAM,EAAE;;;;UACR,MAAM,EAAE"}
+{"version":3,"file":"particle_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_scene.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;GAUG;AAEH;;;;;;;;GAQG;AACH;IAJqC,YAAY;IACrB,QAAQ,GAAzB,MAAM;IACJ,MAAM,CAiUlB;AAjWD;;;;GAIG;AACH,0CAA2C;AAE3C,wGAAwG;AACxG,sCAAuC;;;;;WAOzB,MAAM;;;;UACN,MAAM;;;;;cACN,MAAM;;;;;gBAEN,MAAM;;;;cAEN,MAAM,EAAE;;;;UACR,MAAM,EAAE"}