playlist-data-engine 1.1.0

package/dist/core/generation/ButtonMapper.d.ts

@@ -0,0 +1,346 @@
+/**
+ * Button Mapper - Maps pitch analysis to button assignments for rhythm games
+ *
+ * This is the main entry point for button mapping in the Pitch Detection & Button Mapping pipeline.
+ * It takes rhythm generation output and optional pitch analysis, then assigns buttons based on:
+ *
+ * 1. **Pitch Detection**: Uses melody contour (direction, interval) to determine buttons
+ * 2. **Pattern Library**: Falls back to predefined patterns when pitch is unavailable
+ * 3. **Probability-Based Blending**: Combines pitch and pattern based on pYIN confidence
+ *
+ * Supports two controller modes:
+ * - **DDR**: 4 directional buttons with circular motion philosophy
+ * - **Guitar Hero**: 5 fret buttons with fretboard metaphor
+ *
+ * Part of the Pitch Detection & Button Mapping pipeline - Phase 2.3
+ *
+ * @example
+ * ```typescript
+ * const mapper = new ButtonMapper({
+ *   controllerMode: 'ddr',
+ *   difficulty: 'medium',
+ *   pitchInfluenceWeight: 0.8,
+ * });
+ *
+ * // Map with pitch analysis
+ * const result = mapper.map(generatedRhythm, 'medium', pitchAnalysis);
+ *
+ * // Map without pitch (pattern-only)
+ * const resultNoPitch = mapper.map(generatedRhythm, 'medium');
+ * ```
+ */
+import type { ButtonMappingConfig, DDRButton, GuitarHeroButton, ButtonPattern } from '../types/ButtonMapping.js';
+import type { GeneratedRhythm, RhythmMetadata } from './RhythmGenerator.js';
+import type { DifficultyVariant, PresetDifficultyLevel } from '../analysis/beat/DifficultyVariantGenerator.js';
+import type { PitchAtBeat, IntervalCategory } from './PitchBeatLinker.js';
+/**
+ * Result of mapping buttons to a difficulty variant
+ */
+export interface MappedLevelResult {
+    /** The difficulty variant with keys assigned to beats */
+    variant: DifficultyVariant;
+    /** Original rhythm metadata preserved */
+    rhythmMetadata: RhythmMetadata;
+    /** Button mapping metadata */
+    buttonMetadata: ButtonMappingMetadata;
+    /** Per-beat key assignments (beat index → button key) from the ButtonMapper */
+    keyAssignments: Map<number, string>;
+    /** Per-beat mapping source (beat index → 'pitch' | 'pattern') */
+    mappingSources: Map<number, 'pitch' | 'pattern'>;
+    /** Per-beat pattern IDs (beat index → pattern ID, undefined for pitch-sourced beats) */
+    mappingPatternIds: Map<number, string | undefined>;
+}
+/**
+ * Metadata about the button mapping process
+ */
+export interface ButtonMappingMetadata {
+    /** Controller mode used for mapping */
+    controllerMode: 'ddr' | 'guitar_hero' | 'tap';
+    /** All unique keys used in the chart */
+    keysUsed: string[];
+    /** Number of beats influenced by pitch */
+    pitchInfluencedBeats: number;
+    /** Number of beats from pattern library */
+    patternInfluencedBeats: number;
+    /** IDs of patterns used */
+    patternsUsed: string[];
+    /** Statistics about button distribution */
+    buttonDistribution: Map<string, number>;
+    /** Direction statistics (if pitch analysis was provided) */
+    directionStats?: {
+        up: number;
+        down: number;
+        stable: number;
+        none: number;
+    };
+    /** Interval statistics (if pitch analysis was provided) */
+    intervalStats?: {
+        unison: number;
+        small: number;
+        medium: number;
+        large: number;
+        very_large: number;
+    };
+    /** Band statistics (if pitch analysis was provided) - which frequency bands pitches came from */
+    bandStats?: {
+        low: number;
+        mid: number;
+        high: number;
+    };
+    /** Pattern placements — groups of consecutive beats sharing the same patternId */
+    patternPlacements?: {
+        patternId: string;
+        startIndex: number;
+        length: number;
+    }[];
+}
+/**
+ * A consecutive run of beats that need pattern filling.
+ *
+ * Identified by scanning pitch classification results: consecutive beats
+ * with no pitch-derived key form a single run. Each run records the
+ * surrounding context keys for smooth boundary transitions.
+ */
+export interface PatternRun<T extends DDRButton | GuitarHeroButton> {
+    /** Start index in the beat array */
+    startIndex: number;
+    /** End index (exclusive) in the beat array */
+    endIndex: number;
+    /** Number of beats in this run */
+    length: number;
+    /** Key from the pitch beat immediately before this run (null if run starts at beat 0) */
+    previousKey: T | null;
+    /** Key from the pitch beat immediately after this run (null if run ends at last beat) */
+    nextKey: T | null;
+}
+/**
+ * Result of placing a pattern within a run.
+ *
+ * Each placement represents a single pattern that was selected and
+ * written into a contiguous range of beats within a pattern run.
+ */
+export interface PatternPlacement<T extends DDRButton | GuitarHeroButton> {
+    /** The pattern that was placed */
+    pattern: ButtonPattern<T>;
+    /** Beat index where this pattern starts */
+    startIndex: number;
+    /** Number of beats actually filled by this pattern */
+    filledLength: number;
+}
+/**
+ * DDR Circular Motion Transition Table
+ *
+ * Determines next button based on: current position + pitch direction + interval size.
+ * Follows the natural clockwise flow: up → right → down → left → up
+ */
+declare const DDR_TRANSITIONS: Record<DDRButton, {
+    ascending: Record<IntervalCategory, DDRButton>;
+    descending: Record<IntervalCategory, DDRButton>;
+    stable: DDRButton;
+}>;
+/**
+ * Guitar Hero Fret Transition Table (with string wrap)
+ *
+ * Determines next fret based on: current position + pitch direction + interval size.
+ * String wrap: ascending past 5 → wraps to 2-4; descending past 1 → wraps to 4-2
+ */
+declare const GUITAR_HERO_TRANSITIONS: Record<GuitarHeroButton, {
+    ascending: Record<IntervalCategory, GuitarHeroButton>;
+    descending: Record<IntervalCategory, GuitarHeroButton>;
+    stable: GuitarHeroButton;
+}>;
+/**
+ * Scan pitch classification results and group consecutive null beats into runs.
+ *
+ * A "run" is a maximal sequence of consecutive beats that all need pattern filling
+ * (i.e., their pitchKey is null). Each run records the surrounding context keys
+ * so that pattern selection can produce smooth boundary transitions.
+ *
+ * @param pitchKeys - Array from classifyBeats; null = needs pattern, non-null = has pitch key
+ * @returns Array of PatternRun objects (empty if all beats have pitch keys)
+ */
+export declare function identifyPatternRuns<T extends DDRButton | GuitarHeroButton>(pitchKeys: (T | null)[]): PatternRun<T>[];
+/**
+ * Check if a full multi-beat pattern is compatible for placement within a run.
+ *
+ * Evaluates boundary transitions at both ends of the pattern:
+ * - **Entry**: `pattern.keys[0]` must differ from the previous key (no immediate repeat).
+ * - **Exit**: `pattern.keys[last]` must allow a smooth transition to the next key.
+ *   - DDR: last key must be adjacent to or same as next key (uses `DDR_ADJACENT`).
+ *   - Guitar Hero: last key must be between previous and next, or moving toward next.
+ *
+ * The pattern must also fit within the remaining space of the run.
+ * Difficulty filtering is handled by the caller in `selectPatternForRun()`.
+ *
+ * @param pattern - The pattern to check
+ * @param run - The run this pattern would be placed in
+ * @param positionInRun - Offset from the start of the run (0 = start of run)
+ * @param previousKey - Key immediately before this pattern (run previousKey or previous pattern's last key)
+ * @param nextKey - Key immediately after this pattern (run nextKey, or null if more patterns follow)
+ * @returns True if the pattern is compatible with the run boundaries
+ */
+export declare function isPatternRunCompatible<T extends DDRButton | GuitarHeroButton>(pattern: ButtonPattern<T>, run: PatternRun<T>, positionInRun: number, previousKey: T | null, nextKey: T | null): boolean;
+/**
+ * Select patterns to fill a pattern run using a greedy largest-first strategy.
+ *
+ * The algorithm walks through the run left-to-right:
+ * 1. Filters patterns by difficulty and sorts by length (largest first).
+ * 2. At each position, tries to find a compatible pattern:
+ *    - **Exact fit**: a pattern whose length equals the remaining space, with
+ *      the run's `nextKey` used for exit-transition checking.
+ *    - **Largest fit**: the largest compatible pattern (intermediate placements
+ *      use `null` for nextKey, so exit transitions are deferred).
+ * 3. If no compatible pattern exists at all, the beat is filled via
+ *    `interpolateButton()` and recorded as a synthetic single-key placement.
+ *
+ * Variety constraints (applied in order of priority):
+ * - Never repeat the same pattern consecutively within a run.
+ * - Prefer a different category from the last placed pattern.
+ * - Optionally avoid patterns recently used across runs (via `recentlyUsedPatternIds`).
+ *
+ * @param run - The pattern run to fill
+ * @param patternLibrary - All available patterns for the controller mode
+ * @param maxDifficulty - Maximum pattern difficulty to consider
+ * @param recentlyUsedPatternIds - Optional set of pattern IDs used in recent
+ *   measures (for cross-run variety). Defaults to no constraint.
+ * @returns Array of placements covering every beat in the run
+ */
+export declare function selectPatternForRun<T extends DDRButton | GuitarHeroButton>(run: PatternRun<T>, patternLibrary: ButtonPattern<T>[], maxDifficulty: number, recentlyUsedPatternIds?: Set<string>, randomFn?: () => number): PatternPlacement<T>[];
+/**
+ * Write pattern keys and IDs into the final arrays, preserving pitch-derived keys.
+ *
+ * For each run, each placement writes its pattern's keys sequentially into the
+ * output arrays. Beats that already have a pitch-derived key (non-null in
+ * `pitchKeys`) are left untouched.
+ *
+ * @param pitchKeys - Array from classifyBeats; non-null entries are pitch-derived
+ * @param runs - Pattern runs from identifyPatternRuns()
+ * @param placementsByRun - Pattern placements from selectPatternForRun(), one array per run
+ * @returns Object with fully populated keys and patternIds arrays
+ */
+export declare function placePatterns<T extends DDRButton | GuitarHeroButton>(pitchKeys: (T | null)[], runs: PatternRun<T>[], placementsByRun: PatternPlacement<T>[][]): {
+    keys: T[];
+    patternIds: (string | undefined)[];
+};
+/**
+ * Button Mapper
+ *
+ * Maps pitch analysis to button assignments for rhythm games.
+ * Supports DDR (4 directional buttons) and Guitar Hero (5 fret buttons) modes.
+ */
+export declare class ButtonMapper {
+    private config;
+    /**
+     * Create a new ButtonMapper
+     *
+     * @param config - Configuration options (partial, defaults applied)
+     */
+    constructor(config?: Partial<ButtonMappingConfig>);
+    /**
+     * Generate a deterministic random float for a given context.
+     * Uses MurmurHash so the same seed + context always produces the same value.
+     * Falls back to Math.random() when no seed is configured.
+     */
+    private seededRandom;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): ButtonMappingConfig;
+    /**
+     * Map buttons for a standalone difficulty variant
+     *
+     * Takes a difficulty variant directly (e.g., from generateAtDensity()) along with
+     * rhythm metadata, then assigns buttons based on pitch direction/interval and
+     * pattern library fallback.
+     *
+     * For 'custom' difficulty variants, pattern selection defaults to 'medium' difficulty.
+     *
+     * @param variant - The difficulty variant to map (can be preset or 'custom')
+     * @param rhythmMetadata - Rhythm metadata from the GeneratedRhythm
+     * @param pitchAnalysis - Optional pitch analysis from MelodyContourAnalyzer
+     * @returns Mapped level result with button assignments
+     */
+    mapVariant(variant: DifficultyVariant, rhythmMetadata: RhythmMetadata, pitchAnalysis?: PitchAtBeat[]): MappedLevelResult;
+    /**
+     * Main entry point - map buttons for a difficulty variant
+     *
+     * Takes a generated rhythm and optional pitch analysis, then assigns buttons
+     * based on pitch direction/interval and pattern library fallback.
+     *
+     * @param generatedRhythm - The generated rhythm from RhythmGenerator
+     * @param difficulty - Which difficulty variant to map (preset only, not 'custom')
+     * @param pitchAnalysis - Optional pitch analysis from MelodyContourAnalyzer
+     * @returns Mapped level result with button assignments
+     */
+    map(generatedRhythm: GeneratedRhythm, difficulty: PresetDifficultyLevel, pitchAnalysis?: PitchAtBeat[]): MappedLevelResult;
+    /**
+     * Map buttons for all three difficulty variants
+     *
+     * @param generatedRhythm - The generated rhythm from RhythmGenerator
+     * @param pitchAnalysis - Optional pitch analysis from MelodyContourAnalyzer
+     * @returns Object with mapped results for each difficulty
+     */
+    mapAll(generatedRhythm: GeneratedRhythm, pitchAnalysis?: PitchAtBeat[]): {
+        easy: MappedLevelResult;
+        medium: MappedLevelResult;
+        hard: MappedLevelResult;
+    };
+    /**
+     * Map buttons for a single difficulty variant using run-based pattern placement.
+     *
+     * Pipeline:
+     * 1. classifyBeats() → pitchKeys, probabilities
+     * 2. classifyPitchVsPattern() → boolean classification (pitch vs pattern)
+     * 3. Build workingKeys array (null for pattern beats, pitch key for pitch beats)
+     * 4. identifyPatternRuns() → runs of consecutive pattern beats
+     * 5. selectPatternForRun() per run → pattern placements
+     * 6. placePatterns() → final keys + patternIds
+     * 7. Build ButtonAssignment[] with proper source/patternId per beat
+     * 8. applyConsecutiveLimit() → fix any monotony
+     */
+    private mapButtons;
+    /**
+     * Classify each beat as pitch or pattern based on probability and weight.
+     *
+     * Uses probability-based blending logic:
+     * sorts pitch beats by probability (lowest first), replaces the bottom
+     * `(1 - weight)` fraction with patterns. Beats with no pitch data always
+     * use patterns regardless of weight.
+     *
+     * @param pitchKeys - Array from classifyBeats; null = no pitch available
+     * @param probabilities - Per-beat pitch probabilities
+     * @param weight - pitchInfluenceWeight (0.0 = all pattern, 1.0 = all pitch)
+     * @returns Boolean array where true = pitch, false = pattern
+     */
+    private classifyPitchVsPattern;
+    /**
+     * Get maximum pattern difficulty based on game difficulty
+     */
+    private getMaxPatternDifficulty;
+    /**
+     * Apply consecutive same-key limit to prevent monotonous patterns
+     */
+    private applyConsecutiveLimit;
+    /**
+     * Build metadata about the button mapping process
+     */
+    private buildMetadata;
+    /**
+     * Get the DDR transition table (for debugging/visualization)
+     */
+    static getDDRTransitions(): typeof DDR_TRANSITIONS;
+    /**
+     * Get the Guitar Hero transition table (for debugging/visualization)
+     */
+    static getGuitarHeroTransitions(): typeof GUITAR_HERO_TRANSITIONS;
+    /**
+     * Get all available buttons for the current controller mode
+     */
+    getAvailableButtons(): (DDRButton | GuitarHeroButton)[];
+    /**
+     * Check if a button is valid for the current controller mode
+     */
+    isValidButton(button: unknown): button is DDRButton | GuitarHeroButton;
+}
+export {};
+//# sourceMappingURL=ButtonMapper.d.ts.map

package/dist/core/generation/ButtonMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ButtonMapper.d.ts","sourceRoot":"","sources":["../../../src/core/generation/ButtonMapper.ts"],"names":[],"mappings":"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"}

package/dist/core/generation/ButtonPatternLibrary.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Button Pattern Library
+ *
+ * Contains predefined button patterns for DDR and Guitar Hero controller modes.
+ * These patterns serve as fallback when pitch detection probability is low or
+ * when pitchInfluenceWeight is set to use more pattern-driven mapping.
+ *
+ * @module ButtonPatternLibrary
+ */
+import type { DDRButton, GuitarHeroButton, ButtonPattern, ButtonPatternCategory, ButtonPatternLibrary, DDRPatternLibrary, GuitarHeroPatternLibrary } from '../types/ButtonMapping.js';
+/**
+ * Complete DDR pattern library.
+ * Contains all DDR patterns organized by category and difficulty.
+ */
+export declare const DDR_PATTERN_LIBRARY: DDRPatternLibrary;
+/**
+ * Complete Guitar Hero pattern library.
+ * Contains all Guitar Hero patterns organized by category and difficulty.
+ */
+export declare const GUITAR_HERO_PATTERN_LIBRARY: GuitarHeroPatternLibrary;
+/**
+ * Get a pattern library by controller mode.
+ *
+ * @param mode - The controller mode
+ * @returns The appropriate pattern library
+ */
+export declare function getPatternLibrary(mode: 'ddr'): DDRPatternLibrary;
+export declare function getPatternLibrary(mode: 'guitar_hero'): GuitarHeroPatternLibrary;
+/**
+ * Get all patterns of a specific category from a library.
+ *
+ * @param library - The pattern library
+ * @param category - The category to filter by
+ * @returns Array of patterns in that category
+ */
+export declare function getPatternsByCategory<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>, category: ButtonPatternCategory): ButtonPattern<T>[];
+/**
+ * Get all patterns within a difficulty range.
+ *
+ * @param library - The pattern library
+ * @param minDifficulty - Minimum difficulty (inclusive)
+ * @param maxDifficulty - Maximum difficulty (inclusive)
+ * @returns Array of patterns in the difficulty range
+ */
+export declare function getPatternsByDifficulty<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>, minDifficulty?: number, maxDifficulty?: number): ButtonPattern<T>[];
+/**
+ * Get patterns that match all required tags.
+ *
+ * @param library - The pattern library
+ * @param requiredTags - Tags that must all be present
+ * @returns Array of patterns matching all tags
+ */
+export declare function getPatternsByTags<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>, requiredTags: string[]): ButtonPattern<T>[];
+/**
+ * Get patterns that have a specific key count.
+ *
+ * @param library - The pattern library
+ * @param keyCount - The number of keys in the pattern
+ * @returns Array of patterns with that key count
+ */
+export declare function getPatternsByKeyCount<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>, keyCount: number): ButtonPattern<T>[];
+/**
+ * Get a random pattern from a library.
+ *
+ * @param library - The pattern library
+ * @param filter - Optional filter function
+ * @returns A random pattern, or undefined if no patterns match
+ */
+export declare function getRandomPattern<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>, filter?: (pattern: ButtonPattern<T>) => boolean): ButtonPattern<T> | undefined;
+/**
+ * Get pattern by ID.
+ *
+ * @param library - The pattern library
+ * @param id - The pattern ID to find
+ * @returns The pattern, or undefined if not found
+ */
+export declare function getPatternById<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>, id: string): ButtonPattern<T> | undefined;
+/**
+ * Get statistics about a pattern library.
+ *
+ * @param library - The pattern library
+ * @returns Statistics object
+ */
+export declare function getPatternLibraryStats<T extends DDRButton | GuitarHeroButton>(library: ButtonPatternLibrary<T>): {
+    totalPatterns: number;
+    byCategory: Record<ButtonPatternCategory, number>;
+    byDifficulty: Record<number, number>;
+    averageKeyCount: number;
+    minKeys: number;
+    maxKeys: number;
+};
+//# sourceMappingURL=ButtonPatternLibrary.d.ts.map

package/dist/core/generation/ButtonPatternLibrary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ButtonPatternLibrary.d.ts","sourceRoot":"","sources":["../../../src/core/generation/ButtonPatternLibrary.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACR,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,EAC3B,MAAM,2BAA2B,CAAC;AAsrCnC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,iBAAgE,CAAC;AAEnG;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,wBAGzC,CAAC;AAMF;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,GAAG,iBAAiB,CAAC;AAClE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,wBAAwB,CAAC;AAKjF;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EACxE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAChC,QAAQ,EAAE,qBAAqB,GAChC,aAAa,CAAC,CAAC,CAAC,EAAE,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EAC1E,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAChC,aAAa,GAAE,MAAU,EACzB,aAAa,GAAE,MAAW,GAC3B,aAAa,CAAC,CAAC,CAAC,EAAE,CASpB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EACpE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAChC,YAAY,EAAE,MAAM,EAAE,GACvB,aAAa,CAAC,CAAC,CAAC,EAAE,CAIpB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EACxE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAChC,QAAQ,EAAE,MAAM,GACjB,aAAa,CAAC,CAAC,CAAC,EAAE,CAEpB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EACnE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAChC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,OAAO,GAChD,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAK9B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EACjE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,EAChC,EAAE,EAAE,MAAM,GACX,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAE9B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,SAAS,GAAG,gBAAgB,EACzE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,GACjC;IACC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACnB,CAmCA"}