@woosh/meep-engine 2.154.0 → 2.156.0

package/src/engine/sound/sopra/asset/AssetManagerBufferProvider.js

@@ -0,0 +1,71 @@
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import { BufferProvider } from "./BufferProvider.js";
+
+/**
+ * Production {@link BufferProvider} that draws decoded {@link AudioBuffer}s from the meep
+ * {@link AssetManager}. Reuses the shared decode cache (one immutable AudioBuffer backs many voices)
+ * and the existing alias system.
+ */
+export class AssetManagerBufferProvider extends BufferProvider {
+    /**
+     * @param {AssetManager} assetManager
+     */
+    constructor(assetManager) {
+        super();
+
+        /**
+         * @type {AssetManager}
+         */
+        this.assetManager = assetManager;
+    }
+
+    /**
+     * @private
+     * @param {string} url
+     * @param {boolean} usingAlias
+     * @returns {string|null} resolved path, or null if an alias could not be resolved
+     */
+    __resolvePath(url, usingAlias) {
+        if (!usingAlias) {
+            return url;
+        }
+
+        const description = this.assetManager.resolveAlias(url);
+
+        if (description === undefined) {
+            return null;
+        }
+
+        return description.path;
+    }
+
+    tryGet(url, usingAlias) {
+        const path = this.__resolvePath(url, usingAlias);
+
+        if (path === null) {
+            return null;
+        }
+
+        const asset = this.assetManager.tryGet(path, GameAssetType.Sound);
+
+        if (asset === null || asset === undefined) {
+            return null;
+        }
+
+        return asset.create();
+    }
+
+    get(url, usingAlias) {
+        const path = this.__resolvePath(url, usingAlias);
+
+        if (path === null) {
+            // expected-failure mode: unresolved alias. Surface it as a rejection (a sentinel the
+            // caller acts on), rather than swallowing it.
+            return Promise.reject(new Error(`sopra: asset alias '${url}' could not be resolved`));
+        }
+
+        return this.assetManager
+            .promise(path, GameAssetType.Sound)
+            .then(asset => asset.create());
+    }
+}

package/src/engine/sound/sopra/asset/BufferProvider.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Decouples the sopra core from how audio buffers are obtained, which keeps the engine unit-testable
+ * with a stub provider and no ECS/AssetManager.
+ *
+ * Two access modes mirror the AssetManager: a synchronous fast path for already-decoded buffers, and
+ * an async path for buffers that still need loading.
+ */
+export class BufferProvider {
+    /**
+     * Synchronous lookup — returns the decoded buffer if already available, else null.
+     * @param {string} url
+     * @param {boolean} usingAlias
+     * @returns {AudioBuffer|null}
+     */
+    tryGet(url: string, usingAlias: boolean): AudioBuffer | null;
+    /**
+     * Asynchronous lookup — resolves with the decoded buffer, or rejects if it cannot be obtained.
+     * @param {string} url
+     * @param {boolean} usingAlias
+     * @returns {Promise<AudioBuffer>}
+     */
+    get(url: string, usingAlias: boolean): Promise<AudioBuffer>;
+}
+//# sourceMappingURL=BufferProvider.d.ts.map

package/src/engine/sound/sopra/asset/BufferProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/asset/BufferProvider.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IAEI;;;;;OAKG;IACH,YAJW,MAAM,cACN,OAAO,GACL,WAAW,GAAC,IAAI,CAI5B;IAED;;;;;OAKG;IACH,SAJW,MAAM,cACN,OAAO,GACL,QAAQ,WAAW,CAAC,CAIhC;CACJ"}

package/src/engine/sound/sopra/asset/BufferProvider.js

@@ -0,0 +1,29 @@
+/**
+ * Decouples the sopra core from how audio buffers are obtained, which keeps the engine unit-testable
+ * with a stub provider and no ECS/AssetManager.
+ *
+ * Two access modes mirror the AssetManager: a synchronous fast path for already-decoded buffers, and
+ * an async path for buffers that still need loading.
+ */
+export class BufferProvider {
+
+    /**
+     * Synchronous lookup — returns the decoded buffer if already available, else null.
+     * @param {string} url
+     * @param {boolean} usingAlias
+     * @returns {AudioBuffer|null}
+     */
+    tryGet(url, usingAlias) {
+        return null;
+    }
+
+    /**
+     * Asynchronous lookup — resolves with the decoded buffer, or rejects if it cannot be obtained.
+     * @param {string} url
+     * @param {boolean} usingAlias
+     * @returns {Promise<AudioBuffer>}
+     */
+    get(url, usingAlias) {
+        return Promise.reject(new Error('BufferProvider.get not implemented'));
+    }
+}

package/src/engine/sound/sopra/asset/StubBufferProvider.d.ts

@@ -0,0 +1,31 @@
+/**
+ * In-memory {@link BufferProvider} for tests (and offline/preview use): you hand it buffers up
+ * front. Unknown urls return a never-resolving promise (simulating a slow/missing load) unless
+ * explicitly marked to fail via {@link failOn}.
+ */
+export class StubBufferProvider extends BufferProvider {
+    /**
+     * @type {Map<string, AudioBuffer>}
+     */
+    buffers: Map<string, AudioBuffer>;
+    /**
+     * @type {Set<string>}
+     */
+    failures: Set<string>;
+    /**
+     * @param {string} url
+     * @param {AudioBuffer} buffer
+     * @returns {this}
+     */
+    set(url: string, buffer: AudioBuffer): this;
+    /**
+     * Mark a url so that {@link get} rejects for it (simulates a missing/failed asset).
+     * @param {string} url
+     * @returns {this}
+     */
+    failOn(url: string): this;
+    tryGet(url: any): AudioBuffer;
+    get(url: any): Promise<any>;
+}
+import { BufferProvider } from "./BufferProvider.js";
+//# sourceMappingURL=StubBufferProvider.d.ts.map

package/src/engine/sound/sopra/asset/StubBufferProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StubBufferProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/asset/StubBufferProvider.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;IAEI;;OAEG;IACH,SAFU,IAAI,MAAM,EAAE,WAAW,CAAC,CAEd;IAEpB;;OAEG;IACH,UAFU,IAAI,MAAM,CAAC,CAEA;IAErB;;;;OAIG;IACH,SAJW,MAAM,UACN,WAAW,GACT,IAAI,CAKhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACJ,IAAI,CAKhB;IAED,8BAEC;IAED,4BAaC;CACJ;+BAzD8B,qBAAqB"}

package/src/engine/sound/sopra/asset/StubBufferProvider.js

@@ -0,0 +1,58 @@
+import { BufferProvider } from "./BufferProvider.js";
+
+/**
+ * In-memory {@link BufferProvider} for tests (and offline/preview use): you hand it buffers up
+ * front. Unknown urls return a never-resolving promise (simulating a slow/missing load) unless
+ * explicitly marked to fail via {@link failOn}.
+ */
+export class StubBufferProvider extends BufferProvider {
+
+    /**
+     * @type {Map<string, AudioBuffer>}
+     */
+    buffers = new Map();
+
+    /**
+     * @type {Set<string>}
+     */
+    failures = new Set();
+
+    /**
+     * @param {string} url
+     * @param {AudioBuffer} buffer
+     * @returns {this}
+     */
+    set(url, buffer) {
+        this.buffers.set(url, buffer);
+        return this;
+    }
+
+    /**
+     * Mark a url so that {@link get} rejects for it (simulates a missing/failed asset).
+     * @param {string} url
+     * @returns {this}
+     */
+    failOn(url) {
+        this.failures.add(url);
+        return this;
+    }
+
+    tryGet(url) {
+        return this.buffers.get(url) ?? null;
+    }
+
+    get(url) {
+        if (this.failures.has(url)) {
+            return Promise.reject(new Error(`StubBufferProvider: failure for '${url}'`));
+        }
+
+        const buffer = this.buffers.get(url);
+
+        if (buffer !== undefined) {
+            return Promise.resolve(buffer);
+        }
+
+        // unknown url: never resolves (models a slow/never-arriving load, exercises max-lifetime)
+        return new Promise(() => {});
+    }
+}

package/src/engine/sound/sopra/definition/BusDefinition.d.ts

@@ -0,0 +1,83 @@
+/**
+ * A node in the mixer bus tree. The {@link BusGraph} instantiates a set of these into chained
+ * GainNodes: a bus routes `input → effect[0] → … → effect[n] → output`, and `output` connects into
+ * its parent bus's input (or the engine destination when {@link parentId} is null — the root bus).
+ */
+export class BusDefinition {
+    /**
+     *
+     * @param {string} id
+     * @param {{parentId?:string, gainDb?:number, effects?:AbstractAudioEffect[], sends?:{targetBusId:string,levelDb:number}[]}} [options]
+     * @returns {BusDefinition}
+     */
+    static from(id: string, { parentId, gainDb, effects, sends }?: {
+        parentId?: string;
+        gainDb?: number;
+        effects?: AbstractAudioEffect[];
+        sends?: {
+            targetBusId: string;
+            levelDb: number;
+        }[];
+    }): BusDefinition;
+    /**
+     * Unique bus id.
+     * @type {string}
+     */
+    id: string;
+    /**
+     * Parent bus id. Empty string means "no parent" — a root bus that routes to the engine master
+     * destination (see BUS_ROOT_PARENT in BusGraph).
+     * @type {string}
+     */
+    parentId: string;
+    /**
+     * Bus gain, in decibels.
+     * @type {number}
+     */
+    gainDb: number;
+    /**
+     * Ordered insert-effect chain.
+     * @type {AbstractAudioEffect[]}
+     */
+    effects: AbstractAudioEffect[];
+    /**
+     * Aux/reverb sends. Data shape only in v1 (no runtime routing yet).
+     * @type {{targetBusId:string, levelDb:number}[]}
+     */
+    sends: {
+        targetBusId: string;
+        levelDb: number;
+    }[];
+    /**
+     *
+     * @param {BusDefinition} other
+     * @returns {boolean}
+     */
+    equals(other: BusDefinition): boolean;
+    hash(): number;
+    clone(): BusDefinition;
+    toJSON(): {
+        id: string;
+        parentId: string;
+        gainDb: number;
+        effects: {
+            type: string;
+            data: any;
+        }[];
+        sends: {
+            targetBusId: string;
+            levelDb: number;
+        }[];
+    };
+    fromJSON({ id, parentId, gainDb, effects, sends }: {
+        id?: string;
+        parentId?: string;
+        gainDb?: number;
+        effects?: any[];
+        sends?: any[];
+    }): void;
+}
+export namespace BusDefinition {
+    let typeName: string;
+}
+//# sourceMappingURL=BusDefinition.d.ts.map

package/src/engine/sound/sopra/definition/BusDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BusDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/BusDefinition.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IAiCI;;;;;OAKG;IACH,gBAJW,MAAM,yCACN;QAAC,QAAQ,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,qBAAqB,CAAC;QAAC,KAAK,CAAC,EAAC;YAAC,WAAW,EAAC,MAAM,CAAC;YAAA,OAAO,EAAC,MAAM,CAAA;SAAC,EAAE,CAAA;KAAC,GAC9G,aAAa,CAYzB;IA/CD;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,SAFU,qBAAqB,CAElB;IAEb;;;OAGG;IACH,OAFU;QAAC,WAAW,EAAC,MAAM,CAAC;QAAC,OAAO,EAAC,MAAM,CAAA;KAAC,EAAE,CAErC;IAoBX;;;;OAIG;IACH,cAHW,aAAa,GACX,OAAO,CA0BnB;IAED,eAgBC;IAED,uBAUC;IAED;;;;;;;;;;;;MAQC;IAED;;;;;;aAMC;CACJ"}

package/src/engine/sound/sopra/definition/BusDefinition.js

@@ -0,0 +1,142 @@
+import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { deserializeAudioEffectFromJSON, serializeAudioEffectToJSON } from "../serialization/sopraJSON.js";
+
+/**
+ * A node in the mixer bus tree. The {@link BusGraph} instantiates a set of these into chained
+ * GainNodes: a bus routes `input → effect[0] → … → effect[n] → output`, and `output` connects into
+ * its parent bus's input (or the engine destination when {@link parentId} is null — the root bus).
+ */
+export class BusDefinition {
+
+    /**
+     * Unique bus id.
+     * @type {string}
+     */
+    id = "";
+
+    /**
+     * Parent bus id. Empty string means "no parent" — a root bus that routes to the engine master
+     * destination (see BUS_ROOT_PARENT in BusGraph).
+     * @type {string}
+     */
+    parentId = "";
+
+    /**
+     * Bus gain, in decibels.
+     * @type {number}
+     */
+    gainDb = 0;
+
+    /**
+     * Ordered insert-effect chain.
+     * @type {AbstractAudioEffect[]}
+     */
+    effects = [];
+
+    /**
+     * Aux/reverb sends. Data shape only in v1 (no runtime routing yet).
+     * @type {{targetBusId:string, levelDb:number}[]}
+     */
+    sends = [];
+
+    /**
+     *
+     * @param {string} id
+     * @param {{parentId?:string, gainDb?:number, effects?:AbstractAudioEffect[], sends?:{targetBusId:string,levelDb:number}[]}} [options]
+     * @returns {BusDefinition}
+     */
+    static from(id, { parentId = "", gainDb = 0, effects = [], sends = [] } = {}) {
+        const r = new BusDefinition();
+
+        r.id = id;
+        r.parentId = parentId;
+        r.gainDb = gainDb;
+        r.effects = effects;
+        r.sends = sends;
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {BusDefinition} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this.id !== other.id
+            || this.parentId !== other.parentId
+            || this.gainDb !== other.gainDb
+            || this.effects.length !== other.effects.length
+            || this.sends.length !== other.sends.length
+        ) {
+            return false;
+        }
+
+        for (let i = 0; i < this.effects.length; i++) {
+            if (!this.effects[i].equals(other.effects[i])) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < this.sends.length; i++) {
+            if (this.sends[i].targetBusId !== other.sends[i].targetBusId
+                || this.sends[i].levelDb !== other.sends[i].levelDb) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    hash() {
+        let h = combine_hash(
+            computeStringHash(this.id),
+            computeStringHash(this.parentId),
+            computeHashFloat(this.gainDb)
+        );
+
+        for (let i = 0; i < this.effects.length; i++) {
+            h = combine_hash(h, this.effects[i].hash());
+        }
+
+        for (let i = 0; i < this.sends.length; i++) {
+            h = combine_hash(h, computeStringHash(this.sends[i].targetBusId), computeHashFloat(this.sends[i].levelDb));
+        }
+
+        return h;
+    }
+
+    clone() {
+        const r = new BusDefinition();
+
+        r.id = this.id;
+        r.parentId = this.parentId;
+        r.gainDb = this.gainDb;
+        r.effects = this.effects.map(e => e.clone());
+        r.sends = this.sends.map(s => ({ targetBusId: s.targetBusId, levelDb: s.levelDb }));
+
+        return r;
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            parentId: this.parentId,
+            gainDb: this.gainDb,
+            effects: this.effects.map(serializeAudioEffectToJSON),
+            sends: this.sends.map(s => ({ targetBusId: s.targetBusId, levelDb: s.levelDb }))
+        };
+    }
+
+    fromJSON({ id = "", parentId = "", gainDb = 0, effects = [], sends = [] }) {
+        this.id = id;
+        this.parentId = parentId;
+        this.gainDb = gainDb;
+        this.effects = effects.map(deserializeAudioEffectFromJSON);
+        this.sends = sends.map(s => ({ targetBusId: s.targetBusId, levelDb: s.levelDb }));
+    }
+}
+
+BusDefinition.typeName = "SopraBusDefinition";

package/src/engine/sound/sopra/definition/BusDefinitionSerializationAdapter.d.ts

@@ -0,0 +1,17 @@
+export class BusDefinitionSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    klass: typeof BusDefinition;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {BusDefinition} value
+     */
+    serialize(buffer: BinaryBuffer, value: BusDefinition): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {BusDefinition} value
+     */
+    deserialize(buffer: BinaryBuffer, value: BusDefinition): void;
+}
+import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { BusDefinition } from "./BusDefinition.js";
+//# sourceMappingURL=BusDefinitionSerializationAdapter.d.ts.map

package/src/engine/sound/sopra/definition/BusDefinitionSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BusDefinitionSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/BusDefinitionSerializationAdapter.js"],"names":[],"mappings":"AAGA;IACI,4BAAsB;IACtB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,aAAa,QAmBvB;IAED;;;OAGG;IACH,yCAFW,aAAa,QAoBvB;CACJ;qDArDoD,4EAA4E;8BACnG,oBAAoB"}

package/src/engine/sound/sopra/definition/BusDefinitionSerializationAdapter.js

@@ -0,0 +1,54 @@
+import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { BusDefinition } from "./BusDefinition.js";
+
+export class BusDefinitionSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    klass = BusDefinition;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {BusDefinition} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUTF8String(value.id);
+        buffer.writeUTF8String(value.parentId);
+        buffer.writeFloat32(value.gainDb);
+
+        const effects = value.effects;
+        buffer.writeUintVar(effects.length);
+        for (let i = 0; i < effects.length; i++) {
+            this.objectAdapter.serialize(buffer, effects[i]);
+        }
+
+        const sends = value.sends;
+        buffer.writeUintVar(sends.length);
+        for (let i = 0; i < sends.length; i++) {
+            buffer.writeUTF8String(sends[i].targetBusId);
+            buffer.writeFloat32(sends[i].levelDb);
+        }
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {BusDefinition} value
+     */
+    deserialize(buffer, value) {
+        value.id = buffer.readUTF8String();
+        value.parentId = buffer.readUTF8String();
+        value.gainDb = buffer.readFloat32();
+
+        const effectCount = buffer.readUintVar();
+        value.effects = [];
+        for (let i = 0; i < effectCount; i++) {
+            value.effects.push(this.objectAdapter.deserialize(buffer));
+        }
+
+        const sendCount = buffer.readUintVar();
+        value.sends = [];
+        for (let i = 0; i < sendCount; i++) {
+            const targetBusId = buffer.readUTF8String();
+            const levelDb = buffer.readFloat32();
+            value.sends.push({ targetBusId, levelDb });
+        }
+    }
+}

package/src/engine/sound/sopra/definition/DuckingRule.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Emulated sidechain ducking: while any instance is playing on {@link triggerBusId}, the
+ * {@link targetBusId} bus is attenuated by {@link duckDb} (e.g. music ducks under dialogue), restored
+ * when the trigger goes quiet. WebAudio has no native sidechain, so this is **play-state** ducking
+ * (driven by active-instance count, not signal level) with smooth `setTargetAtTime` attack/release.
+ *
+ * Pure serializable definition; the runtime engage/release lives on {@link SopraEngine}.
+ */
+export class DuckingRule {
+    /**
+     * @param {{triggerBusId?:string, targetBusId?:string, duckDb?:number, attack?:number, release?:number}} [options]
+     * @returns {DuckingRule}
+     */
+    static from({ triggerBusId, targetBusId, duckDb, attack, release }?: {
+        triggerBusId?: string;
+        targetBusId?: string;
+        duckDb?: number;
+        attack?: number;
+        release?: number;
+    }): DuckingRule;
+    /**
+     * Activity on this bus engages the duck.
+     * @type {string}
+     */
+    triggerBusId: string;
+    /**
+     * This bus is attenuated while the trigger is active.
+     * @type {string}
+     */
+    targetBusId: string;
+    /**
+     * Attenuation applied to the target while ducked, in decibels (negative = quieter).
+     * @type {number}
+     */
+    duckDb: number;
+    /**
+     * Duck-in time constant in seconds.
+     * @type {number}
+     */
+    attack: number;
+    /**
+     * Duck-out (restore) time constant in seconds.
+     * @type {number}
+     */
+    release: number;
+    /**
+     * @param {DuckingRule} other
+     * @returns {boolean}
+     */
+    equals(other: DuckingRule): boolean;
+    hash(): number;
+    clone(): DuckingRule;
+    toJSON(): {
+        triggerBusId: string;
+        targetBusId: string;
+        duckDb: number;
+        attack: number;
+        release: number;
+    };
+    fromJSON({ triggerBusId, targetBusId, duckDb, attack, release }: {
+        triggerBusId?: string;
+        targetBusId?: string;
+        duckDb?: number;
+        attack?: number;
+        release?: number;
+    }): void;
+}
+export namespace DuckingRule {
+    let typeName: string;
+}
+//# sourceMappingURL=DuckingRule.d.ts.map

package/src/engine/sound/sopra/definition/DuckingRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DuckingRule.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/DuckingRule.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;IAgCI;;;OAGG;IACH,qEAHW;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,WAAW,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,CAAA;KAAC,GAC1F,WAAW,CAYvB;IA5CD;;;OAGG;IACH,cAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,QAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,SAFU,MAAM,CAEF;IAkBd;;;OAGG;IACH,cAHW,WAAW,GACT,OAAO,CAQnB;IAED,eAQC;IAED,qBAEC;IAED;;;;;;MAQC;IAED;;;;;;aAMC;CACJ"}