@woosh/meep-engine 2.87.3 → 2.87.4

package/src/core/geom/2d/hash-grid/SpatialHashGrid.spec.js

@@ -0,0 +1,158 @@
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { SpatialHashGrid } from "./SpatialHashGrid.js";
+
+test("constructor does not throw", () => {
+    new SpatialHashGrid()
+});
+
+test("new grid should be empty", () => {
+    const grid = new SpatialHashGrid(1, 1);
+
+    expect(grid.is_cell_empty(0, 0)).toBe(true);
+});
+
+test("insert a small tile that fits into a single grid cell", () => {
+    const grid = new SpatialHashGrid(2, 2, 4);
+
+    const el = grid.element_allocate();
+
+    grid.element_set_user_data(el, 7);
+    grid.element_set_bounds_primitive(el, 0.5, 0.5, 1, 1);
+
+    grid.element_insert(el);
+
+    expect(grid.is_cell_empty(0, 0)).toBe(false);
+});
+
+test("insert an element that spans multiple grid cells", () => {
+
+    const grid = new SpatialHashGrid(2, 3, 4);
+
+    const el = grid.element_allocate();
+
+    grid.element_set_user_data(el, 7);
+    grid.element_set_bounds_primitive(el, 0.5, 0.5, 6, 6);
+
+    grid.element_insert(el);
+
+    expect(grid.is_cell_empty(0, 0)).toBe(false);
+    expect(grid.is_cell_empty(0, 1)).toBe(false);
+    expect(grid.is_cell_empty(1, 0)).toBe(false);
+    expect(grid.is_cell_empty(1, 1)).toBe(false);
+    expect(grid.is_cell_empty(0, 2)).toBe(true);
+    expect(grid.is_cell_empty(1, 2)).toBe(true);
+});
+
+test("remove an element that spans multiple grid cells", () => {
+
+    const grid = new SpatialHashGrid(2, 3, 4);
+
+    const el = grid.element_allocate();
+
+    grid.element_set_user_data(el, 7);
+    grid.element_set_bounds_primitive(el, 0.5, 0.5, 6, 6);
+
+    grid.element_insert(el);
+    grid.element_remove(el);
+
+    expect(grid.is_cell_empty(0, 0)).toBe(true);
+    expect(grid.is_cell_empty(0, 1)).toBe(true);
+    expect(grid.is_cell_empty(1, 0)).toBe(true);
+    expect(grid.is_cell_empty(1, 1)).toBe(true);
+    expect(grid.is_cell_empty(0, 2)).toBe(true);
+    expect(grid.is_cell_empty(1, 2)).toBe(true);
+});
+
+test("remove element from grid", () => {
+
+    const grid = new SpatialHashGrid(2, 2, 4);
+
+    const el = grid.element_allocate();
+
+    grid.element_set_user_data(el, 7);
+    grid.element_set_bounds_primitive(el, 0.5, 0.5, 1, 1);
+
+    grid.element_insert(el);
+    grid.element_remove(el);
+
+    expect(grid.is_cell_empty(0, 0)).toBe(true);
+    expect(grid.is_cell_empty(0, 1)).toBe(true);
+    expect(grid.is_cell_empty(1, 0)).toBe(true);
+    expect(grid.is_cell_empty(1, 1)).toBe(true);
+});
+
+test("add 3 element and remove in same order, expect grid to be empty", () => {
+
+    const grid = new SpatialHashGrid(2, 2, 4);
+
+    const a = grid.element_allocate();
+
+    grid.element_set_user_data(a, 3);
+    grid.element_set_bounds_primitive(a, 0.5, 0.5, 1, 1);
+
+    const b = grid.element_allocate();
+
+    grid.element_set_user_data(b, 7);
+    grid.element_set_bounds_primitive(b, 0.5, 0.5, 1, 1);
+
+    const c = grid.element_allocate();
+
+    grid.element_set_user_data(c, 11);
+    grid.element_set_bounds_primitive(c, 0.5, 0.5, 1, 1);
+
+    grid.element_insert(a);
+    grid.element_insert(b);
+    grid.element_insert(c);
+
+    grid.element_remove(a);
+    grid.element_remove(b);
+    grid.element_remove(c);
+
+    expect(grid.is_cell_empty(0, 0)).toBe(true);
+    expect(grid.is_cell_empty(0, 1)).toBe(true);
+    expect(grid.is_cell_empty(1, 0)).toBe(true);
+    expect(grid.is_cell_empty(1, 1)).toBe(true);
+});
+
+test.skip("performance, insertion 1m random", () => {
+    const grid = new SpatialHashGrid(100, 100, 1);
+
+    const random = seededRandom(42);
+
+    const N = 1000000;
+
+    const elements = new Uint32Array(N);
+
+    for (let i = 0; i < N; i++) {
+
+        const position_x = randomFloatBetween(random, 0, 98);
+        const position_y = randomFloatBetween(random, 0, 98);
+
+        const size_x = randomFloatBetween(random, 0.1, 2);
+        const size_y = randomFloatBetween(random, 0.1, 2);
+
+        const element = grid.element_allocate();
+
+        grid.element_set_user_data(element, i);
+        grid.element_set_bounds_primitive(element,
+            position_x,
+            position_y,
+            position_x + size_x,
+            position_y + size_y
+        );
+
+        elements[i] = element;
+    }
+
+    // perform insertion
+    const t0 = performance.now();
+
+    for (let i = 0; i < N; i++) {
+        grid.element_insert(elements[i]);
+    }
+
+    const duration = performance.now() - t0;
+
+    console.log(`Duration ${duration}ms, ${(N / (duration * 1e-3)).toFixed(2)} records per second`);
+});

package/src/core/geom/2d/hash-grid/shg_query_raycast.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {SpatialHashGrid} grid
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} max_distance
+ * @param {function} predicate
+ * @param {*} [predicateContext]
+ * @returns {number} element ID or -1 if not found
+ */
+export function shg_query_raycast(grid: SpatialHashGrid, origin_x: number, origin_y: number, direction_x: number, direction_y: number, max_distance: number, predicate: Function, predicateContext?: any): number;
+//# sourceMappingURL=shg_query_raycast.d.ts.map

package/src/core/geom/2d/hash-grid/shg_query_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shg_query_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_raycast.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,mEATW,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,gDAGJ,MAAM,CAUlB"}

package/src/core/geom/2d/hash-grid/shg_query_raycast.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {SpatialHashGrid} grid
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} max_distance
+ * @param {function} predicate
+ * @param {*} [predicateContext]
+ * @returns {number} element ID or -1 if not found
+ */
+export function shg_query_raycast(
+    grid,
+    origin_x, origin_y,
+    direction_x, direction_y,
+    max_distance,
+    predicate, predicateContext
+) {
+    throw new Error('NIY');
+}

package/src/core/geom/2d/lt-grid/LooseTightGrid.d.ts

@@ -0,0 +1,55 @@
+/**
+ *
+ *  NOTE: THIS CODE IS UNFINISHED, IT IS ONLY A SKETCH
+ *  TODO finish implementation
+ *
+ * Inspired by Makyen's post on stackoverflow: https://stackoverflow.com/a/48384354
+ * Core idea is to have dynamically-sized bounding volumes that contain our AABBs, and then have a grid-aligned index that stores pointers to these volumes
+ * Makyren called it "Loose/Tight Double-Grid", where "loose" refers to dynamic bounding volumes and tight refers to the grid
+ *
+ * Invariants:
+ *  - An element inserted into the structure will belong to exactly one "loose" cell
+ *
+ */
+export class LooseTightGrid {
+    /**
+     *
+     * @param {number} v
+     */
+    set grid_scale(arg: number);
+    /**
+     *
+     * @returns {number}
+     */
+    get grid_scale(): number;
+    /**
+     *
+     * @param {number} size_x
+     * @param {number} size_y
+     */
+    resize(size_x: number, size_y: number): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    cell_position_to_index(x: number, y: number): number;
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number} index
+     */
+    cell_index_to_position(out: number[], out_offset: number, index: number): void;
+    allocate_datum(): void;
+    insert(): void;
+    /**
+     * Rebuild structure from ground-up
+     * This is an expensive operation
+     * Generally you'll never want to call it explicitly, it is used internally when underlying structure changes
+     */
+    rebuild(): void;
+    #private;
+}
+//# sourceMappingURL=LooseTightGrid.d.ts.map

package/src/core/geom/2d/lt-grid/LooseTightGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LooseTightGrid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/lt-grid/LooseTightGrid.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;GAYG;AACH;IAcI;;;OAGG;IACH,4BAYC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,eAHW,MAAM,UACN,MAAM,QAehB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAUlB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,QAOhB;IAED,uBAEC;IAED,eAEC;IAwDD;;;;OAIG;IACH,gBAgCC;;CAEJ"}

package/src/core/geom/2d/lt-grid/LooseTightGrid.js

@@ -0,0 +1,221 @@
+import { assert } from "../../../assert.js";
+import { UINT32_MAX } from "../../../binary/UINT32_MAX.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { de_interleave_2_bits } from "../../3d/morton/de_interleave_bits_by_2.js";
+import { split_by_2 } from "../../3d/morton/split_by_2.js";
+import { BinaryElementPool } from "../../3d/topology/struct/binary/BinaryElementPool.js";
+
+const NULL_POINTER = UINT32_MAX;
+
+const COLUMN_PARENT = 0;
+const COLUMN_CHILD_1 = 1;
+const COLUMN_CHILD_2 = 2;
+const COLUMN_HEIGHT = 3;
+const COLUMN_AABB_OFFSET = 4;
+
+const COLUMN_USER_DATA = COLUMN_CHILD_2;
+
+/**
+ *
+ *  NOTE: THIS CODE IS UNFINISHED, IT IS ONLY A SKETCH
+ *  TODO finish implementation
+ *
+ * Inspired by Makyen's post on stackoverflow: https://stackoverflow.com/a/48384354
+ * Core idea is to have dynamically-sized bounding volumes that contain our AABBs, and then have a grid-aligned index that stores pointers to these volumes
+ * Makyren called it "Loose/Tight Double-Grid", where "loose" refers to dynamic bounding volumes and tight refers to the grid
+ *
+ * Invariants:
+ *  - An element inserted into the structure will belong to exactly one "loose" cell
+ *
+ */
+export class LooseTightGrid {
+
+    #resolution_x = 0
+    #resolution_y = 0
+
+    // amount of space covered by a single grid cell
+    #grid_scale = 1
+
+    #node_pool = new BinaryElementPool(10 * 4)
+    #grid_data = new Uint32Array(0);
+
+    constructor() {
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set grid_scale(v) {
+        assert.isNumber(v, 'v');
+        assert.greaterThan(v, 0, 'v');
+
+        if (this.#grid_scale === v) {
+            // no change
+            return;
+        }
+
+        this.#grid_scale = v;
+
+        this.rebuild();
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get grid_scale() {
+        return this.#grid_scale;
+    }
+
+    /**
+     *
+     * @param {number} size_x
+     * @param {number} size_y
+     */
+    resize(size_x, size_y) {
+        assert.isNonNegativeInteger(size_x, 'size_x');
+        assert.isNonNegativeInteger(size_y, 'size_y');
+
+        if (this.#resolution_x === size_x && this.#resolution_y === size_y) {
+            // no change
+            return;
+        }
+
+        this.#resolution_x = size_x;
+        this.#resolution_y = size_y;
+
+        this.rebuild();
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    cell_position_to_index(x, y) {
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
+
+        const _x = split_by_2(x);
+        const _y = split_by_2(y);
+
+        return _x | (_y << 1);
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} out_offset
+     * @param {number} index
+     */
+    cell_index_to_position(out, out_offset, index) {
+
+        out[out_offset] = de_interleave_2_bits(index)
+        out[out_offset + 1] = de_interleave_2_bits(index >> 1)
+
+    }
+
+    allocate_datum() {
+
+    }
+
+    insert() {
+
+    }
+
+    /**
+     *
+     * @param {number} node
+     */
+    #node_is_leaf(node) {
+        const address = this.#node_pool.element_word(node);
+
+        return this.#node_pool.data_uint32[address + COLUMN_CHILD_1] === NULL_POINTER;
+    }
+
+    /**
+     * Collect leaves and de-allocate all intermediate nodes
+     * @param {number[]} output
+     * @param {number} output_offset
+     * @param {number} node
+     */
+    #erase_tree_structure(output, output_offset, node) {
+        const pool = this.#node_pool;
+
+        const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+        const top = SCRATCH_UINT32_TRAVERSAL_STACK.pointer;
+
+        stack[stack.pointer++] = node;
+
+        let result_count = 0;
+
+        while (stack.pointer > top) {
+
+            stack.pointer--;
+
+            const n = stack[stack.pointer];
+
+            const node_address = pool.element_word(n);
+
+            const child_1 = pool.data_uint32[node_address + COLUMN_CHILD_1];
+            const child_2 = pool.data_uint32[node_address + COLUMN_CHILD_2];
+
+            if (child_1 === NULL_POINTER) {
+                // leaf node
+                output[output_offset + result_count] = n;
+                result_count++;
+            } else {
+                // binary node
+                stack[stack.pointer++] = child_2;
+                stack[stack.pointer++] = child_1;
+
+                // de-allocate node
+                pool.release(n);
+            }
+        }
+
+        return result_count;
+    }
+
+    /**
+     * Rebuild structure from ground-up
+     * This is an expensive operation
+     * Generally you'll never want to call it explicitly, it is used internally when underlying structure changes
+     */
+    rebuild() {
+        //TODO implement
+
+        let leaf_count = 0;
+        const leaf_nodes = [];
+        // traverse previous grid
+        for (let i = 0; i < this.#grid_data.length; i++) {
+            const node = this.#grid_data[i];
+
+            if (node === NULL_POINTER) {
+                // empty grid cell
+                continue;
+            }
+
+            leaf_count += this.#erase_tree_structure(leaf_nodes, leaf_count, node);
+        }
+
+
+        const resolution_y = this.#resolution_y;
+        const resolution_x = this.#resolution_x;
+
+        const grid_cell_count = resolution_x * resolution_y;
+
+        if (grid_cell_count !== this.#grid_data.length) {
+            this.#grid_data = new Uint32Array(grid_cell_count);
+        }
+
+        // drop all roots
+        this.#grid_data.fill(NULL_POINTER);
+
+        // re-insert all leaves
+
+    }
+
+}

package/src/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -174,8 +174,8 @@ export class QuadTreeNode extends AABB2 {
                 }
             }
 
-            const xm = (x0 + x1) / 2;
-            const ym = (y0 + y1) / 2;
+            const xm = (x0 + x1) *0.5;
+            const ym = (y0 + y1) *0.5;
 
             if (datum.y1 < ym) {
                 //top
@@ -189,7 +189,7 @@ export class QuadTreeNode extends AABB2 {
                     this.addDatum(datum);
                 }
             } else if (datum.y0 >= ym) {
-                //top
+                //bottom
                 if (datum.x1 < xm) {
                     //left
                     this.bottomLeft.insertDatum(datum);

package/src/core/geom/2d/quad-tree/qt_query_data_raycast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qt_query_data_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_query_data_raycast.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,0EATW,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,2CAGJ,mBAAiB,SAAS,CAiEtC"}
+{"version":3,"file":"qt_query_data_raycast.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree/qt_query_data_raycast.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,0EATW,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,2CAGJ,mBAAiB,SAAS,CA0EtC"}

package/src/core/geom/2d/quad-tree/qt_query_data_raycast.js

@@ -1,4 +1,4 @@
-import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
+import { aabb2_intersects_ray } from "../aabb/aabb2_intersects_ray.js";
 
 /**
  *
@@ -38,16 +38,21 @@ export function qt_query_data_raycast(
      * @type {QuadTreeDatum<T>|undefined}
      */
     let best_match = undefined;
-    let best_match_distance2 = max_distance2;
+    let best_match_distance = max_distance;
 
     while (stack_pointer > 0) {
 
         --stack_pointer;
         const node = node_stack[stack_pointer];
 
-        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, origin_x, origin_y);
+        const d2 = aabb2_intersects_ray(node.x0, node.y0, node.x1, node.y1, origin_x, origin_y, direction_x, direction_y);
 
-        if (d2 > best_match_distance2) {
+        if (d2 < 0) {
+            // no hit
+            continue;
+        }
+
+        if (d2 > best_match_distance) {
             // too far, not a match
             continue;
         }
@@ -58,17 +63,21 @@ export function qt_query_data_raycast(
         for (let i = 0; i < data_count; i++) {
             const datum = data[i];
 
-            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, origin_x, origin_y);
+            const d_to_datum = aabb2_intersects_ray(datum.x0, datum.y0, datum.x1, datum.y1, origin_x, origin_y, direction_x, direction_y);
+
+            if (d_to_datum < 0) {
+                continue;
+            }
 
-            if (d2_to_datum < best_match_distance2 && predicate.call(
+            if (d_to_datum < best_match_distance && predicate.call(
                 predicateContext,
                 datum.data,
                 origin_x, origin_y,
                 direction_x, direction_y,
-                best_match_distance2
+                best_match_distance
             )) {
                 best_match = datum;
-                best_match_distance2 = d2_to_datum;
+                best_match_distance = d_to_datum;
             }
         }
 

package/src/core/geom/2d/quad-tree-binary/QuadTree.d.ts

@@ -0,0 +1,94 @@
+export const QT_NULL_POINTER: number;
+/**
+ *
+ *  NOTE: THIS CODE IS UNFINISHED, IT IS ONLY A SKETCH
+ *  TODO finish implementation
+ */
+export class QuadTree {
+    /**
+     * Parameters allow us to set initial bounds to prevent early resizing
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    constructor(x0?: number, y0?: number, x1?: number, y1?: number);
+    get root(): number;
+    /**
+     * Resize dimensions of the tree to tightly fit all inserted elements
+     */
+    shrink(): void;
+    /**
+     *
+     * @param {number[]|Float32Array} output
+     */
+    compute_tight_bounds(output: number[] | Float32Array): void;
+    /**
+     * Rebuild tree but keep all the data
+     */
+    rebuild(): void;
+    /**
+     *
+     * @returns {number} ID of data in the tree
+     */
+    element_allocate(): number;
+    /**
+     *
+     * @param {number} element
+     * @param {number}  user_data
+     */
+    element_set_user_data(element: number, user_data: number): void;
+    /**
+     *
+     * @param {number} element
+     * @return {number}
+     */
+    element_get_user_data(element: number): number;
+    /**
+     *
+     * @param {number} element
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    element_set_bounds_primitive(element: number, x0: number, y0: number, x1: number, y1: number): void;
+    /**
+     *
+     * @param {number} element
+     * @return {number} next element in the node
+     */
+    element_get_next(element: number): number;
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
+    ensure_bounds(x0: number, y0: number, x1: number, y1: number): void;
+    /**
+     * Assumes element is allocated and is not present in the tree yet
+     * @param {number} element
+     */
+    element_insert(element: number): void;
+    /**
+     *
+     * @param {number} node
+     * @param {number[]|Uint32Array} destination
+     * @param {number} destination_offset
+     * @return {number} number of elements read
+     */
+    node_read_elements(node: number, destination: number[] | Uint32Array, destination_offset: number): number;
+    /**
+     *
+     * @param {number} datum_id ID of data in tree
+     */
+    element_remove(datum_id: number): void;
+    /**
+     * Remove all data
+     */
+    release_all(): void;
+    #private;
+}
+//# sourceMappingURL=QuadTree.d.ts.map

package/src/core/geom/2d/quad-tree-binary/QuadTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuadTree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/quad-tree-binary/QuadTree.js"],"names":[],"mappings":"AAMA,qCAA0C;AA4C1C;;;;GAIG;AACH;IAaI;;;;;;OAMG;IACH,iBALW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,EAIhB;IAED,mBAEC;IAiCD;;OAEG;IACH,eAaC;IAED;;;OAGG;IACH,6BAFW,MAAM,EAAE,GAAC,YAAY,QAmC/B;IAED;;OAEG;IACH,gBAcC;IAED;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,+BAHW,MAAM,aACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACL,MAAM,CAOjB;IAED;;;;;;;OAOG;IACH,sCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA+BhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACL,MAAM,CAOjB;IAsFD;;;;;;OAMG;IACH,kBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA6BhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QA4BhB;IAwCD;;;;;;OAMG;IACH,yBALW,MAAM,eACN,MAAM,EAAE,GAAC,WAAW,sBACpB,MAAM,GACL,MAAM,CAmBjB;IA0DD;;;OAGG;IACH,yBAFW,MAAM,QAUhB;IAkJD;;OAEG;IACH,oBAIC;;CACJ"}