@woosh/meep-engine 3.36.0 → 3.38.0

package/src/shade/renderer/water/shader_water_avboit.d.ts

@@ -0,0 +1,12 @@
+export { chunk_water_refraction_confidence } from "./chunk_water_transport.js";
+export const shader_water_occupancy: ComputeShader;
+export const shader_water_splat: ComputeShader;
+export const shader_water_draw: ImageShader;
+export const shader_water_confidence_seed: ImageShader;
+export const shader_water_confidence_x: ImageShader;
+export const shader_water_confidence_y: ImageShader;
+export const shader_water_background_copy: ImageShader;
+export const shader_water_debug: ImageShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_water_avboit.d.ts.map

package/src/shade/renderer/water/shader_water_avboit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_water_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water_avboit.js"],"names":[],"mappings":";AAiCA,mDAwBG;AAQH,+CAqCG;AAUH,4CAwBG;AAQH,uDAuBG;AAyBH,oDAA2E;AAC3E,oDAA0E;AAM1E,uDAYG;AAOH,6CAuCG;8BAlP2B,4BAA4B;4BAC9B,0BAA0B"}

package/src/shade/renderer/water/shader_water_avboit.js

@@ -0,0 +1,258 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_sample_volumetrics } from "../deferred/chunk_sample_volumetrics.js";
+import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VOXEL_DOWNSCALE } from "../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
+import { AVBOIT_DRAW_TARGETS } from "../rasterize/native/avboit/avboit_draw_fragment_body.js";
+import { chunk_avboit_occupancy_mark } from "../rasterize/native/avboit/chunk_avboit_occupancy_mark.js";
+import { chunk_avboit_rgb_contribution } from "../rasterize/native/avboit/chunk_avboit_rgb_contribution.js";
+import { chunk_avboit_sample_transmittance } from "../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
+import { chunk_avboit_splat_slice } from "../rasterize/native/avboit/chunk_avboit_splat_slice.js";
+import { chunk_avboit_split_counts } from "../rasterize/native/avboit/chunk_avboit_split_counts.js";
+import { chunk_avboit_transmittance_to_extinction } from "../rasterize/native/avboit/chunk_avboit_transmittance_to_extinction.js";
+import { chunk_avboit_view_depth_to_physical } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_physical.js";
+import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/shader_avboit_occupancy.js";
+import { chunk_get_view_space_depth } from "../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ImageShader } from "../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { atomic_u32, u32, vec2f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
+import { VOLUMETRICS_METADATA_STRUCT } from "../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
+import { DepthStencilState } from '../../descriptor/pipeline/render/DepthStencilState.js';
+export { chunk_water_refraction_confidence } from './chunk_water_transport.js';
+
+const occupancy_resources = new ShaderResourceSetDescriptor();
+occupancy_resources.createGroup().addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("settings", AVBOIT_OCCUPANCY_SETTINGS_STRUCT)
+    .addTexture("interface_depth").addStorageBuffer("occupancy", WebGPUArray.from(atomic_u32, AVBOIT_OCCUPANCY_WORDS), true);
+
+export const shader_water_occupancy = ComputeShader.from({
+    label: "Water / AVBOIT occupancy", resources: occupancy_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+var<workgroup> depth_min: atomic<u32>;
+var<workgroup> depth_max: atomic<u32>;
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3u, @builtin(local_invocation_index) index: u32) {
+    if (index == 0u) { atomicStore(&depth_min, bitcast<u32>(1e30)); atomicStore(&depth_max, 0u); }
+    workgroupBarrier();
+    let size = textureDimensions(interface_depth, 0);
+    if (all(id.xy < size)) {
+        let d = textureLoad(interface_depth, id.xy, 0).r;
+        if (d > 0.0) {
+            let z = clamp(get_view_space_depth(d, camera), camera.clip_near_far.x, camera.clip_near_far.y);
+            atomicMin(&depth_min, bitcast<u32>(z)); atomicMax(&depth_max, bitcast<u32>(z));
+        }
+    }
+    workgroupBarrier();
+    if (index == 0u && atomicLoad(&depth_max) != 0u) {
+        avboit_occupancy_mark(bitcast<f32>(atomicLoad(&depth_min)), bitcast<f32>(atomicLoad(&depth_max)),
+            camera.clip_near_far.x, settings.cluster_parameters);
+    }
+}
+`, [chunk_get_view_space_depth, chunk_avboit_occupancy_mark]),
+});
+
+const splat_resources = new ShaderResourceSetDescriptor();
+splat_resources.createGroup().addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT).addTexture("interface_depth").addTexture("transmission")
+    .addStorageBuffer("extinction_volume", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("overflow_slice", WebGPUArray.from(atomic_u32), true);
+
+export const shader_water_splat = ComputeShader.from({
+    label: "Water / AVBOIT splat", resources: splat_resources,
+    body: CodeChunk.from(/* language=WGSL */ `
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3u) {
+    if (id.x >= warp.voxel_width || id.y >= warp.voxel_height) { return; }
+    let size = textureDimensions(interface_depth, 0);
+    let lo = id.xy * ${AVBOIT_VOXEL_DOWNSCALE}u;
+    let hi = min(lo + vec2u(${AVBOIT_VOXEL_DOWNSCALE}u), size);
+    var total_t = vec3f(0.0);
+    var samples = 0.0;
+    var nearest = 1e30;
+    for (var y = lo.y; y < hi.y; y++) {
+        for (var x = lo.x; x < hi.x; x++) {
+            let coord = vec2u(x, y);
+            let d = textureLoad(interface_depth, coord, 0).r;
+            var t = vec3f(1.0);
+            if (d > 0.0) {
+                t = textureLoad(transmission, coord, 0).rgb;
+                nearest = min(nearest, get_view_space_depth(d, camera));
+            }
+            total_t += t; samples += 1.0;
+        }
+    }
+    if (nearest == 1e30 || samples == 0.0) { return; }
+    // One area-averaged event, not 64 full-coverage layers. Dry samples retain T=1.
+    let extinction = avboit_transmittance_to_extinction(total_t / samples);
+    let counts = avboit_extinction_to_counts(extinction);
+    let p = avboit_view_depth_to_physical(&warp, nearest) - 0.5;
+    let slice = i32(floor(p));
+    let upper = avboit_split_counts(counts, fract(p));
+    let column = (id.y * warp.voxel_width + id.x) * warp.physical_count;
+    avboit_splat_counts(column, slice, counts - upper, id.xy);
+    avboit_splat_counts(column, slice + 1, upper, id.xy);
+}
+`, [chunk_get_view_space_depth, chunk_avboit_splat_slice, chunk_avboit_split_counts,
+    chunk_avboit_transmittance_to_extinction, chunk_avboit_view_depth_to_physical]),
+});
+
+const draw_resources = new ShaderResourceSetDescriptor();
+draw_resources.createGroup().addUniform("camera", CAMERA_UNIFORM_STRUCT).addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT).addTexture("interface_depth")
+    .addTexture("transmission").addTexture("radiance")
+    .addTexture("tIntegral", "float", "3d").addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
+    .addTexture("tVolumetrics", "float", "3d").addTexture("tSTBN_vec3", "float", "3d");
+
+export const shader_water_draw = ImageShader.from({
+    descriptor: ShaderDescriptor.from({ label: "Water / AVBOIT draw", resources: draw_resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+struct WaterContribution {
+    @location(0) color: vec4f, @location(1) norm: vec4f,
+    @location(2) extinction: vec4f, @location(3) emission: vec4f,
+}
+@fragment
+fn main(@builtin(position) coord: vec4f) -> WaterContribution {
+    let pixel = vec2u(coord.xy);
+    let d = textureLoad(interface_depth, pixel, 0).r;
+    if (d <= 0.0) { discard; }
+    let z = get_view_space_depth(d, camera);
+    let uv = coord.xy / vec2f(textureDimensions(interface_depth, 0));
+    let front = avboit_sample_transmittance(&warp, tIntegral, sLinear, uv, z);
+    let t = textureLoad(transmission, pixel, 0).rgb;
+    let w = textureLoad(radiance, pixel, 0).rgb;
+    let fog = sample_volumetrics(z, uv, coord.xy);
+    let c = avboit_rgb_contribution(w, t, front, fog);
+    return WaterContribution(c.color, c.norm, c.extinction, c.emission);
+}
+`, [chunk_get_view_space_depth, chunk_avboit_sample_transmittance,
+            chunk_avboit_rgb_contribution, chunk_sample_volumetrics]),
+    }), targets: AVBOIT_DRAW_TARGETS,
+});
+
+// A depth buffer cannot reveal the receiver hidden behind an emergent object.
+// Fade displacement around those disocclusions instead of exposing a hard control-UV hole.
+// Quarter-resolution conservative seeds and a separable bounded distance transform keep
+// this independent of scene size and avoid a full-resolution neighbourhood search.
+const confidence_seed_resources = new ShaderResourceSetDescriptor();
+confidence_seed_resources.createGroup().addTexture("trace_metadata").addTexture("scene_depth");
+export const shader_water_confidence_seed = ImageShader.from({
+    descriptor: ShaderDescriptor.from({ label: "Water / visibility seeds", resources: confidence_seed_resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+@fragment
+fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
+    let tile = vec2u(coord.xy) * 4u;
+    let size = textureDimensions(trace_metadata, 0);
+    var distance = 16.0;
+    for (var y = 0u; y < 4u; y++) {
+        for (var x = 0u; x < 4u; x++) {
+            let pixel = tile + vec2u(x, y);
+            if (all(pixel < size)) {
+                let t = textureLoad(trace_metadata, pixel, 0);
+                // Only actual geometry/sky boundaries seed the spatial fade. Trace budget
+                // or numerical failures must not create moving 64-pixel holes around themselves.
+                if (t.b <= 0.0 || textureLoad(scene_depth, pixel, 0).r == 0.0) { distance = 0.0; }
+            }
+        }
+    }
+    return vec4f(distance, 0.0, 0.0, 1.0);
+}
+`),
+    }), targets: [{ format: "r16float" }],
+});
+
+function confidence_distance_shader(vertical) {
+    const resources = new ShaderResourceSetDescriptor();
+    resources.createGroup().addTexture("distance_field");
+    return ImageShader.from({ descriptor: ShaderDescriptor.from({
+        label: vertical ? "Water / visibility distance Y" : "Water / visibility distance X", resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+@fragment
+fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
+    let pixel = vec2i(coord.xy);
+    let size = vec2i(textureDimensions(distance_field, 0));
+    var distance = 16.0;
+    for (var offset = -16; offset <= 16; offset++) {
+        let sample = pixel + ${vertical ? "vec2i(0, offset)" : "vec2i(offset, 0)"};
+        if (all(sample >= vec2i(0)) && all(sample < size)) {
+            let d = textureLoad(distance_field, sample, 0).r;
+            distance = min(distance, ${vertical ? "length(vec2f(d, f32(offset)))" : "d + abs(f32(offset))"});
+        }
+    }
+    return vec4f(distance, 0.0, 0.0, 1.0);
+}
+`),
+    }), targets: [{ format: "r16float" }] });
+}
+export const shader_water_confidence_x = confidence_distance_shader(false);
+export const shader_water_confidence_y = confidence_distance_shader(true);
+
+// Initialize all three final targets in the same render pass as water shading.
+// This samples opaque HDR and needs no COPY_SRC usage or renderer changes.
+const background_resources = new ShaderResourceSetDescriptor();
+background_resources.createGroup().addTexture('tScene');
+export const shader_water_background_copy = ImageShader.from({
+    descriptor: ShaderDescriptor.from({label: 'Water / background initialization', resources: background_resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+struct WaterBackground {
+    @location(0) transmission: vec4f, @location(1) radiance: vec4f, @location(2) background: vec4f,
+}
+@fragment
+fn main(@builtin(position) coord: vec4f) -> WaterBackground {
+    return WaterBackground(vec4f(1.0,1.0,1.0,0.0), vec4f(0.0), textureLoad(tScene, vec2i(coord.xy), 0));
+}
+`)}), targets: [{format:'rgba32float'}, {format:'rgba16float'}, {format:'rgba16float'}],
+    depthStencil: DepthStencilState.from({format:'depth32float', depthWriteEnabled:false, depthCompare:'always'}),
+});
+
+const debug_resources = new ShaderResourceSetDescriptor();
+debug_resources.createGroup().addUniform("inspection", WebGPUStruct.from({ mode: u32, resolution: vec2f }, "WaterInspection").pack())
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT).addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    .addTexture("tIntegral", "float", "3d").addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE).addTexture("transmission")
+    .addTexture("radiance").addTexture("receiver").addTexture("interface_depth").addTexture("trace_metadata");
+export const shader_water_debug = ImageShader.from({
+    descriptor: ShaderDescriptor.from({ label: "Water / inspection", resources: debug_resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+@fragment
+fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
+    let uv = coord.xy / inspection.resolution;
+    let pixel = min(vec2u(uv*vec2f(textureDimensions(transmission,0))), textureDimensions(transmission,0)-1u);
+    let t = textureLoad(transmission, pixel, 0);
+    let r = textureLoad(receiver, pixel, 0);
+    if (t.a <= 0.0) { return vec4f(0.025, 0.025, 0.025, 1.0); }
+    var color = t.rgb;
+    switch (inspection.mode) {
+        case 1u: { color = vec3f(t.a); }
+        case 2u: { color = vec3f(r.xy, 0.0); }
+        case 3u: { color = vec3f(r.z / (r.z + 10.0)); }
+        case 4u: {
+            let code = u32(floor(r.w));
+            var palette = array<vec3f,5>(vec3f(0.1,0.9,0.1),vec3f(0.1,0.7,1.0),
+                vec3f(0.4,0.2,0.8),vec3f(0.8,0.3,0.1),vec3f(0.9,0.1,0.6));
+            color = palette[min(code / 8u, 4u)];
+            if (code == 31u) { color = palette[4]; }
+            color.r = max(color.r, fract(r.w) * 2.0);
+        }
+        case 5u: { color = textureLoad(radiance, pixel, 0).rgb; }
+        case 6u: { color = vec3f(min(textureLoad(trace_metadata, pixel, 0).g, 1.0)); }
+        case 10u: {
+            color = vec3f(textureLoad(radiance, pixel, 0).a);
+        }
+        case 8u, 9u: {
+            let z = get_view_space_depth(textureLoad(interface_depth, pixel, 0).r, camera);
+            let front = avboit_sample_transmittance(&warp, tIntegral, sLinear, uv, z);
+            color = select(front, (1.0 - t.rgb) * front, inspection.mode == 9u);
+        }
+        default: {}
+    }
+    return vec4f(color, 1.0);
+}
+`, [chunk_get_view_space_depth, chunk_avboit_sample_transmittance]),
+    }), targets: [{ format: "rgba16float" }],
+});

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AAkRA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAwpCd"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":"AAkRA;;;;;;;;;;;;GAYG;AACH,+BAFU,MAAM,CAqqCd"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -767,6 +767,16 @@ export const WGSLLanguageCore = {
         return out;
     },
 
+    refract(i, n, eta) {
+        const d = WGSLLanguageCore.dot(n, i);
+        const k = 1 - eta * eta * (1 - d * d);
+        const out = new i.constructor(i.length);
+        if (k < 0) { out.fill(0); return out; }
+        const normal_scale = eta * d + Math.sqrt(k);
+        for (let j = 0; j < i.length; j++) out[j] = eta * i[j] - normal_scale * n[j];
+        return out;
+    },
+
     // ---------------------------------------------------------------------
     // Matrix × {matrix, vector} and vector × matrix products.
     //
@@ -1226,6 +1236,9 @@ export const WGSLLanguageCore = {
         t.write(x, y, z, value);
     },
 
+    // CPUBitmapData models one stored mip level.
+    textureNumLevels(_t) { return 1; },
+
     /**
      * `textureDimensions(t, level) -> u32 | vec2<u32> | vec3<u32>`
      *

package/src/shade/renderer/animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.d.ts

@@ -1,29 +0,0 @@
-/**
- * Per-element f32 atomic min/max via CAS-spin over a `atomic<u32>`
- * storage cell, bitcast through f32 for comparison.
- *
- * WGSL has native u32/i32 atomics only. For float min/max the
- * sign-bit-flip encoding (cheaper, only `atomicMin`/`atomicMax`
- * needed) is a tempting alternative, but it leaves the buffer in
- * "encoded" form during the dispatch chain — readers in the same
- * frame would need to know whether the value is encoded or decoded.
- * The CAS-spin keeps the storage in plain f32 the whole time, which
- * matches what the rasterizer's meshlet-culling shader already
- * expects in `meshlet.bounds_box`.
- *
- * Contention model: every contributor reads → compares → conditionally
- * writes. When the existing value already bounds the contribution
- * (typical for late contributors as the box settles), the comparison
- * exits early without any CAS. The worst case is many threads
- * hammering the same slot in the first few iterations; the loop is
- * bounded by collisions, not by thread count.
- *
- * `value` is treated as a normal f32 — NaNs are not handled (vertex
- * positions are never NaN in correctly-loaded geometry). +inf / -inf
- * are valid (they're our scatter sentinels).
- *
- * @type {CodeChunk}
- */
-export const chunk_aabb_atomic_f32: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_aabb_atomic_f32.d.ts.map

package/src/shade/renderer/animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_aabb_atomic_f32.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oCAFU,SAAS,CAgChB;0BA1DuB,uCAAuC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/chunk_aabb_atomic_f32.js

@@ -1,59 +0,0 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-
-/**
- * Per-element f32 atomic min/max via CAS-spin over a `atomic<u32>`
- * storage cell, bitcast through f32 for comparison.
- *
- * WGSL has native u32/i32 atomics only. For float min/max the
- * sign-bit-flip encoding (cheaper, only `atomicMin`/`atomicMax`
- * needed) is a tempting alternative, but it leaves the buffer in
- * "encoded" form during the dispatch chain — readers in the same
- * frame would need to know whether the value is encoded or decoded.
- * The CAS-spin keeps the storage in plain f32 the whole time, which
- * matches what the rasterizer's meshlet-culling shader already
- * expects in `meshlet.bounds_box`.
- *
- * Contention model: every contributor reads → compares → conditionally
- * writes. When the existing value already bounds the contribution
- * (typical for late contributors as the box settles), the comparison
- * exits early without any CAS. The worst case is many threads
- * hammering the same slot in the first few iterations; the loop is
- * bounded by collisions, not by thread count.
- *
- * `value` is treated as a normal f32 — NaNs are not handled (vertex
- * positions are never NaN in correctly-loaded geometry). +inf / -inf
- * are valid (they're our scatter sentinels).
- *
- * @type {CodeChunk}
- */
-export const chunk_aabb_atomic_f32 = CodeChunk.from(
-    //language=WGSL
-    `
-fn aabb_atomic_min_f32(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
-    loop {
-        let old_u = atomicLoad(cell);
-        let old_f = bitcast<f32>(old_u);
-        if value >= old_f {
-            break;
-        }
-        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
-        if result.exchanged {
-            break;
-        }
-    }
-}
-
-fn aabb_atomic_max_f32(cell: ptr<storage, atomic<u32>, read_write>, value: f32) {
-    loop {
-        let old_u = atomicLoad(cell);
-        let old_f = bitcast<f32>(old_u);
-        if value <= old_f {
-            break;
-        }
-        let result = atomicCompareExchangeWeak(cell, old_u, bitcast<u32>(value));
-        if result.exchanged {
-            break;
-        }
-    }
-}
-`);

package/src/shade/renderer/shader/chunk/geometry/plane/plane_ray_raycast.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plane_ray_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/plane/plane_ray_raycast.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gCAFU,SAAS,CA2Cf;0BA/CsB,gCAAgC"}