fractal-midi 0.1.0-alpha.0

package/dist/am4/applicability.js

@@ -0,0 +1,285 @@
+/**
+ * Per-(block, name) applicability helpers — translates the
+ * `typeApplicability.ts` generated data into agent-facing prose and
+ * runtime predicates.
+ *
+ * Used by `list_params` to annotate each parameter row with which
+ * AM4 types expose it, by `set_param` to warn when the agent writes
+ * a knob that the active type doesn't expose, and by `apply_preset`
+ * to surface type/param mismatches before any wire bytes are sent.
+ */
+import { AMP_TYPES, CHORUS_TYPES, COMPRESSOR_TYPES, DELAY_TYPES, DRIVE_TYPES, FILTER_TYPES, FLANGER_TYPES, GATE_TYPES, GEQ_TYPES, PHASER_TYPES, REVERB_TYPES, TREMOLO_TYPES, } from './cacheEnums.js';
+import { TYPE_APPLICABILITY, } from './typeApplicability.js';
+/**
+ * AM4-Edit symbolic enum name → display name array (cacheEnums).
+ * Enums not listed here are surfaced as raw indices in agent-facing
+ * prose. The omitted ones (CABINET_MODE, DISTORT_MODE_1,
+ * DISTORT_EQTYPE, REVERB_SPRINGTYPE, REVERB_LOWSLOPE,
+ * REVERB_HIGHSLOPE, PEQ_TYPE1, PEQ_TYPE5) are sub-mode enums whose
+ * display names we haven't extracted yet — usable as raw indices in
+ * the meantime, easy to add when needed.
+ */
+const ENUM_LOOKUP = {
+    DISTORT_TYPE: AMP_TYPES,
+    AMP_TYPE: AMP_TYPES,
+    FUZZ_TYPE: DRIVE_TYPES,
+    REVERB_TYPE: REVERB_TYPES,
+    REVERB_BASETYPE: REVERB_TYPES,
+    DELAY_TYPE: DELAY_TYPES,
+    DELAY_MODEL: DELAY_TYPES,
+    CHORUS_TYPE: CHORUS_TYPES,
+    FLANGER_TYPE: FLANGER_TYPES,
+    PHASER_TYPE: PHASER_TYPES,
+    TREMOLO_TYPE: TREMOLO_TYPES,
+    COMP_TYPE: COMPRESSOR_TYPES,
+    FILTER_TYPE: FILTER_TYPES,
+    GEQ_TYPE: GEQ_TYPES,
+    GATE_TYPE: GATE_TYPES,
+};
+export function getApplicability(blockDotName) {
+    return TYPE_APPLICABILITY[blockDotName];
+}
+/**
+ * Render a type-enum gate's values as comma-joined display names. Falls
+ * back to `idx N` for enums we don't have a cacheEnums lookup for.
+ */
+function renderTypeNames(gate) {
+    const list = ENUM_LOOKUP[gate.typeEnum] ?? [];
+    return gate.values.map((v) => list[v] ?? `idx ${v}`).join(', ');
+}
+/**
+ * One-line summary of a parameter's applicability for the agent — appears
+ * in `list_params` row decoration. Returns `undefined` for the common
+ * "no applicability data" case (out-of-band registers, params not yet
+ * decoded by the type-applicability extractor) — caller should treat as
+ * always-on. Empty string for confirmed-always-on with no special-case
+ * gates (no decoration needed).
+ */
+export function describeApplicability(blockDotName) {
+    const a = TYPE_APPLICABILITY[blockDotName];
+    if (!a)
+        return undefined;
+    if (a.always && a.gates.length === 0)
+        return '';
+    if (a.always) {
+        // Always-on PLUS special-case pages (e.g. amp.negative_feedback has
+        // a Friedman BE special page in addition to the universal one).
+        // Surface the special cases as informational; agent doesn't need to
+        // gate writes on them.
+        const cases = a.gates.map((g) => `${g.typeEnum}=[${renderTypeNames(g)}]`).join('; ');
+        return `applies to any type (special-cased on: ${cases})`;
+    }
+    // Strictly type-gated. Surface the union of types that expose it.
+    const cases = a.gates.map((g) => `${g.typeEnum}=[${renderTypeNames(g)}]`).join(' OR ');
+    return `applies only when ${cases}`;
+}
+export function checkApplicability(blockDotName, ctx) {
+    const a = TYPE_APPLICABILITY[blockDotName];
+    if (!a)
+        return { applicable: 'unknown' };
+    // Truly universal — no gates at all → applies to every type.
+    if (a.gates.length === 0) {
+        return a.always ? { applicable: true } : { applicable: 'unknown' };
+    }
+    // 2026-05-13 founder-test correction. Original interpretation: if
+    // `a.always === true`, the param applies on every type regardless of
+    // gates ("gates list is informational, special-case pages only"). The
+    // 5F8 Tweed Normal test surfaced that this is wrong for some
+    // metadata-extracted params — amp.master shows `always: true` with a
+    // large primary-type gates list, but the gates list is the AUTHORITATIVE
+    // set of types that expose the param. Wire 185 (5F8 Tweed Normal) is
+    // not in the master gates list; the AM4 silently no-ops master writes
+    // on this amp model. Old interpretation let the write through and
+    // claimed success; new interpretation refuses.
+    //
+    // Concretely: when primary-type gates exist (DISTORT_TYPE / FUZZ_TYPE
+    // / etc.), the active type MUST be in the gate list. Sub-mode gates
+    // (CABINET_MODE, DISTORT_MODE_1, …) are still informational — we
+    // don't track sub-mode state so we can't enforce against them.
+    const block = blockDotName.split('.')[0];
+    const activeIndex = ctx.currentTypes?.[block];
+    if (activeIndex === undefined)
+        return { applicable: 'unknown' };
+    let hasPrimaryGate = false;
+    for (const g of a.gates) {
+        if (!isGateForBlock(g.typeEnum, block))
+            continue;
+        if (!isPrimaryTypeEnum(g.typeEnum, block))
+            continue;
+        hasPrimaryGate = true;
+        if (g.values.includes(activeIndex))
+            return { applicable: true };
+    }
+    if (!hasPrimaryGate) {
+        // Only sub-mode gates — can't enforce; treat as applicable if
+        // `always: true` (the universal-with-special-pages case) or unknown
+        // otherwise (caller's fallback is "let the write through with a
+        // warning" — see preflightApplicabilityWarning).
+        return a.always ? { applicable: true } : { applicable: 'unknown' };
+    }
+    // Primary-type gates exist AND the active type is NOT in any of
+    // them → the param doesn't apply on this type. Refuse the write
+    // rather than letting the device silently no-op it.
+    return { applicable: false, gates: a.gates };
+}
+/**
+ * find_compatible_types: which `block.type` enum values expose every
+ * param in `paramNames`? Used by the unified-surface MCP tool of the
+ * same name so the agent can pick a type compatible with the knobs
+ * it plans to write, BEFORE apply_preset → no "dropped X param"
+ * warning round-trip.
+ *
+ * Algorithm: start with the full type enum, intersect down per param.
+ * Params with no applicability data, or only sub-mode gates (e.g.
+ * CABINET_MODE), can't narrow on the primary-type axis — skipped.
+ * Params with primary-type gates narrow the accepted-types set to the
+ * gate value list.
+ *
+ * Returns `applicability_known: false` when NONE of the listed params
+ * have primary-type gates — caller knows the result is the unfiltered
+ * full list and should treat it as "try and see" rather than "these
+ * are the only valid choices."
+ */
+export function findCompatibleTypes(block, paramNames) {
+    const typeEnum = primaryTypeEnumFor(block);
+    if (typeEnum === undefined) {
+        return {
+            compatible_types: [],
+            total_types: 0,
+            applicability_known: false,
+            note: `block "${block}" has no primary type enum`,
+        };
+    }
+    const enumDisplayNames = ENUM_LOOKUP[typeEnum] ?? [];
+    if (enumDisplayNames.length === 0) {
+        return {
+            compatible_types: [],
+            total_types: 0,
+            applicability_known: false,
+            note: `no display names registered for ${typeEnum}`,
+        };
+    }
+    const totalTypes = enumDisplayNames.length;
+    let accepted = new Set(Array.from({ length: totalTypes }, (_, i) => i));
+    let anyPrimaryGateApplied = false;
+    const skippedParams = [];
+    for (const paramName of paramNames) {
+        const key = `${block}.${paramName}`;
+        const a = TYPE_APPLICABILITY[key];
+        if (a === undefined) {
+            skippedParams.push(`${paramName} (no applicability data — treated as always-on)`);
+            continue;
+        }
+        if (a.always && a.gates.length === 0) {
+            continue;
+        }
+        const exposedHere = new Set();
+        let hasPrimaryGate = false;
+        for (const g of a.gates) {
+            if (g.typeEnum !== typeEnum)
+                continue;
+            hasPrimaryGate = true;
+            for (const v of g.values)
+                exposedHere.add(v);
+        }
+        if (!hasPrimaryGate) {
+            skippedParams.push(`${paramName} (only sub-mode gates — not narrowable on primary type)`);
+            continue;
+        }
+        anyPrimaryGateApplied = true;
+        accepted = new Set([...accepted].filter((idx) => exposedHere.has(idx)));
+        if (accepted.size === 0)
+            break;
+    }
+    const compatibleNames = [...accepted]
+        .sort((a, b) => a - b)
+        .map((idx) => enumDisplayNames[idx])
+        .filter((n) => n !== undefined);
+    const note = skippedParams.length > 0
+        ? `Skipped from narrowing: ${skippedParams.join('; ')}.`
+        : undefined;
+    return {
+        compatible_types: compatibleNames,
+        total_types: totalTypes,
+        applicability_known: anyPrimaryGateApplied,
+        note,
+    };
+}
+/**
+ * Primary type enum for each AM4 block — the enum the agent picks via
+ * `block.type` and that primary-type applicability gates filter on.
+ * Mirrors `isPrimaryTypeEnum` below but returns the enum NAME rather
+ * than a boolean (caller uses it to look up the display-name table).
+ *
+ * Returns undefined for blocks with no primary type enum (e.g. peq,
+ * volpan, ingate) — those exist as block_types but don't have a
+ * `type` selector knob users can pick.
+ */
+function primaryTypeEnumFor(block) {
+    switch (block) {
+        case 'amp': return 'DISTORT_TYPE';
+        case 'drive': return 'FUZZ_TYPE';
+        case 'delay': return 'DELAY_TYPE';
+        case 'reverb': return 'REVERB_TYPE';
+        case 'chorus': return 'CHORUS_TYPE';
+        case 'flanger': return 'FLANGER_TYPE';
+        case 'phaser': return 'PHASER_TYPE';
+        case 'wah': return 'WAH_TYPE';
+        case 'compressor': return 'COMP_TYPE';
+        case 'geq': return 'GEQ_TYPE';
+        case 'filter': return 'FILTER_TYPE';
+        case 'tremolo': return 'TREMOLO_TYPE';
+        case 'gate': return 'GATE_TYPE';
+        default: return undefined;
+    }
+}
+/**
+ * Whether a typeEnum is the block's primary-type enum (the one we track
+ * via `lastKnownType[<block>.type]`). Sub-mode enums (CABINET_MODE,
+ * DISTORT_MODE_1, REVERB_BASETYPE, etc.) gate UI exposure but we don't
+ * read them after every block-type change, so applicability checks
+ * against them must downgrade to 'unknown' instead of firing.
+ */
+function isPrimaryTypeEnum(typeEnum, block) {
+    switch (block) {
+        case 'amp': return typeEnum === 'DISTORT_TYPE' || typeEnum === 'AMP_TYPE';
+        case 'drive': return typeEnum === 'FUZZ_TYPE';
+        case 'delay': return typeEnum === 'DELAY_TYPE' || typeEnum === 'DELAY_MODEL';
+        case 'reverb': return typeEnum === 'REVERB_TYPE';
+        case 'chorus': return typeEnum === 'CHORUS_TYPE';
+        case 'flanger': return typeEnum === 'FLANGER_TYPE';
+        case 'phaser': return typeEnum === 'PHASER_TYPE';
+        case 'wah': return typeEnum === 'WAH_TYPE';
+        case 'compressor': return typeEnum === 'COMP_TYPE';
+        case 'geq': return typeEnum === 'GEQ_TYPE';
+        case 'filter': return typeEnum === 'FILTER_TYPE';
+        case 'tremolo': return typeEnum === 'TREMOLO_TYPE';
+        case 'gate': return typeEnum === 'GATE_TYPE';
+        default: return false;
+    }
+}
+/**
+ * Whether a gate's typeEnum corresponds to a given block. The bulk of
+ * gates are intra-block (DELAY_TYPE on delay params, FUZZ_TYPE on drive
+ * params), but a few cross over (REVERB_BASETYPE / REVERB_SPRINGTYPE
+ * both on reverb params; DISTORT_MODE_1 / CABINET_MODE on amp params).
+ */
+function isGateForBlock(typeEnum, block) {
+    switch (block) {
+        case 'amp': return typeEnum === 'DISTORT_TYPE' || typeEnum === 'AMP_TYPE' || typeEnum === 'DISTORT_MODE_1' || typeEnum === 'DISTORT_EQTYPE' || typeEnum === 'CABINET_MODE';
+        case 'drive': return typeEnum === 'FUZZ_TYPE';
+        case 'delay': return typeEnum === 'DELAY_TYPE' || typeEnum === 'DELAY_MODEL';
+        case 'reverb': return typeEnum === 'REVERB_TYPE' || typeEnum === 'REVERB_BASETYPE' || typeEnum === 'REVERB_SPRINGTYPE' || typeEnum === 'REVERB_LOWSLOPE' || typeEnum === 'REVERB_HIGHSLOPE';
+        case 'chorus': return typeEnum === 'CHORUS_TYPE';
+        case 'flanger': return typeEnum === 'FLANGER_TYPE';
+        case 'phaser': return typeEnum === 'PHASER_TYPE';
+        case 'wah': return typeEnum === 'WAH_TYPE';
+        case 'compressor': return typeEnum === 'COMP_TYPE';
+        case 'geq': return typeEnum === 'GEQ_TYPE';
+        case 'peq': return typeEnum === 'PEQ_TYPE1' || typeEnum === 'PEQ_TYPE5';
+        case 'filter': return typeEnum === 'FILTER_TYPE';
+        case 'tremolo': return typeEnum === 'TREMOLO_TYPE';
+        case 'gate': return typeEnum === 'GATE_TYPE';
+        default: return false;
+    }
+}

package/dist/am4/blockTypes.d.ts

@@ -0,0 +1,43 @@
+/**
+ * AM4 block-type dictionary.
+ *
+ * Used by block-placement writes: the AM4 addresses "which block lives in
+ * slot N" by writing the target block's own pidLow as a float32 into a
+ * dedicated slot register (pidLow=0x00CE, pidHigh=0x0010+slot-1). Passing
+ * 0 clears the slot ("none").
+ *
+ * These pidLows match the addresses used by `KNOWN_PARAMS` in `params.ts`
+ * (block.type writes, block.gain writes, etc.) — they're intentionally the
+ * same constants, duplicated here only to give block placement a clean
+ * dictionary without reaching into the param registry.
+ */
+export declare const BLOCK_TYPE_VALUES: {
+    readonly none: 0;
+    readonly amp: 58;
+    readonly compressor: 46;
+    readonly geq: 50;
+    readonly peq: 54;
+    readonly reverb: 66;
+    readonly delay: 70;
+    readonly chorus: 78;
+    readonly flanger: 82;
+    readonly rotary: 86;
+    readonly phaser: 90;
+    readonly wah: 94;
+    readonly volpan: 102;
+    readonly tremolo: 106;
+    readonly filter: 114;
+    readonly drive: 118;
+    readonly enhancer: 122;
+    readonly gate: 146;
+};
+export type BlockTypeName = keyof typeof BLOCK_TYPE_VALUES;
+/** Reverse lookup: wire value (block pidLow) → block name. */
+export declare const BLOCK_NAMES_BY_VALUE: Record<number, BlockTypeName>;
+/**
+ * Resolve a user-supplied block identifier to its wire value. Accepts the
+ * lowercase block name (case-insensitive) or a numeric pidLow directly.
+ * Returns undefined on an unknown name.
+ */
+export declare function resolveBlockType(input: string | number): number | undefined;
+//# sourceMappingURL=blockTypes.d.ts.map

package/dist/am4/blockTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockTypes.d.ts","sourceRoot":"","sources":["../../src/am4/blockTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;CAmBpB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,iBAAiB,CAAC;AAE3D,8DAA8D;AAC9D,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAE9D,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAK3E"}

package/dist/am4/blockTypes.js

@@ -0,0 +1,48 @@
+/**
+ * AM4 block-type dictionary.
+ *
+ * Used by block-placement writes: the AM4 addresses "which block lives in
+ * slot N" by writing the target block's own pidLow as a float32 into a
+ * dedicated slot register (pidLow=0x00CE, pidHigh=0x0010+slot-1). Passing
+ * 0 clears the slot ("none").
+ *
+ * These pidLows match the addresses used by `KNOWN_PARAMS` in `params.ts`
+ * (block.type writes, block.gain writes, etc.) — they're intentionally the
+ * same constants, duplicated here only to give block placement a clean
+ * dictionary without reaching into the param registry.
+ */
+export const BLOCK_TYPE_VALUES = {
+    none: 0x0000, // empty slot
+    amp: 0x003a,
+    compressor: 0x002e,
+    geq: 0x0032,
+    peq: 0x0036, // pidLow pinned Session 18; no Type enum known
+    reverb: 0x0042,
+    delay: 0x0046,
+    chorus: 0x004e,
+    flanger: 0x0052,
+    rotary: 0x0056, // pidLow pinned Session 18; no Type enum known
+    phaser: 0x005a,
+    wah: 0x005e,
+    volpan: 0x0066,
+    tremolo: 0x006a,
+    filter: 0x0072,
+    drive: 0x0076,
+    enhancer: 0x007a,
+    gate: 0x0092,
+};
+/** Reverse lookup: wire value (block pidLow) → block name. */
+export const BLOCK_NAMES_BY_VALUE = Object.fromEntries(Object.entries(BLOCK_TYPE_VALUES).map(([k, v]) => [v, k]));
+/**
+ * Resolve a user-supplied block identifier to its wire value. Accepts the
+ * lowercase block name (case-insensitive) or a numeric pidLow directly.
+ * Returns undefined on an unknown name.
+ */
+export function resolveBlockType(input) {
+    if (typeof input === 'number')
+        return input;
+    const norm = input.trim().toLowerCase();
+    if (norm in BLOCK_TYPE_VALUES)
+        return BLOCK_TYPE_VALUES[norm];
+    return undefined;
+}

package/dist/am4/cacheEnums.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generated by scripts/gen-cache-enums.ts — do not hand-edit.
+ *
+ * Source: AM4-Edit metadata cache (effectDefinitions_15_2p0.cache),
+ * parsed by scripts/parse-cache.ts, verified against wire captures
+ * by scripts/map-cache-params.ts (Session 15).
+ *
+ * Each array lists the firmware's effect-type dictionary in wire
+ * order. The wire value sent in SET_PARAM (at pidHigh=0x000A of the
+ * block's pidLow) is the integer index encoded as a float32.
+ */
+export declare const AMP_TYPES: readonly string[];
+export declare const DRIVE_TYPES: readonly string[];
+export declare const REVERB_TYPES: readonly string[];
+export declare const DELAY_TYPES: readonly string[];
+export declare const CHORUS_TYPES: readonly string[];
+export declare const FLANGER_TYPES: readonly string[];
+export declare const PHASER_TYPES: readonly string[];
+export declare const WAH_TYPES: readonly string[];
+export declare const COMPRESSOR_TYPES: readonly string[];
+export declare const GEQ_TYPES: readonly string[];
+export declare const FILTER_TYPES: readonly string[];
+export declare const TREMOLO_TYPES: readonly string[];
+export declare const ENHANCER_TYPES: readonly string[];
+export declare const GATE_TYPES: readonly string[];
+export declare const VOLPAN_MODES: readonly string[];
+export declare const TEMPO_DIVISIONS: readonly string[];
+export declare const LFO_WAVEFORMS: readonly string[];
+export declare const AMP_TYPES_VALUES: Record<number, string>;
+export declare const DRIVE_TYPES_VALUES: Record<number, string>;
+export declare const REVERB_TYPES_VALUES: Record<number, string>;
+export declare const DELAY_TYPES_VALUES: Record<number, string>;
+export declare const CHORUS_TYPES_VALUES: Record<number, string>;
+export declare const FLANGER_TYPES_VALUES: Record<number, string>;
+export declare const PHASER_TYPES_VALUES: Record<number, string>;
+export declare const WAH_TYPES_VALUES: Record<number, string>;
+export declare const COMPRESSOR_TYPES_VALUES: Record<number, string>;
+export declare const GEQ_TYPES_VALUES: Record<number, string>;
+export declare const FILTER_TYPES_VALUES: Record<number, string>;
+export declare const TREMOLO_TYPES_VALUES: Record<number, string>;
+export declare const ENHANCER_TYPES_VALUES: Record<number, string>;
+export declare const GATE_TYPES_VALUES: Record<number, string>;
+export declare const VOLPAN_MODES_VALUES: Record<number, string>;
+export declare const TEMPO_DIVISIONS_VALUES: Record<number, string>;
+export declare const LFO_WAVEFORMS_VALUES: Record<number, string>;
+//# sourceMappingURL=cacheEnums.d.ts.map

package/dist/am4/cacheEnums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheEnums.d.ts","sourceRoot":"","sources":["../../src/am4/cacheEnums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAyP7B,CAAC;AAEX,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EA+E/B,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAgFhC,CAAC;AAEX,eAAO,MAAM,WAAW,EAAE,SAAS,MAAM,EA8B/B,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAqBhC,CAAC;AAEX,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAiCjC,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAkBhC,CAAC;AAEX,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAU7B,CAAC;AAEX,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAoBpC,CAAC;AAEX,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAmB7B,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAmBhC,CAAC;AAEX,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAQjC,CAAC;AAEX,eAAO,MAAM,cAAc,EAAE,SAAS,MAAM,EAIlC,CAAC;AAEX,eAAO,MAAM,UAAU,EAAE,SAAS,MAAM,EAK9B,CAAC;AAEX,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAGhC,CAAC;AAEX,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAgFnC,CAAC;AAEX,eAAO,MAAM,aAAa,EAAE,SAAS,MAAM,EAWjC,CAAC;AAEX,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAgE,CAAC;AACrH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAkE,CAAC;AACzH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAmE,CAAC;AAC3H,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAkE,CAAC;AACzH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAmE,CAAC;AAC3H,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAoE,CAAC;AAC7H,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAmE,CAAC;AAC3H,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAgE,CAAC;AACrH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAuE,CAAC;AACnI,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAgE,CAAC;AACrH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAmE,CAAC;AAC3H,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAoE,CAAC;AAC7H,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAqE,CAAC;AAC/H,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAiE,CAAC;AACvH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAmE,CAAC;AAC3H,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAsE,CAAC;AACjI,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAoE,CAAC"}