@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/light/environment/shader_downsample_environment_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_downsample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_downsample_environment_map.js"],"names":[],"mappings":"AAmGA,8DAII;8BAhG0B,+BAA+B"}
+{"version":3,"file":"shader_downsample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_downsample_environment_map.js"],"names":[],"mappings":"AAuGA,8DAII;8BApG0B,+BAA+B"}

package/src/shade/renderer/light/environment/shader_downsample_environment_map.js

@@ -64,11 +64,15 @@ fn main(
         let texel_y = first.y + f32(y);
         let overlap_y = min(texel_y + 1.0, lo.y + span) - max(texel_y, lo.y);
 
+        if (overlap_y <= 0.0) {
+            continue;
+        }
+
         for (var x = 0u; x < 4u; x++) {
             let texel_x = first.x + f32(x);
             let overlap_x = min(texel_x + 1.0, lo.x + span) - max(texel_x, lo.x);
 
-            if (overlap_x <= 0.0 || overlap_y <= 0.0) {
+            if (overlap_x <= 0.0) {
                 continue;
             }
 

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#306@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#308@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts

@@ -45,7 +45,7 @@ export class GPUResidentMaterialContext {
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
      * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
-     * version moves, or what a card capture traces, so the check rides on walks that already happen.
+     * version moves, or what a surface bake traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgIA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA9vBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAlB5C,oCAAoC;AAYtE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}
+{"version":3,"file":"GPUResidentMaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/GPUResidentMaterialContext.js"],"names":[],"mappings":"AAgHA;IAqKI;;;;OAIG;IACH,yCAFW,eAAe,EAkDzB;IA9LD;;;OAGG;IACH,6BAEC;IAQD;;;OAGG;IACH,kCAEC;IAQD;;;OAGG;IACH,yCAEC;IAED;;;OAGG;IACH,kCAIC;IAmED;;;;;OAKG;IACH,0BAEC;IAOD;;;;;;OAMG;IACH,8BAEC;IAsJD;;;;;;;;;OASG;IACH,0BAHW,aAAa,GACX,YAAY,CAmBxB;IAgBD;;;;OAIG;IACH,wBAHW,YAAY,GACV,WAAW,CAIvB;IAGD,uBA0DC;IAuFD,wBA8EC;IAED;;;;OAIG;IACH,sCAFW,eAAe,QAUzB;IAoCD;;;;OAIG;IACH,eAGC;IAED;;;OAGG;IACH,eAGC;IAGD,gBAIC;;CACJ;8BA7uBY,OAAO,0BAA0B,EAAE,eAAe;8BAClD,OAAO,gCAAgC,EAAE,eAAe;2BACxD,OAAO,+BAA+B,EAAE,YAAY;4BACpD,OAAO,qBAAqB,EAAE,aAAa;oCAC3C,OAAO,6BAA6B,EAAE,qBAAqB;kCAC3D,OAAO,qCAAqC,EAAE,mBAAmB;kCAnB5C,oCAAoC;AAatE;;;;;;;GAOG;AAEH;IACI,WAAM;IAEN;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAEZ;;OAEG;IACH,QAFU,qBAAqB,CAExB;IAEP;;OAEG;IACH,gBAFU,WAAW,CAEP;IAEd;;OAEG;IACH,aAFU,WAAW,CAEV;IAEX;;;;OAIG;IACH,gBAFU,WAAW,GAAC,IAAI,CAEZ;IACd;;OAEG;IACH,kBAFU,WAAW,CAEL;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEe;CAClC;AAqBD;IACI,WAAO;IAEP;;OAEG;IACH,QAFU,YAAY,CAEf;CACV"}

package/src/shade/renderer/material/resident/GPUResidentMaterialContext.js

@@ -17,6 +17,7 @@ import { sampler_descriptor_pack } from "../../texture/format/sampler_descriptor
 import { WHITE_PIXEL_TEXTURE } from "../../texture/util/WHITE_PIXEL_TEXTURE.js";
 import { INDIRECT_MATERIAL_ARRAY_TYPE } from "./INDIRECT_MATERIAL_ARRAY_TYPE.js";
 import { INDIRECT_MATERIAL_STRUCT } from "./INDIRECT_MATERIAL_STRUCT.js";
+import { NEUTRAL_SURFACE } from "./NEUTRAL_SURFACE.js";
 import {
     RESIDENT_MATERIAL_TEXTURE_LAYER_SIZE,
     RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
@@ -109,23 +110,6 @@ class TextureInfo {
  */
 const MEDIA_TABLE_RECORDS_OFFSET = MEDIA_TABLE_STRUCT.fields.find(f => f.name === 'records').offset;
 
-/**
- * What a material that is not standard contributes to the ray passes: white, opaque, fully rough,
- * not metallic, not transmissive, not emissive — through the default textures its missing slots
- * already resolve to. Without it the fields the row is written from are absent and skipped into a
- * zeroed buffer, and an opacity of 0 is a surface the rays pass through: a terrain would stop
- * casting ray-traced shadows, and a bake would see it black. The same values a flat standard
- * material gives, which is what the terrain drew with before it had a template of its own.
- */
-const NEUTRAL_SURFACE = Object.freeze({
-    diffuse_color: Object.freeze([1, 1, 1, 1]),
-    roughness_factor: 1,
-    metallic_factor: 0,
-    transmission_factor: 0,
-    ior_factor: 1.5,
-    emissive_factor: Object.freeze([0, 0, 0]),
-});
-
 export class GPUResidentMaterialContext {
 
     /**
@@ -444,7 +428,7 @@ export class GPUResidentMaterialContext {
      * the same contract {@link GPUMaterialManager} restages by. A hit used to be final, so a factor
      * set after the first pack never reached the row. Every caller re-obtains what it needs before
      * {@link update} or {@link commit}: the scene's drawn list, the manager's materials whenever its
-     * version moves, or what a card capture traces, so the check rides on walks that already happen.
+     * version moves, or what a surface bake traces, so the check rides on walks that already happen.
      *
      * @param {ShadeMaterial} material
      * @returns {MaterialInfo}

package/src/shade/renderer/material/resident/NEUTRAL_SURFACE.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What a material that is not standard contributes to the ray passes: white, opaque, fully rough,
+ * not metallic, not transmissive, not emissive — through the default textures its missing slots
+ * already resolve to. Without it the fields the row is written from are absent and skipped into a
+ * zeroed buffer, and an opacity of 0 is a surface the rays pass through: a terrain would stop
+ * casting ray-traced shadows, and a bake would see it black. The same values a flat standard
+ * material gives, which is what the terrain drew with before it had a template of its own.
+ */
+export const NEUTRAL_SURFACE: Readonly<{
+    diffuse_color: readonly number[];
+    roughness_factor: 1;
+    metallic_factor: 0;
+    transmission_factor: 0;
+    ior_factor: 1.5;
+    emissive_factor: readonly number[];
+}>;
+//# sourceMappingURL=NEUTRAL_SURFACE.d.ts.map

package/src/shade/renderer/material/resident/NEUTRAL_SURFACE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NEUTRAL_SURFACE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/resident/NEUTRAL_SURFACE.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;;;;;;;GAOG"}

package/src/shade/renderer/material/resident/NEUTRAL_SURFACE.js

@@ -0,0 +1,16 @@
+/**
+ * What a material that is not standard contributes to the ray passes: white, opaque, fully rough,
+ * not metallic, not transmissive, not emissive — through the default textures its missing slots
+ * already resolve to. Without it the fields the row is written from are absent and skipped into a
+ * zeroed buffer, and an opacity of 0 is a surface the rays pass through: a terrain would stop
+ * casting ray-traced shadows, and a bake would see it black. The same values a flat standard
+ * material gives, which is what the terrain drew with before it had a template of its own.
+ */
+export const NEUTRAL_SURFACE = Object.freeze({
+    diffuse_color: Object.freeze([1, 1, 1, 1]),
+    roughness_factor: 1,
+    metallic_factor: 0,
+    transmission_factor: 0,
+    ior_factor: 1.5,
+    emissive_factor: Object.freeze([0, 0, 0]),
+});

package/src/shade/renderer/path_tracer/shader/INDIRECT_TEXTURE_FILTER.d.ts

@@ -4,7 +4,7 @@
  * or the other by the pipeline they are linked into.
  *
  * Whether the pass averages its reads is the pass's, so it is fixed per shader: `Stochastic`, the
- * default, for every pass that never sets it; `Exact` for the card capture, which stores each read.
+ * default, for every pass that never sets it; `Exact` for the surface caches' bake, which stores each read.
  *
  * @type {ShaderSwitch}
  */

package/src/shade/renderer/path_tracer/shader/INDIRECT_TEXTURE_FILTER.js

@@ -7,7 +7,7 @@ import { IndirectTextureFilter } from "./IndirectTextureFilter.js";
  * or the other by the pipeline they are linked into.
  *
  * Whether the pass averages its reads is the pass's, so it is fixed per shader: `Stochastic`, the
- * default, for every pass that never sets it; `Exact` for the card capture, which stores each read.
+ * default, for every pass that never sets it; `Exact` for the surface caches' bake, which stores each read.
  *
  * @type {ShaderSwitch}
  */

package/src/shade/renderer/path_tracer/shader/IndirectTextureFilter.js

@@ -10,6 +10,6 @@ export const IndirectTextureFilter = {
      * gives on average, for a pass that averages many reads into each result — the path tracer.
      */
     Stochastic: 0,
-    /** The filter itself, every tap weighed: for a pass that keeps each read as it is — the card capture. */
+    /** The filter itself, every tap weighed: for a pass that keeps each read as it is — the surface caches' bake. */
     Exact: 1,
 };

package/src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The resident material texture level a beam reads a triangle's material at: its footprint on the
+ * triangle, in texels of a slot's level 0, as `sample_material_data` and `sample_material_alpha` take
+ * their `texture_level`:
+ *
+ * ```wgsl
+ * fn beam_texture_level(triangle: TriangleVertices, along: vec3<f32>, step_u: vec3<f32>, step_v: vec3<f32>) -> f32
+ * ```
+ *
+ * The beam runs along `along` and spans `step_u` and `step_v` across, all in the triangle's space;
+ * `along` need not be unit length. Each step is carried along the beam onto the triangle's plane and
+ * through the triangle's uv per position. For a step s, direction d and normal n that is
+ * s − d (n·s)/(n·d) on the plane, taken here times n·d, so a triangle turning edge-on, whose footprint
+ * grows without bound, reaches the last level with nothing divided by 0, as a raster's would.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_beam_texture_level: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_beam_texture_level.d.ts.map

package/src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_beam_texture_level.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0CZ;0BA3DmB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_beam_texture_level.js

@@ -0,0 +1,65 @@
+import {
+    RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT,
+    RESIDENT_MATERIAL_TEXTURE_RESOLUTION
+} from "../../material/resident/RESIDENT_MATERIAL_TEXTURE_LAYOUT.js";
+import { TRIANGLE_VERTICES_STRUCT } from "../../shader/chunk/geometry/triangle/TRIANGLE_VERTICES_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The resident material texture level a beam reads a triangle's material at: its footprint on the
+ * triangle, in texels of a slot's level 0, as `sample_material_data` and `sample_material_alpha` take
+ * their `texture_level`:
+ *
+ * ```wgsl
+ * fn beam_texture_level(triangle: TriangleVertices, along: vec3<f32>, step_u: vec3<f32>, step_v: vec3<f32>) -> f32
+ * ```
+ *
+ * The beam runs along `along` and spans `step_u` and `step_v` across, all in the triangle's space;
+ * `along` need not be unit length. Each step is carried along the beam onto the triangle's plane and
+ * through the triangle's uv per position. For a step s, direction d and normal n that is
+ * s − d (n·s)/(n·d) on the plane, taken here times n·d, so a triangle turning edge-on, whose footprint
+ * grows without bound, reaches the last level with nothing divided by 0, as a raster's would.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_beam_texture_level = CodeChunk.from(
+    //language=WGSL
+    `
+fn beam_texture_level(
+    triangle: ${TRIANGLE_VERTICES_STRUCT.wgsl_ref},
+    along: vec3<f32>,
+    step_u: vec3<f32>,
+    step_v: vec3<f32>,
+) -> f32 {
+    let edge_1 = triangle.b.position - triangle.a.position;
+    let edge_2 = triangle.c.position - triangle.a.position;
+    let normal = cross(edge_1, edge_2);
+
+    // an offset in the plane is a·edge_1 + b·edge_2, a and b its dots with these
+    let dual_1 = cross(edge_2, normal) / dot(normal, normal);
+    let dual_2 = cross(normal, edge_1) / dot(normal, normal);
+
+    let uv_1 = triangle.b.uv - triangle.a.uv;
+    let uv_2 = triangle.c.uv - triangle.a.uv;
+
+    let facing = dot(normal, along);
+
+    let on_plane_u = facing * step_u - along * dot(normal, step_u);
+    let on_plane_v = facing * step_v - along * dot(normal, step_v);
+
+    let uv_step_u = dot(on_plane_u, dual_1) * uv_1 + dot(on_plane_u, dual_2) * uv_2;
+    let uv_step_v = dot(on_plane_v, dual_1) * uv_1 + dot(on_plane_v, dual_2) * uv_2;
+
+    let span = ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}.0 * max(length(uv_step_u), length(uv_step_v));
+    let reach = abs(facing);
+
+    // a footprint of a slot or more, edge-on included, is the last level
+    return select(
+        ${RESIDENT_MATERIAL_TEXTURE_LEVEL_COUNT - 1}.0,
+        log2(max(span, reach) / reach),
+        span < ${RESIDENT_MATERIAL_TEXTURE_RESOLUTION}.0 * reach
+    );
+}
+`, [
+        TRIANGLE_VERTICES_STRUCT.declaration_chunk,
+    ]);

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.d.ts

@@ -1,8 +1,10 @@
 /**
- * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
- */
-/**
- * Calculates exposure for eye adaptation
+ * The exposure: the factor the tonemapper multiplies the scene's linear radiance by ahead of its curve, metered from
+ * the frame and adapted to it ({@link update}), or set by {@link exposure_compensation} alone ({@link unadapted}).
+ *
+ * The factor lives in one buffer for the manager's life, {@link multiplier}, which a frame's {@link update} or
+ * {@link unadapted} writes over. A pass recorded ahead of that write in the frame reads the factor the last frame was
+ * shown with: the exposure of the image on screen, Unreal Engine's `View.PreExposure`.
  */
 export class GPUCameraExposureManager {
     /**
@@ -37,6 +39,14 @@ export class GPUCameraExposureManager {
      */
     exposure_compensation: number;
     destroy(): void;
+    /**
+     * The factor, {@link F32_CONTAINER_STRUCT}, as the last {@link update} or {@link unadapted} wrote it. A frame
+     * imports it into its graph once, and hands the handle both to the passes that read it ahead of the exposure,
+     * which take the last frame's factor, and to {@link update} or {@link unadapted}, which write this frame's.
+     *
+     * @returns {GPUBuffer} usable as a uniform or read-only storage
+     */
+    get multiplier(): GPUBuffer;
     /**
      * Offer the pipelines {@link update} meters and adapts with — see {@link PipelineEnquiry}.
      * {@link unadapted} dispatches none.
@@ -45,26 +55,34 @@ export class GPUCameraExposureManager {
      */
     enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
+     * This frame's factor from {@link exposure_compensation} alone: 2^compensation.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
-     * @return {number}
+     * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
+     * @return {number} the handle of {@link multiplier} with this frame's factor written
      */
-    unadapted({ graph, }: {
+    unadapted({ graph, multiplier, }: {
         graph: FrameGraph;
+        multiplier: number;
     }): number;
     /**
+     * This frame's factor metered from `input_color`: the luminance adapted toward the frame's, from the last
+     * frame's, by the adaptation speeds; its factor is middle grey over it, times 2^{@link exposure_compensation}.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.input_color
+     * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
      * @param {number} [options.time_delta_seconds]
+     * @return {number} the handle of {@link multiplier} with this frame's factor written
      */
-    update({ input_color, graph, time_delta_seconds, }: {
+    update({ input_color, graph, multiplier, time_delta_seconds, }: {
         graph: FrameGraph;
         input_color: number;
+        multiplier: number;
         time_delta_seconds?: number;
-    }): any;
+    }): number;
     #private;
 }
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCameraExposureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;GAEG;AACH;IAuCI;;;OAGG;IACH,+BAcC;IAhDD;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,yBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,uBAFU,MAAM,CAEY;IAsB5B,gBAIC;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAMzB;IAED;;;;;OAKG;IACH;QAH+B,KAAK;QACxB,MAAM,CAyCjB;IAED;;;;;;OAMG;IACH;QAJ+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACW,kBAAkB,GAAnC,MAAM;YAwJhB;;CAEJ;8BAjSY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GPUCameraExposureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH;IA0DI;;;OAGG;IACH,+BAyBC;IAtED;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,yBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,uBAFU,MAAM,CAEY;IA4C5B,gBAMC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAMzB;IAED;;;;;;;OAOG;IACH;QAJ+B,KAAK;QACT,UAAU,EAA1B,MAAM;QACL,MAAM,CAejB;IAoBD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACU,UAAU,EAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACL,MAAM,CAmDjB;;CA2EJ;8BA7TY,OAAO,6CAA6C,EAAE,eAAe"}