@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.doc.js

@@ -0,0 +1,2976 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import * as plugins from './plugins.js';
+import { SmartdataDb } from './classes.db.js';
+import { logger } from './logging.js';
+import { SmartdataDbCursor } from './classes.cursor.js';
+import { runCursorOperation } from './classes.cursoroperation.js';
+import { insertBootstrapRecord, } from './classes.bootstraprecord.js';
+import { validateCollectionPreparationOptions, } from './classes.collectionpreparation.js';
+import { getOrdinaryPersistencePolicy, validateOrdinaryStoredDocument } from './classes.ordinarypersistence.js';
+import { inspectStoredDocuments, inspectStoredDocumentEvidence, } from './classes.storedinspection.js';
+import { SmartdataCollection, } from './classes.collection.js';
+import { SmartdataDbWatcher } from './classes.watcher.js';
+import { SmartdataLuceneAdapter } from './classes.lucene.adapter.js';
+import { executeAtomicDelete, executeAtomicDeleteMany } from './classes.atomicdelete.js';
+import { executeAtomicFindOneAndUpdate } from './classes.atomicfindoneandupdate.js';
+import { executeAtomicUpdate, executeAtomicUpdateMany } from './classes.atomicupdate.js';
+import { SmartdataPersistenceError, } from './classes.persistence.js';
+import { isOrdinarySessionInTransaction, runWithOrdinarySmartdataSession, } from './classes.session.js';
+import { getExpectedCollectionTopologyForModel, inspectCollectionTopologyForModel, } from './classes.collectiontopology.js';
+const exactPersistencePolicySymbol = Symbol.for('@push.rocks/smartdata.exactPersistencePolicy');
+/**
+ * Detects plain object literals only. Anything carrying a custom prototype
+ * (Date, ObjectId, Binary, Buffer, RegExp, Decimal128, class instances, ...) is
+ * deliberately excluded so that BSON types are never rebuilt or otherwise
+ * altered while stripping undefined values.
+ */
+const isPlainObject = (valueArg) => {
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(valueArg);
+    return prototype === Object.prototype || prototype === null;
+};
+/**
+ * Recursively drops object properties whose value is `undefined` so MongoDB
+ * stores them as absent rather than as BSON null.
+ *
+ * Notes on the deliberate boundaries of this traversal:
+ * - Array positions are preserved: an `undefined` element stays in place and is
+ *   serialized as null, exactly as `JSON.stringify` does. Removing it would
+ *   shift every following index.
+ * - Only plain objects are recursed into, so BSON types keep their identity.
+ * - On a circular structure the offending value is returned untouched, letting
+ *   BSON raise its usual "Cannot convert circular structure to BSON" error
+ *   instead of overflowing the stack here.
+ */
+const stripUndefinedValues = (valueArg, seenArg) => {
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return valueArg;
+    }
+    const isArray = Array.isArray(valueArg);
+    if (!isArray && !isPlainObject(valueArg)) {
+        return valueArg;
+    }
+    const seen = seenArg ?? new WeakSet();
+    if (seen.has(valueArg)) {
+        return valueArg;
+    }
+    seen.add(valueArg);
+    if (isArray) {
+        return valueArg.map((entryArg) => entryArg === undefined ? null : stripUndefinedValues(entryArg, seen));
+    }
+    const strippedObject = {};
+    for (const keyArg of Object.keys(valueArg)) {
+        const entry = valueArg[keyArg];
+        if (entry === undefined) {
+            continue;
+        }
+        strippedObject[keyArg] = stripUndefinedValues(entry, seen);
+    }
+    return strippedObject;
+};
+export function globalSvDb() {
+    return (value, context) => {
+        if (context.kind !== 'field') {
+            throw new Error('globalSvDb can only decorate fields');
+        }
+        // Store metadata at class level using Symbol.metadata
+        const metadata = context.metadata;
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'globalSaveableProperties')) {
+            metadata.globalSaveableProperties = [
+                ...(metadata.globalSaveableProperties || []),
+            ];
+        }
+        const propName = String(context.name);
+        if (!metadata.globalSaveableProperties.includes(propName)) {
+            metadata.globalSaveableProperties.push(propName);
+        }
+        // Use addInitializer to ensure prototype arrays are set up once
+        context.addInitializer(function () {
+            const proto = this.constructor.prototype;
+            const metadata = this.constructor[Symbol.metadata];
+            if (metadata && metadata.globalSaveableProperties && !proto.globalSaveableProperties) {
+                // Initialize prototype array from metadata (runs once per class)
+                proto.globalSaveableProperties = [...metadata.globalSaveableProperties];
+            }
+        });
+    };
+}
+/**
+ * saveable - saveable decorator to be used on class properties
+ */
+export function svDb(options) {
+    if (options?.numeric !== undefined && typeof options.numeric !== 'boolean') {
+        throw new SmartdataPersistenceError('invalid_configuration', 'svDb numeric must be a boolean.');
+    }
+    const storedOptions = options
+        ? {
+            ...options,
+            ...(options.atomicPaths !== undefined
+                ? {
+                    atomicPaths: Array.isArray(options.atomicPaths)
+                        ? [...options.atomicPaths]
+                        : options.atomicPaths,
+                }
+                : {}),
+        }
+        : undefined;
+    return (value, context) => {
+        if (context.kind !== 'field') {
+            throw new Error('svDb can only decorate fields');
+        }
+        const propName = String(context.name);
+        // Store metadata at class level using Symbol.metadata
+        const metadata = context.metadata;
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'saveableProperties')) {
+            metadata.saveableProperties = [...(metadata.saveableProperties || [])];
+        }
+        if (!metadata.saveableProperties.includes(propName)) {
+            metadata.saveableProperties.push(propName);
+        }
+        // Store options in metadata
+        if (storedOptions) {
+            if (!Object.prototype.hasOwnProperty.call(metadata, '_svDbOptions')) {
+                metadata._svDbOptions = { ...(metadata._svDbOptions || {}) };
+            }
+            metadata._svDbOptions[propName] = storedOptions;
+        }
+        // Use addInitializer to ensure prototype arrays are set up once
+        context.addInitializer(function () {
+            const proto = this.constructor.prototype;
+            const ctor = this.constructor;
+            const metadata = ctor[Symbol.metadata];
+            if (metadata && metadata.saveableProperties && !proto.saveableProperties) {
+                // Initialize prototype array from metadata (runs once per class)
+                proto.saveableProperties = [...metadata.saveableProperties];
+            }
+            // Initialize svDbOptions from metadata
+            if (metadata && metadata._svDbOptions && !ctor._svDbOptions) {
+                ctor._svDbOptions = { ...metadata._svDbOptions };
+            }
+        });
+    };
+}
+/**
+ * searchable - marks a property as searchable with Lucene query syntax
+ */
+export function searchable() {
+    return (value, context) => {
+        if (context.kind !== 'field') {
+            throw new Error('searchable can only decorate fields');
+        }
+        const propName = String(context.name);
+        // Store metadata at class level
+        const metadata = context.metadata;
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'searchableFields')) {
+            metadata.searchableFields = [...(metadata.searchableFields || [])];
+        }
+        if (!metadata.searchableFields.includes(propName)) {
+            metadata.searchableFields.push(propName);
+        }
+        // Use addInitializer to set up constructor property once
+        context.addInitializer(function () {
+            const ctor = this.constructor;
+            const metadata = ctor[Symbol.metadata];
+            if (metadata && metadata.searchableFields && !Array.isArray(ctor.searchableFields)) {
+                // Initialize from metadata (runs once per class)
+                ctor.searchableFields = [...metadata.searchableFields];
+            }
+        });
+    };
+}
+// Escape user input for safe use in MongoDB regular expressions
+function escapeForRegex(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * unique index - decorator to mark a unique index
+ */
+export function unI(optionsArg = {}) {
+    if (typeof optionsArg !== 'object'
+        || optionsArg === null
+        || Array.isArray(optionsArg)
+        || Object.keys(optionsArg).some((keyArg) => keyArg !== 'valueType')) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'unI options must be an object containing only valueType.');
+    }
+    const valueType = optionsArg.valueType ?? 'string';
+    if (valueType !== 'string' && valueType !== 'positiveSafeInteger') {
+        throw new SmartdataPersistenceError('invalid_configuration', 'unI valueType must be "string" or "positiveSafeInteger".');
+    }
+    return (value, context) => {
+        if (context.kind !== 'field') {
+            throw new Error('unI can only decorate fields');
+        }
+        const propName = String(context.name);
+        // Store metadata at class level
+        const metadata = context.metadata;
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'uniqueIndexes')) {
+            metadata.uniqueIndexes = [...(metadata.uniqueIndexes || [])];
+        }
+        if (!metadata.uniqueIndexes.includes(propName)) {
+            metadata.uniqueIndexes.push(propName);
+        }
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'identityValueTypes')) {
+            metadata.identityValueTypes = { ...(metadata.identityValueTypes || {}) };
+        }
+        const existingValueType = metadata.identityValueTypes[propName];
+        if (existingValueType && existingValueType !== valueType) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Identity field "${propName}" has divergent valueType declarations.`);
+        }
+        metadata.identityValueTypes[propName] = valueType;
+        // Also mark as saveable
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'saveableProperties')) {
+            metadata.saveableProperties = [...(metadata.saveableProperties || [])];
+        }
+        if (!metadata.saveableProperties.includes(propName)) {
+            metadata.saveableProperties.push(propName);
+        }
+        // Use addInitializer to ensure prototype arrays are set up once
+        context.addInitializer(function () {
+            const proto = this.constructor.prototype;
+            const metadata = this.constructor[Symbol.metadata];
+            if (metadata && metadata.uniqueIndexes && !proto.uniqueIndexes) {
+                proto.uniqueIndexes = [...metadata.uniqueIndexes];
+            }
+            if (metadata
+                && metadata.identityValueTypes
+                && !Object.prototype.hasOwnProperty.call(proto, 'identityValueTypes')) {
+                proto.identityValueTypes = { ...metadata.identityValueTypes };
+            }
+            if (metadata && metadata.saveableProperties && !proto.saveableProperties) {
+                proto.saveableProperties = [...metadata.saveableProperties];
+            }
+        });
+    };
+}
+/**
+ * index - decorator to mark a field for regular indexing
+ */
+export function index(options) {
+    return (value, context) => {
+        if (context.kind !== 'field') {
+            throw new Error('index can only decorate fields');
+        }
+        const propName = String(context.name);
+        // Store metadata at class level
+        const metadata = context.metadata;
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'regularIndexes')) {
+            metadata.regularIndexes = [...(metadata.regularIndexes || [])];
+        }
+        metadata.regularIndexes.push({
+            field: propName,
+            options: { ...(options || {}) }
+        });
+        // Also mark as saveable
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'saveableProperties')) {
+            metadata.saveableProperties = [...(metadata.saveableProperties || [])];
+        }
+        if (!metadata.saveableProperties.includes(propName)) {
+            metadata.saveableProperties.push(propName);
+        }
+        // Use addInitializer to ensure prototype arrays are set up once
+        context.addInitializer(function () {
+            const proto = this.constructor.prototype;
+            const metadata = this.constructor[Symbol.metadata];
+            if (metadata && metadata.regularIndexes && !proto.regularIndexes) {
+                proto.regularIndexes = [...metadata.regularIndexes];
+            }
+            if (metadata && metadata.saveableProperties && !proto.saveableProperties) {
+                proto.saveableProperties = [...metadata.saveableProperties];
+            }
+        });
+    };
+}
+const normalizeAtomicFindOneAndUpdateOptions = (optionsArg) => {
+    if (typeof optionsArg !== 'object'
+        || optionsArg === null
+        || plugins.nodeUtil.types.isProxy(optionsArg)
+        || !isPlainObject(optionsArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Atomic find-one-and-update options must be an inert plain object.');
+    }
+    const allowedKeys = new Set(['returnDocument', 'upsert', 'sort', 'session']);
+    const keys = Reflect.ownKeys(optionsArg);
+    for (const key of keys) {
+        if (typeof key !== 'string' || !allowedKeys.has(key)) {
+            throw new SmartdataPersistenceError('invalid_argument', `Atomic find-one-and-update received unsupported option "${String(key)}".`);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(optionsArg, key);
+        if (!descriptor || !('value' in descriptor) || descriptor.enumerable !== true) {
+            throw new SmartdataPersistenceError('invalid_argument', `Atomic find-one-and-update option "${key}" must be an inert enumerable data property.`);
+        }
+    }
+    const returnDocumentDescriptor = Object.getOwnPropertyDescriptor(optionsArg, 'returnDocument');
+    if (!returnDocumentDescriptor
+        || !('value' in returnDocumentDescriptor)
+        || (returnDocumentDescriptor.value !== 'before'
+            && returnDocumentDescriptor.value !== 'after')) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Atomic find-one-and-update requires returnDocument to be "before" or "after".');
+    }
+    const upsertDescriptor = Object.getOwnPropertyDescriptor(optionsArg, 'upsert');
+    if (upsertDescriptor && upsertDescriptor.value !== undefined
+        && typeof upsertDescriptor.value !== 'boolean') {
+        throw new SmartdataPersistenceError('invalid_argument', 'Atomic find-one-and-update upsert must be a boolean.');
+    }
+    const sortDescriptor = Object.getOwnPropertyDescriptor(optionsArg, 'sort');
+    const sessionDescriptor = Object.getOwnPropertyDescriptor(optionsArg, 'session');
+    return {
+        returnDocument: returnDocumentDescriptor.value,
+        upsert: upsertDescriptor?.value === true,
+        ...(sortDescriptor?.value !== undefined
+            ? { sort: sortDescriptor.value }
+            : {}),
+        ...(sessionDescriptor?.value !== undefined
+            ? { session: sessionDescriptor.value }
+            : {}),
+    };
+};
+const normalizeAtomicExpressionUpdateOptions = (optionsArg) => {
+    if (optionsArg === undefined) {
+        return undefined;
+    }
+    if (typeof optionsArg !== 'object'
+        || optionsArg === null
+        || plugins.nodeUtil.types.isProxy(optionsArg)
+        || Object.getPrototypeOf(optionsArg) !== Object.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Atomic update options used with $expr must be an inert ordinary object.');
+    }
+    const allowedKeys = new Set(['upsert', 'session']);
+    const normalized = {};
+    for (const key of Reflect.ownKeys(optionsArg)) {
+        if (typeof key !== 'string' || !allowedKeys.has(key)) {
+            throw new SmartdataPersistenceError('invalid_argument', `Atomic update received unsupported option "${String(key)}".`);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(optionsArg, key);
+        if (!descriptor
+            || !('value' in descriptor)
+            || descriptor.enumerable !== true) {
+            throw new SmartdataPersistenceError('invalid_argument', `Atomic update option "${key}" must be an inert enumerable data property.`);
+        }
+        if (key === 'upsert') {
+            if (descriptor.value !== undefined
+                && typeof descriptor.value !== 'boolean') {
+                throw new SmartdataPersistenceError('invalid_argument', 'Atomic update upsert must be a boolean.');
+            }
+            if (descriptor.value !== undefined) {
+                normalized.upsert = descriptor.value;
+            }
+        }
+        else if (descriptor.value !== undefined) {
+            normalized.session = descriptor.value;
+        }
+    }
+    return normalized;
+};
+const reservedOrdinaryPersistenceFields = new Set([
+    '_id',
+    '_createdAt',
+    '_updatedAt',
+    '_smartdataRevision',
+]);
+const stringIdRootSets = new WeakSet();
+const requireBoundedInteger = (valueArg, labelArg, maximumArg) => {
+    if (valueArg === undefined) {
+        return undefined;
+    }
+    if (!Number.isSafeInteger(valueArg) ||
+        valueArg <= 0 ||
+        valueArg > maximumArg) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must be a positive safe integer no greater than ${maximumArg}.`);
+    }
+    return valueArg;
+};
+const requireDeclaredPath = (pathArg, declaredRootsArg, labelArg, declaredNestedPathsArg) => {
+    const pathSegments = typeof pathArg === 'string'
+        ? pathArg.split('.')
+        : [];
+    if (typeof pathArg !== 'string' ||
+        pathArg.length === 0 ||
+        pathArg.length > 1024 ||
+        pathArg.includes('\0') ||
+        pathArg.startsWith('$') ||
+        pathSegments.length > 32 ||
+        pathSegments.some((segmentArg) => (segmentArg.length === 0
+            || segmentArg.startsWith('$')
+            || segmentArg.includes('\0')
+            || unsafePersistedObjectKeys.has(segmentArg))) ||
+        (pathSegments.length > 1
+            && !declaredNestedPathsArg?.has(pathArg))) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains invalid persisted path "${pathArg}".`);
+    }
+    const root = pathSegments[0];
+    if ((reservedOrdinaryPersistenceFields.has(root) &&
+        !(root === '_id' && stringIdRootSets.has(declaredRootsArg))) ||
+        !declaredRootsArg.has(root)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} references undeclared or reserved persisted path "${pathArg}".`);
+    }
+    return root;
+};
+const unsafePersistedObjectKeys = new Set([
+    '__proto__',
+    'prototype',
+    'constructor',
+]);
+const assertSafePersistedValue = (valueArg, labelArg, seenArg = new WeakSet()) => {
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return;
+    }
+    if (seenArg.has(valueArg)) {
+        return;
+    }
+    seenArg.add(valueArg);
+    if (Array.isArray(valueArg)) {
+        for (const entryArg of valueArg) {
+            assertSafePersistedValue(entryArg, labelArg, seenArg);
+        }
+        return;
+    }
+    if (!isPlainObject(valueArg)) {
+        return;
+    }
+    for (const [keyArg, entryArg] of Object.entries(valueArg)) {
+        if (unsafePersistedObjectKeys.has(keyArg) ||
+            keyArg.startsWith('$') ||
+            keyArg.includes('.') ||
+            keyArg.includes('\0')) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains unsafe object key "${keyArg}".`);
+        }
+        assertSafePersistedValue(entryArg, labelArg, seenArg);
+    }
+};
+const atomicFilterComparisonOperators = new Set([
+    '$eq',
+    '$ne',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+]);
+const atomicFilterArrayOperators = new Set(['$in', '$nin']);
+const atomicFilterOperators = new Set([
+    ...atomicFilterComparisonOperators,
+    ...atomicFilterArrayOperators,
+    '$exists',
+    '$type',
+    '$regex',
+    '$options',
+    '$not',
+]);
+const atomicFilterBsonTypes = new Set([
+    ...Object.keys(plugins.mongodb.BSONType),
+    ...Object.values(plugins.mongodb.BSONType),
+]);
+const atomicBsonScalarPrototypes = new Map([
+    [plugins.mongodb.ObjectId.prototype, 'ObjectId'],
+    [plugins.mongodb.Binary.prototype, 'Binary'],
+    [plugins.mongodb.Decimal128.prototype, 'Decimal128'],
+    [plugins.mongodb.Long.prototype, 'Long'],
+    [plugins.mongodb.Int32.prototype, 'Int32'],
+    [plugins.mongodb.Double.prototype, 'Double'],
+    [plugins.mongodb.Timestamp.prototype, 'Timestamp'],
+    [plugins.mongodb.MinKey.prototype, 'MinKey'],
+    [plugins.mongodb.MaxKey.prototype, 'MaxKey'],
+]);
+const getTrustedAtomicBsonScalarType = (valueArg) => {
+    if (typeof valueArg !== 'object'
+        || valueArg === null
+        || plugins.nodeUtil.types.isProxy(valueArg)) {
+        return undefined;
+    }
+    const expectedType = atomicBsonScalarPrototypes.get(Object.getPrototypeOf(valueArg));
+    if (!expectedType) {
+        return undefined;
+    }
+    const ownBsonTypeDescriptor = Object.getOwnPropertyDescriptor(valueArg, '_bsontype');
+    if (ownBsonTypeDescriptor
+        && (!('value' in ownBsonTypeDescriptor)
+            || ownBsonTypeDescriptor.value !== expectedType)) {
+        return undefined;
+    }
+    return expectedType;
+};
+const hasAtomicBsonTypeClaim = (valueArg) => {
+    if (typeof valueArg !== 'object'
+        || valueArg === null
+        || plugins.nodeUtil.types.isProxy(valueArg)) {
+        return false;
+    }
+    for (let prototype = valueArg; prototype; prototype = Object.getPrototypeOf(prototype)) {
+        if (Object.getOwnPropertyDescriptor(prototype, '_bsontype')) {
+            return true;
+        }
+    }
+    return false;
+};
+const isAtomicMongoScalar = (valueArg) => {
+    if (typeof valueArg !== 'object'
+        || valueArg === null
+        || plugins.nodeUtil.types.isProxy(valueArg)) {
+        return false;
+    }
+    const valuePrototype = Object.getPrototypeOf(valueArg);
+    if (valuePrototype === Date.prototype
+        || valuePrototype === RegExp.prototype) {
+        return true;
+    }
+    if (ArrayBuffer.isView(valueArg)) {
+        return true;
+    }
+    return getTrustedAtomicBsonScalarType(valueArg) !== undefined;
+};
+const allowedAtomicBsonScalarTypes = new Set([
+    'ObjectId',
+    'Binary',
+    'Decimal128',
+    'Long',
+    'Int32',
+    'Double',
+    'Timestamp',
+    'MinKey',
+    'MaxKey',
+]);
+const requireSafeAtomicEqualityScalar = (valueArg, labelArg) => {
+    if (typeof valueArg === 'object'
+        && valueArg !== null
+        && plugins.nodeUtil.types.isProxy(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a Proxy object.`);
+    }
+    if (valueArg instanceof RegExp) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a regular expression as an equality value.`);
+    }
+    if (valueArg instanceof Date &&
+        Object.getPrototypeOf(valueArg) !== Date.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a Date subclass with custom BSON behavior.`);
+    }
+    const bsonType = getTrustedAtomicBsonScalarType(valueArg);
+    if (hasAtomicBsonTypeClaim(valueArg)
+        && (!bsonType
+            || !allowedAtomicBsonScalarTypes.has(bsonType))) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} uses an unsupported BSON equality scalar.`);
+    }
+};
+const requireUsableIdentityValue = (valueArg, labelArg, valueTypeArg) => {
+    if (valueTypeArg === 'positiveSafeInteger') {
+        if (typeof valueArg === 'number'
+            && Number.isSafeInteger(valueArg)
+            && valueArg > 0) {
+            return;
+        }
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must contain a positive safe integer identity value.`);
+    }
+    if (typeof valueArg !== 'string' || valueArg.trim().length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must contain a non-empty string identity value.`);
+    }
+};
+const assertUsableIdentityValues = (documentArg, identityFieldsArg, identityValueTypesArg) => {
+    for (const identityField of identityFieldsArg) {
+        requireUsableIdentityValue(documentArg[identityField], `Identity field "${identityField}"`, identityValueTypesArg?.[identityField] ?? 'string');
+    }
+};
+/**
+ * Validates the explicit `$eq` operand used for whole-object compare-and-set
+ * filters. Direct nested object selectors remain forbidden; the operator is
+ * required so object equality cannot be confused with query structure.
+ */
+const assertOnlyDataProperties = (valueArg, labelArg, arrayArg) => {
+    for (const ownKey of Reflect.ownKeys(valueArg)) {
+        if (typeof ownKey === 'symbol') {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain symbol properties.`);
+        }
+        if (arrayArg && ownKey === 'length') {
+            continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, ownKey);
+        if (!descriptor ||
+            !('value' in descriptor) ||
+            typeof descriptor.value === 'function') {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may contain only inert data properties.`);
+        }
+        if (!descriptor.enumerable && !arrayArg) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain hidden data properties.`);
+        }
+    }
+};
+const typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+const typedArrayBufferGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'buffer')?.get;
+const typedArrayByteOffsetGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteOffset')?.get;
+const typedArrayByteLengthGetter = Object.getOwnPropertyDescriptor(typedArrayPrototype, 'byteLength')?.get;
+const dataViewBufferGetter = Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer')?.get;
+const dataViewByteOffsetGetter = Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset')?.get;
+const dataViewByteLengthGetter = Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength')?.get;
+const regExpSourceGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'source')?.get;
+const regExpFlagGetters = [
+    ['d', 'hasIndices'],
+    ['g', 'global'],
+    ['i', 'ignoreCase'],
+    ['m', 'multiline'],
+    ['s', 'dotAll'],
+    ['u', 'unicode'],
+    ['v', 'unicodeSets'],
+    ['y', 'sticky'],
+].map(([flag, property]) => ({
+    flag,
+    getter: Object.getOwnPropertyDescriptor(RegExp.prototype, property)?.get,
+}));
+const getIntrinsicArrayBufferViewBytes = (valueArg, labelArg) => {
+    const readView = (bufferGetterArg, byteOffsetGetterArg, byteLengthGetterArg) => {
+        if (!bufferGetterArg
+            || !byteOffsetGetterArg
+            || !byteLengthGetterArg) {
+            return undefined;
+        }
+        try {
+            const buffer = Reflect.apply(bufferGetterArg, valueArg, []);
+            const byteOffset = Reflect.apply(byteOffsetGetterArg, valueArg, []);
+            const byteLength = Reflect.apply(byteLengthGetterArg, valueArg, []);
+            return new Uint8Array(buffer, byteOffset, byteLength);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const bytes = readView(typedArrayBufferGetter, typedArrayByteOffsetGetter, typedArrayByteLengthGetter)
+        || readView(dataViewBufferGetter, dataViewByteOffsetGetter, dataViewByteLengthGetter);
+    if (!bytes) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains an invalid ArrayBuffer view.`);
+    }
+    return bytes;
+};
+const createInertAtomicBsonScalarSnapshot = (valueArg, labelArg) => {
+    if (valueArg instanceof Date) {
+        if (Object.getPrototypeOf(valueArg) !== Date.prototype ||
+            Reflect.ownKeys(valueArg).length !== 0) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a customized Date value.`);
+        }
+        const snapshot = new Date(valueArg.getTime());
+        Object.defineProperty(snapshot, 'toBSON', {
+            value: undefined,
+            enumerable: false,
+        });
+        return snapshot;
+    }
+    if (ArrayBuffer.isView(valueArg)) {
+        assertOnlyDataProperties(valueArg, labelArg, false);
+        const snapshot = Uint8Array.from(getIntrinsicArrayBufferViewBytes(valueArg, labelArg));
+        Object.defineProperty(snapshot, 'toBSON', {
+            value: undefined,
+            enumerable: false,
+        });
+        return snapshot;
+    }
+    const originalBsonType = getTrustedAtomicBsonScalarType(valueArg);
+    if (!originalBsonType) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains an untrusted BSON scalar.`);
+    }
+    assertOnlyDataProperties(valueArg, labelArg, false);
+    for (let prototype = valueArg; prototype; prototype = Object.getPrototypeOf(prototype)) {
+        if (Object.getOwnPropertyDescriptor(prototype, 'toBSON')) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a custom BSON encoder.`);
+        }
+    }
+    try {
+        const snapshotDocument = plugins.mongodb.BSON.deserialize(plugins.mongodb.BSON.serialize({ value: valueArg }), {
+            promoteBuffers: false,
+            promoteValues: false,
+        });
+        const snapshot = snapshotDocument.value;
+        if (getTrustedAtomicBsonScalarType(snapshot) !== originalBsonType) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} changed BSON scalar type while being captured.`);
+        }
+        Object.defineProperty(snapshot, 'toBSON', {
+            value: undefined,
+            enumerable: false,
+        });
+        return snapshot;
+    }
+    catch (cause) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains an invalid BSON scalar.`, { cause });
+    }
+};
+const createSafeAtomicExactObjectEqualitySnapshot = (valueArg, labelArg, seenArg = new WeakSet()) => {
+    if (valueArg === undefined) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain undefined.`);
+    }
+    if (typeof valueArg === 'function'
+        || typeof valueArg === 'symbol') {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains a value that cannot be encoded as safe BSON.`);
+    }
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return valueArg;
+    }
+    if (plugins.nodeUtil.types.isProxy(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain Proxy objects.`);
+    }
+    if (seenArg.has(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain a circular object graph.`);
+    }
+    if (isAtomicMongoScalar(valueArg)) {
+        requireSafeAtomicEqualityScalar(valueArg, labelArg);
+        return createInertAtomicBsonScalarSnapshot(valueArg, labelArg);
+    }
+    if (!Array.isArray(valueArg) && !isPlainObject(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains an object with a custom BSON encoding boundary.`);
+    }
+    if (Array.isArray(valueArg) &&
+        Object.getPrototypeOf(valueArg) !== Array.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use an Array subclass.`);
+    }
+    assertOnlyDataProperties(valueArg, labelArg, Array.isArray(valueArg));
+    seenArg.add(valueArg);
+    if (Array.isArray(valueArg)) {
+        const snapshot = [];
+        for (let index = 0; index < valueArg.length; index++) {
+            if (!Object.prototype.hasOwnProperty.call(valueArg, index)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain sparse array positions.`);
+            }
+            snapshot.push(createSafeAtomicExactObjectEqualitySnapshot(valueArg[index], labelArg, seenArg));
+        }
+        seenArg.delete(valueArg);
+        Object.defineProperty(snapshot, 'toBSON', {
+            value: undefined,
+            enumerable: false,
+        });
+        return snapshot;
+    }
+    const snapshot = {};
+    for (const [keyArg, entryArg] of Object.entries(valueArg)) {
+        if (unsafePersistedObjectKeys.has(keyArg)
+            || keyArg === 'toBSON'
+            || keyArg === '_bsontype'
+            || keyArg.startsWith('$')
+            || keyArg.includes('.')
+            || keyArg.includes('\0')) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains unsafe object key "${keyArg}".`);
+        }
+        Object.defineProperty(snapshot, keyArg, {
+            value: createSafeAtomicExactObjectEqualitySnapshot(entryArg, labelArg, seenArg),
+            enumerable: true,
+            writable: false,
+            configurable: false,
+        });
+    }
+    seenArg.delete(valueArg);
+    Object.defineProperty(snapshot, 'toBSON', {
+        value: undefined,
+        enumerable: false,
+    });
+    return snapshot;
+};
+const createSafeAtomicFilterValueSnapshot = (valueArg, labelArg) => {
+    if (valueArg === undefined
+        || typeof valueArg === 'function'
+        || typeof valueArg === 'symbol') {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} contains a value that cannot be encoded as safe BSON.`);
+    }
+    if (typeof valueArg === 'object'
+        && valueArg !== null
+        && plugins.nodeUtil.types.isProxy(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a Proxy object.`);
+    }
+    if (Array.isArray(valueArg)) {
+        if (Object.getPrototypeOf(valueArg) !== Array.prototype) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use an Array subclass.`);
+        }
+        assertOnlyDataProperties(valueArg, labelArg, true);
+        const snapshot = [];
+        for (let index = 0; index < valueArg.length; index++) {
+            if (!Object.prototype.hasOwnProperty.call(valueArg, index)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain sparse array positions.`);
+            }
+            snapshot.push(createSafeAtomicFilterValueSnapshot(valueArg[index], labelArg));
+        }
+        return snapshot;
+    }
+    if (typeof valueArg !== 'object' || valueArg === null) {
+        return valueArg;
+    }
+    requireSafeAtomicEqualityScalar(valueArg, labelArg);
+    if (!isAtomicMongoScalar(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must be a scalar BSON value.`);
+    }
+    return createInertAtomicBsonScalarSnapshot(valueArg, labelArg);
+};
+const createSafeAtomicRegExpSnapshot = (valueArg, labelArg) => {
+    if (plugins.nodeUtil.types.isProxy(valueArg)
+        || Object.getPrototypeOf(valueArg) !== RegExp.prototype
+        || !regExpSourceGetter) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a Proxy or RegExp subclass.`);
+    }
+    const source = Reflect.apply(regExpSourceGetter, valueArg, []);
+    const flags = regExpFlagGetters
+        .filter(({ getter }) => getter && Reflect.apply(getter, valueArg, []))
+        .map(({ flag }) => flag)
+        .join('');
+    return new RegExp(source, flags);
+};
+const normalizeAtomicFilterCondition = (valueArg, labelArg, identityValueTypeArg) => {
+    if (valueArg === undefined) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain undefined.`);
+    }
+    if (typeof valueArg === 'object'
+        && valueArg !== null
+        && plugins.nodeUtil.types.isProxy(valueArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not use a Proxy object.`);
+    }
+    if (!isPlainObject(valueArg) || isAtomicMongoScalar(valueArg)) {
+        requireSafeAtomicEqualityScalar(valueArg, labelArg);
+        if (identityValueTypeArg) {
+            requireUsableIdentityValue(valueArg, labelArg, identityValueTypeArg);
+        }
+        return createSafeAtomicFilterValueSnapshot(valueArg, labelArg);
+    }
+    assertOnlyDataProperties(valueArg, labelArg, false);
+    const entries = Object.entries(valueArg);
+    if (entries.length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not be an empty object.`);
+    }
+    const operatorEntries = entries.filter(([key]) => key.startsWith('$'));
+    if (operatorEntries.length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must use supported field operators instead of a nested object selector.`);
+    }
+    if (operatorEntries.length !== entries.length) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not mix operator and literal object keys.`);
+    }
+    const normalized = {};
+    for (const [operator, operand] of operatorEntries) {
+        if (!atomicFilterOperators.has(operator)) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} uses unsupported operator "${operator}".`);
+        }
+        if (atomicFilterComparisonOperators.has(operator)) {
+            if (operator === '$eq'
+                && typeof operand === 'object'
+                && operand !== null
+                && !isAtomicMongoScalar(operand)) {
+                if (identityValueTypeArg) {
+                    requireUsableIdentityValue(operand, `${labelArg} ${operator}`, identityValueTypeArg);
+                }
+                normalized[operator] =
+                    createSafeAtomicExactObjectEqualitySnapshot(operand, `${labelArg} ${operator}`);
+                continue;
+            }
+            if (identityValueTypeArg) {
+                requireUsableIdentityValue(operand, `${labelArg} ${operator}`, identityValueTypeArg);
+            }
+            normalized[operator] = createSafeAtomicFilterValueSnapshot(operand, `${labelArg} ${operator}`);
+            continue;
+        }
+        if (atomicFilterArrayOperators.has(operator)) {
+            if (!Array.isArray(operand)
+                || plugins.nodeUtil.types.isProxy(operand)
+                || Object.getPrototypeOf(operand) !== Array.prototype) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} ${operator} must be an ordinary non-empty array.`);
+            }
+            assertOnlyDataProperties(operand, `${labelArg} ${operator}`, true);
+            if (operand.length === 0) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} ${operator} must be an ordinary non-empty array.`);
+            }
+            if (identityValueTypeArg) {
+                for (const entry of operand) {
+                    requireUsableIdentityValue(entry, `${labelArg} ${operator}`, identityValueTypeArg);
+                }
+            }
+            normalized[operator] = createSafeAtomicFilterValueSnapshot(operand, `${labelArg} ${operator}`);
+            continue;
+        }
+        if (operator === '$exists') {
+            if (typeof operand !== 'boolean') {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} $exists must be a boolean.`);
+            }
+            normalized[operator] = operand;
+            continue;
+        }
+        if (operator === '$type') {
+            if (!atomicFilterBsonTypes.has(operand)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} $type must use a MongoDB BSON type alias or numeric code.`);
+            }
+            normalized[operator] = operand;
+            continue;
+        }
+        if (operator === '$regex') {
+            if (typeof operand === 'string' && operand.length > 0) {
+                normalized[operator] = operand;
+                continue;
+            }
+            if (typeof operand !== 'object' || operand === null) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} $regex must be a non-empty string or RegExp.`);
+            }
+            normalized[operator] = createSafeAtomicRegExpSnapshot(operand, `${labelArg} ${operator}`);
+            continue;
+        }
+        if (operator === '$options') {
+            if (typeof operand !== 'string' ||
+                !/^[imsx]*$/.test(operand) ||
+                !('$regex' in valueArg)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} $options must contain only imsx flags and accompany $regex.`);
+            }
+            normalized[operator] = operand;
+            continue;
+        }
+        if (operator === '$not') {
+            if ((typeof operand === 'object'
+                && operand !== null
+                && plugins.nodeUtil.types.isProxy(operand))
+                ||
+                    !isPlainObject(operand) ||
+                Object.keys(operand).length === 0 ||
+                Object.keys(operand).some((key) => !key.startsWith('$'))) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} $not must contain a non-empty operator object.`);
+            }
+            assertOnlyDataProperties(operand, `${labelArg} $not`, false);
+            normalized[operator] = normalizeAtomicFilterCondition(operand, `${labelArg} $not`, identityValueTypeArg);
+        }
+    }
+    return normalized;
+};
+const atomicNumericExpressionMaximumDepth = 8;
+const atomicNumericExpressionMaximumAddOperands = 16;
+const atomicNumericExpressionMaximumLeafOperands = 64;
+const getAtomicExpressionProperty = (valueArg, expectedKeyArg, labelArg) => {
+    if (typeof valueArg !== 'object'
+        || valueArg === null
+        || Array.isArray(valueArg)
+        || plugins.nodeUtil.types.isProxy(valueArg)
+        || Object.getPrototypeOf(valueArg) !== Object.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must be an inert ordinary object containing only ${expectedKeyArg}.`);
+    }
+    const keys = Reflect.ownKeys(valueArg);
+    if (keys.length !== 1 || keys[0] !== expectedKeyArg) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must contain exactly the ${expectedKeyArg} operator.`);
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(valueArg, expectedKeyArg);
+    if (!descriptor
+        || !('value' in descriptor)
+        || descriptor.enumerable !== true) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} ${expectedKeyArg} must be an inert enumerable data property.`);
+    }
+    return descriptor.value;
+};
+const getAtomicExpressionArrayValues = (valueArg, minimumLengthArg, maximumLengthArg, labelArg) => {
+    if (typeof valueArg !== 'object'
+        || valueArg === null
+        || plugins.nodeUtil.types.isProxy(valueArg)
+        || !Array.isArray(valueArg)
+        || Object.getPrototypeOf(valueArg) !== Array.prototype) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must be an inert ordinary array.`);
+    }
+    const lengthDescriptor = Object.getOwnPropertyDescriptor(valueArg, 'length');
+    const length = lengthDescriptor && 'value' in lengthDescriptor
+        ? lengthDescriptor.value
+        : undefined;
+    if (!Number.isSafeInteger(length)
+        || length < minimumLengthArg
+        || length > maximumLengthArg) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must contain between ${minimumLengthArg} and ${maximumLengthArg} operands.`);
+    }
+    const ownKeys = Reflect.ownKeys(valueArg);
+    if (ownKeys.length !== length + 1 || !ownKeys.includes('length')) {
+        throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain sparse positions or extra properties.`);
+    }
+    const values = [];
+    for (let index = 0; index < length; index++) {
+        const key = String(index);
+        const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+        if (!descriptor
+            || !('value' in descriptor)
+            || descriptor.enumerable !== true) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may contain only dense enumerable data operands.`);
+        }
+        values.push(descriptor.value);
+    }
+    return values;
+};
+const normalizeAtomicNumericExpression = (expressionArg, declaredRootsArg, numericRootsArg, serializedRootsArg, operationLabelArg) => {
+    let leafOperandCount = 0;
+    const normalizeOperand = (operandArg, depthArg) => {
+        if (typeof operandArg === 'number') {
+            leafOperandCount++;
+            if (!Number.isFinite(operandArg)
+                || leafOperandCount > atomicNumericExpressionMaximumLeafOperands) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr requires finite numeric literals and no more than ${atomicNumericExpressionMaximumLeafOperands} leaf operands.`);
+            }
+            return {
+                mongoExpression: operandArg,
+                referencedFields: new Set(),
+            };
+        }
+        if (typeof operandArg === 'string') {
+            leafOperandCount++;
+            if (leafOperandCount > atomicNumericExpressionMaximumLeafOperands) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr may not exceed ${atomicNumericExpressionMaximumLeafOperands} leaf operands.`);
+            }
+            if (!operandArg.startsWith('$')
+                || operandArg.startsWith('$$')
+                || operandArg.length < 2) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr field references must use exactly one leading $.`);
+            }
+            const field = operandArg.slice(1);
+            if (field === 'toBSON' || field === '_bsontype') {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr field "${field}" is reserved.`);
+            }
+            const root = requireDeclaredPath(field, declaredRootsArg, `${operationLabelArg} $expr`);
+            if (field !== root) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr may reference only declared top-level fields.`);
+            }
+            if (!numericRootsArg.has(root)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr field "${root}" is not declared numeric.`);
+            }
+            if (serializedRootsArg.has(root)) {
+                throw new SmartdataPersistenceError('unsupported_operation', `${operationLabelArg} $expr cannot reference serialized field "${root}".`);
+            }
+            return {
+                mongoExpression: `$${root}`,
+                referencedFields: new Set([root]),
+            };
+        }
+        if (depthArg >= atomicNumericExpressionMaximumDepth) {
+            throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} $expr exceeds the maximum $add depth of ${atomicNumericExpressionMaximumDepth}.`);
+        }
+        const rawOperands = getAtomicExpressionArrayValues(getAtomicExpressionProperty(operandArg, '$add', `${operationLabelArg} $expr operand`), 2, atomicNumericExpressionMaximumAddOperands, `${operationLabelArg} $expr $add`);
+        const normalizedOperands = rawOperands.map((entryArg) => normalizeOperand(entryArg, depthArg + 1));
+        return {
+            mongoExpression: {
+                $add: normalizedOperands.map((entryArg) => entryArg.mongoExpression),
+            },
+            referencedFields: new Set(normalizedOperands.flatMap((entryArg) => [
+                ...entryArg.referencedFields,
+            ])),
+        };
+    };
+    const lteOperands = getAtomicExpressionArrayValues(getAtomicExpressionProperty(expressionArg, '$lte', `${operationLabelArg} $expr`), 2, 2, `${operationLabelArg} $expr $lte`);
+    const left = normalizeOperand(lteOperands[0], 0);
+    const right = normalizeOperand(lteOperands[1], 0);
+    const referencedFields = new Set([
+        ...left.referencedFields,
+        ...right.referencedFields,
+    ]);
+    const fieldGuards = [...referencedFields].map((fieldArg) => ({
+        $cond: [
+            { $isNumber: `$${fieldArg}` },
+            {
+                $eq: [
+                    { $subtract: [`$${fieldArg}`, `$${fieldArg}`] },
+                    0,
+                ],
+            },
+            false,
+        ],
+    }));
+    const guardedComparison = {
+        $let: {
+            vars: {
+                smartdataAtomicExprLeft: left.mongoExpression,
+                smartdataAtomicExprRight: right.mongoExpression,
+            },
+            in: {
+                $cond: [
+                    {
+                        $and: [
+                            { $isNumber: '$$smartdataAtomicExprLeft' },
+                            { $isNumber: '$$smartdataAtomicExprRight' },
+                            {
+                                $eq: [
+                                    {
+                                        $subtract: [
+                                            '$$smartdataAtomicExprLeft',
+                                            '$$smartdataAtomicExprLeft',
+                                        ],
+                                    },
+                                    0,
+                                ],
+                            },
+                            {
+                                $eq: [
+                                    {
+                                        $subtract: [
+                                            '$$smartdataAtomicExprRight',
+                                            '$$smartdataAtomicExprRight',
+                                        ],
+                                    },
+                                    0,
+                                ],
+                            },
+                        ],
+                    },
+                    {
+                        $lte: [
+                            '$$smartdataAtomicExprLeft',
+                            '$$smartdataAtomicExprRight',
+                        ],
+                    },
+                    false,
+                ],
+            },
+        },
+    };
+    return fieldGuards.length > 0
+        ? {
+            $cond: [
+                { $and: fieldGuards },
+                guardedComparison,
+                false,
+            ],
+        }
+        : guardedComparison;
+};
+const normalizeStrictFilter = (filterArg, declaredRootsArg, declaredNestedPathsArg, identityValueTypesArg, numericRootsArg, serializedRootsArg, operationLabelArg, globallyConstrainingKeySetsArg) => {
+    if (typeof filterArg !== 'object' ||
+        filterArg === null ||
+        Array.isArray(filterArg) ||
+        plugins.nodeUtil.types.isProxy(filterArg) ||
+        !isPlainObject(filterArg) ||
+        Object.keys(filterArg).length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} requires a non-empty filter object.`);
+    }
+    assertOnlyDataProperties(filterArg, `${operationLabelArg} filter`, false);
+    const requireInertLogicalFilterArray = (valueArg, labelArg) => {
+        if (!Array.isArray(valueArg)
+            || plugins.nodeUtil.types.isProxy(valueArg)
+            || Object.getPrototypeOf(valueArg) !== Array.prototype
+            || valueArg.length === 0) {
+            throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must be a non-empty ordinary array of filters.`);
+        }
+        assertOnlyDataProperties(valueArg, labelArg, true);
+        for (let index = 0; index < valueArg.length; index++) {
+            if (!Object.prototype.hasOwnProperty.call(valueArg, index)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} may not contain sparse array positions.`);
+            }
+            const entry = valueArg[index];
+            if (typeof entry !== 'object'
+                || entry === null
+                || Array.isArray(entry)
+                || plugins.nodeUtil.types.isProxy(entry)
+                || !isPlainObject(entry)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${labelArg} entries must be plain filter objects.`);
+            }
+            assertOnlyDataProperties(entry, `${labelArg} entry`, false);
+        }
+    };
+    const conditionIsEqualityAnchor = (valueArg) => {
+        if (Array.isArray(valueArg)) {
+            return false;
+        }
+        if (typeof valueArg !== 'object' || valueArg === null) {
+            return (valueArg !== undefined
+                && typeof valueArg !== 'function'
+                && typeof valueArg !== 'symbol');
+        }
+        if (plugins.nodeUtil.types.isProxy(valueArg)) {
+            throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} filters may not contain Proxy values.`);
+        }
+        if (isAtomicMongoScalar(valueArg)) {
+            return true;
+        }
+        if (!isPlainObject(valueArg)) {
+            return false;
+        }
+        assertOnlyDataProperties(valueArg, `${operationLabelArg} filter condition`, false);
+        const entries = Object.entries(valueArg);
+        if (entries.length !== 1 || entries[0][0] !== '$eq') {
+            return false;
+        }
+        const operand = entries[0][1];
+        if (Array.isArray(operand)) {
+            return false;
+        }
+        if (typeof operand !== 'object' || operand === null) {
+            return (operand !== undefined
+                && typeof operand !== 'function'
+                && typeof operand !== 'symbol');
+        }
+        if (plugins.nodeUtil.types.isProxy(operand)) {
+            throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} filters may not contain Proxy values.`);
+        }
+        return isAtomicMongoScalar(operand);
+    };
+    const filterHasEqualityAnchor = (filterObjectArg) => {
+        for (const [key, value] of Object.entries(filterObjectArg)) {
+            if (key === '$and' && Array.isArray(value)) {
+                requireInertLogicalFilterArray(value, '$and');
+                if (value.some((entryArg) => isPlainObject(entryArg) &&
+                    filterHasEqualityAnchor(entryArg))) {
+                    return true;
+                }
+                continue;
+            }
+            if (key === '$or' && Array.isArray(value)) {
+                requireInertLogicalFilterArray(value, '$or');
+                if (value.length > 0 &&
+                    value.every((entryArg) => isPlainObject(entryArg) &&
+                        filterHasEqualityAnchor(entryArg))) {
+                    return true;
+                }
+                continue;
+            }
+            if (!key.startsWith('$') && conditionIsEqualityAnchor(value)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (!filterHasEqualityAnchor(filterArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} filters require at least one top-level equality anchor.`);
+    }
+    const collectEqualityAnchoredKeys = (filterObjectArg, anchoredKeysArg) => {
+        for (const [key, value] of Object.entries(filterObjectArg)) {
+            if (key === '$and' && Array.isArray(value)) {
+                requireInertLogicalFilterArray(value, '$and');
+                for (const entryArg of value) {
+                    if (isPlainObject(entryArg)) {
+                        collectEqualityAnchoredKeys(entryArg, anchoredKeysArg);
+                    }
+                }
+                continue;
+            }
+            // $or branches are deliberately excluded: an equality inside one $or
+            // branch does not globally constrain the matched document.
+            if (!key.startsWith('$') && conditionIsEqualityAnchor(value)) {
+                anchoredKeysArg.add(key);
+            }
+        }
+    };
+    if (globallyConstrainingKeySetsArg) {
+        const anchoredKeys = new Set();
+        collectEqualityAnchoredKeys(filterArg, anchoredKeys);
+        const filterIsGloballyConstraining = globallyConstrainingKeySetsArg.some((keySetArg) => keySetArg.size > 0 &&
+            [...keySetArg].every((keyArg) => anchoredKeys.has(keyArg)));
+        if (!filterIsGloballyConstraining) {
+            throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} filters require equality anchors that fully pin an identity field or a declared unqualified unique index.`);
+        }
+    }
+    const normalizeFilterObject = (filterObjectArg, rootArg = false) => {
+        assertOnlyDataProperties(filterObjectArg, `${operationLabelArg} filter`, false);
+        const normalized = {};
+        for (const [key, value] of Object.entries(filterObjectArg)) {
+            if (key === '$and' || key === '$or' || key === '$nor') {
+                requireInertLogicalFilterArray(value, key);
+                normalized[key] = value.map((entry) => {
+                    if (Object.keys(entry).length === 0) {
+                        throw new SmartdataPersistenceError('invalid_argument', `${key} entries must be non-empty filter objects.`);
+                    }
+                    return normalizeFilterObject(entry, false);
+                });
+                continue;
+            }
+            if (key === '$expr') {
+                if (!rootArg) {
+                    throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} permits $expr only at the root of the filter.`);
+                }
+                normalized[key] = normalizeAtomicNumericExpression(value, declaredRootsArg, numericRootsArg, serializedRootsArg, operationLabelArg);
+                continue;
+            }
+            const root = requireDeclaredPath(key, declaredRootsArg, `${operationLabelArg} filter`, declaredNestedPathsArg);
+            if (serializedRootsArg.has(root)) {
+                throw new SmartdataPersistenceError('unsupported_operation', `${operationLabelArg} filters cannot target serialized field "${key}".`);
+            }
+            if (identityValueTypesArg.has(root) && key !== root) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operationLabelArg} filters cannot target a nested path below immutable @unI() field "${root}".`);
+            }
+            normalized[key] = normalizeAtomicFilterCondition(value, `${operationLabelArg} filter path "${key}"`, identityValueTypesArg.get(root));
+        }
+        return normalized;
+    };
+    return normalizeFilterObject(filterArg, true);
+};
+const pathsConflict = (leftArg, rightArg) => leftArg === rightArg ||
+    leftArg.startsWith(`${rightArg}.`) ||
+    rightArg.startsWith(`${leftArg}.`);
+const normalizeAtomicUpdate = (updateArg, declaredRootsArg, declaredNestedPathsArg, uniqueRootsArg, serializedRootsArg) => {
+    if (typeof updateArg !== 'object' ||
+        updateArg === null ||
+        Array.isArray(updateArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Atomic update must be an update object.');
+    }
+    const allowedOperators = new Set([
+        '$set',
+        '$unset',
+        '$inc',
+        '$setOnInsert',
+        '$push',
+        '$addToSet',
+        '$pull',
+    ]);
+    const arrayOperators = new Set(['$push', '$addToSet', '$pull']);
+    for (const operator of Object.keys(updateArg)) {
+        if (!allowedOperators.has(operator)) {
+            throw new SmartdataPersistenceError('invalid_argument', `Atomic update operator "${operator}" is not supported.`);
+        }
+    }
+    const normalized = {};
+    const occupiedPaths = [];
+    for (const operator of allowedOperators) {
+        const operation = updateArg[operator];
+        if (operation === undefined) {
+            continue;
+        }
+        if (!isPlainObject(operation)) {
+            throw new SmartdataPersistenceError('invalid_argument', `${operator} must be a plain object.`);
+        }
+        const entries = Object.entries(operation);
+        if (entries.length === 0) {
+            continue;
+        }
+        const normalizedOperation = {};
+        for (const [path, value] of entries) {
+            const root = requireDeclaredPath(path, declaredRootsArg, operator, declaredNestedPathsArg);
+            if (serializedRootsArg.has(root)) {
+                throw new SmartdataPersistenceError('unsupported_operation', `${operator} cannot target serialized field "${path}".`);
+            }
+            if (uniqueRootsArg.has(root)) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operator} may not modify immutable @unI() field "${root}".`);
+            }
+            const conflict = occupiedPaths.find((occupiedPath) => pathsConflict(path, occupiedPath.path));
+            if (conflict) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operator} path "${path}" conflicts with ${conflict.operator} path "${conflict.path}".`);
+            }
+            occupiedPaths.push({ path, operator });
+            if (arrayOperators.has(operator)) {
+                if (path !== root) {
+                    throw new SmartdataPersistenceError('invalid_argument', `${operator} may only target declared top-level array fields; "${path}" is a nested path.`);
+                }
+                if (value === undefined) {
+                    throw new SmartdataPersistenceError('invalid_argument', `${operator} path "${path}" may not be undefined.`);
+                }
+                if (operator === '$pull') {
+                    if (value === null
+                        || typeof value === 'string'
+                        || typeof value === 'boolean'
+                        || (typeof value === 'number' && Number.isFinite(value))) {
+                        normalizedOperation[path] = value;
+                        continue;
+                    }
+                    if (typeof value !== 'object'
+                        || Array.isArray(value)
+                        || isPlainObject(value)
+                        || value instanceof RegExp) {
+                        throw new SmartdataPersistenceError('invalid_argument', `$pull path "${path}" must use a scalar equality operand.`);
+                    }
+                    // Scalar BSON objects are stored as inert snapshots so a custom
+                    // toBSON encoder can never rewrite the equality operand into an
+                    // operator document at serialization time.
+                    normalizedOperation[path] = createInertAtomicBsonScalarSnapshot(value, `$pull path "${path}"`);
+                    continue;
+                }
+                if (typeof value === 'object'
+                    && value !== null
+                    && !Array.isArray(value)
+                    && !isPlainObject(value)) {
+                    // Non-plain element objects (dates, binary views, BSON scalars)
+                    // must be inert: a custom toBSON encoder could otherwise smuggle a
+                    // modifier document such as $each past validation.
+                    normalizedOperation[path] = createInertAtomicBsonScalarSnapshot(value, `${operator} path "${path}"`);
+                    continue;
+                }
+                assertSafePersistedValue(value, `${operator} path "${path}"`);
+                normalizedOperation[path] = stripUndefinedValues(value);
+                continue;
+            }
+            if (operator === '$unset') {
+                if (value !== '' && value !== true && value !== 1) {
+                    throw new SmartdataPersistenceError('invalid_argument', `$unset path "${path}" must use "", true, or 1.`);
+                }
+                normalizedOperation[path] = '';
+                continue;
+            }
+            if (value === undefined) {
+                throw new SmartdataPersistenceError('invalid_argument', `${operator} path "${path}" may not be undefined.`);
+            }
+            if (operator === '$inc' &&
+                (typeof value !== 'number' || !Number.isFinite(value))) {
+                throw new SmartdataPersistenceError('invalid_argument', `$inc path "${path}" must be a finite number.`);
+            }
+            if (operator !== '$inc') {
+                assertSafePersistedValue(value, `${operator} path "${path}"`);
+            }
+            normalizedOperation[path] =
+                operator === '$inc' ? value : stripUndefinedValues(value);
+        }
+        normalized[operator] = normalizedOperation;
+    }
+    if (Object.keys(normalized).length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Atomic update must contain at least one non-empty operation.');
+    }
+    return normalized;
+};
+const normalizeProjection = (projectionArg, declaredRootsArg, declaredNestedPathsArg) => {
+    if (projectionArg === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(projectionArg) || Object.keys(projectionArg).length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Projection must be a non-empty plain object.');
+    }
+    let inclusionMode;
+    const normalized = {};
+    for (const [path, value] of Object.entries(projectionArg)) {
+        if (path !== '_id') {
+            requireDeclaredPath(path, declaredRootsArg, 'Projection', declaredNestedPathsArg);
+            if (inclusionMode === undefined) {
+                inclusionMode = value;
+            }
+            else if (inclusionMode !== value) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Projection may not mix included and excluded fields except for _id.');
+            }
+        }
+        if (value !== 0 && value !== 1) {
+            throw new SmartdataPersistenceError('invalid_argument', `Projection path "${path}" must use 0 or 1.`);
+        }
+        normalized[path] = value;
+    }
+    return normalized;
+};
+const normalizeSort = (sortArg, declaredRootsArg, declaredNestedPathsArg) => {
+    if (sortArg === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(sortArg) || Object.keys(sortArg).length === 0) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Sort must be a non-empty ordered object.');
+    }
+    const normalized = {};
+    for (const [path, direction] of Object.entries(sortArg)) {
+        if (path !== '_id') {
+            requireDeclaredPath(path, declaredRootsArg, 'Sort', declaredNestedPathsArg);
+        }
+        if (direction !== 1 && direction !== -1) {
+            throw new SmartdataPersistenceError('invalid_argument', `Sort path "${path}" must use 1 or -1.`);
+        }
+        normalized[path] = direction;
+    }
+    return normalized;
+};
+const normalizeQueryHint = (hintArg, modelArg) => {
+    if (hintArg === undefined) {
+        return undefined;
+    }
+    if (typeof hintArg !== 'string' ||
+        !getExpectedCollectionTopologyForModel(modelArg).indexes.some((indexArg) => indexArg.name === hintArg)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Query hint must name an index declared by this model or the built-in _id_ index.');
+    }
+    return hintArg;
+};
+export const convertFilterForMongoDb = (filterArg) => {
+    // SECURITY: Block $where to prevent server-side JS execution
+    if (filterArg.$where !== undefined) {
+        throw new Error('$where operator is not allowed for security reasons');
+    }
+    // Handle logical operators recursively
+    const logicalOperators = ['$and', '$or', '$nor', '$not'];
+    const processedFilter = {};
+    for (const key of Object.keys(filterArg)) {
+        if (logicalOperators.includes(key)) {
+            if (key === '$not') {
+                processedFilter[key] = convertFilterForMongoDb(filterArg[key]);
+            }
+            else if (Array.isArray(filterArg[key])) {
+                processedFilter[key] = filterArg[key].map((subFilter) => convertFilterForMongoDb(subFilter));
+            }
+        }
+    }
+    // If only logical operators, return them
+    const hasOnlyLogicalOperators = Object.keys(filterArg).every(key => logicalOperators.includes(key));
+    if (hasOnlyLogicalOperators) {
+        return processedFilter;
+    }
+    // Original conversion logic for non-MongoDB query objects
+    const convertedFilter = {};
+    // Helper to merge operator objects
+    const mergeIntoConverted = (path, value) => {
+        const existing = convertedFilter[path];
+        if (!existing) {
+            convertedFilter[path] = value;
+        }
+        else if (typeof existing === 'object' && !Array.isArray(existing) &&
+            typeof value === 'object' && !Array.isArray(value) &&
+            (Object.keys(existing).some(k => k.startsWith('$')) || Object.keys(value).some(k => k.startsWith('$')))) {
+            // Both have operators, merge them
+            convertedFilter[path] = { ...existing, ...value };
+        }
+        else {
+            // Otherwise later wins
+            convertedFilter[path] = value;
+        }
+    };
+    const isAtomicMongoValue = (valueArg) => {
+        if (valueArg instanceof Date || valueArg instanceof RegExp) {
+            return true;
+        }
+        if (ArrayBuffer.isView(valueArg)) {
+            return true;
+        }
+        return (typeof valueArg === 'object' &&
+            valueArg !== null &&
+            typeof valueArg._bsontype === 'string');
+    };
+    const convertFilterArgument = (keyPathArg2, filterArg2) => {
+        if (Array.isArray(filterArg2)) {
+            // Arrays are typically used as values for operators like $in or as direct equality matches
+            mergeIntoConverted(keyPathArg2, filterArg2);
+            return;
+        }
+        else if (isAtomicMongoValue(filterArg2)) {
+            // BSON values, dates, regexes, and binary views are scalar query values.
+            // Recursing into them can silently turn an _id filter into an empty filter.
+            mergeIntoConverted(keyPathArg2, filterArg2);
+            return;
+        }
+        else if (typeof filterArg2 === 'object' && filterArg2 !== null) {
+            // Check if this is an object with MongoDB operators
+            const keys = Object.keys(filterArg2);
+            const hasOperators = keys.some(key => key.startsWith('$'));
+            if (hasOperators) {
+                // This object contains MongoDB operators
+                // Validate and pass through allowed operators
+                const allowedOperators = [
+                    // Comparison operators
+                    '$eq', '$ne', '$gt', '$gte', '$lt', '$lte',
+                    // Array operators
+                    '$in', '$nin', '$all', '$elemMatch', '$size',
+                    // Element operators
+                    '$exists', '$type',
+                    // Evaluation operators (safe ones only)
+                    '$regex', '$options', '$text', '$mod',
+                    // Logical operators (nested)
+                    '$and', '$or', '$nor', '$not'
+                ];
+                // Check for dangerous operators
+                if (keys.includes('$where')) {
+                    throw new Error('$where operator is not allowed for security reasons');
+                }
+                // Validate all operators are in the allowed list
+                const invalidOperators = keys.filter(key => key.startsWith('$') && !allowedOperators.includes(key));
+                if (invalidOperators.length > 0) {
+                    console.warn(`Warning: Unknown MongoDB operators detected: ${invalidOperators.join(', ')}`);
+                }
+                // For array operators, ensure the values are appropriate
+                if (filterArg2.$in && !Array.isArray(filterArg2.$in)) {
+                    throw new Error('$in operator requires an array value');
+                }
+                if (filterArg2.$nin && !Array.isArray(filterArg2.$nin)) {
+                    throw new Error('$nin operator requires an array value');
+                }
+                if (filterArg2.$all && !Array.isArray(filterArg2.$all)) {
+                    throw new Error('$all operator requires an array value');
+                }
+                if (filterArg2.$size && typeof filterArg2.$size !== 'number') {
+                    throw new Error('$size operator requires a numeric value');
+                }
+                // Use merge helper to handle duplicate paths
+                mergeIntoConverted(keyPathArg2, filterArg2);
+                return;
+            }
+            // No operators, check for dots in keys
+            for (const key of keys) {
+                if (key.includes('.')) {
+                    throw new Error('keys cannot contain dots');
+                }
+            }
+            // Recursively process nested objects
+            for (const key of keys) {
+                convertFilterArgument(`${keyPathArg2}.${key}`, filterArg2[key]);
+            }
+        }
+        else {
+            // Primitive values
+            mergeIntoConverted(keyPathArg2, filterArg2);
+        }
+    };
+    for (const key of Object.keys(filterArg)) {
+        // Skip logical operators, they were already processed
+        if (!logicalOperators.includes(key)) {
+            convertFilterArgument(key, filterArg[key]);
+        }
+    }
+    // Add back processed logical operators
+    Object.assign(convertedFilter, processedFilter);
+    return convertedFilter;
+};
+let SmartDataDbDoc = (() => {
+    let __createdAt_decorators;
+    let __createdAt_initializers = [];
+    let __createdAt_extraInitializers = [];
+    let __updatedAt_decorators;
+    let __updatedAt_initializers = [];
+    let __updatedAt_extraInitializers = [];
+    return class SmartDataDbDoc {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __createdAt_decorators = [globalSvDb()];
+            __updatedAt_decorators = [globalSvDb()];
+            __esDecorate(null, null, __createdAt_decorators, { kind: "field", name: "_createdAt", static: false, private: false, access: { has: obj => "_createdAt" in obj, get: obj => obj._createdAt, set: (obj, value) => { obj._createdAt = value; } }, metadata: _metadata }, __createdAt_initializers, __createdAt_extraInitializers);
+            __esDecorate(null, null, __updatedAt_decorators, { kind: "field", name: "_updatedAt", static: false, private: false, access: { has: obj => "_updatedAt" in obj, get: obj => obj._updatedAt, set: (obj, value) => { obj._updatedAt = value; } }, metadata: _metadata }, __updatedAt_initializers, __updatedAt_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * the collection object an Doc belongs to
+         */
+        static collection;
+        static get exact() {
+            throw new Error('Model is not configured for exact persistence.');
+        }
+        static defaultManager;
+        static manager;
+        /**
+         * Helper to get collection with fallback to static for Deno compatibility
+         */
+        getCollectionSafe() {
+            return this.collection || this.constructor.collection;
+        }
+        // STATIC
+        /** Insert a strict primary-only bootstrap record without separate collection/index DDL. */
+        static async insertBootstrapRecord(dbArg, recordArg, optionsArg) {
+            return insertBootstrapRecord(this, dbArg, recordArg, optionsArg);
+        }
+        /** Inspect bounded stored BSON without initializing or hydrating the model. */
+        static async inspectStoredDocuments(dbArg, optionsArg) {
+            return inspectStoredDocuments(this, dbArg, optionsArg);
+        }
+        /** Diagnose stored BSON with explicit ordinary validation evidence, without hydration. */
+        static async inspectStoredDocumentEvidence(dbArg, optionsArg = {}) {
+            return inspectStoredDocumentEvidence(this, dbArg, optionsArg);
+        }
+        static createInstanceFromMongoDbNativeDoc(mongoDbNativeDocArg) {
+            const policy = getOrdinaryPersistencePolicy(this);
+            if (policy) {
+                mongoDbNativeDocArg = validateOrdinaryStoredDocument(mongoDbNativeDocArg, policy, [...this.getDeclaredPersistedRoots()]);
+            }
+            const newInstance = new this();
+            if (policy) {
+                for (const field of this.getDeclaredPersistedRoots()) {
+                    if (!Object.prototype.hasOwnProperty.call(mongoDbNativeDocArg, field)) {
+                        delete newInstance[field];
+                    }
+                }
+            }
+            if (policy?.timestamps === 'none') {
+                delete newInstance['_createdAt'];
+                delete newInstance['_updatedAt'];
+            }
+            newInstance.creationStatus = 'db';
+            for (const key of Object.keys(mongoDbNativeDocArg)) {
+                const rawValue = mongoDbNativeDocArg[key];
+                const optionsMap = this._svDbOptions || {};
+                const opts = optionsMap[key];
+                newInstance[key] = opts && typeof opts.deserialize === 'function'
+                    ? opts.deserialize(rawValue)
+                    : rawValue;
+            }
+            return newInstance;
+        }
+        static getDeclaredPersistedRoots() {
+            const prototype = this.prototype;
+            const roots = new Set([
+                ...(prototype.globalSaveableProperties || []),
+                ...(prototype.saveableProperties || []),
+            ]);
+            if (getOrdinaryPersistencePolicy(this)?.idType === 'string') {
+                roots.add('_id');
+                stringIdRootSets.add(roots);
+            }
+            return roots;
+        }
+        static getDeclaredUniqueRoots() {
+            const prototype = this.prototype;
+            return new Set([
+                ...(prototype.uniqueIndexes || []),
+                ...(getOrdinaryPersistencePolicy(this)?.idType === 'string' ? ['_id'] : []),
+            ]);
+        }
+        static getDeclaredIdentityValueTypes() {
+            const prototype = this.prototype;
+            return new Map([...this.getDeclaredUniqueRoots()].map((identityFieldArg) => [
+                identityFieldArg,
+                prototype.identityValueTypes?.[identityFieldArg] ?? 'string',
+            ]));
+        }
+        static getDeclaredNumericRoots() {
+            const collection = this.collection;
+            return new Set(collection.getBoundModelSchema()?.numericFields || []);
+        }
+        /**
+         * Returns every equality key set that globally constrains a single document
+         * of this model: each declared identity field on its own, plus the full key
+         * set of every declared unqualified unique index. Unique indexes that carry
+         * any option beyond `unique` (sparse, partial, or otherwise uninterpretable)
+         * or a non-numeric key direction do not qualify — such indexes do not
+         * guarantee at most one matching document for an equality filter.
+         */
+        static getGloballyConstrainingKeySets() {
+            const keySets = [];
+            for (const identityField of this.getDeclaredUniqueRoots()) {
+                keySets.push(new Set([identityField]));
+            }
+            const collection = this.collection;
+            const modelSchema = collection.getBoundModelSchema();
+            if (modelSchema) {
+                for (const index of modelSchema.indexes) {
+                    if (index.options.unique !== true) {
+                        continue;
+                    }
+                    const hasUnqualifiedOptions = Object.keys(index.options).every((optionKeyArg) => optionKeyArg === 'unique' || optionKeyArg === 'background');
+                    if (!hasUnqualifiedOptions) {
+                        continue;
+                    }
+                    if (index.key.length === 0 ||
+                        index.key.some(([, directionArg]) => directionArg !== 1 && directionArg !== -1)) {
+                        continue;
+                    }
+                    keySets.push(new Set(index.key.map(([fieldArg]) => fieldArg)));
+                }
+            }
+            return keySets;
+        }
+        static getDeclaredAtomicPaths() {
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const uniqueRoots = this.getDeclaredUniqueRoots();
+            const options = this._svDbOptions;
+            const atomicPaths = new Set();
+            for (const [root, fieldOptions] of Object.entries(options || {})) {
+                if (fieldOptions.atomicPaths === undefined) {
+                    continue;
+                }
+                if (!Array.isArray(fieldOptions.atomicPaths)) {
+                    throw new SmartdataPersistenceError('invalid_configuration', `Atomic paths for persisted field "${root}" must be an array.`);
+                }
+                if (typeof fieldOptions.serialize === 'function'
+                    || typeof fieldOptions.deserialize === 'function') {
+                    throw new SmartdataPersistenceError('invalid_configuration', `Serialized persisted field "${root}" may not declare atomic nested paths.`);
+                }
+                if (uniqueRoots.has(root)) {
+                    throw new SmartdataPersistenceError('invalid_configuration', `Immutable @unI() field "${root}" may not declare atomic nested paths.`);
+                }
+                for (const relativePath of fieldOptions.atomicPaths) {
+                    if (typeof relativePath !== 'string' || relativePath.length === 0) {
+                        throw new SmartdataPersistenceError('invalid_configuration', `Atomic paths for persisted field "${root}" must be non-empty strings.`);
+                    }
+                    const fullPath = `${root}.${relativePath}`;
+                    try {
+                        requireDeclaredPath(fullPath, declaredRoots, 'Atomic path declaration', new Set([fullPath]));
+                    }
+                    catch (errorArg) {
+                        throw new SmartdataPersistenceError('invalid_configuration', `Atomic path declaration "${fullPath}" is invalid.`, { cause: errorArg });
+                    }
+                    atomicPaths.add(fullPath);
+                }
+            }
+            return atomicPaths;
+        }
+        static getSerializedPersistedRoots() {
+            const options = this._svDbOptions;
+            return new Set(Object.entries(options || {})
+                .filter(([, fieldOptions]) => typeof fieldOptions.serialize === 'function' ||
+                typeof fieldOptions.deserialize === 'function')
+                .map(([field]) => field));
+        }
+        static getDeclaredQueryPaths() {
+            return new Set([
+                ...this.getDeclaredAtomicPaths(),
+                ...getExpectedCollectionTopologyForModel(this).indexes.flatMap((indexArg) => indexArg.keys.map((keyArg) => keyArg.path)),
+            ]);
+        }
+        static assertHydratedProjection(projectionArg, modifierArg) {
+            if (getOrdinaryPersistencePolicy(this) && (projectionArg !== undefined || modifierArg !== undefined)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Whole-stored-document validation requires an unprojected read without native modifiers.');
+            }
+        }
+        /**
+         * Initializes the model collection and all model-owned indexes. Failed
+         * initialization is retryable after the underlying conflict is repaired.
+         */
+        static async init() {
+            const collection = this.collection;
+            await collection.init();
+        }
+        static async ensureInitialized() {
+            await this.init();
+        }
+        /** Verify or install the model's exact topology within one explicit deadline. */
+        static async prepareCollection(opts) {
+            validateCollectionPreparationOptions(opts);
+            const collection = this.collection;
+            await collection.prepareCollection(opts);
+        }
+        /**
+         * Returns a sanitized view of the indexes installed for this model.
+         */
+        static async getIndexInfo() {
+            const collection = this.collection;
+            return collection.getIndexInfo();
+        }
+        /**
+         * Returns the model's immutable collection and index contract without
+         * resolving a manager, database, or SmartdataCollection.
+         */
+        static getExpectedCollectionTopology() {
+            return getExpectedCollectionTopologyForModel(this);
+        }
+        /**
+         * Inspects an explicitly supplied connected database without initializing or
+         * mutating the model collection.
+         */
+        static async inspectCollectionTopology(dbArg) {
+            return inspectCollectionTopologyForModel(this, dbArg);
+        }
+        /**
+         * Inserts a newly constructed ordinary model through SmartData.
+         */
+        static async insert(documentArg, opts) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Ordinary insert is unavailable for exact-persistence models.');
+            }
+            if (!(documentArg instanceof this)) {
+                throw new SmartdataPersistenceError('invalid_argument', `Model insert requires an instance of "${this.name}".`);
+            }
+            if (documentArg.creationStatus !== 'new') {
+                throw new SmartdataPersistenceError('invalid_argument', 'Model insert requires a newly constructed document.');
+            }
+            assertUsableIdentityValues(documentArg, this.prototype.uniqueIndexes || [], this.prototype.identityValueTypes);
+            const now = new Date().toISOString();
+            if (getOrdinaryPersistencePolicy(this)?.timestamps !== 'none') {
+                documentArg._createdAt = now;
+                documentArg._updatedAt = now;
+            }
+            const collection = this.collection;
+            const result = await collection.insert(documentArg, opts);
+            if (!isOrdinarySessionInTransaction(opts?.session)) {
+                documentArg.creationStatus = 'db';
+            }
+            return result;
+        }
+        /**
+         * Inserts a batch of newly constructed ordinary models through SmartData.
+         * Each document inserts atomically; the batch as a whole is not isolated
+         * unless the caller supplies a transaction session. With ordered semantics
+         * (the default) MongoDB stops at the first failure; documents MongoDB
+         * reports as inserted are marked database-backed even when the batch fails
+         * part-way, so callers can compensate precisely.
+         */
+        static async insertMany(documentsArg, opts) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Ordinary insertMany is unavailable for exact-persistence models.');
+            }
+            if (!Array.isArray(documentsArg) || documentsArg.length === 0) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Model insertMany requires a non-empty array of documents.');
+            }
+            if (opts?.ordered !== undefined
+                && typeof opts.ordered !== 'boolean') {
+                throw new SmartdataPersistenceError('invalid_argument', 'Model insertMany ordered must be a boolean.');
+            }
+            const seenDocuments = new Set();
+            for (const documentArg of documentsArg) {
+                if (!(documentArg instanceof this)) {
+                    throw new SmartdataPersistenceError('invalid_argument', `Model insertMany requires instances of "${this.name}".`);
+                }
+                if (documentArg.creationStatus !== 'new') {
+                    throw new SmartdataPersistenceError('invalid_argument', 'Model insertMany requires newly constructed documents.');
+                }
+                if (seenDocuments.has(documentArg)) {
+                    throw new SmartdataPersistenceError('invalid_argument', 'Model insertMany may not contain the same document instance twice.');
+                }
+                seenDocuments.add(documentArg);
+                assertUsableIdentityValues(documentArg, this.prototype.uniqueIndexes || [], this.prototype.identityValueTypes);
+            }
+            const now = new Date().toISOString();
+            for (const documentArg of documentsArg) {
+                if (getOrdinaryPersistencePolicy(this)?.timestamps !== 'none') {
+                    documentArg._createdAt = now;
+                    documentArg._updatedAt = now;
+                }
+            }
+            const collection = this.collection;
+            const inTransaction = isOrdinarySessionInTransaction(opts?.session);
+            const markInsertedDocuments = (insertedIdsArg) => {
+                if (inTransaction || !insertedIdsArg) {
+                    return;
+                }
+                for (const indexKey of Object.keys(insertedIdsArg)) {
+                    const insertedDocument = documentsArg[Number(indexKey)];
+                    if (insertedDocument) {
+                        insertedDocument.creationStatus = 'db';
+                    }
+                }
+            };
+            try {
+                const result = await collection.insertMany(documentsArg, opts);
+                markInsertedDocuments(result.insertedIds);
+                return result;
+            }
+            catch (error) {
+                const bulkError = error instanceof SmartdataPersistenceError
+                    ? error.cause
+                    : error;
+                if (bulkError instanceof plugins.mongodb.MongoBulkWriteError) {
+                    markInsertedDocuments(bulkError.result?.insertedIds);
+                }
+                throw error;
+            }
+        }
+        /**
+         * Inserts absent identities without changing existing documents, including
+         * their timestamps. The unordered batch is bounded to 1000 documents and
+         * 16 MiB of serialized BSON. New-model timestamps are preserved. Inputs stay
+         * new so the same batch can be retried after an ambiguous result; read a
+         * stored instance before updating it because an existing body may differ.
+         */
+        static async insertManyIfAbsent(documentsArg, opts) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'insertManyIfAbsent is unavailable for exact-persistence models.');
+            }
+            if (!Array.isArray(documentsArg) || documentsArg.length < 1 || documentsArg.length > 1000) {
+                throw new SmartdataPersistenceError('invalid_argument', 'insertManyIfAbsent requires 1 to 1000 newly constructed documents.');
+            }
+            const identityTypes = this.getDeclaredIdentityValueTypes();
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const identityField = opts?.identityField;
+            if (typeof identityField !== 'string' || !identityTypes.has(identityField) || serializedRoots.has(identityField)) {
+                throw new SmartdataPersistenceError('invalid_argument', 'insertManyIfAbsent requires a declared, non-serialized @unI identity field.');
+            }
+            const timeoutMS = requireBoundedInteger(opts?.timeoutMS, 'insertManyIfAbsent timeoutMS', 120_000);
+            const identities = new Set();
+            for (const document of documentsArg) {
+                if (!(document instanceof this) || document.creationStatus !== 'new') {
+                    throw new SmartdataPersistenceError('invalid_argument', 'insertManyIfAbsent requires newly constructed instances of the receiving model.');
+                }
+                assertUsableIdentityValues(document, this.prototype.uniqueIndexes || [], this.prototype.identityValueTypes);
+                const identity = document[identityField];
+                if (identities.has(identity)) {
+                    throw new SmartdataPersistenceError('invalid_argument', 'insertManyIfAbsent may not repeat an identity within one batch.');
+                }
+                identities.add(identity);
+                if (getOrdinaryPersistencePolicy(this)?.timestamps !== 'none') {
+                    for (const timestamp of [document._createdAt, document._updatedAt]) {
+                        if (typeof timestamp !== 'string' || !Number.isFinite(Date.parse(timestamp))) {
+                            throw new SmartdataPersistenceError('invalid_argument', 'insertManyIfAbsent requires valid creation and update timestamps.');
+                        }
+                    }
+                }
+            }
+            const collection = this.collection;
+            return await collection.insertManyIfAbsent(documentsArg, identityField, {
+                session: opts.session,
+                timeoutMS,
+            });
+        }
+        /**
+         * Atomically updates one ordinary model document using a strict selector
+         * and a bounded set of MongoDB update operators.
+         */
+        static async atomicUpdate(filterArg, updateArg, opts) {
+            if (getOrdinaryPersistencePolicy(this)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Validated ordinary models require a transactional postimage update.');
+            }
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'atomicUpdate is unavailable for exact-persistence models.');
+            }
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const declaredAtomicPaths = this.getDeclaredAtomicPaths();
+            const identityValueTypes = this.getDeclaredIdentityValueTypes();
+            const numericRoots = this.getDeclaredNumericRoots();
+            const uniqueRoots = new Set(identityValueTypes.keys());
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const normalizedFilter = normalizeStrictFilter(filterArg, declaredRoots, declaredAtomicPaths, identityValueTypes, numericRoots, serializedRoots, 'Atomic update');
+            const normalizedOptions = '$expr' in normalizedFilter
+                ? normalizeAtomicExpressionUpdateOptions(opts)
+                : opts;
+            if (normalizedOptions?.upsert === true && '$expr' in normalizedFilter) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Atomic update does not support upsert when the filter contains $expr.');
+            }
+            const normalizedUpdate = normalizeAtomicUpdate(updateArg, declaredRoots, declaredAtomicPaths, uniqueRoots, serializedRoots);
+            const now = new Date().toISOString();
+            normalizedUpdate.$set = {
+                ...(normalizedUpdate.$set || {}),
+                _updatedAt: now,
+            };
+            if (normalizedOptions?.upsert === true) {
+                normalizedUpdate.$setOnInsert = {
+                    ...(normalizedUpdate.$setOnInsert || {}),
+                    _createdAt: now,
+                };
+            }
+            const collection = this.collection;
+            const result = await executeAtomicUpdate(collection, normalizedFilter, normalizedUpdate, normalizedOptions);
+            return {
+                acknowledged: result.acknowledged,
+                matchedCount: result.matchedCount,
+                modifiedCount: result.modifiedCount,
+                upsertedId: result.upsertedId,
+            };
+        }
+        /**
+         * Atomically updates one ordinary model document and returns a hydrated
+         * before or after image with a sanitized persistence outcome.
+         */
+        static async atomicFindOneAndUpdate(filterArg, updateArg, optionsArg) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'atomicFindOneAndUpdate is unavailable for exact-persistence models.');
+            }
+            const normalizedOptions = normalizeAtomicFindOneAndUpdateOptions(optionsArg);
+            const policy = getOrdinaryPersistencePolicy(this);
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const declaredAtomicPaths = this.getDeclaredAtomicPaths();
+            const identityValueTypes = this.getDeclaredIdentityValueTypes();
+            const numericRoots = this.getDeclaredNumericRoots();
+            const uniqueRoots = new Set(identityValueTypes.keys());
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const normalizedFilter = normalizeStrictFilter(filterArg, declaredRoots, declaredAtomicPaths, identityValueTypes, numericRoots, serializedRoots, 'Atomic find-one-and-update');
+            if (normalizedOptions.upsert && '$expr' in normalizedFilter) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Atomic find-one-and-update does not support upsert when the filter contains $expr.');
+            }
+            const normalizedUpdate = normalizeAtomicUpdate(updateArg, declaredRoots, declaredAtomicPaths, uniqueRoots, serializedRoots);
+            if (policy?.timestamps !== 'none') {
+                const now = new Date().toISOString();
+                normalizedUpdate.$set = { ...(normalizedUpdate.$set || {}), _updatedAt: now };
+                if (normalizedOptions.upsert) {
+                    normalizedUpdate.$setOnInsert = { ...(normalizedUpdate.$setOnInsert || {}), _createdAt: now };
+                }
+            }
+            const normalizedSort = normalizeSort(normalizedOptions.sort, declaredRoots, this.getDeclaredQueryPaths());
+            const collection = this.collection;
+            const result = await executeAtomicFindOneAndUpdate(collection, normalizedFilter, normalizedUpdate, {
+                returnDocument: normalizedOptions.returnDocument,
+                upsert: normalizedOptions.upsert,
+                ...(normalizedSort ? { sort: normalizedSort } : {}),
+                ...(normalizedOptions.session ? { session: normalizedOptions.session } : {}),
+            });
+            if (result.document === null) {
+                return result;
+            }
+            return {
+                status: result.status,
+                document: this.createInstanceFromMongoDbNativeDoc(result.document),
+            };
+        }
+        /**
+         * Atomically deletes one ordinary model document using a strict selector.
+         *
+         * This static operation intentionally does not hydrate an instance or run
+         * instance deletion hooks. Callers that require those hooks must use the
+         * instance `delete()` method instead.
+         */
+        static async atomicDelete(filterArg, opts) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'atomicDelete is unavailable for exact-persistence models.');
+            }
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const declaredAtomicPaths = this.getDeclaredAtomicPaths();
+            const identityValueTypes = this.getDeclaredIdentityValueTypes();
+            const numericRoots = this.getDeclaredNumericRoots();
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const normalizedFilter = normalizeStrictFilter(filterArg, declaredRoots, declaredAtomicPaths, identityValueTypes, numericRoots, serializedRoots, 'Atomic delete', this.getGloballyConstrainingKeySets());
+            const collection = this.collection;
+            const result = await executeAtomicDelete(collection, normalizedFilter, { session: opts?.session, timeoutMS: requireBoundedInteger(opts?.timeoutMS, 'Atomic delete timeoutMS', 120_000) });
+            return {
+                acknowledged: result.acknowledged,
+                deletedCount: result.deletedCount,
+            };
+        }
+        /**
+         * Atomically deletes every ordinary model document matching a strict
+         * selector. Each matched document is deleted atomically; the batch as a
+         * whole is not isolated. Unlike `atomicDelete()`, the filter does not need
+         * to pin a unique index — plural intent is explicit in this API — but it
+         * still requires declared fields and at least one top-level equality
+         * anchor.
+         */
+        static async atomicDeleteMany(filterArg, opts) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'atomicDeleteMany is unavailable for exact-persistence models.');
+            }
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const declaredAtomicPaths = this.getDeclaredAtomicPaths();
+            const identityValueTypes = this.getDeclaredIdentityValueTypes();
+            const numericRoots = this.getDeclaredNumericRoots();
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const normalizedFilter = normalizeStrictFilter(filterArg, declaredRoots, declaredAtomicPaths, identityValueTypes, numericRoots, serializedRoots, 'Atomic delete-many');
+            const collection = this.collection;
+            const result = await executeAtomicDeleteMany(collection, normalizedFilter, { session: opts?.session, timeoutMS: requireBoundedInteger(opts?.timeoutMS, 'Atomic delete-many timeoutMS', 120_000) });
+            return {
+                acknowledged: result.acknowledged,
+                deletedCount: result.deletedCount,
+            };
+        }
+        /**
+         * Atomically updates every ordinary model document matching a strict
+         * selector. Each matched document is updated atomically; the batch as a
+         * whole is not isolated. No upsert is possible, so `$setOnInsert` is
+         * rejected.
+         */
+        static async atomicUpdateMany(filterArg, updateArg, opts) {
+            if (getOrdinaryPersistencePolicy(this)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Validated ordinary models require transactional postimage updates.');
+            }
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'atomicUpdateMany is unavailable for exact-persistence models.');
+            }
+            if (typeof updateArg === 'object'
+                && updateArg !== null
+                && '$setOnInsert' in updateArg) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Atomic update-many does not support $setOnInsert.');
+            }
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const declaredAtomicPaths = this.getDeclaredAtomicPaths();
+            const uniqueRoots = this.getDeclaredUniqueRoots();
+            const identityValueTypes = this.getDeclaredIdentityValueTypes();
+            const numericRoots = this.getDeclaredNumericRoots();
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const normalizedFilter = normalizeStrictFilter(filterArg, declaredRoots, declaredAtomicPaths, identityValueTypes, numericRoots, serializedRoots, 'Atomic update-many');
+            const normalizedUpdate = normalizeAtomicUpdate(updateArg, declaredRoots, declaredAtomicPaths, uniqueRoots, serializedRoots);
+            const now = new Date().toISOString();
+            normalizedUpdate.$set = {
+                ...(normalizedUpdate.$set || {}),
+                _updatedAt: now,
+            };
+            const collection = this.collection;
+            const result = await executeAtomicUpdateMany(collection, normalizedFilter, normalizedUpdate, opts);
+            return {
+                acknowledged: result.acknowledged,
+                matchedCount: result.matchedCount,
+                modifiedCount: result.modifiedCount,
+            };
+        }
+        /**
+         * Computes bounded grouped counts and optional numeric sums server-side.
+         * Groups by one or two declared top-level fields, always returns a `count`
+         * per group, and sums only declared numeric fields. The `$limit` follows
+         * the group stage without a sort, so when more groups exist than the limit
+         * the returned subset is arbitrary. Use `getGroupedTotalsPage()` when the
+         * caller must detect overflow. The aggregation cursor never leaves SmartData.
+         */
+        static async getGroupedTotals(optionsArg) {
+            const page = await this.getGroupedTotalsPage(optionsArg);
+            return page.rows;
+        }
+        /**
+         * Computes the same bounded grouped totals as `getGroupedTotals()` and
+         * reports whether at least one additional group exists beyond the requested
+         * row limit.
+         */
+        static async getGroupedTotalsPage(optionsArg) {
+            if (this[exactPersistencePolicySymbol]) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'getGroupedTotals is unavailable for exact-persistence models.');
+            }
+            if (typeof optionsArg !== 'object'
+                || optionsArg === null
+                || plugins.nodeUtil.types.isProxy(optionsArg)
+                || !isPlainObject(optionsArg)) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals options must be an inert plain object.');
+            }
+            const allowedKeys = new Set([
+                'groupBy',
+                'sums',
+                'filter',
+                'limit',
+                'maxTimeMS',
+                'timeoutMS',
+                'signal',
+                'session',
+            ]);
+            for (const key of Reflect.ownKeys(optionsArg)) {
+                if (typeof key !== 'string' || !allowedKeys.has(key)) {
+                    throw new SmartdataPersistenceError('invalid_argument', `Grouped totals received unsupported option "${String(key)}".`);
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(optionsArg, key);
+                if (!descriptor
+                    || !('value' in descriptor)
+                    || descriptor.enumerable !== true) {
+                    throw new SmartdataPersistenceError('invalid_argument', `Grouped totals option "${key}" must be an inert enumerable data property.`);
+                }
+            }
+            const groupByOption = optionsArg.groupBy;
+            const sumsOption = optionsArg.sums;
+            const filterOption = optionsArg.filter;
+            const limitOption = optionsArg.limit;
+            const maxTimeMSOption = optionsArg.maxTimeMS;
+            const timeoutMSOption = optionsArg.timeoutMS;
+            const signalOption = optionsArg.signal;
+            if (signalOption !== undefined && !(signalOption instanceof AbortSignal)) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals signal must be an AbortSignal.');
+            }
+            signalOption?.throwIfAborted();
+            const sessionOption = optionsArg.session;
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const serializedRoots = this.getSerializedPersistedRoots();
+            const requireDeclaredGroupField = (fieldArg, labelArg) => {
+                if (typeof fieldArg !== 'string') {
+                    throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must name a declared top-level field.`);
+                }
+                const root = requireDeclaredPath(fieldArg, declaredRoots, labelArg);
+                if (root !== fieldArg) {
+                    throw new SmartdataPersistenceError('invalid_argument', `${labelArg} must name a declared top-level field, not a nested path.`);
+                }
+                if (serializedRoots.has(root)) {
+                    throw new SmartdataPersistenceError('unsupported_operation', `${labelArg} cannot target serialized field "${root}".`);
+                }
+                return root;
+            };
+            if (!Array.isArray(groupByOption)
+                || groupByOption.length < 1
+                || groupByOption.length > 2) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals require one or two groupBy fields.');
+            }
+            const groupByFields = [...groupByOption].map((fieldArg) => requireDeclaredGroupField(fieldArg, 'Grouped totals groupBy field'));
+            if (groupByFields.length < 1
+                || groupByFields.length > 2
+                || new Set(groupByFields).size !== groupByFields.length) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals groupBy fields must be one or two distinct fields.');
+            }
+            if (sumsOption !== undefined && !Array.isArray(sumsOption)) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals sums must be an array of declared numeric fields.');
+            }
+            const sumFields = [...(sumsOption ?? [])].map((fieldArg) => requireDeclaredGroupField(fieldArg, 'Grouped totals sum field'));
+            if (new Set(sumFields).size !== sumFields.length) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals sum fields must be distinct.');
+            }
+            const limit = requireBoundedInteger(limitOption, 'Grouped totals limit', 10_000);
+            if (limit === undefined) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Grouped totals require an explicit limit.');
+            }
+            const maxTimeMS = requireBoundedInteger(maxTimeMSOption, 'Grouped totals maxTimeMS', 120_000);
+            const timeoutMS = requireBoundedInteger(timeoutMSOption, 'Grouped totals timeoutMS', 120_000);
+            const groupStage = {
+                _id: groupByFields.length === 1
+                    ? '$' + groupByFields[0]
+                    : Object.fromEntries(groupByFields.map((fieldArg) => [fieldArg, '$' + fieldArg])),
+                __groupedTotalsCount: { $sum: 1 },
+            };
+            for (const [index, sumField] of sumFields.entries()) {
+                groupStage['__groupedTotalsSum' + index] = { $sum: '$' + sumField };
+            }
+            const collection = this.collection;
+            const rows = await collection.aggregateGroupedTotals(filterOption !== undefined
+                ? convertFilterForMongoDb(filterOption)
+                : undefined, groupStage, limit + 1, {
+                ...(sessionOption ? { session: sessionOption } : {}),
+                ...(maxTimeMS !== undefined ? { maxTimeMS } : {}),
+                ...(timeoutMS !== undefined ? { timeoutMS } : {}),
+                ...(signalOption !== undefined ? { signal: signalOption } : {}),
+            });
+            const hasMore = rows.length > limit;
+            const returnedRows = rows.slice(0, limit);
+            const requireFiniteNumber = (valueArg, labelArg) => {
+                if (typeof valueArg !== 'number' || !Number.isFinite(valueArg)) {
+                    throw new SmartdataPersistenceError('unsupported_operation', `${labelArg} produced a non-numeric total; store safe-integer values in summed fields.`);
+                }
+                return valueArg;
+            };
+            const mappedRows = returnedRows.map((rowArg) => {
+                const group = {};
+                if (groupByFields.length === 1) {
+                    group[groupByFields[0]] = rowArg._id ?? null;
+                }
+                else {
+                    const compoundKey = (rowArg._id ?? {});
+                    for (const fieldArg of groupByFields) {
+                        // Missing and explicit-null values merge into one group that is
+                        // reported as null in both the single-field and compound shapes.
+                        group[fieldArg] = compoundKey[fieldArg] ?? null;
+                    }
+                }
+                const sums = {};
+                for (const [index, sumField] of sumFields.entries()) {
+                    sums[sumField] = requireFiniteNumber(rowArg['__groupedTotalsSum' + index], `Grouped totals sum field "${sumField}"`);
+                }
+                return {
+                    group,
+                    count: requireFiniteNumber(rowArg.__groupedTotalsCount, 'Grouped totals count'),
+                    sums,
+                };
+            });
+            return {
+                rows: mappedRows,
+                hasMore,
+            };
+        }
+        /**
+         * gets all instances as array
+         * @param this
+         * @param filterArg - Type-safe MongoDB filter with nested object support and operators
+         * @returns
+         */
+        static async getInstances(filterArg, opts) {
+            // Pass session through to findAll for transactional queries
+            const foundDocs = await this.collection.findAll(convertFilterForMongoDb(filterArg), { session: opts?.session });
+            const returnArray = [];
+            for (const foundDoc of foundDocs) {
+                const newInstance = this.createInstanceFromMongoDbNativeDoc(foundDoc);
+                returnArray.push(newInstance);
+            }
+            return returnArray;
+        }
+        /**
+         * Cursor-paged query with stable seek pagination — the org-standard way to
+         * list unbounded collections. Orders by a comparable (ideally indexed)
+         * sort field with a unique tiebreaker, returns one page plus the cursor
+         * for the next, and never materializes the full result set.
+         * Owned sessions require a prepared model and remain leased through optional
+         * counting, model hydration and cursor cleanup.
+         */
+        static async getPagedInstances(optionsArg) {
+            const collection = this.collection;
+            optionsArg = { ...optionsArg, cursor: optionsArg.cursor && { ...optionsArg.cursor } };
+            const sortDirection = optionsArg.sortDirection === 'asc' ? 1 : -1;
+            const uniqueField = optionsArg.uniqueField || 'id';
+            const requestedLimit = Number.isSafeInteger(optionsArg.limit) && optionsArg.limit > 0
+                ? optionsArg.limit
+                : 100;
+            const limit = Math.min(requestedLimit, 1000);
+            const baseSelector = convertFilterForMongoDb(optionsArg.filter || {});
+            let selector = baseSelector;
+            if (optionsArg.cursor) {
+                const seekOperator = sortDirection === 1 ? '$gt' : '$lt';
+                const seekSelector = {
+                    $or: [
+                        { [optionsArg.sortField]: { [seekOperator]: optionsArg.cursor.sortValue } },
+                        {
+                            [optionsArg.sortField]: optionsArg.cursor.sortValue,
+                            [uniqueField]: { [seekOperator]: optionsArg.cursor.uniqueValue },
+                        },
+                    ],
+                };
+                selector = Object.keys(baseSelector).length > 0
+                    ? { $and: [baseSelector, seekSelector] }
+                    : seekSelector;
+            }
+            return runWithOrdinarySmartdataSession(optionsArg.session, collection.smartdataDb, {
+                ordinaryWrite: false,
+                prepared: collection.isInitializedForCurrentDatabase(),
+            }, async (rawSessionArg) => {
+                await collection.init();
+                const rawCursor = collection.mongoDbCollection
+                    .find(selector, { session: rawSessionArg })
+                    .sort({ [optionsArg.sortField]: sortDirection, [uniqueField]: sortDirection })
+                    .limit(limit + 1);
+                return runCursorOperation(rawCursor, async (cursorArg) => {
+                    const rawDocuments = await cursorArg.toArray();
+                    const hasMore = rawDocuments.length > limit;
+                    const pageRows = rawDocuments.slice(0, limit);
+                    const documents = pageRows.map((rawDocument) => this.createInstanceFromMongoDbNativeDoc(rawDocument));
+                    const lastRow = pageRows[pageRows.length - 1];
+                    const total = optionsArg.withTotal
+                        ? await collection.mongoDbCollection.countDocuments(baseSelector, {
+                            session: rawSessionArg,
+                        })
+                        : undefined;
+                    return {
+                        documents,
+                        ...(hasMore && lastRow
+                            ? {
+                                nextCursor: {
+                                    sortValue: lastRow[optionsArg.sortField],
+                                    uniqueValue: lastRow[uniqueField],
+                                },
+                            }
+                            : {}),
+                        ...(total !== undefined ? { total } : {}),
+                    };
+                });
+            });
+        }
+        /**
+         * gets the first matching instance
+         * @param this
+         * @param filterArg
+         * @returns
+         */
+        static async getInstance(filterArg, opts) {
+            this.assertHydratedProjection(opts?.projection);
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            // Retrieve one document, with optional session for transactions
+            const foundDoc = await this.collection.findOne(convertFilterForMongoDb(filterArg), {
+                projection: normalizeProjection(opts?.projection, declaredRoots, this.getDeclaredQueryPaths()),
+                maxTimeMS: requireBoundedInteger(opts?.maxTimeMS, 'maxTimeMS', 120_000),
+                session: opts?.session,
+            });
+            if (foundDoc) {
+                const newInstance = this.createInstanceFromMongoDbNativeDoc(foundDoc);
+                return newInstance;
+            }
+            else {
+                return null;
+            }
+        }
+        static async exists(filterArg, opts) {
+            const foundDoc = await this.collection.findOne(convertFilterForMongoDb(filterArg), {
+                projection: { _id: 1 },
+                maxTimeMS: requireBoundedInteger(opts?.maxTimeMS, 'maxTimeMS', 120_000),
+                session: opts?.session,
+            });
+            return foundDoc !== null;
+        }
+        /**
+         * get a unique id prefixed with the class name
+         */
+        static async getNewId(lengthArg = 20) {
+            return `${this.className}:${plugins.smartunique.shortId(lengthArg)}`;
+        }
+        /**
+         * Stream results using model-declared projections, sorts and index hints.
+         * Offset pages require an explicit sort and limit. Include a unique final
+         * tiebreaker; concurrent writes can still move rows between offset pages.
+         */
+        static async getCursor(filterArg, opts) {
+            this.assertHydratedProjection(opts?.projection, opts?.modifier);
+            const { session, modifier } = opts || {};
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            const declaredQueryPaths = this.getDeclaredQueryPaths();
+            const projection = normalizeProjection(opts?.projection, declaredRoots, declaredQueryPaths);
+            const sort = normalizeSort(opts?.sort, declaredRoots, declaredQueryPaths);
+            const hint = normalizeQueryHint(opts?.hint, this);
+            const batchSize = requireBoundedInteger(opts?.batchSize, 'batchSize', 10_000);
+            const limit = requireBoundedInteger(opts?.limit, 'limit', 10_000);
+            const maxTimeMS = requireBoundedInteger(opts?.maxTimeMS, 'maxTimeMS', 120_000);
+            const skip = opts?.skip;
+            if (skip !== undefined && (!Number.isSafeInteger(skip) || skip < 0 || skip > 2_147_483_647 ||
+                !sort || limit === undefined)) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Cursor skip must be an integer from 0 through 2147483647 and requires sort and limit.');
+            }
+            const collection = this.collection;
+            await collection.init();
+            let rawCursor = collection.mongoDbCollection.find(convertFilterForMongoDb(filterArg), {
+                projection,
+                session,
+                hint,
+                skip,
+            });
+            if (sort) {
+                rawCursor = rawCursor.sort(sort);
+            }
+            if (batchSize) {
+                rawCursor = rawCursor.batchSize(batchSize);
+            }
+            if (limit) {
+                rawCursor = rawCursor.limit(limit);
+            }
+            if (maxTimeMS) {
+                rawCursor = rawCursor.maxTimeMS(maxTimeMS);
+            }
+            if (modifier) {
+                const originalCursor = rawCursor;
+                let modifiedCursor;
+                try {
+                    modifiedCursor = modifier(originalCursor);
+                }
+                catch (modifierError) {
+                    try {
+                        await originalCursor.close();
+                    }
+                    catch {
+                        // Preserve the modifier error when best-effort cleanup also fails.
+                    }
+                    throw modifierError;
+                }
+                if (modifiedCursor !== originalCursor) {
+                    try {
+                        await originalCursor.close();
+                    }
+                    catch (originalCursorCloseError) {
+                        try {
+                            await modifiedCursor.close();
+                        }
+                        catch {
+                            // Preserve the original cursor's cleanup error.
+                        }
+                        throw originalCursorCloseError;
+                    }
+                }
+                rawCursor = modifiedCursor;
+            }
+            return new SmartdataDbCursor(rawCursor, this);
+        }
+        /**
+         * Read a bounded offset page while retaining an owned session through cursor
+         * cleanup. Initialize the model before calling; this operation never creates
+         * collections or indexes. Count separately with the same filter and hint.
+         */
+        static async getOffsetPage(filterArg, opts) {
+            const declaredRoots = this.getDeclaredPersistedRoots();
+            this.assertHydratedProjection(opts?.projection);
+            const declaredQueryPaths = this.getDeclaredQueryPaths();
+            const projection = normalizeProjection(opts?.projection, declaredRoots, declaredQueryPaths);
+            const sort = normalizeSort(opts?.sort, declaredRoots, declaredQueryPaths);
+            const hint = normalizeQueryHint(opts?.hint, this);
+            const limit = requireBoundedInteger(opts?.limit, 'limit', 10_000);
+            const skip = opts?.skip;
+            if (!sort || limit === undefined || !Number.isSafeInteger(skip) || skip < 0 || skip > 2_147_483_647) {
+                throw new SmartdataPersistenceError('invalid_argument', 'Offset pages require sort, limit and an integer skip from 0 through 2147483647.');
+            }
+            const timeoutMS = requireBoundedInteger(opts?.timeoutMS === undefined ? 5_000 : opts.timeoutMS, 'timeoutMS', 120_000);
+            const maxTimeMS = requireBoundedInteger(opts?.maxTimeMS, 'maxTimeMS', 120_000);
+            const filter = convertFilterForMongoDb(filterArg);
+            opts.signal?.throwIfAborted();
+            const collection = this.collection;
+            if (!collection.isInitializedForCurrentDatabase()) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Initialize the model before reading an offset page.');
+            }
+            return runWithOrdinarySmartdataSession(opts.session, collection.smartdataDb, {
+                ordinaryWrite: false,
+                prepared: true,
+            }, async (rawSessionArg) => {
+                opts.signal?.throwIfAborted();
+                const rawCursor = collection.mongoDbCollection.find(filter, {
+                    projection, sort, hint, skip, limit, maxTimeMS, timeoutMS,
+                    timeoutMode: 'cursorLifetime', session: rawSessionArg, signal: opts.signal,
+                });
+                return runCursorOperation(rawCursor, async (cursorArg) => {
+                    const documents = await cursorArg.toArray();
+                    return documents.map((documentArg) => this.createInstanceFromMongoDbNativeDoc(documentArg));
+                }, opts.signal);
+            });
+        }
+        /**
+         * watch the collection
+         * @param this
+         * @param filterArg
+         * @param forEachFunction
+         */
+        /**
+         * Watch the collection for changes, with optional buffering and change stream options.
+         * @param filterArg MongoDB filter to select which changes to observe
+         * @param opts optional ChangeStreamOptions plus bufferTimeMs
+         */
+        static async watch(filterArg, opts) {
+            const collection = this.collection;
+            const watcher = await collection.watch(convertFilterForMongoDb(filterArg), opts || {}, this);
+            return watcher;
+        }
+        /**
+         * run a function for all instances
+         * @returns
+         */
+        static async forEach(filterArg, forEachFunction) {
+            const cursor = await this.getCursor(filterArg);
+            await cursor.forEach(forEachFunction);
+        }
+        /**
+         * returns a count of the documents in the collection
+         */
+        static async getCount(filterArg = {}, opts) {
+            const hint = normalizeQueryHint(opts?.hint, this);
+            const collection = this.collection;
+            return await collection.getCount(convertFilterForMongoDb(filterArg), {
+                hint,
+                limit: requireBoundedInteger(opts?.limit, 'limit', 10_000),
+                maxTimeMS: requireBoundedInteger(opts?.maxTimeMS, 'maxTimeMS', 120_000),
+                timeoutMS: requireBoundedInteger(opts?.timeoutMS, 'timeoutMS', 120_000),
+                signal: opts?.signal,
+                session: opts?.session,
+            });
+        }
+        /**
+         * Runs an integrity check on this collection.
+         * Returns a summary with estimated vs actual counts and any duplicate unique fields.
+         */
+        static async checkCollectionIntegrity() {
+            const collection = this.collection;
+            return await collection.checkCollectionIntegrity();
+        }
+        /**
+         * Create a MongoDB filter from a Lucene query string
+         * @param luceneQuery Lucene query string
+         * @returns MongoDB query object
+         */
+        static createSearchFilter(luceneQuery) {
+            const searchableFields = this.getSearchableFields();
+            if (searchableFields.length === 0) {
+                throw new Error(`No searchable fields defined for class ${this.name}`);
+            }
+            const adapter = new SmartdataLuceneAdapter(searchableFields);
+            return adapter.convert(luceneQuery);
+        }
+        /**
+         * List all searchable fields defined on this class
+         */
+        static getSearchableFields() {
+            const ctor = this;
+            return Array.isArray(ctor.searchableFields) ? ctor.searchableFields : [];
+        }
+        /**
+         * Execute a query with optional hard filter and post-fetch validation
+         */
+        static async execQuery(baseFilter, opts) {
+            let mongoFilter = baseFilter || {};
+            if (opts?.filter) {
+                mongoFilter = { $and: [mongoFilter, opts.filter] };
+            }
+            // Fetch with optional session for transactions
+            // Fetch within optional session
+            let docs = await this.getInstances(mongoFilter, { session: opts?.session });
+            if (opts?.validate) {
+                const out = [];
+                for (const d of docs) {
+                    if (await opts.validate(d))
+                        out.push(d);
+                }
+                docs = out;
+            }
+            return docs;
+        }
+        /**
+         * Search documents by text or field:value syntax, with safe regex fallback
+         * Supports additional filtering and post-fetch validation via opts
+         * @param query A search term or field:value expression
+         * @param opts Optional filter and validate hooks
+         * @returns Array of matching documents
+         */
+        static async search(query, opts) {
+            const searchableFields = this.getSearchableFields();
+            if (searchableFields.length === 0) {
+                throw new Error(`No searchable fields defined for class ${this.name}`);
+            }
+            // empty query -> return all
+            const q = query.trim();
+            if (!q) {
+                // empty query: fetch all, apply opts
+                return await this.execQuery({}, opts);
+            }
+            // simple exact field:value (no spaces, no wildcards, no quotes)
+            // simple exact field:value (no spaces, wildcards, quotes)
+            const simpleExact = q.match(/^(\w+):([^"'\*\?\s]+)$/);
+            if (simpleExact) {
+                const field = simpleExact[1];
+                const value = simpleExact[2];
+                if (!searchableFields.includes(field)) {
+                    throw new Error(`Field '${field}' is not searchable for class ${this.name}`);
+                }
+                // simple field:value search
+                return await this.execQuery({ [field]: value }, opts);
+            }
+            // quoted phrase across all searchable fields: exact match of phrase
+            const quoted = q.match(/^"(.+)"$|^'(.+)'$/);
+            if (quoted) {
+                const phrase = quoted[1] || quoted[2] || '';
+                const parts = phrase.split(/\s+/).map((t) => escapeForRegex(t));
+                const pattern = parts.join('\\s+');
+                const orConds = searchableFields.map((f) => ({ [f]: { $regex: pattern, $options: 'i' } }));
+                return await this.execQuery({ $or: orConds }, opts);
+            }
+            // wildcard field:value (supports * and ?) -> direct regex on that field
+            const wildcardField = q.match(/^(\w+):(.+[*?].*)$/);
+            if (wildcardField) {
+                const field = wildcardField[1];
+                // Support quoted wildcard patterns: strip surrounding quotes
+                let pattern = wildcardField[2];
+                if ((pattern.startsWith('"') && pattern.endsWith('"')) ||
+                    (pattern.startsWith("'") && pattern.endsWith("'"))) {
+                    pattern = pattern.slice(1, -1);
+                }
+                if (!searchableFields.includes(field)) {
+                    throw new Error(`Field '${field}' is not searchable for class ${this.name}`);
+                }
+                // escape regex special chars except * and ?, then convert wildcards
+                const escaped = pattern.replace(/([.+^${}()|[\\]\\])/g, '\\$1');
+                const regexPattern = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
+                return await this.execQuery({ [field]: { $regex: regexPattern, $options: 'i' } }, opts);
+            }
+            // wildcard plain term across all fields (supports * and ?)
+            if (!q.includes(':') && (q.includes('*') || q.includes('?'))) {
+                // build wildcard regex pattern: escape all except * and ? then convert
+                const escaped = q.replace(/([.+^${}()|[\\]\\])/g, '\\$1');
+                const pattern = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
+                const orConds = searchableFields.map((f) => ({ [f]: { $regex: pattern, $options: 'i' } }));
+                return await this.execQuery({ $or: orConds }, opts);
+            }
+            // implicit AND for multiple tokens: free terms, quoted phrases, and field:values
+            {
+                // Split query into tokens, preserving quoted substrings
+                const rawTokens = q.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+                // Only apply when more than one token and no boolean operators or grouping
+                if (rawTokens.length > 1 &&
+                    !/(\bAND\b|\bOR\b|\bNOT\b|\(|\))/i.test(q) &&
+                    !/\[|\]/.test(q)) {
+                    const andConds = [];
+                    for (let token of rawTokens) {
+                        // field:value token
+                        const fv = token.match(/^(\w+):(.+)$/);
+                        if (fv) {
+                            const field = fv[1];
+                            let value = fv[2];
+                            if (!searchableFields.includes(field)) {
+                                throw new Error(`Field '${field}' is not searchable for class ${this.name}`);
+                            }
+                            // Strip surrounding quotes if present
+                            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                                value = value.slice(1, -1);
+                            }
+                            // Wildcard search?
+                            if (value.includes('*') || value.includes('?')) {
+                                const escaped = value.replace(/([.+^${}()|[\\]\\])/g, '\\$1');
+                                const pattern = escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
+                                andConds.push({ [field]: { $regex: pattern, $options: 'i' } });
+                            }
+                            else {
+                                andConds.push({ [field]: value });
+                            }
+                        }
+                        else if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith("'") && token.endsWith("'"))) {
+                            // Quoted free phrase across all fields
+                            const phrase = token.slice(1, -1);
+                            const parts = phrase.split(/\s+/).map((t) => escapeForRegex(t));
+                            const pattern = parts.join('\\s+');
+                            andConds.push({ $or: searchableFields.map((f) => ({ [f]: { $regex: pattern, $options: 'i' } })) });
+                        }
+                        else {
+                            // Free term across all fields
+                            const esc = escapeForRegex(token);
+                            andConds.push({ $or: searchableFields.map((f) => ({ [f]: { $regex: esc, $options: 'i' } })) });
+                        }
+                    }
+                    return await this.execQuery({ $and: andConds }, opts);
+                }
+            }
+            // detect advanced Lucene syntax: field:value, wildcards, boolean, grouping
+            const luceneSyntax = /(\w+:[^\s]+)|\*|\?|\bAND\b|\bOR\b|\bNOT\b|\(|\)/;
+            if (luceneSyntax.test(q)) {
+                const filter = this.createSearchFilter(q);
+                return await this.execQuery(filter, opts);
+            }
+            // multi-term unquoted -> AND of regex across fields for each term
+            const terms = q.split(/\s+/);
+            if (terms.length > 1) {
+                const andConds = terms.map((term) => {
+                    const esc = escapeForRegex(term);
+                    const ors = searchableFields.map((f) => ({ [f]: { $regex: esc, $options: 'i' } }));
+                    return { $or: ors };
+                });
+                return await this.execQuery({ $and: andConds }, opts);
+            }
+            // single term -> regex across all searchable fields
+            const esc = escapeForRegex(q);
+            const orConds = searchableFields.map((f) => ({ [f]: { $regex: esc, $options: 'i' } }));
+            return await this.execQuery({ $or: orConds }, opts);
+        }
+        // INSTANCE
+        // INSTANCE
+        /**
+         * how the Doc in memory was created, may prove useful later.
+         */
+        creationStatus = 'new';
+        /**
+         * updated from db in any case where doc comes from db
+         */
+        _createdAt = __runInitializers(this, __createdAt_initializers, new Date().toISOString());
+        /**
+         * will be updated everytime the doc is saved
+         */
+        _updatedAt = (__runInitializers(this, __createdAt_extraInitializers), __runInitializers(this, __updatedAt_initializers, new Date().toISOString()));
+        /**
+         * name
+         */
+        name = __runInitializers(this, __updatedAt_extraInitializers);
+        /**
+         * primary id in the database
+         */
+        dbDocUniqueId;
+        /**
+         * class constructor
+         */
+        constructor() {
+            if (getOrdinaryPersistencePolicy(this.constructor)?.timestamps === 'none') {
+                delete this._createdAt;
+                delete this._updatedAt;
+            }
+        }
+        /**
+         * saves this instance (optionally within a transaction)
+         */
+        async save(opts) {
+            if (getOrdinaryPersistencePolicy(this.constructor)) {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Validated ordinary models use insert() or transactional postimage updates.');
+            }
+            const exactPersistencePolicy = this.constructor[exactPersistencePolicySymbol];
+            if (exactPersistencePolicy) {
+                if (exactPersistencePolicy.unsupportedSave) {
+                    return exactPersistencePolicy.unsupportedSave();
+                }
+                throw new Error('save() is unavailable for exact-persistence models.');
+            }
+            // allow hook before saving
+            if (typeof this.beforeSave === 'function') {
+                await this.beforeSave();
+            }
+            assertUsableIdentityValues(this, this.uniqueIndexes || [], this.identityValueTypes);
+            // tslint:disable-next-line: no-this-assignment
+            const self = this;
+            let dbResult;
+            // update timestamp
+            this._updatedAt = new Date().toISOString();
+            // perform insert or update
+            switch (this.creationStatus) {
+                case 'db':
+                    dbResult = await this.getCollectionSafe().update(self, { session: opts?.session });
+                    break;
+                case 'new':
+                    dbResult = await this.getCollectionSafe().insert(self, { session: opts?.session });
+                    this.creationStatus = 'db';
+                    break;
+                default:
+                    logger.log('error', 'neither new nor in db?');
+            }
+            // allow hook after saving
+            if (typeof this.afterSave === 'function') {
+                await this.afterSave();
+            }
+            return dbResult;
+        }
+        /**
+         * deletes a document from the database (optionally within a transaction)
+         */
+        async delete(opts) {
+            const exactPersistencePolicy = this.constructor[exactPersistencePolicySymbol];
+            if (exactPersistencePolicy) {
+                if (exactPersistencePolicy.forbiddenDelete) {
+                    return exactPersistencePolicy.forbiddenDelete();
+                }
+                throw new Error('delete() is forbidden for exact-persistence models.');
+            }
+            // allow hook before deleting
+            if (typeof this.beforeDelete === 'function') {
+                await this.beforeDelete();
+            }
+            // perform deletion
+            const result = await this.getCollectionSafe().delete(this, { session: opts?.session });
+            // allow hook after delete
+            if (typeof this.afterDelete === 'function') {
+                await this.afterDelete();
+            }
+            return result;
+        }
+        /**
+         * also store any referenced objects to DB
+         * better for data consistency
+         */
+        saveDeep(savedMapArg) {
+            if (!savedMapArg) {
+                savedMapArg = new plugins.lik.ObjectMap();
+            }
+            savedMapArg.add(this);
+            this.save();
+            for (const propertyKey of Object.keys(this)) {
+                const property = this[propertyKey];
+                if (property instanceof SmartDataDbDoc && !savedMapArg.checkForObject(property)) {
+                    property.saveDeep(savedMapArg);
+                }
+            }
+        }
+        /**
+         * updates an object from db
+         */
+        async updateFromDb() {
+            const identifiableObject = await this.createIdentifiableObject();
+            if (Object.keys(identifiableObject).length === 0) {
+                throw new SmartdataPersistenceError('invalid_configuration', 'updateFromDb() requires declared identity fields; without them the lookup would read an arbitrary document.');
+            }
+            const mongoDbNativeDoc = await this.getCollectionSafe().findOne(identifiableObject);
+            if (!mongoDbNativeDoc) {
+                return false; // Document not found in database
+            }
+            if (getOrdinaryPersistencePolicy(this.constructor)) {
+                const hydrated = this.constructor.createInstanceFromMongoDbNativeDoc(mongoDbNativeDoc);
+                for (const field of [...(this.saveableProperties || []), '_id', '_createdAt', '_updatedAt']) {
+                    if (!Object.prototype.hasOwnProperty.call(hydrated, field))
+                        delete this[field];
+                }
+                Object.assign(this, hydrated);
+                return true;
+            }
+            for (const key of Object.keys(mongoDbNativeDoc)) {
+                const rawValue = mongoDbNativeDoc[key];
+                const optionsMap = this.constructor._svDbOptions || {};
+                const opts = optionsMap[key];
+                this[key] = opts && typeof opts.deserialize === 'function'
+                    ? opts.deserialize(rawValue)
+                    : rawValue;
+            }
+            return true;
+        }
+        /**
+         * creates a saveable object so the instance can be persisted as json in the database
+         *
+         * Properties whose value is `undefined` are omitted entirely rather than
+         * written as BSON null, so "absent" stays representable. Explicit `null` is
+         * untouched and remains storable wherever the field type allows it.
+         */
+        async createSavableObject() {
+            if (getOrdinaryPersistencePolicy(this.constructor)?.timestamps === 'none' &&
+                (Object.prototype.hasOwnProperty.call(this, '_createdAt') ||
+                    Object.prototype.hasOwnProperty.call(this, '_updatedAt'))) {
+                throw new SmartdataPersistenceError('invalid_document', 'This ordinary persistence policy forbids managed timestamps.');
+            }
+            assertUsableIdentityValues(this, this.uniqueIndexes || [], this.identityValueTypes);
+            const saveableObject = {}; // is not exposed to outside, so any is ok here
+            const globalProps = this.globalSaveableProperties || [];
+            const specificProps = this.saveableProperties || [];
+            const policy = getOrdinaryPersistencePolicy(this.constructor);
+            const saveableProperties = [...new Set([
+                    ...globalProps, ...specificProps, ...(policy ? ['_id'] : []),
+                ])].filter((fieldArg) => policy?.timestamps !== 'none' ||
+                !['_createdAt', '_updatedAt'].includes(fieldArg));
+            // apply custom serialization if configured
+            const optionsMap = this.constructor._svDbOptions || {};
+            for (const propertyNameString of saveableProperties) {
+                const rawValue = this[propertyNameString];
+                const opts = optionsMap[propertyNameString];
+                const serializedValue = opts && typeof opts.serialize === 'function'
+                    ? opts.serialize(rawValue)
+                    : rawValue;
+                if (serializedValue === undefined) {
+                    // an undefined property means "absent" - skip it so the driver cannot
+                    // turn it into BSON null during serialization
+                    continue;
+                }
+                saveableObject[propertyNameString] = stripUndefinedValues(serializedValue);
+            }
+            return saveableObject;
+        }
+        /**
+         * creates an identifiable object for operations that require filtering
+         */
+        async createIdentifiableObject() {
+            assertUsableIdentityValues(this, this.uniqueIndexes || [], this.identityValueTypes);
+            const identifiableObject = {}; // is not exposed to outside, so any is ok here
+            for (const propertyNameString of this.uniqueIndexes || []) {
+                identifiableObject[propertyNameString] = this[propertyNameString];
+            }
+            if (getOrdinaryPersistencePolicy(this.constructor)?.idType === 'string') {
+                const id = this._id;
+                if (typeof id !== 'string' || id.trim().length === 0) {
+                    throw new SmartdataPersistenceError('invalid_argument', 'String primary ID is required.');
+                }
+                identifiableObject._id = id;
+            }
+            return identifiableObject;
+        }
+    };
+})();
+export { SmartDataDbDoc };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.doc.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.doc.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAExC,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EACL,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,oCAAoC,GACrC,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,4BAA4B,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAChH,OAAO,EACL,sBAAsB,EAAE,6BAA6B,GAGtD,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAGL,mBAAmB,GACpB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACzF,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACzF,OAAO,EACL,yBAAyB,GAC1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,8BAA8B,EAC9B,+BAA+B,GAEhC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qCAAqC,EACrC,iCAAiC,GAGlC,MAAM,iCAAiC,CAAC;AA0BzC,MAAM,4BAA4B,GAAG,MAAM,CAAC,GAAG,CAC7C,8CAA8C,CAC/C,CAAC;AA8BF;;;;;GAKG;AACH,MAAM,aAAa,GAAG,CAAC,QAAiB,EAAuC,EAAE;IAC/E,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAClD,OAAO,SAAS,KAAK,MAAM,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC;AAC9D,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,oBAAoB,GAAG,CAAI,QAAW,EAAE,OAAyB,EAAK,EAAE;IAC5E,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACxC,IAAI,CAAC,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzC,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,IAAI,IAAI,OAAO,EAAU,CAAC;IAC9C,IAAI,IAAI,CAAC,GAAG,CAAC,QAAkB,CAAC,EAAE,CAAC;QACjC,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,QAAkB,CAAC,CAAC;IAC7B,IAAI,OAAO,EAAE,CAAC;QACZ,OAAQ,QAAsB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAC9C,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,oBAAoB,CAAC,QAAQ,EAAE,IAAI,CAAC,CACrD,CAAC;IACpB,CAAC;IACD,MAAM,cAAc,GAA4B,EAAE,CAAC;IACnD,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,QAAmC,CAAC,EAAE,CAAC;QACtE,MAAM,KAAK,GAAI,QAAoC,CAAC,MAAM,CAAC,CAAC;QAC5D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,SAAS;QACX,CAAC;QACD,cAAc,CAAC,MAAM,CAAC,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC7D,CAAC;IACD,OAAO,cAA8B,CAAC;AACxC,CAAC,CAAC;AAEF,MAAM,UAAU,UAAU;IACxB,OAAO,CAAC,KAAgB,EAAE,OAAmC,EAAE,EAAE;QAC/D,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QAED,sDAAsD;QACtD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuC,CAAC;QACjE,IACE,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CACnC,QAAQ,EACR,0BAA0B,CAC3B,EACD,CAAC;YACD,QAAQ,CAAC,wBAAwB,GAAG;gBAClC,GAAG,CAAC,QAAQ,CAAC,wBAAwB,IAAI,EAAE,CAAC;aAC7C,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,wBAAyB,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC3D,QAAQ,CAAC,wBAAyB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpD,CAAC;QAED,gEAAgE;QAChE,OAAO,CAAC,cAAc,CAAC;YACrB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAEnD,IAAI,QAAQ,IAAI,QAAQ,CAAC,wBAAwB,IAAI,CAAC,KAAK,CAAC,wBAAwB,EAAE,CAAC;gBACrF,iEAAiE;gBACjE,KAAK,CAAC,wBAAwB,GAAG,CAAC,GAAG,QAAQ,CAAC,wBAAwB,CAAC,CAAC;YAC1E,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAsBD;;GAEG;AACH,MAAM,UAAU,IAAI,CAAC,OAAqB;IACxC,IAAI,OAAO,EAAE,OAAO,KAAK,SAAS,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAC3E,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,iCAAiC,CAClC,CAAC;IACJ,CAAC;IACD,MAAM,aAAa,GAAG,OAAO;QAC3B,CAAC,CAAC;YACE,GAAG,OAAO;YACV,GAAG,CAAC,OAAO,CAAC,WAAW,KAAK,SAAS;gBACnC,CAAC,CAAC;oBACE,WAAW,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC;wBAC7C,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;wBAC1B,CAAC,CAAC,OAAO,CAAC,WAAW;iBACxB;gBACH,CAAC,CAAC,EAAE,CAAC;SACR;QACH,CAAC,CAAC,SAAS,CAAC;IACd,OAAO,CAAC,KAAgB,EAAE,OAAmC,EAAE,EAAE;QAC/D,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACnD,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEtC,sDAAsD;QACtD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAoB,CAAC,EAAE,CAAC;YAC1E,QAAQ,CAAC,kBAAkB,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,kBAAmB,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrD,QAAQ,CAAC,kBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,CAAC;QAED,4BAA4B;QAC5B,IAAI,aAAa,EAAE,CAAC;YAClB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,EAAE,CAAC;gBACpE,QAAQ,CAAC,YAAY,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,YAAY,IAAI,EAAE,CAAC,EAAE,CAAC;YAC/D,CAAC;YACD,QAAQ,CAAC,YAAa,CAAC,QAAQ,CAAC,GAAG,aAAa,CAAC;QACnD,CAAC;QAED,gEAAgE;QAChE,OAAO,CAAC,cAAc,CAAC;YACrB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACzC,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC;YAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAEvC,IAAI,QAAQ,IAAI,QAAQ,CAAC,kBAAkB,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;gBACzE,iEAAiE;gBACjE,KAAK,CAAC,kBAAkB,GAAG,CAAC,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC;YAC9D,CAAC;YAED,uCAAuC;YACvC,IAAI,QAAQ,IAAI,QAAQ,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC5D,IAAI,CAAC,YAAY,GAAG,EAAE,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC;YACnD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,CAAC,KAAgB,EAAE,OAAmC,EAAE,EAAE;QAC/D,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACzD,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEtC,gCAAgC;QAChC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,kBAAkB,CAAC,EAAE,CAAC;YACxE,QAAQ,CAAC,gBAAgB,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,CAAC;QACrE,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,gBAAiB,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACnD,QAAQ,CAAC,gBAAiB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC5C,CAAC;QAED,yDAAyD;QACzD,OAAO,CAAC,cAAc,CAAC;YACrB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAkB,CAAC;YACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAEvC,IAAI,QAAQ,IAAI,QAAQ,CAAC,gBAAgB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;gBACnF,iDAAiD;gBACjD,IAAI,CAAC,gBAAgB,GAAG,CAAC,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC;YACzD,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAED,gEAAgE;AAChE,SAAS,cAAc,CAAC,KAAa;IACnC,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AACtD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,GAAG,CAAC,aAA0B,EAAE;IAC9C,IACE,OAAO,UAAU,KAAK,QAAQ;WAC3B,UAAU,KAAK,IAAI;WACnB,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;WACzB,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,WAAW,CAAC,EACnE,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,0DAA0D,CAC3D,CAAC;IACJ,CAAC;IACD,MAAM,SAAS,GAAG,UAAU,CAAC,SAAS,IAAI,QAAQ,CAAC;IACnD,IAAI,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,qBAAqB,EAAE,CAAC;QAClE,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,0DAA0D,CAC3D,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,KAAgB,EAAE,OAAmC,EAAE,EAAE;QAC/D,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEtC,gCAAgC;QAChC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,EAAE,CAAC;YACrE,QAAQ,CAAC,aAAa,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,CAAC;QAC/D,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,aAAc,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YAChD,QAAQ,CAAC,aAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC;QACD,IACE,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAoB,CAAC,EACrE,CAAC;YACD,QAAQ,CAAC,kBAAkB,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,kBAAkB,IAAI,EAAE,CAAC,EAAE,CAAC;QAC3E,CAAC;QACD,MAAM,iBAAiB,GAAG,QAAQ,CAAC,kBAAmB,CAAC,QAAQ,CAAC,CAAC;QACjE,IAAI,iBAAiB,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACzD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,mBAAmB,QAAQ,yCAAyC,CACrE,CAAC;QACJ,CAAC;QACD,QAAQ,CAAC,kBAAmB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;QAEnD,wBAAwB;QACxB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAoB,CAAC,EAAE,CAAC;YAC1E,QAAQ,CAAC,kBAAkB,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,kBAAmB,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrD,QAAQ,CAAC,kBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,CAAC;QAED,gEAAgE;QAChE,OAAO,CAAC,cAAc,CAAC;YACrB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAEnD,IAAI,QAAQ,IAAI,QAAQ,CAAC,aAAa,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;gBAC/D,KAAK,CAAC,aAAa,GAAG,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;YACpD,CAAC;YAED,IACE,QAAQ;mBACL,QAAQ,CAAC,kBAAkB;mBAC3B,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,oBAAoB,CAAC,EACrE,CAAC;gBACD,KAAK,CAAC,kBAAkB,GAAG,EAAE,GAAG,QAAQ,CAAC,kBAAkB,EAAE,CAAC;YAChE,CAAC;YAED,IAAI,QAAQ,IAAI,QAAQ,CAAC,kBAAkB,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;gBACzE,KAAK,CAAC,kBAAkB,GAAG,CAAC,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAaD;;GAEG;AACH,MAAM,UAAU,KAAK,CAAC,OAAuB;IAC3C,OAAO,CAAC,KAAgB,EAAE,OAAmC,EAAE,EAAE;QAC/D,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEtC,gCAAgC;QAChC,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuC,CAAC;QACjE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,EAAE,CAAC;YACtE,QAAQ,CAAC,cAAc,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,CAAC;QACjE,CAAC;QACD,QAAQ,CAAC,cAAe,CAAC,IAAI,CAAC;YAC5B,KAAK,EAAE,QAAQ;YACf,OAAO,EAAE,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE;SAChC,CAAC,CAAC;QAEH,wBAAwB;QACxB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,oBAAoB,CAAC,EAAE,CAAC;YAC1E,QAAQ,CAAC,kBAAkB,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,CAAC;QACzE,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,kBAAmB,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrD,QAAQ,CAAC,kBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC9C,CAAC;QAED,gEAAgE;QAChE,OAAO,CAAC,cAAc,CAAC;YACrB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YAEnD,IAAI,QAAQ,IAAI,QAAQ,CAAC,cAAc,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;gBACjE,KAAK,CAAC,cAAc,GAAG,CAAC,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;YACtD,CAAC;YAED,IAAI,QAAQ,IAAI,QAAQ,CAAC,kBAAkB,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;gBACzE,KAAK,CAAC,kBAAkB,GAAG,CAAC,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAAC;YAC9D,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AA2ZD,MAAM,sCAAsC,GAAG,CAG7C,UAAoE,EAMpE,EAAE;IACF,IACE,OAAO,UAAU,KAAK,QAAQ;WAC3B,UAAU,KAAK,IAAI;WACnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;WAC1C,CAAC,aAAa,CAAC,UAAU,CAAC,EAC7B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,mEAAmE,CACpE,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAC7E,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IACzC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACrD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,2DAA2D,MAAM,CAAC,GAAG,CAAC,IAAI,CAC3E,CAAC;QACJ,CAAC;QACD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACpE,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC,IAAI,UAAU,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC9E,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,sCAAsC,GAAG,8CAA8C,CACxF,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,wBAAwB,GAAG,MAAM,CAAC,wBAAwB,CAC9D,UAAU,EACV,gBAAgB,CACjB,CAAC;IACF,IACE,CAAC,wBAAwB;WACtB,CAAC,CAAC,OAAO,IAAI,wBAAwB,CAAC;WACtC,CACD,wBAAwB,CAAC,KAAK,KAAK,QAAQ;eACxC,wBAAwB,CAAC,KAAK,KAAK,OAAO,CAC9C,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,+EAA+E,CAChF,CAAC;IACJ,CAAC;IACD,MAAM,gBAAgB,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAC/E,IAAI,gBAAgB,IAAI,gBAAgB,CAAC,KAAK,KAAK,SAAS;WACvD,OAAO,gBAAgB,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QACjD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,sDAAsD,CACvD,CAAC;IACJ,CAAC;IACD,MAAM,cAAc,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAC3E,MAAM,iBAAiB,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IACjF,OAAO;QACL,cAAc,EAAE,wBAAwB,CAAC,KAAwB;QACjE,MAAM,EAAE,gBAAgB,EAAE,KAAK,KAAK,IAAI;QACxC,GAAG,CAAC,cAAc,EAAE,KAAK,KAAK,SAAS;YACrC,CAAC,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,KAAK,EAAE;YAChC,CAAC,CAAC,EAAE,CAAC;QACP,GAAG,CAAC,iBAAiB,EAAE,KAAK,KAAK,SAAS;YACxC,CAAC,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,KAAkC,EAAE;YACnE,CAAC,CAAC,EAAE,CAAC;KACR,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,sCAAsC,GAAG,CAC7C,UAAqD,EACV,EAAE;IAC7C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IACE,OAAO,UAAU,KAAK,QAAQ;WAC3B,UAAU,KAAK,IAAI;WACnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;WAC1C,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,KAAK,MAAM,CAAC,SAAS,EACzD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,yEAAyE,CAC1E,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;IACnD,MAAM,UAAU,GAAkC,EAAE,CAAC;IACrD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;QAC9C,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACrD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,8CAA8C,MAAM,CAAC,GAAG,CAAC,IAAI,CAC9D,CAAC;QACJ,CAAC;QACD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;QACpE,IACE,CAAC,UAAU;eACR,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;eACxB,UAAU,CAAC,UAAU,KAAK,IAAI,EACjC,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,yBAAyB,GAAG,8CAA8C,CAC3E,CAAC;QACJ,CAAC;QACD,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,IACE,UAAU,CAAC,KAAK,KAAK,SAAS;mBAC3B,OAAO,UAAU,CAAC,KAAK,KAAK,SAAS,EACxC,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,yCAAyC,CAC1C,CAAC;YACJ,CAAC;YACD,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBACnC,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC;YACvC,CAAC;QACH,CAAC;aAAM,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC,KAAkC,CAAC;QACrE,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,iCAAiC,GAAG,IAAI,GAAG,CAAC;IAChD,KAAK;IACL,YAAY;IACZ,YAAY;IACZ,oBAAoB;CACrB,CAAC,CAAC;AACH,MAAM,gBAAgB,GAAG,IAAI,OAAO,EAAe,CAAC;AAEpD,MAAM,qBAAqB,GAAG,CAC5B,QAA4B,EAC5B,QAAgB,EAChB,UAAkB,EACE,EAAE;IACtB,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;QAC/B,QAAQ,IAAI,CAAC;QACb,QAAQ,GAAG,UAAU,EACrB,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,oDAAoD,UAAU,GAAG,CAC7E,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAC1B,OAAe,EACf,gBAA6B,EAC7B,QAAgB,EAChB,sBAAoC,EAC5B,EAAE;IACV,MAAM,YAAY,GAAG,OAAO,OAAO,KAAK,QAAQ;QAC9C,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC;QACpB,CAAC,CAAC,EAAE,CAAC;IACP,IACE,OAAO,OAAO,KAAK,QAAQ;QAC3B,OAAO,CAAC,MAAM,KAAK,CAAC;QACpB,OAAO,CAAC,MAAM,GAAG,IAAI;QACrB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;QACtB,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC;QACvB,YAAY,CAAC,MAAM,GAAG,EAAE;QACxB,YAAY,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAChC,UAAU,CAAC,MAAM,KAAK,CAAC;eACpB,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC;eAC1B,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;eACzB,yBAAyB,CAAC,GAAG,CAAC,UAAU,CAAC,CAC7C,CAAC;QACF,CACE,YAAY,CAAC,MAAM,GAAG,CAAC;eACpB,CAAC,sBAAsB,EAAE,GAAG,CAAC,OAAO,CAAC,CACzC,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,qCAAqC,OAAO,IAAI,CAC5D,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IAC7B,IACE,CAAC,iCAAiC,CAAC,GAAG,CAAC,IAAI,CAAC;QAC1C,CAAC,CAAC,IAAI,KAAK,KAAK,IAAI,gBAAgB,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAC9D,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAC3B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,sDAAsD,OAAO,IAAI,CAC7E,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AAEF,MAAM,yBAAyB,GAAG,IAAI,GAAG,CAAC;IACxC,WAAW;IACX,WAAW;IACX,aAAa;CACd,CAAC,CAAC;AAEH,MAAM,wBAAwB,GAAG,CAC/B,QAAiB,EACjB,QAAgB,EAChB,UAAU,IAAI,OAAO,EAAU,EACzB,EAAE;IACR,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO;IACT,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,OAAO;IACT,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtB,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE,CAAC;YAChC,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QACxD,CAAC;QACD,OAAO;IACT,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,OAAO;IACT,CAAC;IACD,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1D,IACE,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC;YACrC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC;YACtB,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;YACpB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EACrB,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,gCAAgC,MAAM,IAAI,CACtD,CAAC;QACJ,CAAC;QACD,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IACxD,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,+BAA+B,GAAG,IAAI,GAAG,CAAC;IAC9C,KAAK;IACL,KAAK;IACL,KAAK;IACL,MAAM;IACN,KAAK;IACL,MAAM;CACP,CAAC,CAAC;AAEH,MAAM,0BAA0B,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;AAE5D,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAC;IACpC,GAAG,+BAA+B;IAClC,GAAG,0BAA0B;IAC7B,SAAS;IACT,OAAO;IACP,QAAQ;IACR,UAAU;IACV,MAAM;CACP,CAAC,CAAC;AAEH,MAAM,qBAAqB,GAAG,IAAI,GAAG,CAAU;IAC7C,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;IACxC,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;CAC3C,CAAC,CAAC;AAEH,MAAM,0BAA0B,GAAG,IAAI,GAAG,CAAiB;IACzD,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAChD,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC5C,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,EAAE,YAAY,CAAC;IACpD,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC;IACxC,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC;IAC1C,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC5C,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,WAAW,CAAC;IAClD,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC5C,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC;CAC7C,CAAC,CAAC;AAEH,MAAM,8BAA8B,GAAG,CACrC,QAAiB,EACG,EAAE;IACtB,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC3C,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,YAAY,GAAG,0BAA0B,CAAC,GAAG,CACjD,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAChC,CAAC;IACF,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,qBAAqB,GAAG,MAAM,CAAC,wBAAwB,CAC3D,QAAQ,EACR,WAAW,CACZ,CAAC;IACF,IACE,qBAAqB;WAClB,CACD,CAAC,CAAC,OAAO,IAAI,qBAAqB,CAAC;eAChC,qBAAqB,CAAC,KAAK,KAAK,YAAY,CAChD,EACD,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC,CAAC;AAEF,MAAM,sBAAsB,GAAG,CAAC,QAAiB,EAAW,EAAE;IAC5D,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC3C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,KACE,IAAI,SAAS,GAAG,QAAyB,EACzC,SAAS,EACT,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,EAC5C,CAAC;QACD,IAAI,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,CAAC;YAC5D,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAAC,QAAiB,EAAW,EAAE;IACzD,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC3C,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IACvD,IACE,cAAc,KAAK,IAAI,CAAC,SAAS;WAC9B,cAAc,KAAK,MAAM,CAAC,SAAS,EACtC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,8BAA8B,CAAC,QAAQ,CAAC,KAAK,SAAS,CAAC;AAChE,CAAC,CAAC;AAEF,MAAM,4BAA4B,GAAG,IAAI,GAAG,CAAC;IAC3C,UAAU;IACV,QAAQ;IACR,YAAY;IACZ,MAAM;IACN,OAAO;IACP,QAAQ;IACR,WAAW;IACX,QAAQ;IACR,QAAQ;CACT,CAAC,CAAC;AAEH,MAAM,+BAA+B,GAAG,CACtC,QAAiB,EACjB,QAAgB,EACV,EAAE;IACR,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC3C,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,8BAA8B,CAC1C,CAAC;IACJ,CAAC;IACD,IAAI,QAAQ,YAAY,MAAM,EAAE,CAAC;QAC/B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,yDAAyD,CACrE,CAAC;IACJ,CAAC;IACD,IACE,QAAQ,YAAY,IAAI;QACxB,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,SAAS,EAClD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,yDAAyD,CACrE,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IAC1D,IACE,sBAAsB,CAAC,QAAQ,CAAC;WAC7B,CACD,CAAC,QAAQ;eACN,CAAC,4BAA4B,CAAC,GAAG,CAAC,QAAQ,CAAC,CAC/C,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,4CAA4C,CACxD,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,0BAA0B,GAAG,CACjC,QAAiB,EACjB,QAAgB,EAChB,YAAyC,EACnC,EAAE;IACR,IAAI,YAAY,KAAK,qBAAqB,EAAE,CAAC;QAC3C,IACE,OAAO,QAAQ,KAAK,QAAQ;eACzB,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC;eAC9B,QAAQ,GAAG,CAAC,EACf,CAAC;YACD,OAAO;QACT,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,uDAAuD,CACnE,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjE,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,kDAAkD,CAC9D,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,0BAA0B,GAAG,CACjC,WAAoC,EACpC,iBAAmC,EACnC,qBAA6E,EACvE,EAAE;IACR,KAAK,MAAM,aAAa,IAAI,iBAAiB,EAAE,CAAC;QAC9C,0BAA0B,CACxB,WAAW,CAAC,aAAa,CAAC,EAC1B,mBAAmB,aAAa,GAAG,EACnC,qBAAqB,EAAE,CAAC,aAAa,CAAC,IAAI,QAAQ,CACnD,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,wBAAwB,GAAG,CAC/B,QAAgB,EAChB,QAAgB,EAChB,QAAiB,EACX,EAAE;IACR,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/C,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,qCAAqC,CACjD,CAAC;QACJ,CAAC;QACD,IAAI,QAAQ,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;YACpC,SAAS;QACX,CAAC;QACD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACrE,IACE,CAAC,UAAU;YACX,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;YACxB,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU,EACtC,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0CAA0C,CACtD,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,QAAQ,EAAE,CAAC;YACxC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0CAA0C,CACtD,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;AACxE,MAAM,sBAAsB,GAAG,MAAM,CAAC,wBAAwB,CAC5D,mBAAmB,EACnB,QAAQ,CACT,EAAE,GAAG,CAAC;AACP,MAAM,0BAA0B,GAAG,MAAM,CAAC,wBAAwB,CAChE,mBAAmB,EACnB,YAAY,CACb,EAAE,GAAG,CAAC;AACP,MAAM,0BAA0B,GAAG,MAAM,CAAC,wBAAwB,CAChE,mBAAmB,EACnB,YAAY,CACb,EAAE,GAAG,CAAC;AACP,MAAM,oBAAoB,GAAG,MAAM,CAAC,wBAAwB,CAC1D,QAAQ,CAAC,SAAS,EAClB,QAAQ,CACT,EAAE,GAAG,CAAC;AACP,MAAM,wBAAwB,GAAG,MAAM,CAAC,wBAAwB,CAC9D,QAAQ,CAAC,SAAS,EAClB,YAAY,CACb,EAAE,GAAG,CAAC;AACP,MAAM,wBAAwB,GAAG,MAAM,CAAC,wBAAwB,CAC9D,QAAQ,CAAC,SAAS,EAClB,YAAY,CACb,EAAE,GAAG,CAAC;AACP,MAAM,kBAAkB,GAAG,MAAM,CAAC,wBAAwB,CACxD,MAAM,CAAC,SAAS,EAChB,QAAQ,CACT,EAAE,GAAG,CAAC;AACP,MAAM,iBAAiB,GAAG;IACxB,CAAC,GAAG,EAAE,YAAY,CAAC;IACnB,CAAC,GAAG,EAAE,QAAQ,CAAC;IACf,CAAC,GAAG,EAAE,YAAY,CAAC;IACnB,CAAC,GAAG,EAAE,WAAW,CAAC;IAClB,CAAC,GAAG,EAAE,QAAQ,CAAC;IACf,CAAC,GAAG,EAAE,SAAS,CAAC;IAChB,CAAC,GAAG,EAAE,aAAa,CAAC;IACpB,CAAC,GAAG,EAAE,QAAQ,CAAC;CAChB,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC;IAC3B,IAAI;IACJ,MAAM,EAAE,MAAM,CAAC,wBAAwB,CACrC,MAAM,CAAC,SAAS,EAChB,QAAQ,CACT,EAAE,GAAG;CACP,CAAC,CAAC,CAAC;AAEJ,MAAM,gCAAgC,GAAG,CACvC,QAAyB,EACzB,QAAgB,EACJ,EAAE;IACd,MAAM,QAAQ,GAAG,CACf,eAAgE,EAChE,mBAA2D,EAC3D,mBAA2D,EACnC,EAAE;QAC1B,IACE,CAAC,eAAe;eACb,CAAC,mBAAmB;eACpB,CAAC,mBAAmB,EACvB,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC5D,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;YACpE,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,mBAAmB,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;YACpE,OAAO,IAAI,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QACxD,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC,CAAC;IACF,MAAM,KAAK,GACT,QAAQ,CACN,sBAAsB,EACtB,0BAA0B,EAC1B,0BAA0B,CAC3B;WACE,QAAQ,CACT,oBAAoB,EACpB,wBAAwB,EACxB,wBAAwB,CACzB,CAAC;IACJ,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,wCAAwC,CACpD,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF,MAAM,mCAAmC,GAAG,CAC1C,QAAiB,EACjB,QAAgB,EACP,EAAE;IACX,IAAI,QAAQ,YAAY,IAAI,EAAE,CAAC;QAC7B,IACE,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,SAAS;YAClD,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC,EACtC,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,uCAAuC,CACnD,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9C,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE;YACxC,KAAK,EAAE,SAAS;YAChB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjC,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QACpD,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAC9B,gCAAgC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CACrD,CAAC;QACF,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE;YACxC,KAAK,EAAE,SAAS;YAChB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,gBAAgB,GAAG,8BAA8B,CAAC,QAAQ,CAAC,CAAC;IAClE,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,qCAAqC,CACjD,CAAC;IACJ,CAAC;IACD,wBAAwB,CAAC,QAAkB,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC9D,KACE,IAAI,SAAS,GAAG,QAAyB,EACzC,SAAS,EACT,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,EAC5C,CAAC;QACD,IAAI,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAC;YACzD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,qCAAqC,CACjD,CAAC;QACJ,CAAC;IACH,CAAC;IACD,IAAI,CAAC;QACH,MAAM,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CACvD,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,EACnD;YACE,cAAc,EAAE,KAAK;YACrB,aAAa,EAAE,KAAK;SACrB,CACF,CAAC;QACF,MAAM,QAAQ,GAAG,gBAAgB,CAAC,KAAe,CAAC;QAClD,IAAI,8BAA8B,CAAC,QAAQ,CAAC,KAAK,gBAAgB,EAAE,CAAC;YAClE,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,iDAAiD,CAC7D,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE;YACxC,KAAK,EAAE,SAAS;YAChB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,mCAAmC,EAC9C,EAAE,KAAK,EAAE,CACV,CAAC;IACJ,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,2CAA2C,GAAG,CAClD,QAAiB,EACjB,QAAgB,EAChB,UAAU,IAAI,OAAO,EAAU,EACtB,EAAE;IACX,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,6BAA6B,CACzC,CAAC;IACJ,CAAC;IACD,IACE,OAAO,QAAQ,KAAK,UAAU;WAC3B,OAAO,QAAQ,KAAK,QAAQ,EAC/B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,wDAAwD,CACpE,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,iCAAiC,CAC7C,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,2CAA2C,CACvD,CAAC;IACJ,CAAC;IACD,IAAI,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,+BAA+B,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACpD,OAAO,mCAAmC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACjE,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,2DAA2D,CACvE,CAAC;IACJ,CAAC;IACD,IACE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;QACvB,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC,SAAS,EACnD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,iCAAiC,CAC7C,CAAC;IACJ,CAAC;IACD,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtE,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtB,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACrD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC;gBAC3D,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0CAA0C,CACtD,CAAC;YACJ,CAAC;YACD,QAAQ,CAAC,IAAI,CACX,2CAA2C,CACzC,QAAQ,CAAC,KAAK,CAAC,EACf,QAAQ,EACR,OAAO,CACR,CACF,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzB,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE;YACxC,KAAK,EAAE,SAAS;YAChB,UAAU,EAAE,KAAK;SAClB,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1D,IACE,yBAAyB,CAAC,GAAG,CAAC,MAAM,CAAC;eAClC,MAAM,KAAK,QAAQ;eACnB,MAAM,KAAK,WAAW;eACtB,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC;eACtB,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC;eACpB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EACxB,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,gCAAgC,MAAM,IAAI,CACtD,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE;YACtC,KAAK,EAAE,2CAA2C,CAChD,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;YACD,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;YACf,YAAY,EAAE,KAAK;SACpB,CAAC,CAAC;IACL,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACzB,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE;QACxC,KAAK,EAAE,SAAS;QAChB,UAAU,EAAE,KAAK;KAClB,CAAC,CAAC;IACH,OAAO,QAAQ,CAAC;AAClB,CAAC,CAAC;AAEF,MAAM,mCAAmC,GAAG,CAC1C,QAAiB,EACjB,QAAgB,EACP,EAAE;IACX,IACE,QAAQ,KAAK,SAAS;WACnB,OAAO,QAAQ,KAAK,UAAU;WAC9B,OAAO,QAAQ,KAAK,QAAQ,EAC/B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,wDAAwD,CACpE,CAAC;IACJ,CAAC;IACD,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC3C,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,8BAA8B,CAC1C,CAAC;IACJ,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5B,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC,SAAS,EAAE,CAAC;YACxD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,iCAAiC,CAC7C,CAAC;QACJ,CAAC;QACD,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACrD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC;gBAC3D,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0CAA0C,CACtD,CAAC;YACJ,CAAC;YACD,QAAQ,CAAC,IAAI,CACX,mCAAmC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAC/D,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QACtD,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,+BAA+B,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACpD,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,+BAA+B,CAC3C,CAAC;IACJ,CAAC;IACD,OAAO,mCAAmC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACjE,CAAC,CAAC;AAEF,MAAM,8BAA8B,GAAG,CACrC,QAAgB,EAChB,QAAgB,EACR,EAAE;IACV,IACE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;WACrC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,SAAS;WACpD,CAAC,kBAAkB,EACtB,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0CAA0C,CACtD,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,kBAAkB,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC/D,MAAM,KAAK,GAAG,iBAAiB;SAC5B,MAAM,CACL,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CACb,MAAM,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC,CAChD;SACA,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC;SACvB,IAAI,CAAC,EAAE,CAAC,CAAC;IACZ,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF,MAAM,8BAA8B,GAAG,CACrC,QAAiB,EACjB,QAAgB,EAChB,oBAAkD,EACzC,EAAE;IACX,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,6BAA6B,CACzC,CAAC;IACJ,CAAC;IACD,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAC3C,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,8BAA8B,CAC1C,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC9D,+BAA+B,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACpD,IAAI,oBAAoB,EAAE,CAAC;YACzB,0BAA0B,CACxB,QAAQ,EACR,QAAQ,EACR,oBAAoB,CACrB,CAAC;QACJ,CAAC;QACD,OAAO,mCAAmC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACjE,CAAC;IAED,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACpD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,8BAA8B,CAC1C,CAAC;IACJ,CAAC;IACD,MAAM,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IACvE,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0EAA0E,CACtF,CAAC;IACJ,CAAC;IACD,IAAI,eAAe,CAAC,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC;QAC9C,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,gDAAgD,CAC5D,CAAC;IACJ,CAAC;IAED,MAAM,UAAU,GAA4B,EAAE,CAAC;IAC/C,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,eAAe,EAAE,CAAC;QAClD,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,+BAA+B,QAAQ,IAAI,CACvD,CAAC;QACJ,CAAC;QACD,IAAI,+BAA+B,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClD,IACE,QAAQ,KAAK,KAAK;mBACf,OAAO,OAAO,KAAK,QAAQ;mBAC3B,OAAO,KAAK,IAAI;mBAChB,CAAC,mBAAmB,CAAC,OAAO,CAAC,EAChC,CAAC;gBACD,IAAI,oBAAoB,EAAE,CAAC;oBACzB,0BAA0B,CACxB,OAAO,EACP,GAAG,QAAQ,IAAI,QAAQ,EAAE,EACzB,oBAAoB,CACrB,CAAC;gBACJ,CAAC;gBACD,UAAU,CAAC,QAAQ,CAAC;oBAClB,2CAA2C,CACzC,OAAO,EACP,GAAG,QAAQ,IAAI,QAAQ,EAAE,CAC1B,CAAC;gBACJ,SAAS;YACX,CAAC;YACD,IAAI,oBAAoB,EAAE,CAAC;gBACzB,0BAA0B,CACxB,OAAO,EACP,GAAG,QAAQ,IAAI,QAAQ,EAAE,EACzB,oBAAoB,CACrB,CAAC;YACJ,CAAC;YACD,UAAU,CAAC,QAAQ,CAAC,GAAG,mCAAmC,CACxD,OAAO,EACP,GAAG,QAAQ,IAAI,QAAQ,EAAE,CAC1B,CAAC;YACF,SAAS;QACX,CAAC;QACD,IAAI,0BAA0B,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;mBACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;mBACvC,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,KAAK,CAAC,SAAS,EACrD,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,IAAI,QAAQ,uCAAuC,CAC/D,CAAC;YACJ,CAAC;YACD,wBAAwB,CACtB,OAAO,EACP,GAAG,QAAQ,IAAI,QAAQ,EAAE,EACzB,IAAI,CACL,CAAC;YACF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACzB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,IAAI,QAAQ,uCAAuC,CAC/D,CAAC;YACJ,CAAC;YACD,IAAI,oBAAoB,EAAE,CAAC;gBACzB,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;oBAC5B,0BAA0B,CACxB,KAAK,EACL,GAAG,QAAQ,IAAI,QAAQ,EAAE,EACzB,oBAAoB,CACrB,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,UAAU,CAAC,QAAQ,CAAC,GAAG,mCAAmC,CACxD,OAAO,EACP,GAAG,QAAQ,IAAI,QAAQ,EAAE,CAC1B,CAAC;YACF,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,IAAI,OAAO,OAAO,KAAK,SAAS,EAAE,CAAC;gBACjC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,6BAA6B,CACzC,CAAC;YACJ,CAAC;YACD,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;YAC/B,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;YACzB,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;gBACxC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,4DAA4D,CACxE,CAAC;YACJ,CAAC;YACD,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;YAC/B,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC1B,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtD,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;gBAC/B,SAAS;YACX,CAAC;YACD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;gBACpD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,+CAA+C,CAC3D,CAAC;YACJ,CAAC;YACD,UAAU,CAAC,QAAQ,CAAC,GAAG,8BAA8B,CACnD,OAAiB,EACjB,GAAG,QAAQ,IAAI,QAAQ,EAAE,CAC1B,CAAC;YACF,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,KAAK,UAAU,EAAE,CAAC;YAC5B,IACE,OAAO,OAAO,KAAK,QAAQ;gBAC3B,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC;gBAC1B,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,EACvB,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,8DAA8D,CAC1E,CAAC;YACJ,CAAC;YACD,UAAU,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC;YAC/B,SAAS;QACX,CAAC;QACD,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;YACxB,IACE,CACE,OAAO,OAAO,KAAK,QAAQ;mBACxB,OAAO,KAAK,IAAI;mBAChB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAC3C;;oBAED,CAAC,aAAa,CAAC,OAAO,CAAC;gBACvB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC;gBACjC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EACxD,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,iDAAiD,CAC7D,CAAC;YACJ,CAAC;YACD,wBAAwB,CAAC,OAAO,EAAE,GAAG,QAAQ,OAAO,EAAE,KAAK,CAAC,CAAC;YAC7D,UAAU,CAAC,QAAQ,CAAC,GAAG,8BAA8B,CACnD,OAAO,EACP,GAAG,QAAQ,OAAO,EAClB,oBAAoB,CACrB,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,mCAAmC,GAAG,CAAC,CAAC;AAC9C,MAAM,yCAAyC,GAAG,EAAE,CAAC;AACrD,MAAM,0CAA0C,GAAG,EAAE,CAAC;AAEtD,MAAM,2BAA2B,GAAG,CAClC,QAAiB,EACjB,cAA+B,EAC/B,QAAgB,EACP,EAAE;IACX,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;WACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;WACxC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,MAAM,CAAC,SAAS,EACvD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,qDAAqD,cAAc,GAAG,CAClF,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,cAAc,EAAE,CAAC;QACpD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,6BAA6B,cAAc,YAAY,CACnE,CAAC;IACJ,CAAC;IACD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC;IAC7E,IACE,CAAC,UAAU;WACR,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;WACxB,UAAU,CAAC,UAAU,KAAK,IAAI,EACjC,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,IAAI,cAAc,6CAA6C,CAC3E,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC,KAAK,CAAC;AAC1B,CAAC,CAAC;AAEF,MAAM,8BAA8B,GAAG,CACrC,QAAiB,EACjB,gBAAwB,EACxB,gBAAwB,EACxB,QAAgB,EACL,EAAE;IACb,IACE,OAAO,QAAQ,KAAK,QAAQ;WACzB,QAAQ,KAAK,IAAI;WACjB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;WACxC,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;WACxB,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC,SAAS,EACtD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,mCAAmC,CAC/C,CAAC;IACJ,CAAC;IACD,MAAM,gBAAgB,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC7E,MAAM,MAAM,GAAG,gBAAgB,IAAI,OAAO,IAAI,gBAAgB;QAC5D,CAAC,CAAC,gBAAgB,CAAC,KAAK;QACxB,CAAC,CAAC,SAAS,CAAC;IACd,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC;WAC1B,MAAM,GAAG,gBAAgB;WACzB,MAAM,GAAG,gBAAgB,EAC5B,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,yBAAyB,gBAAgB,QAAQ,gBAAgB,YAAY,CACzF,CAAC;IACJ,CAAC;IACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC1C,IAAI,OAAO,CAAC,MAAM,KAAK,MAAM,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjE,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,wDAAwD,CACpE,CAAC;IACJ,CAAC;IACD,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAC5C,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1B,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAClE,IACE,CAAC,UAAU;eACR,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;eACxB,UAAU,CAAC,UAAU,KAAK,IAAI,EACjC,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,mDAAmD,CAC/D,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAOF,MAAM,gCAAgC,GAAG,CACvC,aAAsB,EACtB,gBAA6B,EAC7B,eAA4B,EAC5B,kBAA+B,EAC/B,iBAAyB,EACC,EAAE;IAC5B,IAAI,gBAAgB,GAAG,CAAC,CAAC;IACzB,MAAM,gBAAgB,GAAG,CACvB,UAAmB,EACnB,QAAgB,EAC2B,EAAE;QAC7C,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;YACnC,gBAAgB,EAAE,CAAC;YACnB,IACE,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC;mBACzB,gBAAgB,GAAG,0CAA0C,EAChE,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,4DAA4D,0CAA0C,iBAAiB,CAC5I,CAAC;YACJ,CAAC;YACD,OAAO;gBACL,eAAe,EAAE,UAAU;gBAC3B,gBAAgB,EAAE,IAAI,GAAG,EAAE;aAC5B,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;YACnC,gBAAgB,EAAE,CAAC;YACnB,IAAI,gBAAgB,GAAG,0CAA0C,EAAE,CAAC;gBAClE,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,yBAAyB,0CAA0C,iBAAiB,CACzG,CAAC;YACJ,CAAC;YACD,IACE,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC;mBACxB,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC;mBAC3B,UAAU,CAAC,MAAM,GAAG,CAAC,EACxB,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,yDAAyD,CAC9E,CAAC;YACJ,CAAC;YACD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,WAAW,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,iBAAiB,KAAK,gBAAgB,CAC3D,CAAC;YACJ,CAAC;YACD,MAAM,IAAI,GAAG,mBAAmB,CAC9B,KAAK,EACL,gBAAgB,EAChB,GAAG,iBAAiB,QAAQ,CAC7B,CAAC;YACF,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,sDAAsD,CAC3E,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC/B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,iBAAiB,IAAI,4BAA4B,CACtE,CAAC;YACJ,CAAC;YACD,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,GAAG,iBAAiB,6CAA6C,IAAI,IAAI,CAC1E,CAAC;YACJ,CAAC;YACD,OAAO;gBACL,eAAe,EAAE,IAAI,IAAI,EAAE;gBAC3B,gBAAgB,EAAE,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC;aAClC,CAAC;QACJ,CAAC;QACD,IAAI,QAAQ,IAAI,mCAAmC,EAAE,CAAC;YACpD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,4CAA4C,mCAAmC,GAAG,CACvG,CAAC;QACJ,CAAC;QACD,MAAM,WAAW,GAAG,8BAA8B,CAChD,2BAA2B,CACzB,UAAU,EACV,MAAM,EACN,GAAG,iBAAiB,gBAAgB,CACrC,EACD,CAAC,EACD,yCAAyC,EACzC,GAAG,iBAAiB,aAAa,CAClC,CAAC;QACF,MAAM,kBAAkB,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CACtD,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,CAAC,CAAC,CACzC,CAAC;QACF,OAAO;YACL,eAAe,EAAE;gBACf,IAAI,EAAE,kBAAkB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,eAAe,CAAC;aACrE;YACD,gBAAgB,EAAE,IAAI,GAAG,CACvB,kBAAkB,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC;gBACvC,GAAG,QAAQ,CAAC,gBAAgB;aAC7B,CAAC,CACH;SACF,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,WAAW,GAAG,8BAA8B,CAChD,2BAA2B,CACzB,aAAa,EACb,MAAM,EACN,GAAG,iBAAiB,QAAQ,CAC7B,EACD,CAAC,EACD,CAAC,EACD,GAAG,iBAAiB,aAAa,CAClC,CAAC;IACF,MAAM,IAAI,GAAG,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACjD,MAAM,KAAK,GAAG,gBAAgB,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAClD,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;QAC/B,GAAG,IAAI,CAAC,gBAAgB;QACxB,GAAG,KAAK,CAAC,gBAAgB;KAC1B,CAAC,CAAC;IACH,MAAM,WAAW,GAAG,CAAC,GAAG,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC3D,KAAK,EAAE;YACL,EAAE,SAAS,EAAE,IAAI,QAAQ,EAAE,EAAE;YAC7B;gBACE,GAAG,EAAE;oBACH,EAAE,SAAS,EAAE,CAAC,IAAI,QAAQ,EAAE,EAAE,IAAI,QAAQ,EAAE,CAAC,EAAE;oBAC/C,CAAC;iBACF;aACF;YACD,KAAK;SACN;KACF,CAAC,CAAC,CAAC;IACJ,MAAM,iBAAiB,GAAG;QACxB,IAAI,EAAE;YACJ,IAAI,EAAE;gBACJ,uBAAuB,EAAE,IAAI,CAAC,eAAe;gBAC7C,wBAAwB,EAAE,KAAK,CAAC,eAAe;aAChD;YACD,EAAE,EAAE;gBACF,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE;4BACJ,EAAE,SAAS,EAAE,2BAA2B,EAAE;4BAC1C,EAAE,SAAS,EAAE,4BAA4B,EAAE;4BAC3C;gCACE,GAAG,EAAE;oCACH;wCACE,SAAS,EAAE;4CACT,2BAA2B;4CAC3B,2BAA2B;yCAC5B;qCACF;oCACD,CAAC;iCACF;6BACF;4BACD;gCACE,GAAG,EAAE;oCACH;wCACE,SAAS,EAAE;4CACT,4BAA4B;4CAC5B,4BAA4B;yCAC7B;qCACF;oCACD,CAAC;iCACF;6BACF;yBACF;qBACF;oBACD;wBACE,IAAI,EAAE;4BACJ,2BAA2B;4BAC3B,4BAA4B;yBAC7B;qBACF;oBACD,KAAK;iBACN;aACF;SACF;KACF,CAAC;IACF,OAAO,WAAW,CAAC,MAAM,GAAG,CAAC;QAC3B,CAAC,CAAC;YACE,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,WAAW,EAAE;gBACrB,iBAAiB;gBACjB,KAAK;aACN;SACF;QACH,CAAC,CAAC,iBAAiB,CAAC;AACxB,CAAC,CAAC;AAEF,MAAM,qBAAqB,GAAG,CAC5B,SAAkC,EAClC,gBAA6B,EAC7B,sBAAmC,EACnC,qBAAuE,EACvE,eAA4B,EAC5B,kBAA+B,EAC/B,iBAKwB,EACxB,8BAAmE,EACjB,EAAE;IACpD,IACE,OAAO,SAAS,KAAK,QAAQ;QAC7B,SAAS,KAAK,IAAI;QAClB,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;QACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;QACzC,CAAC,aAAa,CAAC,SAAS,CAAC;QACzB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,KAAK,CAAC,EACnC,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,sCAAsC,CAC3D,CAAC;IACJ,CAAC;IACD,wBAAwB,CACtB,SAAS,EACT,GAAG,iBAAiB,SAAS,EAC7B,KAAK,CACN,CAAC;IACF,MAAM,8BAA8B,GAGsB,CACxD,QAAQ,EACR,QAAQ,EACR,EAAE;QACF,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;eACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;eACxC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,KAAK,CAAC,SAAS;eACnD,QAAQ,CAAC,MAAM,KAAK,CAAC,EACxB,CAAC;YACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,iDAAiD,CAC7D,CAAC;QACJ,CAAC;QACD,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;QACnD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACrD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC;gBAC3D,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0CAA0C,CACtD,CAAC;YACJ,CAAC;YACD,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC9B,IACE,OAAO,KAAK,KAAK,QAAQ;mBACtB,KAAK,KAAK,IAAI;mBACd,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;mBACpB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;mBACrC,CAAC,aAAa,CAAC,KAAK,CAAC,EACxB,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,wCAAwC,CACpD,CAAC;YACJ,CAAC;YACD,wBAAwB,CAAC,KAAK,EAAE,GAAG,QAAQ,QAAQ,EAAE,KAAK,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC,CAAC;IACF,MAAM,yBAAyB,GAAG,CAAC,QAAiB,EAAW,EAAE;QAC/D,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC5B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;YACtD,OAAO,CACL,QAAQ,KAAK,SAAS;mBACnB,OAAO,QAAQ,KAAK,UAAU;mBAC9B,OAAO,QAAQ,KAAK,QAAQ,CAChC,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,wCAAwC,CAC7D,CAAC;QACJ,CAAC;QACD,IAAI,mBAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,wBAAwB,CACtB,QAAQ,EACR,GAAG,iBAAiB,mBAAmB,EACvC,KAAK,CACN,CAAC;QACF,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACzC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;YACpD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACpD,OAAO,CACL,OAAO,KAAK,SAAS;mBAClB,OAAO,OAAO,KAAK,UAAU;mBAC7B,OAAO,OAAO,KAAK,QAAQ,CAC/B,CAAC;QACJ,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YAC5C,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,wCAAwC,CAC7D,CAAC;QACJ,CAAC;QACD,OAAO,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACtC,CAAC,CAAC;IACF,MAAM,uBAAuB,GAAG,CAC9B,eAAwC,EAC/B,EAAE;QACX,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;YAC3D,IAAI,GAAG,KAAK,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3C,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;gBAC9C,IACE,KAAK,CAAC,IAAI,CACR,CAAC,QAAQ,EAAE,EAAE,CACX,aAAa,CAAC,QAAQ,CAAC;oBACvB,uBAAuB,CAAC,QAAQ,CAAC,CACpC,EACD,CAAC;oBACD,OAAO,IAAI,CAAC;gBACd,CAAC;gBACD,SAAS;YACX,CAAC;YACD,IAAI,GAAG,KAAK,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC1C,8BAA8B,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBAC7C,IACE,KAAK,CAAC,MAAM,GAAG,CAAC;oBAChB,KAAK,CAAC,KAAK,CACT,CAAC,QAAQ,EAAE,EAAE,CACX,aAAa,CAAC,QAAQ,CAAC;wBACvB,uBAAuB,CAAC,QAAQ,CAAC,CACpC,EACD,CAAC;oBACD,OAAO,IAAI,CAAC;gBACd,CAAC;gBACD,SAAS;YACX,CAAC;YACD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,yBAAyB,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC7D,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,0DAA0D,CAC/E,CAAC;IACJ,CAAC;IACD,MAAM,2BAA2B,GAAG,CAClC,eAAwC,EACxC,eAA4B,EACtB,EAAE;QACR,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;YAC3D,IAAI,GAAG,KAAK,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3C,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;gBAC9C,KAAK,MAAM,QAAQ,IAAI,KAAK,EAAE,CAAC;oBAC7B,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;wBAC5B,2BAA2B,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;oBACzD,CAAC;gBACH,CAAC;gBACD,SAAS;YACX,CAAC;YACD,qEAAqE;YACrE,2DAA2D;YAC3D,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,yBAAyB,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC7D,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;IACH,CAAC,CAAC;IACF,IAAI,8BAA8B,EAAE,CAAC;QACnC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;QACvC,2BAA2B,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QACrD,MAAM,4BAA4B,GAAG,8BAA8B,CAAC,IAAI,CACtE,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,IAAI,GAAG,CAAC;YAClB,CAAC,GAAG,SAAS,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAC7D,CAAC;QACF,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAClC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,4GAA4G,CACjI,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,qBAAqB,GAAG,CAC5B,eAAwC,EACxC,OAAO,GAAG,KAAK,EACU,EAAE;QAC3B,wBAAwB,CACtB,eAAe,EACf,GAAG,iBAAiB,SAAS,EAC7B,KAAK,CACN,CAAC;QACF,MAAM,UAAU,GAA4B,EAAE,CAAC;QAC/C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;YAC3D,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;gBACtD,8BAA8B,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBAC3C,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;oBACpC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBACpC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,GAAG,4CAA4C,CACnD,CAAC;oBACJ,CAAC;oBACD,OAAO,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;gBAC7C,CAAC,CAAC,CAAC;gBACH,SAAS;YACX,CAAC;YACD,IAAI,GAAG,KAAK,OAAO,EAAE,CAAC;gBACpB,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,gDAAgD,CACrE,CAAC;gBACJ,CAAC;gBACD,UAAU,CAAC,GAAG,CAAC,GAAG,gCAAgC,CAChD,KAAK,EACL,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,iBAAiB,CAClB,CAAC;gBACF,SAAS;YACX,CAAC;YACD,MAAM,IAAI,GAAG,mBAAmB,CAC9B,GAAG,EACH,gBAAgB,EAChB,GAAG,iBAAiB,SAAS,EAC7B,sBAAsB,CACvB,CAAC;YACF,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,GAAG,iBAAiB,4CAA4C,GAAG,IAAI,CACxE,CAAC;YACJ,CAAC;YACD,IAAI,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;gBACpD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,iBAAiB,sEAAsE,IAAI,IAAI,CACnG,CAAC;YACJ,CAAC;YACD,UAAU,CAAC,GAAG,CAAC,GAAG,8BAA8B,CAC9C,KAAK,EACL,GAAG,iBAAiB,iBAAiB,GAAG,GAAG,EAC3C,qBAAqB,CAAC,GAAG,CAAC,IAAI,CAAC,CAChC,CAAC;QACJ,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;IACF,OAAO,qBAAqB,CAC1B,SAAS,EACT,IAAI,CAC+C,CAAC;AACxD,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CAAC,OAAe,EAAE,QAAgB,EAAW,EAAE,CACnE,OAAO,KAAK,QAAQ;IACpB,OAAO,CAAC,UAAU,CAAC,GAAG,QAAQ,GAAG,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC;AAErC,MAAM,qBAAqB,GAAG,CAC5B,SAAoC,EACpC,gBAA6B,EAC7B,sBAAmC,EACnC,cAA2B,EAC3B,kBAA+B,EACyB,EAAE;IAC1D,IACE,OAAO,SAAS,KAAK,QAAQ;QAC7B,SAAS,KAAK,IAAI;QAClB,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EACxB,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,yCAAyC,CAC1C,CAAC;IACJ,CAAC;IACD,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;QAC/B,MAAM;QACN,QAAQ;QACR,MAAM;QACN,cAAc;QACd,OAAO;QACP,WAAW;QACX,OAAO;KACR,CAAC,CAAC;IACH,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC;IAChE,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9C,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,2BAA2B,QAAQ,qBAAqB,CACzD,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,UAAU,GAA4C,EAAE,CAAC;IAC/D,MAAM,aAAa,GAA8C,EAAE,CAAC;IACpE,KAAK,MAAM,QAAQ,IAAI,gBAAgB,EAAE,CAAC;QACxC,MAAM,SAAS,GAAI,SAAqC,CAAC,QAAQ,CAAC,CAAC;QACnE,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,SAAS;QACX,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,0BAA0B,CACtC,CAAC;QACJ,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,SAAS;QACX,CAAC;QACD,MAAM,mBAAmB,GAA4B,EAAE,CAAC;QACxD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,OAAO,EAAE,CAAC;YACpC,MAAM,IAAI,GAAG,mBAAmB,CAC9B,IAAI,EACJ,gBAAgB,EAChB,QAAQ,EACR,sBAAsB,CACvB,CAAC;YACF,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,GAAG,QAAQ,oCAAoC,IAAI,IAAI,CACxD,CAAC;YACJ,CAAC;YACD,IAAI,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,2CAA2C,IAAI,IAAI,CAC/D,CAAC;YACJ,CAAC;YACD,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,EAAE,CACnD,aAAa,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC,CACvC,CAAC;YACF,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,UAAU,IAAI,oBAAoB,QAAQ,CAAC,QAAQ,UAAU,QAAQ,CAAC,IAAI,IAAI,CAC1F,CAAC;YACJ,CAAC;YACD,aAAa,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;YACvC,IAAI,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACjC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;oBAClB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,sDAAsD,IAAI,qBAAqB,CAC3F,CAAC;gBACJ,CAAC;gBACD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACxB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,UAAU,IAAI,yBAAyB,CACnD,CAAC;gBACJ,CAAC;gBACD,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;oBACzB,IACE,KAAK,KAAK,IAAI;2BACX,OAAO,KAAK,KAAK,QAAQ;2BACzB,OAAO,KAAK,KAAK,SAAS;2BAC1B,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EACxD,CAAC;wBACD,mBAAmB,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;wBAClC,SAAS;oBACX,CAAC;oBACD,IACE,OAAO,KAAK,KAAK,QAAQ;2BACtB,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;2BACpB,aAAa,CAAC,KAAK,CAAC;2BACpB,KAAK,YAAY,MAAM,EAC1B,CAAC;wBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,eAAe,IAAI,uCAAuC,CAC3D,CAAC;oBACJ,CAAC;oBACD,gEAAgE;oBAChE,gEAAgE;oBAChE,2CAA2C;oBAC3C,mBAAmB,CAAC,IAAI,CAAC,GAAG,mCAAmC,CAC7D,KAAK,EACL,eAAe,IAAI,GAAG,CACvB,CAAC;oBACF,SAAS;gBACX,CAAC;gBACD,IACE,OAAO,KAAK,KAAK,QAAQ;uBACtB,KAAK,KAAK,IAAI;uBACd,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;uBACrB,CAAC,aAAa,CAAC,KAAK,CAAC,EACxB,CAAC;oBACD,gEAAgE;oBAChE,mEAAmE;oBACnE,mDAAmD;oBACnD,mBAAmB,CAAC,IAAI,CAAC,GAAG,mCAAmC,CAC7D,KAAK,EACL,GAAG,QAAQ,UAAU,IAAI,GAAG,CAC7B,CAAC;oBACF,SAAS;gBACX,CAAC;gBACD,wBAAwB,CAAC,KAAK,EAAE,GAAG,QAAQ,UAAU,IAAI,GAAG,CAAC,CAAC;gBAC9D,mBAAmB,CAAC,IAAI,CAAC,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;gBACxD,SAAS;YACX,CAAC;YACD,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC1B,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;oBAClD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,gBAAgB,IAAI,4BAA4B,CACjD,CAAC;gBACJ,CAAC;gBACD,mBAAmB,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC/B,SAAS;YACX,CAAC;YACD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,UAAU,IAAI,yBAAyB,CACnD,CAAC;YACJ,CAAC;YACD,IACE,QAAQ,KAAK,MAAM;gBACnB,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EACtD,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,cAAc,IAAI,4BAA4B,CAC/C,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,KAAK,MAAM,EAAE,CAAC;gBACxB,wBAAwB,CAAC,KAAK,EAAE,GAAG,QAAQ,UAAU,IAAI,GAAG,CAAC,CAAC;YAChE,CAAC;YACD,mBAAmB,CAAC,IAAI,CAAC;gBACvB,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAC9D,CAAC;QACD,UAAU,CAAC,QAAQ,CAAC,GAAG,mBAAmB,CAAC;IAC7C,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,8DAA8D,CAC/D,CAAC;IACJ,CAAC;IACD,OAAO,UAAoE,CAAC;AAC9E,CAAC,CAAC;AAEF,MAAM,mBAAmB,GAAG,CAC1B,aAAkD,EAClD,gBAA6B,EAC7B,sBAAoC,EACE,EAAE;IACxC,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7E,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,8CAA8C,CAC/C,CAAC;IACJ,CAAC;IACD,IAAI,aAAgC,CAAC;IACrC,MAAM,UAAU,GAA0B,EAAE,CAAC;IAC7C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,CAAC;QAC1D,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACnB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,EAAE,YAAY,EAAE,sBAAsB,CAAC,CAAC;YAClF,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;gBAChC,aAAa,GAAG,KAAc,CAAC;YACjC,CAAC;iBAAM,IAAI,aAAa,KAAK,KAAK,EAAE,CAAC;gBACnC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,qEAAqE,CACtE,CAAC;YACJ,CAAC;QACH,CAAC;QACD,IAAI,KAAK,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,oBAAoB,IAAI,oBAAoB,CAC7C,CAAC;QACJ,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;IAC3B,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,CACpB,OAAsC,EACtC,gBAA6B,EAC7B,sBAAoC,EACF,EAAE;IACpC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjE,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,0CAA0C,CAC3C,CAAC;IACJ,CAAC;IACD,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,KAAK,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACxD,IAAI,IAAI,KAAK,KAAK,EAAE,CAAC;YACnB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,sBAAsB,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,SAAS,KAAK,CAAC,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,cAAc,IAAI,qBAAqB,CACxC,CAAC;QACJ,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAC/B,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CACzB,OAA2B,EAC3B,QAAqE,EACjD,EAAE;IACtB,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,IACE,OAAO,OAAO,KAAK,QAAQ;QAC3B,CAAC,qCAAqC,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAI,CAC3D,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,OAAO,CACxC,EACD,CAAC;QACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,kFAAkF,CACnF,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,SAAiC,EAAE,EAAE;IAC3E,6DAA6D;IAC7D,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACzE,CAAC;IAED,uCAAuC;IACvC,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzD,MAAM,eAAe,GAA2B,EAAE,CAAC;IAEnD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QACzC,IAAI,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;gBACnB,eAAe,CAAC,GAAG,CAAC,GAAG,uBAAuB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;YACjE,CAAC;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBACzC,eAAe,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,SAAc,EAAE,EAAE,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC,CAAC;YACpG,CAAC;QACH,CAAC;IACH,CAAC;IAED,yCAAyC;IACzC,MAAM,uBAAuB,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACpG,IAAI,uBAAuB,EAAE,CAAC;QAC5B,OAAO,eAAe,CAAC;IACzB,CAAC;IAED,0DAA0D;IAC1D,MAAM,eAAe,GAA2B,EAAE,CAAC;IAEnD,mCAAmC;IACnC,MAAM,kBAAkB,GAAG,CAAC,IAAY,EAAE,KAAU,EAAE,EAAE;QACtD,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,eAAe,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAChC,CAAC;aAAM,IACL,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;YACxD,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAClD,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EACvG,CAAC;YACD,kCAAkC;YAClC,eAAe,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE,GAAG,KAAK,EAAE,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,uBAAuB;YACvB,eAAe,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QAChC,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,kBAAkB,GAAG,CAAC,QAAiB,EAAW,EAAE;QACxD,IAAI,QAAQ,YAAY,IAAI,IAAI,QAAQ,YAAY,MAAM,EAAE,CAAC;YAC3D,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,CACL,OAAO,QAAQ,KAAK,QAAQ;YAC5B,QAAQ,KAAK,IAAI;YACjB,OAAQ,QAAoC,CAAC,SAAS,KAAK,QAAQ,CACpE,CAAC;IACJ,CAAC,CAAC;IAEF,MAAM,qBAAqB,GAAG,CAAC,WAAmB,EAAE,UAAe,EAAE,EAAE;QACrE,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;YAC9B,2FAA2F;YAC3F,kBAAkB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;YAC5C,OAAO;QACT,CAAC;aAAM,IAAI,kBAAkB,CAAC,UAAU,CAAC,EAAE,CAAC;YAC1C,yEAAyE;YACzE,4EAA4E;YAC5E,kBAAkB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;YAC5C,OAAO;QACT,CAAC;aAAM,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;YACjE,oDAAoD;YACpD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACrC,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;YAE3D,IAAI,YAAY,EAAE,CAAC;gBACjB,yCAAyC;gBACzC,8CAA8C;gBAC9C,MAAM,gBAAgB,GAAG;oBACvB,uBAAuB;oBACvB,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;oBAC1C,kBAAkB;oBAClB,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO;oBAC5C,oBAAoB;oBACpB,SAAS,EAAE,OAAO;oBAClB,wCAAwC;oBACxC,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM;oBACrC,6BAA6B;oBAC7B,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;iBAC9B,CAAC;gBAEF,gCAAgC;gBAChC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC5B,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;gBACzE,CAAC;gBAED,iDAAiD;gBACjD,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CACzC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,CACvD,CAAC;gBAEF,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAChC,OAAO,CAAC,IAAI,CAAC,gDAAgD,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAC9F,CAAC;gBAED,yDAAyD;gBACzD,IAAI,UAAU,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;oBACrD,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;gBAC1D,CAAC;gBACD,IAAI,UAAU,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;oBACvD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;gBAC3D,CAAC;gBACD,IAAI,UAAU,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;oBACvD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;gBAC3D,CAAC;gBACD,IAAI,UAAU,CAAC,KAAK,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAC7D,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;gBAC7D,CAAC;gBAED,6CAA6C;gBAC7C,kBAAkB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;gBAC5C,OAAO;YACT,CAAC;YAED,uCAAuC;YACvC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;oBACtB,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC;YAED,qCAAqC;YACrC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,qBAAqB,CAAC,GAAG,WAAW,IAAI,GAAG,EAAE,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,mBAAmB;YACnB,kBAAkB,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC,CAAC;IAEF,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QACzC,sDAAsD;QACtD,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACpC,qBAAqB,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,uCAAuC;IACvC,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAEhD,OAAO,eAAe,CAAC;AACzB,CAAC,CAAC;IAEW,cAAc;;;;;;;iBAAd,cAAc;;;sCAyqDxB,UAAU,EAAE;sCAMZ,UAAU,EAAE;YALb,gLAAA,UAAU,6BAAV,UAAU,+FAAoC;YAM9C,gLAAA,UAAU,6BAAV,UAAU,+FAAoC;;;QA/qD9C;;WAEG;QACI,MAAM,CAAC,UAAU,CAA2B;QAC5C,MAAM,KAAK,KAAK;YACrB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QAEM,MAAM,CAAC,cAAc,CAAC;QACtB,MAAM,CAAC,OAAO,CAAC;QAGtB;;WAEG;QACK,iBAAiB;YACvB,OAAO,IAAI,CAAC,UAAU,IAAK,IAAI,CAAC,WAAmB,CAAC,UAAU,CAAC;QACjE,CAAC;QAED,SAAS;QACT,2FAA2F;QACpF,MAAM,CAAC,KAAK,CAAC,qBAAqB,CACvC,KAAkB,EAClB,SAAkB,EAClB,UAA6C;YAE7C,OAAO,qBAAqB,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACnE,CAAC;QAED,+EAA+E;QACxE,MAAM,CAAC,KAAK,CAAC,sBAAsB,CACxC,KAAkB,EAClB,UAA8C;YAE9C,OAAO,sBAAsB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QACzD,CAAC;QAED,0FAA0F;QACnF,MAAM,CAAC,KAAK,CAAC,6BAA6B,CAC/C,KAAkB,EAClB,aAAgD,EAAE;YAElD,OAAO,6BAA6B,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QAChE,CAAC;QAEM,MAAM,CAAC,kCAAkC,CAE9C,mBAAwB;YAExB,MAAM,MAAM,GAAG,4BAA4B,CAAC,IAAI,CAAC,CAAC;YAClD,IAAI,MAAM,EAAE,CAAC;gBACX,mBAAmB,GAAG,8BAA8B,CAClD,mBAAmB,EAAE,MAAM,EAC3B,CAAC,GAAI,IAAY,CAAC,yBAAyB,EAAE,CAAC,CAC/C,CAAC;YACJ,CAAC;YACD,MAAM,WAAW,GAAG,IAAI,IAAI,EAA6B,CAAC;YAC1D,IAAI,MAAM,EAAE,CAAC;gBACX,KAAK,MAAM,KAAK,IAAK,IAAY,CAAC,yBAAyB,EAAiB,EAAE,CAAC;oBAC7E,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;wBACtE,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;oBAC5B,CAAC;gBACH,CAAC;YACH,CAAC;YACD,IAAI,MAAM,EAAE,UAAU,KAAK,MAAM,EAAE,CAAC;gBAClC,OAAO,WAAW,CAAC,YAAY,CAAC,CAAC;gBACjC,OAAO,WAAW,CAAC,YAAY,CAAC,CAAC;YACnC,CAAC;YACA,WAAmB,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC;gBACnD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,GAAG,CAAC,CAAC;gBAC1C,MAAM,UAAU,GAAI,IAAY,CAAC,YAAY,IAAI,EAAE,CAAC;gBACpD,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;gBAC5B,WAAmB,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,UAAU;oBACxE,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;oBAC5B,CAAC,CAAC,QAAQ,CAAC;YACf,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC;QAEO,MAAM,CAAC,yBAAyB;YACtC,MAAM,SAAS,GAAG,IAAI,CAAC,SAGtB,CAAC;YACF,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC;gBACpB,GAAG,CAAC,SAAS,CAAC,wBAAwB,IAAI,EAAE,CAAC;gBAC7C,GAAG,CAAC,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;aACxC,CAAC,CAAC;YACH,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC5D,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACjB,gBAAgB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAC9B,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;QAEO,MAAM,CAAC,sBAAsB;YACnC,MAAM,SAAS,GAAG,IAAI,CAAC,SAEtB,CAAC;YACF,OAAO,IAAI,GAAG,CAAC;gBACb,GAAG,CAAC,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC;gBAClC,GAAG,CAAC,4BAA4B,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;aAC5E,CAAC,CAAC;QACL,CAAC;QAEO,MAAM,CAAC,6BAA6B;YAI1C,MAAM,SAAS,GAAG,IAAI,CAAC,SAGtB,CAAC;YACF,OAAO,IAAI,GAAG,CACZ,CAAC,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,gBAAgB,EAAE,EAAE,CAAC;gBACnF,gBAAgB;gBAChB,SAAS,CAAC,kBAAkB,EAAE,CAAC,gBAAgB,CAAC,IAAI,QAAQ;aAC7D,CAAC,CACH,CAAC;QACJ,CAAC;QAEO,MAAM,CAAC,uBAAuB;YACpC,MAAM,UAAU,GAA8B,IAAY,CAAC,UAAU,CAAC;YACtE,OAAO,IAAI,GAAG,CAAC,UAAU,CAAC,mBAAmB,EAAE,EAAE,aAAa,IAAI,EAAE,CAAC,CAAC;QACxE,CAAC;QAED;;;;;;;WAOG;QACK,MAAM,CAAC,8BAA8B;YAG3C,MAAM,OAAO,GAA+B,EAAE,CAAC;YAC/C,KAAK,MAAM,aAAa,IAAK,IAAY,CAAC,sBAAsB,EAAiB,EAAE,CAAC;gBAClF,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YACzC,CAAC;YACD,MAAM,UAAU,GAA8B,IAAY,CAAC,UAAU,CAAC;YACtE,MAAM,WAAW,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;YACrD,IAAI,WAAW,EAAE,CAAC;gBAChB,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;oBACxC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;wBAClC,SAAS;oBACX,CAAC;oBACD,MAAM,qBAAqB,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,CAC5D,CAAC,YAAY,EAAE,EAAE,CACf,YAAY,KAAK,QAAQ,IAAI,YAAY,KAAK,YAAY,CAC7D,CAAC;oBACF,IAAI,CAAC,qBAAqB,EAAE,CAAC;wBAC3B,SAAS;oBACX,CAAC;oBACD,IACE,KAAK,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC;wBACtB,KAAK,CAAC,GAAG,CAAC,IAAI,CACZ,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,CAAC,YAAY,KAAK,CAAC,IAAI,YAAY,KAAK,CAAC,CAAC,CAChE,EACD,CAAC;wBACD,SAAS;oBACX,CAAC;oBACD,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QAEO,MAAM,CAAC,sBAAsB;YACnC,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,WAAW,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAC1E,MAAM,OAAO,GAAI,IAAY,CAAC,YAEjB,CAAC;YACd,MAAM,WAAW,GAAG,IAAI,GAAG,EAAU,CAAC;YACtC,KAAK,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE,CAAC;gBACjE,IAAI,YAAY,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;oBAC3C,SAAS;gBACX,CAAC;gBACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,CAAC;oBAC7C,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,qCAAqC,IAAI,qBAAqB,CAC/D,CAAC;gBACJ,CAAC;gBACD,IACE,OAAO,YAAY,CAAC,SAAS,KAAK,UAAU;uBACzC,OAAO,YAAY,CAAC,WAAW,KAAK,UAAU,EACjD,CAAC;oBACD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,+BAA+B,IAAI,wCAAwC,CAC5E,CAAC;gBACJ,CAAC;gBACD,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC1B,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,2BAA2B,IAAI,wCAAwC,CACxE,CAAC;gBACJ,CAAC;gBACD,KAAK,MAAM,YAAY,IAAI,YAAY,CAAC,WAAW,EAAE,CAAC;oBACpD,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;wBAClE,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,qCAAqC,IAAI,8BAA8B,CACxE,CAAC;oBACJ,CAAC;oBACD,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,YAAY,EAAE,CAAC;oBAC3C,IAAI,CAAC;wBACH,mBAAmB,CACjB,QAAQ,EACR,aAAa,EACb,yBAAyB,EACzB,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CACpB,CAAC;oBACJ,CAAC;oBAAC,OAAO,QAAQ,EAAE,CAAC;wBAClB,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,4BAA4B,QAAQ,eAAe,EACnD,EAAE,KAAK,EAAE,QAAQ,EAAE,CACpB,CAAC;oBACJ,CAAC;oBACD,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC;QAEO,MAAM,CAAC,2BAA2B;YACxC,MAAM,OAAO,GAAI,IAAY,CAAC,YAQjB,CAAC;YACd,OAAO,IAAI,GAAG,CACZ,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;iBAC1B,MAAM,CACL,CAAC,CAAC,EAAE,YAAY,CAAC,EAAE,EAAE,CACnB,OAAO,YAAY,CAAC,SAAS,KAAK,UAAU;gBAC5C,OAAO,YAAY,CAAC,WAAW,KAAK,UAAU,CACjD;iBACA,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAC3B,CAAC;QACJ,CAAC;QAEO,MAAM,CAAC,qBAAqB;YAClC,OAAO,IAAI,GAAG,CAAC;gBACb,GAAI,IAAY,CAAC,sBAAsB,EAAiB;gBACxD,GAAG,qCAAqC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,OAAO,CAC5D,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CACzD;aACF,CAAC,CAAC;QACL,CAAC;QAEO,MAAM,CAAC,wBAAwB,CAAC,aAAuB,EAAE,WAAqB;YACpF,IAAI,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,KAAK,SAAS,IAAI,WAAW,KAAK,SAAS,CAAC,EAAE,CAAC;gBACrG,MAAM,IAAI,yBAAyB,CAAC,uBAAuB,EACzD,yFAAyF,CAAC,CAAC;YAC/F,CAAC;QACH,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,KAAK,CAAC,IAAI;YACtB,MAAM,UAAU,GAA8B,IAAY,CAAC,UAAU,CAAC;YACtE,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;QAC1B,CAAC;QAEM,MAAM,CAAC,KAAK,CAAC,iBAAiB;YACnC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACpB,CAAC;QAED,iFAAiF;QAC1E,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAA4C;YAChF,oCAAoC,CAAC,IAAI,CAAC,CAAC;YAC3C,MAAM,UAAU,GAA8B,IAAY,CAAC,UAAU,CAAC;YACtE,MAAM,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;QAED;;WAEG;QACI,MAAM,CAAC,KAAK,CAAC,YAAY;YAC9B,MAAM,UAAU,GAA8B,IAAY,CAAC,UAAU,CAAC;YACtE,OAAO,UAAU,CAAC,YAAY,EAAE,CAAC;QACnC,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,6BAA6B;YACzC,OAAO,qCAAqC,CAAC,IAAW,CAAC,CAAC;QAC5D,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,KAAK,CAAC,yBAAyB,CAC3C,KAAkB;YAElB,OAAO,iCAAiC,CAAC,IAAW,EAAE,KAAK,CAAC,CAAC;QAC/D,CAAC;QAED;;WAEG;QACI,MAAM,CAAC,KAAK,CAAC,MAAM,CAExB,WAAc,EACd,IAA8C;YAE9C,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,8DAA8D,CAC/D,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,CAAC,WAAW,YAAY,IAAI,CAAC,EAAE,CAAC;gBACnC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,yCAAyC,IAAI,CAAC,IAAI,IAAI,CACvD,CAAC;YACJ,CAAC;YACD,IAAI,WAAW,CAAC,cAAc,KAAK,KAAK,EAAE,CAAC;gBACzC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,qDAAqD,CACtD,CAAC;YACJ,CAAC;YACD,0BAA0B,CACxB,WAAiD,EAChD,IAAI,CAAC,SAA0C,CAAC,aAAa,IAAI,EAAE,EACnE,IAAI,CAAC,SAEJ,CAAC,kBAAkB,CACtB,CAAC;YACF,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACrC,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,UAAU,KAAK,MAAM,EAAE,CAAC;gBAC9D,WAAW,CAAC,UAAU,GAAG,GAAG,CAAC;gBAC7B,WAAW,CAAC,UAAU,GAAG,GAAG,CAAC;YAC/B,CAAC;YACD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,WAAkB,EAAE,IAAI,CAAC,CAAC;YACjE,IAAI,CAAC,8BAA8B,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;gBACnD,WAAW,CAAC,cAAc,GAAG,IAAI,CAAC;YACpC,CAAC;YACD,OAAO,MAAqF,CAAC;QAC/F,CAAC;QAED;;;;;;;WAOG;QACI,MAAM,CAAC,KAAK,CAAC,UAAU,CAE5B,YAAiB,EACjB,IAAiE;YAEjE,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,kEAAkE,CACnE,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC9D,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,2DAA2D,CAC5D,CAAC;YACJ,CAAC;YACD,IACE,IAAI,EAAE,OAAO,KAAK,SAAS;mBACxB,OAAO,IAAI,CAAC,OAAO,KAAK,SAAS,EACpC,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,6CAA6C,CAC9C,CAAC;YACJ,CAAC;YACD,MAAM,aAAa,GAAG,IAAI,GAAG,EAAK,CAAC;YACnC,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;gBACvC,IAAI,CAAC,CAAC,WAAW,YAAY,IAAI,CAAC,EAAE,CAAC;oBACnC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,2CAA2C,IAAI,CAAC,IAAI,IAAI,CACzD,CAAC;gBACJ,CAAC;gBACD,IAAI,WAAW,CAAC,cAAc,KAAK,KAAK,EAAE,CAAC;oBACzC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,wDAAwD,CACzD,CAAC;gBACJ,CAAC;gBACD,IAAI,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;oBACnC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,oEAAoE,CACrE,CAAC;gBACJ,CAAC;gBACD,aAAa,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;gBAC/B,0BAA0B,CACxB,WAAiD,EAChD,IAAI,CAAC,SAA0C,CAAC,aAAa,IAAI,EAAE,EACnE,IAAI,CAAC,SAEJ,CAAC,kBAAkB,CACtB,CAAC;YACJ,CAAC;YACD,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACrC,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;gBACvC,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,UAAU,KAAK,MAAM,EAAE,CAAC;oBAC9D,WAAW,CAAC,UAAU,GAAG,GAAG,CAAC;oBAC7B,WAAW,CAAC,UAAU,GAAG,GAAG,CAAC;gBAC/B,CAAC;YACH,CAAC;YACD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,aAAa,GAAG,8BAA8B,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACpE,MAAM,qBAAqB,GAAG,CAC5B,cAAmD,EAC7C,EAAE;gBACR,IAAI,aAAa,IAAI,CAAC,cAAc,EAAE,CAAC;oBACrC,OAAO;gBACT,CAAC;gBACD,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;oBACnD,MAAM,gBAAgB,GAAG,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;oBACxD,IAAI,gBAAgB,EAAE,CAAC;wBACrB,gBAAgB,CAAC,cAAc,GAAG,IAAI,CAAC;oBACzC,CAAC;gBACH,CAAC;YACH,CAAC,CAAC;YACF,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,UAAU,CAAC,YAAmB,EAAE,IAAI,CAAC,CAAC;gBACtE,qBAAqB,CACnB,MAAM,CAAC,WAAiD,CACzD,CAAC;gBACF,OAAO,MAAsF,CAAC;YAChG,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,SAAS,GAAG,KAAK,YAAY,yBAAyB;oBAC1D,CAAC,CAAC,KAAK,CAAC,KAAK;oBACb,CAAC,CAAC,KAAK,CAAC;gBACV,IAAI,SAAS,YAAY,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC;oBAC7D,qBAAqB,CACnB,SAAS,CAAC,MAAM,EAAE,WAEL,CACd,CAAC;gBACJ,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAED;;;;;;WAMG;QACI,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAEpC,YAAiB,EACjB,IAA4C;YAE5C,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CAAC,uBAAuB,EACzD,iEAAiE,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,YAAY,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;gBAC1F,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,oEAAoE,CAAC,CAAC;YAC1E,CAAC;YACD,MAAM,aAAa,GAAI,IAAY,CAAC,6BAA6B,EAA8C,CAAC;YAChH,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,aAAa,GAAG,IAAI,EAAE,aAAa,CAAC;YAC1C,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,eAAe,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;gBACjH,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,6EAA6E,CAAC,CAAC;YACnF,CAAC;YACD,MAAM,SAAS,GAAG,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,8BAA8B,EAAE,OAAO,CAAC,CAAC;YAClG,MAAM,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAC;YAC9C,KAAK,MAAM,QAAQ,IAAI,YAAY,EAAE,CAAC;gBACpC,IAAI,CAAC,CAAC,QAAQ,YAAY,IAAI,CAAC,IAAI,QAAQ,CAAC,cAAc,KAAK,KAAK,EAAE,CAAC;oBACrE,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,iFAAiF,CAAC,CAAC;gBACvF,CAAC;gBACD,0BAA0B,CAAC,QAA8C,EACtE,IAAI,CAAC,SAA0C,CAAC,aAAa,IAAI,EAAE,EACnE,IAAI,CAAC,SAAkF,CAAC,kBAAkB,CAAC,CAAC;gBAC/G,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAoB,CAAC;gBAC5D,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC7B,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,iEAAiE,CAAC,CAAC;gBACvE,CAAC;gBACD,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBACzB,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,UAAU,KAAK,MAAM,EAAE,CAAC;oBAC9D,KAAK,MAAM,SAAS,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;wBACnE,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;4BAC7E,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,mEAAmE,CAAC,CAAC;wBACzE,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;YACD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,OAAO,MAAM,UAAU,CAAC,kBAAkB,CAAC,YAAmB,EAAE,aAAa,EAAE;gBAC7E,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,SAAS;aACV,CAAC,CAAC;QACL,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,KAAK,CAAC,YAAY,CAE9B,SAAoC,EACpC,SAAoC,EACpC,IAAoC;YAEpC,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvC,MAAM,IAAI,yBAAyB,CAAC,uBAAuB,EACzD,qEAAqE,CAAC,CAAC;YAC3E,CAAC;YACD,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,2DAA2D,CAC5D,CAAC;YACJ,CAAC;YACD,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,mBAAmB,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAClF,MAAM,kBAAkB,GAAI,IAAY,CAAC,6BAA6B,EAGrE,CAAC;YACF,MAAM,YAAY,GAAI,IAAY,CAAC,uBAAuB,EAAiB,CAAC;YAC5E,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC;YACvD,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAoC,EACpC,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,eAAe,CAChB,CAAC;YACF,MAAM,iBAAiB,GAAG,OAAO,IAAI,gBAAgB;gBACnD,CAAC,CAAC,sCAAsC,CAAC,IAAI,CAAC;gBAC9C,CAAC,CAAC,IAAI,CAAC;YACT,IAAI,iBAAiB,EAAE,MAAM,KAAK,IAAI,IAAI,OAAO,IAAI,gBAAgB,EAAE,CAAC;gBACtE,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,uEAAuE,CACxE,CAAC;YACJ,CAAC;YACD,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,eAAe,CAChB,CAAC;YACF,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACrC,gBAAgB,CAAC,IAAI,GAAG;gBACtB,GAAG,CAAC,gBAAgB,CAAC,IAAI,IAAI,EAAE,CAAC;gBAChC,UAAU,EAAE,GAAG;aAChB,CAAC;YACF,IAAI,iBAAiB,EAAE,MAAM,KAAK,IAAI,EAAE,CAAC;gBACvC,gBAAgB,CAAC,YAAY,GAAG;oBAC9B,GAAG,CAAC,gBAAgB,CAAC,YAAY,IAAI,EAAE,CAAC;oBACxC,UAAU,EAAE,GAAG;iBAChB,CAAC;YACJ,CAAC;YACD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,MAAM,GAAG,MAAM,mBAAmB,CACtC,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,CAClB,CAAC;YACF,OAAO;gBACL,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,UAAU,EAAE,MAAM,CAAC,UAA6C;aACjE,CAAC;QACJ,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,KAAK,CAAC,sBAAsB,CAKxC,SAAoC,EACpC,SAAoC,EACpC,UAAuE;YAEvE,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,qEAAqE,CACtE,CAAC;YACJ,CAAC;YACD,MAAM,iBAAiB,GAAG,sCAAsC,CAAC,UAAU,CAAC,CAAC;YAC7E,MAAM,MAAM,GAAG,4BAA4B,CAAC,IAAI,CAAC,CAAC;YAClD,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,mBAAmB,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAClF,MAAM,kBAAkB,GAAI,IAAY,CAAC,6BAA6B,EAGrE,CAAC;YACF,MAAM,YAAY,GAAI,IAAY,CAAC,uBAAuB,EAAiB,CAAC;YAC5E,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC;YACvD,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAoC,EACpC,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,4BAA4B,CAC7B,CAAC;YACF,IAAI,iBAAiB,CAAC,MAAM,IAAI,OAAO,IAAI,gBAAgB,EAAE,CAAC;gBAC5D,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,oFAAoF,CACrF,CAAC;YACJ,CAAC;YACD,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,eAAe,CAChB,CAAC;YACF,IAAI,MAAM,EAAE,UAAU,KAAK,MAAM,EAAE,CAAC;gBAClC,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;gBACrC,gBAAgB,CAAC,IAAI,GAAG,EAAE,GAAG,CAAC,gBAAgB,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;gBAC9E,IAAI,iBAAiB,CAAC,MAAM,EAAE,CAAC;oBAC7B,gBAAgB,CAAC,YAAY,GAAG,EAAE,GAAG,CAAC,gBAAgB,CAAC,YAAY,IAAI,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;gBAChG,CAAC;YACH,CAAC;YACD,MAAM,cAAc,GAAG,aAAa,CAClC,iBAAiB,CAAC,IAAqC,EACvD,aAAa,EACZ,IAAY,CAAC,qBAAqB,EAAiB,CACrD,CAAC;YACF,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,MAAM,GAAG,MAAM,6BAA6B,CAChD,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB;gBACE,cAAc,EAAE,iBAAiB,CAAC,cAAc;gBAChD,MAAM,EAAE,iBAAiB,CAAC,MAAM;gBAChC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,cAAwC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7E,GAAG,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAC7E,CACF,CAAC;YACF,IAAI,MAAM,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;gBAC7B,OAAO,MAAoE,CAAC;YAC9E,CAAC;YACD,OAAO;gBACL,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,QAAQ,EAAG,IAAY,CAAC,kCAAkC,CAAC,MAAM,CAAC,QAAQ,CAAM;aACnB,CAAC;QAClE,CAAC;QAED;;;;;;WAMG;QACI,MAAM,CAAC,KAAK,CAAC,YAAY,CAE9B,SAAoC,EACpC,IAAoC;YAEpC,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,2DAA2D,CAC5D,CAAC;YACJ,CAAC;YACD,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,mBAAmB,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAClF,MAAM,kBAAkB,GAAI,IAAY,CAAC,6BAA6B,EAGrE,CAAC;YACF,MAAM,YAAY,GAAI,IAAY,CAAC,uBAAuB,EAAiB,CAAC;YAC5E,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAoC,EACpC,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,eAAe,EACd,IAAY,CAAC,8BAA8B,EAAE,CAC/C,CAAC;YACF,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,MAAM,GAAG,MAAM,mBAAmB,CACtC,UAAU,EACV,gBAAgB,EAChB,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,yBAAyB,EAAE,OAAO,CAAC,EAAE,CAClH,CAAC;YACF,OAAO;gBACL,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;aAClC,CAAC;QACJ,CAAC;QAED;;;;;;;WAOG;QACI,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAElC,SAAoC,EACpC,IAAoC;YAEpC,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,+DAA+D,CAChE,CAAC;YACJ,CAAC;YACD,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,mBAAmB,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAClF,MAAM,kBAAkB,GAAI,IAAY,CAAC,6BAA6B,EAGrE,CAAC;YACF,MAAM,YAAY,GAAI,IAAY,CAAC,uBAAuB,EAAiB,CAAC;YAC5E,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAoC,EACpC,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,oBAAoB,CACrB,CAAC;YACF,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,MAAM,GAAG,MAAM,uBAAuB,CAC1C,UAAU,EACV,gBAAgB,EAChB,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,8BAA8B,EAAE,OAAO,CAAC,EAAE,CACvH,CAAC;YACF,OAAO;gBACL,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;aAClC,CAAC;QACJ,CAAC;QAED;;;;;WAKG;QACI,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAElC,SAAoC,EACpC,SAA0D,EAC1D,IAAwC;YAExC,IAAI,4BAA4B,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvC,MAAM,IAAI,yBAAyB,CAAC,uBAAuB,EACzD,oEAAoE,CAAC,CAAC;YAC1E,CAAC;YACD,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,+DAA+D,CAChE,CAAC;YACJ,CAAC;YACD,IACE,OAAO,SAAS,KAAK,QAAQ;mBAC1B,SAAS,KAAK,IAAI;mBAClB,cAAc,IAAI,SAAS,EAC9B,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,mDAAmD,CACpD,CAAC;YACJ,CAAC;YACD,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,mBAAmB,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAClF,MAAM,WAAW,GAAI,IAAY,CAAC,sBAAsB,EAAiB,CAAC;YAC1E,MAAM,kBAAkB,GAAI,IAAY,CAAC,6BAA6B,EAGrE,CAAC;YACF,MAAM,YAAY,GAAI,IAAY,CAAC,uBAAuB,EAAiB,CAAC;YAC5E,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAoC,EACpC,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,YAAY,EACZ,eAAe,EACf,oBAAoB,CACrB,CAAC;YACF,MAAM,gBAAgB,GAAG,qBAAqB,CAC5C,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,eAAe,CAChB,CAAC;YACF,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACrC,gBAAgB,CAAC,IAAI,GAAG;gBACtB,GAAG,CAAC,gBAAgB,CAAC,IAAI,IAAI,EAAE,CAAC;gBAChC,UAAU,EAAE,GAAG;aAChB,CAAC;YACF,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,MAAM,GAAG,MAAM,uBAAuB,CAC1C,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,IAAI,CACL,CAAC;YACF,OAAO;gBACL,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,aAAa,EAAE,MAAM,CAAC,aAAa;aACpC,CAAC;QACJ,CAAC;QAED;;;;;;;WAOG;QACI,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAElC,UAA6C;YAE7C,MAAM,IAAI,GAAG,MAAO,IAAY,CAAC,oBAAoB,CAAC,UAAU,CAChC,CAAC;YACjC,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;QAED;;;;WAIG;QACI,MAAM,CAAC,KAAK,CAAC,oBAAoB,CAEtC,UAA6C;YAE7C,IAAK,IAAY,CAAC,4BAA4B,CAAC,EAAE,CAAC;gBAChD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,+DAA+D,CAChE,CAAC;YACJ,CAAC;YACD,IACE,OAAO,UAAU,KAAK,QAAQ;mBAC3B,UAAU,KAAK,IAAI;mBACnB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC;mBAC1C,CAAC,aAAa,CAAC,UAAU,CAAC,EAC7B,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,uDAAuD,CACxD,CAAC;YACJ,CAAC;YACD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC;gBAC1B,SAAS;gBACT,MAAM;gBACN,QAAQ;gBACR,OAAO;gBACP,WAAW;gBACX,WAAW;gBACX,QAAQ;gBACR,SAAS;aACV,CAAC,CAAC;YACH,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC9C,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBACrD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,+CAA+C,MAAM,CAAC,GAAG,CAAC,IAAI,CAC/D,CAAC;gBACJ,CAAC;gBACD,MAAM,UAAU,GAAG,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;gBACpE,IACE,CAAC,UAAU;uBACR,CAAC,CAAC,OAAO,IAAI,UAAU,CAAC;uBACxB,UAAU,CAAC,UAAU,KAAK,IAAI,EACjC,CAAC;oBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,0BAA0B,GAAG,8CAA8C,CAC5E,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC;YACzC,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC;YACnC,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC;YACvC,MAAM,WAAW,GAAG,UAAU,CAAC,KAAK,CAAC;YACrC,MAAM,eAAe,GAAG,UAAU,CAAC,SAAS,CAAC;YAC7C,MAAM,eAAe,GAAG,UAAU,CAAC,SAAS,CAAC;YAC7C,MAAM,YAAY,GAAG,UAAU,CAAC,MAAM,CAAC;YACvC,IAAI,YAAY,KAAK,SAAS,IAAI,CAAC,CAAC,YAAY,YAAY,WAAW,CAAC,EAAE,CAAC;gBACzE,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EAAE,+CAA+C,CAAC,CAAC;YAC3G,CAAC;YACD,YAAY,EAAE,cAAc,EAAE,CAAC;YAC/B,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,CAAC;YACzC,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,eAAe,GAAI,IAAY,CAAC,2BAA2B,EAAiB,CAAC;YACnF,MAAM,yBAAyB,GAAG,CAChC,QAAiB,EACjB,QAAgB,EACR,EAAE;gBACV,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;oBACjC,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,wCAAwC,CACpD,CAAC;gBACJ,CAAC;gBACD,MAAM,IAAI,GAAG,mBAAmB,CAAC,QAAQ,EAAE,aAAa,EAAE,QAAQ,CAAC,CAAC;gBACpE,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;oBACtB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,GAAG,QAAQ,2DAA2D,CACvE,CAAC;gBACJ,CAAC;gBACD,IAAI,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC9B,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,GAAG,QAAQ,oCAAoC,IAAI,IAAI,CACxD,CAAC;gBACJ,CAAC;gBACD,OAAO,IAAI,CAAC;YACd,CAAC,CAAC;YACF,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC;mBAC1B,aAAa,CAAC,MAAM,GAAG,CAAC;mBACxB,aAAa,CAAC,MAAM,GAAG,CAAC,EAC3B,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,mDAAmD,CACpD,CAAC;YACJ,CAAC;YACD,MAAM,aAAa,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CACxD,yBAAyB,CAAC,QAAQ,EAAE,8BAA8B,CAAC,CACpE,CAAC;YACF,IACE,aAAa,CAAC,MAAM,GAAG,CAAC;mBACrB,aAAa,CAAC,MAAM,GAAG,CAAC;mBACxB,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC,IAAI,KAAK,aAAa,CAAC,MAAM,EACvD,CAAC;gBACD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,mEAAmE,CACpE,CAAC;YACJ,CAAC;YACD,IAAI,UAAU,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC3D,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,kEAAkE,CACnE,CAAC;YACJ,CAAC;YACD,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CACzD,yBAAyB,CAAC,QAAQ,EAAE,0BAA0B,CAAC,CAChE,CAAC;YACF,IAAI,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,MAAM,EAAE,CAAC;gBACjD,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,6CAA6C,CAC9C,CAAC;YACJ,CAAC;YACD,MAAM,KAAK,GAAG,qBAAqB,CACjC,WAAW,EACX,sBAAsB,EACtB,MAAM,CACP,CAAC;YACF,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,2CAA2C,CAC5C,CAAC;YACJ,CAAC;YACD,MAAM,SAAS,GAAG,qBAAqB,CACrC,eAAe,EACf,0BAA0B,EAC1B,OAAO,CACR,CAAC;YACF,MAAM,SAAS,GAAG,qBAAqB,CAAC,eAAe,EAAE,0BAA0B,EAAE,OAAO,CAAC,CAAC;YAC9F,MAAM,UAAU,GAA4B;gBAC1C,GAAG,EAAE,aAAa,CAAC,MAAM,KAAK,CAAC;oBAC7B,CAAC,CAAC,GAAG,GAAG,aAAa,CAAC,CAAC,CAAC;oBACxB,CAAC,CAAC,MAAM,CAAC,WAAW,CAChB,aAAa,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,GAAG,GAAG,QAAQ,CAAC,CAAC,CAC5D;gBACL,oBAAoB,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE;aAClC,CAAC;YACF,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;gBACpD,UAAU,CAAC,oBAAoB,GAAG,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,QAAQ,EAAE,CAAC;YACtE,CAAC;YACD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,IAAI,GAAG,MAAM,UAAU,CAAC,sBAAsB,CAClD,YAAY,KAAK,SAAS;gBACxB,CAAC,CAAC,uBAAuB,CAAC,YAAY,CAAC;gBACvC,CAAC,CAAC,SAAS,EACb,UAAU,EACV,KAAK,GAAG,CAAC,EACT;gBACE,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACpD,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACjD,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACjD,GAAG,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aAChE,CACF,CAAC;YACF,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;YACpC,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAC1C,MAAM,mBAAmB,GAAG,CAC1B,QAAiB,EACjB,QAAgB,EACR,EAAE;gBACV,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC/D,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,GAAG,QAAQ,4EAA4E,CACxF,CAAC;gBACJ,CAAC;gBACD,OAAO,QAAQ,CAAC;YAClB,CAAC,CAAC;YACF,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;gBAC7C,MAAM,KAAK,GAA4B,EAAE,CAAC;gBAC1C,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAC/B,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,IAAI,IAAI,CAAC;gBAC/C,CAAC;qBAAM,CAAC;oBACN,MAAM,WAAW,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,EAAE,CAA4B,CAAC;oBAClE,KAAK,MAAM,QAAQ,IAAI,aAAa,EAAE,CAAC;wBACrC,gEAAgE;wBAChE,iEAAiE;wBACjE,KAAK,CAAC,QAAQ,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;oBAClD,CAAC;gBACH,CAAC;gBACD,MAAM,IAAI,GAA2B,EAAE,CAAC;gBACxC,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;oBACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,mBAAmB,CAClC,MAAM,CAAC,oBAAoB,GAAG,KAAK,CAAC,EACpC,6BAA6B,QAAQ,GAAG,CACzC,CAAC;gBACJ,CAAC;gBACD,OAAO;oBACL,KAAK;oBACL,KAAK,EAAE,mBAAmB,CACxB,MAAM,CAAC,oBAAoB,EAC3B,sBAAsB,CACvB;oBACD,IAAI;iBAC4B,CAAC;YACrC,CAAC,CAAC,CAAC;YACH,OAAO;gBACL,IAAI,EAAE,UAAU;gBAChB,OAAO;aACR,CAAC;QACJ,CAAC;QAED;;;;;WAKG;QACI,MAAM,CAAC,KAAK,CAAC,YAAY,CAE9B,SAAyB,EACzB,IAA8C;YAE9C,4DAA4D;YAC5D,MAAM,SAAS,GAAG,MAAO,IAAY,CAAC,UAAU,CAAC,OAAO,CACtD,uBAAuB,CAAC,SAAS,CAAC,EAClC,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAC3B,CAAC;YACF,MAAM,WAAW,GAAQ,EAAE,CAAC;YAC5B,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,MAAM,WAAW,GAAO,IAAY,CAAC,kCAAkC,CAAC,QAAQ,CAAC,CAAC;gBAClF,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAChC,CAAC;YACD,OAAO,WAAW,CAAC;QACrB,CAAC;QAED;;;;;;;WAOG;QACI,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAEnC,UAcC;YAMD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,UAAU,GAAG,EAAE,GAAG,UAAU,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,IAAI,EAAE,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC;YACtF,MAAM,aAAa,GAAG,UAAU,CAAC,aAAa,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAClE,MAAM,WAAW,GAAG,UAAU,CAAC,WAAW,IAAI,IAAI,CAAC;YACnD,MAAM,cAAc,GAAG,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,KAAM,GAAG,CAAC;gBACpF,CAAC,CAAC,UAAU,CAAC,KAAM;gBACnB,CAAC,CAAC,GAAG,CAAC;YACR,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;YAC7C,MAAM,YAAY,GAAG,uBAAuB,CAAC,UAAU,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;YAEtE,IAAI,QAAQ,GAAQ,YAAY,CAAC;YACjC,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;gBACtB,MAAM,YAAY,GAAG,aAAa,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;gBACzD,MAAM,YAAY,GAAG;oBACnB,GAAG,EAAE;wBACH,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE;wBAC3E;4BACE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,SAAS;4BACnD,CAAC,WAAW,CAAC,EAAE,EAAE,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE;yBACjE;qBACF;iBACF,CAAC;gBACF,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC;oBAC7C,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,EAAE;oBACxC,CAAC,CAAC,YAAY,CAAC;YACnB,CAAC;YAED,OAAO,+BAA+B,CAAC,UAAU,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,EAAE;gBACjF,aAAa,EAAE,KAAK;gBACpB,QAAQ,EAAE,UAAU,CAAC,+BAA+B,EAAE;aACvD,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;gBACzB,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;gBACxB,MAAM,SAAS,GAAG,UAAU,CAAC,iBAAiB;qBAC3C,IAAI,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;qBAC1C,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC,WAAW,CAAC,EAAE,aAAa,EAAE,CAAC;qBAC7E,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;gBACpB,OAAO,kBAAkB,CAAC,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE;oBACvD,MAAM,YAAY,GAAG,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC;oBAC/C,MAAM,OAAO,GAAG,YAAY,CAAC,MAAM,GAAG,KAAK,CAAC;oBAC5C,MAAM,QAAQ,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;oBAC9C,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAC5B,CAAC,WAAgB,EAAE,EAAE,CAAE,IAAY,CAAC,kCAAkC,CAAC,WAAW,CAAM,CACzF,CAAC;oBACF,MAAM,OAAO,GAAQ,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBACnD,MAAM,KAAK,GAAG,UAAU,CAAC,SAAS;wBAChC,CAAC,CAAC,MAAM,UAAU,CAAC,iBAAiB,CAAC,cAAc,CAAC,YAAY,EAAE;4BAC9D,OAAO,EAAE,aAAa;yBACvB,CAAC;wBACJ,CAAC,CAAC,SAAS,CAAC;oBACd,OAAO;wBACL,SAAS;wBACT,GAAG,CAAC,OAAO,IAAI,OAAO;4BACpB,CAAC,CAAC;gCACE,UAAU,EAAE;oCACV,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC;oCACxC,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC;iCAClC;6BACF;4BACH,CAAC,CAAC,EAAE,CAAC;wBACP,GAAG,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;qBAC1C,CAAC;gBACJ,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC;QAED;;;;;WAKG;QACI,MAAM,CAAC,KAAK,CAAC,WAAW,CAE7B,SAAyB,EACzB,IAAkC;YAEjC,IAAY,CAAC,wBAAwB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YACzD,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,gEAAgE;YAChE,MAAM,QAAQ,GAAG,MAAO,IAAY,CAAC,UAAU,CAAC,OAAO,CACrD,uBAAuB,CAAC,SAAS,CAAC,EAClC;gBACE,UAAU,EAAE,mBAAmB,CAC7B,IAAI,EAAE,UAAU,EAChB,aAAa,EACZ,IAAY,CAAC,qBAAqB,EAAE,CACtC;gBACD,SAAS,EAAE,qBAAqB,CAC9B,IAAI,EAAE,SAAS,EACf,WAAW,EACX,OAAO,CACR;gBACD,OAAO,EAAE,IAAI,EAAE,OAAO;aACvB,CACF,CAAC;YACF,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,WAAW,GAAO,IAAY,CAAC,kCAAkC,CAAC,QAAQ,CAAC,CAAC;gBAClF,OAAO,WAAW,CAAC;YACrB,CAAC;iBAAM,CAAC;gBACN,OAAO,IAAW,CAAC;YACrB,CAAC;QACH,CAAC;QAEM,MAAM,CAAC,KAAK,CAAC,MAAM,CAExB,SAAyB,EACzB,IAGC;YAED,MAAM,QAAQ,GAAG,MAAO,IAAY,CAAC,UAAU,CAAC,OAAO,CACrD,uBAAuB,CAAC,SAAS,CAAC,EAClC;gBACE,UAAU,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE;gBACtB,SAAS,EAAE,qBAAqB,CAC9B,IAAI,EAAE,SAAS,EACf,WAAW,EACX,OAAO,CACR;gBACD,OAAO,EAAE,IAAI,EAAE,OAAO;aACvB,CACF,CAAC;YACF,OAAO,QAAQ,KAAK,IAAI,CAAC;QAC3B,CAAC;QAED;;WAEG;QACI,MAAM,CAAC,KAAK,CAAC,QAAQ,CAE1B,YAAoB,EAAE;YAEtB,OAAO,GAAI,IAAY,CAAC,SAAS,IAAI,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;QAChF,CAAC;QAED;;;;WAIG;QACI,MAAM,CAAC,KAAK,CAAC,SAAS,CAE3B,SAAyB,EACzB,IAAiC;YAEhC,IAAY,CAAC,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;YACzE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;YACzC,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC/E,MAAM,kBAAkB,GAAI,IAAY,CAAC,qBAAqB,EAAiB,CAAC;YAChF,MAAM,UAAU,GAAG,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;YAC5F,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;YAC1E,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAClD,MAAM,SAAS,GAAG,qBAAqB,CACrC,IAAI,EAAE,SAAS,EACf,WAAW,EACX,MAAM,CACP,CAAC;YACF,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAClE,MAAM,SAAS,GAAG,qBAAqB,CACrC,IAAI,EAAE,SAAS,EACf,WAAW,EACX,OAAO,CACR,CAAC;YACF,MAAM,IAAI,GAAG,IAAI,EAAE,IAAI,CAAC;YACxB,IAAI,IAAI,KAAK,SAAS,IAAI,CACxB,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,aAAa;gBAC/D,CAAC,IAAI,IAAI,KAAK,KAAK,SAAS,CAC7B,EAAE,CAAC;gBACF,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,uFAAuF,CACxF,CAAC;YACJ,CAAC;YACD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,UAAU,CAAC,IAAI,EAAE,CAAC;YACxB,IAAI,SAAS,GACX,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,EAAE;gBACpE,UAAU;gBACV,OAAO;gBACP,IAAI;gBACJ,IAAI;aACL,CAAC,CAAC;YACL,IAAI,IAAI,EAAE,CAAC;gBACT,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC;YACD,IAAI,SAAS,EAAE,CAAC;gBACd,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAC7C,CAAC;YACD,IAAI,KAAK,EAAE,CAAC;gBACV,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACrC,CAAC;YACD,IAAI,SAAS,EAAE,CAAC;gBACd,SAAS,GAAG,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAC7C,CAAC;YACD,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,cAAc,GAAG,SAAS,CAAC;gBACjC,IAAI,cAA+C,CAAC;gBACpD,IAAI,CAAC;oBACH,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAC;gBAC5C,CAAC;gBAAC,OAAO,aAAa,EAAE,CAAC;oBACvB,IAAI,CAAC;wBACH,MAAM,cAAc,CAAC,KAAK,EAAE,CAAC;oBAC/B,CAAC;oBAAC,MAAM,CAAC;wBACP,mEAAmE;oBACrE,CAAC;oBACD,MAAM,aAAa,CAAC;gBACtB,CAAC;gBACD,IAAI,cAAc,KAAK,cAAc,EAAE,CAAC;oBACtC,IAAI,CAAC;wBACH,MAAM,cAAc,CAAC,KAAK,EAAE,CAAC;oBAC/B,CAAC;oBAAC,OAAO,wBAAwB,EAAE,CAAC;wBAClC,IAAI,CAAC;4BACH,MAAM,cAAc,CAAC,KAAK,EAAE,CAAC;wBAC/B,CAAC;wBAAC,MAAM,CAAC;4BACP,gDAAgD;wBAClD,CAAC;wBACD,MAAM,wBAAwB,CAAC;oBACjC,CAAC;gBACH,CAAC;gBACD,SAAS,GAAG,cAAc,CAAC;YAC7B,CAAC;YACD,OAAO,IAAI,iBAAiB,CAAI,SAAS,EAAE,IAAoC,CAAC,CAAC;QACnF,CAAC;QAED;;;;WAIG;QACI,MAAM,CAAC,KAAK,CAAC,aAAa,CAE/B,SAAyB,EACzB,IAAoC;YAEpC,MAAM,aAAa,GAAI,IAAY,CAAC,yBAAyB,EAAiB,CAAC;YAC9E,IAAY,CAAC,wBAAwB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YACzD,MAAM,kBAAkB,GAAI,IAAY,CAAC,qBAAqB,EAAiB,CAAC;YAChF,MAAM,UAAU,GAAG,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;YAC5F,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;YAC1E,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAClD,MAAM,KAAK,GAAG,qBAAqB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAClE,MAAM,IAAI,GAAG,IAAI,EAAE,IAAI,CAAC;YACxB,IAAI,CAAC,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,aAAa,EAAE,CAAC;gBACpG,MAAM,IAAI,yBAAyB,CACjC,kBAAkB,EAClB,iFAAiF,CAClF,CAAC;YACJ,CAAC;YACD,MAAM,SAAS,GAAG,qBAAqB,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;YACtH,MAAM,SAAS,GAAG,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;YAC/E,MAAM,MAAM,GAAG,uBAAuB,CAAC,SAAS,CAAC,CAAC;YAClD,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;YAC9B,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,IAAI,CAAC,UAAU,CAAC,+BAA+B,EAAE,EAAE,CAAC;gBAClD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,qDAAqD,CACtD,CAAC;YACJ,CAAC;YACD,OAAO,+BAA+B,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,EAAE;gBAC3E,aAAa,EAAE,KAAK;gBACpB,QAAQ,EAAE,IAAI;aACf,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;gBACzB,IAAI,CAAC,MAAM,EAAE,cAAc,EAAE,CAAC;gBAC9B,MAAM,SAAS,GAAG,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,EAAE;oBAC1D,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS;oBACzD,WAAW,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM;iBAC3E,CAAC,CAAC;gBACH,OAAO,kBAAkB,CAAC,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE;oBACvD,MAAM,SAAS,GAAG,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC;oBAC5C,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAClC,IAAY,CAAC,kCAAkC,CAAC,WAAW,CAAM,CACnE,CAAC;gBACJ,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC,CAAC,CAAC;QACL,CAAC;QAED;;;;;WAKG;QACH;;;;WAIG;QACI,MAAM,CAAC,KAAK,CAAC,KAAK,CAEvB,SAAyB,EACzB,IAAsE;YAEtE,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,MAAM,OAAO,GAA0B,MAAM,UAAU,CAAC,KAAK,CAC3D,uBAAuB,CAAC,SAAS,CAAC,EAClC,IAAI,IAAI,EAAE,EACV,IAAW,CACZ,CAAC;YACF,OAAO,OAAO,CAAC;QACjB,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,KAAK,CAAC,OAAO,CAEzB,SAAyB,EACzB,eAA6C;YAE7C,MAAM,MAAM,GAAyB,MAAO,IAAY,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YAC9E,MAAM,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QACxC,CAAC;QAED;;WAEG;QACI,MAAM,CAAC,KAAK,CAAC,QAAQ,CAE1B,YAA4B,EAAS,EACrC,IAA6B;YAE7B,MAAM,IAAI,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAClD,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,OAAO,MAAM,UAAU,CAAC,QAAQ,CAAC,uBAAuB,CAAC,SAAS,CAAC,EAAE;gBACnE,IAAI;gBACJ,KAAK,EAAE,qBAAqB,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC;gBAC1D,SAAS,EAAE,qBAAqB,CAC9B,IAAI,EAAE,SAAS,EACf,WAAW,EACX,OAAO,CACR;gBACD,SAAS,EAAE,qBAAqB,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,CAAC;gBACvE,MAAM,EAAE,IAAI,EAAE,MAAM;gBACpB,OAAO,EAAE,IAAI,EAAE,OAAO;aACvB,CAAC,CAAC;QACL,CAAC;QAED;;;WAGG;QACI,MAAM,CAAC,KAAK,CAAC,wBAAwB;YAG1C,MAAM,UAAU,GAA4B,IAAY,CAAC,UAAU,CAAC;YACpE,OAAO,MAAM,UAAU,CAAC,wBAAwB,EAAE,CAAC;QACrD,CAAC;QAED;;;;WAIG;QACI,MAAM,CAAC,kBAAkB,CAE9B,WAAmB;YAEnB,MAAM,gBAAgB,GAAI,IAAY,CAAC,mBAAmB,EAAE,CAAC;YAC7D,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClC,MAAM,IAAI,KAAK,CAAC,0CAA0C,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YACzE,CAAC;YACD,MAAM,OAAO,GAAG,IAAI,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;YAC7D,OAAO,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QACtC,CAAC;QACD;;WAEG;QACI,MAAM,CAAC,mBAAmB;YAC/B,MAAM,IAAI,GAAG,IAAW,CAAC;YACzB,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3E,CAAC;QACD;;WAEG;QACK,MAAM,CAAC,KAAK,CAAC,SAAS,CAE5B,UAA+B,EAC/B,IAAuB;YAEvB,IAAI,WAAW,GAAG,UAAU,IAAI,EAAE,CAAC;YACnC,IAAI,IAAI,EAAE,MAAM,EAAE,CAAC;gBACjB,WAAW,GAAG,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACrD,CAAC;YACD,+CAA+C;YAC/C,gCAAgC;YAChC,IAAI,IAAI,GAAQ,MAAO,IAAY,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;YAC1F,IAAI,IAAI,EAAE,QAAQ,EAAE,CAAC;gBACnB,MAAM,GAAG,GAAQ,EAAE,CAAC;gBACpB,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;oBACrB,IAAI,MAAM,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;wBAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC1C,CAAC;gBACD,IAAI,GAAG,GAAG,CAAC;YACb,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QAED;;;;;;WAMG;QACI,MAAM,CAAC,KAAK,CAAC,MAAM,CAExB,KAAa,EACb,IAAuB;YAEvB,MAAM,gBAAgB,GAAI,IAAY,CAAC,mBAAmB,EAAE,CAAC;YAC7D,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClC,MAAM,IAAI,KAAK,CAAC,0CAA0C,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YACzE,CAAC;YACD,4BAA4B;YAC5B,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,CAAC,EAAE,CAAC;gBACP,qCAAqC;gBACrC,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;YACjD,CAAC;YACD,gEAAgE;YAChE,0DAA0D;YAC1D,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;YACtD,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC7B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;oBACtC,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,iCAAiC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC/E,CAAC;gBACD,4BAA4B;gBAC5B,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,CAAC;YACjE,CAAC;YACD,oEAAoE;YACpE,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;YAC5C,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;gBAC5C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;gBAChE,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACnC,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC3F,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC;YAC/D,CAAC;YACD,wEAAwE;YACxE,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC;YACpD,IAAI,aAAa,EAAE,CAAC;gBAClB,MAAM,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;gBAC/B,6DAA6D;gBAC7D,IAAI,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;gBAC/B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;oBAClD,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;oBACvD,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACjC,CAAC;gBACD,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;oBACtC,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,iCAAiC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC/E,CAAC;gBACD,oEAAoE;gBACpE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;gBAChE,MAAM,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBACtE,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;YACnG,CAAC;YACD,2DAA2D;YAC3D,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC7D,uEAAuE;gBACvE,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;gBAC1D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBACjE,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC3F,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC;YAC/D,CAAC;YACD,iFAAiF;YACjF,CAAC;gBACC,wDAAwD;gBACxD,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC,IAAI,EAAE,CAAC;gBAClE,2EAA2E;gBAC3E,IACE,SAAS,CAAC,MAAM,GAAG,CAAC;oBACpB,CAAC,iCAAiC,CAAC,IAAI,CAAC,CAAC,CAAC;oBAC1C,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAChB,CAAC;oBACD,MAAM,QAAQ,GAAU,EAAE,CAAC;oBAC3B,KAAK,IAAI,KAAK,IAAI,SAAS,EAAE,CAAC;wBAC5B,oBAAoB;wBACpB,MAAM,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;wBACvC,IAAI,EAAE,EAAE,CAAC;4BACP,MAAM,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;4BACpB,IAAI,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;4BAClB,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gCACtC,MAAM,IAAI,KAAK,CAAC,UAAU,KAAK,iCAAiC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;4BAC/E,CAAC;4BACD,sCAAsC;4BACtC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gCACrG,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;4BAC7B,CAAC;4BACD,mBAAmB;4BACnB,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gCAC/C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAAC;gCAC9D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gCACjE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;4BACjE,CAAC;iCAAM,CAAC;gCACN,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;4BACpC,CAAC;wBACH,CAAC;6BAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;4BAC5G,uCAAuC;4BACvC,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;4BAClC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;4BAChE,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;4BACnC,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;wBACrG,CAAC;6BAAM,CAAC;4BACN,8BAA8B;4BAC9B,MAAM,GAAG,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;4BAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;wBACjG,CAAC;oBACH,CAAC;oBACD,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,IAAI,CAAC,CAAC;gBACjE,CAAC;YACH,CAAC;YACD,2EAA2E;YAC3E,MAAM,YAAY,GAAG,iDAAiD,CAAC;YACvE,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;gBACzB,MAAM,MAAM,GAAI,IAAY,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC;gBACnD,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACrD,CAAC;YACD,kEAAkE;YAClE,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;oBAClC,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;oBACjC,MAAM,GAAG,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;oBACnF,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;gBACtB,CAAC,CAAC,CAAC;gBACH,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,IAAI,CAAC,CAAC;YACjE,CAAC;YACD,oDAAoD;YACpD,MAAM,GAAG,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;YAC9B,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;YACvF,OAAO,MAAO,IAAY,CAAC,SAAS,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC;QAC/D,CAAC;QAGD,WAAW;QAEX,WAAW;QAEX;;WAEG;QACI,cAAc,GAAiB,KAAK,CAAC;QAE5C;;WAEG;QAEH,UAAU,qDAAW,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAC;QAE9C;;WAEG;QAEH,UAAU,8GAAW,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,GAAC;QAuC9C;;WAEG;QACI,IAAI,0DAAU;QAErB;;WAEG;QACI,aAAa,CAAU;QAE9B;;WAEG;QACH;YACE,IAAI,4BAA4B,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,UAAU,KAAK,MAAM,EAAE,CAAC;gBAC1E,OAAQ,IAAY,CAAC,UAAU,CAAC;gBAChC,OAAQ,IAAY,CAAC,UAAU,CAAC;YAClC,CAAC;QACH,CAAC;QAED;;WAEG;QACI,KAAK,CAAC,IAAI,CAAC,IAAkD;YAClE,IAAI,4BAA4B,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;gBACnD,MAAM,IAAI,yBAAyB,CAAC,uBAAuB,EACzD,4EAA4E,CAAC,CAAC;YAClF,CAAC;YACD,MAAM,sBAAsB,GAAI,IAAI,CAAC,WAAmB,CACtD,4BAA4B,CAC6B,CAAC;YAC5D,IAAI,sBAAsB,EAAE,CAAC;gBAC3B,IAAI,sBAAsB,CAAC,eAAe,EAAE,CAAC;oBAC3C,OAAO,sBAAsB,CAAC,eAAe,EAAE,CAAC;gBAClD,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;YACzE,CAAC;YACD,2BAA2B;YAC3B,IAAI,OAAQ,IAAY,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;gBACnD,MAAO,IAAY,CAAC,UAAU,EAAE,CAAC;YACnC,CAAC;YACD,0BAA0B,CACxB,IAA0C,EAC1C,IAAI,CAAC,aAAa,IAAI,EAAE,EACxB,IAAI,CAAC,kBAAkB,CACxB,CAAC;YACF,+CAA+C;YAC/C,MAAM,IAAI,GAAQ,IAAI,CAAC;YACvB,IAAI,QAAa,CAAC;YAClB,mBAAmB;YACnB,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YAC3C,2BAA2B;YAC3B,QAAQ,IAAI,CAAC,cAAc,EAAE,CAAC;gBAC5B,KAAK,IAAI;oBACP,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;oBACnF,MAAM;gBACR,KAAK,KAAK;oBACR,QAAQ,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;oBACnF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;oBAC3B,MAAM;gBACR;oBACE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC;YAClD,CAAC;YACD,0BAA0B;YAC1B,IAAI,OAAQ,IAAY,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;gBAClD,MAAO,IAAY,CAAC,SAAS,EAAE,CAAC;YAClC,CAAC;YACD,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;WAEG;QACI,KAAK,CAAC,MAAM,CAAC,IAAkD;YACpE,MAAM,sBAAsB,GAAI,IAAI,CAAC,WAAmB,CACtD,4BAA4B,CAC6B,CAAC;YAC5D,IAAI,sBAAsB,EAAE,CAAC;gBAC3B,IAAI,sBAAsB,CAAC,eAAe,EAAE,CAAC;oBAC3C,OAAO,sBAAsB,CAAC,eAAe,EAAE,CAAC;gBAClD,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;YACzE,CAAC;YACD,6BAA6B;YAC7B,IAAI,OAAQ,IAAY,CAAC,YAAY,KAAK,UAAU,EAAE,CAAC;gBACrD,MAAO,IAAY,CAAC,YAAY,EAAE,CAAC;YACrC,CAAC;YACD,mBAAmB;YACnB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;YACvF,0BAA0B;YAC1B,IAAI,OAAQ,IAAY,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;gBACpD,MAAO,IAAY,CAAC,WAAW,EAAE,CAAC;YACpC,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED;;;WAGG;QACI,QAAQ,CAAC,WAA6D;YAC3E,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,WAAW,GAAG,IAAI,OAAO,CAAC,GAAG,CAAC,SAAS,EAA4B,CAAC;YACtE,CAAC;YACD,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,IAAI,EAAE,CAAC;YACZ,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5C,MAAM,QAAQ,GAAQ,IAAI,CAAC,WAAW,CAAC,CAAC;gBACxC,IAAI,QAAQ,YAAY,cAAc,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAChF,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;gBACjC,CAAC;YACH,CAAC;QACH,CAAC;QAED;;WAEG;QACI,KAAK,CAAC,YAAY;YACvB,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,wBAAwB,EAAE,CAAC;YACjE,IAAI,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjD,MAAM,IAAI,yBAAyB,CACjC,uBAAuB,EACvB,6GAA6G,CAC9G,CAAC;YACJ,CAAC;YACD,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;YACpF,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACtB,OAAO,KAAK,CAAC,CAAC,iCAAiC;YACjD,CAAC;YACD,IAAI,4BAA4B,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;gBACnD,MAAM,QAAQ,GAAI,IAAI,CAAC,WAAmB,CAAC,kCAAkC,CAAC,gBAAgB,CAAC,CAAC;gBAChG,KAAK,MAAM,KAAK,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,YAAY,CAAC,EAAE,CAAC;oBAC5F,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC;wBAAE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;gBACjF,CAAC;gBACD,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;gBAC9B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;gBAChD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;gBACvC,MAAM,UAAU,GAAI,IAAI,CAAC,WAAmB,CAAC,YAAY,IAAI,EAAE,CAAC;gBAChE,MAAM,IAAI,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;gBAC7B,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,UAAU;oBACxD,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;oBAC5B,CAAC,CAAC,QAAQ,CAAC;YACf,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QAED;;;;;;WAMG;QACI,KAAK,CAAC,mBAAmB;YAC9B,IAAI,4BAA4B,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,UAAU,KAAK,MAAM;gBACvE,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;oBACvD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC;gBAC9D,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EACpD,8DAA8D,CAAC,CAAC;YACpE,CAAC;YACD,0BAA0B,CACxB,IAA0C,EAC1C,IAAI,CAAC,aAAa,IAAI,EAAE,EACxB,IAAI,CAAC,kBAAkB,CACxB,CAAC;YACF,MAAM,cAAc,GAAY,EAAE,CAAC,CAAC,+CAA+C;YACnF,MAAM,WAAW,GAAG,IAAI,CAAC,wBAAwB,IAAI,EAAE,CAAC;YACxD,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC;YACpD,MAAM,MAAM,GAAG,4BAA4B,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC9D,MAAM,kBAAkB,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC;oBACrC,GAAG,WAAW,EAAE,GAAG,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;iBAC7D,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,MAAM;gBACpD,CAAC,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;YACpD,2CAA2C;YAC3C,MAAM,UAAU,GAAI,IAAI,CAAC,WAAmB,CAAC,YAAY,IAAI,EAAE,CAAC;YAChE,KAAK,MAAM,kBAAkB,IAAI,kBAAkB,EAAE,CAAC;gBACpD,MAAM,QAAQ,GAAI,IAAY,CAAC,kBAAkB,CAAC,CAAC;gBACnD,MAAM,IAAI,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC;gBAC5C,MAAM,eAAe,GAAG,IAAI,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,UAAU;oBAClE,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;oBAC1B,CAAC,CAAC,QAAQ,CAAC;gBACb,IAAI,eAAe,KAAK,SAAS,EAAE,CAAC;oBAClC,sEAAsE;oBACtE,8CAA8C;oBAC9C,SAAS;gBACX,CAAC;gBACA,cAAsB,CAAC,kBAAkB,CAAC,GAAG,oBAAoB,CAAC,eAAe,CAAC,CAAC;YACtF,CAAC;YACD,OAAO,cAA6B,CAAC;QACvC,CAAC;QAED;;WAEG;QACI,KAAK,CAAC,wBAAwB;YACnC,0BAA0B,CACxB,IAA0C,EAC1C,IAAI,CAAC,aAAa,IAAI,EAAE,EACxB,IAAI,CAAC,kBAAkB,CACxB,CAAC;YACF,MAAM,kBAAkB,GAAQ,EAAE,CAAC,CAAC,+CAA+C;YACnF,KAAK,MAAM,kBAAkB,IAAI,IAAI,CAAC,aAAa,IAAI,EAAE,EAAE,CAAC;gBAC1D,kBAAkB,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC;YACpE,CAAC;YACD,IAAI,4BAA4B,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAC;gBACxE,MAAM,EAAE,GAAI,IAAY,CAAC,GAAG,CAAC;gBAC7B,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBACrD,MAAM,IAAI,yBAAyB,CAAC,kBAAkB,EAAE,gCAAgC,CAAC,CAAC;gBAC5F,CAAC;gBACD,kBAAkB,CAAC,GAAG,GAAG,EAAE,CAAC;YAC9B,CAAC;YACD,OAAO,kBAAkB,CAAC;QAC5B,CAAC;;;SA76DU,cAAc"}