@push.rocks/smartpuppeteer 2.0.7 → 2.2.0

package/dist_ts/smartpuppeteer.classes.livebrowsersession.js

@@ -0,0 +1,2468 @@
+import { getEnvAwareBrowserInstance } from './smartpuppeteer.classes.smartpuppeteer.js';
+import * as plugins from './smartpuppeteer.plugins.js';
+const defaultViewport = {
+    width: 800,
+    height: 600,
+    deviceScaleFactor: 1,
+};
+const maxViewportWidth = 4096;
+const maxViewportHeight = 4096;
+const maxDeviceScaleFactor = 3;
+const maxViewportPixelArea = 8294400;
+const maxSelectorLength = 4096;
+const maxTextLength = 32768;
+const maxUrlLength = 16384;
+const maxTimeoutMs = 60000;
+const maxOutstandingFrames = 3;
+const maxQueuedPublicOperations = 64;
+const maxQueuedInternalOperations = 128;
+const maxEvaluationScriptBytes = 262144;
+const maxEvaluationOutputBytes = 1048576;
+const maxEvaluationDepth = 32;
+const maxEvaluationNodes = 50000;
+const maxEvaluationStringBytes = 262144;
+const maxEvaluationArrayLength = 10000;
+const maxEvaluationObjectKeys = 10000;
+const evaluationBootstrapKey = '__smartpuppeteerEvaluate';
+const evaluationCancelKey = '__smartpuppeteerCancel';
+const evaluationCleanupKey = '__smartpuppeteerCleanup';
+const validateBoundedString = (value, name, minLength, maxLength) => {
+    if (typeof value !== 'string'
+        || value.length < minLength
+        || value.length > maxLength) {
+        throw new Error(`${name} must contain between ${minLength} and ${maxLength} characters`);
+    }
+    return value;
+};
+const validateFiniteNumber = (value, name, minimum, maximum) => {
+    if (typeof value !== 'number'
+        || !Number.isFinite(value)
+        || value < minimum
+        || value > maximum) {
+        throw new Error(`${name} must be a finite number between ${minimum} and ${maximum}`);
+    }
+    return value;
+};
+const validateInteger = (value, name, minimum, maximum) => {
+    const validatedValue = validateFiniteNumber(value, name, minimum, maximum);
+    if (!Number.isInteger(validatedValue)) {
+        throw new Error(`${name} must be an integer`);
+    }
+    return validatedValue;
+};
+const validateOptionalBoolean = (value, name) => {
+    if (value !== undefined && typeof value !== 'boolean') {
+        throw new Error(`${name} must be a boolean`);
+    }
+};
+const truncate = (value, maxLength) => {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+};
+const normalizeErrorMessage = (error) => {
+    if (error instanceof Error) {
+        return truncate(error.message, 2048);
+    }
+    return truncate(String(error), 2048);
+};
+const normalizeAbortReason = (signal) => {
+    return signal.reason ?? new Error('The browser operation was aborted');
+};
+const readUint32 = (data, offset) => {
+    return (data[offset] * 0x1000000
+        + data[offset + 1] * 0x10000
+        + data[offset + 2] * 0x100
+        + data[offset + 3]);
+};
+const readImageDimensions = (data, format, fallback) => {
+    if (format === 'png'
+        && data.length >= 24
+        && data[0] === 0x89
+        && data[1] === 0x50
+        && data[2] === 0x4e
+        && data[3] === 0x47) {
+        return {
+            width: readUint32(data, 16),
+            height: readUint32(data, 20),
+        };
+    }
+    if (format === 'jpeg' && data.length >= 4 && data[0] === 0xff && data[1] === 0xd8) {
+        let offset = 2;
+        while (offset + 8 < data.length) {
+            if (data[offset] !== 0xff) {
+                offset += 1;
+                continue;
+            }
+            const marker = data[offset + 1];
+            if (marker === 0xd8 || marker === 0xd9) {
+                offset += 2;
+                continue;
+            }
+            const segmentLength = (data[offset + 2] << 8) + data[offset + 3];
+            if (segmentLength < 2 || offset + segmentLength + 2 > data.length) {
+                break;
+            }
+            if (marker === 0xc0
+                || marker === 0xc1
+                || marker === 0xc2
+                || marker === 0xc3
+                || marker === 0xc5
+                || marker === 0xc6
+                || marker === 0xc7
+                || marker === 0xc9
+                || marker === 0xca
+                || marker === 0xcb
+                || marker === 0xcd
+                || marker === 0xce
+                || marker === 0xcf) {
+                return {
+                    height: (data[offset + 5] << 8) + data[offset + 6],
+                    width: (data[offset + 7] << 8) + data[offset + 8],
+                };
+            }
+            offset += segmentLength + 2;
+        }
+    }
+    return fallback;
+};
+const normalizeViewport = (viewport) => {
+    const normalizedViewport = {
+        width: validateInteger(viewport.width, 'viewport.width', 1, maxViewportWidth),
+        height: validateInteger(viewport.height, 'viewport.height', 1, maxViewportHeight),
+        deviceScaleFactor: validateFiniteNumber(viewport.deviceScaleFactor, 'viewport.deviceScaleFactor', 0.25, maxDeviceScaleFactor),
+    };
+    const physicalWidth = Math.ceil(normalizedViewport.width * normalizedViewport.deviceScaleFactor);
+    const physicalHeight = Math.ceil(normalizedViewport.height * normalizedViewport.deviceScaleFactor);
+    if (physicalWidth * physicalHeight > maxViewportPixelArea) {
+        throw new Error(`viewport pixel area must not exceed ${maxViewportPixelArea} physical pixels`);
+    }
+    return normalizedViewport;
+};
+const createPuppeteerViewport = (viewport) => ({
+    ...viewport,
+    isMobile: false,
+    isLandscape: false,
+    hasTouch: false,
+});
+export class LiveBrowserSession {
+    constructor(optionsArg = {}) {
+        this.eventListeners = new Set();
+        this.tabs = new Map();
+        this.tabIdsByPage = new WeakMap();
+        this.outstandingFrames = new Map();
+        this.operationQueue = [];
+        this.operationRunning = false;
+        this.admittedPublicOperations = 0;
+        this.admittedInternalOperations = 0;
+        this.status = 'stopped';
+        this.activeTabId = null;
+        this.viewport = { ...defaultViewport };
+        this.viewportRevision = 1;
+        this.tabSequence = 0;
+        this.frameSequence = 0;
+        this.evaluationSequence = 0;
+        this.normalStopRequested = false;
+        if (optionsArg.launchOptions?.protocol
+            && optionsArg.launchOptions.protocol !== 'cdp') {
+            throw new Error('LiveBrowserSession only supports Puppeteer CDP transport');
+        }
+        if (optionsArg.launchOptions?.browser
+            && optionsArg.launchOptions.browser !== 'chrome') {
+            throw new Error('LiveBrowserSession requires Chromium');
+        }
+        if (optionsArg.launchOptions && 'signal' in optionsArg.launchOptions) {
+            throw new Error('LiveBrowserSession owns launch cancellation; launchOptions.signal is unsupported');
+        }
+        validateOptionalBoolean(optionsArg.allowEvaluation, 'allowEvaluation');
+        for (const [name, value] of Object.entries(optionsArg.security ?? {})) {
+            validateOptionalBoolean(value, `security.${name}`);
+        }
+        const launchViewport = optionsArg.launchOptions?.defaultViewport;
+        const viewport = normalizeViewport(optionsArg.viewport
+            ?? (launchViewport
+                ? {
+                    width: launchViewport.width,
+                    height: launchViewport.height,
+                    deviceScaleFactor: launchViewport.deviceScaleFactor ?? 1,
+                }
+                : defaultViewport));
+        this.options = {
+            ...optionsArg,
+            launchOptions: {
+                ...optionsArg.launchOptions,
+                args: [...(optionsArg.launchOptions?.args ?? [])],
+                defaultViewport: createPuppeteerViewport(viewport),
+                ...(optionsArg.security?.denyDownloads
+                    ? { downloadBehavior: { policy: 'deny' } }
+                    : {}),
+            },
+            viewport,
+            screencast: optionsArg.screencast ? { ...optionsArg.screencast } : undefined,
+            security: optionsArg.security ? { ...optionsArg.security } : undefined,
+        };
+        this.viewport = { ...viewport };
+        this.validateScreencastOptions();
+    }
+    onEvent(listener) {
+        if (typeof listener !== 'function') {
+            throw new Error('listener must be a function');
+        }
+        this.eventListeners.add(listener);
+        return () => {
+            this.eventListeners.delete(listener);
+        };
+    }
+    getState() {
+        return {
+            status: this.status,
+            activeTabId: this.activeTabId,
+            viewportRevision: this.viewportRevision,
+            viewport: { ...this.viewport },
+            tabs: [...this.tabs.values()].map((tab) => this.createTabState(tab)),
+            ...(this.lastError ? { lastError: { ...this.lastError } } : {}),
+        };
+    }
+    async start(operationOptions = {}) {
+        return this.enqueuePublicOperation(async (signal) => {
+            if (this.status === 'running' || this.status === 'starting') {
+                return;
+            }
+            this.normalStopRequested = false;
+            this.lastError = undefined;
+            this.viewportRevision = 1;
+            const browserLifetimeController = new AbortController();
+            this.browserLifetimeController = browserLifetimeController;
+            this.status = 'starting';
+            this.emitState();
+            try {
+                if (signal.aborted) {
+                    throw signal.reason;
+                }
+                if (browserLifetimeController.signal.aborted) {
+                    throw browserLifetimeController.signal.reason;
+                }
+                const abortBrowserLaunch = () => {
+                    if (!browserLifetimeController.signal.aborted) {
+                        browserLifetimeController.abort(normalizeAbortReason(signal));
+                    }
+                };
+                signal.addEventListener('abort', abortBrowserLaunch, { once: true });
+                try {
+                    this.browser = await getEnvAwareBrowserInstance({
+                        forceNoSandbox: this.options.forceNoSandbox,
+                        requireSandbox: this.options.requireSandbox,
+                        usePipe: this.options.usePipe,
+                        launchOptions: {
+                            ...this.options.launchOptions,
+                            protocol: 'cdp',
+                            signal: browserLifetimeController.signal,
+                        },
+                    });
+                }
+                finally {
+                    signal.removeEventListener('abort', abortBrowserLaunch);
+                }
+                if (signal.aborted) {
+                    throw signal.reason;
+                }
+                this.browserContext = this.browser.defaultBrowserContext();
+                await this.configureBrowserSecurity(this.browser);
+                this.browserDisconnectedListener = () => {
+                    if (this.normalStopRequested || this.status === 'stopped' || this.status === 'stopping') {
+                        return;
+                    }
+                    const error = {
+                        code: 'browser_disconnected',
+                        message: 'The Chromium process disconnected',
+                        fatal: true,
+                    };
+                    this.emitError(error);
+                    void this.requestShutdown(error).catch((cleanupError) => {
+                        this.emitError({
+                            code: 'browser_disconnect_cleanup_failed',
+                            message: normalizeErrorMessage(cleanupError),
+                            fatal: true,
+                        });
+                    });
+                };
+                this.browser.on('disconnected', this.browserDisconnectedListener);
+                const initialPages = await this.browserContext.pages();
+                if (initialPages.length === 0) {
+                    initialPages.push(await this.browserContext.newPage());
+                }
+                const initialPage = initialPages[0];
+                if (initialPage.url() !== 'about:blank') {
+                    await initialPage.goto('about:blank');
+                }
+                for (const page of initialPages) {
+                    await this.registerPage(page);
+                }
+                const firstTab = this.tabs.values().next().value;
+                if (!firstTab) {
+                    throw new Error('Chromium did not provide an initial page');
+                }
+                this.activeTabId = firstTab.id;
+                await firstTab.page.bringToFront();
+                this.status = 'running';
+                this.emitState();
+                await this.startScreencast(firstTab);
+                if (signal.aborted) {
+                    throw normalizeAbortReason(signal);
+                }
+            }
+            catch (error) {
+                if (signal.aborted || this.normalStopRequested) {
+                    await this.stopInternal();
+                    throw error;
+                }
+                const startError = {
+                    code: 'start_failed',
+                    message: normalizeErrorMessage(error),
+                    fatal: true,
+                };
+                this.emitError(startError);
+                await this.stopInternal(startError);
+                throw error;
+            }
+        }, operationOptions);
+    }
+    async stop() {
+        this.normalStopRequested = true;
+        return this.requestShutdown();
+    }
+    async acknowledgeFrame(acknowledgement) {
+        if (!acknowledgement || typeof acknowledgement !== 'object') {
+            return { accepted: false };
+        }
+        const { tabId, sequence, generation, viewportRevision } = acknowledgement;
+        if (typeof tabId !== 'string'
+            || tabId.length < 1
+            || tabId.length > 128
+            || !Number.isInteger(sequence)
+            || sequence < 1
+            || !Number.isInteger(generation)
+            || generation < 0
+            || !Number.isInteger(viewportRevision)
+            || viewportRevision < 1) {
+            return { accepted: false };
+        }
+        const outstandingFrame = this.outstandingFrames.get(sequence);
+        if (!outstandingFrame) {
+            return { accepted: false };
+        }
+        if (outstandingFrame.tabId !== tabId
+            || outstandingFrame.generation !== generation
+            || outstandingFrame.viewportRevision !== viewportRevision) {
+            return { accepted: false };
+        }
+        const tab = this.tabs.get(outstandingFrame.tabId);
+        if (!tab
+            || this.activeTabId !== tab.id
+            || tab.generation !== outstandingFrame.generation
+            || this.viewportRevision !== outstandingFrame.viewportRevision
+            || tab.cdpSession !== outstandingFrame.cdpSession
+            || outstandingFrame.cdpSession.detached) {
+            this.outstandingFrames.delete(sequence);
+            await this.acknowledgeCdpFrame(outstandingFrame);
+            return { accepted: false };
+        }
+        this.outstandingFrames.delete(sequence);
+        return {
+            accepted: await this.acknowledgeCdpFrame(outstandingFrame),
+        };
+    }
+    async createTab(optionsArg = {}, operationOptions = {}) {
+        const url = optionsArg.url === undefined ? undefined : this.validateUrl(optionsArg.url);
+        const activate = optionsArg.activate ?? true;
+        validateOptionalBoolean(optionsArg.activate, 'activate');
+        const timeout = this.validateTimeout(optionsArg.timeoutMs, 30000);
+        const waitUntil = this.validateWaitUntil(optionsArg.waitUntil);
+        return this.enqueuePublicOperation(async (signal) => {
+            const context = this.requireBrowserContext();
+            const previousActiveTabId = this.activeTabId;
+            let page;
+            let tab;
+            try {
+                page = await context.newPage();
+                if (signal.aborted) {
+                    throw signal.reason;
+                }
+                tab = await this.registerPage(page);
+                if (url !== undefined) {
+                    await this.navigateTab(tab, async () => {
+                        await tab.page.goto(url, { timeout, waitUntil, signal });
+                    }, signal);
+                }
+                if (activate) {
+                    await this.activateTabInternal(tab.id);
+                }
+                else {
+                    const previousActiveTab = previousActiveTabId
+                        ? this.tabs.get(previousActiveTabId)
+                        : undefined;
+                    if (previousActiveTab && !previousActiveTab.page.isClosed()) {
+                        await previousActiveTab.page.bringToFront();
+                    }
+                    this.emitState();
+                }
+                return this.createTabState(tab);
+            }
+            catch (error) {
+                if (page) {
+                    const rollbackError = await this.rollbackCreatedPage(page, tab, previousActiveTabId);
+                    if (rollbackError) {
+                        throw new AggregateError([error, rollbackError], 'Tab creation failed and its page could not be closed cleanly');
+                    }
+                }
+                throw error;
+            }
+        }, operationOptions);
+    }
+    async activateTab(tabId, operationOptions = {}) {
+        return this.enqueuePublicOperation(async () => {
+            await this.activateTabInternal(tabId);
+        }, operationOptions);
+    }
+    async closeTab(tabId, operationOptions = {}) {
+        return this.enqueuePublicOperation(async () => {
+            const tab = this.requireTab(tabId);
+            const wasActive = this.activeTabId === tab.id;
+            if (wasActive) {
+                await this.stopScreencast(tab);
+            }
+            else {
+                await this.retireOutstandingFrames((frame) => frame.tabId === tab.id);
+            }
+            try {
+                if (!tab.page.isClosed()) {
+                    await tab.page.close();
+                }
+            }
+            catch (error) {
+                if (wasActive
+                    && this.status === 'running'
+                    && this.activeTabId === tab.id
+                    && tab.status === 'open') {
+                    await this.startScreencast(tab);
+                }
+                this.emitState();
+                throw error;
+            }
+            tab.closing = true;
+            this.removePageListeners(tab);
+            this.tabs.delete(tab.id);
+            this.tabIdsByPage.delete(tab.page);
+            if (wasActive) {
+                this.activeTabId = null;
+                await this.activateReplacementTab();
+            }
+            else {
+                this.emitState();
+            }
+        }, operationOptions);
+    }
+    async navigate(optionsArg, operationOptions = {}) {
+        const url = this.validateUrl(optionsArg.url);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveNavigationTab(optionsArg.tabId);
+            await this.navigateTab(tab, async () => {
+                await tab.page.goto(url, this.createPuppeteerNavigationOptions(optionsArg, signal));
+            }, signal);
+        }, operationOptions);
+    }
+    async back(optionsArg = {}, operationOptions = {}) {
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveNavigationTab(optionsArg.tabId);
+            await this.navigateTab(tab, async () => {
+                await tab.page.goBack(this.createPuppeteerNavigationOptions(optionsArg, signal));
+            }, signal);
+        }, operationOptions);
+    }
+    async forward(optionsArg = {}, operationOptions = {}) {
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveNavigationTab(optionsArg.tabId);
+            await this.navigateTab(tab, async () => {
+                await tab.page.goForward(this.createPuppeteerNavigationOptions(optionsArg, signal));
+            }, signal);
+        }, operationOptions);
+    }
+    async reload(optionsArg = {}, operationOptions = {}) {
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveNavigationTab(optionsArg.tabId);
+            await this.navigateTab(tab, async () => {
+                await tab.page.reload(this.createPuppeteerNavigationOptions(optionsArg, signal));
+            }, signal);
+        }, operationOptions);
+    }
+    async setViewport(viewportArg, operationOptions = {}) {
+        const viewport = normalizeViewport(viewportArg);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.requireActiveTab();
+            await this.stopScreencast(tab);
+            try {
+                if (signal.aborted) {
+                    throw signal.reason;
+                }
+                await tab.page.setViewport(createPuppeteerViewport(viewport));
+                this.viewport = { ...viewport };
+                this.viewportRevision += 1;
+                tab.appliedViewportRevision = this.viewportRevision;
+                this.emitState();
+            }
+            finally {
+                if (this.status === 'running' && this.activeTabId === tab.id && tab.status === 'open') {
+                    await this.startScreencast(tab);
+                }
+            }
+        }, operationOptions);
+    }
+    async dispatchMouse(input) {
+        const { tab, cdpSession } = this.requireRawInputTarget(input);
+        this.validateCoordinates(input.x, input.y);
+        const type = input.type === 'move'
+            ? 'mouseMoved'
+            : input.type === 'down'
+                ? 'mousePressed'
+                : input.type === 'up'
+                    ? 'mouseReleased'
+                    : undefined;
+        if (!type) {
+            throw new Error('mouse input type must be move, down, or up');
+        }
+        const allowedButtons = ['none', 'left', 'middle', 'right', 'back', 'forward'];
+        const button = input.button ?? (type === 'mouseMoved' ? 'none' : 'left');
+        if (!allowedButtons.includes(button)) {
+            throw new Error('mouse button is invalid');
+        }
+        const buttons = input.buttons === undefined
+            ? undefined
+            : validateInteger(input.buttons, 'buttons', 0, 31);
+        const clickCount = input.clickCount === undefined
+            ? undefined
+            : validateInteger(input.clickCount, 'clickCount', 0, 3);
+        try {
+            await cdpSession.send('Input.dispatchMouseEvent', {
+                type,
+                x: input.x,
+                y: input.y,
+                button,
+                buttons,
+                clickCount,
+                modifiers: this.createModifierMask(input.modifiers),
+                pointerType: 'mouse',
+            });
+        }
+        catch (error) {
+            this.handlePossibleCdpDisconnection(tab, cdpSession, error);
+            throw error;
+        }
+    }
+    async dispatchWheel(input) {
+        const { tab, cdpSession } = this.requireRawInputTarget(input);
+        this.validateCoordinates(input.x, input.y);
+        validateFiniteNumber(input.deltaX, 'deltaX', -1000000, 1000000);
+        validateFiniteNumber(input.deltaY, 'deltaY', -1000000, 1000000);
+        try {
+            await cdpSession.send('Input.dispatchMouseEvent', {
+                type: 'mouseWheel',
+                x: input.x,
+                y: input.y,
+                deltaX: input.deltaX,
+                deltaY: input.deltaY,
+                modifiers: this.createModifierMask(input.modifiers),
+                pointerType: 'mouse',
+            });
+        }
+        catch (error) {
+            this.handlePossibleCdpDisconnection(tab, cdpSession, error);
+            throw error;
+        }
+    }
+    async dispatchKey(input) {
+        const { tab, cdpSession } = this.requireRawInputTarget(input);
+        const type = input.type === 'down'
+            ? 'keyDown'
+            : input.type === 'up'
+                ? 'keyUp'
+                : undefined;
+        if (!type) {
+            throw new Error('key input type must be down or up');
+        }
+        const key = validateBoundedString(input.key, 'key', 1, 64);
+        const code = input.code === undefined
+            ? undefined
+            : validateBoundedString(input.code, 'code', 1, 64);
+        const text = input.text === undefined
+            ? undefined
+            : validateBoundedString(input.text, 'text', 0, 1024);
+        const unmodifiedText = input.unmodifiedText === undefined
+            ? undefined
+            : validateBoundedString(input.unmodifiedText, 'unmodifiedText', 0, 1024);
+        const windowsVirtualKeyCode = input.windowsVirtualKeyCode === undefined
+            ? undefined
+            : validateInteger(input.windowsVirtualKeyCode, 'windowsVirtualKeyCode', 0, 65535);
+        const nativeVirtualKeyCode = input.nativeVirtualKeyCode === undefined
+            ? undefined
+            : validateInteger(input.nativeVirtualKeyCode, 'nativeVirtualKeyCode', 0, 65535);
+        const location = input.location === undefined
+            ? undefined
+            : validateInteger(input.location, 'location', 0, 3);
+        validateOptionalBoolean(input.autoRepeat, 'autoRepeat');
+        validateOptionalBoolean(input.isKeypad, 'isKeypad');
+        try {
+            await cdpSession.send('Input.dispatchKeyEvent', {
+                type,
+                key,
+                code,
+                text,
+                unmodifiedText,
+                windowsVirtualKeyCode,
+                nativeVirtualKeyCode,
+                autoRepeat: input.autoRepeat,
+                isKeypad: input.isKeypad,
+                location,
+                modifiers: this.createModifierMask(input.modifiers),
+            });
+        }
+        catch (error) {
+            this.handlePossibleCdpDisconnection(tab, cdpSession, error);
+            throw error;
+        }
+    }
+    async insertText(input) {
+        const { tab, cdpSession } = this.requireRawInputTarget(input);
+        const text = validateBoundedString(input.text, 'text', 0, maxTextLength);
+        try {
+            await cdpSession.send('Input.insertText', { text });
+        }
+        catch (error) {
+            this.handlePossibleCdpDisconnection(tab, cdpSession, error);
+            throw error;
+        }
+    }
+    async captureSnapshot(optionsArg = {}, operationOptions = {}) {
+        const format = optionsArg.format ?? 'jpeg';
+        if (format !== 'jpeg' && format !== 'png') {
+            throw new Error('snapshot format must be jpeg or png');
+        }
+        const quality = optionsArg.quality === undefined
+            ? undefined
+            : validateInteger(optionsArg.quality, 'quality', 0, 100);
+        if (format === 'png' && quality !== undefined) {
+            throw new Error('quality is only supported for jpeg snapshots');
+        }
+        if ('fullPage' in optionsArg) {
+            throw new Error('fullPage snapshots are not supported by LiveBrowserSession');
+        }
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveActionTab(optionsArg.tabId);
+            await this.ensureTabViewport(tab);
+            const capturedTab = this.resolveActionTab(tab.id);
+            if (signal.aborted) {
+                throw signal.reason;
+            }
+            const viewport = { ...this.viewport };
+            const viewportRevision = this.viewportRevision;
+            const data = await capturedTab.page.screenshot({
+                type: format,
+                ...(format === 'jpeg' && quality !== undefined ? { quality } : {}),
+            });
+            if (signal.aborted) {
+                throw signal.reason;
+            }
+            const dimensions = readImageDimensions(data, format, {
+                width: Math.round(viewport.width * viewport.deviceScaleFactor),
+                height: Math.round(viewport.height * viewport.deviceScaleFactor),
+            });
+            return {
+                tabId: capturedTab.id,
+                viewportRevision,
+                viewport,
+                format,
+                mimeType: format === 'jpeg' ? 'image/jpeg' : 'image/png',
+                ...dimensions,
+                data,
+            };
+        }, operationOptions);
+    }
+    async observe(optionsArg = {}, operationOptions = {}) {
+        const maxCharacters = optionsArg.maxCharacters === undefined
+            ? 12000
+            : validateInteger(optionsArg.maxCharacters, 'maxCharacters', 256, 50000);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveActionTab(optionsArg.tabId);
+            await this.ensureTabViewport(tab);
+            const observedTab = this.resolveActionTab(tab.id);
+            if (signal.aborted) {
+                throw signal.reason;
+            }
+            await this.refreshTab(observedTab);
+            const accessibilitySnapshot = await observedTab.page.accessibility.snapshot({
+                interestingOnly: true,
+            });
+            if (signal.aborted) {
+                throw signal.reason;
+            }
+            const header = [
+                `Tab: ${observedTab.id}`,
+                `Status: ${observedTab.status}`,
+                `Title: ${observedTab.title}`,
+                `URL: ${observedTab.url}`,
+                'Accessibility:',
+            ];
+            const lines = [...header];
+            let reachedTraversalLimit = false;
+            const appendNode = (node, depth) => {
+                if (lines.join('\n').length >= maxCharacters) {
+                    reachedTraversalLimit = true;
+                    return;
+                }
+                const details = [node.role];
+                if (node.name) {
+                    details.push(`"${truncate(node.name, 512)}"`);
+                }
+                if (node.value !== undefined) {
+                    details.push(`value="${truncate(String(node.value), 512)}"`);
+                }
+                for (const property of [
+                    'disabled',
+                    'expanded',
+                    'focused',
+                    'readonly',
+                    'required',
+                    'selected',
+                    'checked',
+                    'pressed',
+                ]) {
+                    const value = node[property];
+                    if (value !== undefined && value !== false) {
+                        details.push(`${property}=${String(value)}`);
+                    }
+                }
+                lines.push(`${'  '.repeat(Math.min(depth, 20))}- ${details.join(' ')}`);
+                for (const child of node.children ?? []) {
+                    appendNode(child, depth + 1);
+                    if (reachedTraversalLimit) {
+                        break;
+                    }
+                }
+            };
+            if (accessibilitySnapshot) {
+                appendNode(accessibilitySnapshot, 0);
+            }
+            else {
+                lines.push('- No accessibility nodes');
+            }
+            const unboundedText = lines.join('\n');
+            const truncatedText = unboundedText.length > maxCharacters
+                ? unboundedText.slice(0, maxCharacters)
+                : unboundedText;
+            const state = this.getState();
+            return {
+                tabId: observedTab.id,
+                url: observedTab.url,
+                title: observedTab.title,
+                tab: this.createTabState(observedTab),
+                state,
+                text: truncatedText,
+                truncated: reachedTraversalLimit || unboundedText.length > maxCharacters,
+            };
+        }, operationOptions);
+    }
+    async evaluate(expressionArg, optionsArg = {}, operationOptions = {}) {
+        if (!this.options.allowEvaluation) {
+            throw new Error('LiveBrowserSession evaluation is disabled');
+        }
+        const expression = validateBoundedString(expressionArg, 'expression', 1, maxEvaluationScriptBytes);
+        const expressionBytes = new TextEncoder().encode(expression).byteLength;
+        if (expressionBytes > maxEvaluationScriptBytes) {
+            throw new Error(`expression must not exceed ${maxEvaluationScriptBytes} UTF-8 bytes`);
+        }
+        const evaluationOptions = this.normalizeEvaluationOptions(optionsArg);
+        const evaluationId = ++this.evaluationSequence;
+        const cancellationKey = `__smartpuppeteerCancel${evaluationId}`;
+        const evaluationExpression = this.createEvaluationExpression(expression, evaluationOptions, cancellationKey);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.resolveActionTab(optionsArg.tabId);
+            const cdpSession = await tab.page.createCDPSession();
+            let executionContextId;
+            let cancellationPromise;
+            let terminationPromise;
+            let timeoutHandle;
+            let evaluationTimedOut = false;
+            const terminateEvaluation = () => {
+                terminationPromise ??= cdpSession.send('Runtime.terminateExecution').then(() => undefined);
+            };
+            const cancelEvaluation = () => {
+                if (executionContextId === undefined) {
+                    return;
+                }
+                cancellationPromise ??= cdpSession.send('Runtime.evaluate', {
+                    expression: `globalThis[${JSON.stringify(evaluationCancelKey)}]?.(${JSON.stringify(cancellationKey)})`,
+                    contextId: executionContextId,
+                    returnByValue: true,
+                    awaitPromise: false,
+                    includeCommandLineAPI: false,
+                    userGesture: false,
+                    disableBreaks: true,
+                }).then(() => undefined);
+            };
+            signal.addEventListener('abort', cancelEvaluation, { once: true });
+            let evaluationError;
+            let evaluationFailed = false;
+            try {
+                if (signal.aborted) {
+                    throw normalizeAbortReason(signal);
+                }
+                executionContextId = tab.evaluationExecutionContextId;
+                if (executionContextId === undefined) {
+                    const frameTreeResponse = await cdpSession.send('Page.getFrameTree');
+                    if (signal.aborted) {
+                        throw normalizeAbortReason(signal);
+                    }
+                    const isolatedWorld = await cdpSession.send('Page.createIsolatedWorld', {
+                        frameId: frameTreeResponse.frameTree.frame.id,
+                        worldName: 'smartpuppeteer-evaluation',
+                        grantUniveralAccess: false,
+                    });
+                    executionContextId = isolatedWorld.executionContextId;
+                    tab.evaluationExecutionContextId = executionContextId;
+                }
+                if (signal.aborted) {
+                    throw normalizeAbortReason(signal);
+                }
+                const bootstrapResponse = await cdpSession.send('Runtime.evaluate', {
+                    expression: this.createEvaluationBootstrapExpression(),
+                    contextId: executionContextId,
+                    returnByValue: true,
+                    awaitPromise: true,
+                    includeCommandLineAPI: false,
+                    userGesture: false,
+                    disableBreaks: true,
+                });
+                if (bootstrapResponse.exceptionDetails) {
+                    throw new Error(this.readCdpExceptionMessage(bootstrapResponse.exceptionDetails));
+                }
+                if (signal.aborted) {
+                    throw normalizeAbortReason(signal);
+                }
+                timeoutHandle = setTimeout(() => {
+                    evaluationTimedOut = true;
+                    terminateEvaluation();
+                }, evaluationOptions.timeoutMs + 250);
+                const evaluationResponse = await cdpSession.send('Runtime.evaluate', {
+                    expression: evaluationExpression,
+                    contextId: executionContextId,
+                    returnByValue: true,
+                    awaitPromise: true,
+                    timeout: evaluationOptions.timeoutMs + 250,
+                    includeCommandLineAPI: false,
+                    userGesture: false,
+                    disableBreaks: true,
+                    allowUnsafeEvalBlockedByCSP: true,
+                });
+                if (evaluationTimedOut) {
+                    throw new Error(`Evaluation timed out after ${evaluationOptions.timeoutMs}ms`);
+                }
+                if (signal.aborted) {
+                    throw normalizeAbortReason(signal);
+                }
+                if (evaluationResponse.exceptionDetails) {
+                    throw new Error(this.readCdpExceptionMessage(evaluationResponse.exceptionDetails));
+                }
+                const envelope = evaluationResponse.result.value;
+                if (!envelope || typeof envelope !== 'object' || typeof envelope.ok !== 'boolean') {
+                    throw new Error('Evaluation returned an invalid result envelope');
+                }
+                if (!envelope.ok) {
+                    throw new Error(typeof envelope.error === 'string'
+                        ? truncate(envelope.error, 2048)
+                        : 'Evaluation failed');
+                }
+                if (typeof envelope.json !== 'string') {
+                    throw new Error('Evaluation returned an invalid JSON result');
+                }
+                if (new TextEncoder().encode(envelope.json).byteLength > evaluationOptions.maxOutputBytes) {
+                    throw new Error('Evaluation result exceeded maxOutputBytes during transfer');
+                }
+                return JSON.parse(envelope.json);
+            }
+            catch (error) {
+                evaluationError = error;
+                evaluationFailed = true;
+                throw error;
+            }
+            finally {
+                signal.removeEventListener('abort', cancelEvaluation);
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                const cleanupErrors = [];
+                if (cancellationPromise) {
+                    try {
+                        await cancellationPromise;
+                    }
+                    catch (error) {
+                        cleanupErrors.push(error);
+                    }
+                }
+                if (terminationPromise) {
+                    try {
+                        await terminationPromise;
+                    }
+                    catch (error) {
+                        cleanupErrors.push(error);
+                    }
+                }
+                if (executionContextId !== undefined && !cdpSession.detached) {
+                    try {
+                        await cdpSession.send('Runtime.evaluate', {
+                            expression: `globalThis[${JSON.stringify(evaluationCleanupKey)}]?.(${JSON.stringify(cancellationKey)})`,
+                            contextId: executionContextId,
+                            returnByValue: true,
+                            awaitPromise: false,
+                            includeCommandLineAPI: false,
+                            userGesture: false,
+                            disableBreaks: true,
+                        });
+                    }
+                    catch {
+                        // Navigation destroys the old execution context and its cancellation registry.
+                    }
+                }
+                if (!cdpSession.detached) {
+                    try {
+                        await cdpSession.detach();
+                    }
+                    catch (error) {
+                        cleanupErrors.push(error);
+                    }
+                }
+                if (cleanupErrors.length > 0) {
+                    throw new AggregateError(evaluationFailed ? [evaluationError, ...cleanupErrors] : cleanupErrors, 'Evaluation cleanup was incomplete');
+                }
+            }
+        }, operationOptions);
+    }
+    async click(optionsArg, operationOptions = {}) {
+        const selector = validateBoundedString(optionsArg.selector, 'selector', 1, maxSelectorLength);
+        const timeout = this.validateTimeout(optionsArg.timeoutMs);
+        const allowedButtons = ['left', 'middle', 'right'];
+        if (optionsArg.button !== undefined && !allowedButtons.includes(optionsArg.button)) {
+            throw new Error('click button is invalid');
+        }
+        const clickCount = optionsArg.clickCount === undefined
+            ? undefined
+            : validateInteger(optionsArg.clickCount, 'clickCount', 1, 3);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.requireSemanticActionTarget(optionsArg);
+            await this.ensureTabViewport(tab);
+            const actionTab = this.requireSemanticActionTarget(optionsArg);
+            await actionTab.page.locator(selector).setTimeout(timeout).click({
+                button: optionsArg.button,
+                count: clickCount,
+                signal,
+            });
+            await this.refreshTab(actionTab);
+            this.emitState();
+        }, operationOptions);
+    }
+    async fill(optionsArg, operationOptions = {}) {
+        const selector = validateBoundedString(optionsArg.selector, 'selector', 1, maxSelectorLength);
+        const text = validateBoundedString(optionsArg.text, 'text', 0, maxTextLength);
+        const timeout = this.validateTimeout(optionsArg.timeoutMs);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.requireSemanticActionTarget(optionsArg);
+            await this.ensureTabViewport(tab);
+            const actionTab = this.requireSemanticActionTarget(optionsArg);
+            await actionTab.page.locator(selector).setTimeout(timeout).fill(text, { signal });
+            await this.refreshTab(actionTab);
+            this.emitState();
+        }, operationOptions);
+    }
+    async press(optionsArg, operationOptions = {}) {
+        const selector = validateBoundedString(optionsArg.selector, 'selector', 1, maxSelectorLength);
+        const key = validateBoundedString(optionsArg.key, 'key', 1, 64);
+        const timeout = this.validateTimeout(optionsArg.timeoutMs);
+        return this.enqueuePublicOperation(async (signal) => {
+            const tab = this.requireSemanticActionTarget(optionsArg);
+            await this.ensureTabViewport(tab);
+            const actionTab = this.requireSemanticActionTarget(optionsArg);
+            const element = await actionTab.page.waitForSelector(selector, {
+                visible: true,
+                timeout,
+                signal,
+            });
+            if (!element) {
+                throw new Error(`No visible element matched selector: ${selector}`);
+            }
+            try {
+                await element.press(key);
+            }
+            finally {
+                await element.dispose();
+            }
+            await this.refreshTab(actionTab);
+            this.emitState();
+        }, operationOptions);
+    }
+    enqueuePublicOperation(operation, operationOptions = {}) {
+        const callerSignal = operationOptions.signal;
+        if (callerSignal !== undefined
+            && (typeof callerSignal !== 'object'
+                || typeof callerSignal.addEventListener !== 'function'
+                || typeof callerSignal.removeEventListener !== 'function')) {
+            return Promise.reject(new Error('operationOptions.signal must be an AbortSignal'));
+        }
+        if (callerSignal?.aborted) {
+            return Promise.reject(normalizeAbortReason(callerSignal));
+        }
+        if (this.status === 'stopping'
+            || this.normalStopRequested
+            || (this.status === 'stopped' && this.operationRunning)) {
+            return Promise.reject(new Error('LiveBrowserSession is stopping'));
+        }
+        if (this.admittedPublicOperations >= maxQueuedPublicOperations) {
+            return Promise.reject(new Error('LiveBrowserSession operation queue is full'));
+        }
+        this.admittedPublicOperations += 1;
+        return this.enqueueQueuedOperation('public', operation, false, callerSignal);
+    }
+    enqueueInternalOperation(operation, priority = false) {
+        if (this.status === 'stopped' || this.status === 'stopping') {
+            return Promise.reject(new Error('LiveBrowserSession is stopping'));
+        }
+        this.admittedInternalOperations += 1;
+        return this.enqueueQueuedOperation('internal', operation, priority);
+    }
+    enqueueQueuedOperation(kind, operation, priority = false, callerSignal) {
+        return new Promise((resolve, reject) => {
+            const queuedOperation = {
+                kind,
+                state: 'queued',
+                controller: new AbortController(),
+                run: operation,
+                resolve: (value) => resolve(value),
+                reject,
+                capacityReleased: false,
+            };
+            if (callerSignal) {
+                const onCallerAbort = () => {
+                    const abortReason = normalizeAbortReason(callerSignal);
+                    if (queuedOperation.state === 'queued') {
+                        const operationIndex = this.operationQueue.indexOf(queuedOperation);
+                        if (operationIndex >= 0) {
+                            this.operationQueue.splice(operationIndex, 1);
+                        }
+                        queuedOperation.controller.abort(abortReason);
+                        queuedOperation.reject(abortReason);
+                        this.finalizeQueuedOperation(queuedOperation);
+                        this.drainOperationQueue();
+                    }
+                    else if (queuedOperation.state === 'active') {
+                        queuedOperation.controller.abort(abortReason);
+                    }
+                };
+                callerSignal.addEventListener('abort', onCallerAbort, { once: true });
+                queuedOperation.removeCallerAbortListener = () => {
+                    callerSignal.removeEventListener('abort', onCallerAbort);
+                };
+                if (callerSignal.aborted) {
+                    onCallerAbort();
+                }
+            }
+            if (queuedOperation.state !== 'queued') {
+                return;
+            }
+            if (priority) {
+                this.operationQueue.unshift(queuedOperation);
+            }
+            else {
+                this.operationQueue.push(queuedOperation);
+            }
+            this.drainOperationQueue();
+        });
+    }
+    drainOperationQueue() {
+        if (this.operationRunning) {
+            return;
+        }
+        const queuedOperation = this.operationQueue.shift();
+        if (!queuedOperation) {
+            return;
+        }
+        this.operationRunning = true;
+        this.activeOperation = queuedOperation;
+        queuedOperation.state = 'active';
+        void this.executeQueuedOperation(queuedOperation).catch((error) => {
+            this.operationRunning = false;
+            this.activeOperation = undefined;
+            this.emitError({
+                code: 'operation_scheduler_failed',
+                message: normalizeErrorMessage(error),
+                fatal: true,
+            });
+            this.drainOperationQueue();
+        });
+    }
+    async executeQueuedOperation(queuedOperation) {
+        try {
+            if (queuedOperation.controller.signal.aborted) {
+                throw queuedOperation.controller.signal.reason;
+            }
+            const value = await queuedOperation.run(queuedOperation.controller.signal);
+            if (queuedOperation.controller.signal.aborted) {
+                throw queuedOperation.controller.signal.reason;
+            }
+            queuedOperation.resolve(value);
+        }
+        catch (error) {
+            queuedOperation.reject(error);
+        }
+        finally {
+            this.finalizeQueuedOperation(queuedOperation);
+            if (this.activeOperation === queuedOperation) {
+                this.activeOperation = undefined;
+            }
+            this.operationRunning = false;
+            if (this.status === 'stopped'
+                && !this.operationQueue.some((operation) => operation.kind === 'shutdown')) {
+                this.normalStopRequested = false;
+            }
+            this.drainOperationQueue();
+        }
+    }
+    finalizeQueuedOperation(queuedOperation) {
+        if (queuedOperation.state === 'settled') {
+            return;
+        }
+        queuedOperation.state = 'settled';
+        queuedOperation.removeCallerAbortListener?.();
+        queuedOperation.removeCallerAbortListener = undefined;
+        if (queuedOperation.capacityReleased) {
+            return;
+        }
+        queuedOperation.capacityReleased = true;
+        if (queuedOperation.kind === 'public') {
+            this.admittedPublicOperations -= 1;
+        }
+        else if (queuedOperation.kind === 'internal') {
+            this.admittedInternalOperations -= 1;
+        }
+    }
+    cancelQueuedOperations(error) {
+        for (const queuedOperation of this.operationQueue.splice(0)) {
+            queuedOperation.controller.abort(error);
+            queuedOperation.reject(error);
+            this.finalizeQueuedOperation(queuedOperation);
+        }
+    }
+    beginShutdown(abortActiveOperation) {
+        if (this.status !== 'stopped' && this.status !== 'stopping') {
+            this.status = 'stopping';
+            this.emitState();
+        }
+        const shutdownError = new Error('LiveBrowserSession is stopping');
+        if (abortActiveOperation
+            && this.activeOperation
+            && this.activeOperation.kind !== 'shutdown') {
+            this.activeOperation.controller.abort(shutdownError);
+        }
+        if (this.browserLifetimeController && !this.browserLifetimeController.signal.aborted) {
+            this.browserLifetimeController.abort(shutdownError);
+        }
+        this.cancelQueuedOperations(shutdownError);
+    }
+    requestShutdown(error) {
+        if (this.status === 'stopped') {
+            return Promise.resolve();
+        }
+        if (this.shutdownPromise) {
+            return this.shutdownPromise;
+        }
+        this.beginShutdown(true);
+        const shutdownPromise = this.enqueueQueuedOperation('shutdown', async () => this.stopInternal(error), true);
+        this.shutdownPromise = shutdownPromise;
+        void shutdownPromise.then(() => {
+            if (this.shutdownPromise === shutdownPromise) {
+                this.shutdownPromise = undefined;
+            }
+        }, () => {
+            if (this.shutdownPromise === shutdownPromise) {
+                this.shutdownPromise = undefined;
+            }
+        });
+        return shutdownPromise;
+    }
+    scheduleOperation(operation, errorCode, tabId, priority = false) {
+        if (this.admittedInternalOperations >= maxQueuedInternalOperations) {
+            const queueError = new Error('LiveBrowserSession internal operation queue is full');
+            const liveBrowserError = {
+                code: 'internal_operation_queue_full',
+                message: queueError.message,
+                fatal: priority,
+                ...(tabId ? { tabId } : {}),
+            };
+            this.emitError(liveBrowserError);
+            if (priority) {
+                void this.requestShutdown(liveBrowserError).catch((error) => {
+                    this.emitError({
+                        code: 'queue_overflow_shutdown_failed',
+                        message: normalizeErrorMessage(error),
+                        fatal: true,
+                    });
+                });
+            }
+            return false;
+        }
+        void this.enqueueInternalOperation(operation, priority).catch((error) => {
+            if (this.status === 'stopped'
+                || this.status === 'stopping'
+                || this.normalStopRequested) {
+                return;
+            }
+            this.emitError({
+                code: errorCode,
+                message: normalizeErrorMessage(error),
+                fatal: false,
+                ...(tabId ? { tabId } : {}),
+            });
+        });
+        return true;
+    }
+    emitEvent(event) {
+        for (const listener of [...this.eventListeners]) {
+            try {
+                listener(event);
+            }
+            catch {
+                // A consumer listener must not interrupt browser lifecycle cleanup.
+            }
+        }
+    }
+    emitState() {
+        this.emitEvent({
+            type: 'state',
+            state: this.getState(),
+        });
+    }
+    emitError(error) {
+        if (error.fatal) {
+            this.lastError = { ...error };
+        }
+        this.emitEvent({
+            type: 'error',
+            error: { ...error },
+        });
+        this.emitState();
+    }
+    createTabState(tab) {
+        return {
+            id: tab.id,
+            url: tab.url,
+            title: tab.title,
+            active: this.activeTabId === tab.id,
+            status: tab.status,
+            generation: tab.generation,
+            appliedViewportRevision: tab.appliedViewportRevision,
+            streaming: tab.streaming,
+        };
+    }
+    async stopInternal(error) {
+        if (this.status === 'stopped') {
+            return;
+        }
+        this.status = 'stopping';
+        if (error) {
+            this.lastError = { ...error };
+        }
+        this.emitState();
+        if (this.browserLifetimeController && !this.browserLifetimeController.signal.aborted) {
+            this.browserLifetimeController.abort(new Error('LiveBrowserSession is stopping'));
+        }
+        const browser = this.browser;
+        if (browser && this.browserDisconnectedListener) {
+            browser.off('disconnected', this.browserDisconnectedListener);
+        }
+        this.browserDisconnectedListener = undefined;
+        const shutdownErrors = [];
+        for (const tab of [...this.tabs.values()]) {
+            tab.closing = true;
+            const securityCdpSession = tab.securityCdpSession;
+            tab.securityCdpSession = undefined;
+            if (securityCdpSession && !securityCdpSession.detached) {
+                try {
+                    await securityCdpSession.detach();
+                }
+                catch {
+                    // Browser lifetime cancellation may close the target before explicit detach settles.
+                }
+            }
+            try {
+                await this.stopScreencast(tab);
+            }
+            catch (cleanupError) {
+                shutdownErrors.push(cleanupError);
+            }
+            try {
+                this.removePageListeners(tab);
+            }
+            catch (cleanupError) {
+                shutdownErrors.push(cleanupError);
+            }
+        }
+        try {
+            await this.retireOutstandingFrames(() => true);
+        }
+        catch (cleanupError) {
+            shutdownErrors.push(cleanupError);
+        }
+        if (browser) {
+            try {
+                await browser.close();
+            }
+            catch (closeError) {
+                shutdownErrors.push(closeError);
+            }
+        }
+        for (const tab of this.tabs.values()) {
+            this.tabIdsByPage.delete(tab.page);
+        }
+        this.tabs.clear();
+        this.outstandingFrames.clear();
+        this.browser = undefined;
+        this.browserContext = undefined;
+        this.browserLifetimeController = undefined;
+        this.activeTabId = null;
+        this.status = 'stopped';
+        this.emitState();
+        if (shutdownErrors.length > 0 && !error) {
+            throw new AggregateError(shutdownErrors, 'LiveBrowserSession shutdown was incomplete');
+        }
+    }
+    async configureBrowserSecurity(browser) {
+        if (!this.options.security?.denyPermissions) {
+            return;
+        }
+        const cdpSession = await browser.target().createCDPSession();
+        try {
+            await cdpSession.send('Browser.grantPermissions', { permissions: [] });
+        }
+        finally {
+            if (!cdpSession.detached) {
+                await cdpSession.detach();
+            }
+        }
+    }
+    requireBrowserContext() {
+        if (this.status !== 'running' || !this.browserContext) {
+            throw new Error('LiveBrowserSession is not running');
+        }
+        return this.browserContext;
+    }
+    requireTab(tabId) {
+        validateBoundedString(tabId, 'tabId', 1, 128);
+        const tab = this.tabs.get(tabId);
+        if (!tab) {
+            throw new Error(`Unknown tab: ${tabId}`);
+        }
+        return tab;
+    }
+    requireActiveTab() {
+        if (this.status !== 'running' || !this.activeTabId) {
+            throw new Error('LiveBrowserSession has no active tab');
+        }
+        const tab = this.requireTab(this.activeTabId);
+        if (tab.status !== 'open' || tab.page.isClosed()) {
+            throw new Error(`Active tab is not available: ${tab.id}`);
+        }
+        return tab;
+    }
+    resolveActionTab(tabId) {
+        if (this.status !== 'running') {
+            throw new Error('LiveBrowserSession is not running');
+        }
+        const tab = tabId ? this.requireTab(tabId) : this.requireActiveTab();
+        if (tab.status !== 'open' || tab.page.isClosed()) {
+            throw new Error(`Tab is not available: ${tab.id}`);
+        }
+        return tab;
+    }
+    resolveNavigationTab(tabId) {
+        return this.resolveActionTab(tabId);
+    }
+    async ensureTabViewport(tab) {
+        if (tab.appliedViewportRevision === this.viewportRevision) {
+            return;
+        }
+        const shouldRestartScreencast = this.activeTabId === tab.id && tab.streaming;
+        if (shouldRestartScreencast) {
+            await this.stopScreencast(tab);
+        }
+        try {
+            await tab.page.setViewport(createPuppeteerViewport(this.viewport));
+            tab.appliedViewportRevision = this.viewportRevision;
+        }
+        finally {
+            if (shouldRestartScreencast
+                && this.status === 'running'
+                && this.activeTabId === tab.id
+                && tab.status === 'open'
+                && !tab.page.isClosed()) {
+                await this.startScreencast(tab);
+            }
+        }
+    }
+    async registerPage(page) {
+        const existingTabId = this.tabIdsByPage.get(page);
+        if (existingTabId) {
+            return this.requireTab(existingTabId);
+        }
+        if (page.isClosed()) {
+            throw new Error('Cannot register a closed page');
+        }
+        const tab = {
+            id: `tab-${++this.tabSequence}`,
+            page,
+            url: truncate(page.url(), 4096),
+            title: '',
+            status: 'open',
+            generation: 0,
+            appliedViewportRevision: 0,
+            streaming: false,
+            streamInvalidated: true,
+            navigationInProgress: false,
+            closing: false,
+            stateUpdateQueued: false,
+            stateUpdatePending: false,
+            navigationResetPending: false,
+            removeListeners: [],
+        };
+        this.tabs.set(tab.id, tab);
+        this.tabIdsByPage.set(page, tab.id);
+        try {
+            if (this.options.security?.denyFileChoosers) {
+                const securityCdpSession = await page.createCDPSession();
+                tab.securityCdpSession = securityCdpSession;
+                await securityCdpSession.send('Page.enable', {
+                    enableFileChooserOpenedEvent: true,
+                });
+                await securityCdpSession.send('Page.setInterceptFileChooserDialog', {
+                    enabled: true,
+                    cancel: true,
+                });
+            }
+            await this.ensureTabViewport(tab);
+            await this.refreshTab(tab);
+            const onPopup = (popup) => {
+                if (!popup
+                    || this.normalStopRequested
+                    || this.status === 'stopped'
+                    || this.status === 'stopping') {
+                    return;
+                }
+                const popupWasScheduled = this.scheduleOperation(async () => {
+                    if (popup.isClosed()) {
+                        return;
+                    }
+                    const previousActiveTabId = this.activeTabId;
+                    let popupTab;
+                    try {
+                        popupTab = await this.registerPage(popup);
+                        await this.activateTabInternal(popupTab.id);
+                    }
+                    catch (error) {
+                        const rollbackError = await this.rollbackCreatedPage(popup, popupTab, previousActiveTabId);
+                        if (rollbackError) {
+                            throw new AggregateError([error, rollbackError], 'Popup registration rollback failed');
+                        }
+                        throw error;
+                    }
+                }, 'popup_registration_failed', tab.id);
+                if (!popupWasScheduled) {
+                    const popupError = {
+                        code: 'popup_registration_capacity_exceeded',
+                        message: 'A popup could not be admitted to the internal operation queue',
+                        fatal: true,
+                        tabId: tab.id,
+                    };
+                    this.emitError(popupError);
+                    void this.requestShutdown(popupError).catch((shutdownError) => {
+                        this.emitError({
+                            code: 'untracked_popup_shutdown_failed',
+                            message: normalizeErrorMessage(shutdownError),
+                            fatal: true,
+                            tabId: tab.id,
+                        });
+                    });
+                }
+            };
+            const onFrameNavigated = (frame) => {
+                if (frame !== page.mainFrame() || tab.closing) {
+                    return;
+                }
+                tab.evaluationExecutionContextId = undefined;
+                const navigationReset = !tab.navigationInProgress;
+                if (navigationReset) {
+                    tab.streamInvalidated = true;
+                    this.retireFramesForTabInBackground(tab.id);
+                }
+                this.requestTabStateUpdate(tab, navigationReset);
+            };
+            const onLoad = () => {
+                this.requestTabStateUpdate(tab, false);
+            };
+            const onClose = () => {
+                tab.streamInvalidated = true;
+                this.retireFramesForTabInBackground(tab.id);
+                if (tab.closing || this.normalStopRequested) {
+                    return;
+                }
+                this.scheduleOperation(async () => {
+                    await this.handleUnexpectedPageClose(tab);
+                }, 'page_close_cleanup_failed', tab.id, true);
+            };
+            const onCrash = (error) => {
+                tab.streamInvalidated = true;
+                this.retireFramesForTabInBackground(tab.id);
+                if (tab.closing || this.normalStopRequested) {
+                    return;
+                }
+                this.scheduleOperation(async () => {
+                    if (!this.tabs.has(tab.id) || tab.status === 'crashed') {
+                        return;
+                    }
+                    await this.stopScreencast(tab);
+                    tab.status = 'crashed';
+                    const wasActive = this.activeTabId === tab.id;
+                    if (wasActive) {
+                        this.activeTabId = null;
+                    }
+                    this.emitError({
+                        code: 'page_crashed',
+                        message: normalizeErrorMessage(error),
+                        fatal: false,
+                        tabId: tab.id,
+                    });
+                    if (wasActive) {
+                        await this.activateReplacementTab();
+                    }
+                }, 'page_crash_cleanup_failed', tab.id, true);
+            };
+            const onPageError = (error) => {
+                if (tab.closing || this.normalStopRequested) {
+                    return;
+                }
+                this.emitError({
+                    code: 'page_error',
+                    message: normalizeErrorMessage(error),
+                    fatal: false,
+                    tabId: tab.id,
+                });
+            };
+            page.on('popup', onPopup);
+            page.on('framenavigated', onFrameNavigated);
+            page.on('load', onLoad);
+            page.on('close', onClose);
+            page.on('error', onCrash);
+            page.on('pageerror', onPageError);
+            tab.removeListeners.push(() => page.off('popup', onPopup), () => page.off('framenavigated', onFrameNavigated), () => page.off('load', onLoad), () => page.off('close', onClose), () => page.off('error', onCrash), () => page.off('pageerror', onPageError));
+            return tab;
+        }
+        catch (error) {
+            if (tab.securityCdpSession && !tab.securityCdpSession.detached) {
+                try {
+                    await tab.securityCdpSession.detach();
+                }
+                catch {
+                    // The page may have closed while security setup was failing.
+                }
+            }
+            this.removePageListeners(tab);
+            this.tabs.delete(tab.id);
+            this.tabIdsByPage.delete(page);
+            throw error;
+        }
+    }
+    removePageListeners(tab) {
+        for (const removeListener of tab.removeListeners.splice(0)) {
+            removeListener();
+        }
+    }
+    retireFramesForTabInBackground(tabId) {
+        void this.retireOutstandingFrames((frame) => frame.tabId === tabId).catch((error) => {
+            if (this.status === 'running' && !this.normalStopRequested) {
+                this.emitError({
+                    code: 'frame_retirement_failed',
+                    message: normalizeErrorMessage(error),
+                    fatal: false,
+                    tabId,
+                });
+            }
+        });
+    }
+    requestTabStateUpdate(tab, navigationReset) {
+        if (!this.tabs.has(tab.id) || tab.closing) {
+            return;
+        }
+        tab.stateUpdatePending = true;
+        tab.navigationResetPending ||= navigationReset;
+        if (tab.stateUpdateQueued) {
+            return;
+        }
+        tab.stateUpdateQueued = true;
+        const wasScheduled = this.scheduleOperation(async () => {
+            try {
+                const shouldResetNavigation = tab.navigationResetPending;
+                tab.stateUpdatePending = false;
+                tab.navigationResetPending = false;
+                if (!this.tabs.has(tab.id) || tab.closing) {
+                    return;
+                }
+                if (shouldResetNavigation && this.activeTabId === tab.id) {
+                    await this.stopScreencast(tab);
+                }
+                await this.refreshTab(tab);
+                this.emitState();
+                if (shouldResetNavigation
+                    && this.activeTabId === tab.id
+                    && this.status === 'running'
+                    && tab.status === 'open') {
+                    await this.startScreencast(tab);
+                }
+            }
+            finally {
+                tab.stateUpdateQueued = false;
+                if (tab.stateUpdatePending
+                    && this.tabs.has(tab.id)
+                    && this.status === 'running'
+                    && !tab.closing) {
+                    this.requestTabStateUpdate(tab, false);
+                }
+            }
+        }, 'page_state_update_failed', tab.id);
+        if (!wasScheduled) {
+            tab.stateUpdateQueued = false;
+        }
+    }
+    async rollbackCreatedPage(page, tab, previousActiveTabId) {
+        const rollbackErrors = [];
+        if (tab) {
+            try {
+                await this.stopScreencast(tab);
+            }
+            catch (error) {
+                rollbackErrors.push(error);
+            }
+            tab.closing = true;
+        }
+        try {
+            if (!page.isClosed()) {
+                await page.close();
+            }
+        }
+        catch (error) {
+            rollbackErrors.push(error);
+        }
+        const pageClosed = page.isClosed();
+        if (tab) {
+            if (pageClosed) {
+                this.removePageListeners(tab);
+                this.tabs.delete(tab.id);
+                this.tabIdsByPage.delete(tab.page);
+            }
+            else {
+                tab.closing = false;
+                try {
+                    await this.refreshTab(tab);
+                }
+                catch (error) {
+                    rollbackErrors.push(error);
+                }
+            }
+        }
+        else {
+            this.tabIdsByPage.delete(page);
+            if (!pageClosed) {
+                const rollbackError = {
+                    code: 'untracked_page_rollback_failed',
+                    message: 'A failed page registration could not close its Chromium page',
+                    fatal: true,
+                };
+                if (!this.normalStopRequested && this.status === 'running') {
+                    this.emitError(rollbackError);
+                }
+                this.normalStopRequested = true;
+                this.beginShutdown(false);
+                try {
+                    await this.stopInternal();
+                }
+                catch (error) {
+                    rollbackErrors.push(error);
+                }
+            }
+        }
+        const previousActiveTab = previousActiveTabId
+            ? this.tabs.get(previousActiveTabId)
+            : undefined;
+        this.activeTabId = previousActiveTab?.id ?? null;
+        if (previousActiveTab
+            && previousActiveTab.status === 'open'
+            && !previousActiveTab.page.isClosed()) {
+            try {
+                await this.ensureTabViewport(previousActiveTab);
+                await previousActiveTab.page.bringToFront();
+                if (this.status === 'running' && !previousActiveTab.streaming) {
+                    await this.startScreencast(previousActiveTab);
+                }
+            }
+            catch (error) {
+                rollbackErrors.push(error);
+            }
+        }
+        this.emitState();
+        if (rollbackErrors.length === 0) {
+            return undefined;
+        }
+        return new AggregateError(rollbackErrors, 'Failed to roll back a new tab');
+    }
+    async handleUnexpectedPageClose(tab) {
+        if (!this.tabs.has(tab.id)) {
+            return;
+        }
+        await this.stopScreencast(tab);
+        this.removePageListeners(tab);
+        this.tabs.delete(tab.id);
+        this.tabIdsByPage.delete(tab.page);
+        if (this.activeTabId === tab.id) {
+            this.activeTabId = null;
+            await this.activateReplacementTab();
+        }
+        else {
+            this.emitState();
+        }
+    }
+    async activateTabInternal(tabId) {
+        const tab = this.requireTab(tabId);
+        if (tab.status !== 'open' || tab.page.isClosed()) {
+            throw new Error(`Tab is not available: ${tab.id}`);
+        }
+        if (this.activeTabId === tab.id && tab.streaming) {
+            await tab.page.bringToFront();
+            return;
+        }
+        const currentTab = this.activeTabId ? this.tabs.get(this.activeTabId) : undefined;
+        if (currentTab) {
+            await this.stopScreencast(currentTab);
+        }
+        try {
+            await this.ensureTabViewport(tab);
+            await tab.page.bringToFront();
+            this.activeTabId = tab.id;
+            this.emitState();
+            if (this.status === 'running') {
+                await this.startScreencast(tab);
+            }
+        }
+        catch (error) {
+            if (currentTab && this.tabs.has(currentTab.id) && !currentTab.page.isClosed()) {
+                this.activeTabId = currentTab.id;
+                await this.ensureTabViewport(currentTab);
+                await currentTab.page.bringToFront();
+                if (this.status === 'running' && !currentTab.streaming) {
+                    await this.startScreencast(currentTab);
+                }
+            }
+            this.emitState();
+            throw error;
+        }
+    }
+    async activateReplacementTab() {
+        const attemptedTabIds = new Set();
+        while (true) {
+            const replacementTab = [...this.tabs.values()].find((tab) => (!attemptedTabIds.has(tab.id)
+                && tab.status === 'open'
+                && !tab.page.isClosed()));
+            if (!replacementTab) {
+                this.activeTabId = null;
+                this.normalStopRequested = true;
+                this.beginShutdown(false);
+                await this.stopInternal();
+                return;
+            }
+            attemptedTabIds.add(replacementTab.id);
+            try {
+                await this.activateTabInternal(replacementTab.id);
+                return;
+            }
+            catch (error) {
+                this.activeTabId = null;
+                this.emitError({
+                    code: 'replacement_tab_activation_failed',
+                    message: normalizeErrorMessage(error),
+                    fatal: false,
+                    tabId: replacementTab.id,
+                });
+            }
+        }
+    }
+    async navigateTab(tab, navigation, signal) {
+        const isActive = this.activeTabId === tab.id;
+        tab.evaluationExecutionContextId = undefined;
+        tab.navigationInProgress = true;
+        if (isActive) {
+            await this.stopScreencast(tab);
+        }
+        try {
+            if (signal.aborted) {
+                throw signal.reason;
+            }
+            await navigation();
+        }
+        finally {
+            tab.navigationInProgress = false;
+            if (this.tabs.has(tab.id) && !tab.page.isClosed()) {
+                await this.refreshTab(tab);
+                this.emitState();
+                if (isActive
+                    && this.activeTabId === tab.id
+                    && this.status === 'running'
+                    && tab.status === 'open') {
+                    await this.startScreencast(tab);
+                }
+            }
+        }
+    }
+    createPuppeteerNavigationOptions(options, signal) {
+        return {
+            timeout: this.validateTimeout(options.timeoutMs, 30000),
+            waitUntil: this.validateWaitUntil(options.waitUntil),
+            signal,
+        };
+    }
+    async refreshTab(tab) {
+        if (tab.page.isClosed()) {
+            return;
+        }
+        tab.url = truncate(tab.page.url(), 4096);
+        try {
+            tab.title = truncate(await tab.page.title(), 1024);
+        }
+        catch (error) {
+            if (!tab.page.isClosed() && !tab.closing) {
+                throw error;
+            }
+        }
+    }
+    async startScreencast(tab) {
+        if (this.status !== 'running'
+            || this.activeTabId !== tab.id
+            || tab.status !== 'open'
+            || tab.page.isClosed()
+            || tab.streaming) {
+            return;
+        }
+        await this.ensureTabViewport(tab);
+        const cdpSession = await tab.page.createCDPSession();
+        const generation = tab.generation + 1;
+        const frameListener = (event) => {
+            this.handleScreencastFrame(tab, cdpSession, generation, event);
+        };
+        const cdpConnection = cdpSession.connection();
+        const cdpSessionDetachedListener = (detachedSession) => {
+            if (detachedSession !== cdpSession) {
+                return;
+            }
+            this.handlePossibleCdpDisconnection(tab, cdpSession, new Error('The tab CDP session disconnected'));
+        };
+        tab.cdpSession = cdpSession;
+        tab.cdpConnection = cdpConnection;
+        tab.screencastFrameListener = frameListener;
+        tab.cdpSessionDetachedListener = cdpSessionDetachedListener;
+        tab.generation = generation;
+        tab.streaming = true;
+        tab.streamInvalidated = false;
+        cdpSession.on('Page.screencastFrame', frameListener);
+        cdpConnection?.on(plugins.puppeteer.CDPSessionEvent.SessionDetached, cdpSessionDetachedListener);
+        const format = this.options.screencast?.format ?? 'jpeg';
+        try {
+            await cdpSession.send('Page.startScreencast', {
+                format,
+                quality: this.options.screencast?.quality ?? 80,
+                maxWidth: this.options.screencast?.maxWidth,
+                maxHeight: this.options.screencast?.maxHeight,
+                everyNthFrame: this.options.screencast?.everyNthFrame ?? 1,
+            });
+            this.emitState();
+        }
+        catch (error) {
+            tab.streaming = false;
+            tab.streamInvalidated = true;
+            tab.cdpSession = undefined;
+            tab.cdpConnection = undefined;
+            tab.screencastFrameListener = undefined;
+            tab.cdpSessionDetachedListener = undefined;
+            cdpSession.off('Page.screencastFrame', frameListener);
+            cdpConnection?.off(plugins.puppeteer.CDPSessionEvent.SessionDetached, cdpSessionDetachedListener);
+            if (!cdpSession.detached) {
+                try {
+                    await cdpSession.detach();
+                }
+                catch {
+                    // The target may have closed while screencast startup was failing.
+                }
+            }
+            throw error;
+        }
+    }
+    async stopScreencast(tab) {
+        const cdpSession = tab.cdpSession;
+        const cdpConnection = tab.cdpConnection;
+        const frameListener = tab.screencastFrameListener;
+        const cdpSessionDetachedListener = tab.cdpSessionDetachedListener;
+        tab.streaming = false;
+        tab.streamInvalidated = true;
+        tab.cdpSession = undefined;
+        tab.cdpConnection = undefined;
+        tab.screencastFrameListener = undefined;
+        tab.cdpSessionDetachedListener = undefined;
+        await this.retireOutstandingFrames((frame) => frame.tabId === tab.id);
+        if (!cdpSession) {
+            return;
+        }
+        if (!cdpSession.detached) {
+            try {
+                await cdpSession.send('Page.stopScreencast');
+            }
+            catch {
+                // Page close and browser disconnect detach the target before cleanup runs.
+            }
+        }
+        await this.retireOutstandingFrames((frame) => frame.tabId === tab.id);
+        if (frameListener) {
+            cdpSession.off('Page.screencastFrame', frameListener);
+        }
+        if (cdpConnection && cdpSessionDetachedListener) {
+            cdpConnection.off(plugins.puppeteer.CDPSessionEvent.SessionDetached, cdpSessionDetachedListener);
+        }
+        if (!cdpSession.detached) {
+            try {
+                await cdpSession.detach();
+            }
+            catch {
+                // A concurrent page close can detach the session first.
+            }
+        }
+    }
+    handleScreencastFrame(tab, cdpSession, generation, event) {
+        if (this.status !== 'running'
+            || this.activeTabId !== tab.id
+            || tab.status !== 'open'
+            || tab.streamInvalidated
+            || !tab.streaming
+            || tab.generation !== generation
+            || tab.appliedViewportRevision !== this.viewportRevision
+            || tab.cdpSession !== cdpSession) {
+            this.acknowledgeCdpFrameInBackground({
+                tabId: tab.id,
+                generation,
+                viewportRevision: this.viewportRevision,
+                cdpSessionId: event.sessionId,
+                cdpSession,
+            });
+            return;
+        }
+        const format = this.options.screencast?.format ?? 'jpeg';
+        const data = new Uint8Array(plugins.Buffer.from(event.data, 'base64'));
+        const dimensions = readImageDimensions(data, format, {
+            width: Math.max(1, Math.round(event.metadata.deviceWidth)),
+            height: Math.max(1, Math.round(event.metadata.deviceHeight)),
+        });
+        const sequence = ++this.frameSequence;
+        const outstandingFrame = {
+            tabId: tab.id,
+            generation,
+            viewportRevision: this.viewportRevision,
+            cdpSessionId: event.sessionId,
+            cdpSession,
+        };
+        while (this.outstandingFrames.size >= maxOutstandingFrames) {
+            const oldestFrameEntry = this.outstandingFrames.entries().next().value;
+            if (!oldestFrameEntry) {
+                break;
+            }
+            this.outstandingFrames.delete(oldestFrameEntry[0]);
+            this.acknowledgeCdpFrameInBackground(oldestFrameEntry[1]);
+        }
+        this.outstandingFrames.set(sequence, outstandingFrame);
+        const frame = {
+            tabId: tab.id,
+            sequence,
+            generation,
+            viewportRevision: this.viewportRevision,
+            viewport: { ...this.viewport },
+            format,
+            mimeType: format === 'jpeg' ? 'image/jpeg' : 'image/png',
+            ...dimensions,
+            metadata: {
+                offsetTop: event.metadata.offsetTop,
+                pageScaleFactor: event.metadata.pageScaleFactor,
+                deviceWidth: event.metadata.deviceWidth,
+                deviceHeight: event.metadata.deviceHeight,
+                scrollOffsetX: event.metadata.scrollOffsetX,
+                scrollOffsetY: event.metadata.scrollOffsetY,
+                ...(event.metadata.timestamp !== undefined
+                    ? { timestamp: event.metadata.timestamp }
+                    : {}),
+            },
+            data,
+        };
+        this.emitEvent({ type: 'frame', frame });
+    }
+    async acknowledgeCdpFrame(frame) {
+        if (frame.cdpSession.detached) {
+            this.handleFrameAcknowledgementFailure(frame, new Error('CDP session detached before frame acknowledgement'));
+            return false;
+        }
+        try {
+            await frame.cdpSession.send('Page.screencastFrameAck', {
+                sessionId: frame.cdpSessionId,
+            });
+            return true;
+        }
+        catch (error) {
+            this.handleFrameAcknowledgementFailure(frame, error);
+            return false;
+        }
+    }
+    acknowledgeCdpFrameInBackground(frame) {
+        void this.acknowledgeCdpFrame(frame);
+    }
+    handleFrameAcknowledgementFailure(frame, error) {
+        const tab = this.tabs.get(frame.tabId);
+        const isCurrentStream = Boolean(tab
+            && tab.cdpSession === frame.cdpSession
+            && !tab.streamInvalidated);
+        if (isCurrentStream
+            && this.status === 'running'
+            && !this.normalStopRequested) {
+            this.emitError({
+                code: 'frame_acknowledgement_failed',
+                message: normalizeErrorMessage(error),
+                fatal: false,
+                tabId: frame.tabId,
+            });
+        }
+        if (tab) {
+            this.handlePossibleCdpDisconnection(tab, frame.cdpSession, error);
+        }
+    }
+    async retireOutstandingFrames(predicate) {
+        const acknowledgements = [];
+        for (const [sequence, frame] of this.outstandingFrames) {
+            if (!predicate(frame)) {
+                continue;
+            }
+            this.outstandingFrames.delete(sequence);
+            acknowledgements.push(this.acknowledgeCdpFrame(frame));
+        }
+        await Promise.all(acknowledgements);
+    }
+    handlePossibleCdpDisconnection(tab, cdpSession, error) {
+        if (this.normalStopRequested
+            || this.status !== 'running'
+            || tab.cdpSession !== cdpSession
+            || tab.streamInvalidated
+            || !cdpSession.detached) {
+            return;
+        }
+        tab.streamInvalidated = true;
+        this.retireFramesForTabInBackground(tab.id);
+        this.scheduleOperation(async () => {
+            if (!this.tabs.has(tab.id) || tab.cdpSession !== cdpSession) {
+                return;
+            }
+            await this.stopScreencast(tab);
+            tab.status = 'crashed';
+            const wasActive = this.activeTabId === tab.id;
+            if (wasActive) {
+                this.activeTabId = null;
+            }
+            this.emitError({
+                code: 'cdp_disconnected',
+                message: normalizeErrorMessage(error),
+                fatal: false,
+                tabId: tab.id,
+            });
+            if (wasActive) {
+                await this.activateReplacementTab();
+            }
+        }, 'cdp_disconnect_cleanup_failed', tab.id, true);
+    }
+    requireRawInputTarget(input) {
+        const tab = this.requireInputTarget(input, true);
+        const cdpSession = tab.cdpSession;
+        if (!tab.streaming || tab.streamInvalidated || !cdpSession || cdpSession.detached) {
+            throw new Error(`Tab input transport is not available: ${tab.id}`);
+        }
+        return { tab, cdpSession };
+    }
+    requireSemanticActionTarget(input) {
+        return this.requireInputTarget(input, false);
+    }
+    requireInputTarget(input, requireActive) {
+        if (this.status !== 'running') {
+            throw new Error('LiveBrowserSession is not running');
+        }
+        const tab = this.requireTab(input.tabId);
+        if (requireActive && this.activeTabId !== tab.id) {
+            throw new Error(`Tab is not active: ${tab.id}`);
+        }
+        if (!Number.isInteger(input.generation) || input.generation !== tab.generation) {
+            throw new Error(`Stale tab generation ${input.generation}; current generation is ${tab.generation}`);
+        }
+        if (input.viewportRevision !== this.viewportRevision) {
+            throw new Error(`Stale viewport revision ${input.viewportRevision}; current revision is ${this.viewportRevision}`);
+        }
+        if (tab.status !== 'open' || tab.page.isClosed()) {
+            throw new Error(`Tab is not available: ${tab.id}`);
+        }
+        return tab;
+    }
+    validateCoordinates(x, y) {
+        validateFiniteNumber(x, 'x', 0, this.viewport.width);
+        validateFiniteNumber(y, 'y', 0, this.viewport.height);
+        if (x >= this.viewport.width) {
+            throw new Error(`x must be less than viewport width ${this.viewport.width}`);
+        }
+        if (y >= this.viewport.height) {
+            throw new Error(`y must be less than viewport height ${this.viewport.height}`);
+        }
+    }
+    createModifierMask(modifiers) {
+        if (modifiers === undefined) {
+            return 0;
+        }
+        if (!modifiers || typeof modifiers !== 'object' || Array.isArray(modifiers)) {
+            throw new Error('modifiers must be an object');
+        }
+        const allowedKeys = new Set(['alt', 'control', 'meta', 'shift']);
+        for (const key of Object.keys(modifiers)) {
+            if (!allowedKeys.has(key)) {
+                throw new Error(`Unknown modifier: ${key}`);
+            }
+        }
+        validateOptionalBoolean(modifiers.alt, 'modifiers.alt');
+        validateOptionalBoolean(modifiers.control, 'modifiers.control');
+        validateOptionalBoolean(modifiers.meta, 'modifiers.meta');
+        validateOptionalBoolean(modifiers.shift, 'modifiers.shift');
+        return ((modifiers.alt ? 1 : 0)
+            | (modifiers.control ? 2 : 0)
+            | (modifiers.meta ? 4 : 0)
+            | (modifiers.shift ? 8 : 0));
+    }
+    validateUrl(url) {
+        const validatedUrl = validateBoundedString(url, 'url', 1, maxUrlLength);
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(validatedUrl);
+        }
+        catch {
+            throw new Error('url must be absolute');
+        }
+        if (this.options.security?.httpNavigationOnly
+            && parsedUrl.protocol !== 'http:'
+            && parsedUrl.protocol !== 'https:') {
+            throw new Error('url protocol must be http or https');
+        }
+        return validatedUrl;
+    }
+    normalizeEvaluationOptions(options) {
+        return {
+            timeoutMs: options.timeoutMs === undefined
+                ? 5000
+                : validateInteger(options.timeoutMs, 'timeoutMs', 1, 30000),
+            maxOutputBytes: options.maxOutputBytes === undefined
+                ? 262144
+                : validateInteger(options.maxOutputBytes, 'maxOutputBytes', 1, maxEvaluationOutputBytes),
+            maxDepth: options.maxDepth === undefined
+                ? 16
+                : validateInteger(options.maxDepth, 'maxDepth', 1, maxEvaluationDepth),
+            maxNodes: options.maxNodes === undefined
+                ? 10000
+                : validateInteger(options.maxNodes, 'maxNodes', 1, maxEvaluationNodes),
+            maxStringBytes: options.maxStringBytes === undefined
+                ? 65536
+                : validateInteger(options.maxStringBytes, 'maxStringBytes', 0, maxEvaluationStringBytes),
+            maxArrayLength: options.maxArrayLength === undefined
+                ? 1000
+                : validateInteger(options.maxArrayLength, 'maxArrayLength', 0, maxEvaluationArrayLength),
+            maxObjectKeys: options.maxObjectKeys === undefined
+                ? 1000
+                : validateInteger(options.maxObjectKeys, 'maxObjectKeys', 0, maxEvaluationObjectKeys),
+        };
+    }
+    readCdpExceptionMessage(exceptionDetails) {
+        const description = exceptionDetails.exception?.description;
+        if (typeof description === 'string' && description.length > 0) {
+            return truncate(description, 2048);
+        }
+        return truncate(exceptionDetails.text, 2048);
+    }
+    createEvaluationBootstrapExpression() {
+        const bootstrapKeyLiteral = JSON.stringify(evaluationBootstrapKey);
+        const cancelKeyLiteral = JSON.stringify(evaluationCancelKey);
+        const cleanupKeyLiteral = JSON.stringify(evaluationCleanupKey);
+        return `(() => {
+      'use strict';
+      if (typeof globalThis[${bootstrapKeyLiteral}] === 'function') {
+        return true;
+      }
+      const safeGlobalThis = globalThis;
+      const SafeArray = Array;
+      const SafeError = Error;
+      const SafeFunction = Function;
+      const SafeJSON = JSON;
+      const SafeMap = Map;
+      const SafeNumber = Number;
+      const SafeObject = Object;
+      const SafePromise = Promise;
+      const SafeString = String;
+      const SafeTextEncoder = TextEncoder;
+      const SafeWeakSet = WeakSet;
+      const SafeClearTimeout = clearTimeout;
+      const SafeSetTimeout = setTimeout;
+      const safeCreate = SafeObject.create;
+      const safeDefineProperty = SafeObject.defineProperty;
+      const safeGetOwnPropertyDescriptor = SafeObject.getOwnPropertyDescriptor;
+      const safeGetOwnPropertySymbols = SafeObject.getOwnPropertySymbols;
+      const safeGetPrototypeOf = SafeObject.getPrototypeOf;
+      const safeIsArray = SafeArray.isArray;
+      const safeIsFinite = SafeNumber.isFinite;
+      const safeKeys = SafeObject.keys;
+      const safeSetPrototypeOf = SafeObject.setPrototypeOf;
+      const safeStringify = SafeJSON.stringify;
+      const safeMapDelete = SafeFunction.prototype.call.bind(SafeMap.prototype.delete);
+      const safeMapGet = SafeFunction.prototype.call.bind(SafeMap.prototype.get);
+      const safeMapSet = SafeFunction.prototype.call.bind(SafeMap.prototype.set);
+      const safePromiseThen = SafeFunction.prototype.call.bind(SafePromise.prototype.then);
+      const safeWeakSetAdd = SafeFunction.prototype.call.bind(SafeWeakSet.prototype.add);
+      const safeWeakSetHas = SafeFunction.prototype.call.bind(SafeWeakSet.prototype.has);
+      const safeEncode = SafeFunction.prototype.call.bind(SafeTextEncoder.prototype.encode);
+      const encoder = new SafeTextEncoder();
+      const cancellationHandlers = new SafeMap();
+
+      const createEnvelope = (ok, value) => {
+        const envelope = safeCreate(null);
+        envelope.ok = ok;
+        if (ok) {
+          envelope.json = value;
+        } else {
+          envelope.error = value;
+        }
+        return envelope;
+      };
+      const byteLength = (value) => safeEncode(encoder, value).byteLength;
+      const cancelEvaluation = (cancellationKey) => {
+        const handler = safeMapGet(cancellationHandlers, cancellationKey);
+        if (typeof handler === 'function') {
+          handler();
+        }
+        return safeMapDelete(cancellationHandlers, cancellationKey);
+      };
+      const evaluate = async (source, options, cancellationKey) => {
+        const seen = new SafeWeakSet();
+        let visitedNodes = 0;
+        const normalize = (value, depth) => {
+          visitedNodes += 1;
+          if (visitedNodes > options.maxNodes) {
+            throw new SafeError('Evaluation result exceeded maxNodes');
+          }
+          if (depth > options.maxDepth) {
+            throw new SafeError('Evaluation result exceeded maxDepth');
+          }
+          if (value === null || typeof value === 'boolean') {
+            return value;
+          }
+          if (typeof value === 'number') {
+            if (!safeIsFinite(value)) {
+              throw new SafeError('Evaluation result contains a non-finite number');
+            }
+            return value;
+          }
+          if (typeof value === 'string') {
+            if (byteLength(value) > options.maxStringBytes) {
+              throw new SafeError('Evaluation result string exceeded maxStringBytes');
+            }
+            return value;
+          }
+          if (typeof value !== 'object') {
+            throw new SafeError('Evaluation result contains a non-JSON value');
+          }
+          if (safeWeakSetHas(seen, value)) {
+            throw new SafeError('Evaluation result contains a cycle or repeated object');
+          }
+          safeWeakSetAdd(seen, value);
+
+          if (safeIsArray(value)) {
+            if (value.length > options.maxArrayLength) {
+              throw new SafeError('Evaluation result array exceeded maxArrayLength');
+            }
+            const keys = safeKeys(value);
+            if (keys.length !== value.length) {
+              throw new SafeError('Evaluation result contains a sparse or extended array');
+            }
+            const output = SafeArray(value.length);
+            safeSetPrototypeOf(output, null);
+            for (let index = 0; index < value.length; index += 1) {
+              const descriptor = safeGetOwnPropertyDescriptor(value, SafeString(index));
+              if (!descriptor || !('value' in descriptor)) {
+                throw new SafeError('Evaluation result contains an array accessor');
+              }
+              output[index] = normalize(descriptor.value, depth + 1);
+            }
+            return output;
+          }
+
+          const prototype = safeGetPrototypeOf(value);
+          if (prototype !== SafeObject.prototype && prototype !== null) {
+            throw new SafeError('Evaluation result contains a non-plain object');
+          }
+          if (safeGetOwnPropertySymbols(value).length > 0) {
+            throw new SafeError('Evaluation result contains symbol properties');
+          }
+          const keys = safeKeys(value);
+          if (keys.length > options.maxObjectKeys) {
+            throw new SafeError('Evaluation result object exceeded maxObjectKeys');
+          }
+          const output = safeCreate(null);
+          for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            if (byteLength(key) > options.maxStringBytes) {
+              throw new SafeError('Evaluation result key exceeded maxStringBytes');
+            }
+            const descriptor = safeGetOwnPropertyDescriptor(value, key);
+            if (!descriptor || !('value' in descriptor)) {
+              throw new SafeError('Evaluation result contains an object accessor');
+            }
+            output[key] = normalize(descriptor.value, depth + 1);
+          }
+          return output;
+        };
+
+        try {
+          const execute = SafeFunction(
+            '\"use strict\"; return (async () => (' + source + '\\n))();',
+          );
+          const boundedExecution = new SafePromise((resolve, reject) => {
+            let timeout;
+            safeMapSet(cancellationHandlers, cancellationKey, () => {
+              if (timeout !== undefined) {
+                SafeClearTimeout(timeout);
+              }
+              reject(new SafeError('Evaluation cancelled'));
+            });
+            timeout = SafeSetTimeout(() => {
+              reject(new SafeError('Evaluation timed out after ' + options.timeoutMs + 'ms'));
+            }, options.timeoutMs);
+            safePromiseThen(
+              execute(),
+              (value) => {
+                SafeClearTimeout(timeout);
+                resolve(value);
+              },
+              (error) => {
+                SafeClearTimeout(timeout);
+                reject(error);
+              },
+            );
+          });
+          let normalizedResult;
+          try {
+            normalizedResult = normalize(await boundedExecution, 0);
+          } finally {
+            safeMapDelete(cancellationHandlers, cancellationKey);
+          }
+          const json = safeStringify(normalizedResult);
+          if (typeof json !== 'string' || byteLength(json) > options.maxOutputBytes) {
+            throw new SafeError('Evaluation result exceeded maxOutputBytes');
+          }
+          return createEnvelope(true, json);
+        } catch (error) {
+          let message = 'Evaluation failed';
+          if (typeof error === 'string') {
+            message = error;
+          } else if (error && typeof error === 'object') {
+            const descriptor = safeGetOwnPropertyDescriptor(error, 'message');
+            if (descriptor && 'value' in descriptor && typeof descriptor.value === 'string') {
+              message = descriptor.value;
+            }
+          }
+          if (byteLength(message) > 2048) {
+            message = 'Evaluation failed with an oversized error';
+          }
+          return createEnvelope(false, message);
+        }
+      };
+
+      for (const [key, value] of [
+        [${bootstrapKeyLiteral}, evaluate],
+        [${cancelKeyLiteral}, cancelEvaluation],
+        [${cleanupKeyLiteral}, cancelEvaluation],
+      ]) {
+        safeDefineProperty(safeGlobalThis, key, {
+          value,
+          configurable: false,
+          enumerable: false,
+          writable: false,
+        });
+      }
+      return true;
+    })()`;
+    }
+    createEvaluationExpression(expression, options, cancellationKey) {
+        return `globalThis[${JSON.stringify(evaluationBootstrapKey)}](${JSON.stringify(expression)}, ${JSON.stringify(options)}, ${JSON.stringify(cancellationKey)})`;
+    }
+    validateTimeout(timeoutMs, defaultValue = 5000) {
+        if (timeoutMs === undefined) {
+            return defaultValue;
+        }
+        return validateInteger(timeoutMs, 'timeoutMs', 1, maxTimeoutMs);
+    }
+    validateWaitUntil(waitUntil) {
+        const validatedWaitUntil = waitUntil ?? 'load';
+        if (!['load', 'domcontentloaded', 'networkidle0', 'networkidle2'].includes(validatedWaitUntil)) {
+            throw new Error('waitUntil must be load, domcontentloaded, networkidle0, or networkidle2');
+        }
+        return validatedWaitUntil;
+    }
+    validateScreencastOptions() {
+        const options = this.options.screencast;
+        if (!options) {
+            return;
+        }
+        if (options.format !== undefined && options.format !== 'jpeg' && options.format !== 'png') {
+            throw new Error('screencast.format must be jpeg or png');
+        }
+        if (options.quality !== undefined) {
+            validateInteger(options.quality, 'screencast.quality', 0, 100);
+        }
+        if (options.maxWidth !== undefined) {
+            validateInteger(options.maxWidth, 'screencast.maxWidth', 1, maxViewportWidth);
+        }
+        if (options.maxHeight !== undefined) {
+            validateInteger(options.maxHeight, 'screencast.maxHeight', 1, maxViewportHeight);
+        }
+        if (options.maxWidth !== undefined
+            && options.maxHeight !== undefined
+            && options.maxWidth * options.maxHeight > maxViewportPixelArea) {
+            throw new Error(`screencast pixel area must not exceed ${maxViewportPixelArea} pixels`);
+        }
+        if (options.everyNthFrame !== undefined) {
+            validateInteger(options.everyNthFrame, 'screencast.everyNthFrame', 1, 100);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartpuppeteer.classes.livebrowsersession.js","sourceRoot":"","sources":["../ts/smartpuppeteer.classes.livebrowsersession.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAiCxF,OAAO,KAAK,OAAO,MAAM,6BAA6B,CAAC;AAEvD,MAAM,eAAe,GAAyB;IAC5C,KAAK,EAAE,GAAG;IACV,MAAM,EAAE,GAAG;IACX,iBAAiB,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,gBAAgB,GAAG,IAAI,CAAC;AAC9B,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAC/B,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAC/B,MAAM,oBAAoB,GAAG,OAAO,CAAC;AACrC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAC/B,MAAM,aAAa,GAAG,KAAK,CAAC;AAC5B,MAAM,YAAY,GAAG,KAAK,CAAC;AAC3B,MAAM,YAAY,GAAG,KAAK,CAAC;AAC3B,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAC/B,MAAM,yBAAyB,GAAG,EAAE,CAAC;AACrC,MAAM,2BAA2B,GAAG,GAAG,CAAC;AACxC,MAAM,wBAAwB,GAAG,MAAM,CAAC;AACxC,MAAM,wBAAwB,GAAG,OAAO,CAAC;AACzC,MAAM,kBAAkB,GAAG,EAAE,CAAC;AAC9B,MAAM,kBAAkB,GAAG,KAAK,CAAC;AACjC,MAAM,wBAAwB,GAAG,MAAM,CAAC;AACxC,MAAM,wBAAwB,GAAG,KAAK,CAAC;AACvC,MAAM,uBAAuB,GAAG,KAAK,CAAC;AACtC,MAAM,sBAAsB,GAAG,0BAA0B,CAAC;AAC1D,MAAM,mBAAmB,GAAG,wBAAwB,CAAC;AACrD,MAAM,oBAAoB,GAAG,yBAAyB,CAAC;AAyEvD,MAAM,qBAAqB,GAAG,CAC5B,KAAc,EACd,IAAY,EACZ,SAAiB,EACjB,SAAiB,EACT,EAAE;IACV,IACE,OAAO,KAAK,KAAK,QAAQ;WACtB,KAAK,CAAC,MAAM,GAAG,SAAS;WACxB,KAAK,CAAC,MAAM,GAAG,SAAS,EAC3B,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,yBAAyB,SAAS,QAAQ,SAAS,aAAa,CAAC,CAAC;IAC3F,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAC3B,KAAc,EACd,IAAY,EACZ,OAAe,EACf,OAAe,EACP,EAAE;IACV,IACE,OAAO,KAAK,KAAK,QAAQ;WACtB,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;WACvB,KAAK,GAAG,OAAO;WACf,KAAK,GAAG,OAAO,EAClB,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,oCAAoC,OAAO,QAAQ,OAAO,EAAE,CAAC,CAAC;IACvF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,eAAe,GAAG,CACtB,KAAc,EACd,IAAY,EACZ,OAAe,EACf,OAAe,EACP,EAAE;IACV,MAAM,cAAc,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC3E,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,qBAAqB,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,cAAc,CAAC;AACxB,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG,CAAC,KAAc,EAAE,IAAY,EAAQ,EAAE;IACrE,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CAAC,GAAG,IAAI,oBAAoB,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAE,SAAiB,EAAU,EAAE;IAC5D,IAAI,KAAK,CAAC,MAAM,IAAI,SAAS,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;AAC5D,CAAC,CAAC;AAEF,MAAM,qBAAqB,GAAG,CAAC,KAAc,EAAU,EAAE;IACvD,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,OAAO,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;AACvC,CAAC,CAAC;AAEF,MAAM,oBAAoB,GAAG,CAAC,MAAmB,EAAW,EAAE;IAC5D,OAAO,MAAM,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;AACzE,CAAC,CAAC;AAEF,MAAM,UAAU,GAAG,CAAC,IAAgB,EAAE,MAAc,EAAU,EAAE;IAC9D,OAAO,CACL,IAAI,CAAC,MAAM,CAAE,GAAG,SAAS;UACvB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,GAAG,OAAO;UAC3B,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,GAAG,KAAK;UACzB,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CACpB,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAC1B,IAAgB,EAChB,MAA+B,EAC/B,QAA0B,EACR,EAAE;IACpB,IACE,MAAM,KAAK,KAAK;WACb,IAAI,CAAC,MAAM,IAAI,EAAE;WACjB,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI;WAChB,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI;WAChB,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI;WAChB,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EACnB,CAAC;QACD,OAAO;YACL,KAAK,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;YAC3B,MAAM,EAAE,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC;SAC7B,CAAC;IACJ,CAAC;IAED,IAAI,MAAM,KAAK,MAAM,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QAClF,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,OAAO,MAAM,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC;gBAC1B,MAAM,IAAI,CAAC,CAAC;gBACZ,SAAS;YACX,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC;YACjC,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;gBACvC,MAAM,IAAI,CAAC,CAAC;gBACZ,SAAS;YACX,CAAC;YACD,MAAM,aAAa,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC;YACnE,IAAI,aAAa,GAAG,CAAC,IAAI,MAAM,GAAG,aAAa,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;gBAClE,MAAM;YACR,CAAC;YACD,IACE,MAAM,KAAK,IAAI;mBACZ,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI;mBACf,MAAM,KAAK,IAAI,EAClB,CAAC;gBACD,OAAO;oBACL,MAAM,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE;oBACpD,KAAK,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAE;iBACpD,CAAC;YACJ,CAAC;YACD,MAAM,IAAI,aAAa,GAAG,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,iBAAiB,GAAG,CAAC,QAA8B,EAAwB,EAAE;IACjF,MAAM,kBAAkB,GAAG;QACzB,KAAK,EAAE,eAAe,CAAC,QAAQ,CAAC,KAAK,EAAE,gBAAgB,EAAE,CAAC,EAAE,gBAAgB,CAAC;QAC7E,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,CAAC;QACjF,iBAAiB,EAAE,oBAAoB,CACrC,QAAQ,CAAC,iBAAiB,EAC1B,4BAA4B,EAC5B,IAAI,EACJ,oBAAoB,CACrB;KACF,CAAC;IACF,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAC7B,kBAAkB,CAAC,KAAK,GAAG,kBAAkB,CAAC,iBAAiB,CAChE,CAAC;IACF,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAC9B,kBAAkB,CAAC,MAAM,GAAG,kBAAkB,CAAC,iBAAiB,CACjE,CAAC;IACF,IAAI,aAAa,GAAG,cAAc,GAAG,oBAAoB,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,uCAAuC,oBAAoB,kBAAkB,CAC9E,CAAC;IACJ,CAAC;IACD,OAAO,kBAAkB,CAAC;AAC5B,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG,CAC9B,QAA8B,EACF,EAAE,CAAC,CAAC;IAChC,GAAG,QAAQ;IACX,QAAQ,EAAE,KAAK;IACf,WAAW,EAAE,KAAK;IAClB,QAAQ,EAAE,KAAK;CAChB,CAAC,CAAC;AAEH,MAAM,OAAO,kBAAkB;IA2B7B,YAAY,aAAyC,EAAE;QAzBtC,mBAAc,GAAG,IAAI,GAAG,EAA6B,CAAC;QACtD,SAAI,GAAG,IAAI,GAAG,EAAkC,CAAC;QACjD,iBAAY,GAAG,IAAI,OAAO,EAAkC,CAAC;QAC7D,sBAAiB,GAAG,IAAI,GAAG,EAA6B,CAAC;QAMzD,mBAAc,GAAuB,EAAE,CAAC;QAEjD,qBAAgB,GAAG,KAAK,CAAC;QACzB,6BAAwB,GAAG,CAAC,CAAC;QAC7B,+BAA0B,GAAG,CAAC,CAAC;QAE/B,WAAM,GAAoD,SAAS,CAAC;QACpE,gBAAW,GAAkB,IAAI,CAAC;QAClC,aAAQ,GAAyB,EAAE,GAAG,eAAe,EAAE,CAAC;QACxD,qBAAgB,GAAG,CAAC,CAAC;QACrB,gBAAW,GAAG,CAAC,CAAC;QAChB,kBAAa,GAAG,CAAC,CAAC;QAClB,uBAAkB,GAAG,CAAC,CAAC;QACvB,wBAAmB,GAAG,KAAK,CAAC;QAIlC,IACE,UAAU,CAAC,aAAa,EAAE,QAAQ;eAC/B,UAAU,CAAC,aAAa,CAAC,QAAQ,KAAK,KAAK,EAC9C,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;QAC9E,CAAC;QACD,IACE,UAAU,CAAC,aAAa,EAAE,OAAO;eAC9B,UAAU,CAAC,aAAa,CAAC,OAAO,KAAK,QAAQ,EAChD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QACD,IAAI,UAAU,CAAC,aAAa,IAAI,QAAQ,IAAI,UAAU,CAAC,aAAa,EAAE,CAAC;YACrE,MAAM,IAAI,KAAK,CAAC,kFAAkF,CAAC,CAAC;QACtG,CAAC;QACD,uBAAuB,CAAC,UAAU,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;QACvE,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,IAAI,EAAE,CAAC,EAAE,CAAC;YACtE,uBAAuB,CAAC,KAAK,EAAE,YAAY,IAAI,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,MAAM,cAAc,GAAG,UAAU,CAAC,aAAa,EAAE,eAAe,CAAC;QACjE,MAAM,QAAQ,GAAG,iBAAiB,CAChC,UAAU,CAAC,QAAQ;eAChB,CAAC,cAAc;gBAChB,CAAC,CAAC;oBACE,KAAK,EAAE,cAAc,CAAC,KAAK;oBAC3B,MAAM,EAAE,cAAc,CAAC,MAAM;oBAC7B,iBAAiB,EAAE,cAAc,CAAC,iBAAiB,IAAI,CAAC;iBACzD;gBACH,CAAC,CAAC,eAAe,CAAC,CACrB,CAAC;QACF,IAAI,CAAC,OAAO,GAAG;YACb,GAAG,UAAU;YACb,aAAa,EAAE;gBACb,GAAG,UAAU,CAAC,aAAa;gBAC3B,IAAI,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;gBACjD,eAAe,EAAE,uBAAuB,CAAC,QAAQ,CAAC;gBAClD,GAAG,CAAC,UAAU,CAAC,QAAQ,EAAE,aAAa;oBACpC,CAAC,CAAC,EAAE,gBAAgB,EAAE,EAAE,MAAM,EAAE,MAAe,EAAE,EAAE;oBACnD,CAAC,CAAC,EAAE,CAAC;aACR;YACD,QAAQ;YACR,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,SAAS;YAC5E,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;SACvE,CAAC;QACF,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAChC,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAEM,OAAO,CAAC,QAAmC;QAChD,IAAI,OAAO,QAAQ,KAAK,UAAU,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QACD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAClC,OAAO,GAAG,EAAE;YACV,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACvC,CAAC,CAAC;IACJ,CAAC;IAEM,QAAQ;QACb,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,QAAQ,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE;YAC9B,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACpE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAChE,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,KAAK,CAAC,mBAAiD,EAAE;QACpE,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;gBAC5D,OAAO;YACT,CAAC;YAED,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YACjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;YAC1B,MAAM,yBAAyB,GAAG,IAAI,eAAe,EAAE,CAAC;YACxD,IAAI,CAAC,yBAAyB,GAAG,yBAAyB,CAAC;YAC3D,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;YACzB,IAAI,CAAC,SAAS,EAAE,CAAC;YAEjB,IAAI,CAAC;gBACH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;gBACtB,CAAC;gBACD,IAAI,yBAAyB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;oBAC7C,MAAM,yBAAyB,CAAC,MAAM,CAAC,MAAM,CAAC;gBAChD,CAAC;gBACD,MAAM,kBAAkB,GAAG,GAAS,EAAE;oBACpC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;wBAC9C,yBAAyB,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC,CAAC;oBAChE,CAAC;gBACH,CAAC,CAAC;gBACF,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;gBACrE,IAAI,CAAC;oBACH,IAAI,CAAC,OAAO,GAAG,MAAM,0BAA0B,CAAC;wBAC9C,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;wBAC3C,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc;wBAC3C,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO;wBAC7B,aAAa,EAAE;4BACb,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa;4BAC7B,QAAQ,EAAE,KAAK;4BACf,MAAM,EAAE,yBAAyB,CAAC,MAAM;yBACzC;qBACF,CAAC,CAAC;gBACL,CAAC;wBAAS,CAAC;oBACT,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;gBAC1D,CAAC;gBACD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;gBACtB,CAAC;gBACD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,qBAAqB,EAAE,CAAC;gBAC3D,MAAM,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAClD,IAAI,CAAC,2BAA2B,GAAG,GAAG,EAAE;oBACtC,IAAI,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;wBACxF,OAAO;oBACT,CAAC;oBACD,MAAM,KAAK,GAAsB;wBAC/B,IAAI,EAAE,sBAAsB;wBAC5B,OAAO,EAAE,mCAAmC;wBAC5C,KAAK,EAAE,IAAI;qBACZ,CAAC;oBACF,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;oBACtB,KAAK,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,YAAY,EAAE,EAAE;wBACtD,IAAI,CAAC,SAAS,CAAC;4BACb,IAAI,EAAE,mCAAmC;4BACzC,OAAO,EAAE,qBAAqB,CAAC,YAAY,CAAC;4BAC5C,KAAK,EAAE,IAAI;yBACZ,CAAC,CAAC;oBACL,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC;gBACF,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,cAAc,EAAE,IAAI,CAAC,2BAA2B,CAAC,CAAC;gBAElE,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;gBACvD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC9B,YAAY,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC;gBACzD,CAAC;gBACD,MAAM,WAAW,GAAG,YAAY,CAAC,CAAC,CAAE,CAAC;gBACrC,IAAI,WAAW,CAAC,GAAG,EAAE,KAAK,aAAa,EAAE,CAAC;oBACxC,MAAM,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACxC,CAAC;gBAED,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;oBAChC,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBAChC,CAAC;gBAED,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAA2C,CAAC;gBACvF,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;gBAC9D,CAAC;gBACD,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,EAAE,CAAC;gBAC/B,MAAM,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;gBACnC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;gBACxB,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,MAAM,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBACrC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC/C,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;oBAC1B,MAAM,KAAK,CAAC;gBACd,CAAC;gBACD,MAAM,UAAU,GAAsB;oBACpC,IAAI,EAAE,cAAc;oBACpB,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;oBACrC,KAAK,EAAE,IAAI;iBACZ,CAAC;gBACF,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;gBAC3B,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;gBACpC,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAChC,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;IAChC,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,eAAwD;QAExD,IAAI,CAAC,eAAe,IAAI,OAAO,eAAe,KAAK,QAAQ,EAAE,CAAC;YAC5D,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;QAC7B,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,eAAe,CAAC;QAC1E,IACE,OAAO,KAAK,KAAK,QAAQ;eACtB,KAAK,CAAC,MAAM,GAAG,CAAC;eAChB,KAAK,CAAC,MAAM,GAAG,GAAG;eAClB,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC;eAC3B,QAAQ,GAAG,CAAC;eACZ,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC;eAC7B,UAAU,GAAG,CAAC;eACd,CAAC,MAAM,CAAC,SAAS,CAAC,gBAAgB,CAAC;eACnC,gBAAgB,GAAG,CAAC,EACvB,CAAC;YACD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;QAC7B,CAAC;QACD,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC9D,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;QAC7B,CAAC;QACD,IACE,gBAAgB,CAAC,KAAK,KAAK,KAAK;eAC7B,gBAAgB,CAAC,UAAU,KAAK,UAAU;eAC1C,gBAAgB,CAAC,gBAAgB,KAAK,gBAAgB,EACzD,CAAC;YACD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;QAC7B,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAClD,IACE,CAAC,GAAG;eACD,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;eAC3B,GAAG,CAAC,UAAU,KAAK,gBAAgB,CAAC,UAAU;eAC9C,IAAI,CAAC,gBAAgB,KAAK,gBAAgB,CAAC,gBAAgB;eAC3D,GAAG,CAAC,UAAU,KAAK,gBAAgB,CAAC,UAAU;eAC9C,gBAAgB,CAAC,UAAU,CAAC,QAAQ,EACvC,CAAC;YACD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACxC,MAAM,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;YACjD,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;QAC7B,CAAC;QAED,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACxC,OAAO;YACL,QAAQ,EAAE,MAAM,IAAI,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;SAC3D,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,SAAS,CACpB,aAA2C,EAAE,EAC7C,mBAAiD,EAAE;QAEnD,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QACxF,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,IAAI,IAAI,CAAC;QAC7C,uBAAuB,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACzD,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC7C,MAAM,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC;YAC7C,IAAI,IAAwC,CAAC;YAC7C,IAAI,GAAuC,CAAC;YAC5C,IAAI,CAAC;gBACH,IAAI,GAAG,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;gBAC/B,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;gBACtB,CAAC;gBACD,GAAG,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gBACpC,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;oBACtB,MAAM,IAAI,CAAC,WAAW,CACpB,GAAG,EACH,KAAK,IAAI,EAAE;wBACT,MAAM,GAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;oBAC5D,CAAC,EACD,MAAM,CACP,CAAC;gBACJ,CAAC;gBAED,IAAI,QAAQ,EAAE,CAAC;oBACb,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACzC,CAAC;qBAAM,CAAC;oBACN,MAAM,iBAAiB,GAAG,mBAAmB;wBAC3C,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC;wBACpC,CAAC,CAAC,SAAS,CAAC;oBACd,IAAI,iBAAiB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;wBAC5D,MAAM,iBAAiB,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;oBAC9C,CAAC;oBACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACnB,CAAC;gBACD,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,IAAI,EAAE,CAAC;oBACT,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAClD,IAAI,EACJ,GAAG,EACH,mBAAmB,CACpB,CAAC;oBACF,IAAI,aAAa,EAAE,CAAC;wBAClB,MAAM,IAAI,cAAc,CACtB,CAAC,KAAK,EAAE,aAAa,CAAC,EACtB,8DAA8D,CAC/D,CAAC;oBACJ,CAAC;gBACH,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,WAAW,CACtB,KAAa,EACb,mBAAiD,EAAE;QAEnD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,IAAI,EAAE;YAC5C,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;QACxC,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,QAAQ,CACnB,KAAa,EACb,mBAAiD,EAAE;QAEnD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,IAAI,EAAE;YAC5C,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACnC,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,CAAC;YAC9C,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACjC,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,CAAC;gBACH,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;oBACzB,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACzB,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IACE,SAAS;uBACN,IAAI,CAAC,MAAM,KAAK,SAAS;uBACzB,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;uBAC3B,GAAG,CAAC,MAAM,KAAK,MAAM,EACxB,CAAC;oBACD,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;gBAClC,CAAC;gBACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,MAAM,KAAK,CAAC;YACd,CAAC;YAED,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC;YACnB,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAEnC,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;gBACxB,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,CAAC;QACH,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,QAAQ,CACnB,UAAuC,EACvC,mBAAiD,EAAE;QAEnD,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,IAAI,CAAC,WAAW,CACpB,GAAG,EACH,KAAK,IAAI,EAAE;gBACT,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,gCAAgC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;YACtF,CAAC,EACD,MAAM,CACP,CAAC;QACJ,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,aAA4C,EAAE,EAC9C,mBAAiD,EAAE;QAEnD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,IAAI,CAAC,WAAW,CACpB,GAAG,EACH,KAAK,IAAI,EAAE;gBACT,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gCAAgC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;YACnF,CAAC,EACD,MAAM,CACP,CAAC;QACJ,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,aAA4C,EAAE,EAC9C,mBAAiD,EAAE;QAEnD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,IAAI,CAAC,WAAW,CACpB,GAAG,EACH,KAAK,IAAI,EAAE;gBACT,MAAM,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gCAAgC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;YACtF,CAAC,EACD,MAAM,CACP,CAAC;QACJ,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,MAAM,CACjB,aAA4C,EAAE,EAC9C,mBAAiD,EAAE;QAEnD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACxD,MAAM,IAAI,CAAC,WAAW,CACpB,GAAG,EACH,KAAK,IAAI,EAAE;gBACT,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gCAAgC,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;YACnF,CAAC,EACD,MAAM,CACP,CAAC;QACJ,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,WAAW,CACtB,WAAiC,EACjC,mBAAiD,EAAE;QAEnD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,WAAW,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACpC,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAC/B,IAAI,CAAC;gBACH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;gBACtB,CAAC;gBACD,MAAM,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC9D,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;gBAChC,IAAI,CAAC,gBAAgB,IAAI,CAAC,CAAC;gBAC3B,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,gBAAgB,CAAC;gBACpD,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,CAAC;oBAAS,CAAC;gBACT,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;oBACtF,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;gBAClC,CAAC;YACH,CAAC;QACH,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,KAA6B;QACtD,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC9D,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,MAAM;YAChC,CAAC,CAAC,YAAY;YACd,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,MAAM;gBACrB,CAAC,CAAC,cAAc;gBAChB,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI;oBACnB,CAAC,CAAC,eAAe;oBACjB,CAAC,CAAC,SAAS,CAAC;QAClB,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;QACD,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;QAC9E,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACzE,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,KAAK,SAAS;YACzC,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,KAAK,SAAS;YAC/C,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE1D,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,IAAI,CAAC,0BAA0B,EAAE;gBAChD,IAAI;gBACJ,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,MAAM;gBACN,OAAO;gBACP,UAAU;gBACV,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC;gBACnD,WAAW,EAAE,OAAO;aACrB,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,8BAA8B,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;YAC5D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,KAA6B;QACtD,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC9D,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;QAC3C,oBAAoB,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAChE,oBAAoB,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAChE,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,IAAI,CAAC,0BAA0B,EAAE;gBAChD,IAAI,EAAE,YAAY;gBAClB,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,CAAC,EAAE,KAAK,CAAC,CAAC;gBACV,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC;gBACnD,WAAW,EAAE,OAAO;aACrB,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,8BAA8B,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;YAC5D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,WAAW,CAAC,KAA2B;QAClD,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC9D,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,MAAM;YAChC,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI;gBACnB,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,SAAS,CAAC;QAChB,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,GAAG,GAAG,qBAAqB,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,SAAS;YACnC,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,KAAK,SAAS;YACnC,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACvD,MAAM,cAAc,GAAG,KAAK,CAAC,cAAc,KAAK,SAAS;YACvD,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,cAAc,EAAE,gBAAgB,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QAC3E,MAAM,qBAAqB,GAAG,KAAK,CAAC,qBAAqB,KAAK,SAAS;YACrE,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,qBAAqB,EAAE,uBAAuB,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QACpF,MAAM,oBAAoB,GAAG,KAAK,CAAC,oBAAoB,KAAK,SAAS;YACnE,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,oBAAoB,EAAE,sBAAsB,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;QAClF,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,KAAK,SAAS;YAC3C,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACtD,uBAAuB,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QACxD,uBAAuB,CAAC,KAAK,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAEpD,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,IAAI,CAAC,wBAAwB,EAAE;gBAC9C,IAAI;gBACJ,GAAG;gBACH,IAAI;gBACJ,IAAI;gBACJ,cAAc;gBACd,qBAAqB;gBACrB,oBAAoB;gBACpB,UAAU,EAAE,KAAK,CAAC,UAAU;gBAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,QAAQ;gBACR,SAAS,EAAE,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,CAAC;aACpD,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,8BAA8B,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;YAC5D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,UAAU,CAAC,KAAkC;QACxD,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC9D,MAAM,IAAI,GAAG,qBAAqB,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC;QACzE,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QACtD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,8BAA8B,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;YAC5D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,aAA0C,EAAE,EAC5C,mBAAiD,EAAE;QAEnD,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,IAAI,MAAM,CAAC;QAC3C,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,KAAK,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,KAAK,SAAS;YAC9C,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAC3D,IAAI,MAAM,KAAK,KAAK,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC9C,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAClE,CAAC;QACD,IAAI,UAAU,IAAI,UAAU,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACpD,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAClD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;YACD,MAAM,QAAQ,GAAG,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YACtC,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;YAC/C,MAAM,IAAI,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC;gBAC7C,IAAI,EAAE,MAAM;gBACZ,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACnE,CAAC,CAAC;YACH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;YACD,MAAM,UAAU,GAAG,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE;gBACnD,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,iBAAiB,CAAC;gBAC9D,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC,iBAAiB,CAAC;aACjE,CAAC,CAAC;YACH,OAAO;gBACL,KAAK,EAAE,WAAW,CAAC,EAAE;gBACrB,gBAAgB;gBAChB,QAAQ;gBACR,MAAM;gBACN,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW;gBACxD,GAAG,UAAU;gBACb,IAAI;aACL,CAAC;QACJ,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,OAAO,CAClB,aAAyC,EAAE,EAC3C,mBAAiD,EAAE;QAEnD,MAAM,aAAa,GAAG,UAAU,CAAC,aAAa,KAAK,SAAS;YAC1D,CAAC,CAAC,KAAK;YACP,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,aAAa,EAAE,eAAe,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;QAC3E,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACpD,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAClD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;YACD,MAAM,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;YACnC,MAAM,qBAAqB,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;gBAC1E,eAAe,EAAE,IAAI;aACtB,CAAC,CAAC;YACH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;YACD,MAAM,MAAM,GAAG;gBACb,QAAQ,WAAW,CAAC,EAAE,EAAE;gBACxB,WAAW,WAAW,CAAC,MAAM,EAAE;gBAC/B,UAAU,WAAW,CAAC,KAAK,EAAE;gBAC7B,QAAQ,WAAW,CAAC,GAAG,EAAE;gBACzB,gBAAgB;aACjB,CAAC;YACF,MAAM,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;YAC1B,IAAI,qBAAqB,GAAG,KAAK,CAAC;YAElC,MAAM,UAAU,GAAG,CACjB,IAAwC,EACxC,KAAa,EACP,EAAE;gBACR,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,IAAI,aAAa,EAAE,CAAC;oBAC7C,qBAAqB,GAAG,IAAI,CAAC;oBAC7B,OAAO;gBACT,CAAC;gBACD,MAAM,OAAO,GAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;oBACd,OAAO,CAAC,IAAI,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;gBAChD,CAAC;gBACD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;oBAC7B,OAAO,CAAC,IAAI,CAAC,UAAU,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC/D,CAAC;gBACD,KAAK,MAAM,QAAQ,IAAI;oBACrB,UAAU;oBACV,UAAU;oBACV,SAAS;oBACT,UAAU;oBACV,UAAU;oBACV,UAAU;oBACV,SAAS;oBACT,SAAS;iBACD,EAAE,CAAC;oBACX,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;oBAC7B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,KAAK,EAAE,CAAC;wBAC3C,OAAO,CAAC,IAAI,CAAC,GAAG,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;oBAC/C,CAAC;gBACH,CAAC;gBACD,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACxE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,IAAI,EAAE,EAAE,CAAC;oBACxC,UAAU,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;oBAC7B,IAAI,qBAAqB,EAAE,CAAC;wBAC1B,MAAM;oBACR,CAAC;gBACH,CAAC;YACH,CAAC,CAAC;YAEF,IAAI,qBAAqB,EAAE,CAAC;gBAC1B,UAAU,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC;YACvC,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;YACzC,CAAC;YAED,MAAM,aAAa,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACvC,MAAM,aAAa,GAAG,aAAa,CAAC,MAAM,GAAG,aAAa;gBACxD,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC;gBACvC,CAAC,CAAC,aAAa,CAAC;YAClB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,OAAO;gBACL,KAAK,EAAE,WAAW,CAAC,EAAE;gBACrB,GAAG,EAAE,WAAW,CAAC,GAAG;gBACpB,KAAK,EAAE,WAAW,CAAC,KAAK;gBACxB,GAAG,EAAE,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC;gBACrC,KAAK;gBACL,IAAI,EAAE,aAAa;gBACnB,SAAS,EAAE,qBAAqB,IAAI,aAAa,CAAC,MAAM,GAAG,aAAa;aACzE,CAAC;QACJ,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,QAAQ,CACnB,aAAqB,EACrB,aAA0C,EAAE,EAC5C,mBAAiD,EAAE;QAEnD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;QACD,MAAM,UAAU,GAAG,qBAAqB,CACtC,aAAa,EACb,YAAY,EACZ,CAAC,EACD,wBAAwB,CACzB,CAAC;QACF,MAAM,eAAe,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC;QACxE,IAAI,eAAe,GAAG,wBAAwB,EAAE,CAAC;YAC/C,MAAM,IAAI,KAAK,CAAC,8BAA8B,wBAAwB,cAAc,CAAC,CAAC;QACxF,CAAC;QACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,0BAA0B,CAAC,UAAU,CAAC,CAAC;QACtE,MAAM,YAAY,GAAG,EAAE,IAAI,CAAC,kBAAkB,CAAC;QAC/C,MAAM,eAAe,GAAG,yBAAyB,YAAY,EAAE,CAAC;QAChE,MAAM,oBAAoB,GAAG,IAAI,CAAC,0BAA0B,CAC1D,UAAU,EACV,iBAAiB,EACjB,eAAe,CAChB,CAAC;QAEF,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACpD,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACrD,IAAI,kBAAsC,CAAC;YAC3C,IAAI,mBAA8C,CAAC;YACnD,IAAI,kBAA6C,CAAC;YAClD,IAAI,aAAwD,CAAC;YAC7D,IAAI,kBAAkB,GAAG,KAAK,CAAC;YAC/B,MAAM,mBAAmB,GAAG,GAAS,EAAE;gBACrC,kBAAkB,KAAK,UAAU,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC7F,CAAC,CAAC;YACF,MAAM,gBAAgB,GAAG,GAAS,EAAE;gBAClC,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;oBACrC,OAAO;gBACT,CAAC;gBACD,mBAAmB,KAAK,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE;oBAC1D,UAAU,EAAE,cAAc,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG;oBACtG,SAAS,EAAE,kBAAkB;oBAC7B,aAAa,EAAE,IAAI;oBACnB,YAAY,EAAE,KAAK;oBACnB,qBAAqB,EAAE,KAAK;oBAC5B,WAAW,EAAE,KAAK;oBAClB,aAAa,EAAE,IAAI;iBACpB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YAC3B,CAAC,CAAC;YACF,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACnE,IAAI,eAAwB,CAAC;YAC7B,IAAI,gBAAgB,GAAG,KAAK,CAAC;YAC7B,IAAI,CAAC;gBACH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC;gBACrC,CAAC;gBACD,kBAAkB,GAAG,GAAG,CAAC,4BAA4B,CAAC;gBACtD,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;oBACrC,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBACrE,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;wBACnB,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC;oBACrC,CAAC;oBACD,MAAM,aAAa,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,0BAA0B,EAAE;wBACtE,OAAO,EAAE,iBAAiB,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;wBAC7C,SAAS,EAAE,2BAA2B;wBACtC,mBAAmB,EAAE,KAAK;qBAC3B,CAAC,CAAC;oBACH,kBAAkB,GAAG,aAAa,CAAC,kBAAkB,CAAC;oBACtD,GAAG,CAAC,4BAA4B,GAAG,kBAAkB,CAAC;gBACxD,CAAC;gBACD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC;gBACrC,CAAC;gBACD,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE;oBAClE,UAAU,EAAE,IAAI,CAAC,mCAAmC,EAAE;oBACtD,SAAS,EAAE,kBAAkB;oBAC7B,aAAa,EAAE,IAAI;oBACnB,YAAY,EAAE,IAAI;oBAClB,qBAAqB,EAAE,KAAK;oBAC5B,WAAW,EAAE,KAAK;oBAClB,aAAa,EAAE,IAAI;iBACpB,CAAC,CAAC;gBACH,IAAI,iBAAiB,CAAC,gBAAgB,EAAE,CAAC;oBACvC,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBACpF,CAAC;gBACD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC;gBACrC,CAAC;gBACD,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;oBAC9B,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,mBAAmB,EAAE,CAAC;gBACxB,CAAC,EAAE,iBAAiB,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC;gBACtC,MAAM,kBAAkB,GAAG,MAAM,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE;oBACnE,UAAU,EAAE,oBAAoB;oBAChC,SAAS,EAAE,kBAAkB;oBAC7B,aAAa,EAAE,IAAI;oBACnB,YAAY,EAAE,IAAI;oBAClB,OAAO,EAAE,iBAAiB,CAAC,SAAS,GAAG,GAAG;oBAC1C,qBAAqB,EAAE,KAAK;oBAC5B,WAAW,EAAE,KAAK;oBAClB,aAAa,EAAE,IAAI;oBACnB,2BAA2B,EAAE,IAAI;iBAClC,CAAC,CAAC;gBACH,IAAI,kBAAkB,EAAE,CAAC;oBACvB,MAAM,IAAI,KAAK,CAAC,8BAA8B,iBAAiB,CAAC,SAAS,IAAI,CAAC,CAAC;gBACjF,CAAC;gBACD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,MAAM,oBAAoB,CAAC,MAAM,CAAC,CAAC;gBACrC,CAAC;gBACD,IAAI,kBAAkB,CAAC,gBAAgB,EAAE,CAAC;oBACxC,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,CAAC,CAAC;gBACrF,CAAC;gBACD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,MAAM,CAAC,KAAwC,CAAC;gBACpF,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,OAAO,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;oBAClF,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;gBACpE,CAAC;gBACD,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;oBACjB,MAAM,IAAI,KAAK,CACb,OAAO,QAAQ,CAAC,KAAK,KAAK,QAAQ;wBAChC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;wBAChC,CAAC,CAAC,mBAAmB,CACxB,CAAC;gBACJ,CAAC;gBACD,IAAI,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACtC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;gBAChE,CAAC;gBACD,IAAI,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,UAAU,GAAG,iBAAiB,CAAC,cAAc,EAAE,CAAC;oBAC1F,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;gBAC/E,CAAC;gBACD,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAA0B,CAAC;YAC5D,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,eAAe,GAAG,KAAK,CAAC;gBACxB,gBAAgB,GAAG,IAAI,CAAC;gBACxB,MAAM,KAAK,CAAC;YACd,CAAC;oBAAS,CAAC;gBACT,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;gBACtD,IAAI,aAAa,EAAE,CAAC;oBAClB,YAAY,CAAC,aAAa,CAAC,CAAC;gBAC9B,CAAC;gBACD,MAAM,aAAa,GAAc,EAAE,CAAC;gBACpC,IAAI,mBAAmB,EAAE,CAAC;oBACxB,IAAI,CAAC;wBACH,MAAM,mBAAmB,CAAC;oBAC5B,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBACD,IAAI,kBAAkB,EAAE,CAAC;oBACvB,IAAI,CAAC;wBACH,MAAM,kBAAkB,CAAC;oBAC3B,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBACD,IAAI,kBAAkB,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;oBAC7D,IAAI,CAAC;wBACH,MAAM,UAAU,CAAC,IAAI,CAAC,kBAAkB,EAAE;4BACxC,UAAU,EAAE,cAAc,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG;4BACvG,SAAS,EAAE,kBAAkB;4BAC7B,aAAa,EAAE,IAAI;4BACnB,YAAY,EAAE,KAAK;4BACnB,qBAAqB,EAAE,KAAK;4BAC5B,WAAW,EAAE,KAAK;4BAClB,aAAa,EAAE,IAAI;yBACpB,CAAC,CAAC;oBACL,CAAC;oBAAC,MAAM,CAAC;wBACP,+EAA+E;oBACjF,CAAC;gBACH,CAAC;gBACD,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;oBACzB,IAAI,CAAC;wBACH,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC;oBAC5B,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;gBACD,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,MAAM,IAAI,cAAc,CACtB,gBAAgB,CAAC,CAAC,CAAC,CAAC,eAAe,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,aAAa,EACtE,mCAAmC,CACpC,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,KAAK,CAChB,UAAoC,EACpC,mBAAiD,EAAE;QAEnD,MAAM,QAAQ,GAAG,qBAAqB,CACpC,UAAU,CAAC,QAAQ,EACnB,UAAU,EACV,CAAC,EACD,iBAAiB,CAClB,CAAC;QACF,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAC3D,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACnD,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACnF,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,KAAK,SAAS;YACpD,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,eAAe,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YACzD,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YAC/D,MAAM,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC;gBAC/D,MAAM,EAAE,UAAU,CAAC,MAAM;gBACzB,KAAK,EAAE,UAAU;gBACjB,MAAM;aACP,CAAC,CAAC;YACH,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YACjC,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,UAAmC,EACnC,mBAAiD,EAAE;QAEnD,MAAM,QAAQ,GAAG,qBAAqB,CACpC,UAAU,CAAC,QAAQ,EACnB,UAAU,EACV,CAAC,EACD,iBAAiB,CAClB,CAAC;QACF,MAAM,IAAI,GAAG,qBAAqB,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC;QAC9E,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAC3D,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YACzD,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YAC/D,MAAM,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YAClF,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YACjC,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEM,KAAK,CAAC,KAAK,CAChB,UAAoC,EACpC,mBAAiD,EAAE;QAEnD,MAAM,QAAQ,GAAG,qBAAqB,CACpC,UAAU,CAAC,QAAQ,EACnB,UAAU,EACV,CAAC,EACD,iBAAiB,CAClB,CAAC;QACF,MAAM,GAAG,GAAG,qBAAqB,CAAC,UAAU,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAChE,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAC3D,OAAO,IAAI,CAAC,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAClD,MAAM,GAAG,GAAG,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YACzD,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC;YAC/D,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE;gBAC7D,OAAO,EAAE,IAAI;gBACb,OAAO;gBACP,MAAM;aACP,CAAC,CAAC;YACH,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,wCAAwC,QAAQ,EAAE,CAAC,CAAC;YACtE,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,KAAK,CAAC,GAAiC,CAAC,CAAC;YACzD,CAAC;oBAAS,CAAC;gBACT,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,CAAC;YACD,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YACjC,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC,EAAE,gBAAgB,CAAC,CAAC;IACvB,CAAC;IAEO,sBAAsB,CAC5B,SAA8C,EAC9C,mBAAiD,EAAE;QAEnD,MAAM,YAAY,GAAG,gBAAgB,CAAC,MAAM,CAAC;QAC7C,IACE,YAAY,KAAK,SAAS;eACvB,CACD,OAAO,YAAY,KAAK,QAAQ;mBAC7B,OAAO,YAAY,CAAC,gBAAgB,KAAK,UAAU;mBACnD,OAAO,YAAY,CAAC,mBAAmB,KAAK,UAAU,CAC1D,EACD,CAAC;YACD,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC,CAAC;QACrF,CAAC;QACD,IAAI,YAAY,EAAE,OAAO,EAAE,CAAC;YAC1B,OAAO,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC,CAAC;QAC5D,CAAC;QACD,IACE,IAAI,CAAC,MAAM,KAAK,UAAU;eACvB,IAAI,CAAC,mBAAmB;eACxB,CAAC,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,gBAAgB,CAAC,EACvD,CAAC;YACD,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,IAAI,CAAC,wBAAwB,IAAI,yBAAyB,EAAE,CAAC;YAC/D,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC,CAAC;QACjF,CAAC;QACD,IAAI,CAAC,wBAAwB,IAAI,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,sBAAsB,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;IAC/E,CAAC;IAEO,wBAAwB,CAC9B,SAAiD,EACjD,QAAQ,GAAG,KAAK;QAEhB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC5D,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,CAAC,0BAA0B,IAAI,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IACtE,CAAC;IAEO,sBAAsB,CAC5B,IAA0B,EAC1B,SAA8C,EAC9C,QAAQ,GAAG,KAAK,EAChB,YAA0B;QAE1B,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,MAAM,eAAe,GAAqB;gBACxC,IAAI;gBACJ,KAAK,EAAE,QAAQ;gBACf,UAAU,EAAE,IAAI,eAAe,EAAE;gBACjC,GAAG,EAAE,SAAS;gBACd,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,KAAU,CAAC;gBACvC,MAAM;gBACN,gBAAgB,EAAE,KAAK;aACxB,CAAC;YACF,IAAI,YAAY,EAAE,CAAC;gBACjB,MAAM,aAAa,GAAG,GAAS,EAAE;oBAC/B,MAAM,WAAW,GAAG,oBAAoB,CAAC,YAAY,CAAC,CAAC;oBACvD,IAAI,eAAe,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;wBACvC,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;wBACpE,IAAI,cAAc,IAAI,CAAC,EAAE,CAAC;4BACxB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;wBAChD,CAAC;wBACD,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;wBAC9C,eAAe,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;wBACpC,IAAI,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC;wBAC9C,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC7B,CAAC;yBAAM,IAAI,eAAe,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;wBAC9C,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;oBAChD,CAAC;gBACH,CAAC,CAAC;gBACF,YAAY,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;gBACtE,eAAe,CAAC,yBAAyB,GAAG,GAAG,EAAE;oBAC/C,YAAY,CAAC,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;gBAC3D,CAAC,CAAC;gBACF,IAAI,YAAY,CAAC,OAAO,EAAE,CAAC;oBACzB,aAAa,EAAE,CAAC;gBAClB,CAAC;YACH,CAAC;YACD,IAAI,eAAe,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;gBACvC,OAAO;YACT,CAAC;YACD,IAAI,QAAQ,EAAE,CAAC;gBACb,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;YAC/C,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;YAC5C,CAAC;YACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,mBAAmB;QACzB,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QACD,MAAM,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QACpD,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,eAAe,CAAC,KAAK,GAAG,QAAQ,CAAC;QACjC,KAAK,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YAChE,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;YACjC,IAAI,CAAC,SAAS,CAAC;gBACb,IAAI,EAAE,4BAA4B;gBAClC,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;gBACrC,KAAK,EAAE,IAAI;aACZ,CAAC,CAAC;YACH,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAAC,eAAiC;QACpE,IAAI,CAAC;YACH,IAAI,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBAC9C,MAAM,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;YACjD,CAAC;YACD,MAAM,KAAK,GAAG,MAAM,eAAe,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC3E,IAAI,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBAC9C,MAAM,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC;YACjD,CAAC;YACD,eAAe,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAChC,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC;YAC9C,IAAI,IAAI,CAAC,eAAe,KAAK,eAAe,EAAE,CAAC;gBAC7C,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;YACnC,CAAC;YACD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;YAC9B,IACE,IAAI,CAAC,MAAM,KAAK,SAAS;mBACtB,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,UAAU,CAAC,EAC1E,CAAC;gBACD,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;YACnC,CAAC;YACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;IAEO,uBAAuB,CAAC,eAAiC;QAC/D,IAAI,eAAe,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YACxC,OAAO;QACT,CAAC;QACD,eAAe,CAAC,KAAK,GAAG,SAAS,CAAC;QAClC,eAAe,CAAC,yBAAyB,EAAE,EAAE,CAAC;QAC9C,eAAe,CAAC,yBAAyB,GAAG,SAAS,CAAC;QACtD,IAAI,eAAe,CAAC,gBAAgB,EAAE,CAAC;YACrC,OAAO;QACT,CAAC;QACD,eAAe,CAAC,gBAAgB,GAAG,IAAI,CAAC;QACxC,IAAI,eAAe,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACtC,IAAI,CAAC,wBAAwB,IAAI,CAAC,CAAC;QACrC,CAAC;aAAM,IAAI,eAAe,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC/C,IAAI,CAAC,0BAA0B,IAAI,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAEO,sBAAsB,CAAC,KAAY;QACzC,KAAK,MAAM,eAAe,IAAI,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAC5D,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACxC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC9B,IAAI,CAAC,uBAAuB,CAAC,eAAe,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,oBAA6B;QACjD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC5D,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;YACzB,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC;QACD,MAAM,aAAa,GAAG,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QAClE,IACE,oBAAoB;eACjB,IAAI,CAAC,eAAe;eACpB,IAAI,CAAC,eAAe,CAAC,IAAI,KAAK,UAAU,EAC3C,CAAC;YACD,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QACvD,CAAC;QACD,IAAI,IAAI,CAAC,yBAAyB,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACrF,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QACtD,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,CAAC;IAC7C,CAAC;IAEO,eAAe,CAAC,KAAyB;QAC/C,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC,eAAe,CAAC;QAC9B,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACzB,MAAM,eAAe,GAAG,IAAI,CAAC,sBAAsB,CACjD,UAAU,EACV,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EACpC,IAAI,CACL,CAAC;QACF,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,KAAK,eAAe,CAAC,IAAI,CACvB,GAAG,EAAE;YACH,IAAI,IAAI,CAAC,eAAe,KAAK,eAAe,EAAE,CAAC;gBAC7C,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;YACnC,CAAC;QACH,CAAC,EACD,GAAG,EAAE;YACH,IAAI,IAAI,CAAC,eAAe,KAAK,eAAe,EAAE,CAAC;gBAC7C,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;YACnC,CAAC;QACH,CAAC,CACF,CAAC;QACF,OAAO,eAAe,CAAC;IACzB,CAAC;IAEO,iBAAiB,CACvB,SAAiD,EACjD,SAAiB,EACjB,KAAc,EACd,QAAQ,GAAG,KAAK;QAEhB,IAAI,IAAI,CAAC,0BAA0B,IAAI,2BAA2B,EAAE,CAAC;YACnE,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;YACpF,MAAM,gBAAgB,GAAsB;gBAC1C,IAAI,EAAE,+BAA+B;gBACrC,OAAO,EAAE,UAAU,CAAC,OAAO;gBAC3B,KAAK,EAAE,QAAQ;gBACf,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC5B,CAAC;YACF,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;YACjC,IAAI,QAAQ,EAAE,CAAC;gBACb,KAAK,IAAI,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;oBAC1D,IAAI,CAAC,SAAS,CAAC;wBACb,IAAI,EAAE,gCAAgC;wBACtC,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;wBACrC,KAAK,EAAE,IAAI;qBACZ,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACL,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,KAAK,IAAI,CAAC,wBAAwB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACtE,IACE,IAAI,CAAC,MAAM,KAAK,SAAS;mBACtB,IAAI,CAAC,MAAM,KAAK,UAAU;mBAC1B,IAAI,CAAC,mBAAmB,EAC3B,CAAC;gBACD,OAAO;YACT,CAAC;YACD,IAAI,CAAC,SAAS,CAAC;gBACb,IAAI,EAAE,SAAS;gBACf,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;gBACrC,KAAK,EAAE,KAAK;gBACZ,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC5B,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,SAAS,CAAC,KAAwB;QACxC,KAAK,MAAM,QAAQ,IAAI,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;YAChD,IAAI,CAAC;gBACH,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;YAAC,MAAM,CAAC;gBACP,oEAAoE;YACtE,CAAC;QACH,CAAC;IACH,CAAC;IAEO,SAAS;QACf,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE;SACvB,CAAC,CAAC;IACL,CAAC;IAEO,SAAS,CAAC,KAAwB;QACxC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YAChB,IAAI,CAAC,SAAS,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,SAAS,CAAC;YACb,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE;SACpB,CAAC,CAAC;QACH,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAEO,cAAc,CAAC,GAA2B;QAChD,OAAO;YACL,EAAE,EAAE,GAAG,CAAC,EAAE;YACV,GAAG,EAAE,GAAG,CAAC,GAAG;YACZ,KAAK,EAAE,GAAG,CAAC,KAAK;YAChB,MAAM,EAAE,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;YACnC,MAAM,EAAE,GAAG,CAAC,MAAM;YAClB,UAAU,EAAE,GAAG,CAAC,UAAU;YAC1B,uBAAuB,EAAE,GAAG,CAAC,uBAAuB;YACpD,SAAS,EAAE,GAAG,CAAC,SAAS;SACzB,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,YAAY,CAAC,KAAyB;QAClD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC;QACzB,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC,SAAS,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,IAAI,CAAC,yBAAyB,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACrF,IAAI,CAAC,yBAAyB,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC,CAAC;QACpF,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC7B,IAAI,OAAO,IAAI,IAAI,CAAC,2BAA2B,EAAE,CAAC;YAChD,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,2BAA2B,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,CAAC,2BAA2B,GAAG,SAAS,CAAC;QAE7C,MAAM,cAAc,GAAc,EAAE,CAAC;QACrC,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;YAC1C,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC;YACnB,MAAM,kBAAkB,GAAG,GAAG,CAAC,kBAAkB,CAAC;YAClD,GAAG,CAAC,kBAAkB,GAAG,SAAS,CAAC;YACnC,IAAI,kBAAkB,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;gBACvD,IAAI,CAAC;oBACH,MAAM,kBAAkB,CAAC,MAAM,EAAE,CAAC;gBACpC,CAAC;gBAAC,MAAM,CAAC;oBACP,qFAAqF;gBACvF,CAAC;YACH,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACjC,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACpC,CAAC;YACD,IAAI,CAAC;gBACH,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAChC,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QACD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,uBAAuB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;QACjD,CAAC;QAAC,OAAO,YAAY,EAAE,CAAC;YACtB,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACpC,CAAC;QAED,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;YACxB,CAAC;YAAC,OAAO,UAAU,EAAE,CAAC;gBACpB,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,IAAI,CAAC,yBAAyB,GAAG,SAAS,CAAC;QAC3C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;QACxB,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YACxC,MAAM,IAAI,cAAc,CAAC,cAAc,EAAE,4CAA4C,CAAC,CAAC;QACzF,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,wBAAwB,CACpC,OAAkC;QAElC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,eAAe,EAAE,CAAC;YAC5C,OAAO;QACT,CAAC;QACD,MAAM,UAAU,GAAG,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;QAC7D,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,IAAI,CAAC,0BAA0B,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;QACzE,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;gBACzB,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC;YAC5B,CAAC;QACH,CAAC;IACH,CAAC;IAEO,qBAAqB;QAC3B,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QACD,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAEO,UAAU,CAAC,KAAa;QAC9B,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,gBAAgB,KAAK,EAAE,CAAC,CAAC;QAC3C,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,gBAAgB;QACtB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACnD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAC1D,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC9C,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,gBAAgB,CAAC,KAAc;QACrC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACrE,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,oBAAoB,CAAC,KAAc;QACzC,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAEO,KAAK,CAAC,iBAAiB,CAAC,GAA2B;QACzD,IAAI,GAAG,CAAC,uBAAuB,KAAK,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1D,OAAO;QACT,CAAC;QACD,MAAM,uBAAuB,GAAG,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC;QAC7E,IAAI,uBAAuB,EAAE,CAAC;YAC5B,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACjC,CAAC;QACD,IAAI,CAAC;YACH,MAAM,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;YACnE,GAAG,CAAC,uBAAuB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QACtD,CAAC;gBAAS,CAAC;YACT,IACE,uBAAuB;mBACpB,IAAI,CAAC,MAAM,KAAK,SAAS;mBACzB,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;mBAC3B,GAAG,CAAC,MAAM,KAAK,MAAM;mBACrB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EACvB,CAAC;gBACD,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,YAAY,CAAC,IAA4B;QACrD,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClD,IAAI,aAAa,EAAE,CAAC;YAClB,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QACxC,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,GAAG,GAA2B;YAClC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE;YAC/B,IAAI;YACJ,GAAG,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC;YAC/B,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,MAAM;YACd,UAAU,EAAE,CAAC;YACb,uBAAuB,EAAE,CAAC;YAC1B,SAAS,EAAE,KAAK;YAChB,iBAAiB,EAAE,IAAI;YACvB,oBAAoB,EAAE,KAAK;YAC3B,OAAO,EAAE,KAAK;YACd,iBAAiB,EAAE,KAAK;YACxB,kBAAkB,EAAE,KAAK;YACzB,sBAAsB,EAAE,KAAK;YAC7B,eAAe,EAAE,EAAE;SACpB,CAAC;QACF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QAC3B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QACpC,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,gBAAgB,EAAE,CAAC;gBAC5C,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACzD,GAAG,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;gBAC5C,MAAM,kBAAkB,CAAC,IAAI,CAAC,aAAa,EAAE;oBAC3C,4BAA4B,EAAE,IAAI;iBACnC,CAAC,CAAC;gBACH,MAAM,kBAAkB,CAAC,IAAI,CAAC,oCAAoC,EAAE;oBAClE,OAAO,EAAE,IAAI;oBACb,MAAM,EAAE,IAAI;iBACb,CAAC,CAAC;YACL,CAAC;YACD,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAE3B,MAAM,OAAO,GAAG,CAAC,KAAoC,EAAQ,EAAE;gBAC7D,IACE,CAAC,KAAK;uBACH,IAAI,CAAC,mBAAmB;uBACxB,IAAI,CAAC,MAAM,KAAK,SAAS;uBACzB,IAAI,CAAC,MAAM,KAAK,UAAU,EAC7B,CAAC;oBACD,OAAO;gBACT,CAAC;gBACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;oBAC1D,IAAI,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;wBACrB,OAAO;oBACT,CAAC;oBACD,MAAM,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC;oBAC7C,IAAI,QAA4C,CAAC;oBACjD,IAAI,CAAC;wBACH,QAAQ,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;wBAC1C,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;oBAC9C,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAClD,KAAK,EACL,QAAQ,EACR,mBAAmB,CACpB,CAAC;wBACF,IAAI,aAAa,EAAE,CAAC;4BAClB,MAAM,IAAI,cAAc,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,EAAE,oCAAoC,CAAC,CAAC;wBACzF,CAAC;wBACD,MAAM,KAAK,CAAC;oBACd,CAAC;gBACH,CAAC,EAAE,2BAA2B,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;gBACxC,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACvB,MAAM,UAAU,GAAsB;wBACpC,IAAI,EAAE,sCAAsC;wBAC5C,OAAO,EAAE,+DAA+D;wBACxE,KAAK,EAAE,IAAI;wBACX,KAAK,EAAE,GAAG,CAAC,EAAE;qBACd,CAAC;oBACF,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;oBAC3B,KAAK,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,aAAa,EAAE,EAAE;wBAC5D,IAAI,CAAC,SAAS,CAAC;4BACb,IAAI,EAAE,iCAAiC;4BACvC,OAAO,EAAE,qBAAqB,CAAC,aAAa,CAAC;4BAC7C,KAAK,EAAE,IAAI;4BACX,KAAK,EAAE,GAAG,CAAC,EAAE;yBACd,CAAC,CAAC;oBACL,CAAC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC,CAAC;YACF,MAAM,gBAAgB,GAAG,CAAC,KAA8B,EAAQ,EAAE;gBAChE,IAAI,KAAK,KAAK,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;oBAC9C,OAAO;gBACT,CAAC;gBACD,GAAG,CAAC,4BAA4B,GAAG,SAAS,CAAC;gBAC7C,MAAM,eAAe,GAAG,CAAC,GAAG,CAAC,oBAAoB,CAAC;gBAClD,IAAI,eAAe,EAAE,CAAC;oBACpB,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;oBAC7B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC9C,CAAC;gBACD,IAAI,CAAC,qBAAqB,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;YACnD,CAAC,CAAC;YACF,MAAM,MAAM,GAAG,GAAS,EAAE;gBACxB,IAAI,CAAC,qBAAqB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACzC,CAAC,CAAC;YACF,MAAM,OAAO,GAAG,GAAS,EAAE;gBACzB,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;gBAC7B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC5C,IAAI,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC5C,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;oBAChC,MAAM,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,CAAC;gBAC5C,CAAC,EAAE,2BAA2B,EAAE,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YAChD,CAAC,CAAC;YACF,MAAM,OAAO,GAAG,CAAC,KAAY,EAAQ,EAAE;gBACrC,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;gBAC7B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC5C,IAAI,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC5C,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;oBAChC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;wBACvD,OAAO;oBACT,CAAC;oBACD,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;oBAC/B,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;oBACvB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,CAAC;oBAC9C,IAAI,SAAS,EAAE,CAAC;wBACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;oBAC1B,CAAC;oBACD,IAAI,CAAC,SAAS,CAAC;wBACb,IAAI,EAAE,cAAc;wBACpB,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;wBACrC,KAAK,EAAE,KAAK;wBACZ,KAAK,EAAE,GAAG,CAAC,EAAE;qBACd,CAAC,CAAC;oBACH,IAAI,SAAS,EAAE,CAAC;wBACd,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;oBACtC,CAAC;gBACH,CAAC,EAAE,2BAA2B,EAAE,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YAChD,CAAC,CAAC;YACF,MAAM,WAAW,GAAG,CAAC,KAAc,EAAQ,EAAE;gBAC3C,IAAI,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBAC5C,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,YAAY;oBAClB,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;oBACrC,KAAK,EAAE,KAAK;oBACZ,KAAK,EAAE,GAAG,CAAC,EAAE;iBACd,CAAC,CAAC;YACL,CAAC,CAAC;YAEF,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC1B,IAAI,CAAC,EAAE,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;YAC5C,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACxB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC1B,IAAI,CAAC,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;YAClC,GAAG,CAAC,eAAe,CAAC,IAAI,CACtB,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,EAClD,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,EAChC,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CACzC,CAAC;YACF,OAAO,GAAG,CAAC;QACb,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,GAAG,CAAC,kBAAkB,IAAI,CAAC,GAAG,CAAC,kBAAkB,CAAC,QAAQ,EAAE,CAAC;gBAC/D,IAAI,CAAC;oBACH,MAAM,GAAG,CAAC,kBAAkB,CAAC,MAAM,EAAE,CAAC;gBACxC,CAAC;gBAAC,MAAM,CAAC;oBACP,6DAA6D;gBAC/D,CAAC;YACH,CAAC;YACD,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC/B,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,mBAAmB,CAAC,GAA2B;QACrD,KAAK,MAAM,cAAc,IAAI,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3D,cAAc,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAEO,8BAA8B,CAAC,KAAa;QAClD,KAAK,IAAI,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YAClF,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC3D,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,yBAAyB;oBAC/B,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;oBACrC,KAAK,EAAE,KAAK;oBACZ,KAAK;iBACN,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,qBAAqB,CAC3B,GAA2B,EAC3B,eAAwB;QAExB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;YAC1C,OAAO;QACT,CAAC;QACD,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC9B,GAAG,CAAC,sBAAsB,KAAK,eAAe,CAAC;QAC/C,IAAI,GAAG,CAAC,iBAAiB,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QACD,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC7B,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;YACrD,IAAI,CAAC;gBACH,MAAM,qBAAqB,GAAG,GAAG,CAAC,sBAAsB,CAAC;gBACzD,GAAG,CAAC,kBAAkB,GAAG,KAAK,CAAC;gBAC/B,GAAG,CAAC,sBAAsB,GAAG,KAAK,CAAC;gBACnC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;oBAC1C,OAAO;gBACT,CAAC;gBACD,IAAI,qBAAqB,IAAI,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC;oBACzD,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;gBACjC,CAAC;gBACD,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;gBAC3B,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,IACE,qBAAqB;uBAClB,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;uBAC3B,IAAI,CAAC,MAAM,KAAK,SAAS;uBACzB,GAAG,CAAC,MAAM,KAAK,MAAM,EACxB,CAAC;oBACD,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;gBAClC,CAAC;YACH,CAAC;oBAAS,CAAC;gBACT,GAAG,CAAC,iBAAiB,GAAG,KAAK,CAAC;gBAC9B,IACE,GAAG,CAAC,kBAAkB;uBACnB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;uBACrB,IAAI,CAAC,MAAM,KAAK,SAAS;uBACzB,CAAC,GAAG,CAAC,OAAO,EACf,CAAC;oBACD,IAAI,CAAC,qBAAqB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC;QACH,CAAC,EAAE,0BAA0B,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QACvC,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,GAAG,CAAC,iBAAiB,GAAG,KAAK,CAAC;QAChC,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAC/B,IAA4B,EAC5B,GAAuC,EACvC,mBAAkC;QAElC,MAAM,cAAc,GAAc,EAAE,CAAC;QACrC,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YACjC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;YACD,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC;QACrB,CAAC;QACD,IAAI,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;gBACrB,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QACnC,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,UAAU,EAAE,CAAC;gBACf,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;gBAC9B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACzB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACrC,CAAC;iBAAM,CAAC;gBACN,GAAG,CAAC,OAAO,GAAG,KAAK,CAAC;gBACpB,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;gBAC7B,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC/B,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,aAAa,GAAsB;oBACvC,IAAI,EAAE,gCAAgC;oBACtC,OAAO,EAAE,8DAA8D;oBACvE,KAAK,EAAE,IAAI;iBACZ,CAAC;gBACF,IAAI,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;oBAC3D,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;gBAChC,CAAC;gBACD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;gBAChC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC1B,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC5B,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,iBAAiB,GAAG,mBAAmB;YAC3C,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC;YACpC,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,WAAW,GAAG,iBAAiB,EAAE,EAAE,IAAI,IAAI,CAAC;QACjD,IACE,iBAAiB;eACd,iBAAiB,CAAC,MAAM,KAAK,MAAM;eACnC,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,EACrC,CAAC;YACD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;gBAChD,MAAM,iBAAiB,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC5C,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,CAAC;oBAC9D,MAAM,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QACD,IAAI,CAAC,SAAS,EAAE,CAAC;QACjB,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,IAAI,cAAc,CAAC,cAAc,EAAE,+BAA+B,CAAC,CAAC;IAC7E,CAAC;IAEO,KAAK,CAAC,yBAAyB,CAAC,GAA2B;QACjE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3B,OAAO;QACT,CAAC;QACD,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;QAC9B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACzB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEnC,IAAI,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC;YAChC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACxB,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACtC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,KAAa;QAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,IAAI,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC;YACjD,MAAM,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAClF,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QACxC,CAAC;QACD,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;YAClC,MAAM,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC9B,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAC9B,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;gBAC9E,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;gBACzC,MAAM,UAAU,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;gBACrC,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;oBACvD,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,sBAAsB;QAClC,MAAM,eAAe,GAAG,IAAI,GAAG,EAAU,CAAC;QAC1C,OAAO,IAAI,EAAE,CAAC;YACZ,MAAM,cAAc,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAC3D,CAAC,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;mBACzB,GAAG,CAAC,MAAM,KAAK,MAAM;mBACrB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CACxB,CAAC,CAAC;YACH,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;gBACxB,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;gBAChC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC1B,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC1B,OAAO;YACT,CAAC;YAED,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;YACvC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,mBAAmB,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;gBAClD,OAAO;YACT,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;gBACxB,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,mCAAmC;oBACzC,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;oBACrC,KAAK,EAAE,KAAK;oBACZ,KAAK,EAAE,cAAc,CAAC,EAAE;iBACzB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,WAAW,CACvB,GAA2B,EAC3B,UAA+B,EAC/B,MAAmB;QAEnB,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,CAAC;QAC7C,GAAG,CAAC,4BAA4B,GAAG,SAAS,CAAC;QAC7C,GAAG,CAAC,oBAAoB,GAAG,IAAI,CAAC;QAChC,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACjC,CAAC;QACD,IAAI,CAAC;YACH,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,MAAM,MAAM,CAAC,MAAM,CAAC;YACtB,CAAC;YACD,MAAM,UAAU,EAAE,CAAC;QACrB,CAAC;gBAAS,CAAC;YACT,GAAG,CAAC,oBAAoB,GAAG,KAAK,CAAC;YACjC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;gBAClD,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;gBAC3B,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,IACE,QAAQ;uBACL,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;uBAC3B,IAAI,CAAC,MAAM,KAAK,SAAS;uBACzB,GAAG,CAAC,MAAM,KAAK,MAAM,EACxB,CAAC;oBACD,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;gBAClC,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEO,gCAAgC,CACtC,OAAsC,EACtC,MAAmB;QAEnB,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;YACvD,SAAS,EAAE,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,SAAS,CAAC;YACpD,MAAM;SACP,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,UAAU,CAAC,GAA2B;QAClD,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACxB,OAAO;QACT,CAAC;QACD,GAAG,CAAC,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC;YACH,GAAG,CAAC,KAAK,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;gBACzC,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,eAAe,CAAC,GAA2B;QACvD,IACE,IAAI,CAAC,MAAM,KAAK,SAAS;eACtB,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;eAC3B,GAAG,CAAC,MAAM,KAAK,MAAM;eACrB,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE;eACnB,GAAG,CAAC,SAAS,EAChB,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QAElC,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACrD,MAAM,UAAU,GAAG,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC;QACtC,MAAM,aAAa,GAA6B,CAAC,KAAK,EAAE,EAAE;YACxD,IAAI,CAAC,qBAAqB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;QACjE,CAAC,CAAC;QACF,MAAM,aAAa,GAAG,UAAU,CAAC,UAAU,EAAE,CAAC;QAC9C,MAAM,0BAA0B,GAAgC,CAAC,eAAe,EAAE,EAAE;YAClF,IAAI,eAAe,KAAK,UAAU,EAAE,CAAC;gBACnC,OAAO;YACT,CAAC;YACD,IAAI,CAAC,8BAA8B,CACjC,GAAG,EACH,UAAU,EACV,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAC9C,CAAC;QACJ,CAAC,CAAC;QACF,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC;QAC5B,GAAG,CAAC,aAAa,GAAG,aAAa,CAAC;QAClC,GAAG,CAAC,uBAAuB,GAAG,aAAa,CAAC;QAC5C,GAAG,CAAC,0BAA0B,GAAG,0BAA0B,CAAC;QAC5D,GAAG,CAAC,UAAU,GAAG,UAAU,CAAC;QAC5B,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;QACrB,GAAG,CAAC,iBAAiB,GAAG,KAAK,CAAC;QAC9B,UAAU,CAAC,EAAE,CAAC,sBAAsB,EAAE,aAAa,CAAC,CAAC;QACrD,aAAa,EAAE,EAAE,CACf,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,eAAe,EACjD,0BAA0B,CAC3B,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,IAAI,MAAM,CAAC;QACzD,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,IAAI,CAAC,sBAAsB,EAAE;gBAC5C,MAAM;gBACN,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,IAAI,EAAE;gBAC/C,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,QAAQ;gBAC3C,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,SAAS;gBAC7C,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,aAAa,IAAI,CAAC;aAC3D,CAAC,CAAC;YACH,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,GAAG,CAAC,SAAS,GAAG,KAAK,CAAC;YACtB,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC7B,GAAG,CAAC,UAAU,GAAG,SAAS,CAAC;YAC3B,GAAG,CAAC,aAAa,GAAG,SAAS,CAAC;YAC9B,GAAG,CAAC,uBAAuB,GAAG,SAAS,CAAC;YACxC,GAAG,CAAC,0BAA0B,GAAG,SAAS,CAAC;YAC3C,UAAU,CAAC,GAAG,CAAC,sBAAsB,EAAE,aAAa,CAAC,CAAC;YACtD,aAAa,EAAE,GAAG,CAChB,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,eAAe,EACjD,0BAA0B,CAC3B,CAAC;YACF,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;gBACzB,IAAI,CAAC;oBACH,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC;gBAC5B,CAAC;gBAAC,MAAM,CAAC;oBACP,mEAAmE;gBACrE,CAAC;YACH,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,GAA2B;QACtD,MAAM,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;QAClC,MAAM,aAAa,GAAG,GAAG,CAAC,aAAa,CAAC;QACxC,MAAM,aAAa,GAAG,GAAG,CAAC,uBAAuB,CAAC;QAClD,MAAM,0BAA0B,GAAG,GAAG,CAAC,0BAA0B,CAAC;QAClE,GAAG,CAAC,SAAS,GAAG,KAAK,CAAC;QACtB,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC7B,GAAG,CAAC,UAAU,GAAG,SAAS,CAAC;QAC3B,GAAG,CAAC,aAAa,GAAG,SAAS,CAAC;QAC9B,GAAG,CAAC,uBAAuB,GAAG,SAAS,CAAC;QACxC,GAAG,CAAC,0BAA0B,GAAG,SAAS,CAAC;QAC3C,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC;QACtE,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO;QACT,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,MAAM,UAAU,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YAC/C,CAAC;YAAC,MAAM,CAAC;gBACP,2EAA2E;YAC7E,CAAC;QACH,CAAC;QACD,MAAM,IAAI,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC,EAAE,CAAC,CAAC;QACtE,IAAI,aAAa,EAAE,CAAC;YAClB,UAAU,CAAC,GAAG,CAAC,sBAAsB,EAAE,aAAa,CAAC,CAAC;QACxD,CAAC;QACD,IAAI,aAAa,IAAI,0BAA0B,EAAE,CAAC;YAChD,aAAa,CAAC,GAAG,CACf,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,eAAe,EACjD,0BAA0B,CAC3B,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,MAAM,UAAU,CAAC,MAAM,EAAE,CAAC;YAC5B,CAAC;YAAC,MAAM,CAAC;gBACP,wDAAwD;YAC1D,CAAC;QACH,CAAC;IACH,CAAC;IAEO,qBAAqB,CAC3B,GAA2B,EAC3B,UAAwC,EACxC,UAAkB,EAClB,KAA4B;QAE5B,IACE,IAAI,CAAC,MAAM,KAAK,SAAS;eACtB,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE;eAC3B,GAAG,CAAC,MAAM,KAAK,MAAM;eACrB,GAAG,CAAC,iBAAiB;eACrB,CAAC,GAAG,CAAC,SAAS;eACd,GAAG,CAAC,UAAU,KAAK,UAAU;eAC7B,GAAG,CAAC,uBAAuB,KAAK,IAAI,CAAC,gBAAgB;eACrD,GAAG,CAAC,UAAU,KAAK,UAAU,EAChC,CAAC;YACD,IAAI,CAAC,+BAA+B,CAAC;gBACnC,KAAK,EAAE,GAAG,CAAC,EAAE;gBACb,UAAU;gBACV,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACvC,YAAY,EAAE,KAAK,CAAC,SAAS;gBAC7B,UAAU;aACX,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,IAAI,MAAM,CAAC;QACzD,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;QACvE,MAAM,UAAU,GAAG,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE;YACnD,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC1D,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;SAC7D,CAAC,CAAC;QACH,MAAM,QAAQ,GAAG,EAAE,IAAI,CAAC,aAAa,CAAC;QACtC,MAAM,gBAAgB,GAAsB;YAC1C,KAAK,EAAE,GAAG,CAAC,EAAE;YACb,UAAU;YACV,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,YAAY,EAAE,KAAK,CAAC,SAAS;YAC7B,UAAU;SACX,CAAC;QACF,OAAO,IAAI,CAAC,iBAAiB,CAAC,IAAI,IAAI,oBAAoB,EAAE,CAAC;YAC3D,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAEpD,CAAC;YACd,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACtB,MAAM;YACR,CAAC;YACD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,IAAI,CAAC,+BAA+B,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAC;QACvD,MAAM,KAAK,GAAsB;YAC/B,KAAK,EAAE,GAAG,CAAC,EAAE;YACb,QAAQ;YACR,UAAU;YACV,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,QAAQ,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE;YAC9B,MAAM;YACN,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW;YACxD,GAAG,UAAU;YACb,QAAQ,EAAE;gBACR,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS;gBACnC,eAAe,EAAE,KAAK,CAAC,QAAQ,CAAC,eAAe;gBAC/C,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,WAAW;gBACvC,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,YAAY;gBACzC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,aAAa;gBAC3C,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,aAAa;gBAC3C,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,KAAK,SAAS;oBACxC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE;oBACzC,CAAC,CAAC,EAAE,CAAC;aACR;YACD,IAAI;SACL,CAAC;QACF,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3C,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,KAAwB;QACxD,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,iCAAiC,CACpC,KAAK,EACL,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAC/D,CAAC;YACF,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,CAAC;YACH,MAAM,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,yBAAyB,EAAE;gBACrD,SAAS,EAAE,KAAK,CAAC,YAAY;aAC9B,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,iCAAiC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACrD,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAEO,+BAA+B,CAAC,KAAwB;QAC9D,KAAK,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAEO,iCAAiC,CACvC,KAAwB,EACxB,KAAc;QAEd,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvC,MAAM,eAAe,GAAG,OAAO,CAC7B,GAAG;eACA,GAAG,CAAC,UAAU,KAAK,KAAK,CAAC,UAAU;eACnC,CAAC,GAAG,CAAC,iBAAiB,CAC1B,CAAC;QACF,IACE,eAAe;eACZ,IAAI,CAAC,MAAM,KAAK,SAAS;eACzB,CAAC,IAAI,CAAC,mBAAmB,EAC5B,CAAC;YACD,IAAI,CAAC,SAAS,CAAC;gBACb,IAAI,EAAE,8BAA8B;gBACpC,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;gBACrC,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,KAAK,CAAC,KAAK;aACnB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,GAAG,EAAE,CAAC;YACR,IAAI,CAAC,8BAA8B,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,uBAAuB,CACnC,SAAgD;QAEhD,MAAM,gBAAgB,GAA4B,EAAE,CAAC;QACrD,KAAK,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;gBACtB,SAAS;YACX,CAAC;YACD,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACxC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;QACzD,CAAC;QACD,MAAM,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IACtC,CAAC;IAEO,8BAA8B,CACpC,GAA2B,EAC3B,UAAwC,EACxC,KAAc;QAEd,IACE,IAAI,CAAC,mBAAmB;eACrB,IAAI,CAAC,MAAM,KAAK,SAAS;eACzB,GAAG,CAAC,UAAU,KAAK,UAAU;eAC7B,GAAG,CAAC,iBAAiB;eACrB,CAAC,UAAU,CAAC,QAAQ,EACvB,CAAC;YACD,OAAO;QACT,CAAC;QACD,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,8BAA8B,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC5C,IAAI,CAAC,iBAAiB,CAAC,KAAK,IAAI,EAAE;YAChC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;gBAC5D,OAAO;YACT,CAAC;YACD,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;YAC/B,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;YACvB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,CAAC;YAC9C,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YAC1B,CAAC;YACD,IAAI,CAAC,SAAS,CAAC;gBACb,IAAI,EAAE,kBAAkB;gBACxB,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC;gBACrC,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,GAAG,CAAC,EAAE;aACd,CAAC,CAAC;YACH,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAC;YACtC,CAAC;QACH,CAAC,EAAE,+BAA+B,EAAE,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IACpD,CAAC;IAEO,qBAAqB,CAC3B,KAAsE;QAEtE,MAAM,GAAG,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACjD,MAAM,UAAU,GAAG,GAAG,CAAC,UAAU,CAAC;QAClC,IAAI,CAAC,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,iBAAiB,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,QAAQ,EAAE,CAAC;YAClF,MAAM,IAAI,KAAK,CAAC,yCAAyC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QACrE,CAAC;QACD,OAAO,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC;IAC7B,CAAC;IAEO,2BAA2B,CACjC,KAAsE;QAEtE,OAAO,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IAEO,kBAAkB,CACxB,KAAsE,EACtE,aAAsB;QAEtB,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,aAAa,IAAI,IAAI,CAAC,WAAW,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,sBAAsB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QAClD,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,UAAU,KAAK,GAAG,CAAC,UAAU,EAAE,CAAC;YAC/E,MAAM,IAAI,KAAK,CACb,wBAAwB,KAAK,CAAC,UAAU,2BAA2B,GAAG,CAAC,UAAU,EAAE,CACpF,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,gBAAgB,KAAK,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACrD,MAAM,IAAI,KAAK,CACb,2BAA2B,KAAK,CAAC,gBAAgB,yBAAyB,IAAI,CAAC,gBAAgB,EAAE,CAClG,CAAC;QACJ,CAAC;QACD,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,yBAAyB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;QACrD,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,mBAAmB,CAAC,CAAS,EAAE,CAAS;QAC9C,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACrD,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;QAC/E,CAAC;QACD,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,uCAAuC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAEO,kBAAkB,CAAC,SAAqC;QAC9D,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,CAAC,CAAC;QACX,CAAC;QACD,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;YAC5E,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QACjE,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC1B,MAAM,IAAI,KAAK,CAAC,qBAAqB,GAAG,EAAE,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QACD,uBAAuB,CAAC,SAAS,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;QACxD,uBAAuB,CAAC,SAAS,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;QAChE,uBAAuB,CAAC,SAAS,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAC1D,uBAAuB,CAAC,SAAS,CAAC,KAAK,EAAE,iBAAiB,CAAC,CAAC;QAC5D,OAAO,CACL,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cACrB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cAC3B,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cACxB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC5B,CAAC;IACJ,CAAC;IAEO,WAAW,CAAC,GAAY;QAC9B,MAAM,YAAY,GAAG,qBAAqB,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC;QACxE,IAAI,SAAc,CAAC;QACnB,IAAI,CAAC;YACH,SAAS,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC;QACpC,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;QAC1C,CAAC;QACD,IACE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,kBAAkB;eACtC,SAAS,CAAC,QAAQ,KAAK,OAAO;eAC9B,SAAS,CAAC,QAAQ,KAAK,QAAQ,EAClC,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,0BAA0B,CAChC,OAAoC;QAEpC,OAAO;YACL,SAAS,EAAE,OAAO,CAAC,SAAS,KAAK,SAAS;gBACxC,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC,EAAE,KAAK,CAAC;YAC7D,cAAc,EAAE,OAAO,CAAC,cAAc,KAAK,SAAS;gBAClD,CAAC,CAAC,MAAM;gBACR,CAAC,CAAC,eAAe,CACb,OAAO,CAAC,cAAc,EACtB,gBAAgB,EAChB,CAAC,EACD,wBAAwB,CACzB;YACL,QAAQ,EAAE,OAAO,CAAC,QAAQ,KAAK,SAAS;gBACtC,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC,EAAE,kBAAkB,CAAC;YACxE,QAAQ,EAAE,OAAO,CAAC,QAAQ,KAAK,SAAS;gBACtC,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC,EAAE,kBAAkB,CAAC;YACxE,cAAc,EAAE,OAAO,CAAC,cAAc,KAAK,SAAS;gBAClD,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC,eAAe,CACb,OAAO,CAAC,cAAc,EACtB,gBAAgB,EAChB,CAAC,EACD,wBAAwB,CACzB;YACL,cAAc,EAAE,OAAO,CAAC,cAAc,KAAK,SAAS;gBAClD,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,eAAe,CACb,OAAO,CAAC,cAAc,EACtB,gBAAgB,EAChB,CAAC,EACD,wBAAwB,CACzB;YACL,aAAa,EAAE,OAAO,CAAC,aAAa,KAAK,SAAS;gBAChD,CAAC,CAAC,IAAI;gBACN,CAAC,CAAC,eAAe,CACb,OAAO,CAAC,aAAa,EACrB,eAAe,EACf,CAAC,EACD,uBAAuB,CACxB;SACN,CAAC;IACJ,CAAC;IAEO,uBAAuB,CAC7B,gBAAqE;QAErE,MAAM,WAAW,GAAG,gBAAgB,CAAC,SAAS,EAAE,WAAW,CAAC;QAC5D,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9D,OAAO,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,QAAQ,CAAC,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC/C,CAAC;IAEO,mCAAmC;QACzC,MAAM,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC;QACnE,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;QAC7D,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;QAC/D,OAAO;;8BAEmB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA+LtC,mBAAmB;WACnB,gBAAgB;WAChB,iBAAiB;;;;;;;;;;SAUnB,CAAC;IACR,CAAC;IAEO,0BAA0B,CAChC,UAAkB,EAClB,OAAqC,EACrC,eAAuB;QAEvB,OAAO,cAAc,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,GAAG,CAAC;IAChK,CAAC;IAEO,eAAe,CAAC,SAAkB,EAAE,YAAY,GAAG,IAAI;QAC7D,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,YAAY,CAAC;QACtB,CAAC;QACD,OAAO,eAAe,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC,EAAE,YAAY,CAAC,CAAC;IAClE,CAAC;IAEO,iBAAiB,CAAC,SAAiC;QACzD,MAAM,kBAAkB,GAAG,SAAS,IAAI,MAAM,CAAC;QAC/C,IAAI,CAAC,CAAC,MAAM,EAAE,kBAAkB,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;YAC/F,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;QAC7F,CAAC;QACD,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAEO,yBAAyB;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,IAAI,OAAO,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YAC1F,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAClC,eAAe,CAAC,OAAO,CAAC,OAAO,EAAE,oBAAoB,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YACnC,eAAe,CAAC,OAAO,CAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAC,EAAE,gBAAgB,CAAC,CAAC;QAChF,CAAC;QACD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;YACpC,eAAe,CAAC,OAAO,CAAC,SAAS,EAAE,sBAAsB,EAAE,CAAC,EAAE,iBAAiB,CAAC,CAAC;QACnF,CAAC;QACD,IACE,OAAO,CAAC,QAAQ,KAAK,SAAS;eAC3B,OAAO,CAAC,SAAS,KAAK,SAAS;eAC/B,OAAO,CAAC,QAAQ,GAAG,OAAO,CAAC,SAAS,GAAG,oBAAoB,EAC9D,CAAC;YACD,MAAM,IAAI,KAAK,CACb,yCAAyC,oBAAoB,SAAS,CACvE,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACxC,eAAe,CAAC,OAAO,CAAC,aAAa,EAAE,0BAA0B,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAC7E,CAAC;IACH,CAAC;CACF"}