@woosh/meep-engine 3.8.0 → 3.10.0

package/src/avif/native/av1/transform/inverse_transform_2d.js

@@ -0,0 +1,180 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import {
+    ADST_ADST,
+    ADST_DCT,
+    ADST_FLIPADST,
+    DCT_ADST,
+    DCT_DCT,
+    DCT_FLIPADST,
+    FLIPADST_ADST,
+    FLIPADST_DCT,
+    FLIPADST_FLIPADST,
+    H_ADST,
+    H_DCT,
+    H_FLIPADST,
+    V_ADST,
+    V_DCT,
+    V_FLIPADST
+} from "../tables/av1_symbols.js";
+import { TRANSFORM_ROW_SHIFT } from "../tables/transform_tables.js";
+import { TX_HEIGHT_LOG2, TX_WIDTH_LOG2 } from "../tables/block_tables.js";
+import { round2 } from "../util/round2.js";
+import { inverse_adst, inverse_dct, inverse_identity, inverse_wht, round2_12 } from "./inverse_transform_1d.js";
+
+/**
+ * Whether the row (horizontal) transform for `tx_type` is a DCT. Exported because the encoder's
+ * forward transform has to be the inverse of whichever pair this picks.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function row_is_dct(tx_type) {
+    return tx_type === DCT_DCT || tx_type === ADST_DCT || tx_type === FLIPADST_DCT || tx_type === H_DCT;
+}
+
+/**
+ * Whether the row (horizontal) transform for `tx_type` is an ADST.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function row_is_adst(tx_type) {
+    return tx_type === DCT_ADST
+        || tx_type === ADST_ADST
+        || tx_type === DCT_FLIPADST
+        || tx_type === FLIPADST_FLIPADST
+        || tx_type === ADST_FLIPADST
+        || tx_type === FLIPADST_ADST
+        || tx_type === H_ADST
+        || tx_type === H_FLIPADST;
+}
+
+/**
+ * Whether the column (vertical) transform for `tx_type` is a DCT.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function column_is_dct(tx_type) {
+    return tx_type === DCT_DCT || tx_type === DCT_ADST || tx_type === DCT_FLIPADST || tx_type === V_DCT;
+}
+
+/**
+ * Whether the column (vertical) transform for `tx_type` is an ADST.
+ * @param {number} tx_type
+ * @returns {boolean}
+ */
+export function column_is_adst(tx_type) {
+    return tx_type === ADST_DCT
+        || tx_type === ADST_ADST
+        || tx_type === FLIPADST_DCT
+        || tx_type === FLIPADST_FLIPADST
+        || tx_type === ADST_FLIPADST
+        || tx_type === FLIPADST_ADST
+        || tx_type === V_ADST
+        || tx_type === V_FLIPADST;
+}
+
+/**
+ * 2D inverse transform, in place.
+ *
+ * `residual` holds the dequantised coefficients on entry, row-major with stride `1 << log2W`, and
+ * the spatial residual on exit. Coefficients only ever occupy the top-left 32x32 of a block, and
+ * the caller is responsible for having zeroed the rest — the specification reads those positions as
+ * zero rather than as whatever was left there.
+ *
+ * @param {Int32Array} residual
+ * @param {number} tx_size
+ * @param {number} tx_type
+ * @param {number} lossless `1` to use the Walsh-Hadamard transform
+ * @param {number} bit_depth
+ * @param {Int32Array} t scratch of at least 64 entries
+ * @see AV1 spec 7.13.3 "2D inverse transform process"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function inverse_transform_2d(residual, tx_size, tx_type, lossless, bit_depth, t) {
+    const log2_w = TX_WIDTH_LOG2[tx_size];
+    const log2_h = TX_HEIGHT_LOG2[tx_size];
+
+    const w = 1 << log2_w;
+    const h = 1 << log2_h;
+
+    const row_shift = lossless === 1 ? 0 : TRANSFORM_ROW_SHIFT[tx_size];
+    const column_shift = lossless === 1 ? 0 : 4;
+
+    const row_clamp_range = bit_depth + 8;
+    const column_clamp_range = Math.max(bit_depth + 6, 16);
+
+    // a transform whose sides differ by a factor of two carries an extra 1/sqrt(2) so that the
+    // basis stays orthonormal; it is folded into the row pass
+    const rectangular = Math.abs(log2_w - log2_h) === 1;
+
+    for (let i = 0; i < h; i++) {
+        const row = i * w;
+
+        let occupied = 0;
+
+        for (let j = 0; j < w; j++) {
+            const coefficient = i < 32 && j < 32 ? residual[row + j] : 0;
+
+            t[j] = coefficient;
+            occupied |= coefficient;
+        }
+
+        // every step of every one of these transforms is a multiply and a rounded shift of its
+        // inputs, and none of them adds a constant, so a row of zeros comes out of all of them as a
+        // row of zeros. Past the end of a block a quantiser emptied that is most of the rows, and
+        // finding out costs one comparison per coefficient against the whole transform it skips
+        if (occupied === 0) {
+            residual.fill(0, row, row + w);
+
+            continue;
+        }
+
+        if (rectangular) {
+            for (let j = 0; j < w; j++) {
+                t[j] = round2_12(t[j] * 2896);
+            }
+        }
+
+        if (lossless === 1) {
+            inverse_wht(t, 2);
+        } else if (row_is_dct(tx_type)) {
+            inverse_dct(t, log2_w, row_clamp_range);
+        } else if (row_is_adst(tx_type)) {
+            inverse_adst(t, log2_w, row_clamp_range);
+        } else {
+            inverse_identity(t, log2_w);
+        }
+
+        for (let j = 0; j < w; j++) {
+            residual[row + j] = round2(t[j], row_shift);
+        }
+    }
+
+    const column_low = -(1 << (column_clamp_range - 1));
+    const column_high = (1 << (column_clamp_range - 1)) - 1;
+
+    for (let i = 0; i < h * w; i++) {
+        residual[i] = clamp(residual[i], column_low, column_high);
+    }
+
+    for (let j = 0; j < w; j++) {
+        for (let i = 0; i < h; i++) {
+            t[i] = residual[i * w + j];
+        }
+
+        if (lossless === 1) {
+            inverse_wht(t, 0);
+        } else if (column_is_dct(tx_type)) {
+            inverse_dct(t, log2_h, column_clamp_range);
+        } else if (column_is_adst(tx_type)) {
+            inverse_adst(t, log2_h, column_clamp_range);
+        } else {
+            inverse_identity(t, log2_h);
+        }
+
+        for (let i = 0; i < h; i++) {
+            residual[i * w + j] = round2(t[i], column_shift);
+        }
+    }
+}

package/src/avif/native/av1/util/ceil_log2.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `CeilLog2( x )` from the AV1 specification: the number of bits needed to code a value in the
+ * range `0 .. x - 1`. Defined to be `0` for `x < 2`.
+ *
+ * @param {number} x 32-bit unsigned integer, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function ceil_log2(x: number): number;
+//# sourceMappingURL=ceil_log2.d.ts.map

package/src/avif/native/av1/util/ceil_log2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ceil_log2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/ceil_log2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,6BAPW,MAAM,GACJ,MAAM,CAYlB"}

package/src/avif/native/av1/util/ceil_log2.js

@@ -0,0 +1,18 @@
+/**
+ * `CeilLog2( x )` from the AV1 specification: the number of bits needed to code a value in the
+ * range `0 .. x - 1`. Defined to be `0` for `x < 2`.
+ *
+ * @param {number} x 32-bit unsigned integer, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function ceil_log2(x) {
+    if (x < 2) {
+        return 0;
+    }
+
+    return 32 - Math.clz32(x - 1);
+}

package/src/avif/native/av1/util/floor_log2.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `FloorLog2( x )` from the AV1 specification: the position of the most significant set bit.
+ *
+ * The specification guarantees `x >= 1` at every call site. `x === 0` returns `-1` here rather than
+ * throwing, matching what the specification's own shift-loop definition would produce, so a caller
+ * that reaches it with zero fails on the resulting index rather than being masked by a clamp.
+ *
+ * The core primitive under its own name: `msb_32` is the same operation, and the alias exists so
+ * that code transliterated from the specification can be read against it.
+ *
+ * @param {number} x 32-bit unsigned integer
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const floor_log2: typeof msb_32;
+import { msb_32 } from "../../../../core/binary/msb_32.js";
+//# sourceMappingURL=floor_log2.d.ts.map

package/src/avif/native/av1/util/floor_log2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor_log2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/floor_log2.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,uCAAiC;uBAnBV,mCAAmC"}

package/src/avif/native/av1/util/floor_log2.js

@@ -0,0 +1,20 @@
+import { msb_32 } from "../../../../core/binary/msb_32.js";
+
+/**
+ * `FloorLog2( x )` from the AV1 specification: the position of the most significant set bit.
+ *
+ * The specification guarantees `x >= 1` at every call site. `x === 0` returns `-1` here rather than
+ * throwing, matching what the specification's own shift-loop definition would produce, so a caller
+ * that reaches it with zero fails on the resulting index rather than being masked by a clamp.
+ *
+ * The core primitive under its own name: `msb_32` is the same operation, and the alias exists so
+ * that code transliterated from the specification can be read against it.
+ *
+ * @param {number} x 32-bit unsigned integer
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const floor_log2 = msb_32;

package/src/avif/native/av1/util/round2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `Round2( x, n )` from the AV1 specification: divide by `2^n` and round half up, rounding towards
+ * negative infinity on the halfway case for negative inputs.
+ *
+ * The specification defines this with real division and a floor; JavaScript's `>>` is an arithmetic
+ * shift, which is exactly that floor, so the integer form transliterates directly. The `n === 0`
+ * guard is not cosmetic: `1 << -1` is `1 << 31` under JavaScript's shift-count masking, which would
+ * silently produce garbage.
+ *
+ * `x` must fit in a signed 32-bit integer, which every intermediate the specification feeds to this
+ * function does.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function round2(x: number, n: number): number;
+//# sourceMappingURL=round2.d.ts.map

package/src/avif/native/av1/util/round2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/round2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,0BARW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB"}

package/src/avif/native/av1/util/round2.js

@@ -0,0 +1,27 @@
+/**
+ * `Round2( x, n )` from the AV1 specification: divide by `2^n` and round half up, rounding towards
+ * negative infinity on the halfway case for negative inputs.
+ *
+ * The specification defines this with real division and a floor; JavaScript's `>>` is an arithmetic
+ * shift, which is exactly that floor, so the integer form transliterates directly. The `n === 0`
+ * guard is not cosmetic: `1 << -1` is `1 << 31` under JavaScript's shift-count masking, which would
+ * silently produce garbage.
+ *
+ * `x` must fit in a signed 32-bit integer, which every intermediate the specification feeds to this
+ * function does.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function round2(x, n) {
+    if (n === 0) {
+        return x;
+    }
+
+    return (x + (1 << (n - 1))) >> n;
+}

package/src/avif/native/av1/util/round2_signed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `Round2Signed( x, n )` from the AV1 specification: {@link round2} applied to the magnitude, so
+ * that rounding is symmetric about zero rather than biased towards negative infinity.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function round2_signed(x: number, n: number): number;
+//# sourceMappingURL=round2_signed.d.ts.map

package/src/avif/native/av1/util/round2_signed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round2_signed.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/round2_signed.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,iCARW,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB"}

package/src/avif/native/av1/util/round2_signed.js

@@ -0,0 +1,17 @@
+import { round2 } from "./round2.js";
+
+/**
+ * `Round2Signed( x, n )` from the AV1 specification: {@link round2} applied to the magnitude, so
+ * that rounding is symmetric about zero rather than biased towards negative infinity.
+ *
+ * @param {number} x
+ * @param {number} n number of bits to shift away, `>= 0`
+ * @returns {number}
+ * @see AV1 spec 4.7 "Mathematical functions"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function round2_signed(x, n) {
+    return x >= 0 ? round2(x, n) : -round2(-x, n);
+}

package/src/avif/native/av1/util/tile_log2.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `tile_log2( blkSize, target )`: the smallest `k` for which `blkSize << k >= target`.
+ *
+ * The specification writes this as a loop, and a loop is what it stays: the closed form would need
+ * a ceiling of a ratio of logarithms, and the inputs here are tiny.
+ *
+ * @param {number} block_size
+ * @param {number} target
+ * @returns {number}
+ * @see AV1 spec 5.9.16 "Tile size calculation function"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tile_log2(block_size: number, target: number): number;
+//# sourceMappingURL=tile_log2.d.ts.map

package/src/avif/native/av1/util/tile_log2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile_log2.d.ts","sourceRoot":"","sources":["../../../../../../src/avif/native/av1/util/tile_log2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,sCARW,MAAM,UACN,MAAM,GACJ,MAAM,CAclB"}

package/src/avif/native/av1/util/tile_log2.js

@@ -0,0 +1,23 @@
+/**
+ * `tile_log2( blkSize, target )`: the smallest `k` for which `blkSize << k >= target`.
+ *
+ * The specification writes this as a loop, and a loop is what it stays: the closed form would need
+ * a ceiling of a ratio of logarithms, and the inputs here are tiny.
+ *
+ * @param {number} block_size
+ * @param {number} target
+ * @returns {number}
+ * @see AV1 spec 5.9.16 "Tile size calculation function"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tile_log2(block_size, target) {
+    let k = 0;
+
+    while ((block_size << k) < target) {
+        k++;
+    }
+
+    return k;
+}

package/src/avif/native/bitstream/BitReader.d.ts

@@ -0,0 +1,174 @@
+/**
+ * MSB-first bit cursor over a byte range, carrying the AV1 bitstream descriptors.
+ *
+ * This is the counterpart to {@link BitWriter}. It reads out of an existing `Uint8Array` without
+ * copying, so a reader can be pointed at a slice of a much larger file cheaply. Bounds are checked
+ * on every read: a truncated or malformed stream throws rather than reading zeroes off the end of
+ * the buffer and producing a plausible-looking but wrong header.
+ *
+ * It is a struct with methods rather than a struct plus free functions because that is the shape
+ * meep already uses for stream cursors ({@link BinaryBuffer}), and because a bit cursor's whole
+ * purpose is the coupling of the position to the buffer.
+ *
+ * Not used for tile data: arithmetic-coded payloads are read by the symbol decoder straight from
+ * the byte array, so this class is never on a per-sample path.
+ *
+ * @see AV1 spec 4.10 "Descriptors"
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BitReader {
+    /**
+     * Bytes being read. Not owned.
+     * @type {Uint8Array}
+     */
+    data: Uint8Array;
+    /**
+     * Index into {@link data} of the byte holding the next bit.
+     * @type {number}
+     */
+    byte_position: number;
+    /**
+     * Index of the next bit within the byte at {@link byte_position}, `0` being the most
+     * significant bit.
+     * @type {number}
+     */
+    bit_position: number;
+    /**
+     * Index into {@link data} one past the last readable byte.
+     * @type {number}
+     */
+    end: number;
+    /**
+     * Index into {@link data} of the first readable byte. Kept so {@link position_in_bits} can be
+     * reported relative to the start of the range rather than the start of the array.
+     * @type {number}
+     */
+    start: number;
+    /**
+     * Number of bytes consumed by the most recent {@link leb128} call. The AV1 syntax refers to
+     * this as `Leb128Bytes` and several OBU size computations need it.
+     * @type {number}
+     */
+    leb128_bytes: number;
+    /**
+     * Point the reader at a byte range. Cheap: no allocation, no copy, so a reader can be reused
+     * across many payloads.
+     *
+     * @param {Uint8Array} data
+     * @param {number} [byte_offset] offset within `data` to start at
+     * @param {number} [byte_length] number of bytes readable from `byte_offset`
+     * @returns {BitReader} this
+     */
+    init(data: Uint8Array, byte_offset?: number, byte_length?: number): BitReader;
+    /**
+     * Bits consumed since {@link init}.
+     * @returns {number}
+     */
+    get position_in_bits(): number;
+    /**
+     * Bits left before the end of the range.
+     * @returns {number}
+     */
+    get bits_remaining(): number;
+    /**
+     * Whether the cursor sits on a byte boundary. Several descriptors are only legal there.
+     * @returns {boolean}
+     */
+    get is_byte_aligned(): boolean;
+    /**
+     * `f(1)`. The single primitive every other descriptor is built from.
+     * @returns {number} `0` or `1`
+     */
+    read_bit(): number;
+    /**
+     * `f(n)`: unsigned `n`-bit number, most significant bit first.
+     *
+     * Accumulates with multiplication rather than `<<` so that `n === 32` does not overflow into a
+     * negative number. Bits are taken a byte at a time rather than one at a time, which matters
+     * because sequence headers read a lot of 8- and 16-bit fields.
+     *
+     * @param {number} n `0 .. 32`
+     * @returns {number}
+     * @see AV1 spec 8.1 "Parsing process for f(n)"
+     */
+    f(n: number): number;
+    /**
+     * `su(n)`: signed integer whose bottom `n` bits appear in the bitstream.
+     *
+     * @param {number} n `1 .. 32`
+     * @returns {number}
+     * @see AV1 spec 4.10.6 "su(n)"
+     */
+    su(n: number): number;
+    /**
+     * `ns(n)`: unsigned integer in `0 .. n - 1`, coded with one bit fewer over the lower part of
+     * the range.
+     *
+     * @param {number} n number of distinct values, `>= 1`
+     * @returns {number}
+     * @see AV1 spec 4.10.7 "ns(n)"
+     */
+    ns(n: number): number;
+    /**
+     * `uvlc()`: Exp-Golomb-style variable length unsigned number.
+     *
+     * A run of 32 or more leading zeroes is the specification's encoding of `(1 << 32) - 1` and is
+     * returned as such rather than treated as corruption. The leading-zero count is still bounded
+     * by the buffer, so a stream of zero bytes terminates on the range check in {@link read_bit}.
+     *
+     * @returns {number}
+     * @see AV1 spec 4.10.3 "uvlc()"
+     */
+    uvlc(): number;
+    /**
+     * `le(n)`: unsigned little-endian `n`-byte number. Only legal on a byte boundary.
+     *
+     * @param {number} n number of bytes
+     * @returns {number}
+     * @see AV1 spec 4.10.4 "le(n)"
+     */
+    le(n: number): number;
+    /**
+     * `leb128()`: unsigned integer in a variable number of little-endian 7-bit groups. Only legal
+     * on a byte boundary. Sets {@link leb128_bytes}.
+     *
+     * Accumulates with multiplication because a conforming eight-byte encoding carries 56 bits of
+     * payload; the value itself is required to fit in 32 bits, which is checked, but the shift
+     * would have wrapped before the check could run.
+     *
+     * @returns {number}
+     * @see AV1 spec 4.10.5 "leb128()"
+     */
+    leb128(): number;
+    /**
+     * Skip forward to the next byte boundary, requiring the skipped bits to be zero as the
+     * specification's `byte_alignment()` does.
+     *
+     * @see AV1 spec 5.3.5 "Byte alignment syntax"
+     */
+    byte_alignment(): void;
+    /**
+     * Consume the `trailing_one_bit` plus zero padding that terminates an OBU payload.
+     *
+     * @see AV1 spec 5.3.4 "Trailing bits syntax"
+     */
+    trailing_bits(): void;
+    /**
+     * Advance to the next byte boundary without checking what the skipped bits contain.
+     *
+     * The specification says the padding "shall be equal to 0", and {@link byte_alignment} enforces
+     * that. A decoder cannot afford to: libaom rounds a frame header up to a whole byte by simply
+     * advancing its write cursor, so inside an OBU_FRAME those bits are whatever was already in its
+     * output buffer. Refusing such a file would reject a large share of the AVIFs in existence over
+     * bits nothing reads.
+     */
+    skip_to_byte_boundary(): void;
+    /**
+     * Advance the cursor by whole bytes without reading. Requires byte alignment.
+     * @param {number} count
+     */
+    skip_bytes(count: number): void;
+}
+//# sourceMappingURL=BitReader.d.ts.map

package/src/avif/native/bitstream/BitReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BitReader.d.ts","sourceRoot":"","sources":["../../../../../src/avif/native/bitstream/BitReader.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACI;;;OAGG;IACH,MAFU,UAAU,CAER;IAEZ;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,KAFU,MAAM,CAER;IAER;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,WALW,UAAU,gBACV,MAAM,gBACN,MAAM,GACJ,SAAS,CAerB;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,YAFa,MAAM,CAiBlB;IAED;;;;;;;;;;OAUG;IACH,KAJW,MAAM,GACJ,MAAM,CA6ClB;IAED;;;;;;OAMG;IACH,MAJW,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;;OAOG;IACH,MAJW,MAAM,GACJ,MAAM,CAclB;IAED;;;;;;;;;OASG;IACH,QAHa,MAAM,CAkBlB;IAED;;;;;;OAMG;IACH,MAJW,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;;;;;;;OAUG;IACH,UAHa,MAAM,CAqClB;IAED;;;;;OAKG;IACH,uBAMC;IAED;;;;OAIG;IACH,sBAUC;IAED;;;;;;;;OAQG;IACH,8BAIC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAYhB;CACJ"}