@directivegames/genesys.js 3.1.24

package/dist/src/components/visual/AnimationStateMachineComponent.js

@@ -0,0 +1,1048 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+/**
+ * AnimationStateMachineComponent manages complex animation transitions.
+ *
+ * It loads animation clips from GLTF sources and orchestrates state-based
+ * playback with parameter-driven transitions. The component keeps a map of
+ * parameters that can be modified at runtime to influence which state is active
+ * and how clips blend. External animation sources may be loaded dynamically,
+ * and one-shot animations can temporarily override the current state.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Define states and transitions in JSON or code and pass via options.
+ * - Update parameters with `setParameter` to trigger transitions.
+ * - Use for characters requiring contextual movement such as walking, jumping,
+ *   or reacting to gameplay events.
+ */
+import * as THREE from 'three';
+import { AnimationClipCache } from '../../animation/AnimationClipCache.js';
+import { addSyntheticRootBone, needsSyntheticRoot, retargetAnimationClips } from '../../animation/AnimationRetargeting.js';
+import { AssetPath } from '../../storage/storageProvider.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { AsyncTaskWorker, IAsyncLoadableTag } from '../../utils/IAsyncLoadable.js';
+import { resourceManager } from '../../utils/ResourceManager.js';
+import { SceneComponent } from '../SceneComponent.js';
+import { GLTFMeshComponent } from './GLTFMeshComponent.js';
+let AnimationStateMachineComponent = class AnimationStateMachineComponent extends SceneComponent {
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "mixer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "actions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "gltfComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "parameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "currentState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "stateTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "states", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "clipOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "oneShotClips", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "isOneShotPlaying", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "oneShotPrevState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "oneShotResolve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "oneShotCurrentClip", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "oneShotFreezeOnLastFrame", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "clipFinishedFlag", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "externalAnimationSources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "targetSkeletonProfile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "enabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "isInitialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_asyncTaskWorker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new AsyncTaskWorker()
+        });
+        Object.defineProperty(this, "_onOneShotFinished", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (event) => {
+                if (!this.isOneShotPlaying)
+                    return;
+                if (!event || !event.action)
+                    return;
+                if (event.action.getClip().name !== this.oneShotCurrentClip)
+                    return;
+                // Clean up
+                event.action.getMixer().removeEventListener('finished', this._onOneShotFinished);
+                if (this.oneShotFreezeOnLastFrame) {
+                    this.setEnabled(false);
+                }
+                else {
+                    // Normal mode: stop action and resume state machine
+                    event.action.stop();
+                    event.action.enabled = false;
+                    event.action.setEffectiveWeight(0);
+                    this.isOneShotPlaying = false;
+                    this.oneShotCurrentClip = null;
+                    this.oneShotFreezeOnLastFrame = false;
+                    // Resume state machine
+                    if (this.oneShotPrevState) {
+                        this.transitionToState(this.oneShotPrevState);
+                        // Explicitly play the animation for the resumed state
+                        const resumedState = this.states[this.oneShotPrevState];
+                        if (resumedState) {
+                            if (resumedState.blend && resumedState.blend.length > 0) {
+                                this.updateBlendWeights(resumedState.blend);
+                            }
+                            else if (resumedState.clip) {
+                                let clipToPlay = undefined;
+                                if (typeof resumedState.clip === 'string') {
+                                    clipToPlay = resumedState.clip;
+                                }
+                                else if (Array.isArray(resumedState.clip)) {
+                                    if (resumedState.clip.length > 0) {
+                                        const idx = Math.floor(Math.random() * resumedState.clip.length);
+                                        const candidate = resumedState.clip[idx];
+                                        if (typeof candidate === 'string') {
+                                            clipToPlay = candidate;
+                                        }
+                                    }
+                                }
+                                if (typeof clipToPlay === 'string') {
+                                    this.play(clipToPlay, 0.3);
+                                }
+                            }
+                        }
+                        this.oneShotPrevState = null;
+                    }
+                }
+                if (this.oneShotResolve) {
+                    this.oneShotResolve();
+                    this.oneShotResolve = null;
+                }
+            }
+        });
+        Object.defineProperty(this, "_onClipFinished", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (event) => {
+                // Only set the flag if the finished action is the current state's clip
+                if (!event || !event.action)
+                    return;
+                const currentState = this.currentState && this.states[this.currentState];
+                if (!currentState)
+                    return;
+                let relevant = false;
+                if (currentState.clip) {
+                    if (typeof currentState.clip === 'string' && event.action.getClip().name === currentState.clip)
+                        relevant = true;
+                    if (Array.isArray(currentState.clip) && currentState.clip.includes(event.action.getClip().name))
+                        relevant = true;
+                }
+                // For blend states, could check if the finished action is in the blend, but usually only single-clip states are LoopOnce
+                if (relevant) {
+                    this.clipFinishedFlag = true;
+                }
+            }
+        });
+    }
+    async _loadAnim() {
+        // Load animation config from ResourceManager
+        const configPath = new AssetPath(this.options.configUrl);
+        this.config = await resourceManager.loadJsonObject(configPath);
+        if (!this.config) {
+            console.error(`AnimationStateMachineComponent: Failed to load animation config from ${this.options.configUrl}`);
+            return;
+        }
+        // Initialize component state from loaded config
+        if (this.config.parameters) {
+            for (const [key, value] of Object.entries(this.config.parameters)) {
+                this.parameters.set(key, value);
+            }
+        }
+        if (this.config.states) {
+            this.states = this.config.states;
+        }
+        if (this.config.initialState) {
+            this.currentState = this.config.initialState;
+        }
+        if (this.config.clipOptions) {
+            this.clipOptions = this.config.clipOptions;
+        }
+        if (this.config.oneShotClips) {
+            this.oneShotClips = new Set(this.config.oneShotClips);
+        }
+        if (this.config.externalAnimationSources) {
+            this.externalAnimationSources = this.config.externalAnimationSources;
+        }
+        this.gltfComponent = this.getActor()?.getComponent(GLTFMeshComponent) ?? null;
+        if (!this.gltfComponent) {
+            console.error('AnimationStateMachineComponent: No GLTFMeshComponent found in actor.');
+        }
+        // Load target skeleton profile if retargeting is enabled
+        if (this.config.targetSkeletonProfile) {
+            try {
+                const profilePath = new AssetPath(this.config.targetSkeletonProfile);
+                this.targetSkeletonProfile = await resourceManager.loadJsonObject(profilePath);
+                if (!this.targetSkeletonProfile) {
+                    console.error(`AnimationStateMachineComponent: Failed to load target skeleton profile from ${this.config.targetSkeletonProfile}`);
+                }
+            }
+            catch (e) {
+                console.error('AnimationStateMachineComponent: Failed to load target skeleton profile:', e);
+            }
+        }
+        // Load external animation sources - but only after the GLTF is loaded
+        // This will be handled in setupAnimations() when the GLTF mesh is ready
+        if (this.gltfComponent) {
+            this.gltfComponent.onMeshLoaded.add((meshComponent, mesh) => {
+                this._asyncTaskWorker.runTask(async () => { await this.setupAnimations(); });
+            });
+            if (this.gltfComponent.isModelLoaded()) {
+                await this.setupAnimations();
+            }
+        }
+        else {
+            // No GLTF component found, mark as initialized since setup is complete
+            this.isInitialized = true;
+        }
+    }
+    beginPlay() {
+        super.beginPlay();
+        // Reset initialization state
+        this.isInitialized = false;
+        this._asyncTaskWorker.runTask(async () => { await this._loadAnim(); });
+    }
+    // start IAsyncLoadable implementation
+    async waitForLoad() {
+        await this._asyncTaskWorker.waitUntilComplete();
+    }
+    isLoading() {
+        return this._asyncTaskWorker.isRunning();
+    }
+    // end IAsyncLoadable implementation
+    /**
+     * Load external animation sources with optional retargeting.
+     */
+    async loadExternalAnimationSources() {
+        if (!this.gltfComponent) {
+            console.error('AnimationStateMachineComponent: Cannot load external animations without GLTFMeshComponent');
+            return;
+        }
+        // Get target skeleton if retargeting is enabled
+        const targetSkinnedMeshData = this.targetSkeletonProfile ? this.gltfComponent.getSkinnedMeshData() : null;
+        const targetSkeleton = targetSkinnedMeshData?.skeleton ?? null;
+        const targetSkinnedMesh = targetSkinnedMeshData?.skinnedMesh ?? null;
+        if (this.targetSkeletonProfile && (!targetSkeleton || !targetSkinnedMesh)) {
+            console.error('AnimationStateMachineComponent: Target skeleton profile specified but no skinned mesh found on target character');
+            return;
+        }
+        await Promise.all(this.externalAnimationSources.map(async (sourceConfig) => {
+            try {
+                // Parse source config (can be string URL or object with profile)
+                const sourceUrl = typeof sourceConfig === 'string' ? sourceConfig : sourceConfig.url;
+                const sourceProfileUrl = typeof sourceConfig === 'string' ? null : sourceConfig.skeletonProfile;
+                // Load the source GLTF
+                const modelPath = new AssetPath(sourceUrl);
+                const gltf = await resourceManager.loadModel(modelPath);
+                if (!gltf || !gltf.animations || gltf.animations.length === 0) {
+                    console.warn(`AnimationStateMachineComponent: No animations found in ${sourceUrl}`);
+                    return;
+                }
+                // If retargeting is enabled, load source profile and retarget
+                if (this.targetSkeletonProfile && sourceProfileUrl && targetSkeleton && targetSkinnedMesh) {
+                    // Load source skeleton profile
+                    const sourceProfilePath = new AssetPath(sourceProfileUrl);
+                    const sourceProfile = await resourceManager.loadJsonObject(sourceProfilePath);
+                    if (!sourceProfile) {
+                        console.error(`AnimationStateMachineComponent: Failed to load source profile from ${sourceProfileUrl}`);
+                        return;
+                    }
+                    // Check if source and target profiles are the same - if so, skip retargeting
+                    if (sourceProfile.name === this.targetSkeletonProfile.name) {
+                        console.log(`AnimationStateMachineComponent: Source and target use same profile "${sourceProfile.name}", skipping retargeting for ${gltf.animations.length} clips from ${sourceUrl}`);
+                        for (const clip of gltf.animations) {
+                            AnimationClipCache.instance.addClip(clip);
+                        }
+                        return;
+                    }
+                    // Get source skeleton from the GLTF
+                    const sourceScene = gltf.scene;
+                    let sourceSkinnedMesh;
+                    sourceScene.traverse((node) => {
+                        if (node instanceof THREE.SkinnedMesh && node.skeleton && !sourceSkinnedMesh) {
+                            sourceSkinnedMesh = node;
+                        }
+                    });
+                    if (!sourceSkinnedMesh || !sourceSkinnedMesh.skeleton) {
+                        console.error(`AnimationStateMachineComponent: No skeleton found in source GLTF ${sourceUrl}`);
+                        return;
+                    }
+                    const sourceSkeleton = sourceSkinnedMesh.skeleton;
+                    // Check if target needs a synthetic root bone (source has root, target doesn't)
+                    let effectiveTargetProfile = this.targetSkeletonProfile;
+                    let effectiveTargetSkeleton = targetSkeleton;
+                    if (needsSyntheticRoot(sourceProfile, this.targetSkeletonProfile)) {
+                        console.log(`AnimationStateMachineComponent: Adding synthetic root bone to target skeleton for retargeting from ${sourceUrl}`);
+                        const syntheticResult = addSyntheticRootBone(targetSkeleton, targetSkinnedMesh, this.targetSkeletonProfile);
+                        effectiveTargetSkeleton = syntheticResult.skeleton;
+                        effectiveTargetProfile = syntheticResult.updatedProfile;
+                    }
+                    // Retarget all clips
+                    const results = retargetAnimationClips(gltf.animations, sourceProfile, effectiveTargetProfile, sourceSkeleton, effectiveTargetSkeleton, targetSkinnedMesh);
+                    // Add successfully retargeted clips to cache
+                    let successCount = 0;
+                    for (const result of results) {
+                        if (result.success && result.clip) {
+                            AnimationClipCache.instance.addClip(result.clip);
+                            successCount++;
+                        }
+                        else {
+                            console.warn(`AnimationStateMachineComponent: Failed to retarget clip "${result.originalName}" from ${sourceUrl}`);
+                        }
+                    }
+                    console.log(`AnimationStateMachineComponent: Retargeted ${successCount}/${gltf.animations.length} clips from ${sourceUrl}`);
+                }
+                else {
+                    // No retargeting - add clips as-is
+                    for (const clip of gltf.animations) {
+                        AnimationClipCache.instance.addClip(clip);
+                    }
+                    console.log(`AnimationStateMachineComponent: Loaded ${gltf.animations.length} clips from ${sourceUrl} (no retargeting)`);
+                }
+            }
+            catch (e) {
+                const sourceUrl = typeof sourceConfig === 'string' ? sourceConfig : sourceConfig.url;
+                console.error(`AnimationStateMachineComponent: Failed to load external animation source: ${sourceUrl}`, e);
+            }
+        }));
+    }
+    addAnimation(clip, animationNameOverride) {
+        const loopMap = {
+            LoopOnce: THREE.LoopOnce,
+            LoopRepeat: THREE.LoopRepeat,
+            LoopPingPong: THREE.LoopPingPong,
+        };
+        const blendModeMap = {
+            NormalAnimationBlendMode: THREE.NormalAnimationBlendMode,
+            AdditiveAnimationBlendMode: THREE.AdditiveAnimationBlendMode,
+        };
+        let processedClip = clip;
+        // Filter tracks if a GLTF component and model are available
+        if (this.gltfComponent && this.gltfComponent.getModel()) {
+            const model = this.gltfComponent.getModel();
+            if (model) {
+                const validNodeNames = new Set();
+                model.traverse((node) => {
+                    validNodeNames.add(node.name);
+                });
+                const originalTracks = processedClip.tracks;
+                const filteredTracks = [];
+                let tracksWereFiltered = false;
+                for (const track of originalTracks) {
+                    // Extract the base node name (e.g., "mixamorigRightHand" from "mixamorigRightHand.position")
+                    const nodeName = track.name.split('.')[0];
+                    if (validNodeNames.has(nodeName)) {
+                        filteredTracks.push(track);
+                    }
+                    else {
+                        // console.log(`AnimationStateMachine: Filtering out track for missing node '${nodeName}' in clip '${processedClip.name}'`);
+                        tracksWereFiltered = true;
+                    }
+                }
+                if (tracksWereFiltered) {
+                    // console.log(`AnimationStateMachine: Clip '${processedClip.name}' had ${originalTracks.length - filteredTracks.length} tracks removed.`);
+                    processedClip = new THREE.AnimationClip(processedClip.name, processedClip.duration, filteredTracks, processedClip.blendMode);
+                }
+            }
+        }
+        const action = this.mixer.clipAction(processedClip);
+        // Apply user-defined options for this clip
+        const opts = this.clipOptions[processedClip.name]; // Use processedClip.name in case it was recreated
+        if (opts) {
+            if (opts.loop) {
+                const loopType = loopMap[opts.loop];
+                if (loopType !== undefined) {
+                    action.setLoop(loopType, Infinity);
+                }
+            }
+            if (opts.clampWhenFinished) {
+                action.clampWhenFinished = opts.clampWhenFinished;
+            }
+            if (opts.blendMode) {
+                const blendMode = blendModeMap[opts.blendMode];
+                if (blendMode !== undefined) {
+                    action.blendMode = blendMode;
+                }
+            }
+        }
+        this.actions.set(animationNameOverride ?? processedClip.name, action);
+        return action;
+    }
+    async setupAnimations() {
+        if (!this.gltfComponent)
+            return;
+        if (this.isInitialized)
+            return; // Already initialized, avoid duplicate setup
+        const model = this.gltfComponent.getModel();
+        const clips = this.gltfComponent.getAnimations();
+        if (model) {
+            // Load external animation sources now that the GLTF is ready
+            if (this.externalAnimationSources.length > 0) {
+                await this.loadExternalAnimationSources();
+            }
+            // Create mixer on the model root (the GLTF scene Group)
+            this.mixer = new THREE.AnimationMixer(model);
+            this.actions.clear();
+            // Get all unique clip names from the state machine definition
+            const stateClipNames = new Set();
+            for (const state of Object.values(this.states)) {
+                if (state.clip) {
+                    if (typeof state.clip === 'string') {
+                        stateClipNames.add(state.clip);
+                    }
+                    else if (Array.isArray(state.clip)) {
+                        state.clip.forEach(name => stateClipNames.add(name));
+                    }
+                }
+                if (state.blend) {
+                    state.blend.forEach(b => stateClipNames.add(b.clip));
+                }
+            }
+            // Add one-shot clips to the set
+            for (const oneShotClipName of this.oneShotClips) {
+                stateClipNames.add(oneShotClipName);
+            }
+            // First, add all original model animations to the cache
+            for (const clip of clips) {
+                if (!AnimationClipCache.instance.hasClip(clip.name)) {
+                    AnimationClipCache.instance.addClip(clip);
+                }
+            }
+            // Load clips for states first: try cache, then model animations
+            for (const clipName of stateClipNames) {
+                let clip = AnimationClipCache.instance.getClip(clipName);
+                if (!clip) {
+                    clip = clips.find(c => c.name === clipName);
+                    if (clip) {
+                        AnimationClipCache.instance.addClip(clip);
+                    }
+                }
+                if (clip) {
+                    this.addAnimation(clip);
+                }
+                else {
+                    console.warn(`AnimationStateMachineComponent: Clip '${clipName}' not found in cache or model.`);
+                }
+            }
+            // Also create actions for ALL clips from the cache (original + retargeted)
+            // This allows external systems to access all animations
+            const allCachedClips = AnimationClipCache.instance.getClipNames();
+            for (const clipName of allCachedClips) {
+                if (!this.actions.has(clipName)) {
+                    const clip = AnimationClipCache.instance.getClip(clipName);
+                    if (clip) {
+                        this.addAnimation(clip);
+                    }
+                }
+            }
+            // Now that animations are set up, play initial state and mark as initialized
+            this.playInitialState();
+            this.isInitialized = true;
+        }
+    }
+    playInitialState() {
+        // Play initial state
+        if (this.currentState && this.states[this.currentState]) {
+            const state = this.states[this.currentState];
+            if (state.clip) {
+                let clipToPlay = undefined;
+                if (typeof state.clip === 'string') {
+                    clipToPlay = state.clip;
+                }
+                else if (Array.isArray(state.clip)) {
+                    if (state.clip.length > 0) {
+                        const idx = Math.floor(Math.random() * state.clip.length);
+                        const candidate = state.clip[idx];
+                        if (typeof candidate === 'string') {
+                            clipToPlay = candidate;
+                        }
+                    }
+                }
+                if (typeof clipToPlay === 'string') {
+                    this.play(clipToPlay);
+                }
+            }
+            this.stateTime = 0;
+        }
+    }
+    play(clip, blendDuration = 0.3) {
+        if (!this.mixer)
+            return;
+        if (!clip)
+            return;
+        const action = this.actions.get(clip);
+        if (action) {
+            // Find the currently playing action (if any)
+            const prevAction = this.getActiveActions()[0];
+            if (prevAction && prevAction !== action) {
+                prevAction.crossFadeTo(action, blendDuration, false);
+            }
+            action.reset().play();
+            // Listen for finished event to set the flag
+            action.getMixer().addEventListener('finished', this._onClipFinished);
+        }
+    }
+    /**
+     * Set one or more animation parameters. If called with (key, value), sets a single parameter.
+     * If called with an object, sets multiple parameters at once and only evaluates the state machine once.
+     *
+     * If the component is not yet initialized, parameters will be stored and applied once initialization completes.
+     */
+    setParameter(key, value) {
+        // Skip parameter updates if disabled
+        if (!this.enabled) {
+            return;
+        }
+        // If not initialized yet, warn and ignore parameter changes
+        if (!this.isInitialized) {
+            if (typeof key === 'object' && key !== null) {
+                const keys = Object.keys(key).join(', ');
+                console.warn(`AnimationStateMachineComponent not yet initialized. Ignoring setParameter call for: ${keys}`);
+            }
+            else if (typeof key === 'string') {
+                console.warn(`AnimationStateMachineComponent not yet initialized. Ignoring setParameter call for: ${key}`);
+            }
+            return;
+        }
+        if (typeof key === 'object' && key !== null) {
+            for (const [k, v] of Object.entries(key)) {
+                if (!this.parameters.has(k)) {
+                    console.error(`Parameter '${k}' does not exist in AnimationStateMachineComponent.`);
+                    continue;
+                }
+                this.parameters.set(k, v);
+            }
+            this.evaluateStateMachine();
+        }
+        else if (typeof key === 'string') {
+            if (!this.parameters.has(key)) {
+                console.error(`Parameter '${key}' does not exist in AnimationStateMachineComponent.`);
+                return;
+            }
+            this.parameters.set(key, value);
+            this.evaluateStateMachine();
+        }
+    }
+    /**
+     * Get an animation parameter
+     */
+    getParameter(key) {
+        if (!this.parameters.has(key)) {
+            if (!this.isInitialized) {
+                throw new Error(`AnimationStateMachineComponent not yet initialized. Cannot get parameter '${key}'.`);
+            }
+            throw new Error(`Parameter '${key}' does not exist in AnimationStateMachineComponent.`);
+        }
+        return this.parameters.get(key);
+    }
+    /**
+     * Get all parameters as a plain object
+     */
+    getAllParameters() {
+        return Object.fromEntries(this.parameters.entries());
+    }
+    /**
+     * Check if a parameter exists
+     */
+    hasParameter(key) {
+        return this.parameters.has(key);
+    }
+    /**
+     * Force the state machine to a specific state
+     */
+    transitionToState(state) {
+        if (!this.states[state])
+            return;
+        if (this.currentState === state)
+            return; // Guard: don't re-enter the same state
+        // Fade out actions of the previous state before setting the new state
+        if (this.currentState && this.states[this.currentState]) {
+            const prevState = this.states[this.currentState];
+            let prevActionNames = [];
+            if (prevState.blend && prevState.blend.length > 0) {
+                prevActionNames = prevState.blend.map(b => b.reversed ? `${b.clip}#Reversed` : b.clip);
+            }
+            else if (prevState.clip) {
+                if (typeof prevState.clip === 'string') {
+                    prevActionNames = [prevState.clip];
+                }
+                else if (Array.isArray(prevState.clip)) {
+                    prevActionNames = prevState.clip;
+                }
+            }
+            // Fade out only the actions of the previous state
+            for (const name of prevActionNames) {
+                const action = this.actions.get(name);
+                if (action && action.isRunning()) {
+                    action.fadeOut(0.3); // Use default blend duration for fade out
+                }
+            }
+        }
+        this.currentState = state;
+        this.stateTime = 0;
+        // Find the transition to this state to get the blendDuration
+        let blendDuration = 0.3;
+        if (this.currentState && this.states) {
+            const prevState = this.states[this.currentState];
+            if (prevState && prevState.transitions) {
+                const transition = prevState.transitions.find(t => t.to === state);
+                if (transition && typeof transition.blendDuration === 'number') {
+                    blendDuration = transition.blendDuration;
+                }
+            }
+        }
+        // Play or blend to the new state's animation(s)
+        const newState = this.states[state];
+        if (newState.blend && newState.blend.length > 0) {
+            this.updateBlendWeights(newState.blend);
+        }
+        else if (newState.clip) {
+            let clipToPlay = undefined;
+            if (typeof newState.clip === 'string') {
+                clipToPlay = newState.clip;
+            }
+            else if (Array.isArray(newState.clip)) {
+                if (newState.clip.length > 0) {
+                    const idx = Math.floor(Math.random() * newState.clip.length);
+                    const candidate = newState.clip[idx];
+                    if (typeof candidate === 'string') {
+                        clipToPlay = candidate;
+                    }
+                }
+            }
+            if (typeof clipToPlay === 'string') {
+                this.play(clipToPlay, blendDuration);
+            }
+        }
+    }
+    /**
+     * Blend to a set of animation clips with given weights (static or parameter-mapped)
+     */
+    updateBlendWeights(blend) {
+        if (!this.mixer)
+            return;
+        const animationNames = [];
+        // Start and set weights for blend actions
+        blend.forEach(({ clip, weight, weightParam, reversed }) => {
+            reversed ??= false;
+            const animationName = reversed ? `${clip}#Reversed` : clip;
+            let action;
+            if (typeof clip === 'string') {
+                action = this.actions.get(animationName);
+                if (!action) {
+                    const clips = this.gltfComponent?.getAnimations() ?? [];
+                    const clipInstance = clips.find(c => c.name === clip);
+                    if (clipInstance) {
+                        action = this.addAnimation(clipInstance.clone(), animationName);
+                        action.timeScale = reversed ? -1 : 1;
+                    }
+                }
+            }
+            let w = weight ?? 0;
+            if (weightParam) {
+                const paramValue = this.getParameter(weightParam);
+                if (typeof paramValue === 'number') {
+                    w = Math.max(0, Math.min(1, paramValue));
+                }
+            }
+            if (action) {
+                // reset the weights if this is the first time the action is seen
+                if (!animationNames.includes(animationName)) {
+                    animationNames.push(animationName);
+                    action.setEffectiveWeight(0);
+                }
+                // use accumulated weights in case the action is reused in the blend
+                w += action.getEffectiveWeight();
+                action.setEffectiveWeight(w);
+                action.enabled = true;
+                if (!action.isRunning()) {
+                    action.play();
+                }
+            }
+        });
+    }
+    /**
+     * Check if the current parameters match the given condition object
+     * Supports operators: greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, equalTo, notEqualTo
+     */
+    matchesCondition(condition) {
+        // Special handling for clipFinished
+        if ('clipFinished' in condition) {
+            if (condition.clipFinished === true && this.clipFinishedFlag) {
+                return true;
+            }
+            else if (condition.clipFinished === true && !this.clipFinishedFlag) {
+                return false;
+            }
+        }
+        for (const key in condition) {
+            const param = this.getParameter(key);
+            const cond = condition[key];
+            if (typeof cond === 'object' && cond !== null && !Array.isArray(cond)) {
+                if ('greaterThan' in cond && !(typeof param === 'number' && param > cond.greaterThan))
+                    return false;
+                if ('greaterThanOrEqual' in cond && !(typeof param === 'number' && param >= cond.greaterThanOrEqual))
+                    return false;
+                if ('lessThan' in cond && !(typeof param === 'number' && param < cond.lessThan))
+                    return false;
+                if ('lessThanOrEqual' in cond && !(typeof param === 'number' && param <= cond.lessThanOrEqual))
+                    return false;
+                if ('equalTo' in cond && !(param === cond.equalTo))
+                    return false;
+                if ('notEqualTo' in cond && !(param !== cond.notEqualTo))
+                    return false;
+            }
+            else {
+                if (param !== cond)
+                    return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Evaluate the state machine and perform transitions if needed
+     */
+    evaluateStateMachine() {
+        if (this.isOneShotPlaying)
+            return; // Pause state machine during one-shot
+        if (!this.currentState || !this.states[this.currentState])
+            return;
+        // 1. Check global transitions (from '__any__') first
+        const globalState = this.states['__any__'];
+        if (globalState && globalState.transitions) {
+            for (const transition of globalState.transitions) {
+                if (this.matchesCondition(transition.condition)) {
+                    this.transitionToState(transition.to);
+                    this.clipFinishedFlag = false;
+                    return;
+                }
+            }
+        }
+        // 2. Check current state's transitions
+        const state = this.states[this.currentState];
+        for (const transition of state.transitions) {
+            if (this.matchesCondition(transition.condition)) {
+                this.transitionToState(transition.to);
+                this.clipFinishedFlag = false;
+                break;
+            }
+        }
+        // Reset the flag if not used
+        this.clipFinishedFlag = false;
+    }
+    /**
+     * Blend to a new animation clip over a given duration (in seconds)
+     */
+    blendTo(clip, duration = 0.3) {
+        if (!this.mixer)
+            return;
+        let nextAction = this.actions.get(clip);
+        // Fade out all other actions instead of stopping them immediately
+        for (const [name, action] of this.actions.entries()) {
+            if (action !== nextAction) {
+                action.fadeOut(duration);
+            }
+        }
+        // Use local variables only, do not use this.currentAction
+        if (nextAction) {
+            nextAction.reset().play();
+        }
+    }
+    /**
+     * Called every frame after physics. Used to update state time and evaluate transitions.
+     */
+    tickPostPhysics(deltaTime) {
+        super.tickPostPhysics(deltaTime);
+        // Skip animation processing if disabled
+        if (!this.enabled) {
+            return;
+        }
+        this.stateTime += deltaTime;
+        // Always update blend weights if in a blend state
+        if (this.currentState && this.states[this.currentState]?.blend) {
+            this.updateBlendWeights(this.states[this.currentState].blend);
+        }
+        this.evaluateStateMachine();
+        if (this.mixer) {
+            this.mixer.update(deltaTime);
+        }
+    }
+    /**
+     * Sets whether the animation state machine is enabled
+     * When disabled, all animations are cleared and no further processing occurs
+     */
+    setEnabled(enabled) {
+        if (this.enabled === enabled)
+            return;
+        this.enabled = enabled;
+        if (!enabled) {
+            this.clearAllAnimations();
+        }
+    }
+    /**
+     * Gets whether the animation state machine is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Gets whether the animation state machine has finished initializing
+     * (external animations loaded, parameters set up, and animations configured)
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+    /**
+     * Clears all currently playing animations
+     */
+    clearAllAnimations() {
+        if (!this.mixer)
+            return;
+        // Stop and fade out all actions
+        for (const [name, action] of this.actions.entries()) {
+            if (action.isRunning()) {
+                action.fadeOut(0.1); // Quick fade out
+                action.stop();
+            }
+        }
+        // Reset state
+        this.isOneShotPlaying = false;
+        this.oneShotCurrentClip = null;
+        this.oneShotPrevState = null;
+        this.clipFinishedFlag = false;
+        if (this.oneShotResolve) {
+            this.oneShotResolve();
+            this.oneShotResolve = null;
+        }
+    }
+    getClipNames() {
+        return Array.from(this.actions.keys());
+    }
+    /**
+     * Returns the currently active animation actions based on the current state.
+     */
+    getActiveActions() {
+        if (!this.currentState)
+            return [];
+        const state = this.states[this.currentState];
+        if (!state)
+            return [];
+        if (state.blend && state.blend.length > 0) {
+            // Return all actions in the blend
+            return state.blend
+                .map(b => this.actions.get(b.clip))
+                .filter((a) => !!a);
+        }
+        else if (state.clip) {
+            if (typeof state.clip === 'string') {
+                const a = this.actions.get(state.clip);
+                return a ? [a] : [];
+            }
+            else if (Array.isArray(state.clip)) {
+                // Optionally, pick a random one for display, or just return empty (since active action is ambiguous)
+                // We'll return empty to avoid confusion
+                return [];
+            }
+        }
+        return [];
+    }
+    /**
+     * Trigger a one-shot animation by name. Returns a promise that resolves when the one-shot finishes.
+     * @param clip The name of the one-shot animation clip to play
+     * @param freezeOnLastFrame If true, the animation will freeze on the last frame and not resume the state machine
+     */
+    playOneShot(clip, freezeOnLastFrame = false) {
+        if (!this.oneShotClips.has(clip)) {
+            throw new Error(`Clip '${clip}' is not a registered one-shot clip.`);
+        }
+        // If a one-shot is already playing, interrupt it properly
+        if (this.isOneShotPlaying) {
+            this.interruptCurrentOneShot();
+        }
+        if (!this.mixer)
+            return Promise.resolve();
+        const action = this.actions.get(clip);
+        if (!action) {
+            throw new Error(`One-shot animation action '${clip}' not found.`);
+        }
+        this.isOneShotPlaying = true;
+        this.oneShotPrevState = this.currentState;
+        this.oneShotCurrentClip = clip;
+        this.oneShotFreezeOnLastFrame = freezeOnLastFrame;
+        // Fade out all other actions
+        for (const [name, act] of this.actions.entries()) {
+            if (act !== action) {
+                act.fadeOut(0.2);
+            }
+        }
+        action.reset();
+        action.setLoop(THREE.LoopOnce, 1);
+        action.clampWhenFinished = true;
+        action.enabled = true;
+        action.setEffectiveWeight(1);
+        action.play();
+        // Listen for finished event
+        return new Promise((resolve) => {
+            this.oneShotResolve = resolve;
+            action.getMixer().addEventListener('finished', this._onOneShotFinished);
+        });
+    }
+    /**
+     * Interrupts the currently playing one-shot animation and cleans up its state
+     */
+    interruptCurrentOneShot() {
+        if (!this.isOneShotPlaying || !this.oneShotCurrentClip)
+            return;
+        // Find and stop the current one-shot action
+        const currentAction = this.actions.get(this.oneShotCurrentClip);
+        if (currentAction && this.mixer) {
+            // Remove the event listener to prevent the old callback from firing
+            currentAction.getMixer().removeEventListener('finished', this._onOneShotFinished);
+            // Stop the action and reset its state
+            currentAction.stop();
+            currentAction.enabled = false;
+            currentAction.setEffectiveWeight(0);
+        }
+        // Resolve the previous promise if it exists
+        if (this.oneShotResolve) {
+            this.oneShotResolve();
+            this.oneShotResolve = null;
+        }
+        // Reset one-shot state variables
+        this.isOneShotPlaying = false;
+        this.oneShotCurrentClip = null;
+        this.oneShotFreezeOnLastFrame = false;
+        // Note: We don't reset oneShotPrevState here since the new one-shot will set it
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_AnimationMachine';
+    }
+};
+_a = IAsyncLoadableTag;
+AnimationStateMachineComponent = __decorate([
+    EngineClass('AnimationStateMachineComponent'),
+    __metadata("design:paramtypes", [Object])
+], AnimationStateMachineComponent);
+export { AnimationStateMachineComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AnimationStateMachineComponent.js","sourceRoot":"","sources":["../../../../src/components/visual/AnimationStateMachineComponent.ts"],"names":[],"mappings":";;;;;;;;;;AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACvB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAwGpD,IAAM,8BAA8B,GAApC,MAAM,8BAA+B,SAAQ,cAA4C;IAyB9F,YAAY,OAAqC;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAC;QAzBR;;;;mBAAsB,IAAI;WAAC;QAE5B;;;;mBAAqC,IAAI;WAAC;QAC1C;;;;mBAA8C,IAAI,GAAG,EAAE;WAAC;QACxD;;;;mBAA0C,IAAI;WAAC;QAC/C;;;;mBAAqD,IAAI,GAAG,EAAE;WAAC;QAC/D;;;;mBAA8B,IAAI;WAAC;QACnC;;;;mBAAoB,CAAC;WAAC;QACtB;;;;mBAAyC,EAAE;WAAC;QAC5C;;;;mBAA4D,EAAE;WAAC;QAC/D;;;;mBAA4B,IAAI,GAAG,EAAE;WAAC;QACtC;;;;mBAA4B,KAAK;WAAC;QAClC;;;;mBAAkC,IAAI;WAAC;QACvC;;;;mBAAsC,IAAI;WAAC;QAC3C;;;;mBAAoC,IAAI;WAAC;QACzC;;;;mBAAoC,KAAK;WAAC;QAC1C;;;;mBAA4B,KAAK;WAAC;QAClC;;;;mBAAoE,EAAE;WAAC;QACvE;;;;mBAAgD,IAAI;WAAC;QACrD;;;;mBAA6C,IAAI;WAAC;QAClD;;;;mBAAmB,IAAI;WAAC;QACxB;;;;mBAAyB,KAAK;WAAC;QAC/B;;;;mBAAmB,IAAI,eAAe,EAAE;WAAC;QA60BzC;;;;mBAAqB,CAAC,KAAU,EAAE,EAAE;gBAC1C,IAAI,CAAC,IAAI,CAAC,gBAAgB;oBAAE,OAAO;gBACnC,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM;oBAAE,OAAO;gBACpC,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,kBAAkB;oBAAE,OAAO;gBACpE,WAAW;gBACX,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;gBAEjF,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;oBAClC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;gBACzB,CAAC;qBAAM,CAAC;oBACN,oDAAoD;oBACpD,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;oBACpB,KAAK,CAAC,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;oBAC7B,KAAK,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;oBACnC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;oBAC9B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;oBAC/B,IAAI,CAAC,wBAAwB,GAAG,KAAK,CAAC;oBAEtC,uBAAuB;oBACvB,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;wBAC1B,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;wBAC9C,sDAAsD;wBACtD,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;wBACxD,IAAI,YAAY,EAAE,CAAC;4BACjB,IAAI,YAAY,CAAC,KAAK,IAAI,YAAY,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gCACxD,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;4BAC9C,CAAC;iCAAM,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC;gCAC7B,IAAI,UAAU,GAAuB,SAAS,CAAC;gCAC/C,IAAI,OAAO,YAAY,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oCAC1C,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC;gCACjC,CAAC;qCAAM,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;oCAC5C,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wCACjC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wCACjE,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wCACzC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;4CAClC,UAAU,GAAG,SAAS,CAAC;wCACzB,CAAC;oCACH,CAAC;gCACH,CAAC;gCACD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;oCACnC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;gCAC7B,CAAC;4BACH,CAAC;wBACH,CAAC;wBACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;oBAC/B,CAAC;gBACH,CAAC;gBAED,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;oBACxB,IAAI,CAAC,cAAc,EAAE,CAAC;oBACtB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;gBAC7B,CAAC;YACH,CAAC;WAAC;QAEM;;;;mBAAkB,CAAC,KAAU,EAAE,EAAE;gBACvC,uEAAuE;gBACvE,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,MAAM;oBAAE,OAAO;gBACpC,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBACzE,IAAI,CAAC,YAAY;oBAAE,OAAO;gBAC1B,IAAI,QAAQ,GAAG,KAAK,CAAC;gBACrB,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC;oBACtB,IAAI,OAAO,YAAY,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI;wBAAE,QAAQ,GAAG,IAAI,CAAC;oBAChH,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC;wBAAE,QAAQ,GAAG,IAAI,CAAC;gBACnH,CAAC;gBACD,yHAAyH;gBACzH,IAAI,QAAQ,EAAE,CAAC;oBACb,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;gBAC/B,CAAC;YACH,CAAC;WAAC;IA74BF,CAAC;IAEO,KAAK,CAAC,SAAS;QACrB,6CAA6C;QAC7C,MAAM,UAAU,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,GAAG,MAAM,eAAe,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAC/D,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,OAAO,CAAC,KAAK,CAAC,wEAAwE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;YAChH,OAAO;QACT,CAAC;QAED,gDAAgD;QAChD,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YAC3B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;gBAClE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;QACnC,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;QAC/C,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;QAC7C,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,wBAAwB,EAAE,CAAC;YACzC,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,MAAM,CAAC,wBAAwB,CAAC;QACvE,CAAC;QAED,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,EAAE,EAAE,YAAY,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC;QAC9E,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO,CAAC,KAAK,CAAC,sEAAsE,CAAC,CAAC;QACxF,CAAC;QAED,yDAAyD;QACzD,IAAI,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;YACtC,IAAI,CAAC;gBACH,MAAM,WAAW,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;gBACrE,IAAI,CAAC,qBAAqB,GAAG,MAAM,eAAe,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;gBAC/E,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;oBAChC,OAAO,CAAC,KAAK,CAAC,+EAA+E,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,CAAC;gBACpI,CAAC;YACH,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,KAAK,CAAC,yEAAyE,EAAE,CAAC,CAAC,CAAC;YAC9F,CAAC;QACH,CAAC;QAED,sEAAsE;QACtE,wEAAwE;QAExE,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,IAAI,EAAE,EAAE;gBAC1D,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/E,CAAC,CAAC,CAAC;YACH,IAAI,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,EAAE,CAAC;gBACvC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAC/B,CAAC;QACH,CAAC;aAAM,CAAC;YACN,uEAAuE;YACvE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAEe,SAAS;QACvB,KAAK,CAAC,SAAS,EAAE,CAAC;QAElB,6BAA6B;QAC7B,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAE3B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,CAAC;IAED,sCAAsC;IAC/B,KAAK,CAAC,WAAW;QACtB,MAAM,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,EAAE,CAAC;IAClD,CAAC;IAEM,SAAS;QACd,OAAO,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC;IAC3C,CAAC;IACD,oCAAoC;IAEpC;;OAEG;IACK,KAAK,CAAC,4BAA4B;QACxC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,OAAO,CAAC,KAAK,CAAC,2FAA2F,CAAC,CAAC;YAC3G,OAAO;QACT,CAAC;QAED,gDAAgD;QAChD,MAAM,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QAC1G,MAAM,cAAc,GAAG,qBAAqB,EAAE,QAAQ,IAAI,IAAI,CAAC;QAC/D,MAAM,iBAAiB,GAAG,qBAAqB,EAAE,WAAW,IAAI,IAAI,CAAC;QAErE,IAAI,IAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC,cAAc,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC1E,OAAO,CAAC,KAAK,CAAC,iHAAiH,CAAC,CAAC;YACjI,OAAO;QACT,CAAC;QAED,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,KAAK,EAAE,YAAY,EAAE,EAAE;YACzE,IAAI,CAAC;gBACH,iEAAiE;gBACjE,MAAM,SAAS,GAAG,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC;gBACrF,MAAM,gBAAgB,GAAG,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,eAAe,CAAC;gBAEhG,uBAAuB;gBACvB,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,SAAS,CAAC,CAAC;gBAC3C,MAAM,IAAI,GAAG,MAAM,eAAe,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;gBACxD,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC9D,OAAO,CAAC,IAAI,CAAC,0DAA0D,SAAS,EAAE,CAAC,CAAC;oBACpF,OAAO;gBACT,CAAC;gBAED,8DAA8D;gBAC9D,IAAI,IAAI,CAAC,qBAAqB,IAAI,gBAAgB,IAAI,cAAc,IAAI,iBAAiB,EAAE,CAAC;oBAC1F,+BAA+B;oBAC/B,MAAM,iBAAiB,GAAG,IAAI,SAAS,CAAC,gBAAgB,CAAC,CAAC;oBAC1D,MAAM,aAAa,GAA2B,MAAM,eAAe,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;oBAEtG,IAAI,CAAC,aAAa,EAAE,CAAC;wBACnB,OAAO,CAAC,KAAK,CAAC,sEAAsE,gBAAgB,EAAE,CAAC,CAAC;wBACxG,OAAO;oBACT,CAAC;oBAED,6EAA6E;oBAC7E,IAAI,aAAa,CAAC,IAAI,KAAK,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAC;wBAC3D,OAAO,CAAC,GAAG,CAAC,uEAAuE,aAAa,CAAC,IAAI,+BAA+B,IAAI,CAAC,UAAU,CAAC,MAAM,eAAe,SAAS,EAAE,CAAC,CAAC;wBACtL,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;4BACnC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;wBAC5C,CAAC;wBACD,OAAO;oBACT,CAAC;oBAED,oCAAoC;oBACpC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC;oBAC/B,IAAI,iBAAgD,CAAC;oBACrD,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE;wBAC5B,IAAI,IAAI,YAAY,KAAK,CAAC,WAAW,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,iBAAiB,EAAE,CAAC;4BAC7E,iBAAiB,GAAG,IAAyB,CAAC;wBAChD,CAAC;oBACH,CAAC,CAAC,CAAC;oBAEH,IAAI,CAAC,iBAAiB,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC;wBACtD,OAAO,CAAC,KAAK,CAAC,oEAAoE,SAAS,EAAE,CAAC,CAAC;wBAC/F,OAAO;oBACT,CAAC;oBAED,MAAM,cAAc,GAAG,iBAAiB,CAAC,QAAQ,CAAC;oBAElD,gFAAgF;oBAChF,IAAI,sBAAsB,GAAG,IAAI,CAAC,qBAAqB,CAAC;oBACxD,IAAI,uBAAuB,GAAG,cAAc,CAAC;oBAE7C,IAAI,kBAAkB,CAAC,aAAa,EAAE,IAAI,CAAC,qBAAqB,CAAC,EAAE,CAAC;wBAClE,OAAO,CAAC,GAAG,CAAC,sGAAsG,SAAS,EAAE,CAAC,CAAC;wBAC/H,MAAM,eAAe,GAAG,oBAAoB,CAC1C,cAAc,EACd,iBAAiB,EACjB,IAAI,CAAC,qBAAqB,CAC3B,CAAC;wBACF,uBAAuB,GAAG,eAAe,CAAC,QAAQ,CAAC;wBACnD,sBAAsB,GAAG,eAAe,CAAC,cAAc,CAAC;oBAC1D,CAAC;oBAED,qBAAqB;oBACrB,MAAM,OAAO,GAAG,sBAAsB,CACpC,IAAI,CAAC,UAAU,EACf,aAAa,EACb,sBAAsB,EACtB,cAAc,EACd,uBAAuB,EACvB,iBAAiB,CAClB,CAAC;oBAEF,6CAA6C;oBAC7C,IAAI,YAAY,GAAG,CAAC,CAAC;oBACrB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;wBAC7B,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;4BAClC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;4BACjD,YAAY,EAAE,CAAC;wBACjB,CAAC;6BAAM,CAAC;4BACN,OAAO,CAAC,IAAI,CAAC,4DAA4D,MAAM,CAAC,YAAY,UAAU,SAAS,EAAE,CAAC,CAAC;wBACrH,CAAC;oBACH,CAAC;oBAED,OAAO,CAAC,GAAG,CAAC,8CAA8C,YAAY,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,eAAe,SAAS,EAAE,CAAC,CAAC;gBAC9H,CAAC;qBAAM,CAAC;oBACN,mCAAmC;oBACnC,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;wBACnC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBAC5C,CAAC;oBACD,OAAO,CAAC,GAAG,CAAC,0CAA0C,IAAI,CAAC,UAAU,CAAC,MAAM,eAAe,SAAS,mBAAmB,CAAC,CAAC;gBAC3H,CAAC;YACH,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,MAAM,SAAS,GAAG,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC;gBACrF,OAAO,CAAC,KAAK,CAAC,6EAA6E,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC;YAC7G,CAAC;QACH,CAAC,CAAC,CAAC,CAAC;IACN,CAAC;IAEO,YAAY,CAAC,IAAyB,EAAE,qBAA8B;QAC5E,MAAM,OAAO,GAAG;YACd,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,YAAY,EAAE,KAAK,CAAC,YAAY;SACxB,CAAC;QACX,MAAM,YAAY,GAAG;YACnB,wBAAwB,EAAE,KAAK,CAAC,wBAAwB;YACxD,0BAA0B,EAAE,KAAK,CAAC,0BAA0B;SACpD,CAAC;QAEX,IAAI,aAAa,GAAG,IAAI,CAAC;QAEzB,4DAA4D;QAC5D,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,EAAE,CAAC;YACxD,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC5C,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,cAAc,GAAG,IAAI,GAAG,EAAU,CAAC;gBACzC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE;oBACtB,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBAChC,CAAC,CAAC,CAAC;gBAEH,MAAM,cAAc,GAAG,aAAa,CAAC,MAAM,CAAC;gBAC5C,MAAM,cAAc,GAA0B,EAAE,CAAC;gBACjD,IAAI,kBAAkB,GAAG,KAAK,CAAC;gBAE/B,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;oBACnC,6FAA6F;oBAC7F,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC1C,IAAI,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;wBACjC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC7B,CAAC;yBAAM,CAAC;wBACN,4HAA4H;wBAC5H,kBAAkB,GAAG,IAAI,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBAED,IAAI,kBAAkB,EAAE,CAAC;oBACvB,2IAA2I;oBAC3I,aAAa,GAAG,IAAI,KAAK,CAAC,aAAa,CACrC,aAAa,CAAC,IAAI,EAClB,aAAa,CAAC,QAAQ,EACtB,cAAc,EACd,aAAa,CAAC,SAAS,CACxB,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,KAAM,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QACrD,2CAA2C;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,kDAAkD;QACrG,IAAI,IAAI,EAAE,CAAC;YACT,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;gBACd,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACpC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;oBAC3B,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC;YACD,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBAC3B,MAAM,CAAC,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC;YACpD,CAAC;YACD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;gBACnB,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC/C,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;oBAC5B,MAAM,CAAC,SAAS,GAAG,SAAS,CAAC;gBAC/B,CAAC;YACH,CAAC;QACH,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,IAAI,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACtE,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO;QAChC,IAAI,IAAI,CAAC,aAAa;YAAE,OAAO,CAAC,6CAA6C;QAE7E,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;QAEjD,IAAI,KAAK,EAAE,CAAC;YACV,6DAA6D;YAC7D,IAAI,IAAI,CAAC,wBAAwB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC7C,MAAM,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAC5C,CAAC;YAED,wDAAwD;YACxD,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YAErB,8DAA8D;YAC9D,MAAM,cAAc,GAAG,IAAI,GAAG,EAAU,CAAC;YACzC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC/C,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;oBACf,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;wBACnC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBACjC,CAAC;yBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;wBACrC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;oBACvD,CAAC;gBACH,CAAC;gBACD,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;oBAChB,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;gBACvD,CAAC;YACH,CAAC;YAED,gCAAgC;YAChC,KAAK,MAAM,eAAe,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBAChD,cAAc,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YACtC,CAAC;YAED,wDAAwD;YACxD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;oBACpD,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC5C,CAAC;YACH,CAAC;YAED,gEAAgE;YAChE,KAAK,MAAM,QAAQ,IAAI,cAAc,EAAE,CAAC;gBACtC,IAAI,IAAI,GAAG,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;gBACzD,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;oBAC5C,IAAI,IAAI,EAAE,CAAC;wBACT,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBAC5C,CAAC;gBACH,CAAC;gBACD,IAAI,IAAI,EAAE,CAAC;oBACT,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAC1B,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,IAAI,CAAC,yCAAyC,QAAQ,gCAAgC,CAAC,CAAC;gBAClG,CAAC;YACH,CAAC;YAED,2EAA2E;YAC3E,wDAAwD;YACxD,MAAM,cAAc,GAAG,kBAAkB,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;YAClE,KAAK,MAAM,QAAQ,IAAI,cAAc,EAAE,CAAC;gBACtC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAChC,MAAM,IAAI,GAAG,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;oBAC3D,IAAI,IAAI,EAAE,CAAC;wBACT,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;oBAC1B,CAAC;gBACH,CAAC;YACH,CAAC;YAED,6EAA6E;YAC7E,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC5B,CAAC;IACH,CAAC;IAEO,gBAAgB;QACtB,qBAAqB;QACrB,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YACxD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAmB,CAAC;YAC/D,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACf,IAAI,UAAU,GAAuB,SAAS,CAAC;gBAC/C,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACnC,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC;gBAC1B,CAAC;qBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;oBACrC,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC1B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC1D,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;wBAClC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;4BAClC,UAAU,GAAG,SAAS,CAAC;wBACzB,CAAC;oBACH,CAAC;gBACH,CAAC;gBACD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;oBACnC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBACxB,CAAC;YACH,CAAC;YACD,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAEO,IAAI,CAAC,IAAa,EAAE,gBAAwB,GAAG;QACrD,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QACxB,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,MAAM,EAAE,CAAC;YACX,6CAA6C;YAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,UAAU,IAAI,UAAU,KAAK,MAAM,EAAE,CAAC;gBACxC,UAAU,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;YACvD,CAAC;YACD,MAAM,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;YACtB,4CAA4C;YAC5C,MAAM,CAAC,QAAQ,EAAE,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACI,YAAY,CAAC,GAAuD,EAAE,KAAiC;QAC5G,qCAAqC;QACrC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,4DAA4D;QAC5D,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;gBAC5C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACzC,OAAO,CAAC,IAAI,CAAC,uFAAuF,IAAI,EAAE,CAAC,CAAC;YAC9G,CAAC;iBAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;gBACnC,OAAO,CAAC,IAAI,CAAC,uFAAuF,GAAG,EAAE,CAAC,CAAC;YAC7G,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YAC5C,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBACzC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC5B,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,qDAAqD,CAAC,CAAC;oBACpF,SAAS;gBACX,CAAC;gBACD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAC5B,CAAC;YACD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC;aAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC9B,OAAO,CAAC,KAAK,CAAC,cAAc,GAAG,qDAAqD,CAAC,CAAC;gBACtF,OAAO;YACT,CAAC;YACD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAkC,CAAC,CAAC;YAC7D,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC9B,CAAC;IACH,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,GAAW;QAC7B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACxB,MAAM,IAAI,KAAK,CAAC,6EAA6E,GAAG,IAAI,CAAC,CAAC;YACxG,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,cAAc,GAAG,qDAAqD,CAAC,CAAC;QAC1F,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;IACnC,CAAC;IAED;;OAEG;IACI,gBAAgB;QACrB,OAAO,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;IACvD,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,GAAW;QAC7B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,iBAAiB,CAAC,KAAa;QACpC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YAAE,OAAO;QAChC,IAAI,IAAI,CAAC,YAAY,KAAK,KAAK;YAAE,OAAO,CAAC,uCAAuC;QAEhF,sEAAsE;QACtE,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YACxD,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACjD,IAAI,eAAe,GAAa,EAAE,CAAC;YACnC,IAAI,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAClD,eAAe,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACzF,CAAC;iBAAM,IAAI,SAAS,CAAC,IAAI,EAAE,CAAC;gBAC1B,IAAI,OAAO,SAAS,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACvC,eAAe,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;gBACrC,CAAC;qBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;oBACzC,eAAe,GAAG,SAAS,CAAC,IAAI,CAAC;gBACnC,CAAC;YACH,CAAC;YACD,kDAAkD;YAClD,KAAK,MAAM,IAAI,IAAI,eAAe,EAAE,CAAC;gBACnC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACtC,IAAI,MAAM,IAAI,MAAM,CAAC,SAAS,EAAE,EAAE,CAAC;oBACjC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,0CAA0C;gBACjE,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QAEnB,6DAA6D;QAC7D,IAAI,aAAa,GAAG,GAAG,CAAC;QACxB,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACrC,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACjD,IAAI,SAAS,IAAI,SAAS,CAAC,WAAW,EAAE,CAAC;gBACvC,MAAM,UAAU,GAAG,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,CAAC,CAAC;gBACnE,IAAI,UAAU,IAAI,OAAO,UAAU,CAAC,aAAa,KAAK,QAAQ,EAAE,CAAC;oBAC/D,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;gBAC3C,CAAC;YACH,CAAC;QACH,CAAC;QAED,gDAAgD;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChD,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC1C,CAAC;aAAM,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,UAAU,GAAuB,SAAS,CAAC;YAC/C,IAAI,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtC,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC;YAC7B,CAAC;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxC,IAAI,QAAQ,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;oBAC7D,MAAM,SAAS,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACrC,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;wBAClC,UAAU,GAAG,SAAS,CAAC;oBACzB,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACnC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,KAAyF;QAClH,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QACxB,MAAM,cAAc,GAAa,EAAE,CAAC;QACpC,0CAA0C;QAC1C,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,EAAE;YACxD,QAAQ,KAAK,KAAK,CAAC;YACnB,MAAM,aAAa,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;YAC3D,IAAI,MAAyC,CAAC;YAC9C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC7B,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;gBACzC,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC;oBACxD,MAAM,YAAY,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;oBACtD,IAAI,YAAY,EAAE,CAAC;wBACjB,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,KAAK,EAAE,EAAE,aAAa,CAAC,CAAC;wBAChE,MAAM,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACvC,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,CAAC;YACpB,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;gBAClD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;oBACnC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;gBAC3C,CAAC;YACH,CAAC;YACD,IAAI,MAAM,EAAE,CAAC;gBACX,iEAAiE;gBACjE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;oBAC5C,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACnC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;gBAC/B,CAAC;gBACD,oEAAoE;gBACpE,CAAC,IAAI,MAAM,CAAC,kBAAkB,EAAE,CAAC;gBACjC,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;gBACtB,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,CAAC;oBACxB,MAAM,CAAC,IAAI,EAAE,CAAC;gBAChB,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,gBAAgB,CAAC,SAAiC;QACxD,oCAAoC;QACpC,IAAI,cAAc,IAAI,SAAS,EAAE,CAAC;YAChC,IAAI,SAAS,CAAC,YAAY,KAAK,IAAI,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC7D,OAAO,IAAI,CAAC;YACd,CAAC;iBAAM,IAAI,SAAS,CAAC,YAAY,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACrE,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC;QACD,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YACrC,MAAM,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;YAC5B,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACtE,IAAI,aAAa,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC;oBAAE,OAAO,KAAK,CAAC;gBACpG,IAAI,oBAAoB,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,IAAI,IAAI,CAAC,kBAAkB,CAAC;oBAAE,OAAO,KAAK,CAAC;gBACnH,IAAI,UAAU,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAAE,OAAO,KAAK,CAAC;gBAC9F,IAAI,iBAAiB,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,IAAI,IAAI,CAAC,eAAe,CAAC;oBAAE,OAAO,KAAK,CAAC;gBAC7G,IAAI,SAAS,IAAI,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,CAAC;oBAAE,OAAO,KAAK,CAAC;gBACjE,IAAI,YAAY,IAAI,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,UAAU,CAAC;oBAAE,OAAO,KAAK,CAAC;YACzE,CAAC;iBAAM,CAAC;gBACN,IAAI,KAAK,KAAK,IAAI;oBAAE,OAAO,KAAK,CAAC;YACnC,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO,CAAC,sCAAsC;QACzE,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC;YAAE,OAAO;QAElE,qDAAqD;QACrD,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,WAAW,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC;YAC3C,KAAK,MAAM,UAAU,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC;gBACjD,IAAI,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;oBAChD,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;oBACtC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;oBAC9B,OAAO;gBACT,CAAC;YACH,CAAC;QACH,CAAC;QAED,uCAAuC;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAmB,CAAC;QAC/D,KAAK,MAAM,UAAU,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC;YAC3C,IAAI,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;gBAChD,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBACtC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;gBAC9B,MAAM;YACR,CAAC;QACH,CAAC;QACD,6BAA6B;QAC7B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,OAAO,CAAC,IAAY,EAAE,WAAmB,GAAG;QACjD,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QACxB,IAAI,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACxC,kEAAkE;QAClE,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;YACpD,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;gBAC1B,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QACD,0DAA0D;QAC1D,IAAI,UAAU,EAAE,CAAC;YACf,UAAU,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;OAEG;IACa,eAAe,CAAC,SAAiB;QAC/C,KAAK,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAEjC,wCAAwC;QACxC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC;QAC5B,kDAAkD;QAClD,IAAI,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,KAAK,EAAE,CAAC;YAC/D,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,KAAM,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,UAAU,CAAC,OAAgB;QAChC,IAAI,IAAI,CAAC,OAAO,KAAK,OAAO;YAAE,OAAO;QAErC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAED;;OAEG;IACI,SAAS;QACd,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;OAGG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAGD;;OAEG;IACK,kBAAkB;QACxB,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QAExB,gCAAgC;QAChC,KAAK,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;YACpD,IAAI,MAAM,CAAC,SAAS,EAAE,EAAE,CAAC;gBACvB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,iBAAiB;gBACtC,MAAM,CAAC,IAAI,EAAE,CAAC;YAChB,CAAC;QACH,CAAC;QAED,cAAc;QACd,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAE9B,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;IACH,CAAC;IAEM,YAAY;QACjB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,gBAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,OAAO,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK;YAAE,OAAO,EAAE,CAAC;QACtB,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1C,kCAAkC;YAClC,OAAO,KAAK,CAAC,KAAK;iBACf,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;iBAClC,MAAM,CAAC,CAAC,CAAC,EAA8B,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACtB,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACnC,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACvC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACtB,CAAC;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrC,qGAAqG;gBACrG,wCAAwC;gBACxC,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,IAAY,EAAE,oBAA6B,KAAK;QACjE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,SAAS,IAAI,sCAAsC,CAAC,CAAC;QACvE,CAAC;QAED,0DAA0D;QAC1D,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACjC,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,KAAK,CAAC,8BAA8B,IAAI,cAAc,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC;QAC1C,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,wBAAwB,GAAG,iBAAiB,CAAC;QAClD,6BAA6B;QAC7B,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;YACjD,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;gBACnB,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QACD,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;QAClC,MAAM,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAChC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,CAAC,IAAI,EAAE,CAAC;QACd,4BAA4B;QAC5B,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACnC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC;YAC9B,MAAM,CAAC,QAAQ,EAAE,CAAC,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAC1E,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,kBAAkB;YAAE,OAAO;QAE/D,4CAA4C;QAC5C,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAChE,IAAI,aAAa,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAChC,oEAAoE;YACpE,aAAa,CAAC,QAAQ,EAAE,CAAC,mBAAmB,CAAC,UAAU,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAElF,sCAAsC;YACtC,aAAa,CAAC,IAAI,EAAE,CAAC;YACrB,aAAa,CAAC,OAAO,GAAG,KAAK,CAAC;YAC9B,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;QACtC,CAAC;QAED,4CAA4C;QAC5C,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;QAED,iCAAiC;QACjC,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,wBAAwB,GAAG,KAAK,CAAC;QACtC,gFAAgF;IAClF,CAAC;IAwED,sGAAsG;IACtG,mBAAmB;IACnB,sGAAsG;IAEtF,kBAAkB;QAChC,OAAO,uBAAuB,CAAC;IACjC,CAAC;CACF,CAAA;KAh7BW,iBAAiB;AADhB,8BAA8B;IAD1C,WAAW,CAAC,gCAAgC,CAAC;;GACjC,8BAA8B,CAi7B1C"}