@git.zone/tsrust 1.9.1 → 1.10.0

package/dist_ts/mod_matrix/classes.nativematrixbuilder.js

@@ -0,0 +1,1084 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ArtifactAssembler, MAX_ARTIFACT_BYTES, MAX_ASSEMBLY_INPUT_BYTES, } from '../mod_artifact/index.js';
+import { CargoConfig } from '../mod_cargo/index.js';
+import { assertGitSnapshotUnchanged, captureGitSnapshot, MAX_PROVENANCE_SIDECAR_BYTES, PROVENANCE_SIDECAR_SUFFIX, ProvenanceStore, } from '../mod_provenance/index.js';
+import { ToolchainManager } from '../mod_toolchain/index.js';
+import { friendlyTargetName } from '../mod_cli/helpers.targets.js';
+import { commitinfo } from '../00_commitinfo_data.js';
+import { MatrixCommandRunner, } from './classes.matrixcommandrunner.js';
+import { resolveMatrixPlan, } from './helpers.matrixconfig.js';
+const capabilityCommandTimeoutMs = 5 * 60 * 1000;
+const buildCommandTimeoutMs = 60 * 60 * 1000;
+const maximumRetainedDiagnosticRuns = 3;
+const sshConnectionArgs = [
+    '-o',
+    'ServerAliveInterval=15',
+    '-o',
+    'ServerAliveCountMax=2',
+];
+const matrixOwnerFileName = '.tsrust-matrix-owner';
+const forwardEnvironmentGrantName = 'TSRUST_MATRIX_ALLOWED_ENVIRONMENT';
+const defaultWorkerEnvironmentNames = [
+    'PATH',
+    'USER',
+    'LOGNAME',
+    'SHELL',
+    'TMPDIR',
+    'TMP',
+    'TEMP',
+    'LANG',
+    'LC_ALL',
+    'LC_CTYPE',
+    'TERM',
+    'COLORTERM',
+    'CI',
+    'RUSTUP_HOME',
+];
+const transportEnvironmentNames = [
+    'PATH',
+    'HOME',
+    'USER',
+    'LOGNAME',
+    'SHELL',
+    'SSH_AUTH_SOCK',
+    'SSH_AGENT_PID',
+    'TMPDIR',
+    'TMP',
+    'TEMP',
+    'LANG',
+    'LC_ALL',
+    'LC_CTYPE',
+    'TERM',
+    'COLORTERM',
+    'CI',
+];
+const bundledToolchainValidationSource = [
+    "const fs = require('node:fs');",
+    "const path = require('node:path');",
+    'const [root, ...executables] = process.argv.slice(1);',
+    'const rootEntry = fs.lstatSync(root);',
+    'if (!rootEntry.isDirectory() || rootEntry.isSymbolicLink()) process.exit(1);',
+    'if (process.getuid && rootEntry.uid !== process.getuid()) process.exit(1);',
+    'if ((rootEntry.mode & 0o022) !== 0) process.exit(1);',
+    'const physicalRoot = fs.realpathSync(root);',
+    'for (const executable of executables) {',
+    '  const entry = fs.lstatSync(executable);',
+    '  if (!entry.isFile() && !entry.isSymbolicLink()) process.exit(1);',
+    '  const resolvedPath = fs.realpathSync(executable);',
+    '  const relativePath = path.relative(physicalRoot, resolvedPath);',
+    "  if (!relativePath || relativePath.startsWith('..') || path.isAbsolute(relativePath)) process.exit(1);",
+    '  const resolved = fs.statSync(resolvedPath);',
+    '  if (!resolved.isFile() || (resolved.mode & 0o111) === 0 || (resolved.mode & 0o022) !== 0) process.exit(1);',
+    '  if (process.getuid && resolved.uid !== process.getuid()) process.exit(1);',
+    '}',
+].join('\n');
+const remoteWatchdogSource = [
+    "const childProcess = require('node:child_process');",
+    'const shell = process.argv[1];',
+    'const script = process.argv[2];',
+    "const child = childProcess.spawn(shell, ['-lc', script], { detached: true, stdio: ['ignore', 'inherit', 'inherit'] });",
+    'let lastHeartbeat = Date.now();',
+    'let terminationDeadline;',
+    'let spawnError;',
+    'let finished = false;',
+    'const killGroup = (signal) => { if (!child.pid) return; try { process.kill(-child.pid, signal); } catch (error) { if (error.code !== "ESRCH") throw error; } };',
+    'const groupExists = () => { if (!child.pid) return false; try { process.kill(-child.pid, 0); return true; } catch (error) { if (error.code === "ESRCH") return false; throw error; } };',
+    'const terminate = (signal) => { if (terminationDeadline) return; killGroup(signal); terminationDeadline = Date.now() + 10000; };',
+    'const enforceEscalation = () => { if (terminationDeadline && Date.now() >= terminationDeadline) killGroup("SIGKILL"); };',
+    'const waitForGroupExit = async () => { const deadline = Math.max(Date.now(), terminationDeadline || 0) + 2000; while (groupExists() && Date.now() < deadline) { enforceEscalation(); await new Promise((resolve) => setTimeout(resolve, 100)); } enforceEscalation(); return !groupExists(); };',
+    'const signalHandlers = new Map();',
+    'for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) { const handler = () => terminate(signal); signalHandlers.set(signal, handler); process.on(signal, handler); }',
+    'const heartbeatTimer = setInterval(() => { if (Date.now() - lastHeartbeat > 45000) terminate("SIGHUP"); enforceEscalation(); }, 1000);',
+    'process.stdin.on("data", () => { lastHeartbeat = Date.now(); });',
+    'process.stdin.on("end", () => terminate("SIGHUP"));',
+    'process.stdin.on("error", () => terminate("SIGHUP"));',
+    'process.stdin.resume();',
+    'child.once("error", (error) => { spawnError = error; });',
+    'child.once("close", (code, signal) => { void (async () => {',
+    '  if (finished) return;',
+    '  finished = true;',
+    '  const hadSurvivingGroup = groupExists();',
+    '  if (hadSurvivingGroup) terminate("SIGTERM");',
+    '  const stopped = await waitForGroupExit();',
+    '  clearInterval(heartbeatTimer);',
+    '  for (const [registeredSignal, handler] of signalHandlers) process.off(registeredSignal, handler);',
+    '  process.stdin.destroy();',
+    '  if (spawnError) console.error(spawnError);',
+    '  if (!stopped) console.error("Remote matrix command left a live process group");',
+    '  process.exitCode = spawnError || !stopped || hadSurvivingGroup ? 1 : (code ?? (signal ? 1 : 0));',
+    '})(); });',
+].join('\n');
+const shellQuote = (valueArg) => `'${valueArg.replace(/'/g, `'"'"'`)}'`;
+const expectedHostDetails = (hostArg) => {
+    switch (hostArg) {
+        case 'linux_amd64':
+            return { system: 'Linux', machine: 'x86_64' };
+        case 'linux_arm64':
+            return { system: 'Linux', machine: 'aarch64' };
+        case 'macos_amd64':
+            return { system: 'Darwin', machine: 'x86_64' };
+        case 'macos_arm64':
+            return { system: 'Darwin', machine: 'arm64' };
+    }
+};
+const artifactNamesFor = (workerArg, binariesArg) => workerArg.targets
+    .flatMap((target) => binariesArg.flatMap((binary) => {
+    const binaryName = `${binary}_${target.friendly}`;
+    return [binaryName, `${binaryName}${PROVENANCE_SIDECAR_SUFFIX}`];
+}))
+    .sort();
+const linuxProbeCompiler = (targetArg) => {
+    switch (targetArg) {
+        case 'linux_amd64':
+            return 'x86_64-linux-gnu-gcc';
+        case 'linux_arm64':
+            return 'aarch64-linux-gnu-gcc';
+        case 'linux_amd64_musl':
+            return 'x86_64-linux-musl-gcc';
+        case 'linux_arm64_musl':
+            return 'aarch64-linux-musl-gcc';
+        default:
+            return undefined;
+    }
+};
+export class NativeMatrixBuilder {
+    workspace;
+    environment;
+    commandRunner;
+    plan;
+    constructor(optionsArg) {
+        this.workspace = path.resolve(optionsArg.workspace);
+        this.environment = { ...process.env, ...(optionsArg.environment || {}) };
+        this.commandRunner =
+            optionsArg.commandRunner || new MatrixCommandRunner(this.environment);
+        this.plan = resolveMatrixPlan(optionsArg.config);
+        this.assertForwardEnvironmentGrant();
+    }
+    async check() {
+        await this.assertBundleCompatibleSource();
+        await this.commandRunner.execute('git', ['--version'], {
+            cwd: this.workspace,
+            capture: true,
+            timeoutMs: capabilityCommandTimeoutMs,
+        });
+        await this.commandRunner.execute('pnpm', ['--version'], {
+            cwd: this.workspace,
+            capture: true,
+            timeoutMs: capabilityCommandTimeoutMs,
+        });
+        await this.assertInstalledTsrustVersion(this.workspace);
+        for (const worker of this.plan.workers) {
+            if (worker.config.transport === 'local') {
+                await this.checkLocalWorker(worker);
+            }
+            else {
+                await this.checkSshWorker(worker, this.resolveSshWorker(worker));
+            }
+        }
+        return this.checkResult();
+    }
+    async build() {
+        const gitBefore = await captureGitSnapshot(this.workspace);
+        if (!gitBefore.available || gitBefore.commit === 'unknown') {
+            throw new Error('tsrust matrix build requires a Git checkout');
+        }
+        if (gitBefore.status.length > 0 || (gitBefore.unsafeIndexFlags?.length || 0) > 0) {
+            throw new Error('tsrust matrix build requires a clean Git worktree');
+        }
+        await this.assertPlanMatchesCommit(gitBefore.commit);
+        await this.check();
+        assertGitSnapshotUnchanged(gitBefore, await captureGitSnapshot(this.workspace));
+        await this.assertBundleCompatibleSource();
+        assertGitSnapshotUnchanged(gitBefore, await captureGitSnapshot(this.workspace));
+        const projectIdentity = this.readProjectIdentity();
+        const binaries = await this.readBinaryTargets();
+        const runParent = path.join(this.workspace, '.nogit', 'tsrust-matrix');
+        await this.ensureLocalRunParent(runParent);
+        const runDirectory = await fs.promises.mkdtemp(path.join(runParent, `${gitBefore.commit.slice(0, 12)}-`));
+        const bundlePath = path.join(runDirectory, 'source.bundle');
+        const sourceDirectories = [];
+        const remoteWorkspaces = [];
+        let completed = false;
+        try {
+            await this.commandRunner.execute('git', ['bundle', 'create', bundlePath, 'HEAD'], {
+                cwd: this.workspace,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+            await this.commandRunner.execute('git', ['bundle', 'verify', bundlePath], {
+                cwd: this.workspace,
+                capture: true,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+            assertGitSnapshotUnchanged(gitBefore, await captureGitSnapshot(this.workspace));
+            for (const worker of this.plan.workers) {
+                if (worker.config.transport === 'local') {
+                    sourceDirectories.push(await this.buildLocalWorker(worker, bundlePath, runDirectory, gitBefore.commit, projectIdentity, binaries));
+                }
+                else {
+                    const remoteWorkspace = this.describeRemoteWorkspace(worker, this.resolveSshWorker(worker), gitBefore.commit);
+                    remoteWorkspaces.push(remoteWorkspace);
+                    await this.createRemoteWorkspace(remoteWorkspace, gitBefore.commit);
+                    sourceDirectories.push(await this.buildSshWorker(remoteWorkspace, bundlePath, runDirectory, gitBefore.commit, projectIdentity, binaries));
+                }
+            }
+            const gitAfterWorkers = await captureGitSnapshot(this.workspace);
+            assertGitSnapshotUnchanged(gitBefore, gitAfterWorkers);
+            this.assertProjectIdentityUnchanged(projectIdentity);
+            while (remoteWorkspaces.length > 0) {
+                const remoteWorkspace = remoteWorkspaces[0];
+                await this.cleanupRemoteWorkspace(remoteWorkspace, gitBefore.commit);
+                remoteWorkspaces.shift();
+            }
+            const gitAfterRemoteCleanup = await captureGitSnapshot(this.workspace);
+            assertGitSnapshotUnchanged(gitBefore, gitAfterRemoteCleanup);
+            this.assertProjectIdentityUnchanged(projectIdentity);
+            const assembly = await new ArtifactAssembler({
+                workspace: this.workspace,
+                sourceDirectories,
+                expectedTargets: this.plan.expectedTargets,
+                expectedBinaries: binaries,
+                expectedProjectName: projectIdentity.projectName,
+                expectedProjectVersion: projectIdentity.projectVersion,
+                expectedGitCommit: gitBefore.commit,
+                expectedTsrustVersion: commitinfo.version,
+            }).assemble();
+            if (assembly.cleanupPending) {
+                console.warn('Matrix assembly committed; stale transaction cleanup will retry next run.');
+            }
+            completed = true;
+            try {
+                await fs.promises.rm(runDirectory, { recursive: true });
+            }
+            catch (error) {
+                console.warn(`Matrix assembly succeeded but local staging cleanup failed at ${runDirectory}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return {
+                ...this.checkResult(),
+                gitCommit: gitBefore.commit,
+                assembly,
+            };
+        }
+        finally {
+            if (!completed) {
+                console.error(`Retained local tsrust matrix diagnostics at ${runDirectory}`);
+                for (const remoteWorkspace of remoteWorkspaces) {
+                    console.error(`${remoteWorkspace.worker.host} matrix diagnostics may remain at ${remoteWorkspace.directory}`);
+                }
+                console.error('Matrix diagnostics are not pruned automatically; inspect before removal.');
+            }
+        }
+    }
+    checkResult() {
+        return {
+            workers: this.plan.workers.map((worker) => worker.host),
+            targets: this.plan.expectedTargets.map((target) => target.friendly),
+        };
+    }
+    assertForwardEnvironmentGrant() {
+        const granted = new Set((this.environment[forwardEnvironmentGrantName] || '')
+            .split(',')
+            .map((name) => name.trim())
+            .filter(Boolean));
+        const reserved = new Set([
+            ...defaultWorkerEnvironmentNames,
+            ...transportEnvironmentNames,
+            'HOME',
+            'CARGO_HOME',
+            forwardEnvironmentGrantName,
+        ]);
+        const forbidden = this.plan.forwardEnvironment.filter((name) => reserved.has(name) || !granted.has(name));
+        if (forbidden.length > 0) {
+            throw new Error(`matrix.forwardEnvironment is not granted by ${forwardEnvironmentGrantName}: ${forbidden.join(', ')}`);
+        }
+    }
+    workerEnvironment(homeArg, cargoHomeArg) {
+        const environment = {};
+        for (const name of [
+            ...defaultWorkerEnvironmentNames,
+            ...this.plan.forwardEnvironment,
+        ]) {
+            if (this.environment[name] !== undefined)
+                environment[name] = this.environment[name];
+        }
+        environment.HOME = homeArg;
+        environment.CARGO_HOME = cargoHomeArg;
+        if (!environment.RUSTUP_HOME && this.environment.HOME) {
+            environment.RUSTUP_HOME = path.join(this.environment.HOME, '.rustup');
+        }
+        return environment;
+    }
+    transportEnvironment() {
+        const environment = {};
+        for (const name of [...transportEnvironmentNames, ...this.plan.forwardEnvironment]) {
+            if (this.environment[name] !== undefined)
+                environment[name] = this.environment[name];
+        }
+        return environment;
+    }
+    remainingBuildTimeout(deadlineArg, workerArg) {
+        const remaining = deadlineArg - Date.now();
+        if (remaining <= 0) {
+            throw new Error(`Matrix worker ${workerArg} exceeded its shared build timeout`);
+        }
+        return remaining;
+    }
+    async assertInstalledTsrustVersion(workspaceArg) {
+        const packagePath = path.join(workspaceArg, 'node_modules', '@git.zone', 'tsrust', 'package.json');
+        const packageJson = JSON.parse(await fs.promises.readFile(packagePath, 'utf8'));
+        if (packageJson.name !== '@git.zone/tsrust' || packageJson.version !== commitinfo.version) {
+            throw new Error(`Project-local tsrust ${String(packageJson.version || 'unknown')} does not match coordinator ${commitinfo.version}`);
+        }
+    }
+    async assertPlanMatchesCommit(gitCommitArg) {
+        const committedFile = await this.commandRunner.execute('git', ['show', `${gitCommitArg}:.smartconfig.json`], {
+            cwd: this.workspace,
+            capture: true,
+            timeoutMs: capabilityCommandTimeoutMs,
+        });
+        const committedRoot = JSON.parse(committedFile.stdout);
+        const committedConfig = committedRoot['@git.zone/tsrust'];
+        const committedPlan = resolveMatrixPlan(committedConfig);
+        if (JSON.stringify(committedPlan) !== JSON.stringify(this.plan)) {
+            throw new Error('Matrix configuration does not match the exact Git commit');
+        }
+    }
+    remoteWorkerEnvironmentFunction(homeArg, cargoHomeArg) {
+        const names = [
+            ...new Set([...defaultWorkerEnvironmentNames, ...this.plan.forwardEnvironment]),
+        ];
+        const assignments = names.map((name) => `${name}="\${${name}-}"`).join(' ');
+        return `run_matrix_worker() { worker_rustup_home="\${RUSTUP_HOME:-\${HOME}/.rustup}"; env -i ${assignments} HOME=${shellQuote(homeArg)} CARGO_HOME=${shellQuote(cargoHomeArg)} RUSTUP_HOME="$worker_rustup_home" "$@"; }`;
+    }
+    async assertBundleCompatibleSource() {
+        const staged = await this.commandRunner.execute('git', ['ls-files', '--stage', '-z'], {
+            cwd: this.workspace,
+            capture: true,
+            timeoutMs: capabilityCommandTimeoutMs,
+        });
+        for (const entry of staged.stdout.split('\0').filter(Boolean)) {
+            const mode = entry.slice(0, entry.indexOf(' '));
+            if (mode === '160000') {
+                throw new Error('tsrust matrix builds do not support Git submodules');
+            }
+            if (mode === '120000') {
+                throw new Error('tsrust matrix builds do not support tracked symbolic links');
+            }
+        }
+        const tracked = await this.commandRunner.execute('git', ['ls-files', '-z'], {
+            cwd: this.workspace,
+            capture: true,
+            timeoutMs: capabilityCommandTimeoutMs,
+        });
+        if (tracked.stdout.length > 0) {
+            const attributes = await this.commandRunner.execute('git', ['check-attr', '-z', '--stdin', 'filter'], {
+                cwd: this.workspace,
+                capture: true,
+                input: tracked.stdout,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+            const values = attributes.stdout.split('\0');
+            for (let index = 0; index + 2 < values.length; index += 3) {
+                if (!['unspecified', 'unset'].includes(values[index + 2])) {
+                    throw new Error(`tsrust matrix builds do not support checkout filters: ${values[index]}`);
+                }
+            }
+        }
+        const pointerCandidates = await this.commandRunner.execute('git', [
+            'grep',
+            '-I',
+            '-l',
+            '-z',
+            '-e',
+            '^version https://',
+            'HEAD',
+            '--',
+        ], {
+            cwd: this.workspace,
+            capture: true,
+            timeoutMs: capabilityCommandTimeoutMs,
+            allowedExitCodes: [0, 1],
+        });
+        for (const candidate of pointerCandidates.stdout.split('\0').filter(Boolean)) {
+            const filePath = candidate.startsWith('HEAD:') ? candidate.slice(5) : candidate;
+            const content = await this.commandRunner.execute('git', ['show', `HEAD:${filePath}`], {
+                cwd: this.workspace,
+                capture: true,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+            if (/^version https:\/\/[^\r\n]+\r?\n(?:ext-[^\r\n]+\r?\n)*oid sha256:[a-f0-9]{64}\r?\nsize [0-9]+(?:\r?\n|$)/.test(content.stdout)) {
+                throw new Error(`tsrust matrix builds do not support Git LFS pointer ${filePath}`);
+            }
+        }
+    }
+    async checkLocalWorker(workerArg) {
+        const actualHost = friendlyTargetName(new ToolchainManager().getHostTriple());
+        if (actualHost !== workerArg.host) {
+            throw new Error(`Local matrix worker expected ${workerArg.host} but coordinator is ${actualHost}`);
+        }
+        await this.checkLocalToolchain(workerArg.host);
+        await this.checkLocalExecution(workerArg);
+    }
+    async checkLocalToolchain(hostArg) {
+        let hasSystemCargo = false;
+        try {
+            await this.commandRunner.execute('cargo', ['--version'], {
+                cwd: this.workspace,
+                capture: true,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+            hasSystemCargo = true;
+        }
+        catch {
+            hasSystemCargo = false;
+        }
+        if (hasSystemCargo) {
+            await this.commandRunner.execute('rustup', ['--version'], {
+                cwd: this.workspace,
+                capture: true,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+        }
+        else {
+            const toolchainManager = new ToolchainManager();
+            if (await toolchainManager.isInstalled()) {
+                await this.commandRunner.execute(path.join(ToolchainManager.BIN_DIR, 'cargo'), ['--version'], {
+                    cwd: this.workspace,
+                    capture: true,
+                    timeoutMs: capabilityCommandTimeoutMs,
+                });
+                await this.commandRunner.execute(path.join(ToolchainManager.BIN_DIR, 'rustup'), ['--version'], {
+                    cwd: this.workspace,
+                    capture: true,
+                    timeoutMs: capabilityCommandTimeoutMs,
+                });
+            }
+            else {
+                await this.commandRunner.execute('curl', ['--version'], {
+                    cwd: this.workspace,
+                    capture: true,
+                    timeoutMs: capabilityCommandTimeoutMs,
+                });
+            }
+        }
+        if (hostArg.startsWith('macos_')) {
+            await this.commandRunner.execute('xcrun', ['--find', 'clang'], {
+                cwd: this.workspace,
+                capture: true,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+        }
+        else {
+            await this.commandRunner.execute('cc', ['--version'], {
+                cwd: this.workspace,
+                capture: true,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+        }
+    }
+    async checkLocalExecution(workerArg) {
+        for (const target of workerArg.targets) {
+            if (target.friendly === workerArg.host)
+                continue;
+            if (workerArg.host.startsWith('macos_') && target.friendly.startsWith('macos_')) {
+                const architecture = target.friendly === 'macos_arm64' ? '-arm64' : '-x86_64';
+                await this.commandRunner.execute('/usr/bin/arch', [architecture, '/usr/bin/true'], {
+                    cwd: this.workspace,
+                    timeoutMs: capabilityCommandTimeoutMs,
+                });
+                continue;
+            }
+            if (workerArg.host.startsWith('linux_') && target.friendly.startsWith('linux_')) {
+                await this.checkLocalLinuxCrossExecution(target.friendly);
+                continue;
+            }
+            throw new Error(`Matrix worker ${workerArg.host} cannot execute smoke tests for ${target.friendly}`);
+        }
+    }
+    async checkLocalLinuxCrossExecution(targetArg) {
+        const compiler = linuxProbeCompiler(targetArg);
+        if (!compiler) {
+            throw new Error(`No matrix execution probe is available for ${targetArg}`);
+        }
+        const probeParent = path.join(this.workspace, '.nogit', 'tsrust-matrix-probes');
+        await fs.promises.mkdir(probeParent, { recursive: true, mode: 0o700 });
+        const probeDirectory = await fs.promises.mkdtemp(path.join(probeParent, `${targetArg}-`));
+        try {
+            const sourcePath = path.join(probeDirectory, 'probe.c');
+            const binaryPath = path.join(probeDirectory, 'probe');
+            await fs.promises.writeFile(sourcePath, 'int main(void) { return 0; }\n');
+            await this.commandRunner.execute(compiler, ['-static', '-O2', sourcePath, '-o', binaryPath], {
+                cwd: this.workspace,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+            await this.commandRunner.execute(binaryPath, [], {
+                cwd: this.workspace,
+                timeoutMs: capabilityCommandTimeoutMs,
+            });
+        }
+        finally {
+            await fs.promises.rm(probeDirectory, { recursive: true, force: true });
+        }
+    }
+    resolveSshWorker(workerArg) {
+        if (workerArg.config.transport !== 'ssh') {
+            throw new Error(`Matrix worker ${workerArg.host} is not configured for SSH`);
+        }
+        const destination = this.environment[workerArg.config.destinationEnv]?.trim() || '';
+        const temporaryRoot = (this.environment[workerArg.config.temporaryRootEnv]?.trim() || '').replace(/\/+$/, '');
+        if (!/^[A-Za-z0-9._-]+(?:@[A-Za-z0-9._-]+)?$/.test(destination)) {
+            throw new Error(`${workerArg.config.destinationEnv} must contain one SSH alias or user@host destination without options`);
+        }
+        if (!/^\/[A-Za-z0-9._/-]+$/.test(temporaryRoot) ||
+            path.posix.normalize(temporaryRoot) !== temporaryRoot ||
+            temporaryRoot.split('/').filter(Boolean).length < 2) {
+            throw new Error(`${workerArg.config.temporaryRootEnv} must contain a non-root absolute path without spaces`);
+        }
+        return { destination, temporaryRoot };
+    }
+    async checkSshWorker(workerArg, runtimeArg) {
+        const details = expectedHostDetails(workerArg.host);
+        const token = crypto.randomUUID();
+        const probeDirectory = `${runtimeArg.temporaryRoot}/tsrust-matrix.check.${token}`;
+        const commands = [
+            'set -eu',
+            'umask 077',
+            `test "$(uname -s)" = ${shellQuote(details.system)}`,
+            `test "$(uname -m)" = ${shellQuote(details.machine)}`,
+            'command -v git >/dev/null',
+            'command -v node >/dev/null',
+            'command -v pnpm >/dev/null',
+            this.remoteToolchainCapabilityCommand(),
+            ...(details.system === 'Darwin' ? ['command -v codesign >/dev/null'] : []),
+            ...(details.system === 'Darwin'
+                ? ['xcrun --find clang >/dev/null']
+                : ['command -v cc >/dev/null']),
+            ...this.remoteRootValidationCommands(runtimeArg.temporaryRoot),
+            `test "$(find "$root" -mindepth 1 -maxdepth 1 -type d -name 'tsrust-matrix.*' | wc -l | tr -d ' ')" -lt ${maximumRetainedDiagnosticRuns}`,
+            `probe=${shellQuote(probeDirectory)}`,
+            `test "$probe" = ${shellQuote(probeDirectory)}`,
+            'created=0',
+            'cleanup_probe() { if [ "$created" = 1 ]; then rm -rf "$probe"; fi; }',
+            'trap cleanup_probe EXIT HUP INT TERM',
+            'mkdir -m 700 "$probe"',
+            'created=1',
+            ...this.remoteExecutionProbeCommands(workerArg, probeDirectory),
+            'rm -rf "$probe"',
+            'created=0',
+            'trap - EXIT HUP INT TERM',
+        ];
+        try {
+            await this.runRemoteOwnedScript(workerArg, runtimeArg, commands.join('\n'), capabilityCommandTimeoutMs);
+        }
+        catch (error) {
+            throw new Error(`${workerArg.host} capability check failed; diagnostics may remain at ${probeDirectory}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    remoteToolchainCapabilityCommand() {
+        const root = ToolchainManager.TOOLCHAIN_DIR;
+        const cargo = path.join(ToolchainManager.BIN_DIR, 'cargo');
+        const rustup = path.join(ToolchainManager.BIN_DIR, 'rustup');
+        const installLock = `${root}.install.lock`;
+        return `if command -v cargo >/dev/null && cargo --version >/dev/null 2>&1; then command -v rustup >/dev/null; rustup --version >/dev/null; elif [ -e ${shellQuote(installLock)} ]; then exit 1; elif [ -x ${shellQuote(cargo)} ] && [ -x ${shellQuote(rustup)} ]; then node -e ${shellQuote(bundledToolchainValidationSource)} ${shellQuote(root)} ${shellQuote(cargo)} ${shellQuote(rustup)}; ${shellQuote(cargo)} --version >/dev/null; ${shellQuote(rustup)} --version >/dev/null; elif [ -e ${shellQuote(cargo)} ] || [ -e ${shellQuote(rustup)} ]; then exit 1; else command -v curl >/dev/null; fi`;
+    }
+    remoteRootValidationCommands(rootArg) {
+        return [
+            `root=${shellQuote(rootArg)}`,
+            'if [ -e "$root" ]; then test -d "$root"; test ! -L "$root"; else mkdir -p "$root"; fi',
+            'test "$(cd "$root" && pwd -P)" = "$root"',
+            'test -z "$(find "$root" -prune -perm -022 -print)"',
+            'if [ "$(uname -s)" = Darwin ]; then test "$(stat -f %u "$root")" = "$(id -u)"; else test "$(stat -c %u "$root")" = "$(id -u)"; fi',
+        ];
+    }
+    remoteOwnershipValidationCommands(remoteArg, gitCommitArg) {
+        const ownerPath = `${remoteArg.directory}/${matrixOwnerFileName}`;
+        const ownerContents = `${remoteArg.ownerToken}\n${gitCommitArg}\n${remoteArg.directory}`;
+        return [
+            `directory=${shellQuote(remoteArg.directory)}`,
+            `test "$directory" = ${shellQuote(remoteArg.directory)}`,
+            'test -d "$directory"',
+            'test ! -L "$directory"',
+            'test "$(cd "$directory/.." && pwd -P)" = "$root"',
+            'test -z "$(find "$directory" -prune -perm -077 -print)"',
+            'if [ "$(uname -s)" = Darwin ]; then test "$(stat -f %u "$directory")" = "$(id -u)"; else test "$(stat -c %u "$directory")" = "$(id -u)"; fi',
+            `test -f ${shellQuote(ownerPath)}`,
+            `test ! -L ${shellQuote(ownerPath)}`,
+            `test -z "$(find ${shellQuote(ownerPath)} -prune -perm -077 -print)"`,
+            `if [ "$(uname -s)" = Darwin ]; then test "$(stat -f %u ${shellQuote(ownerPath)})" = "$(id -u)"; else test "$(stat -c %u ${shellQuote(ownerPath)})" = "$(id -u)"; fi`,
+            `test "$(cat ${shellQuote(ownerPath)})" = ${shellQuote(ownerContents)}`,
+        ];
+    }
+    remoteExecutionProbeCommands(workerArg, probeDirectoryArg) {
+        const commands = [];
+        for (const target of workerArg.targets) {
+            if (target.friendly === workerArg.host)
+                continue;
+            if (workerArg.host.startsWith('macos_') && target.friendly.startsWith('macos_')) {
+                const architecture = target.friendly === 'macos_arm64' ? '-arm64' : '-x86_64';
+                commands.push(`/usr/bin/arch ${architecture} /usr/bin/true`);
+                continue;
+            }
+            if (workerArg.host.startsWith('linux_') && target.friendly.startsWith('linux_')) {
+                const compiler = linuxProbeCompiler(target.friendly);
+                if (!compiler) {
+                    throw new Error(`No matrix execution probe is available for ${target.friendly}`);
+                }
+                const sourcePath = `${probeDirectoryArg}/probe-${target.friendly}.c`;
+                const binaryPath = `${probeDirectoryArg}/probe-${target.friendly}`;
+                commands.push(`printf '%s\n' 'int main(void) { return 0; }' > ${shellQuote(sourcePath)}`, `${compiler} -static -O2 ${shellQuote(sourcePath)} -o ${shellQuote(binaryPath)}`, shellQuote(binaryPath));
+                continue;
+            }
+            throw new Error(`Matrix worker ${workerArg.host} cannot execute smoke tests for ${target.friendly}`);
+        }
+        return commands;
+    }
+    async readBinaryTargets() {
+        const rustDirectory = await this.detectRustDirectory();
+        const workspaceInfo = await new CargoConfig(rustDirectory).parse();
+        const binaries = [...new Set(workspaceInfo.binTargets)];
+        if (binaries.length === 0) {
+            throw new Error('tsrust matrix build requires at least one Cargo binary target');
+        }
+        for (const binary of binaries) {
+            if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(binary)) {
+                throw new Error(`Invalid Cargo binary name for matrix build: ${binary}`);
+            }
+        }
+        return binaries;
+    }
+    async detectRustDirectory() {
+        for (const directoryName of ['rust', 'ts_rust']) {
+            const candidate = path.join(this.workspace, directoryName);
+            try {
+                const stat = await fs.promises.stat(path.join(candidate, 'Cargo.toml'));
+                if (stat.isFile())
+                    return candidate;
+            }
+            catch {
+                // Try the next conventional Rust source directory.
+            }
+        }
+        throw new Error('No rust/ or ts_rust/ directory found with a Cargo.toml');
+    }
+    readProjectIdentity() {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(this.workspace, 'package.json'), 'utf8'));
+        if (typeof packageJson.name !== 'string' || typeof packageJson.version !== 'string') {
+            throw new Error('tsrust matrix build requires package.json name and version');
+        }
+        return { projectName: packageJson.name, projectVersion: packageJson.version };
+    }
+    assertProjectIdentityUnchanged(identityArg) {
+        const current = this.readProjectIdentity();
+        if (current.projectName !== identityArg.projectName ||
+            current.projectVersion !== identityArg.projectVersion) {
+            throw new Error('Project package identity changed during the matrix build');
+        }
+    }
+    async ensureLocalRunParent(parentArg) {
+        await fs.promises.mkdir(parentArg, { recursive: true, mode: 0o700 });
+        const stat = await fs.promises.lstat(parentArg);
+        if (!stat.isDirectory() || stat.isSymbolicLink()) {
+            throw new Error(`tsrust matrix state path is not a regular directory: ${parentArg}`);
+        }
+        const expectedPhysicalPath = path.join(await fs.promises.realpath(this.workspace), '.nogit', 'tsrust-matrix');
+        if ((await fs.promises.realpath(parentArg)) !== expectedPhysicalPath) {
+            throw new Error(`tsrust matrix state path traverses a symbolic link: ${parentArg}`);
+        }
+        if ((typeof process.getuid === 'function' && stat.uid !== process.getuid()) ||
+            (stat.mode & 0o077) !== 0) {
+            throw new Error(`tsrust matrix state path has unsafe ownership or permissions: ${parentArg}`);
+        }
+        const retainedRuns = (await fs.promises.readdir(parentArg, { withFileTypes: true })).filter((entry) => entry.isDirectory());
+        if (retainedRuns.length >= maximumRetainedDiagnosticRuns) {
+            throw new Error(`tsrust matrix retains at most ${maximumRetainedDiagnosticRuns} failed local runs; inspect and remove the reported paths before retrying`);
+        }
+    }
+    async buildLocalWorker(workerArg, bundlePathArg, runDirectoryArg, gitCommitArg, identityArg, binariesArg) {
+        const workerParent = path.join(runDirectoryArg, workerArg.host);
+        const workerWorkspace = path.join(workerParent, 'workspace');
+        const workerHome = path.join(workerParent, 'home');
+        const workerCargoHome = path.join(workerParent, 'cargo-home');
+        await fs.promises.mkdir(workerParent, { mode: 0o700 });
+        await fs.promises.mkdir(workerHome, { mode: 0o700 });
+        await fs.promises.mkdir(workerCargoHome, { mode: 0o700 });
+        const workerEnvironment = this.workerEnvironment(workerHome, workerCargoHome);
+        const buildDeadline = Date.now() + buildCommandTimeoutMs;
+        await this.commandRunner.execute('git', ['-c', 'advice.detachedHead=false', 'clone', '--quiet', bundlePathArg, workerWorkspace], {
+            cwd: this.workspace,
+            timeoutMs: Math.min(capabilityCommandTimeoutMs, this.remainingBuildTimeout(buildDeadline, workerArg.host)),
+        });
+        await this.assertWorkerSource(workerWorkspace, gitCommitArg, buildDeadline, workerArg.host);
+        await this.commandRunner.execute('pnpm', ['install', '--frozen-lockfile'], {
+            cwd: workerWorkspace,
+            timeoutMs: this.remainingBuildTimeout(buildDeadline, workerArg.host),
+            environment: workerEnvironment,
+        });
+        await this.assertInstalledTsrustVersion(workerWorkspace);
+        this.remainingBuildTimeout(buildDeadline, workerArg.host);
+        await this.commandRunner.execute('pnpm', this.workerTsrustArgs(workerArg), {
+            cwd: workerWorkspace,
+            timeoutMs: this.remainingBuildTimeout(buildDeadline, workerArg.host),
+            environment: workerEnvironment,
+        });
+        await this.assertWorkerSource(workerWorkspace, gitCommitArg, buildDeadline, workerArg.host);
+        const artifactDirectory = path.join(workerWorkspace, 'dist_rust');
+        await this.assertArtifactDirectory(artifactDirectory, workerArg, binariesArg, gitCommitArg, identityArg);
+        this.remainingBuildTimeout(buildDeadline, workerArg.host);
+        await this.smokeLocalArtifacts(artifactDirectory, workerArg, binariesArg, workerEnvironment, buildDeadline);
+        await this.assertWorkerSource(workerWorkspace, gitCommitArg, buildDeadline, workerArg.host);
+        return artifactDirectory;
+    }
+    workerTsrustArgs(workerArg) {
+        return [
+            'exec',
+            'tsrust',
+            ...workerArg.targets.flatMap((target) => ['--target', target.friendly]),
+        ];
+    }
+    async assertWorkerSource(workspaceArg, gitCommitArg, buildDeadlineArg, workerArg) {
+        const commit = await this.commandRunner.execute('git', ['rev-parse', 'HEAD'], {
+            cwd: workspaceArg,
+            capture: true,
+            timeoutMs: Math.min(capabilityCommandTimeoutMs, this.remainingBuildTimeout(buildDeadlineArg, workerArg)),
+        });
+        if (commit.stdout.trim() !== gitCommitArg) {
+            throw new Error(`Matrix worker cloned the wrong Git commit: ${workspaceArg}`);
+        }
+        const status = await this.commandRunner.execute('git', ['status', '--porcelain=v1', '--untracked-files=all'], {
+            cwd: workspaceArg,
+            capture: true,
+            timeoutMs: Math.min(capabilityCommandTimeoutMs, this.remainingBuildTimeout(buildDeadlineArg, workerArg)),
+        });
+        if (status.stdout.length > 0) {
+            throw new Error(`Matrix worker source is dirty: ${workspaceArg}`);
+        }
+        const index = await this.commandRunner.execute('git', ['ls-files', '-v', '-z'], {
+            cwd: workspaceArg,
+            capture: true,
+            timeoutMs: Math.min(capabilityCommandTimeoutMs, this.remainingBuildTimeout(buildDeadlineArg, workerArg)),
+        });
+        if (index.stdout
+            .split('\0')
+            .some((entry) => entry.length > 0 && !entry.startsWith('H '))) {
+            throw new Error(`Matrix worker source uses unsafe Git index flags: ${workspaceArg}`);
+        }
+    }
+    async assertArtifactDirectory(directoryArg, workerArg, binariesArg, gitCommitArg, identityArg) {
+        const expectedNames = artifactNamesFor(workerArg, binariesArg);
+        const actualNames = (await fs.promises.readdir(directoryArg)).sort();
+        if (JSON.stringify(actualNames) !== JSON.stringify(expectedNames)) {
+            throw new Error(`Unexpected ${workerArg.host} matrix artifacts: ${actualNames.join(', ')}`);
+        }
+        let aggregateBytes = 0;
+        for (const target of workerArg.targets) {
+            for (const binary of binariesArg) {
+                const binaryPath = path.join(directoryArg, `${binary}_${target.friendly}`);
+                const binaryStat = await fs.promises.lstat(binaryPath);
+                if (!binaryStat.isFile() || binaryStat.isSymbolicLink() || !(binaryStat.mode & 0o111)) {
+                    throw new Error(`Matrix artifact is not an executable regular file: ${binaryPath}`);
+                }
+                if (binaryStat.size > MAX_ARTIFACT_BYTES) {
+                    throw new Error(`Matrix artifact exceeds the size limit: ${binaryPath}`);
+                }
+                const sidecarStat = await fs.promises.lstat(ProvenanceStore.sidecarPath(binaryPath));
+                if (!sidecarStat.isFile() || sidecarStat.isSymbolicLink()) {
+                    throw new Error(`Matrix provenance is not a regular file: ${binaryPath}`);
+                }
+                if (sidecarStat.size > MAX_PROVENANCE_SIDECAR_BYTES) {
+                    throw new Error(`Matrix provenance exceeds the size limit: ${binaryPath}`);
+                }
+                aggregateBytes += binaryStat.size + sidecarStat.size;
+                if (aggregateBytes > MAX_ASSEMBLY_INPUT_BYTES) {
+                    throw new Error('Matrix artifacts exceed the aggregate size limit');
+                }
+                const buildInfo = await ProvenanceStore.readSidecar(binaryPath);
+                if (buildInfo.binary !== binary ||
+                    buildInfo.target !== target.friendly ||
+                    buildInfo.projectName !== identityArg.projectName ||
+                    buildInfo.projectVersion !== identityArg.projectVersion ||
+                    buildInfo.gitCommit !== gitCommitArg ||
+                    buildInfo.gitDirty !== false ||
+                    buildInfo.tsrustVersion !== commitinfo.version) {
+                    throw new Error(`Matrix provenance does not match the build request: ${binaryPath}`);
+                }
+            }
+        }
+    }
+    async smokeLocalArtifacts(directoryArg, workerArg, binariesArg, environmentArg, buildDeadlineArg) {
+        if (!this.plan.smokeTestArgs)
+            return;
+        for (const target of workerArg.targets) {
+            for (const binary of binariesArg) {
+                const binaryPath = path.join(directoryArg, `${binary}_${target.friendly}`);
+                if (target.friendly.startsWith('macos_')) {
+                    const architecture = target.friendly === 'macos_arm64' ? '-arm64' : '-x86_64';
+                    await this.commandRunner.execute('/usr/bin/arch', [architecture, binaryPath, ...this.plan.smokeTestArgs], {
+                        cwd: directoryArg,
+                        timeoutMs: Math.min(capabilityCommandTimeoutMs, this.remainingBuildTimeout(buildDeadlineArg, workerArg.host)),
+                        environment: environmentArg,
+                    });
+                }
+                else {
+                    await this.commandRunner.execute(binaryPath, this.plan.smokeTestArgs, {
+                        cwd: directoryArg,
+                        timeoutMs: Math.min(capabilityCommandTimeoutMs, this.remainingBuildTimeout(buildDeadlineArg, workerArg.host)),
+                        environment: environmentArg,
+                    });
+                }
+            }
+        }
+    }
+    describeRemoteWorkspace(workerArg, runtimeArg, gitCommitArg) {
+        const ownerToken = crypto.randomUUID();
+        const directory = `${runtimeArg.temporaryRoot}/tsrust-matrix.${gitCommitArg}.${workerArg.host}.${ownerToken}`;
+        return { worker: workerArg, runtime: runtimeArg, directory, ownerToken, gitCommit: gitCommitArg };
+    }
+    async createRemoteWorkspace(remoteArg, gitCommitArg) {
+        const { ownerToken, directory } = remoteArg;
+        const ownerContents = `${ownerToken}\n${gitCommitArg}\n${directory}`;
+        const ownerPath = `${directory}/${matrixOwnerFileName}`;
+        const script = [
+            'set -eu',
+            'umask 077',
+            ...this.remoteRootValidationCommands(remoteArg.runtime.temporaryRoot),
+            `test "$(find "$root" -mindepth 1 -maxdepth 1 -type d -name 'tsrust-matrix.*' | wc -l | tr -d ' ')" -lt ${maximumRetainedDiagnosticRuns}`,
+            `directory=${shellQuote(directory)}`,
+            `test "$directory" = ${shellQuote(directory)}`,
+            'created=0',
+            `cleanup_unowned() { if [ "$created" = 1 ]; then rm -f ${shellQuote(ownerPath)}; rmdir "$directory" 2>/dev/null || true; fi; }`,
+            'trap cleanup_unowned EXIT HUP INT TERM',
+            'mkdir -m 700 "$directory"',
+            'created=1',
+            `printf '%s\n' ${shellQuote(ownerToken)} ${shellQuote(gitCommitArg)} ${shellQuote(directory)} > ${shellQuote(ownerPath)}`,
+            `chmod 600 ${shellQuote(ownerPath)}`,
+            `test ! -L ${shellQuote(ownerPath)}`,
+            `test "$(cat ${shellQuote(ownerPath)})" = ${shellQuote(ownerContents)}`,
+            'trap - EXIT HUP INT TERM',
+        ].join('\n');
+        await this.runRemoteLoginScript(remoteArg.worker, remoteArg.runtime, script, capabilityCommandTimeoutMs);
+    }
+    async buildSshWorker(remoteArg, bundlePathArg, runDirectoryArg, gitCommitArg, identityArg, binariesArg) {
+        const buildDeadline = Date.now() + buildCommandTimeoutMs;
+        const remoteBundle = `${remoteArg.directory}/source.bundle`;
+        const remoteWorkspace = `${remoteArg.directory}/workspace`;
+        const remoteBundleTemporary = `${remoteBundle}.${crypto.randomUUID()}.tmp`;
+        await this.runRemoteTransferScript(remoteArg, [
+            `bundle=${shellQuote(remoteBundle)}`,
+            `bundle_temporary=${shellQuote(remoteBundleTemporary)}`,
+            'trap \'rm -f "$bundle_temporary"\' EXIT HUP INT TERM',
+            'cat > "$bundle_temporary"',
+            'chmod 600 "$bundle_temporary"',
+            'mv "$bundle_temporary" "$bundle"',
+            'trap - EXIT HUP INT TERM',
+        ].join('\n'), {
+            inputFile: bundlePathArg,
+            timeoutMs: this.remainingBuildTimeout(buildDeadline, remoteArg.worker.host),
+        });
+        const expectedNames = artifactNamesFor(remoteArg.worker, binariesArg);
+        const remoteDist = `${remoteWorkspace}/dist_rust`;
+        const remoteHome = `${remoteArg.directory}/home`;
+        const remoteCargoHome = `${remoteArg.directory}/cargo-home`;
+        const buildCommands = [
+            'set -eu',
+            ...this.remoteRootValidationCommands(remoteArg.runtime.temporaryRoot),
+            ...this.remoteOwnershipValidationCommands(remoteArg, gitCommitArg),
+            `bundle=${shellQuote(remoteBundle)}`,
+            `workspace=${shellQuote(remoteWorkspace)}`,
+            `expected_commit=${shellQuote(gitCommitArg)}`,
+            `mkdir -m 700 ${shellQuote(remoteHome)} ${shellQuote(remoteCargoHome)}`,
+            'git -c advice.detachedHead=false clone --quiet "$bundle" "$workspace"',
+            'cd "$workspace"',
+            'test "$(git rev-parse HEAD)" = "$expected_commit"',
+            'test -z "$(git status --porcelain=v1 --untracked-files=all)"',
+            `test -z "$(git ls-files -v | grep -v '^H ' || true)"`,
+            this.remoteWorkerEnvironmentFunction(remoteHome, remoteCargoHome),
+            ['run_matrix_worker', 'pnpm', 'install', '--frozen-lockfile']
+                .map(shellQuote)
+                .join(' '),
+            [
+                'run_matrix_worker',
+                'node',
+                '-e',
+                `const value = require('./node_modules/@git.zone/tsrust/package.json'); if (value.name !== '@git.zone/tsrust' || value.version !== ${JSON.stringify(commitinfo.version)}) process.exit(1);`,
+            ]
+                .map(shellQuote)
+                .join(' '),
+            ['run_matrix_worker', 'pnpm', ...this.workerTsrustArgs(remoteArg.worker)]
+                .map(shellQuote)
+                .join(' '),
+            'test "$(git rev-parse HEAD)" = "$expected_commit"',
+            'test -z "$(git status --porcelain=v1 --untracked-files=all)"',
+            `test -z "$(git ls-files -v | grep -v '^H ' || true)"`,
+            `actual_names="$(find ${shellQuote(remoteDist)} -mindepth 1 -maxdepth 1 -exec basename {} \\; | LC_ALL=C sort)"`,
+            `test "$actual_names" = ${shellQuote(expectedNames.join('\n'))}`,
+            ...expectedNames.map((name) => `test -f ${shellQuote(`${remoteDist}/${name}`)}; test ! -L ${shellQuote(`${remoteDist}/${name}`)}`),
+            'artifact_total=0',
+            ...expectedNames.map((name) => {
+                const artifactPath = `${remoteDist}/${name}`;
+                const maximumBytes = name.endsWith(PROVENANCE_SIDECAR_SUFFIX)
+                    ? MAX_PROVENANCE_SIDECAR_BYTES
+                    : MAX_ARTIFACT_BYTES;
+                return `if [ "$(uname -s)" = Darwin ]; then artifact_size="$(stat -f %z ${shellQuote(artifactPath)})"; else artifact_size="$(stat -c %s ${shellQuote(artifactPath)})"; fi; test "$artifact_size" -le ${maximumBytes}; artifact_total=$((artifact_total + artifact_size)); test "$artifact_total" -le ${MAX_ASSEMBLY_INPUT_BYTES}`;
+            }),
+            ...remoteArg.worker.targets.flatMap((target) => binariesArg.map((binary) => `test -x ${shellQuote(`${remoteDist}/${binary}_${target.friendly}`)}`)),
+            ...this.remoteSmokeCommands(remoteArg.worker, remoteDist, binariesArg),
+            'test "$(git rev-parse HEAD)" = "$expected_commit"',
+            'test -z "$(git status --porcelain=v1 --untracked-files=all)"',
+            `test -z "$(git ls-files -v | grep -v '^H ' || true)"`,
+        ];
+        await this.runRemoteOwnedScript(remoteArg.worker, remoteArg.runtime, buildCommands.join('\n'), this.remainingBuildTimeout(buildDeadline, remoteArg.worker.host));
+        const localArtifactDirectory = path.join(runDirectoryArg, remoteArg.worker.host, 'artifacts');
+        await fs.promises.mkdir(localArtifactDirectory, { recursive: true, mode: 0o700 });
+        let downloadedBytes = 0;
+        for (const name of expectedNames) {
+            const remoteFile = `${remoteDist}/${name}`;
+            const localFile = path.join(localArtifactDirectory, name);
+            const maximumBytes = name.endsWith(PROVENANCE_SIDECAR_SUFFIX)
+                ? MAX_PROVENANCE_SIDECAR_BYTES
+                : MAX_ARTIFACT_BYTES;
+            const blockSize = 1024 * 1024;
+            const blockCount = Math.ceil(maximumBytes / blockSize) + 1;
+            try {
+                await this.runRemoteTransferScript(remoteArg, [
+                    `file=${shellQuote(remoteFile)}`,
+                    `test "$file" = ${shellQuote(remoteFile)}`,
+                    'test -f "$file"',
+                    'test ! -L "$file"',
+                    'if [ "$(uname -s)" = Darwin ]; then file_size="$(stat -f %z "$file")"; else file_size="$(stat -c %s "$file")"; fi',
+                    `test "$file_size" -le ${maximumBytes}`,
+                    `dd if="$file" bs=${blockSize} count=${blockCount} 2>/dev/null`,
+                ].join('\n'), {
+                    outputFile: localFile,
+                    maximumOutputBytes: maximumBytes,
+                    timeoutMs: this.remainingBuildTimeout(buildDeadline, remoteArg.worker.host),
+                });
+                const downloaded = await fs.promises.lstat(localFile);
+                if (!downloaded.isFile() || downloaded.isSymbolicLink() || downloaded.size > maximumBytes) {
+                    throw new Error(`Remote matrix artifact exceeds its size limit: ${name}`);
+                }
+                downloadedBytes += downloaded.size;
+                if (downloadedBytes > MAX_ASSEMBLY_INPUT_BYTES) {
+                    throw new Error('Remote matrix artifacts exceed the aggregate size limit');
+                }
+                await fs.promises.chmod(localFile, name.endsWith(PROVENANCE_SIDECAR_SUFFIX) ? 0o644 : 0o755);
+            }
+            catch (error) {
+                await fs.promises.rm(localFile, { force: true });
+                throw error;
+            }
+        }
+        await this.assertArtifactDirectory(localArtifactDirectory, remoteArg.worker, binariesArg, gitCommitArg, identityArg);
+        this.remainingBuildTimeout(buildDeadline, remoteArg.worker.host);
+        return localArtifactDirectory;
+    }
+    remoteSmokeCommands(workerArg, directoryArg, binariesArg) {
+        if (!this.plan.smokeTestArgs)
+            return [];
+        const commands = [];
+        for (const target of workerArg.targets) {
+            for (const binary of binariesArg) {
+                const binaryPath = `${directoryArg}/${binary}_${target.friendly}`;
+                if (target.friendly.startsWith('macos_')) {
+                    const architecture = target.friendly === 'macos_arm64' ? '-arm64' : '-x86_64';
+                    commands.push([
+                        'run_matrix_worker',
+                        '/usr/bin/arch',
+                        architecture,
+                        binaryPath,
+                        ...this.plan.smokeTestArgs,
+                    ]
+                        .map(shellQuote)
+                        .join(' '));
+                }
+                else {
+                    commands.push(['run_matrix_worker', binaryPath, ...this.plan.smokeTestArgs]
+                        .map(shellQuote)
+                        .join(' '));
+                }
+            }
+        }
+        return commands;
+    }
+    async cleanupRemoteWorkspace(remoteArg, gitCommitArg) {
+        const script = [
+            'set -eu',
+            ...this.remoteRootValidationCommands(remoteArg.runtime.temporaryRoot),
+            ...this.remoteOwnershipValidationCommands(remoteArg, gitCommitArg),
+            'rm -rf "$directory"',
+        ].join('\n');
+        await this.runRemoteLoginScript(remoteArg.worker, remoteArg.runtime, script, capabilityCommandTimeoutMs);
+    }
+    async runRemoteTransferScript(remoteArg, scriptArg, optionsArg) {
+        const details = expectedHostDetails(remoteArg.worker.host);
+        const guardedScript = [
+            'set -eu',
+            `test "$(uname -s)" = ${shellQuote(details.system)}`,
+            `test "$(uname -m)" = ${shellQuote(details.machine)}`,
+            ...this.remoteRootValidationCommands(remoteArg.runtime.temporaryRoot),
+            ...this.remoteOwnershipValidationCommands(remoteArg, remoteArg.gitCommit),
+            scriptArg,
+        ].join('\n');
+        await this.commandRunner.execute('ssh', [
+            '-T',
+            ...sshConnectionArgs,
+            '--',
+            remoteArg.runtime.destination,
+            `/bin/sh -c ${shellQuote(guardedScript)}`,
+        ], {
+            cwd: this.workspace,
+            timeoutMs: optionsArg.timeoutMs,
+            inputFile: optionsArg.inputFile,
+            outputFile: optionsArg.outputFile,
+            maximumOutputBytes: optionsArg.maximumOutputBytes,
+            environment: this.transportEnvironment(),
+        });
+    }
+    async runRemoteLoginScript(workerArg, runtimeArg, scriptArg, timeoutMsArg) {
+        const shell = workerArg.host.startsWith('macos_') ? '/bin/zsh' : '/bin/bash';
+        const shellFlags = workerArg.host.startsWith('macos_') ? '-lic' : '-lc';
+        const details = expectedHostDetails(workerArg.host);
+        const guardedScript = [
+            'set -eu',
+            `test "$(uname -s)" = ${shellQuote(details.system)}`,
+            `test "$(uname -m)" = ${shellQuote(details.machine)}`,
+            scriptArg,
+        ].join('\n');
+        await this.commandRunner.execute('ssh', [
+            ...sshConnectionArgs,
+            '--',
+            runtimeArg.destination,
+            `${shell} ${shellFlags} ${shellQuote(guardedScript)}`,
+        ], {
+            cwd: this.workspace,
+            timeoutMs: timeoutMsArg,
+            environment: this.transportEnvironment(),
+        });
+    }
+    async runRemoteOwnedScript(workerArg, runtimeArg, scriptArg, timeoutMsArg) {
+        const shell = workerArg.host.startsWith('macos_') ? '/bin/zsh' : '/bin/bash';
+        const outerFlags = workerArg.host.startsWith('macos_') ? '-lic' : '-lc';
+        const details = expectedHostDetails(workerArg.host);
+        const guardedScript = [
+            'set -eu',
+            `test "$(uname -s)" = ${shellQuote(details.system)}`,
+            `test "$(uname -m)" = ${shellQuote(details.machine)}`,
+            scriptArg,
+        ].join('\n');
+        const watchdogCommand = ['node', '-e', remoteWatchdogSource, shell, guardedScript]
+            .map(shellQuote)
+            .join(' ');
+        await this.commandRunner.execute('ssh', [
+            ...sshConnectionArgs,
+            '--',
+            runtimeArg.destination,
+            `${shell} ${outerFlags} ${shellQuote(watchdogCommand)}`,
+        ], {
+            cwd: this.workspace,
+            timeoutMs: timeoutMsArg,
+            heartbeatStdin: true,
+            environment: this.transportEnvironment(),
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nativematrixbuilder.js","sourceRoot":"","sources":["../../ts/mod_matrix/classes.nativematrixbuilder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,GAEzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EACL,0BAA0B,EAC1B,kBAAkB,EAClB,4BAA4B,EAC5B,yBAAyB,EACzB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAsB,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EACL,mBAAmB,GAGpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,iBAAiB,GAIlB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,0BAA0B,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;AACjD,MAAM,qBAAqB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAC7C,MAAM,6BAA6B,GAAG,CAAC,CAAC;AACxC,MAAM,iBAAiB,GAAG;IACxB,IAAI;IACJ,wBAAwB;IACxB,IAAI;IACJ,uBAAuB;CACxB,CAAC;AACF,MAAM,mBAAmB,GAAG,sBAAsB,CAAC;AACnD,MAAM,2BAA2B,GAAG,mCAAmC,CAAC;AACxE,MAAM,6BAA6B,GAAG;IACpC,MAAM;IACN,MAAM;IACN,SAAS;IACT,OAAO;IACP,QAAQ;IACR,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,UAAU;IACV,MAAM;IACN,WAAW;IACX,IAAI;IACJ,aAAa;CACL,CAAC;AACX,MAAM,yBAAyB,GAAG;IAChC,MAAM;IACN,MAAM;IACN,MAAM;IACN,SAAS;IACT,OAAO;IACP,eAAe;IACf,eAAe;IACf,QAAQ;IACR,KAAK;IACL,MAAM;IACN,MAAM;IACN,QAAQ;IACR,UAAU;IACV,MAAM;IACN,WAAW;IACX,IAAI;CACI,CAAC;AACX,MAAM,gCAAgC,GAAG;IACvC,gCAAgC;IAChC,oCAAoC;IACpC,uDAAuD;IACvD,uCAAuC;IACvC,8EAA8E;IAC9E,4EAA4E;IAC5E,sDAAsD;IACtD,6CAA6C;IAC7C,yCAAyC;IACzC,2CAA2C;IAC3C,oEAAoE;IACpE,qDAAqD;IACrD,mEAAmE;IACnE,yGAAyG;IACzG,+CAA+C;IAC/C,8GAA8G;IAC9G,6EAA6E;IAC7E,GAAG;CACJ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACb,MAAM,oBAAoB,GAAG;IAC3B,qDAAqD;IACrD,gCAAgC;IAChC,iCAAiC;IACjC,wHAAwH;IACxH,iCAAiC;IACjC,0BAA0B;IAC1B,iBAAiB;IACjB,uBAAuB;IACvB,iKAAiK;IACjK,yLAAyL;IACzL,kIAAkI;IAClI,0HAA0H;IAC1H,iSAAiS;IACjS,mCAAmC;IACnC,sKAAsK;IACtK,wIAAwI;IACxI,kEAAkE;IAClE,qDAAqD;IACrD,uDAAuD;IACvD,yBAAyB;IACzB,0DAA0D;IAC1D,6DAA6D;IAC7D,yBAAyB;IACzB,oBAAoB;IACpB,4CAA4C;IAC5C,gDAAgD;IAChD,6CAA6C;IAC7C,kCAAkC;IAClC,qGAAqG;IACrG,4BAA4B;IAC5B,8CAA8C;IAC9C,mFAAmF;IACnF,oGAAoG;IACpG,WAAW;CACZ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAgCb,MAAM,UAAU,GAAG,CAAC,QAAgB,EAAU,EAAE,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC;AAExF,MAAM,mBAAmB,GAAG,CAC1B,OAAoB,EACqD,EAAE;IAC3E,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,aAAa;YAChB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;QAChD,KAAK,aAAa;YAChB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;QACjD,KAAK,aAAa;YAChB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;QACjD,KAAK,aAAa;YAChB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IAClD,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CACvB,SAAgC,EAChC,WAAqB,EACX,EAAE,CACZ,SAAS,CAAC,OAAO;KACd,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAClB,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;IAC7B,MAAM,UAAU,GAAG,GAAG,MAAM,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;IAClD,OAAO,CAAC,UAAU,EAAE,GAAG,UAAU,GAAG,yBAAyB,EAAE,CAAC,CAAC;AACnE,CAAC,CAAC,CACH;KACA,IAAI,EAAE,CAAC;AAEZ,MAAM,kBAAkB,GAAG,CAAC,SAAiB,EAAsB,EAAE;IACnE,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,aAAa;YAChB,OAAO,sBAAsB,CAAC;QAChC,KAAK,aAAa;YAChB,OAAO,uBAAuB,CAAC;QACjC,KAAK,kBAAkB;YACrB,OAAO,uBAAuB,CAAC;QACjC,KAAK,kBAAkB;YACrB,OAAO,wBAAwB,CAAC;QAClC;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,OAAO,mBAAmB;IACb,SAAS,CAAS;IAClB,WAAW,CAAoB;IAC/B,aAAa,CAAuB;IACpC,IAAI,CAAsB;IAE3C,YAAY,UAAuC;QACjD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,UAAU,CAAC,WAAW,IAAI,EAAE,CAAC,EAAE,CAAC;QACzE,IAAI,CAAC,aAAa;YAChB,UAAU,CAAC,aAAa,IAAI,IAAI,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACxE,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACjD,IAAI,CAAC,6BAA6B,EAAE,CAAC;IACvC,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,MAAM,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAC1C,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,WAAW,CAAC,EAAE;YACrD,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,0BAA0B;SACtC,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE;YACtD,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,0BAA0B;SACtC,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,4BAA4B,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACxD,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YACvC,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,KAAK,OAAO,EAAE,CAAC;gBACxC,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,MAAM,SAAS,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3D,IAAI,CAAC,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC3D,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;QACjE,CAAC;QACD,IAAI,SAAS,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC;YACjF,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;QACvE,CAAC;QACD,MAAM,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACrD,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QACnB,0BAA0B,CAAC,SAAS,EAAE,MAAM,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAChF,MAAM,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAC1C,0BAA0B,CAAC,SAAS,EAAE,MAAM,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAChF,MAAM,eAAe,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACnD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAChD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC;QACvE,MAAM,IAAI,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;QAC3C,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,OAAO,CAC5C,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAC1D,CAAC;QACF,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;QAC5D,MAAM,iBAAiB,GAAa,EAAE,CAAC;QACvC,MAAM,gBAAgB,GAAuB,EAAE,CAAC;QAChD,IAAI,SAAS,GAAG,KAAK,CAAC;QAEtB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE;gBAChF,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,EAAE;gBACxE,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;YACH,0BAA0B,CAAC,SAAS,EAAE,MAAM,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;YAEhF,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACvC,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,KAAK,OAAO,EAAE,CAAC;oBACxC,iBAAiB,CAAC,IAAI,CACpB,MAAM,IAAI,CAAC,gBAAgB,CACzB,MAAM,EACN,UAAU,EACV,YAAY,EACZ,SAAS,CAAC,MAAM,EAChB,eAAe,EACf,QAAQ,CACT,CACF,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,MAAM,eAAe,GAAG,IAAI,CAAC,uBAAuB,CAClD,MAAM,EACN,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAC7B,SAAS,CAAC,MAAM,CACjB,CAAC;oBACF,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;oBACvC,MAAM,IAAI,CAAC,qBAAqB,CAAC,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;oBACpE,iBAAiB,CAAC,IAAI,CACpB,MAAM,IAAI,CAAC,cAAc,CACvB,eAAe,EACf,UAAU,EACV,YAAY,EACZ,SAAS,CAAC,MAAM,EAChB,eAAe,EACf,QAAQ,CACT,CACF,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,MAAM,eAAe,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACjE,0BAA0B,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;YACvD,IAAI,CAAC,8BAA8B,CAAC,eAAe,CAAC,CAAC;YACrD,OAAO,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACnC,MAAM,eAAe,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;gBAC5C,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;gBACrE,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC3B,CAAC;YACD,MAAM,qBAAqB,GAAG,MAAM,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACvE,0BAA0B,CAAC,SAAS,EAAE,qBAAqB,CAAC,CAAC;YAC7D,IAAI,CAAC,8BAA8B,CAAC,eAAe,CAAC,CAAC;YACrD,MAAM,QAAQ,GAAG,MAAM,IAAI,iBAAiB,CAAC;gBAC3C,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,iBAAiB;gBACjB,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe;gBAC1C,gBAAgB,EAAE,QAAQ;gBAC1B,mBAAmB,EAAE,eAAe,CAAC,WAAW;gBAChD,sBAAsB,EAAE,eAAe,CAAC,cAAc;gBACtD,iBAAiB,EAAE,SAAS,CAAC,MAAM;gBACnC,qBAAqB,EAAE,UAAU,CAAC,OAAO;aAC1C,CAAC,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,QAAQ,CAAC,cAAc,EAAE,CAAC;gBAC5B,OAAO,CAAC,IAAI,CAAC,2EAA2E,CAAC,CAAC;YAC5F,CAAC;YACD,SAAS,GAAG,IAAI,CAAC;YACjB,IAAI,CAAC;gBACH,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC1D,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,IAAI,CACV,iEAAiE,YAAY,KAC3E,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,CACH,CAAC;YACJ,CAAC;YACD,OAAO;gBACL,GAAG,IAAI,CAAC,WAAW,EAAE;gBACrB,SAAS,EAAE,SAAS,CAAC,MAAM;gBAC3B,QAAQ;aACT,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,+CAA+C,YAAY,EAAE,CAAC,CAAC;gBAC7E,KAAK,MAAM,eAAe,IAAI,gBAAgB,EAAE,CAAC;oBAC/C,OAAO,CAAC,KAAK,CACX,GAAG,eAAe,CAAC,MAAM,CAAC,IAAI,qCAAqC,eAAe,CAAC,SAAS,EAAE,CAC/F,CAAC;gBACJ,CAAC;gBACD,OAAO,CAAC,KAAK,CAAC,0EAA0E,CAAC,CAAC;YAC5F,CAAC;QACH,CAAC;IACH,CAAC;IAEO,WAAW;QACjB,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;YACvD,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC;SACpE,CAAC;IACJ,CAAC;IAEO,6BAA6B;QACnC,MAAM,OAAO,GAAG,IAAI,GAAG,CACrB,CAAC,IAAI,CAAC,WAAW,CAAC,2BAA2B,CAAC,IAAI,EAAE,CAAC;aAClD,KAAK,CAAC,GAAG,CAAC;aACV,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;aAC1B,MAAM,CAAC,OAAO,CAAC,CACnB,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAS;YAC/B,GAAG,6BAA6B;YAChC,GAAG,yBAAyB;YAC5B,MAAM;YACN,YAAY;YACZ,2BAA2B;SAC5B,CAAC,CAAC;QACH,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CACnD,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CACnD,CAAC;QACF,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzB,MAAM,IAAI,KAAK,CACb,+CAA+C,2BAA2B,KAAK,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACtG,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,iBAAiB,CAAC,OAAe,EAAE,YAAoB;QAC7D,MAAM,WAAW,GAAsB,EAAE,CAAC;QAC1C,KAAK,MAAM,IAAI,IAAI;YACjB,GAAG,6BAA6B;YAChC,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB;SAChC,EAAE,CAAC;YACF,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,SAAS;gBAAE,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACvF,CAAC;QACD,WAAW,CAAC,IAAI,GAAG,OAAO,CAAC;QAC3B,WAAW,CAAC,UAAU,GAAG,YAAY,CAAC;QACtC,IAAI,CAAC,WAAW,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;YACtD,WAAW,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,oBAAoB;QAC1B,MAAM,WAAW,GAAsB,EAAE,CAAC;QAC1C,KAAK,MAAM,IAAI,IAAI,CAAC,GAAG,yBAAyB,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC;YACnF,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,SAAS;gBAAE,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACvF,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,qBAAqB,CAAC,WAAmB,EAAE,SAAsB;QACvE,MAAM,SAAS,GAAG,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC3C,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,iBAAiB,SAAS,oCAAoC,CAAC,CAAC;QAClF,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,4BAA4B,CAAC,YAAoB;QAC7D,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,YAAY,EACZ,cAAc,EACd,WAAW,EACX,QAAQ,EACR,cAAc,CACf,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,CAG7E,CAAC;QACF,IAAI,WAAW,CAAC,IAAI,KAAK,kBAAkB,IAAI,WAAW,CAAC,OAAO,KAAK,UAAU,CAAC,OAAO,EAAE,CAAC;YAC1F,MAAM,IAAI,KAAK,CACb,wBAAwB,MAAM,CAAC,WAAW,CAAC,OAAO,IAAI,SAAS,CAAC,+BAA+B,UAAU,CAAC,OAAO,EAAE,CACpH,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,uBAAuB,CAAC,YAAoB;QACxD,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CACpD,KAAK,EACL,CAAC,MAAM,EAAE,GAAG,YAAY,oBAAoB,CAAC,EAC7C;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,0BAA0B;SACtC,CACF,CAAC;QACF,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,MAAM,CAA4B,CAAC;QAClF,MAAM,eAAe,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAAC;QAC1D,MAAM,aAAa,GAAG,iBAAiB,CAAC,eAAgC,CAAC,CAAC;QAC1E,IAAI,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YAChE,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;IAEO,+BAA+B,CAAC,OAAe,EAAE,YAAoB;QAC3E,MAAM,KAAK,GAAG;YACZ,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,6BAA6B,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;SAChF,CAAC;QACF,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,IAAI,QAAQ,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC5E,OAAO,wFAAwF,WAAW,SAAS,UAAU,CAAC,OAAO,CAAC,eAAe,UAAU,CAAC,YAAY,CAAC,4CAA4C,CAAC;IAC5N,CAAC;IAEO,KAAK,CAAC,4BAA4B;QACxC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC7C,KAAK,EACL,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,EAC7B;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,0BAA0B;SACtC,CACF,CAAC;QACF,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;YAChD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;YAChF,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE;YAC1E,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,0BAA0B;SACtC,CAAC,CAAC;QACH,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC9B,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CACjD,KAAK,EACL,CAAC,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,CAAC,EACzC;gBACE,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,KAAK,EAAE,OAAO,CAAC,MAAM;gBACrB,SAAS,EAAE,0BAA0B;aACtC,CACF,CAAC;YACF,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC7C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;gBAC1D,IAAI,CAAC,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC1D,MAAM,IAAI,KAAK,CACb,yDAAyD,MAAM,CAAC,KAAK,CAAC,EAAE,CACzE,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CACxD,KAAK,EACL;YACE,MAAM;YACN,IAAI;YACJ,IAAI;YACJ,IAAI;YACJ,IAAI;YACJ,mBAAmB;YACnB,MAAM;YACN,IAAI;SACL,EACD;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,0BAA0B;YACrC,gBAAgB,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;SACzB,CACF,CAAC;QACF,KAAK,MAAM,SAAS,IAAI,iBAAiB,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;YAC7E,MAAM,QAAQ,GAAG,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAChF,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,QAAQ,QAAQ,EAAE,CAAC,EAAE;gBACpF,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;YACH,IACE,0GAA0G,CAAC,IAAI,CAC7G,OAAO,CAAC,MAAM,CACf,EACD,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,uDAAuD,QAAQ,EAAE,CAAC,CAAC;YACrF,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,SAAgC;QAC7D,MAAM,UAAU,GAAG,kBAAkB,CAAC,IAAI,gBAAgB,EAAE,CAAC,aAAa,EAAE,CAAC,CAAC;QAC9E,IAAI,UAAU,KAAK,SAAS,CAAC,IAAI,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CACb,gCAAgC,SAAS,CAAC,IAAI,uBAAuB,UAAU,EAAE,CAClF,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC/C,MAAM,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;IAC5C,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,OAAoB;QACpD,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC,EAAE;gBACvD,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;YACH,cAAc,GAAG,IAAI,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,cAAc,GAAG,KAAK,CAAC;QACzB,CAAC;QACD,IAAI,cAAc,EAAE,CAAC;YACnB,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,EAAE;gBACxD,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,EAAE,CAAC;YAChD,IAAI,MAAM,gBAAgB,CAAC,WAAW,EAAE,EAAE,CAAC;gBACzC,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,EAC5C,CAAC,WAAW,CAAC,EACb;oBACE,GAAG,EAAE,IAAI,CAAC,SAAS;oBACnB,OAAO,EAAE,IAAI;oBACb,SAAS,EAAE,0BAA0B;iBACtC,CACF,CAAC;gBACF,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,EAC7C,CAAC,WAAW,CAAC,EACb;oBACE,GAAG,EAAE,IAAI,CAAC,SAAS;oBACnB,OAAO,EAAE,IAAI;oBACb,SAAS,EAAE,0BAA0B;iBACtC,CACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE;oBACtD,GAAG,EAAE,IAAI,CAAC,SAAS;oBACnB,OAAO,EAAE,IAAI;oBACb,SAAS,EAAE,0BAA0B;iBACtC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QACD,IAAI,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE;gBAC7D,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,WAAW,CAAC,EAAE;gBACpD,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI;gBACb,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,SAAgC;QAChE,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACvC,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,IAAI;gBAAE,SAAS;YACjD,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChF,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;gBAC9E,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC,YAAY,EAAE,eAAe,CAAC,EAAE;oBACjF,GAAG,EAAE,IAAI,CAAC,SAAS;oBACnB,SAAS,EAAE,0BAA0B;iBACtC,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YACD,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChF,MAAM,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC1D,SAAS;YACX,CAAC;YACD,MAAM,IAAI,KAAK,CACb,iBAAiB,SAAS,CAAC,IAAI,mCAAmC,MAAM,CAAC,QAAQ,EAAE,CACpF,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,6BAA6B,CAAC,SAAiB;QAC3D,MAAM,QAAQ,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,8CAA8C,SAAS,EAAE,CAAC,CAAC;QAC7E,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,EAAE,sBAAsB,CAAC,CAAC;QAChF,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACvE,MAAM,cAAc,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,CAAC;YACxD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;YACtD,MAAM,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,EAAE,gCAAgC,CAAC,CAAC;YAC1E,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,QAAQ,EACR,CAAC,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,CAAC,EAChD;gBACE,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,SAAS,EAAE,0BAA0B;aACtC,CACF,CAAC;YACF,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,EAAE;gBAC/C,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,SAAS,EAAE,0BAA0B;aACtC,CAAC,CAAC;QACL,CAAC;gBAAS,CAAC;YACT,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,cAAc,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,SAAgC;QACvD,IAAI,SAAS,CAAC,MAAM,CAAC,SAAS,KAAK,KAAK,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CAAC,iBAAiB,SAAS,CAAC,IAAI,4BAA4B,CAAC,CAAC;QAC/E,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACpF,MAAM,aAAa,GAAG,CACpB,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAClE,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QACtB,IAAI,CAAC,wCAAwC,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAChE,MAAM,IAAI,KAAK,CACb,GAAG,SAAS,CAAC,MAAM,CAAC,cAAc,sEAAsE,CACzG,CAAC;QACJ,CAAC;QACD,IACE,CAAC,sBAAsB,CAAC,IAAI,CAAC,aAAa,CAAC;YAC3C,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,aAAa;YACrD,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,EACnD,CAAC;YACD,MAAM,IAAI,KAAK,CACb,GAAG,SAAS,CAAC,MAAM,CAAC,gBAAgB,uDAAuD,CAC5F,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,CAAC;IACxC,CAAC;IAEO,KAAK,CAAC,cAAc,CAC1B,SAAgC,EAChC,UAA8B;QAE9B,MAAM,OAAO,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,cAAc,GAAG,GAAG,UAAU,CAAC,aAAa,wBAAwB,KAAK,EAAE,CAAC;QAClF,MAAM,QAAQ,GAAG;YACf,SAAS;YACT,WAAW;YACX,wBAAwB,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACpD,wBAAwB,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YACrD,2BAA2B;YAC3B,4BAA4B;YAC5B,4BAA4B;YAC5B,IAAI,CAAC,gCAAgC,EAAE;YACvC,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,gCAAgC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,GAAG,CAAC,OAAO,CAAC,MAAM,KAAK,QAAQ;gBAC7B,CAAC,CAAC,CAAC,+BAA+B,CAAC;gBACnC,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC;YACjC,GAAG,IAAI,CAAC,4BAA4B,CAAC,UAAU,CAAC,aAAa,CAAC;YAC9D,0GAA0G,6BAA6B,EAAE;YACzI,SAAS,UAAU,CAAC,cAAc,CAAC,EAAE;YACrC,mBAAmB,UAAU,CAAC,cAAc,CAAC,EAAE;YAC/C,WAAW;YACX,sEAAsE;YACtE,sCAAsC;YACtC,uBAAuB;YACvB,WAAW;YACX,GAAG,IAAI,CAAC,4BAA4B,CAAC,SAAS,EAAE,cAAc,CAAC;YAC/D,iBAAiB;YACjB,WAAW;YACX,0BAA0B;SAC3B,CAAC;QACF,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,oBAAoB,CAC7B,SAAS,EACT,UAAU,EACV,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EACnB,0BAA0B,CAC3B,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CACb,GAAG,SAAS,CAAC,IAAI,uDAAuD,cAAc,KACpF,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CACvD,EAAE,EACF,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,gCAAgC;QACtC,MAAM,IAAI,GAAG,gBAAgB,CAAC,aAAa,CAAC;QAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QAC7D,MAAM,WAAW,GAAG,GAAG,IAAI,eAAe,CAAC;QAC3C,OAAO,gJAAgJ,UAAU,CAAC,WAAW,CAAC,8BAA8B,UAAU,CAAC,KAAK,CAAC,cAAc,UAAU,CAAC,MAAM,CAAC,oBAAoB,UAAU,CAAC,gCAAgC,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,MAAM,CAAC,KAAK,UAAU,CAAC,KAAK,CAAC,0BAA0B,UAAU,CAAC,MAAM,CAAC,oCAAoC,UAAU,CAAC,KAAK,CAAC,cAAc,UAAU,CAAC,MAAM,CAAC,sDAAsD,CAAC;IAC5kB,CAAC;IAEO,4BAA4B,CAAC,OAAe;QAClD,OAAO;YACL,QAAQ,UAAU,CAAC,OAAO,CAAC,EAAE;YAC7B,uFAAuF;YACvF,0CAA0C;YAC1C,oDAAoD;YACpD,mIAAmI;SACpI,CAAC;IACJ,CAAC;IAEO,iCAAiC,CACvC,SAA2B,EAC3B,YAAoB;QAEpB,MAAM,SAAS,GAAG,GAAG,SAAS,CAAC,SAAS,IAAI,mBAAmB,EAAE,CAAC;QAClE,MAAM,aAAa,GAAG,GAAG,SAAS,CAAC,UAAU,KAAK,YAAY,KAAK,SAAS,CAAC,SAAS,EAAE,CAAC;QACzF,OAAO;YACL,aAAa,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE;YAC9C,uBAAuB,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE;YACxD,sBAAsB;YACtB,wBAAwB;YACxB,kDAAkD;YAClD,yDAAyD;YACzD,6IAA6I;YAC7I,WAAW,UAAU,CAAC,SAAS,CAAC,EAAE;YAClC,aAAa,UAAU,CAAC,SAAS,CAAC,EAAE;YACpC,mBAAmB,UAAU,CAAC,SAAS,CAAC,6BAA6B;YACrE,0DAA0D,UAAU,CAAC,SAAS,CAAC,4CAA4C,UAAU,CAAC,SAAS,CAAC,qBAAqB;YACrK,eAAe,UAAU,CAAC,SAAS,CAAC,QAAQ,UAAU,CAAC,aAAa,CAAC,EAAE;SACxE,CAAC;IACJ,CAAC;IAEO,4BAA4B,CAClC,SAAgC,EAChC,iBAAyB;QAEzB,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACvC,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,IAAI;gBAAE,SAAS;YACjD,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChF,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;gBAC9E,QAAQ,CAAC,IAAI,CAAC,iBAAiB,YAAY,gBAAgB,CAAC,CAAC;gBAC7D,SAAS;YACX,CAAC;YACD,IAAI,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAChF,MAAM,QAAQ,GAAG,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBACrD,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,MAAM,IAAI,KAAK,CAAC,8CAA8C,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACnF,CAAC;gBACD,MAAM,UAAU,GAAG,GAAG,iBAAiB,UAAU,MAAM,CAAC,QAAQ,IAAI,CAAC;gBACrE,MAAM,UAAU,GAAG,GAAG,iBAAiB,UAAU,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACnE,QAAQ,CAAC,IAAI,CACX,kDAAkD,UAAU,CAAC,UAAU,CAAC,EAAE,EAC1E,GAAG,QAAQ,gBAAgB,UAAU,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,EAAE,EAChF,UAAU,CAAC,UAAU,CAAC,CACvB,CAAC;gBACF,SAAS;YACX,CAAC;YACD,MAAM,IAAI,KAAK,CACb,iBAAiB,SAAS,CAAC,IAAI,mCAAmC,MAAM,CAAC,QAAQ,EAAE,CACpF,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,iBAAiB;QAC7B,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;QACvD,MAAM,aAAa,GAAG,MAAM,IAAI,WAAW,CAAC,aAAa,CAAC,CAAC,KAAK,EAAE,CAAC;QACnE,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,CAAC;QACxD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QACD,KAAK,MAAM,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBACjD,MAAM,IAAI,KAAK,CAAC,+CAA+C,MAAM,EAAE,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,mBAAmB;QAC/B,KAAK,MAAM,aAAa,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC;YAChD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;YAC3D,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC,CAAC;gBACxE,IAAI,IAAI,CAAC,MAAM,EAAE;oBAAE,OAAO,SAAS,CAAC;YACtC,CAAC;YAAC,MAAM,CAAC;gBACP,mDAAmD;YACrD,CAAC;QACH,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IAEO,mBAAmB;QACzB,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAC5B,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CAC1B,CAAC;QAC3C,IAAI,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,WAAW,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YACpF,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;QACD,OAAO,EAAE,WAAW,EAAE,WAAW,CAAC,IAAI,EAAE,cAAc,EAAE,WAAW,CAAC,OAAO,EAAE,CAAC;IAChF,CAAC;IAEO,8BAA8B,CAAC,WAGtC;QACC,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3C,IACE,OAAO,CAAC,WAAW,KAAK,WAAW,CAAC,WAAW;YAC/C,OAAO,CAAC,cAAc,KAAK,WAAW,CAAC,cAAc,EACrD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAAC,SAAiB;QAClD,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACrE,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChD,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YACjD,MAAM,IAAI,KAAK,CAAC,wDAAwD,SAAS,EAAE,CAAC,CAAC;QACvF,CAAC;QACD,MAAM,oBAAoB,GAAG,IAAI,CAAC,IAAI,CACpC,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,EAC1C,QAAQ,EACR,eAAe,CAChB,CAAC;QACF,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,KAAK,oBAAoB,EAAE,CAAC;YACrE,MAAM,IAAI,KAAK,CAAC,uDAAuD,SAAS,EAAE,CAAC,CAAC;QACtF,CAAC;QACD,IACE,CAAC,OAAO,OAAO,CAAC,MAAM,KAAK,UAAU,IAAI,IAAI,CAAC,GAAG,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC;YACvE,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,EACzB,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,iEAAiE,SAAS,EAAE,CAAC,CAAC;QAChG,CAAC;QACD,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CACzF,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,EAAE,CAC/B,CAAC;QACF,IAAI,YAAY,CAAC,MAAM,IAAI,6BAA6B,EAAE,CAAC;YACzD,MAAM,IAAI,KAAK,CACb,iCAAiC,6BAA6B,2EAA2E,CAC1I,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAC5B,SAAgC,EAChC,aAAqB,EACrB,eAAuB,EACvB,YAAoB,EACpB,WAA4D,EAC5D,WAAqB;QAErB,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAChE,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;QAC7D,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;QACnD,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAC9D,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,YAAY,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACvD,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACrD,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1D,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;QAC9E,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,qBAAqB,CAAC;QACzD,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,KAAK,EACL,CAAC,IAAI,EAAE,2BAA2B,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,eAAe,CAAC,EACvF;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,0BAA0B,EAC1B,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,CAC1D;SACF,CACF,CAAC;QACF,MAAM,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5F,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,SAAS,EAAE,mBAAmB,CAAC,EAAE;YACzE,GAAG,EAAE,eAAe;YACpB,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC;YACpE,WAAW,EAAE,iBAAiB;SAC/B,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,4BAA4B,CAAC,eAAe,CAAC,CAAC;QACzD,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC1D,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE;YACzE,GAAG,EAAE,eAAe;YACpB,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC;YACpE,WAAW,EAAE,iBAAiB;SAC/B,CAAC,CAAC;QACH,MAAM,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5F,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;QAClE,MAAM,IAAI,CAAC,uBAAuB,CAChC,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,YAAY,EACZ,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC1D,MAAM,IAAI,CAAC,mBAAmB,CAC5B,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,iBAAiB,EACjB,aAAa,CACd,CAAC;QACF,MAAM,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5F,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAEO,gBAAgB,CAAC,SAAgC;QACvD,OAAO;YACL,MAAM;YACN,QAAQ;YACR,GAAG,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;SACxE,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAC9B,YAAoB,EACpB,YAAoB,EACpB,gBAAwB,EACxB,SAAsB;QAEtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE;YAC5E,GAAG,EAAE,YAAY;YACjB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,0BAA0B,EAC1B,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC,CACxD;SACF,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,YAAY,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,8CAA8C,YAAY,EAAE,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC7C,KAAK,EACL,CAAC,QAAQ,EAAE,gBAAgB,EAAE,uBAAuB,CAAC,EACrD;YACE,GAAG,EAAE,YAAY;YACjB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,0BAA0B,EAC1B,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC,CACxD;SACF,CACF,CAAC;QACF,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,kCAAkC,YAAY,EAAE,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE;YAC9E,GAAG,EAAE,YAAY;YACjB,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,0BAA0B,EAC1B,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC,CACxD;SACF,CAAC,CAAC;QACH,IACE,KAAK,CAAC,MAAM;aACT,KAAK,CAAC,IAAI,CAAC;aACX,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAC/D,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,qDAAqD,YAAY,EAAE,CAAC,CAAC;QACvF,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,uBAAuB,CACnC,YAAoB,EACpB,SAAgC,EAChC,WAAqB,EACrB,YAAoB,EACpB,WAA4D;QAE5D,MAAM,aAAa,GAAG,gBAAgB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC/D,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACrE,IAAI,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,CAAC;YAClE,MAAM,IAAI,KAAK,CACb,cAAc,SAAS,CAAC,IAAI,sBAAsB,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3E,CAAC;QACJ,CAAC;QACD,IAAI,cAAc,GAAG,CAAC,CAAC;QACvB,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACvC,KAAK,MAAM,MAAM,IAAI,WAAW,EAAE,CAAC;gBACjC,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,MAAM,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC3E,MAAM,UAAU,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;gBACvD,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,UAAU,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC,UAAU,CAAC,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC;oBACtF,MAAM,IAAI,KAAK,CAAC,sDAAsD,UAAU,EAAE,CAAC,CAAC;gBACtF,CAAC;gBACD,IAAI,UAAU,CAAC,IAAI,GAAG,kBAAkB,EAAE,CAAC;oBACzC,MAAM,IAAI,KAAK,CAAC,2CAA2C,UAAU,EAAE,CAAC,CAAC;gBAC3E,CAAC;gBACD,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,eAAe,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;gBACrF,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,WAAW,CAAC,cAAc,EAAE,EAAE,CAAC;oBAC1D,MAAM,IAAI,KAAK,CAAC,4CAA4C,UAAU,EAAE,CAAC,CAAC;gBAC5E,CAAC;gBACD,IAAI,WAAW,CAAC,IAAI,GAAG,4BAA4B,EAAE,CAAC;oBACpD,MAAM,IAAI,KAAK,CAAC,6CAA6C,UAAU,EAAE,CAAC,CAAC;gBAC7E,CAAC;gBACD,cAAc,IAAI,UAAU,CAAC,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC;gBACrD,IAAI,cAAc,GAAG,wBAAwB,EAAE,CAAC;oBAC9C,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;gBACtE,CAAC;gBACD,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;gBAChE,IACE,SAAS,CAAC,MAAM,KAAK,MAAM;oBAC3B,SAAS,CAAC,MAAM,KAAK,MAAM,CAAC,QAAQ;oBACpC,SAAS,CAAC,WAAW,KAAK,WAAW,CAAC,WAAW;oBACjD,SAAS,CAAC,cAAc,KAAK,WAAW,CAAC,cAAc;oBACvD,SAAS,CAAC,SAAS,KAAK,YAAY;oBACpC,SAAS,CAAC,QAAQ,KAAK,KAAK;oBAC5B,SAAS,CAAC,aAAa,KAAK,UAAU,CAAC,OAAO,EAC9C,CAAC;oBACD,MAAM,IAAI,KAAK,CAAC,uDAAuD,UAAU,EAAE,CAAC,CAAC;gBACvF,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAC/B,YAAoB,EACpB,SAAgC,EAChC,WAAqB,EACrB,cAAiC,EACjC,gBAAwB;QAExB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO;QACrC,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACvC,KAAK,MAAM,MAAM,IAAI,WAAW,EAAE,CAAC;gBACjC,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,GAAG,MAAM,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;gBAC3E,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACzC,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;oBAC9E,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,eAAe,EACf,CAAC,YAAY,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EACtD;wBACE,GAAG,EAAE,YAAY;wBACjB,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,0BAA0B,EAC1B,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC,IAAI,CAAC,CAC7D;wBACD,WAAW,EAAE,cAAc;qBAC5B,CACF,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;wBACpE,GAAG,EAAE,YAAY;wBACjB,SAAS,EAAE,IAAI,CAAC,GAAG,CACjB,0BAA0B,EAC1B,IAAI,CAAC,qBAAqB,CAAC,gBAAgB,EAAE,SAAS,CAAC,IAAI,CAAC,CAC7D;wBACD,WAAW,EAAE,cAAc;qBAC5B,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEO,uBAAuB,CAC7B,SAAgC,EAChC,UAA8B,EAC9B,YAAoB;QAEpB,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;QACvC,MAAM,SAAS,GAAG,GAAG,UAAU,CAAC,aAAa,kBAAkB,YAAY,IAAI,SAAS,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9G,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC;IACpG,CAAC;IAEO,KAAK,CAAC,qBAAqB,CACjC,SAA2B,EAC3B,YAAoB;QAEpB,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;QAC5C,MAAM,aAAa,GAAG,GAAG,UAAU,KAAK,YAAY,KAAK,SAAS,EAAE,CAAC;QACrE,MAAM,SAAS,GAAG,GAAG,SAAS,IAAI,mBAAmB,EAAE,CAAC;QACxD,MAAM,MAAM,GAAG;YACb,SAAS;YACT,WAAW;YACX,GAAG,IAAI,CAAC,4BAA4B,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC;YACrE,0GAA0G,6BAA6B,EAAE;YACzI,aAAa,UAAU,CAAC,SAAS,CAAC,EAAE;YACpC,uBAAuB,UAAU,CAAC,SAAS,CAAC,EAAE;YAC9C,WAAW;YACX,yDAAyD,UAAU,CAAC,SAAS,CAAC,iDAAiD;YAC/H,wCAAwC;YACxC,2BAA2B;YAC3B,WAAW;YACX,iBAAiB,UAAU,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,YAAY,CAAC,IAAI,UAAU,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,SAAS,CAAC,EAAE;YACzH,aAAa,UAAU,CAAC,SAAS,CAAC,EAAE;YACpC,aAAa,UAAU,CAAC,SAAS,CAAC,EAAE;YACpC,eAAe,UAAU,CAAC,SAAS,CAAC,QAAQ,UAAU,CAAC,aAAa,CAAC,EAAE;YACvE,0BAA0B;SAC3B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,MAAM,IAAI,CAAC,oBAAoB,CAC7B,SAAS,CAAC,MAAM,EAChB,SAAS,CAAC,OAAO,EACjB,MAAM,EACN,0BAA0B,CAC3B,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,cAAc,CAC1B,SAA2B,EAC3B,aAAqB,EACrB,eAAuB,EACvB,YAAoB,EACpB,WAA4D,EAC5D,WAAqB;QAErB,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,qBAAqB,CAAC;QACzD,MAAM,YAAY,GAAG,GAAG,SAAS,CAAC,SAAS,gBAAgB,CAAC;QAC5D,MAAM,eAAe,GAAG,GAAG,SAAS,CAAC,SAAS,YAAY,CAAC;QAC3D,MAAM,qBAAqB,GAAG,GAAG,YAAY,IAAI,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC;QAC3E,MAAM,IAAI,CAAC,uBAAuB,CAChC,SAAS,EACT;YACE,UAAU,UAAU,CAAC,YAAY,CAAC,EAAE;YACpC,oBAAoB,UAAU,CAAC,qBAAqB,CAAC,EAAE;YACvD,sDAAsD;YACtD,2BAA2B;YAC3B,+BAA+B;YAC/B,kCAAkC;YAClC,0BAA0B;SAC3B,CAAC,IAAI,CAAC,IAAI,CAAC,EACZ;YACE,SAAS,EAAE,aAAa;YACxB,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC;SAC5E,CACF,CAAC;QACF,MAAM,aAAa,GAAG,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QACtE,MAAM,UAAU,GAAG,GAAG,eAAe,YAAY,CAAC;QAClD,MAAM,UAAU,GAAG,GAAG,SAAS,CAAC,SAAS,OAAO,CAAC;QACjD,MAAM,eAAe,GAAG,GAAG,SAAS,CAAC,SAAS,aAAa,CAAC;QAC5D,MAAM,aAAa,GAAG;YACpB,SAAS;YACT,GAAG,IAAI,CAAC,4BAA4B,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC;YACrE,GAAG,IAAI,CAAC,iCAAiC,CAAC,SAAS,EAAE,YAAY,CAAC;YAClE,UAAU,UAAU,CAAC,YAAY,CAAC,EAAE;YACpC,aAAa,UAAU,CAAC,eAAe,CAAC,EAAE;YAC1C,mBAAmB,UAAU,CAAC,YAAY,CAAC,EAAE;YAC7C,gBAAgB,UAAU,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,eAAe,CAAC,EAAE;YACvE,uEAAuE;YACvE,iBAAiB;YACjB,mDAAmD;YACnD,8DAA8D;YAC9D,sDAAsD;YACtD,IAAI,CAAC,+BAA+B,CAAC,UAAU,EAAE,eAAe,CAAC;YACjE,CAAC,mBAAmB,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,CAAC;iBAC1D,GAAG,CAAC,UAAU,CAAC;iBACf,IAAI,CAAC,GAAG,CAAC;YACZ;gBACE,mBAAmB;gBACnB,MAAM;gBACN,IAAI;gBACJ,qIAAqI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,oBAAoB;aAC5L;iBACE,GAAG,CAAC,UAAU,CAAC;iBACf,IAAI,CAAC,GAAG,CAAC;YACZ,CAAC,mBAAmB,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;iBACtE,GAAG,CAAC,UAAU,CAAC;iBACf,IAAI,CAAC,GAAG,CAAC;YACZ,mDAAmD;YACnD,8DAA8D;YAC9D,sDAAsD;YACtD,wBAAwB,UAAU,CAAC,UAAU,CAAC,kEAAkE;YAChH,0BAA0B,UAAU,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE;YAChE,GAAG,aAAa,CAAC,GAAG,CAClB,CAAC,IAAI,EAAE,EAAE,CACP,WAAW,UAAU,CAAC,GAAG,UAAU,IAAI,IAAI,EAAE,CAAC,eAAe,UAAU,CAAC,GAAG,UAAU,IAAI,IAAI,EAAE,CAAC,EAAE,CACrG;YACD,kBAAkB;YAClB,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC5B,MAAM,YAAY,GAAG,GAAG,UAAU,IAAI,IAAI,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC;oBAC3D,CAAC,CAAC,4BAA4B;oBAC9B,CAAC,CAAC,kBAAkB,CAAC;gBACvB,OAAO,mEAAmE,UAAU,CAAC,YAAY,CAAC,wCAAwC,UAAU,CAAC,YAAY,CAAC,qCAAqC,YAAY,oFAAoF,wBAAwB,EAAE,CAAC;YACpU,CAAC,CAAC;YACF,GAAG,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAC7C,WAAW,CAAC,GAAG,CACb,CAAC,MAAM,EAAE,EAAE,CAAC,WAAW,UAAU,CAAC,GAAG,UAAU,IAAI,MAAM,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,CAClF,CACF;YACD,GAAG,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,CAAC;YACtE,mDAAmD;YACnD,8DAA8D;YAC9D,sDAAsD;SACvD,CAAC;QACF,MAAM,IAAI,CAAC,oBAAoB,CAC7B,SAAS,CAAC,MAAM,EAChB,SAAS,CAAC,OAAO,EACjB,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EACxB,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CACjE,CAAC;QAEF,MAAM,sBAAsB,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;QAC9F,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,sBAAsB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAClF,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,KAAK,MAAM,IAAI,IAAI,aAAa,EAAE,CAAC;YACjC,MAAM,UAAU,GAAG,GAAG,UAAU,IAAI,IAAI,EAAE,CAAC;YAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,IAAI,CAAC,CAAC;YAC1D,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC;gBAC3D,CAAC,CAAC,4BAA4B;gBAC9B,CAAC,CAAC,kBAAkB,CAAC;YACvB,MAAM,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC;YAC9B,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;YAC3D,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,uBAAuB,CAChC,SAAS,EACT;oBACE,QAAQ,UAAU,CAAC,UAAU,CAAC,EAAE;oBAChC,kBAAkB,UAAU,CAAC,UAAU,CAAC,EAAE;oBAC1C,iBAAiB;oBACjB,mBAAmB;oBACnB,mHAAmH;oBACnH,yBAAyB,YAAY,EAAE;oBACvC,oBAAoB,SAAS,UAAU,UAAU,cAAc;iBAChE,CAAC,IAAI,CAAC,IAAI,CAAC,EACZ;oBACE,UAAU,EAAE,SAAS;oBACrB,kBAAkB,EAAE,YAAY;oBAChC,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC;iBAC5E,CACF,CAAC;gBACF,MAAM,UAAU,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBACtD,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,UAAU,CAAC,cAAc,EAAE,IAAI,UAAU,CAAC,IAAI,GAAG,YAAY,EAAE,CAAC;oBAC1F,MAAM,IAAI,KAAK,CAAC,kDAAkD,IAAI,EAAE,CAAC,CAAC;gBAC5E,CAAC;gBACD,eAAe,IAAI,UAAU,CAAC,IAAI,CAAC;gBACnC,IAAI,eAAe,GAAG,wBAAwB,EAAE,CAAC;oBAC/C,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;gBAC7E,CAAC;gBACD,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,CACrB,SAAS,EACT,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CACzD,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;gBACjD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QACD,MAAM,IAAI,CAAC,uBAAuB,CAChC,sBAAsB,EACtB,SAAS,CAAC,MAAM,EAChB,WAAW,EACX,YAAY,EACZ,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACjE,OAAO,sBAAsB,CAAC;IAChC,CAAC;IAEO,mBAAmB,CACzB,SAAgC,EAChC,YAAoB,EACpB,WAAqB;QAErB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO,EAAE,CAAC;QACxC,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACvC,KAAK,MAAM,MAAM,IAAI,WAAW,EAAE,CAAC;gBACjC,MAAM,UAAU,GAAG,GAAG,YAAY,IAAI,MAAM,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAClE,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACzC,MAAM,YAAY,GAAG,MAAM,CAAC,QAAQ,KAAK,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;oBAC9E,QAAQ,CAAC,IAAI,CACX;wBACE,mBAAmB;wBACnB,eAAe;wBACf,YAAY;wBACZ,UAAU;wBACV,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa;qBAC3B;yBACE,GAAG,CAAC,UAAU,CAAC;yBACf,IAAI,CAAC,GAAG,CAAC,CACb,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,QAAQ,CAAC,IAAI,CACX,CAAC,mBAAmB,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;yBAC1D,GAAG,CAAC,UAAU,CAAC;yBACf,IAAI,CAAC,GAAG,CAAC,CACb,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAClC,SAA2B,EAC3B,YAAoB;QAEpB,MAAM,MAAM,GAAG;YACb,SAAS;YACT,GAAG,IAAI,CAAC,4BAA4B,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC;YACrE,GAAG,IAAI,CAAC,iCAAiC,CAAC,SAAS,EAAE,YAAY,CAAC;YAClE,qBAAqB;SACtB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,MAAM,IAAI,CAAC,oBAAoB,CAC7B,SAAS,CAAC,MAAM,EAChB,SAAS,CAAC,OAAO,EACjB,MAAM,EACN,0BAA0B,CAC3B,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,uBAAuB,CACnC,SAA2B,EAC3B,SAAiB,EACjB,UAGC;QAED,MAAM,OAAO,GAAG,mBAAmB,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC3D,MAAM,aAAa,GAAG;YACpB,SAAS;YACT,wBAAwB,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACpD,wBAAwB,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YACrD,GAAG,IAAI,CAAC,4BAA4B,CAAC,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC;YACrE,GAAG,IAAI,CAAC,iCAAiC,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC;YACzE,SAAS;SACV,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,KAAK,EACL;YACE,IAAI;YACJ,GAAG,iBAAiB;YACpB,IAAI;YACJ,SAAS,CAAC,OAAO,CAAC,WAAW;YAC7B,cAAc,UAAU,CAAC,aAAa,CAAC,EAAE;SAC1C,EACD;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,UAAU,EAAE,UAAU,CAAC,UAAU;YACjC,kBAAkB,EAAE,UAAU,CAAC,kBAAkB;YACjD,WAAW,EAAE,IAAI,CAAC,oBAAoB,EAAE;SACzC,CACF,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAChC,SAAgC,EAChC,UAA8B,EAC9B,SAAiB,EACjB,YAAoB;QAEpB,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC;QAC7E,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;QACxE,MAAM,OAAO,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,aAAa,GAAG;YACpB,SAAS;YACT,wBAAwB,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACpD,wBAAwB,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YACrD,SAAS;SACV,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,KAAK,EACL;YACE,GAAG,iBAAiB;YACpB,IAAI;YACJ,UAAU,CAAC,WAAW;YACtB,GAAG,KAAK,IAAI,UAAU,IAAI,UAAU,CAAC,aAAa,CAAC,EAAE;SACtD,EACD;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,SAAS,EAAE,YAAY;YACvB,WAAW,EAAE,IAAI,CAAC,oBAAoB,EAAE;SACzC,CACF,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,oBAAoB,CAChC,SAAgC,EAChC,UAA8B,EAC9B,SAAiB,EACjB,YAAoB;QAEpB,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,WAAW,CAAC;QAC7E,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;QACxE,MAAM,OAAO,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACpD,MAAM,aAAa,GAAG;YACpB,SAAS;YACT,wBAAwB,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YACpD,wBAAwB,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE;YACrD,SAAS;SACV,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACb,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,aAAa,CAAC;aAC/E,GAAG,CAAC,UAAU,CAAC;aACf,IAAI,CAAC,GAAG,CAAC,CAAC;QACb,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAC9B,KAAK,EACL;YACE,GAAG,iBAAiB;YACpB,IAAI;YACJ,UAAU,CAAC,WAAW;YACtB,GAAG,KAAK,IAAI,UAAU,IAAI,UAAU,CAAC,eAAe,CAAC,EAAE;SACxD,EACD;YACE,GAAG,EAAE,IAAI,CAAC,SAAS;YACnB,SAAS,EAAE,YAAY;YACvB,cAAc,EAAE,IAAI;YACpB,WAAW,EAAE,IAAI,CAAC,oBAAoB,EAAE;SACzC,CACF,CAAC;IACJ,CAAC;CACF"}