@modelprofile.com/flexharness 10.24.0 → 11.0.0

package/dist_ts/classes.flexharness.lifecycle.js

@@ -0,0 +1,625 @@
+import { FlexHarnessAbortError } from './errors.js';
+import { validateIdentifier } from './utils.validation.js';
+import { scopeRetirementMessage, combineErrors } from './utils.flexharness.js';
+/**
+ * Harness and scope lifecycle: namespace fences, storage drains, orphaned resources, scope
+ * retirement and disposal.
+ */
+export class FlexHarnessLifecycle {
+    core;
+    scopeRetirements = new Map();
+    storageDrains = new Map();
+    storageCompactorLifecycleControllers = new Map();
+    orphanedResourceQueue = Promise.resolve();
+    orphanedStoredSessions = new Set();
+    orphanedExecutionContexts = new Map();
+    orphanedProviderReleases = new Map();
+    orphanedTombstoneCleanups = new Map();
+    orphanedTombstoneOwners = new Map();
+    disposePromise;
+    constructor(core) {
+        this.core = core;
+    }
+    retireScope(scopeId) {
+        this.core.commands.assertNoAmbientSlashCommandTeardown({ scopeId });
+        this.core.assertOpen();
+        validateIdentifier(scopeId, 'scopeId');
+        const existing = this.scopeRetirements.get(scopeId);
+        if (existing)
+            return existing;
+        const admission = this.core.getScopeAdmission(scopeId);
+        admission.generation++;
+        admission.retiring = true;
+        let retirement;
+        retirement = this.retireScopeInternal(scopeId).finally(() => {
+            if (this.scopeRetirements.get(scopeId) === retirement)
+                this.scopeRetirements.delete(scopeId);
+            admission.retiring = false;
+            this.core.pruneScopeAdmission(scopeId, admission);
+        });
+        this.scopeRetirements.set(scopeId, retirement);
+        return retirement;
+    }
+    async dispose() {
+        this.core.commands.assertNoAmbientSlashCommandTeardown();
+        if (this.disposePromise)
+            return this.disposePromise;
+        this.core.closed = true;
+        let disposal;
+        disposal = this.disposeInternal().catch((error) => {
+            if (this.disposePromise === disposal)
+                this.disposePromise = undefined;
+            throw error;
+        });
+        this.disposePromise = disposal;
+        return disposal;
+    }
+    async fenceNamespace(state, currentRun, cause) {
+        if (state.lifecycle === 'retired')
+            return;
+        if (this.storageDrains.has(state.storageKey)) {
+            state.fenceAdditionalErrors.push(cause);
+            return;
+        }
+        if (state.fenceInProgress) {
+            state.fenceAdditionalErrors.push(cause);
+            return;
+        }
+        state.fenceInProgress = true;
+        state.lifecycle = 'fenced';
+        const reason = this.core.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.'));
+        if (!state.compactorLifecycleController.signal.aborted) {
+            state.compactorLifecycleController.abort(reason);
+        }
+        const cleanupErrors = [];
+        const ambientContext = this.core.compaction.compactorInvocationContext.getStore();
+        const invocation = ambientContext?.storageKey === state.storageKey
+            && ambientContext.sessionId === currentRun.sessionId
+            ? ambientContext
+            : this.core.compaction.effectiveRunCompactorContext(currentRun);
+        const contextFor = (sessionId) => this.core.compaction.createCompactorContext(invocation.scopeId, invocation.scope, state.storageKey, sessionId);
+        try {
+            for (const stored of state.sessions.values()) {
+                this.core.compaction.abortCompactorLifecycle(stored, reason);
+                this.core.prompts.cancelStoredPromptQueue(stored, reason, stored === currentRun.stored ? currentRun.queueId : undefined, contextFor(stored.session.sessionId));
+            }
+            const otherRuns = [...state.activeRuns.values()].filter((run) => run !== currentRun);
+            for (const run of otherRuns)
+                this.core.runs.cancelRun(run, reason, contextFor(run.sessionId));
+            const dependentRuns = otherRuns.filter((run) => this.core.sessionsAreDependencyRelated(state, currentRun.sessionId, run.sessionId));
+            const independentRuns = otherRuns.filter((run) => !dependentRuns.includes(run));
+            const runResults = await Promise.allSettled(independentRuns.map((run) => run.completion));
+            for (const result of runResults) {
+                if (result.status === 'rejected')
+                    this.core.appendUnexpectedErrors(cleanupErrors, result.reason);
+            }
+            if (dependentRuns.length > 0
+                || (currentRun.delegatedRunAdmissionOwner !== undefined
+                    && state.delegatedRunAdmissionOwners.has(currentRun.delegatedRunAdmissionOwner))) {
+                state.fenceAdditionalErrors.push(cause, ...cleanupErrors);
+                const stateLoad = this.core.stateLoads.get(state.storageKey);
+                if (!stateLoad) {
+                    throw combineErrors([cause, ...cleanupErrors, new Error('The fenced namespace no longer has durable cleanup ownership.')]);
+                }
+                const deferredDrain = this.drainStorage(state.storageKey, stateLoad, reason, { scopeId: invocation.scopeId, scope: invocation.scope });
+                void deferredDrain.catch(() => undefined);
+                return;
+            }
+            cleanupErrors.push(...await this.core.admission.settleDelegatedRunAdmissionOwners([
+                ...state.delegatedRunAdmissionOwners,
+            ]));
+            const detachedCleanupAttempts = this.core.providers.beginDetachedCleanupSettlement(state);
+            await Promise.allSettled([...state.sessionInitializations.values()]);
+            cleanupErrors.push(...await this.closeOrphanedResources(state.storageKey));
+            await state.scopeQueue;
+            await this.core.projects.awaitProjectManagementOperations(state.storageKey, [
+                ...state.sessions.keys(),
+                ...state.retainedSessionCleanups.keys(),
+            ]);
+            const currentTombstoneRoot = state.tombstones.get(currentRun.sessionId)?.rootSessionId
+                ?? currentRun.sessionId;
+            const currentTombstoneCleanup = state.tombstoneCleanups.get(currentTombstoneRoot);
+            const currentTombstoneSessions = new Set(this.core.deletion.tombstoneGroup(state, currentTombstoneRoot).map((tombstone) => tombstone.sessionId));
+            if (currentTombstoneCleanup) {
+                this.retainOrphanedTombstoneCleanup(state.storageKey, currentTombstoneRoot, currentTombstoneCleanup);
+            }
+            const tombstoneAttempts = [...state.tombstoneCleanups.entries()]
+                .filter(([rootSessionId]) => rootSessionId !== currentTombstoneRoot);
+            const tombstoneResults = await Promise.allSettled(tombstoneAttempts.map(([, cleanup]) => cleanup));
+            for (const result of tombstoneResults) {
+                if (result.status === 'rejected')
+                    this.core.appendUnexpectedErrors(cleanupErrors, result.reason);
+            }
+            const attemptedTombstones = new Set(tombstoneAttempts.map(([sessionId]) => sessionId));
+            const attemptedTombstoneSessions = new Set([...attemptedTombstones].flatMap((rootSessionId) => this.core.deletion.tombstoneGroup(state, rootSessionId).map((tombstone) => tombstone.sessionId)));
+            const storedSessions = new Set([
+                ...state.sessions.values(),
+                ...[...state.retainedSessionCleanups]
+                    .filter(([sessionId]) => !currentTombstoneSessions.has(sessionId)
+                    && !attemptedTombstoneSessions.has(sessionId))
+                    .map(([, retained]) => retained.stored),
+            ]);
+            for (const stored of storedSessions) {
+                try {
+                    await this.abortStoredSession(stored, reason, contextFor(stored.session.sessionId));
+                }
+                catch (error) {
+                    cleanupErrors.push(this.core.projectOperationError(error, 'agentSession', currentRun.scopeId, stored.session.sessionId, currentRun.runId));
+                }
+                try {
+                    await this.closeStoredSession(stored, contextFor(stored.session.sessionId));
+                }
+                catch (error) {
+                    if (!this.storedSessionCleanupCompleted(stored)) {
+                        cleanupErrors.push(this.core.projectOperationError(error, 'toolCleanup', currentRun.scopeId, stored.session.sessionId, currentRun.runId));
+                    }
+                }
+                if (stored !== currentRun.stored)
+                    this.core.prompts.purgeStoredPromptQueue(stored);
+            }
+            cleanupErrors.push(...await this.core.providers.settleDetachedCleanups(state, detachedCleanupAttempts));
+            state.fenceAdditionalErrors.length = 0;
+            if (cleanupErrors.length > 0)
+                throw combineErrors([cause, ...cleanupErrors]);
+            state.lifecycle = 'retired';
+            state.sessions.clear();
+            const currentRetainedCleanups = [...state.retainedSessionCleanups]
+                .filter(([sessionId]) => currentTombstoneSessions.has(sessionId));
+            state.retainedSessionCleanups.clear();
+            for (const [sessionId, retained] of currentRetainedCleanups) {
+                state.retainedSessionCleanups.set(sessionId, retained);
+            }
+            state.sessionDeletions.clear();
+            state.tombstoneCleanups.clear();
+            if (currentTombstoneCleanup) {
+                state.tombstoneCleanups.set(currentTombstoneRoot, currentTombstoneCleanup);
+            }
+            state.activeRuns.clear();
+            state.delegatedRunAdmissionOwners.clear();
+            state.pendingPermissions.clear();
+            state.initializingSessions.clear();
+            state.sessionInitializations.clear();
+            this.core.stateLoads.delete(state.storageKey);
+            if (this.storageCompactorLifecycleControllers.get(state.storageKey)
+                === state.compactorLifecycleController)
+                this.storageCompactorLifecycleControllers.delete(state.storageKey);
+        }
+        finally {
+            state.fenceInProgress = false;
+        }
+    }
+    deferNamespaceDrain(state, cause, invocation) {
+        state.lifecycle = 'fenced';
+        state.fenceAdditionalErrors.push(cause);
+        const stateLoad = this.core.stateLoads.get(state.storageKey);
+        if (!stateLoad)
+            return;
+        const drain = this.drainStorage(state.storageKey, stateLoad, this.core.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.')), invocation);
+        void drain.catch(() => undefined);
+    }
+    deferReversionReleaseDrain(state, stored, scopeId, scope) {
+        state.lifecycle = 'fenced';
+        const reason = this.core.trustInternalError(new FlexHarnessAbortError('The session namespace was fenced.'));
+        this.core.compaction.abortCompactorLifecycle(stored, reason);
+        const stateLoad = this.core.stateLoads.get(state.storageKey);
+        if (!stateLoad)
+            return;
+        const drain = this.drainStorage(state.storageKey, stateLoad, reason, { scopeId, scope });
+        void drain.catch(() => undefined);
+    }
+    async closeStoredSession(stored, context = stored.compactorContext) {
+        const errors = [];
+        if (!stored.agentSessionCloseCompleted) {
+            try {
+                await this.core.compaction.withCompactorContext(context, () => stored.agentSession.close());
+                if (!stored.agentSession.closeCleanupCompleted) {
+                    throw new Error('AgentSession.close() resolved before cleanup ownership was released.');
+                }
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (stored.agentSession.closeCleanupCompleted) {
+                stored.agentSessionCloseCompleted = true;
+            }
+        }
+        if (stored.agentSessionCloseCompleted && !stored.executionContextCloseCompleted) {
+            try {
+                await stored.executionContextHandle.close();
+                stored.executionContextCloseCompleted = true;
+                delete stored.executionContextHandle;
+                delete stored.jobs;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (stored.agentSessionCloseCompleted) {
+            stored.agentSessionAbortCompleted = true;
+        }
+        if (stored.agentSessionCloseCompleted && !stored.agentEventStoreReleased) {
+            try {
+                await this.core.stores.agentEvents.releaseSession(stored.storageKey, stored.session.sessionId);
+                stored.agentEventStoreReleased = true;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (stored.agentSessionCloseCompleted
+            && stored.executionContextCloseCompleted
+            && !stored.jobStoreReleased) {
+            try {
+                await this.core.stores.jobs.releaseSession(stored.storageKey, stored.session.sessionId);
+                stored.jobStoreReleased = true;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (stored.metricsFailure !== undefined) {
+            errors.push(stored.metricsFailure);
+            // Runtime ownership has settled; the fenced namespace will be reloaded from its durable WAL.
+            if (stored.agentSessionCloseCompleted)
+                delete stored.metricsFailure;
+        }
+        if (errors.length > 0)
+            throw combineErrors(errors);
+    }
+    async abortStoredSession(stored, reason, context = stored.compactorContext) {
+        if (stored.agentSessionAbortCompleted)
+            return;
+        await this.core.compaction.withCompactorContext(context, () => stored.agentSession.abortSession(reason, { abortBackgroundJobs: true }));
+        stored.agentSessionAbortCompleted = true;
+    }
+    storedSessionCleanupCompleted(stored) {
+        return stored.agentSessionCloseCompleted
+            && stored.executionContextCloseCompleted
+            && stored.agentEventStoreReleased
+            && stored.jobStoreReleased;
+    }
+    async releasePartialProviderSession(providerName, storageKey, sessionId) {
+        const retained = this.retainPartialProviderSession(providerName, storageKey, sessionId);
+        if (!retained)
+            return;
+        await retained.release();
+    }
+    retainPartialProviderSession(providerName, storageKey, sessionId) {
+        const provider = this.core.stores[providerName];
+        if (!provider.releaseSession)
+            return undefined;
+        const key = JSON.stringify([providerName, storageKey, sessionId]);
+        let retained = this.orphanedProviderReleases.get(key);
+        if (!retained) {
+            retained = {
+                providerName,
+                storageKey,
+                sessionId,
+                release: async () => {
+                    await provider.releaseSession(storageKey, sessionId);
+                    if (this.orphanedProviderReleases.get(key) === retained) {
+                        this.orphanedProviderReleases.delete(key);
+                    }
+                },
+            };
+            this.orphanedProviderReleases.set(key, retained);
+        }
+        return retained;
+    }
+    hasOrphanedSessionResources(storageKey, sessionId) {
+        return [...this.orphanedStoredSessions].some((stored) => stored.storageKey === storageKey && stored.session.sessionId === sessionId)
+            || [...this.orphanedExecutionContexts.values()].some((owner) => owner.storageKey === storageKey && owner.sessionId === sessionId)
+            || [...this.orphanedProviderReleases.values()].some((retained) => retained.storageKey === storageKey && retained.sessionId === sessionId);
+    }
+    retainOrphanedTombstoneCleanup(storageKey, sessionId, completion) {
+        const key = JSON.stringify([storageKey, sessionId]);
+        if (this.orphanedTombstoneCleanups.has(key))
+            return;
+        const retained = { storageKey, sessionId, completion };
+        this.orphanedTombstoneCleanups.set(key, retained);
+        void completion.then(() => {
+            if (this.orphanedTombstoneCleanups.get(key) === retained) {
+                this.orphanedTombstoneCleanups.delete(key);
+            }
+        }, () => {
+            if (this.orphanedTombstoneCleanups.get(key) === retained) {
+                this.orphanedTombstoneCleanups.delete(key);
+            }
+        });
+    }
+    closeOrphanedResources(storageKey) {
+        const operation = this.orphanedResourceQueue.then(() => this.closeOrphanedResourcesInternal(storageKey));
+        this.orphanedResourceQueue = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async closeOrphanedResourcesInternal(storageKey) {
+        const errors = [];
+        for (const [key, owner] of [...this.orphanedTombstoneOwners]) {
+            if (storageKey !== undefined && owner.state.storageKey !== storageKey)
+                continue;
+            try {
+                await this.core.deletion.finishTombstoneCleanup(owner.state, owner.rootSessionId, owner.scopeId, { scopeId: owner.scopeId, scope: owner.scope });
+                this.orphanedTombstoneOwners.delete(key);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        const tombstoneCleanups = [...this.orphanedTombstoneCleanups.values()]
+            .filter((retained) => storageKey === undefined || retained.storageKey === storageKey);
+        const tombstoneResults = await Promise.allSettled(tombstoneCleanups.map((retained) => retained.completion));
+        for (const result of tombstoneResults) {
+            if (result.status === 'rejected')
+                this.core.appendUnexpectedErrors(errors, result.reason);
+        }
+        for (const stored of [...this.orphanedStoredSessions]) {
+            if (storageKey !== undefined && stored.storageKey !== storageKey)
+                continue;
+            try {
+                await this.closeStoredSession(stored);
+                this.orphanedStoredSessions.delete(stored);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        for (const [handle, owner] of [...this.orphanedExecutionContexts]) {
+            if (storageKey !== undefined && owner.storageKey !== storageKey)
+                continue;
+            try {
+                await handle.close();
+                this.orphanedExecutionContexts.delete(handle);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        for (const [key, retained] of [...this.orphanedProviderReleases]) {
+            if (storageKey !== undefined && retained.storageKey !== storageKey)
+                continue;
+            if (retained.providerName === 'jobs'
+                && [...this.orphanedExecutionContexts.values()].some((owner) => owner.storageKey === retained.storageKey && owner.sessionId === retained.sessionId))
+                continue;
+            try {
+                await retained.release();
+            }
+            catch (error) {
+                errors.push(error);
+                this.orphanedProviderReleases.set(key, retained);
+            }
+        }
+        return errors;
+    }
+    orphanedResourceStorageKeys() {
+        return new Set([
+            ...[...this.orphanedStoredSessions].map((stored) => stored.storageKey),
+            ...[...this.orphanedExecutionContexts.values()].map((owner) => owner.storageKey),
+            ...[...this.orphanedProviderReleases.values()].map((retained) => retained.storageKey),
+            ...[...this.orphanedTombstoneCleanups.values()].map((retained) => retained.storageKey),
+            ...[...this.orphanedTombstoneOwners.values()].map((owner) => owner.state.storageKey),
+        ]);
+    }
+    async retireScopeInternal(scopeId) {
+        const scope = await this.core.scopeResolver.resolveScope(scopeId);
+        this.core.assertOpen();
+        validateIdentifier(scope.storageKey, 'resolved storageKey');
+        this.core.commands.assertNoAmbientSlashCommandTeardown({ storageKey: scope.storageKey });
+        const errors = [];
+        const listingSettlement = this.core.commands.abortSlashCommandListings(scope.storageKey, this.core.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage)));
+        if (listingSettlement)
+            await listingSettlement;
+        await this.core.commands.abortSlashCommandExecutions(scope.storageKey, this.core.trustInternalError(new FlexHarnessAbortError(scopeRetirementMessage)), errors);
+        const stateLoad = this.core.stateLoads.get(scope.storageKey);
+        if (!stateLoad) {
+            const drain = this.storageDrains.get(scope.storageKey);
+            if (drain) {
+                try {
+                    await drain;
+                }
+                catch (error) {
+                    this.core.appendUnexpectedErrors(errors, error);
+                }
+            }
+            else {
+                errors.push(...await this.closeOrphanedResources(scope.storageKey));
+            }
+        }
+        else {
+            try {
+                await this.drainStorage(scope.storageKey, stateLoad, this.core.createScopeRetirementError(), { scopeId, scope: scope.scope });
+            }
+            catch (error) {
+                this.core.appendUnexpectedErrors(errors, error);
+            }
+        }
+        if (errors.length > 0)
+            throw combineErrors(errors);
+    }
+    drainStorage(storageKey, stateLoad, reason, invocation) {
+        const compactorController = this.storageCompactorLifecycleControllers.get(storageKey);
+        if (compactorController && !compactorController.signal.aborted) {
+            compactorController.abort(reason);
+        }
+        const existing = this.storageDrains.get(storageKey);
+        if (existing)
+            return existing;
+        let completed = false;
+        let drain;
+        drain = this.drainStorageInternal(storageKey, stateLoad, reason, invocation).then(() => {
+            completed = true;
+        }).finally(() => {
+            if (completed && this.core.stateLoads.get(storageKey) === stateLoad) {
+                this.core.stateLoads.delete(storageKey);
+                if (this.storageCompactorLifecycleControllers.get(storageKey) === compactorController) {
+                    this.storageCompactorLifecycleControllers.delete(storageKey);
+                }
+            }
+            if (this.storageDrains.get(storageKey) === drain)
+                this.storageDrains.delete(storageKey);
+        });
+        this.storageDrains.set(storageKey, drain);
+        return drain;
+    }
+    async drainStorageInternal(storageKey, stateLoad, reason, invocation) {
+        let state;
+        try {
+            state = await stateLoad;
+        }
+        catch {
+            const orphanErrors = await this.closeOrphanedResources(storageKey);
+            if (orphanErrors.length > 0)
+                throw combineErrors(orphanErrors);
+            return;
+        }
+        if (state.lifecycle !== 'fenced')
+            state.lifecycle = 'retiring';
+        const configurationSettlement = this.core.configurations.abortSessionConfigurations(storageKey, reason);
+        if (configurationSettlement)
+            await configurationSettlement;
+        for (const staged of [...state.sessionImports.values()]) {
+            if (staged.phase === 'staging')
+                this.core.imports.releaseStagedSessionImport(staged);
+        }
+        const errors = [];
+        const listingSettlement = this.core.commands.abortSlashCommandListings(storageKey, reason);
+        if (listingSettlement)
+            await listingSettlement;
+        await this.core.commands.abortSlashCommandExecutions(storageKey, reason, errors);
+        const detachedCleanupAttempts = this.core.providers.beginDetachedCleanupSettlement(state);
+        const contextFor = (sessionId) => invocation
+            ? this.core.compaction.createCompactorContext(invocation.scopeId, invocation.scope, storageKey, sessionId)
+            : undefined;
+        for (const stored of state.sessions.values()) {
+            this.core.compaction.abortCompactorLifecycle(stored, reason);
+            this.core.prompts.cancelStoredPromptQueue(stored, reason, undefined, contextFor(stored.session.sessionId));
+        }
+        for (const run of state.activeRuns.values()) {
+            if (run.phase !== 'finalizing' && run.phase !== 'promoting') {
+                this.core.runs.cancelRun(run, reason, contextFor(run.sessionId));
+            }
+        }
+        for (const pending of [...state.pendingPermissions.values()])
+            this.core.permissions.rejectPending(state, pending, reason);
+        const runResults = await Promise.allSettled([...state.activeRuns.values()].map((run) => run.completion));
+        for (const result of runResults) {
+            if (result.status === 'rejected')
+                this.core.appendUnexpectedErrors(errors, result.reason);
+        }
+        errors.push(...await this.core.admission.settleDelegatedRunAdmissionOwners([
+            ...state.delegatedRunAdmissionOwners,
+        ]));
+        for (const stored of state.sessions.values()) {
+            try {
+                await this.abortStoredSession(stored, reason, contextFor(stored.session.sessionId));
+            }
+            catch (error) {
+                errors.push(this.core.projectOperationError(error, 'agentSession', stored.session.scopeId, stored.session.sessionId, 'lifecycle-abort'));
+            }
+        }
+        await Promise.allSettled([...state.sessionInitializations.values()]);
+        errors.push(...await this.closeOrphanedResources(state.storageKey));
+        await state.scopeQueue;
+        await this.core.projects.awaitProjectManagementOperations(state.storageKey, [
+            ...state.sessions.keys(),
+            ...state.retainedSessionCleanups.keys(),
+        ]);
+        await Promise.all([...state.sessions.values()].flatMap((stored) => [
+            stored.projectionQueue,
+            stored.permissionQueue,
+            ...(stored.promptQueueDrain ? [stored.promptQueueDrain] : []),
+        ]));
+        const tombstoneAttempts = [...state.tombstoneCleanups.entries()];
+        const tombstoneResults = await Promise.allSettled(tombstoneAttempts.map(([, cleanup]) => cleanup));
+        for (const result of tombstoneResults) {
+            if (result.status === 'rejected')
+                this.core.appendUnexpectedErrors(errors, result.reason);
+        }
+        const attemptedTombstones = new Set(tombstoneAttempts.map(([sessionId]) => sessionId));
+        errors.push(...await this.core.providers.settleDetachedCleanups(state, detachedCleanupAttempts));
+        for (const stored of state.sessions.values()) {
+            try {
+                await this.closeStoredSession(stored, contextFor(stored.session.sessionId));
+            }
+            catch (error) {
+                this.core.appendUnexpectedErrors(errors, this.core.projectOperationError(error, 'toolCleanup', stored.session.scopeId, stored.session.sessionId, 'lifecycle-close'));
+            }
+            const releaseContext = invocation ?? stored.compactorContext;
+            if (releaseContext) {
+                try {
+                    await this.core.reversions.drainReversionReleases(state, stored, releaseContext.scopeId, releaseContext.scope, true);
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            this.core.prompts.purgeStoredPromptQueue(stored);
+        }
+        const roots = this.core.deletion.orderTombstoneRootsChildFirst(state, [...new Set([...state.tombstones.values()].map((tombstone) => tombstone.rootSessionId ?? tombstone.sessionId))]);
+        for (const rootSessionId of roots) {
+            if (attemptedTombstones.has(rootSessionId))
+                continue;
+            if (this.core.deletion.descendantTombstoneRoots(state, rootSessionId).length > 0)
+                continue;
+            const retained = state.retainedSessionCleanups.get(rootSessionId);
+            try {
+                await this.core.deletion.finishTombstoneCleanup(state, rootSessionId, invocation?.scopeId ?? retained?.stored.session.scopeId ?? state.scopeIdHint, invocation);
+            }
+            catch (error) {
+                this.core.appendUnexpectedErrors(errors, error);
+            }
+        }
+        errors.push(...state.fenceAdditionalErrors.splice(0));
+        if (errors.length > 0)
+            throw combineErrors(errors);
+        state.lifecycle = 'retired';
+        state.sessions.clear();
+        state.retainedSessionCleanups.clear();
+        state.sessionDeletions.clear();
+        state.tombstoneCleanups.clear();
+        state.activeRuns.clear();
+        state.delegatedRunAdmissionOwners.clear();
+        state.pendingPermissions.clear();
+        state.initializingSessions.clear();
+        state.sessionInitializations.clear();
+        state.sessionImports.clear();
+    }
+    async disposeInternal() {
+        const pendingAdmissions = [...this.core.prompts.pendingPromptAdmissionOwners];
+        const pendingAdmissionReason = this.core.trustInternalError(new FlexHarnessAbortError('The prompt admission was aborted because FlexHarness was disposed.'));
+        for (const pending of pendingAdmissions) {
+            if (!pending.controller.signal.aborted)
+                pending.controller.abort(pendingAdmissionReason);
+        }
+        await Promise.all(pendingAdmissions.map((pending) => pending.settled));
+        const errors = [];
+        const listingSettlement = this.core.commands.abortSlashCommandListings(undefined, this.core.trustInternalError(new FlexHarnessAbortError('The slash command listing was aborted because FlexHarness was disposed.')));
+        if (listingSettlement)
+            await listingSettlement;
+        await this.core.commands.abortSlashCommandExecutions(undefined, this.core.trustInternalError(new FlexHarnessAbortError('The slash command was aborted because FlexHarness was disposed.')), errors);
+        const loads = [...this.core.stateLoads.entries()];
+        const results = await Promise.allSettled(loads.map(([storageKey, stateLoad]) => this.drainStorage(storageKey, stateLoad, this.core.trustInternalError(new FlexHarnessAbortError('The run was aborted because FlexHarness was disposed.')))));
+        for (const result of results) {
+            if (result.status === 'rejected')
+                this.core.appendUnexpectedErrors(errors, result.reason);
+        }
+        const drainedStorageKeys = new Set(loads.map(([storageKey]) => storageKey));
+        for (const storageKey of this.orphanedResourceStorageKeys()) {
+            if (!drainedStorageKeys.has(storageKey)) {
+                errors.push(...await this.closeOrphanedResources(storageKey));
+            }
+        }
+        this.core.listeners.clear();
+        if (errors.length > 0)
+            throw combineErrors(errors);
+        this.core.compaction.compactorInvocationContext.disable();
+        this.core.commands.slashCommandInvocationContext.disable();
+        this.core.commands.slashCommandActivityContext.disable();
+        this.core.stateLoads.clear();
+        this.core.scopeAdmissions.clear();
+        this.scopeRetirements.clear();
+        this.storageDrains.clear();
+        this.storageCompactorLifecycleControllers.clear();
+        this.core.configurations.sessionConfigurations.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.flexharness.lifecycle.js","sourceRoot":"","sources":["../ts/classes.flexharness.lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAU3D,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAG/E;;;GAGG;AACH,MAAM,OAAO,oBAAoB;IAeF,IAAI;IAdhB,gBAAgB,GAAG,IAAI,GAAG,EAAyB,CAAC;IACrD,aAAa,GAAG,IAAI,GAAG,EAAyB,CAAC;IACjD,oCAAoC,GAAG,IAAI,GAAG,EAA2B,CAAC;IAClF,qBAAqB,GAAkB,OAAO,CAAC,OAAO,EAAE,CAAC;IACjD,sBAAsB,GAAG,IAAI,GAAG,EAAuB,CAAC;IACxD,yBAAyB,GAAG,IAAI,GAAG,EAGhD,CAAC;IACa,wBAAwB,GAAG,IAAI,GAAG,EAAoC,CAAC;IACvE,yBAAyB,GAAG,IAAI,GAAG,EAAqC,CAAC;IAC1E,uBAAuB,GAAG,IAAI,GAAG,EAA2C,CAAC;IACrF,cAAc,CAAiB;IAEvC,YAA6B,IAA6B;oBAA7B,IAAI;IAA4B,CAAC;IAEvD,WAAW,CAAC,OAAe;QAChC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,mCAAmC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QACvB,kBAAkB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QACpD,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACvD,SAAS,CAAC,UAAU,EAAE,CAAC;QACvB,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC;QAC1B,IAAI,UAA0B,CAAC;QAC/B,UAAU,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YAC1D,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,UAAU;gBAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC7F,SAAS,CAAC,QAAQ,GAAG,KAAK,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QAC/C,OAAO,UAAU,CAAC;IACpB,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,mCAAmC,EAAE,CAAC;QACzD,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO,IAAI,CAAC,cAAc,CAAC;QACpD,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACxB,IAAI,QAAwB,CAAC;QAC7B,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YAChD,IAAI,IAAI,CAAC,cAAc,KAAK,QAAQ;gBAAE,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;YACtE,MAAM,KAAK,CAAC;QACd,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,KAAoB,EAAE,UAAsB,EAAE,KAAc;QACtF,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO;QAC1C,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,CAAC;YAC7C,KAAK,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxC,OAAO;QACT,CAAC;QACD,IAAI,KAAK,CAAC,eAAe,EAAE,CAAC;YAC1B,KAAK,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACxC,OAAO;QACT,CAAC;QACD,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC;QAC7B,KAAK,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CAAC,mCAAmC,CAAC,CAAC,CAAC;QAC5G,IAAI,CAAC,KAAK,CAAC,4BAA4B,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACvD,KAAK,CAAC,4BAA4B,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACnD,CAAC;QACD,MAAM,aAAa,GAAc,EAAE,CAAC;QACpC,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,0BAA0B,CAAC,QAAQ,EAAE,CAAC;QAClF,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,KAAK,KAAK,CAAC,UAAU;eAC7D,cAAc,CAAC,SAAS,KAAK,UAAU,CAAC,SAAS;YACpD,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,4BAA4B,CAAC,UAAU,CAAC,CAAC;QAClE,MAAM,UAAU,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CACnF,UAAU,CAAC,OAAO,EAClB,UAAU,CAAC,KAAK,EAChB,KAAK,CAAC,UAAU,EAChB,SAAS,CACV,CAAC;QACF,IAAI,CAAC;YACH,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;gBAC7C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAC7D,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,uBAAuB,CACvC,MAAM,EACN,MAAM,EACN,MAAM,KAAK,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,EAC7D,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CACrC,CAAC;YACJ,CAAC;YACD,MAAM,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,UAAU,CAAC,CAAC;YACrF,KAAK,MAAM,GAAG,IAAI,SAAS;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;YAC9F,MAAM,aAAa,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAC7C,IAAI,CAAC,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;YACtF,MAAM,eAAe,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;YAChF,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;YAC1F,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;gBAChC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;oBAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACnG,CAAC;YACD,IACE,aAAa,CAAC,MAAM,GAAG,CAAC;mBACrB,CAAC,UAAU,CAAC,0BAA0B,KAAK,SAAS;uBAClD,KAAK,CAAC,2BAA2B,CAAC,GAAG,CAAC,UAAU,CAAC,0BAA0B,CAAC,CAAC,EAClF,CAAC;gBACD,KAAK,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,aAAa,CAAC,CAAC;gBAC1D,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;gBAC7D,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,MAAM,aAAa,CAAC,CAAC,KAAK,EAAE,GAAG,aAAa,EAAE,IAAI,KAAK,CACrD,+DAA+D,CAChE,CAAC,CAAC,CAAC;gBACN,CAAC;gBACD,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CACrC,KAAK,CAAC,UAAU,EAChB,SAAS,EACT,MAAM,EACN,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,CACzD,CAAC;gBACF,KAAK,aAAa,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;gBAC1C,OAAO;YACT,CAAC;YACD,aAAa,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,iCAAiC,CAAC;gBAChF,GAAG,KAAK,CAAC,2BAA2B;aACrC,CAAC,CAAC,CAAC;YACJ,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC;YAC1F,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACrE,aAAa,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;YAC3E,MAAM,KAAK,CAAC,UAAU,CAAC;YACvB,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,gCAAgC,CACvD,KAAK,CAAC,UAAU,EAChB;gBACE,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE;gBACxB,GAAG,KAAK,CAAC,uBAAuB,CAAC,IAAI,EAAE;aACxC,CACF,CAAC;YACF,MAAM,oBAAoB,GAAG,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,aAAa;mBACjF,UAAU,CAAC,SAAS,CAAC;YAC1B,MAAM,uBAAuB,GAAG,KAAK,CAAC,iBAAiB,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;YAClF,MAAM,wBAAwB,GAAG,IAAI,GAAG,CACtC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,KAAK,EAAE,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,CACvG,CAAC;YACF,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,IAAI,CAAC,8BAA8B,CACjC,KAAK,CAAC,UAAU,EAChB,oBAAoB,EACpB,uBAAuB,CACxB,CAAC;YACJ,CAAC;YACD,MAAM,iBAAiB,GAAG,CAAC,GAAG,KAAK,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC;iBAC7D,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC,EAAE,EAAE,CAAC,aAAa,KAAK,oBAAoB,CAAC,CAAC;YACvE,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,UAAU,CAC/C,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAChD,CAAC;YACF,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;gBACtC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;oBAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACnG,CAAC;YACD,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;YACvF,MAAM,0BAA0B,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE,CAC5F,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACpG,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;gBAC7B,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE;gBAC1B,GAAG,CAAC,GAAG,KAAK,CAAC,uBAAuB,CAAC;qBAClC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CACtB,CAAC,wBAAwB,CAAC,GAAG,CAAC,SAAS,CAAC;uBACrC,CAAC,0BAA0B,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;qBAC/C,GAAG,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC;aAC1C,CAAC,CAAC;YACH,KAAK,MAAM,MAAM,IAAI,cAAc,EAAE,CAAC;gBACpC,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;gBACtF,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAChD,KAAK,EACL,cAAc,EACd,UAAU,CAAC,OAAO,EAClB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,UAAU,CAAC,KAAK,CACjB,CAAC,CAAC;gBACL,CAAC;gBACD,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;gBAC9E,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,EAAE,CAAC;wBAChD,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAChD,KAAK,EACL,aAAa,EACb,UAAU,CAAC,OAAO,EAClB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,UAAU,CAAC,KAAK,CACjB,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBACD,IAAI,MAAM,KAAK,UAAU,CAAC,MAAM;oBAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;YACrF,CAAC;YACD,aAAa,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC;YACxG,KAAK,CAAC,qBAAqB,CAAC,MAAM,GAAG,CAAC,CAAC;YACvC,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC;gBAAE,MAAM,aAAa,CAAC,CAAC,KAAK,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC;YAC7E,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;YAC5B,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACvB,MAAM,uBAAuB,GAAG,CAAC,GAAG,KAAK,CAAC,uBAAuB,CAAC;iBAC/D,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,wBAAwB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;YACpE,KAAK,CAAC,uBAAuB,CAAC,KAAK,EAAE,CAAC;YACtC,KAAK,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,uBAAuB,EAAE,CAAC;gBAC5D,KAAK,CAAC,uBAAuB,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YACzD,CAAC;YACD,KAAK,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC/B,KAAK,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;YAChC,IAAI,uBAAuB,EAAE,CAAC;gBAC5B,KAAK,CAAC,iBAAiB,CAAC,GAAG,CAAC,oBAAoB,EAAE,uBAAuB,CAAC,CAAC;YAC7E,CAAC;YACD,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACzB,KAAK,CAAC,2BAA2B,CAAC,KAAK,EAAE,CAAC;YAC1C,KAAK,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;YACjC,KAAK,CAAC,oBAAoB,CAAC,KAAK,EAAE,CAAC;YACnC,KAAK,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAC9C,IACE,IAAI,CAAC,oCAAoC,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC;oBAC3D,KAAK,CAAC,4BAA4B;gBACtC,IAAI,CAAC,oCAAoC,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACvE,CAAC;gBAAS,CAAC;YACT,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC;QAChC,CAAC;IACH,CAAC;IAEM,mBAAmB,CACxB,KAAoB,EACpB,KAAc,EACd,UAA+C;QAE/C,KAAK,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC3B,KAAK,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxC,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS;YAAE,OAAO;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAC7B,KAAK,CAAC,UAAU,EAChB,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CAAC,mCAAmC,CAAC,CAAC,EAC5F,UAAU,CACX,CAAC;QACF,KAAK,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAEM,0BAA0B,CAC/B,KAAoB,EACpB,MAA2B,EAC3B,OAAe,EACf,KAAa;QAEb,KAAK,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CAAC,mCAAmC,CAAC,CAAC,CAAC;QAC5G,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7D,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS;YAAE,OAAO;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAC7B,KAAK,CAAC,UAAU,EAChB,SAAS,EACT,MAAM,EACN,EAAE,OAAO,EAAE,KAAK,EAAE,CACnB,CAAC;QACF,KAAK,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAC7B,MAA2B,EAC3B,OAAO,GAAyC,MAAM,CAAC,gBAAiB;QAExE,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,0BAA0B,EAAE,CAAC;YACvC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAC7C,OAAO,EACP,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,CAClC,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,qBAAqB,EAAE,CAAC;oBAC/C,MAAM,IAAI,KAAK,CAAC,sEAAsE,CAAC,CAAC;gBAC1F,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;YACD,IAAI,MAAM,CAAC,YAAY,CAAC,qBAAqB,EAAE,CAAC;gBAC9C,MAAM,CAAC,0BAA0B,GAAG,IAAI,CAAC;YAC3C,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,0BAA0B,IAAI,CAAC,MAAM,CAAC,8BAA8B,EAAE,CAAC;YAChF,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,sBAAuB,CAAC,KAAM,EAAE,CAAC;gBAC9C,MAAM,CAAC,8BAA8B,GAAG,IAAI,CAAC;gBAC7C,OAAO,MAAM,CAAC,sBAAsB,CAAC;gBACrC,OAAO,MAAM,CAAC,IAAI,CAAC;YACrB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,0BAA0B,EAAE,CAAC;YACtC,MAAM,CAAC,0BAA0B,GAAG,IAAI,CAAC;QAC3C,CAAC;QACD,IAAI,MAAM,CAAC,0BAA0B,IAAI,CAAC,MAAM,CAAC,uBAAuB,EAAE,CAAC;YACzE,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,cAAe,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBAChG,MAAM,CAAC,uBAAuB,GAAG,IAAI,CAAC;YACxC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,IACE,MAAM,CAAC,0BAA0B;eAC9B,MAAM,CAAC,8BAA8B;eACrC,CAAC,MAAM,CAAC,gBAAgB,EAC3B,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,cAAe,CAAC,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;gBACzF,MAAM,CAAC,gBAAgB,GAAG,IAAI,CAAC;YACjC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;YACnC,6FAA6F;YAC7F,IAAI,MAAM,CAAC,0BAA0B;gBAAE,OAAO,MAAM,CAAC,cAAc,CAAC;QACtE,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;IAEM,KAAK,CAAC,kBAAkB,CAC7B,MAA2B,EAC3B,MAA6B,EAC7B,OAAO,GAAyC,MAAM,CAAC,gBAAiB;QAExE,IAAI,MAAM,CAAC,0BAA0B;YAAE,OAAO;QAC9C,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,oBAAoB,CAC7C,OAAO,EACP,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE,EAAE,mBAAmB,EAAE,IAAI,EAAE,CAAC,CAC9E,CAAC;QACF,MAAM,CAAC,0BAA0B,GAAG,IAAI,CAAC;IAC3C,CAAC;IAEM,6BAA6B,CAAC,MAA2B;QAC9D,OAAO,MAAM,CAAC,0BAA0B;eACnC,MAAM,CAAC,8BAA8B;eACrC,MAAM,CAAC,uBAAuB;eAC9B,MAAM,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,6BAA6B,CACxC,YAAoC,EACpC,UAAkB,EAClB,SAAiB;QAEjB,MAAM,QAAQ,GAAG,IAAI,CAAC,4BAA4B,CAAC,YAAY,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;QACxF,IAAI,CAAC,QAAQ;YAAE,OAAO;QACtB,MAAM,QAAQ,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAEM,4BAA4B,CACjC,YAAoC,EACpC,UAAkB,EAClB,SAAiB;QAEjB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,CAAC,cAAc;YAAE,OAAO,SAAS,CAAC;QAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,YAAY,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;QAClE,IAAI,QAAQ,GAAG,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,QAAQ,GAAG;gBACT,YAAY;gBACZ,UAAU;gBACV,SAAS;gBACT,OAAO,EAAE,KAAK,IAAI,EAAE;oBAClB,MAAM,QAAQ,CAAC,cAAe,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;oBACtD,IAAI,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;wBACxD,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBAC5C,CAAC;gBACH,CAAC;aACF,CAAC;YACF,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,2BAA2B,CAAC,UAAkB,EAAE,SAAiB;QACtE,OAAO,CAAC,GAAG,IAAI,CAAC,sBAAsB,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CACtD,MAAM,CAAC,UAAU,KAAK,UAAU,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,KAAK,SAAS,CAAC;eACxE,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7D,KAAK,CAAC,UAAU,KAAK,UAAU,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC;eAChE,CAAC,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAC/D,QAAQ,CAAC,UAAU,KAAK,UAAU,IAAI,QAAQ,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;IAC9E,CAAC;IAEO,8BAA8B,CACpC,UAAkB,EAClB,SAAiB,EACjB,UAAyB;QAEzB,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;QACpD,IAAI,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,OAAO;QACpD,MAAM,QAAQ,GAA8B,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;QAClF,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAClD,KAAK,UAAU,CAAC,IAAI,CAClB,GAAG,EAAE;YACH,IAAI,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACzD,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC,EACD,GAAG,EAAE;YACH,IAAI,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACzD,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC,CACF,CAAC;IACJ,CAAC;IAEM,sBAAsB,CAAC,UAAmB;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,EAAE,CACrD,IAAI,CAAC,8BAA8B,CAAC,UAAU,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,qBAAqB,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;QAC9E,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,8BAA8B,CAAC,UAAmB;QAC9D,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,EAAE,CAAC;YAC7D,IAAI,UAAU,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,CAAC,UAAU,KAAK,UAAU;gBAAE,SAAS;YAChF,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAC7C,KAAK,CAAC,KAAK,EACX,KAAK,CAAC,aAAa,EACnB,KAAK,CAAC,OAAO,EACb,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAC/C,CAAC;gBACF,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC3C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,MAAM,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC;aACnE,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,UAAU,KAAK,SAAS,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU,CAAC,CAAC;QACxF,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,UAAU,CAC/C,iBAAiB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC,CACzD,CAAC;QACF,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;YACtC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5F,CAAC;QACD,KAAK,MAAM,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,sBAAsB,CAAC,EAAE,CAAC;YACtD,IAAI,UAAU,KAAK,SAAS,IAAI,MAAM,CAAC,UAAU,KAAK,UAAU;gBAAE,SAAS;YAC3E,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;gBACtC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC7C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,EAAE,CAAC;YAClE,IAAI,UAAU,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,UAAU;gBAAE,SAAS;YAC1E,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,KAAM,EAAE,CAAC;gBACtB,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAChD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;QACD,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,wBAAwB,CAAC,EAAE,CAAC;YACjE,IAAI,UAAU,KAAK,SAAS,IAAI,QAAQ,CAAC,UAAU,KAAK,UAAU;gBAAE,SAAS;YAC7E,IACE,QAAQ,CAAC,YAAY,KAAK,MAAM;mBAC7B,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7D,KAAK,CAAC,UAAU,KAAK,QAAQ,CAAC,UAAU,IAAI,KAAK,CAAC,SAAS,KAAK,QAAQ,CAAC,SAAS,CAAC;gBACrF,SAAS;YACX,IAAI,CAAC;gBACH,MAAM,QAAQ,CAAC,OAAO,EAAE,CAAC;YAC3B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACnB,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,2BAA2B;QACjC,OAAO,IAAI,GAAG,CAAC;YACb,GAAG,CAAC,GAAG,IAAI,CAAC,sBAAsB,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC;YACtE,GAAG,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC;YAChF,GAAG,CAAC,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;YACrF,GAAG,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;YACtF,GAAG,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC;SACrF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,OAAe;QAC/C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAClE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;QACvB,kBAAkB,CAAC,KAAK,CAAC,UAAU,EAAE,qBAAqB,CAAC,CAAC;QAC5D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,mCAAmC,CAAC,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;QACzF,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CACpE,KAAK,CAAC,UAAU,EAChB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CAAC,sBAAsB,CAAC,CAAC,CAChF,CAAC;QACF,IAAI,iBAAiB;YAAE,MAAM,iBAAiB,CAAC;QAC/C,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAClD,KAAK,CAAC,UAAU,EAChB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CAAC,sBAAsB,CAAC,CAAC,EAC/E,MAAM,CACP,CAAC;QACF,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YACvD,IAAI,KAAK,EAAE,CAAC;gBACV,IAAI,CAAC;oBACH,MAAM,KAAK,CAAC;gBACd,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gBAClD,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;YACtE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,YAAY,CACrB,KAAK,CAAC,UAAU,EAChB,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,EACtC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAChC,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;QACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC;IAEM,YAAY,CACjB,UAAkB,EAClB,SAAiC,EACjC,MAA6B,EAC7B,UAA+C;QAE/C,MAAM,mBAAmB,GAAG,IAAI,CAAC,oCAAoC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACtF,IAAI,mBAAmB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAC/D,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACpC,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACpD,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,IAAI,SAAS,GAAG,KAAK,CAAC;QACtB,IAAI,KAAqB,CAAC;QAC1B,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YACrF,SAAS,GAAG,IAAI,CAAC;QACnB,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACd,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,SAAS,EAAE,CAAC;gBACpE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBACxC,IAAI,IAAI,CAAC,oCAAoC,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,mBAAmB,EAAE,CAAC;oBACtF,IAAI,CAAC,oCAAoC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBAC/D,CAAC;YACH,CAAC;YACD,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,KAAK;gBAAE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1F,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAChC,UAAkB,EAClB,SAAiC,EACjC,MAA6B,EAC7B,UAA+C;QAE/C,IAAI,KAAoB,CAAC;QACzB,IAAI,CAAC;YACH,KAAK,GAAG,MAAM,SAAS,CAAC;QAC1B,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC;YACnE,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC;gBAAE,MAAM,aAAa,CAAC,YAAY,CAAC,CAAC;YAC/D,OAAO;QACT,CAAC;QACD,IAAI,KAAK,CAAC,SAAS,KAAK,QAAQ;YAAE,KAAK,CAAC,SAAS,GAAG,UAAU,CAAC;QAC/D,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,0BAA0B,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QACxG,IAAI,uBAAuB;YAAE,MAAM,uBAAuB,CAAC;QAC3D,KAAK,MAAM,MAAM,IAAI,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;YACxD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS;gBAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC;QACvF,CAAC;QACD,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QAC3F,IAAI,iBAAiB;YAAE,MAAM,iBAAiB,CAAC;QAC/C,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACjF,MAAM,uBAAuB,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC;QAC1F,MAAM,UAAU,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,UAAU;YAClD,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC;YAC1G,CAAC,CAAC,SAAS,CAAC;QACd,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,uBAAuB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAC7D,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,uBAAuB,CACvC,MAAM,EACN,MAAM,EACN,SAAS,EACT,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CACrC,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5C,IAAI,GAAG,CAAC,KAAK,KAAK,YAAY,IAAI,GAAG,CAAC,KAAK,KAAK,WAAW,EAAE,CAAC;gBAC5D,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;QACD,KAAK,MAAM,OAAO,IAAI,CAAC,GAAG,KAAK,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAC1H,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;QACzG,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;YAChC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,iCAAiC,CAAC;YACzE,GAAG,KAAK,CAAC,2BAA2B;SACrC,CAAC,CAAC,CAAC;QACJ,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,kBAAkB,CAC3B,MAAM,EACN,MAAM,EACN,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CACrC,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CACzC,KAAK,EACL,cAAc,EACd,MAAM,CAAC,OAAO,CAAC,OAAO,EACtB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,iBAAiB,CAClB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QACD,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,KAAK,CAAC,sBAAsB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QACrE,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;QACpE,MAAM,KAAK,CAAC,UAAU,CAAC;QACvB,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,gCAAgC,CACvD,KAAK,CAAC,UAAU,EAChB;YACE,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE;YACxB,GAAG,KAAK,CAAC,uBAAuB,CAAC,IAAI,EAAE;SACxC,CACF,CAAC;QACF,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC;YACjE,MAAM,CAAC,eAAe;YACtB,MAAM,CAAC,eAAe;YACtB,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SAC9D,CAAC,CAAC,CAAC;QACJ,MAAM,iBAAiB,GAAG,CAAC,GAAG,KAAK,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC,CAAC;QACjE,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,UAAU,CAC/C,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAChD,CAAC;QACF,KAAK,MAAM,MAAM,IAAI,gBAAgB,EAAE,CAAC;YACtC,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;QACvF,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC;QACjG,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;YAC9E,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,qBAAqB,CACtE,KAAK,EACL,aAAa,EACb,MAAM,CAAC,OAAO,CAAC,OAAO,EACtB,MAAM,CAAC,OAAO,CAAC,SAAS,EACxB,iBAAiB,CAClB,CAAC,CAAC;YACL,CAAC;YACD,MAAM,cAAc,GAAG,UAAU,IAAI,MAAM,CAAC,gBACK,CAAC;YAClD,IAAI,cAAc,EAAE,CAAC;gBACnB,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAC/C,KAAK,EACL,MAAM,EACN,cAAc,CAAC,OAAO,EACtB,cAAc,CAAC,KAAK,EACpB,IAAI,CACL,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACrB,CAAC;YACH,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;QACnD,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAC5D,KAAK,EACL,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAC3D,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CACpD,CAAC;QACF,KAAK,MAAM,aAAa,IAAI,KAAK,EAAE,CAAC;YAClC,IAAI,mBAAmB,CAAC,GAAG,CAAC,aAAa,CAAC;gBAAE,SAAS;YACrD,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,wBAAwB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,MAAM,GAAG,CAAC;gBAAE,SAAS;YAC3F,MAAM,QAAQ,GAAG,KAAK,CAAC,uBAAuB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;YAClE,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAC7C,KAAK,EACL,aAAa,EACb,UAAU,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,KAAK,CAAC,WAAW,EAC5E,UAAU,CACX,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;QACnD,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;QAC5B,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACvB,KAAK,CAAC,uBAAuB,CAAC,KAAK,EAAE,CAAC;QACtC,KAAK,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAC/B,KAAK,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAChC,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACzB,KAAK,CAAC,2BAA2B,CAAC,KAAK,EAAE,CAAC;QAC1C,KAAK,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QACjC,KAAK,CAAC,oBAAoB,CAAC,KAAK,EAAE,CAAC;QACnC,KAAK,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC;QACrC,KAAK,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,MAAM,iBAAiB,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,4BAA4B,CAAC,CAAC;QAC9E,MAAM,sBAAsB,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CACnF,oEAAoE,CACrE,CAAC,CAAC;QACH,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE,CAAC;YACxC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO;gBAAE,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC3F,CAAC;QACD,MAAM,OAAO,CAAC,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;QACvE,MAAM,MAAM,GAAc,EAAE,CAAC;QAC7B,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CACpE,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CACpD,yEAAyE,CAC1E,CAAC,CACH,CAAC;QACF,IAAI,iBAAiB;YAAE,MAAM,iBAAiB,CAAC;QAC/C,MAAM,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAClD,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CACpD,iEAAiE,CAClE,CAAC,EACF,MAAM,CACP,CAAC;QACF,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC;QAClD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,SAAS,CAAC,EAAE,EAAE,CAC7E,IAAI,CAAC,YAAY,CACf,UAAU,EACV,SAAS,EACT,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,CACpD,uDAAuD,CACxD,CAAC,CACH,CAAC,CAAC,CAAC;QACN,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,UAAU;gBAAE,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;QAC5E,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,2BAA2B,EAAE,EAAE,CAAC;YAC5D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBACxC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,CAAC,CAAC;YAChE,CAAC;QACH,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QAC5B,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;YAAE,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,0BAA0B,CAAC,OAAO,EAAE,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,6BAA6B,CAAC,OAAO,EAAE,CAAC;QAC3D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC,OAAO,EAAE,CAAC;QACzD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;QAClC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAC9B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,oCAAoC,CAAC,KAAK,EAAE,CAAC;QAClD,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,qBAAqB,CAAC,KAAK,EAAE,CAAC;IACzD,CAAC;CACF"}