@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How the contact term meets the shadow map's.
+ */
+export type ContactCombine = number;
+export namespace ContactCombine {
+    let Multiply: number;
+    let Min: number;
+    let RemoveSun: number;
+}
+/**
+ * Bits of the composite's `flags`.
+ */
+export type ContactCompositeFlags = number;
+export namespace ContactCompositeFlags {
+    let Contact: number;
+    let Reference: number;
+}
+/**
+ * The playground's way of putting a contact mask into the sun's shadow term without a change to
+ * deferred shading.
+ *
+ * It runs after lighting, re-evaluates the sun's direct term per pixel with the very chunks the
+ * deferred pass uses (same G-buffer decode, same shadow-map lookup with the same random seed, same
+ * BRDF and multiple-scattering compensation), and takes back the part of it the combined visibility removes. The result is the image the
+ * deferred pass would have produced reading the mask beside the CSM/VSM lookup — exact, because the
+ * sun term is linear in visibility — at the price of evaluating the sun term twice. In a product the
+ * mask is one texture read in the sun's shadow term; this pass is scaffolding, and is timed apart.
+ *
+ * Its second target records, per pixel, the shadow map's visibility, the contact term, the combined
+ * visibility and the ray-traced reference, for the debug views and the counters.
+ *
+ * @type {ImageShader}
+ */
+export const shader_contact_lab_composite: ImageShader;
+import { ImageShader } from "../../renderer/shader/ImageShader.js";
+//# sourceMappingURL=shader_contact_lab_composite.d.ts.map

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_contact_lab_composite.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_composite.js"],"names":[],"mappings":";;;6BA4BU,MAAM;;;;;;;;;oCAgBN,MAAM;;;;;AAwKhB;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,WAAW,CAkBlB;4BArOyB,sCAAsC"}

package/src/shade/playground/contact_shadows/shader_contact_lab_composite.js

@@ -0,0 +1,245 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../renderer/camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_read_gBuffer_material } from "../../renderer/deferred/chunk_read_gBuffer_material.js";
+import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
+import { chunk_mat4_extract_position } from "../../renderer/shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_directional_lights_iteration_mask } from "../../renderer/shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import { chunk_get_directional_light_info_by_index } from "../../renderer/shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import { REFLECTED_LIGHT_STRUCT } from "../../renderer/shader/chunk/light/REFLECTED_LIGHT_STRUCT.js";
+import { chunk_re_direct_multiscatter } from "../../renderer/shader/chunk/material/chunk_re_direct_multiscatter.js";
+import { chunk_re_direct_physical } from "../../renderer/shader/chunk/material/chunk_re_direct_physical.js";
+import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../renderer/shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
+import { MATERIAL_SHADING_INFO_STRUCT } from "../../renderer/shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
+import { chunk_random_initialize } from "../../renderer/shader/chunk/random/chunk_random_initialize.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../renderer/shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../renderer/shader/ShaderDescriptor.js";
+import { u32 } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../../renderer/shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
+import { chunk_shadowmap_get_light_visibility } from "../../renderer/shadow/map/shader/chunk_shadowmap_get_light_visibility.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../renderer/texture/SAMPLER_LINEAR_UPSCALE.js";
+import { VIEW_UNIFORM_STRUCT } from "../../renderer/view/VIEW_UNIFORM_STRUCT.js";
+
+/**
+ * How the contact term meets the shadow map's.
+ * @enum {number}
+ */
+export const ContactCombine = {
+    /** visibility = shadow map × contact: what UE's desktop path and Filament/Bevy do */
+    Multiply: 0,
+    /** visibility = min(shadow map, contact): what Godot and UE's mobile path do */
+    Min: 1,
+    /**
+     * visibility = 0: takes the whole sun term back out. Only for checking the composite, against a
+     * frame rendered with the sun's intensity at zero.
+     */
+    RemoveSun: 2,
+};
+
+/**
+ * Bits of the composite's `flags`.
+ * @enum {number}
+ */
+export const ContactCompositeFlags = {
+    /** `tContact` holds this frame's mask; otherwise the contact term is 1 */
+    Contact: 1,
+    /** `tReference` holds this frame's ray-traced visibility; otherwise the reference reads lit */
+    Reference: 2,
+};
+
+const SETTINGS = WebGPUStruct.from({
+    combine: u32,
+    flags: u32,
+}, "ContactCompositeSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SETTINGS);
+
+resources.createGroup()
+    .addTexture("tColor")
+    .addTexture("gBufferDepth")
+    .addTexture("gBufferPBR")
+    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferAlbedo")
+    .addTexture("gBufferEmissive", "uint")
+    .addTexture("tContact", "unfilterable-float")
+    .addTexture("tReference", "unfilterable-float")
+    .addTexture("tSplitSum", "float")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE);
+
+resources.createGroup()
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    .addTexture("shadowmapAtlas", "depth")
+    .addSampler("sCompareLinear", "comparison", SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR);
+
+resources.createGroup()
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const COMBINE_MIN = ${ContactCombine.Min}u;
+const COMBINE_REMOVE_SUN = ${ContactCombine.RemoveSun}u;
+const FLAG_CONTACT = ${ContactCompositeFlags.Contact}u;
+const FLAG_REFERENCE = ${ContactCompositeFlags.Reference}u;
+
+struct Output {
+    @location(0) color: vec4<f32>,
+    // shadow map, contact, combined, reference: 1 everywhere the sun cannot reach anyway
+    @location(1) visibility: vec4<f32>,
+}
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> Output {
+    let i_coord = vec2<u32>(coord.xy);
+
+    // the deferred pass seeds its shadow sampling exactly so; the first draw below is the same draw
+    random_initialize(vec3u(i_coord, view.frame_index), vec3u(0xEE6B2807, 7, 0xD0974829));
+
+    let color_in = textureLoad(tColor, i_coord, 0);
+
+    var out: Output;
+
+    out.color = color_in;
+    out.visibility = vec4<f32>(1.0);
+
+    let texel_depth = textureLoad(gBufferDepth, i_coord, 0).r;
+
+    let directional_bits = directional_lights_iteration_mask(&light_data);
+
+    if (is_background(texel_depth) || directional_bits == 0u) {
+        return out;
+    }
+
+    let position_ws = project_position_from_depth(uv, texel_depth, camera.view_projection_matrix_inverse);
+    let view_direction = normalize(mat4_extract_position(camera.transform) - position_ws);
+
+    let g_buffer_sample_normal = textureLoad(gBufferNormal, i_coord, 0);
+
+    let geometry = ${GEOMETRIC_SHADING_INFO_STRUCT.wgsl_ref}(
+        decode_g_buffer_normal(g_buffer_sample_normal.xy),
+        decode_g_buffer_normal(g_buffer_sample_normal.zw),
+        position_ws,
+        view_direction,
+    );
+
+    let material = read_gBuffer_material(i_coord);
+
+    // the scene's one sun: the first directional light, as the ray-traced reference picks it
+    let directional_index = countTrailingZeros(directional_bits);
+
+    let shadow_map = shadowmap_get_directional_light_visibility(
+        &light_data,
+        directional_index,
+        geometry.position,
+        geometry.view_direction,
+        geometry.shading_normal
+    );
+
+    let sun = get_directional_light_info_by_index(&light_data, directional_index);
+
+    if (dot(sun.direction, geometry.shading_normal) <= 0.0) {
+        // turned away from the sun: every term says shadowed, and none of them is being tested here
+        return out;
+    }
+
+    var unshadowed: ${REFLECTED_LIGHT_STRUCT.wgsl_ref};
+
+    re_direct_physical(sun, geometry, material, &unshadowed);
+    // the deferred pass scales its pixel's accumulated specular by this after the last light: a factor
+    // per pixel, so the sun's share is scaled alike and the term stays linear in visibility
+    re_direct_multiscatter(geometry, material, &unshadowed);
+
+    let sun_radiance = unshadowed.diffuse + unshadowed.specular;
+
+    var contact = 1.0;
+
+    if ((settings.flags & FLAG_CONTACT) != 0u) {
+        contact = textureLoad(tContact, i_coord, 0).r;
+    }
+
+    var combined = shadow_map * contact;
+
+    if (settings.combine == COMBINE_MIN) {
+        combined = min(shadow_map, contact);
+    } else if (settings.combine == COMBINE_REMOVE_SUN) {
+        combined = 0.0;
+    }
+
+    var reference = 1.0;
+
+    if ((settings.flags & FLAG_REFERENCE) != 0u) {
+        reference = textureLoad(tReference, i_coord, 0).r;
+    }
+
+    /*
+     The deferred pass added sun_radiance × shadow_map. The sun term is linear in its visibility, so
+     taking back sun_radiance × (shadow_map − combined) leaves exactly what the deferred pass would
+     have written had it read the combined visibility.
+    */
+    out.color = vec4<f32>(color_in.rgb - sun_radiance * (shadow_map - combined), color_in.a);
+    out.visibility = vec4<f32>(shadow_map, contact, combined, reference);
+
+    return out;
+}
+`, [
+        SETTINGS.declaration_chunk,
+        REFLECTED_LIGHT_STRUCT.declaration_chunk,
+        GEOMETRIC_SHADING_INFO_STRUCT.declaration_chunk,
+        MATERIAL_SHADING_INFO_STRUCT.declaration_chunk,
+        chunk_random_initialize,
+        chunk_is_background,
+        chunk_project_position_from_depth,
+        chunk_mat4_extract_position,
+        chunk_decode_g_buffer_normal,
+        chunk_read_gBuffer_material,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+        chunk_shadowmap_get_light_visibility,
+        chunk_re_direct_physical,
+        chunk_re_direct_multiscatter,
+    ]
+);
+
+/**
+ * The playground's way of putting a contact mask into the sun's shadow term without a change to
+ * deferred shading.
+ *
+ * It runs after lighting, re-evaluates the sun's direct term per pixel with the very chunks the
+ * deferred pass uses (same G-buffer decode, same shadow-map lookup with the same random seed, same
+ * BRDF and multiple-scattering compensation), and takes back the part of it the combined visibility removes. The result is the image the
+ * deferred pass would have produced reading the mask beside the CSM/VSM lookup — exact, because the
+ * sun term is linear in visibility — at the price of evaluating the sun term twice. In a product the
+ * mask is one texture read in the sun's shadow term; this pass is scaffolding, and is timed apart.
+ *
+ * Its second target records, per pixel, the shadow map's visibility, the contact term, the combined
+ * visibility and the ray-traced reference, for the debug views and the counters.
+ *
+ * @type {ImageShader}
+ */
+export const shader_contact_lab_composite = new ImageShader({
+    descriptor: ShaderDescriptor.from({
+        label: "Contact lab / composite",
+        resources,
+        body,
+    }),
+    targets: [
+        {
+            label: "color",
+            format: "rgba16float",
+        },
+        {
+            label: "visibility",
+            format: "rgba8unorm",
+        },
+    ],
+});

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The reference: the sun's visibility from every pixel's G-buffer position, by one ray toward the sun's
+ * centre through the scene's BVH. Hard, as a shadow from a point on the sun. Alpha-tested and glass
+ * occluders are resolved from their materials, as the path tracer does.
+ *
+ * The engine's ray-traced shadow prototype (`shadow/ray/shader_ray_shadow_code.js`) traces the same
+ * query from the same chunks, but jitters each ray over the sun's disc and packs 8×4 pixels into a word
+ * for its denoiser. Its rays start at `offset_ray_from_depth`, which fixes at 3e-5 of the view distance
+ * the normal offset this one takes as a setting, so that it can be swept.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_contact_lab_reference: ComputeShader;
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+//# sourceMappingURL=shader_contact_lab_reference.d.ts.map

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_contact_lab_reference.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_reference.js"],"names":[],"mappings":"AAuGA;;;;;;;;;;;GAWG;AACH,2CAFU,aAAa,CAMpB;8BAxG2B,wCAAwC"}

package/src/shade/playground/contact_shadows/shader_contact_lab_reference.js

@@ -0,0 +1,120 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../renderer/camera/CAMERA_UNIFORM_STRUCT.js";
+import { RESOURCE_GROUP_RTX } from "../../renderer/geometry/sr_create_group_RTX.js";
+import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../renderer/material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
+import { chunk_ray_shaded_query_occluded } from "../../renderer/path_tracer/shader/chunk_ray_shaded_query_occluded.js";
+import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_is_background } from "../../renderer/shader/chunk/depth/chunk_is_background.js";
+import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { chunk_offset_ray } from "../../renderer/shader/chunk/geometry/ray/chunk_offset_ray.js";
+import { RAY_STRUCT } from "../../renderer/shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { chunk_directional_lights_iteration_mask } from "../../renderer/shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import { chunk_get_directional_light_info_by_index } from "../../renderer/shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import { chunk_random } from "../../renderer/shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../../renderer/shader/chunk/random/chunk_random_initialize.js";
+import { chunk_texel_coordinate_to_uv } from "../../renderer/shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
+import { VIEW_UNIFORM_STRUCT } from "../../renderer/view/VIEW_UNIFORM_STRUCT.js";
+import { f32 } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { chunk_mat4_extract_position } from "../../renderer/shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+
+const SETTINGS = WebGPUStruct.from({
+    normal_offset: f32,
+}, "ContactReferenceSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", SETTINGS);
+
+resources.addGroup(RESOURCE_GROUP_RTX);
+
+resources.createGroup()
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
+    .addTexture("textures", "unfilterable-float", "2d-array");
+
+resources.createGroup()
+    .addTexture("gBufferDepth")
+    .addTexture("gBufferNormal", "uint")
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addStorageTexture("tReference", "r32float", "2d", "write-only");
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let size = textureDimensions(gBufferDepth);
+
+    if (any(id.xy >= size)) {
+        return;
+    }
+
+    // the alpha test of a hit is stochastic by its opacity
+    random_initialize(vec3<u32>(id.xy, view.frame_index), vec3<u32>(0x5bd1e995u, 13u, 0x9e3779b9u));
+
+    let depth = textureLoad(gBufferDepth, id.xy, 0).r;
+
+    var visibility = 1.0;
+
+    let directional_bits = directional_lights_iteration_mask(&light_data);
+
+    if (!is_background(depth) && directional_bits != 0u) {
+        let uv = texel_coordinate_to_uv(vec2<f32>(id.xy), size);
+        let position_ws = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
+        let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+
+        let sun = get_directional_light_info_by_index(&light_data, countTrailingZeros(directional_bits));
+
+        var ray: ${RAY_STRUCT.wgsl_ref};
+
+        let distance = length(position_ws - mat4_extract_position(camera.transform));
+
+        ray.origin = offset_ray(position_ws + geometric_normal * (settings.normal_offset * distance), geometric_normal);
+        ray.direction = sun.direction;
+        ray.tmax = sun.distance;
+
+        if (ray_shaded_query_occluded(ray)) {
+            visibility = 0.0;
+        }
+    }
+
+    textureStore(tReference, id.xy, vec4<f32>(visibility));
+}
+`, [
+        SETTINGS.declaration_chunk,
+        chunk_mat4_extract_position,
+        chunk_random,
+        chunk_random_initialize,
+        chunk_is_background,
+        chunk_texel_coordinate_to_uv,
+        chunk_project_position_from_depth,
+        chunk_decode_g_buffer_normal,
+        chunk_offset_ray,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+        chunk_ray_shaded_query_occluded,
+    ]
+);
+
+/**
+ * The reference: the sun's visibility from every pixel's G-buffer position, by one ray toward the sun's
+ * centre through the scene's BVH. Hard, as a shadow from a point on the sun. Alpha-tested and glass
+ * occluders are resolved from their materials, as the path tracer does.
+ *
+ * The engine's ray-traced shadow prototype (`shadow/ray/shader_ray_shadow_code.js`) traces the same
+ * query from the same chunks, but jitters each ray over the sun's disc and packs 8×4 pixels into a word
+ * for its denoiser. Its rays start at `offset_ray_from_depth`, which fixes at 3e-5 of the view distance
+ * the normal offset this one takes as a setting, so that it can be swept.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_contact_lab_reference = ComputeShader.from({
+    label: "Contact lab / ray-traced reference",
+    resources,
+    body,
+});

package/src/shade/playground/contact_shadows/shader_contact_lab_stats.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What each counter of the stats buffer counts, over one frame's pixels, before TAA. "Shadowed" means
+ * a visibility under ½; the reference is the ray-traced sun visibility of the pixel's own G-buffer
+ * position.
+ */
+export type ContactStat = number;
+export namespace ContactStat {
+    let ReferenceShadowed: number;
+    let ShadowMapMissed: number;
+    let Fixed: number;
+    let Missed: number;
+    let ShadowMapFalse: number;
+    let False: number;
+    let AddedFalse: number;
+    let SpuriousFlips: number;
+    let ShadowMapSpuriousFlips: number;
+    let ReferenceFlips: number;
+    let Pixels: number;
+    let ContactShadowed: number;
+    let CombinedError: number;
+    let ShadowMapError: number;
+    let DarkerThanBoth: number;
+    let CombinedChange: number;
+    let ShadowMapChange: number;
+}
+/**
+ * Counters before the depth bands.
+ * @type {number}
+ */
+export const CONTACT_STAT_BAND_BASE: number;
+/**
+ * Depth bands the band counters split by, in metres of view depth: [0, 2), [2, 4), [4, 8), … doubling,
+ * the last open-ended.
+ * @type {number}
+ */
+export const CONTACT_STAT_BAND_COUNT: number;
+/**
+ * Per band, at CONTACT_STAT_BAND_BASE + band × 4: reference shadowed, shadow map missed, fixed,
+ * added false.
+ * @type {number}
+ */
+export const CONTACT_STAT_BAND_STRIDE: number;
+/**
+ * @type {number}
+ */
+export const CONTACT_STAT_COUNT: number;
+/**
+ * The playground's counters: one frame's pixels classified against the ray-traced reference, overall
+ * and by depth band, and against the previous frame's record for flips the reference does not share.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_contact_lab_stats: ComputeShader;
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+//# sourceMappingURL=shader_contact_lab_stats.d.ts.map

package/src/shade/playground/contact_shadows/shader_contact_lab_stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_contact_lab_stats.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/contact_shadows/shader_contact_lab_stats.js"],"names":[],"mappings":";;;;;0BAcU,MAAM;;;;;;;;;;;;;;;;;;;;AAuChB;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;;GAIG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;GAEG;AACH,iCAFU,MAAM,CAE8F;AAiI9G;;;;;GAKG;AACH,uCAFU,aAAa,CAMpB;8BApN2B,wCAAwC"}