@woosh/meep-engine 3.11.3 → 3.13.0

package/src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.js

@@ -1,84 +1,83 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-
-/**
- * Workgroup size for the per-region stride loop. Each workgroup
- * handles one region; threads in the workgroup walk the region's
- * words in WORKGROUP_SIZE-stride'd slots, so a region with N words
- * takes ceil(N / WORKGROUP_SIZE) iterations per thread.
- */
-export const BUFFER_INTRA_COPY_WORKGROUP_SIZE = 64;
-
-/**
- * One copy job: source and destination regions inside the same buffer.
- * Offsets and lengths are in `u32` words (not bytes). The shader does
- * not validate non-overlap — the caller is responsible.
- */
-export const BUFFER_INTRA_COPY_REGION_STRUCT = WebGPUStruct.from({
-    src_offset: u32,
-    dst_offset: u32,
-    word_count: u32,
-}, "BufferIntraCopyRegion");
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('buffer', WebGPUArray.from(u32), true)
-    .addStorageBuffer('regions', WebGPUArray.from(BUFFER_INTRA_COPY_REGION_STRUCT), false);
-
-// One workgroup per region, dispatch over the regions list. Threads
-// stride-loop over the region's words. WebGPU rejects same-buffer
-// `copyBufferToBuffer` even with non-overlapping ranges, which is why
-// we go via a compute shader for intra-buffer relocation. A single
-// `read_write` binding sidesteps the read+write-on-same-binding
-// resource conflict that would prevent binding the buffer twice with
-// different access modes.
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BUFFER_INTRA_COPY_WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    let region = regions[wg_id.x];
-
-    var i: u32 = local_id;
-    loop {
-        if(i >= region.word_count) { break; }
-
-        buffer[region.dst_offset + i] = buffer[region.src_offset + i];
-
-        i = i + ${BUFFER_INTRA_COPY_WORKGROUP_SIZE}u;
-    }
-}
-`);
-
-/**
- * Compute-shader memcpy across regions of a single storage buffer.
- * One workgroup per region; threads in the workgroup stride-loop
- * over the region's `word_count` u32 words.
- *
- * Why a compute shader rather than `copyBufferToBuffer`: WebGPU
- * forbids `copyBufferToBuffer` from passing the same buffer as both
- * source and destination, even when the byte ranges don't overlap —
- * the validation check is buffer-identity, not range-overlap. The
- * compute path sidesteps that by binding the buffer once as
- * `read_write` storage and reading + writing through the same
- * binding.
- *
- * Caller responsibility: the regions table must list non-overlapping
- * (src, dst) ranges. The shader does no overlap checks.
- *
- * Dispatch: one workgroup per entry in `regions`, i.e.
- * `group_count_x = region_count`. Skip when `region_count === 0`.
- */
-export const shader_buffer_intra_copy_regions = ComputeShader.from({
-    label: "Copy GPU Buffer/ Intra-buffer regions",
-    body,
-    resources,
-    group_size: [BUFFER_INTRA_COPY_WORKGROUP_SIZE, 1, 1],
-});
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+/**
+ * Workgroup size for the per-region stride loop. Each workgroup
+ * handles one region; threads in the workgroup walk the region's
+ * words in WORKGROUP_SIZE-stride'd slots, so a region with N words
+ * takes ceil(N / WORKGROUP_SIZE) iterations per thread.
+ */
+export const BUFFER_INTRA_COPY_WORKGROUP_SIZE = 64;
+
+/**
+ * One copy job: source and destination regions inside the same buffer.
+ * Offsets and lengths are in `u32` words (not bytes). The shader does
+ * not validate non-overlap — the caller is responsible.
+ */
+export const BUFFER_INTRA_COPY_REGION_STRUCT = WebGPUStruct.from({
+    src_offset: u32,
+    dst_offset: u32,
+    word_count: u32,
+}, "BufferIntraCopyRegion");
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('buffer', WebGPUArray.from(u32), true)
+    .addStorageBuffer('regions', WebGPUArray.from(BUFFER_INTRA_COPY_REGION_STRUCT), false);
+
+// One workgroup per region, dispatch over the regions list. Threads
+// stride-loop over the region's words. WebGPU rejects same-buffer
+// `copyBufferToBuffer` even with non-overlapping ranges, which is why
+// we go via a compute shader for intra-buffer relocation. A single
+// `read_write` binding sidesteps the read+write-on-same-binding
+// resource conflict that would prevent binding the buffer twice with
+// different access modes.
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${BUFFER_INTRA_COPY_WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    let region = regions[wg_id.x];
+
+    var i: u32 = local_id;
+    loop {
+        if(i >= region.word_count) { break; }
+
+        buffer[region.dst_offset + i] = buffer[region.src_offset + i];
+
+        i = i + ${BUFFER_INTRA_COPY_WORKGROUP_SIZE}u;
+    }
+}
+`);
+
+/**
+ * Compute-shader memcpy across regions of a single storage buffer.
+ * One workgroup per region; threads in the workgroup stride-loop
+ * over the region's `word_count` u32 words.
+ *
+ * Why a compute shader rather than `copyBufferToBuffer`: WebGPU
+ * forbids `copyBufferToBuffer` from passing the same buffer as both
+ * source and destination, even when the byte ranges don't overlap —
+ * the validation check is buffer-identity, not range-overlap. The
+ * compute path sidesteps that by binding the buffer once as
+ * `read_write` storage and reading + writing through the same
+ * binding.
+ *
+ * Caller responsibility: the regions table must list non-overlapping
+ * (src, dst) ranges. The shader does no overlap checks.
+ *
+ * Dispatch: one workgroup per entry in `regions`, i.e.
+ * `group_count_x = region_count`. Skip when `region_count === 0`.
+ */
+export const shader_buffer_intra_copy_regions = ComputeShader.from({
+    label: "Copy GPU Buffer/ Intra-buffer regions",
+    body,
+    resources,
+});

package/src/shade/renderer/deferred/shader_tonemap_HDR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR.js"],"names":[],"mappings":"AA2DA,6CAYG;4BA/DyB,0BAA0B"}
+{"version":3,"file":"shader_tonemap_HDR.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/deferred/shader_tonemap_HDR.js"],"names":[],"mappings":"AA8DA,6CAYG;4BAlEyB,0BAA0B"}

package/src/shade/renderer/deferred/shader_tonemap_HDR.js

@@ -16,9 +16,12 @@ const SETTINGS_STRUCT = WebGPUStruct.from({
 });
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. exposure stays
+// bound - it is computed on the GPU, so there is no CPU value to write.
+resources.setImmediate("settings", SETTINGS_STRUCT);
 resources.createGroup()
     .addTexture("input_color", "float")
-    .addUniform("settings", SETTINGS_STRUCT)
     .addUniform("exposure", F32_CONTAINER_STRUCT)
 
 const body = CodeChunk.from(

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.d.ts

@@ -42,12 +42,12 @@ export class GPUDynamicMeshResidency {
      */
     create_bindings(encoder: ShadeGPUCommandContext, mesh: DynamicMesh, camera: GPUBuffer): any[];
     /**
-     * @param {GPURenderPassEncoder} render_pass
+     * @param {ShadeGPURenderPassEncoder} render_pass
      * @param {GraphicsContext} graphics
      * @param {RenderPipelineDescriptor} pipeline
      * @param {Array} bindings from {@link create_bindings}
      */
-    draw(render_pass: GPURenderPassEncoder, graphics: GraphicsContext, pipeline: RenderPipelineDescriptor, bindings: any[]): void;
+    draw(render_pass: ShadeGPURenderPassEncoder, graphics: GraphicsContext, pipeline: RenderPipelineDescriptor, bindings: any[]): void;
     destroy(): void;
     #private;
 }

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDynamicMeshResidency.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidency.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAuBI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,kCAJW,YAAY,sBACZ,MAAM,WACN,WAAW,QAoCrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8FAYC;IAED;;;;;OAKG;IACH,8HAIC;IAED,gBAcC;;CACJ"}
+{"version":3,"file":"GPUDynamicMeshResidency.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidency.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAuBI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,kCAJW,YAAY,sBACZ,MAAM,WACN,WAAW,QAoCrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8FAYC;IAED;;;;;OAKG;IACH,mIAIC;IAED,gBAcC;;CACJ"}

package/src/shade/renderer/dynamic/GPUDynamicMeshResidency.js

@@ -1,167 +1,167 @@
-import { round_up } from "../../../core/math/round_up.js";
-import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
-
-/**
- * Growth factor for the vertex and index buffers.
- *
- * Dynamic geometry changes size constantly — a trail lengthens as it is emitted and shortens as it
- * expires — so buffers are grown with headroom and never shrunk. Sizing exactly would mean
- * reallocating on almost every frame for content whose whole purpose is to change.
- *
- * @type {number}
- */
-const GROWTH_FACTOR = 1.5;
-
-/**
- * Storage buffers are bound by size, and a binding's size has to be a multiple of 4 — so a grown
- * capacity is rounded up rather than taken as the growth factor leaves it. Without this, a buffer
- * whose contents happen to land on the wrong number of bytes is rejected at bind time: 36 bytes of
- * indices grown by 1.5 gives 54, which is not a legal binding size.
- *
- * @type {number}
- */
-const BUFFER_SIZE_ALIGNMENT = 4;
-
-/**
- * What one {@link Geometry} owns on the GPU while it is being drawn by the dynamic path.
- *
- * Keyed on the geometry rather than on the mesh or on batch membership, so an effect that is hidden
- * for a frame, or removed and re-added, does not pay for its buffers again.
- */
-export class GPUDynamicMeshResidency {
-    /**
-     * Interleaved vertices, laid out per {@link DYNAMIC_MESH_VERTEX_STRIDE}.
-     *
-     * @type {GPUBuffer|null}
-     */
-    #vertices = null;
-
-    /**
-     * @type {number} capacity in bytes
-     */
-    #vertices_capacity = 0;
-
-    /**
-     * @type {GPUBuffer|null}
-     */
-    #indices = null;
-
-    /**
-     * @type {number} capacity in bytes
-     */
-    #indices_capacity = 0;
-
-    /**
-     * How many indices to draw — the count from the last upload, not the buffer's capacity.
-     *
-     * @type {number}
-     */
-    index_count = 0;
-
-    /**
-     * The {@link Geometry.version} this was uploaded from.
-     *
-     * @type {number}
-     */
-    version = -1;
-
-    /**
-     * @param {GPUDevice} device
-     * @param {Float32Array} staging interleaved vertices, valid up to `vertex_float_count`
-     * @param {number} vertex_float_count
-     * @param {Uint32Array} indices
-     */
-    write(device, staging, vertex_float_count, indices) {
-        const vertex_bytes = vertex_float_count * 4;
-        const index_bytes = indices.length * 4;
-
-        if (this.#vertices_capacity < vertex_bytes) {
-            if (this.#vertices !== null) {
-                this.#vertices.destroy();
-            }
-
-            this.#vertices_capacity = round_up(Math.ceil(vertex_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
-            this.#vertices = device.createBuffer({
-                size: this.#vertices_capacity,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                label: "DynamicMesh/vertices",
-            });
-        }
-
-        if (this.#indices_capacity < index_bytes) {
-            if (this.#indices !== null) {
-                this.#indices.destroy();
-            }
-
-            this.#indices_capacity = round_up(Math.ceil(index_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
-            this.#indices = device.createBuffer({
-                size: this.#indices_capacity,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                label: "DynamicMesh/indices",
-            });
-        }
-
-        device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);
-        device.queue.writeBuffer(this.#indices, 0, indices.buffer, indices.byteOffset, index_bytes);
-
-        this.index_count = indices.length;
-    }
-
-    /**
-     * Build this mesh's bind groups for the frame.
-     *
-     * **Must be called before the render pass is opened.** The per-draw constants are staged through
-     * a transient buffer, and staging records a copy onto the command encoder — which WebGPU locks
-     * for as long as a pass is open on it. Doing this lazily at draw time is the obvious shape and
-     * an invalid one.
-     *
-     * The constants are transient because one mesh is one draw and its transform and colour are
-     * expected to differ every frame, so there is nothing worth keeping between them.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {DynamicMesh} mesh
-     * @param {GPUBuffer} camera
-     * @returns {Array} bind groups, for {@link draw}
-     */
-    create_bindings(encoder, mesh, camera) {
-        const draw_buffer = encoder.allocateTransientValueBuffer(DYNAMIC_MESH_DRAW_STRUCT, {
-            model: mesh.transform_global,
-            color: mesh.color,
-        });
-
-        return DYNAMIC_MESH_RESOURCES.generateBindings({
-            camera,
-            draw: draw_buffer,
-            vertices: this.#vertices,
-            indices: this.#indices,
-        }, encoder);
-    }
-
-    /**
-     * @param {GPURenderPassEncoder} render_pass
-     * @param {GraphicsContext} graphics
-     * @param {RenderPipelineDescriptor} pipeline
-     * @param {Array} bindings from {@link create_bindings}
-     */
-    draw(render_pass, graphics, pipeline, bindings) {
-        graphics.setPipelineBindings(render_pass, pipeline, bindings);
-
-        render_pass.draw(this.index_count);
-    }
-
-    destroy() {
-        if (this.#vertices !== null) {
-            this.#vertices.destroy();
-            this.#vertices = null;
-        }
-
-        if (this.#indices !== null) {
-            this.#indices.destroy();
-            this.#indices = null;
-        }
-
-        this.#vertices_capacity = 0;
-        this.#indices_capacity = 0;
-        this.index_count = 0;
-    }
-}
+import { round_up } from "../../../core/math/round_up.js";
+import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
+
+/**
+ * Growth factor for the vertex and index buffers.
+ *
+ * Dynamic geometry changes size constantly — a trail lengthens as it is emitted and shortens as it
+ * expires — so buffers are grown with headroom and never shrunk. Sizing exactly would mean
+ * reallocating on almost every frame for content whose whole purpose is to change.
+ *
+ * @type {number}
+ */
+const GROWTH_FACTOR = 1.5;
+
+/**
+ * Storage buffers are bound by size, and a binding's size has to be a multiple of 4 — so a grown
+ * capacity is rounded up rather than taken as the growth factor leaves it. Without this, a buffer
+ * whose contents happen to land on the wrong number of bytes is rejected at bind time: 36 bytes of
+ * indices grown by 1.5 gives 54, which is not a legal binding size.
+ *
+ * @type {number}
+ */
+const BUFFER_SIZE_ALIGNMENT = 4;
+
+/**
+ * What one {@link Geometry} owns on the GPU while it is being drawn by the dynamic path.
+ *
+ * Keyed on the geometry rather than on the mesh or on batch membership, so an effect that is hidden
+ * for a frame, or removed and re-added, does not pay for its buffers again.
+ */
+export class GPUDynamicMeshResidency {
+    /**
+     * Interleaved vertices, laid out per {@link DYNAMIC_MESH_VERTEX_STRIDE}.
+     *
+     * @type {GPUBuffer|null}
+     */
+    #vertices = null;
+
+    /**
+     * @type {number} capacity in bytes
+     */
+    #vertices_capacity = 0;
+
+    /**
+     * @type {GPUBuffer|null}
+     */
+    #indices = null;
+
+    /**
+     * @type {number} capacity in bytes
+     */
+    #indices_capacity = 0;
+
+    /**
+     * How many indices to draw — the count from the last upload, not the buffer's capacity.
+     *
+     * @type {number}
+     */
+    index_count = 0;
+
+    /**
+     * The {@link Geometry.version} this was uploaded from.
+     *
+     * @type {number}
+     */
+    version = -1;
+
+    /**
+     * @param {GPUDevice} device
+     * @param {Float32Array} staging interleaved vertices, valid up to `vertex_float_count`
+     * @param {number} vertex_float_count
+     * @param {Uint32Array} indices
+     */
+    write(device, staging, vertex_float_count, indices) {
+        const vertex_bytes = vertex_float_count * 4;
+        const index_bytes = indices.length * 4;
+
+        if (this.#vertices_capacity < vertex_bytes) {
+            if (this.#vertices !== null) {
+                this.#vertices.destroy();
+            }
+
+            this.#vertices_capacity = round_up(Math.ceil(vertex_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
+            this.#vertices = device.createBuffer({
+                size: this.#vertices_capacity,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                label: "DynamicMesh/vertices",
+            });
+        }
+
+        if (this.#indices_capacity < index_bytes) {
+            if (this.#indices !== null) {
+                this.#indices.destroy();
+            }
+
+            this.#indices_capacity = round_up(Math.ceil(index_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
+            this.#indices = device.createBuffer({
+                size: this.#indices_capacity,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                label: "DynamicMesh/indices",
+            });
+        }
+
+        device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);
+        device.queue.writeBuffer(this.#indices, 0, indices.buffer, indices.byteOffset, index_bytes);
+
+        this.index_count = indices.length;
+    }
+
+    /**
+     * Build this mesh's bind groups for the frame.
+     *
+     * **Must be called before the render pass is opened.** The per-draw constants are staged through
+     * a transient buffer, and staging records a copy onto the command encoder — which WebGPU locks
+     * for as long as a pass is open on it. Doing this lazily at draw time is the obvious shape and
+     * an invalid one.
+     *
+     * The constants are transient because one mesh is one draw and its transform and colour are
+     * expected to differ every frame, so there is nothing worth keeping between them.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {DynamicMesh} mesh
+     * @param {GPUBuffer} camera
+     * @returns {Array} bind groups, for {@link draw}
+     */
+    create_bindings(encoder, mesh, camera) {
+        const draw_buffer = encoder.allocateTransientValueBuffer(DYNAMIC_MESH_DRAW_STRUCT, {
+            model: mesh.transform_global,
+            color: mesh.color,
+        });
+
+        return DYNAMIC_MESH_RESOURCES.generateBindings({
+            camera,
+            draw: draw_buffer,
+            vertices: this.#vertices,
+            indices: this.#indices,
+        }, encoder);
+    }
+
+    /**
+     * @param {ShadeGPURenderPassEncoder} render_pass
+     * @param {GraphicsContext} graphics
+     * @param {RenderPipelineDescriptor} pipeline
+     * @param {Array} bindings from {@link create_bindings}
+     */
+    draw(render_pass, graphics, pipeline, bindings) {
+        graphics.setPipelineBindings(render_pass, pipeline, bindings);
+
+        render_pass.draw(this.index_count);
+    }
+
+    destroy() {
+        if (this.#vertices !== null) {
+            this.#vertices.destroy();
+            this.#vertices = null;
+        }
+
+        if (this.#indices !== null) {
+            this.#indices.destroy();
+            this.#indices = null;
+        }
+
+        this.#vertices_capacity = 0;
+        this.#indices_capacity = 0;
+        this.index_count = 0;
+    }
+}

package/src/shade/renderer/dynamic/shader_dynamic_mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh.js"],"names":[],"mappings":"AA4GA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAiCpC;AAlJD;;;GAGG;AACH,oDAY6B;AAoI7B;;;;GAIG;AACH,qCAFU,2BAA2B,CAEW;yCAvKP,8DAA8D;6BAO1E,gCAAgC;4CAJjB,mDAAmD"}
+{"version":3,"file":"shader_dynamic_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAgCpC;AAzJD;;;GAGG;AACH,oDAY6B;AA2I7B;;;;GAIG;AACH,qCAFU,2BAA2B,CAEW;yCA9KP,8DAA8D;6BAO1E,gCAAgC;4CAJjB,mDAAmD"}