@woosh/meep-engine 3.14.0 → 3.14.2

package/src/shade/device/graph/TextureResourceDescriptor.js

@@ -1,156 +1,161 @@
-import { assert } from "../../../core/assert.js";
-import { array_copy } from "../../../core/collection/array/array_copy.js";
-import { combine_hash } from "../../../core/collection/array/combine_hash.js";
-import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
-import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
-import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
-import {
-    ResourceDescriptor
-} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
-import { compute_max_mip_count } from "../../util/compute_max_mip_count.js";
-import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
-
-/**
- * **Vestigial.** Nothing branches on it — see {@link TextureResourceDescriptor.resolution_domain}.
- *
- * @enum {number}
- */
-export const TextureResolutionDomain = {
-    Absolute: 0,
-    PresentationRelative: 1
-}
-
-export class TextureResourceDescriptor extends ResourceDescriptor {
-    /**
-     * **Vestigial. Do not read this to decide how to interpret {@link resolution}.**
-     *
-     * No code branches on it; only {@link hash} folds it in. {@link from} stores whatever
-     * resolution it is given without touching this field, and every caller gives it pixels — so a
-     * descriptor's resolution is absolute pixels whatever this says, including on the default
-     * `PresentationRelative` that {@link from} leaves in place.
-     *
-     * @type {TextureResolutionDomain|number}
-     */
-    resolution_domain = TextureResolutionDomain.PresentationRelative;
-
-    // TODO use Uint32 instead
-    resolution = new Float64Array([1, 1, 1]);
-    sampleCount = 1;
-
-    mipLevelCount = 1;
-
-    /**
-     *
-     * @type {GPUTextureDimension|string}
-     */
-    dimension = "2d"
-
-    /**
-     * @type {string|GPUTextureFormat}
-     */
-    format = "rgba8unorm";
-
-    /**
-     * @type {number|GPUTextureUsageFlags}
-     */
-    usage = GPUTextureUsage.TEXTURE_BINDING;
-
-    /**
-     *
-     * @param {number[]} resolution
-     * @param {GPUTextureDimension|string} [dimension]
-     * @param {GPUTextureFormat|string} format
-     * @param {GPUTextureUsageFlags|number} [usage]
-     * @param {boolean} [enableMips]
-     * @returns {TextureResourceDescriptor}
-     */
-    static from({
-                    resolution,
-                    dimension = "2d",
-                    format,
-                    usage = GPUTextureUsage.TEXTURE_BINDING,
-                    enableMips = false
-                }) {
-
-        assert.isString(format, 'format');
-        assert.defined(resolution, 'resolution');
-        assert.isArrayLike(resolution, 'resolution');
-        assert.isBoolean(enableMips, 'enableMips');
-
-        const r = new TextureResourceDescriptor();
-
-        array_copy(resolution, 0, r.resolution, 0, Math.min(r.resolution.length, resolution.length));
-        r.dimension = dimension;
-        r.format = format;
-        r.usage = usage;
-
-        if (enableMips === true) {
-
-            r.mipLevelCount = compute_max_mip_count(resolution[0], resolution[1]);
-
-        }
-
-        return r;
-
-    }
-
-    /**
-     *
-     * @param {GPUTexture} texture
-     * @returns {TextureResourceDescriptor}
-     */
-    static fromTexture(texture) {
-        const r = new TextureResourceDescriptor();
-
-        r.format = texture.format;
-        r.dimension = texture.dimension;
-
-        r.usage = texture.usage;
-        r.sampleCount = texture.sampleCount;
-        r.resolution_domain = TextureResolutionDomain.Absolute;
-
-        r.resolution[0] = texture.width;
-        r.resolution[1] = texture.height;
-        r.resolution[2] = texture.depthOrArrayLayers;
-
-
-        r.mipLevelCount = texture.mipLevelCount;
-
-        return r;
-    }
-
-    get type() {
-        return "texture";
-    }
-
-    hash() {
-        return combine_hash(
-            this.resolution_domain,
-            this.mipLevelCount,
-            computeHashFloatArray(this.resolution),
-            this.sampleCount,
-            this.usage,
-            computeStringHash(this.format)
-        );
-    }
-
-    /**
-     *
-     * @param {TextureResourceDescriptor} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return isArrayEqualStrict(this.resolution, other.resolution)
-            && this.mipLevelCount === other.mipLevelCount
-            && this.resolution_domain === other.resolution_domain
-            && this.sampleCount === other.sampleCount
-            && this.dimension === other.dimension
-            && this.format === other.format
-            && this.usage === other.usage
-            ;
-    }
-
-    toString() {
-        return `Texture{ resolution = [${this.resolution.join(",")}], mipLevelCount = ${this.mipLevelCount}, dimension = ${this.dimension}, format = ${this.format}, usage = ${decode_bitmask_enum(this.usage, GPUTextureUsage).join(' | ')}, sampleCount = ${this.sampleCount} }`;
-    }
+import { assert } from "../../../core/assert.js";
+import { array_copy } from "../../../core/collection/array/array_copy.js";
+import { combine_hash } from "../../../core/collection/array/combine_hash.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import {
+    ResourceDescriptor
+} from "../../../engine/graphics/render/frame_graph/resource/ResourceDescriptor.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
+import { decode_bitmask_enum } from "../decode_bitmask_enum.js";
+import { GPUTextureUsage } from "../../descriptor/GPUTextureUsage.js";
+
+/**
+ * **Vestigial.** Nothing branches on it — see {@link TextureResourceDescriptor.resolution_domain}.
+ *
+ * @enum {number}
+ */
+export const TextureResolutionDomain = {
+    Absolute: 0,
+    PresentationRelative: 1
+}
+
+export class TextureResourceDescriptor extends ResourceDescriptor {
+    /**
+     * **Vestigial. Do not read this to decide how to interpret {@link resolution}.**
+     *
+     * No code branches on it; only {@link hash} folds it in. {@link from} stores whatever
+     * resolution it is given without touching this field, and every caller gives it pixels — so a
+     * descriptor's resolution is absolute pixels whatever this says, including on the default
+     * `PresentationRelative` that {@link from} leaves in place.
+     *
+     * @type {TextureResolutionDomain|number}
+     */
+    resolution_domain = TextureResolutionDomain.PresentationRelative;
+
+    // TODO use Uint32 instead
+    resolution = new Float64Array([1, 1, 1]);
+    sampleCount = 1;
+
+    mipLevelCount = 1;
+
+    /**
+     *
+     * @type {GPUTextureDimension|string}
+     */
+    dimension = "2d"
+
+    /**
+     * @type {string|GPUTextureFormat}
+     */
+    format = "rgba8unorm";
+
+    /**
+     * @type {number|GPUTextureUsageFlags}
+     */
+    usage = GPUTextureUsage.TEXTURE_BINDING;
+
+    /**
+     *
+     * @param {number[]} resolution
+     * @param {GPUTextureDimension|string} [dimension]
+     * @param {GPUTextureFormat|string} format
+     * @param {GPUTextureUsageFlags|number} [usage]
+     * @param {boolean} [enableMips]
+     * @returns {TextureResourceDescriptor}
+     */
+    static from({
+                    resolution,
+                    dimension = "2d",
+                    format,
+                    usage = GPUTextureUsage.TEXTURE_BINDING,
+                    enableMips = false
+                }) {
+
+        assert.isString(format, 'format');
+        assert.defined(resolution, 'resolution');
+        assert.isArrayLike(resolution, 'resolution');
+        assert.isBoolean(enableMips, 'enableMips');
+
+        const r = new TextureResourceDescriptor();
+
+        array_copy(resolution, 0, r.resolution, 0, Math.min(r.resolution.length, resolution.length));
+        r.dimension = dimension;
+        r.format = format;
+        r.usage = usage;
+
+        if (enableMips === true) {
+
+            // `r.resolution` rather than the argument: it has already been padded to three, so a
+            // caller that gave two axes reads as depth 1 instead of `undefined`
+            r.mipLevelCount = texture_mip_level_count(
+                r.resolution[0], r.resolution[1], r.resolution[2], r.dimension
+            );
+
+        }
+
+        return r;
+
+    }
+
+    /**
+     *
+     * @param {GPUTexture} texture
+     * @returns {TextureResourceDescriptor}
+     */
+    static fromTexture(texture) {
+        const r = new TextureResourceDescriptor();
+
+        r.format = texture.format;
+        r.dimension = texture.dimension;
+
+        r.usage = texture.usage;
+        r.sampleCount = texture.sampleCount;
+        r.resolution_domain = TextureResolutionDomain.Absolute;
+
+        r.resolution[0] = texture.width;
+        r.resolution[1] = texture.height;
+        r.resolution[2] = texture.depthOrArrayLayers;
+
+
+        r.mipLevelCount = texture.mipLevelCount;
+
+        return r;
+    }
+
+    get type() {
+        return "texture";
+    }
+
+    hash() {
+        return combine_hash(
+            this.resolution_domain,
+            this.mipLevelCount,
+            computeHashFloatArray(this.resolution),
+            this.sampleCount,
+            this.usage,
+            computeStringHash(this.format)
+        );
+    }
+
+    /**
+     *
+     * @param {TextureResourceDescriptor} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return isArrayEqualStrict(this.resolution, other.resolution)
+            && this.mipLevelCount === other.mipLevelCount
+            && this.resolution_domain === other.resolution_domain
+            && this.sampleCount === other.sampleCount
+            && this.dimension === other.dimension
+            && this.format === other.format
+            && this.usage === other.usage
+            ;
+    }
+
+    toString() {
+        return `Texture{ resolution = [${this.resolution.join(",")}], mipLevelCount = ${this.mipLevelCount}, dimension = ${this.dimension}, format = ${this.format}, usage = ${decode_bitmask_enum(this.usage, GPUTextureUsage).join(' | ')}, sampleCount = ${this.sampleCount} }`;
+    }
 }

package/src/shade/device/mock/SoftwareGPUQueue.d.ts

@@ -19,10 +19,17 @@ export class SoftwareGPUQueue implements GPUQueue {
      */
     writeBuffer(buffer: GPUBuffer, bufferOffset: number, data: BufferSource, dataOffset?: number, size?: number): void;
     /**
-     * 2D single-layer subset of {@link GPUQueue#writeTexture}: copies rows
-     * from a BufferSource into the destination mip's lazily-allocated
-     * storage. `dataLayout.offset` is in bytes (spec), `bytesPerRow`
-     * defaults to a tightly-packed row.
+     * Emulates {@link GPUQueue#writeTexture}: copies rows of texel blocks from a BufferSource into
+     * the destination mip's lazily-allocated storage.
+     *
+     * The same operation as {@link SoftwareGPUCommandEncoder#copyBufferToTexture} with the bytes
+     * supplied inline rather than through a `GPUBuffer`, and it runs on the same two functions —
+     * which is what makes it block-aware, multi-layer and `rowsPerImage`-honouring rather than the
+     * 2D single-layer `bytes_per_texel` subset it used to be. A BC7 write is not a special case here;
+     * it is the same row loop over a row that happens to be four texels tall.
+     *
+     * `dataLayout.offset` is in bytes (spec), `bytesPerRow` defaults to a tightly packed row of
+     * blocks.
      *
      * @param {GPUTexelCopyTextureInfo} destination
      * @param {BufferSource} data

package/src/shade/device/mock/SoftwareGPUQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUQueue.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUQueue.js"],"names":[],"mappings":"AA2DA;;;GAGG;AACH,yCAFgB,QAAQ;IAYpB;;OAEG;IACH,uCAEC;IAoDD;;;;;;;;;OASG;IACH,6CALW,MAAM,QACN,YAAY,eACZ,MAAM,SACN,MAAM,QA6ChB;IAED;;;;;;;;;;OAUG;IACH,yDAJW,YAAY,iEAiDtB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAmEC;IAED;;;OAGG;IACH,uBAFW,0BAA0B,QA0BpC;IAED;;;;;;OAMG;IACH,uBAFa,QAAQ,SAAS,CAAC,CAI9B;;CACJ"}
+{"version":3,"file":"SoftwareGPUQueue.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUQueue.js"],"names":[],"mappings":"AA4DA;;;GAGG;AACH,yCAFgB,QAAQ;IAYpB;;OAEG;IACH,uCAEC;IAoDD;;;;;;;;;OASG;IACH,6CALW,MAAM,QACN,YAAY,eACZ,MAAM,SACN,MAAM,QA6ChB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yDAJW,YAAY,iEAmCtB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAmEC;IAED;;;OAGG;IACH,uBAFW,0BAA0B,QA0BpC;IAED;;;;;;OAMG;IACH,uBAFa,QAAQ,SAAS,CAAC,CAI9B;;CACJ"}

package/src/shade/device/mock/SoftwareGPUQueue.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { array_buffer_copy } from "../../../core/collection/array/typed/array_buffer_copy.js";
+import { texture_copy_execute, texture_copy_refusal } from "./texture_copy.js";
 import { SoftwareGPUValidationError } from "./SoftwareGPUError.js";
 
 /**
@@ -184,10 +185,17 @@ export class SoftwareGPUQueue {
     }
 
     /**
-     * 2D single-layer subset of {@link GPUQueue#writeTexture}: copies rows
-     * from a BufferSource into the destination mip's lazily-allocated
-     * storage. `dataLayout.offset` is in bytes (spec), `bytesPerRow`
-     * defaults to a tightly-packed row.
+     * Emulates {@link GPUQueue#writeTexture}: copies rows of texel blocks from a BufferSource into
+     * the destination mip's lazily-allocated storage.
+     *
+     * The same operation as {@link SoftwareGPUCommandEncoder#copyBufferToTexture} with the bytes
+     * supplied inline rather than through a `GPUBuffer`, and it runs on the same two functions —
+     * which is what makes it block-aware, multi-layer and `rowsPerImage`-honouring rather than the
+     * 2D single-layer `bytes_per_texel` subset it used to be. A BC7 write is not a special case here;
+     * it is the same row loop over a row that happens to be four texels tall.
+     *
+     * `dataLayout.offset` is in bytes (spec), `bytesPerRow` defaults to a tightly packed row of
+     * blocks.
      *
      * @param {GPUTexelCopyTextureInfo} destination
      * @param {BufferSource} data
@@ -199,46 +207,32 @@ export class SoftwareGPUQueue {
 
         assert.equal(texture.isSoftwareGPUTexture, true, 'texture.isSoftwareGPUTexture !== true');
 
-        const texture_refusal = texture_write_refusal(texture);
+        /*
+         The destination half of a copy's validation, which is a superset of what this used to check
+         for itself: the same invalid/destroyed/COPY_DST refusals, and additionally a format WebGPU
+         forbids copies of, a mip outside the chain, and a region past the edge of it.
+        */
+        const refusal = texture_copy_refusal({ texture_destination: destination, size });
 
-        if (texture_refusal !== null) {
-            this.#device.generate_error(new SoftwareGPUValidationError(`writeTexture: ${texture_refusal}`));
+        if (refusal !== null) {
+            this.#device.generate_error(new SoftwareGPUValidationError(`writeTexture: ${refusal}`));
 
             return;
         }
 
-        const width = size.width ?? size[0] ?? 1;
-        const height = size.height ?? size[1] ?? 1;
-        const depth = size.depthOrArrayLayers ?? size[2] ?? 1;
-
-        assert.equal(depth, 1, 'only single-layer writes are emulated');
-
-        const mip = destination.mipLevel ?? 0;
-        const origin_x = destination.origin?.x ?? destination.origin?.[0] ?? 0;
-        const origin_y = destination.origin?.y ?? destination.origin?.[1] ?? 0;
-
-        const bytes_per_texel = texture.bytes_per_texel;
-
         const source = normalize_buffer_source(data);
 
-        const source_offset = source.byteOffset + (dataLayout?.offset ?? 0);
-        const bytes_per_row = dataLayout?.bytesPerRow ?? width * bytes_per_texel;
-
-        const mip_data = texture.get_mip_data(mip);
-        const dst_stride = texture.mip_width(mip) * bytes_per_texel;
-
-        assert.lessThanOrEqual(origin_x + width, texture.mip_width(mip), 'write exceeds mip width');
-        assert.lessThanOrEqual(origin_y + height, texture.mip_height(mip), 'write exceeds mip height');
-
-        for (let row = 0; row < height; row++) {
-            array_buffer_copy(
-                source.buffer,
-                source_offset + row * bytes_per_row,
-                mip_data,
-                (origin_y + row) * dst_stride + origin_x * bytes_per_texel,
-                width * bytes_per_texel
-            );
-        }
+        texture_copy_execute({
+            buffer_source: {
+                // the inline bytes, in the shape the buffer endpoint reads
+                buffer: { data: source.buffer },
+                offset: source.byteOffset + (dataLayout?.offset ?? 0),
+                bytesPerRow: dataLayout?.bytesPerRow,
+                rowsPerImage: dataLayout?.rowsPerImage,
+            },
+            texture_destination: destination,
+            size,
+        });
     }
 
     /**

package/src/shade/device/mock/SoftwareGPUTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IA+CtB;;;;;OAKG;IACH,kDAFa,kBAAkB,CAI9B;IA/BD;;;OAGG;IACH,sDAFW,OAAO,EAmBjB;IAtCD;;;;;;OAMG;IACH,uBAEC;IAoBG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IAatD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;OAGG;IACH,kEAMC;IAED;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCAzMqC,4BAA4B"}
+{"version":3,"file":"SoftwareGPUTexture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUTexture.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,yEAFgB,UAAU;IA+CtB;;;;;OAKG;IACH,kDAFa,kBAAkB,CAI9B;IA/BD;;;OAGG;IACH,sDAFW,OAAO,EAmBjB;IAtCD;;;;;;OAMG;IACH,uBAEC;IAoBG,WAAuC;IACvC,YAAyC;IACzC,wBAAiE;IAEjE,YAA+B;IAC/B,eAA6C;IAC7C,WAA6B;IAC7B,iBAA8C;IAC9C,mBAAkD;IAatD;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,wCAEC;IAED;;;;;;;;;OASG;IACH,8BAUC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,WAAW,CAgBvB;IAED;;;OAGG;IACH,kEAMC;IAED;;;OAGG;IACH,gBAOC;IAGL;;;OAGG;IACH,+BAFU,OAAO,CAEgC;;CANhD;sCA1MqC,4BAA4B"}

package/src/shade/device/mock/SoftwareGPUTexture.js

@@ -1,8 +1,11 @@
 import {
     gpu_texture_format_info,
+    gpu_texture_format_is_block_compressed,
+    gpu_texture_format_level_bytes,
     gpu_texture_format_row_bytes,
     gpu_texture_format_row_count
 } from "../../descriptor/texture/format/gpu_texture_format_info.js";
+import { texture_mip_size } from "../../util/texture_mip_extent.js";
 import { SoftwareGPUObjectBase } from "./SoftwareGPUObjectBase.js";
 import { SoftwareGPUTextureView } from "./SoftwareGPUTextureView.js";
 
@@ -100,7 +103,7 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
     get bytes_per_texel() {
         const info = this.format_info;
 
-        if (info.block_width !== 1 || info.block_height !== 1) {
+        if (gpu_texture_format_is_block_compressed(this.format)) {
             throw new Error(
                 `bytes_per_texel: '${this.format}' is block-compressed (${info.block_width}x${info.block_height}), use row_bytes instead`
             );
@@ -114,7 +117,7 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
      * @returns {number}
      */
     mip_width(mip) {
-        return Math.max(1, this.width >> mip);
+        return texture_mip_size(this.width, mip);
     }
 
     /**
@@ -122,7 +125,7 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
      * @returns {number}
      */
     mip_height(mip) {
-        return Math.max(1, this.height >> mip);
+        return texture_mip_size(this.height, mip);
     }
 
     /**
@@ -154,7 +157,8 @@ export class SoftwareGPUTexture extends SoftwareGPUObjectBase {
      * @returns {number}
      */
     layer_bytes(mip = 0) {
-        return this.row_bytes(mip) * this.row_count(mip);
+        // one layer, hence the 1 — get_mip_data multiplies by depthOrArrayLayers itself
+        return gpu_texture_format_level_bytes(this.format, this.mip_width(mip), this.mip_height(mip), 1);
     }
 
     /**

package/src/shade/device/timing/profile/frame_graph_extract_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frame_graph_extract_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/frame_graph_extract_topology.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;GAgBG;AACH,iEALa,kBAAkB,CAkH9B;mCArKM,yBAAyB"}
+{"version":3,"file":"frame_graph_extract_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/frame_graph_extract_topology.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;;GAgBG;AACH,iEALa,kBAAkB,CAkH9B;mCA3JM,yBAAyB"}