@directivegames/genesys.js 3.1.24

package/dist/src/render/lightmapping/LightmapManager.js

@@ -0,0 +1,630 @@
+import * as THREE from 'three';
+import { deinterleaveGeometry } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { GLTFMeshActor } from '../../actors/GLTFMeshActor.js';
+import { DirectionalLightComponent, PointLightComponent, RectAreaLightComponent, SpotLightComponent } from '../../components/lights/index.js';
+import { GLTFMeshComponent } from '../../components/visual/GLTFMeshComponent.js';
+import { MeshComponent } from '../../components/visual/MeshComponent.js';
+import { PhysicsMotionType } from '../../physics/PhysicsTypes.js';
+import { LightmapAtlas } from './LightmapAtlas.js';
+import { LightmapBaker } from './LightmapBaker.js';
+import { createMeshMappings } from './LightmapSerialization.js';
+import { LightmapSerializer } from './LightmapSerializer.js';
+/**
+ * Manages lightmap baking for an entire scene
+ *
+ * This class coordinates the lightmapping process by:
+ * 1. Finding all static mesh actors in the scene
+ * 2. Generating UV2 coordinates for lightmapping
+ * 3. Creating render targets and baking lighting information
+ * 4. Applying the resulting lightmaps to materials
+ */
+export class LightmapManager {
+    constructor(world, renderer, options = {}) {
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "renderer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "atlas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastBakedTexture", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastBakedRenderTarget", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastBakeOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lastBakedActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.world = world;
+        this.renderer = renderer;
+        this.options = {
+            // Default bake options
+            resolution: 512,
+            casts: 32,
+            filterMode: THREE.LinearFilter,
+            directLightEnabled: true,
+            indirectLightEnabled: false,
+            ambientLightEnabled: false,
+            ambientDistance: 10.0,
+            progressiveSamples: 100,
+            // lightPosition: new THREE.Vector3(10, 10, 10), // Removed - use getPrimaryLight() instead
+            // lightSize: 0.5, // Removed - now part of individual light sources
+            // Manager-specific defaults
+            progressiveBaking: false,
+            autoApply: true,
+            autoLoadLightmaps: true,
+            ...options
+        };
+    }
+    /**
+     * Initialize the lightmapping system
+     */
+    async initialize() {
+        try {
+            this.atlas = new LightmapAtlas();
+            this.baker = new LightmapBaker(this.renderer);
+            await LightmapAtlas.loadXAtlas();
+        }
+        catch (error) {
+            console.warn('Failed to initialize lightmap manager:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clean up any existing textures and GPU resources before rebaking
+     */
+    cleanupTexturesAndResources() {
+        console.log('🧹 Cleaning up previous lightmapping textures and resources...');
+        // Dispose of previous atlas result textures if they exist
+        if (this.baker) {
+            const atlasResult = this.baker.getAtlasResult();
+            if (atlasResult) {
+                if (atlasResult.positionTexture) {
+                    atlasResult.positionTexture.dispose();
+                    console.log('Disposed atlas position texture');
+                }
+                if (atlasResult.normalTexture) {
+                    atlasResult.normalTexture.dispose();
+                    console.log('Disposed atlas normal texture');
+                }
+            }
+            // Dispose the baker which will clear its internal state
+            this.baker.dispose();
+        }
+        // Dispose of previous lightmap render target
+        if (this.lastBakedRenderTarget) {
+            this.lastBakedRenderTarget.dispose();
+            console.log('Disposed previous lightmap render target');
+            this.lastBakedRenderTarget = null;
+        }
+        // Clear previous lightmap texture reference (no need to dispose, it's the same as render target texture)
+        if (this.lastBakedTexture) {
+            console.log('Cleared previous lightmap texture reference');
+            this.lastBakedTexture = null;
+        }
+        // Restore any cloned geometries from previous baking
+        if (this.lastBakedActors.length > 0) {
+            console.log('Clearing previous baked actors references');
+        }
+        // Clear references
+        this.lastBakeOptions = null;
+        this.lastBakedActors = [];
+        // Re-initialize baker for fresh state
+        this.baker ??= new LightmapBaker(this.renderer);
+        console.log('✓ Cleanup completed - ready for fresh lightmap baking');
+    }
+    /**
+     * Bake lightmaps for the entire scene
+     */
+    async bakeLightmaps(options = {}, onProgress) {
+        if (!this.atlas || !this.baker) {
+            throw new Error('LightmapManager not initialized. Call initialize() first.');
+        }
+        const startTime = performance.now();
+        onProgress?.('preparing', 0, 'Initializing lightmap baking...');
+        // Clean up any existing textures and GPU resources before rebaking
+        this.cleanupTexturesAndResources();
+        // Store bake options for potential export
+        // this.lastBakeOptions = { ...options }; // Removed
+        // Get all static mesh actors in the scene
+        const meshActors = this.getStaticMeshActors();
+        if (meshActors.length === 0) {
+            console.warn('No static mesh actors found');
+            return;
+        }
+        console.log('Collected ', meshActors.length, ' mesh actors');
+        // Collect all meshes and ensure unique geometries for lightmapping
+        const allMeshes = [];
+        for (const actor of meshActors) {
+            const actorMeshes = this.getMeshesFromActor(actor);
+            // Filter meshes for baking (only include meshes with materials and visibility)
+            const bakingMeshes = actorMeshes.filter(mesh => {
+                return mesh.material && mesh.visible;
+            });
+            allMeshes.push(...bakingMeshes);
+        }
+        if (allMeshes.length === 0) {
+            console.warn('No meshes found for lightmapping');
+            return;
+        }
+        console.log('Collected ', allMeshes.length, ' meshes');
+        console.log('DeInterleaving meshes...');
+        const deInterleavedMeshes = allMeshes.map(mesh => {
+            const clonedGeometry = mesh.geometry.clone();
+            deinterleaveGeometry(clonedGeometry);
+            mesh.geometry = clonedGeometry;
+            return mesh;
+        });
+        console.log('Generating UV2 coordinates...');
+        // Prepare meshes and generate UV2 coordinates
+        onProgress?.('atlas', 20, 'Preparing meshes and generating UV2 coordinates...');
+        await this.baker.prepareMeshes(deInterleavedMeshes);
+        // Generate atlas
+        console.log('Generating atlas...');
+        onProgress?.('atlas', 40, 'Generating lightmap atlas...');
+        this.baker.generateAtlas(deInterleavedMeshes, {
+            resolution: options.resolution ?? this.options.resolution,
+            ...options.atlasOptions,
+        });
+        // Build bake options with defaults
+        const bakeOptions = {
+            resolution: options.resolution ?? this.options.resolution,
+            casts: options.casts ?? this.options.casts,
+            filterMode: options.filterMode ?? this.options.filterMode,
+            directLightEnabled: options.directLightEnabled ?? this.options.directLightEnabled,
+            indirectLightEnabled: options.indirectLightEnabled ?? this.options.indirectLightEnabled,
+            ambientLightEnabled: options.ambientLightEnabled ?? this.options.ambientLightEnabled,
+            ambientDistance: options.ambientDistance ?? this.options.ambientDistance,
+            progressiveSamples: options.progressiveSamples ?? this.options.progressiveSamples,
+            lightSources: options.lightSources ?? this.getAllLightSources(),
+        };
+        // Bake lightmap
+        onProgress?.('baking', 60, 'Baking lightmap...');
+        let lightmapTexture;
+        if (this.options.progressiveBaking) {
+            // Progressive baking
+            console.log('Baking lightmap progressive with options:', bakeOptions);
+            lightmapTexture = await this.baker.bakeProgressiveLightmap(deInterleavedMeshes, bakeOptions, (samples, maxSamples) => {
+                const progress = 60 + (samples / maxSamples) * 30;
+                onProgress?.('baking', progress, `Baking... ${samples}/${maxSamples} samples`);
+            });
+        }
+        else {
+            // Single-pass baking with multiple samples
+            console.log('Baking lightmap single-pass with options:', bakeOptions);
+            const result = this.baker.bakeLightmap(bakeOptions);
+            const samples = bakeOptions.progressiveSamples ?? this.options.progressiveSamples ?? 100;
+            // Render multiple samples even in non-progressive mode
+            for (let i = 0; i < samples; i++) {
+                result.render();
+                // Update progress occasionally
+                if (i % 10 === 0) {
+                    const progress = 60 + (i / samples) * 30;
+                    onProgress?.('baking', progress, `Baking... ${i + 1}/${samples} samples`);
+                }
+            }
+            lightmapTexture = result.lightmapTexture;
+        }
+        console.log('Baking done.');
+        // Store the baking data for potential export (including original UV2 data)
+        this.lastBakedTexture = lightmapTexture.texture;
+        this.lastBakedRenderTarget = lightmapTexture;
+        this.lastBakeOptions = bakeOptions;
+        this.lastBakedActors = meshActors;
+        const endTime = performance.now();
+        const duration = (endTime - startTime) / 1000;
+        onProgress?.('applying', 100, `Lightmap baking completed in ${duration.toFixed(2)}s`);
+        // Smart light management after successful baking
+        if (this.options.autoApply) {
+            console.log('Applying lightmap.');
+            this.applyLightmaps(meshActors, lightmapTexture.texture);
+        }
+        else {
+            this.manageRuntimeLighting(true);
+        }
+    }
+    /**
+     * Gets all static mesh actors that can be lightmapped
+     * Only includes actors with mesh components that have Static physics motion type
+     */
+    getStaticMeshActors() {
+        return this.world.getActorsByPredicate(actor => {
+            // Find all mesh components in the actor (recursively through all children)
+            const meshComponents = this.getAllMeshComponentsFromActor(actor);
+            // An actor is included if it has at least one static mesh component
+            return meshComponents.some(meshComponent => {
+                const physicsOptions = meshComponent.getPhysicsOptions();
+                const motionType = physicsOptions?.motionType ?? PhysicsMotionType.Static;
+                return motionType === PhysicsMotionType.Static;
+            });
+        });
+    }
+    /**
+     * Recursively finds all mesh components in an actor and its children
+     */
+    getAllMeshComponentsFromActor(actor) {
+        const meshComponents = [];
+        // Helper function to recursively check components
+        const checkComponent = (component) => {
+            // Check if this component is a mesh component
+            if (component instanceof MeshComponent || component instanceof GLTFMeshComponent) {
+                meshComponents.push(component);
+            }
+            // Recursively check all children
+            if (component.children) {
+                for (const child of component.children) {
+                    checkComponent(child);
+                }
+            }
+        };
+        // Start with root component
+        const rootComponent = actor.rootComponent;
+        if (rootComponent) {
+            checkComponent(rootComponent);
+        }
+        // Also check if the actor itself is a GLTFMeshActor (for backward compatibility)
+        if (actor instanceof GLTFMeshActor) {
+            const meshComponent = actor.getMeshComponent();
+            if (meshComponent && !meshComponents.includes(meshComponent)) {
+                meshComponents.push(meshComponent);
+            }
+        }
+        return meshComponents;
+    }
+    /**
+     * Gets all meshes from an actor
+     */
+    getMeshesFromActor(actor) {
+        const meshes = [];
+        const meshComponents = this.getAllMeshComponentsFromActor(actor);
+        for (const meshComponent of meshComponents) {
+            if (meshComponent instanceof GLTFMeshComponent) {
+                const model = meshComponent.getModel();
+                if (model) {
+                    model.traverse((child) => {
+                        if (child instanceof THREE.Mesh) {
+                            meshes.push(child);
+                        }
+                    });
+                }
+            }
+        }
+        // Check if root component is a MeshComponent
+        const rootComponent = actor.rootComponent;
+        if (rootComponent instanceof MeshComponent) {
+            const mesh = rootComponent.getMesh();
+            if (mesh) {
+                meshes.push(mesh);
+            }
+        }
+        return meshes;
+    }
+    /**
+     * Gets all light sources in the scene for lightmapping
+     */
+    getAllLightSources() {
+        const lightSources = [];
+        // Collect directional lights
+        const directionalLightActors = this.world.getActorsByPredicate(actor => actor.getComponents(DirectionalLightComponent).length > 0);
+        for (const lightActor of directionalLightActors) {
+            const lightComponent = lightActor.getComponents(DirectionalLightComponent)[0];
+            const lightPosition = lightActor.getWorldPosition();
+            lightSources.push({
+                position: lightPosition,
+                size: 0.5,
+                intensity: lightComponent.light?.intensity ?? 1.0,
+                color: lightComponent.light?.color ? new THREE.Vector3(lightComponent.light.color.r, lightComponent.light.color.g, lightComponent.light.color.b) : new THREE.Vector3(1, 1, 1)
+            });
+        }
+        // Collect point lights
+        const pointLightActors = this.world.getActorsByPredicate(actor => actor.getComponents(PointLightComponent).length > 0);
+        for (const lightActor of pointLightActors) {
+            const lightComponent = lightActor.getComponents(PointLightComponent)[0];
+            const lightPosition = lightActor.getWorldPosition();
+            lightSources.push({
+                position: lightPosition,
+                size: lightComponent.light?.distance ? lightComponent.light.distance * 0.1 : 1.0,
+                intensity: lightComponent.light?.intensity ?? 1.0,
+                color: lightComponent.light?.color ? new THREE.Vector3(lightComponent.light.color.r, lightComponent.light.color.g, lightComponent.light.color.b) : new THREE.Vector3(1, 1, 1)
+            });
+        }
+        // Collect spot lights
+        const spotLightActors = this.world.getActorsByPredicate(actor => actor.getComponents(SpotLightComponent).length > 0);
+        for (const lightActor of spotLightActors) {
+            const lightComponent = lightActor.getComponents(SpotLightComponent)[0];
+            const lightPosition = lightActor.getWorldPosition();
+            lightSources.push({
+                position: lightPosition,
+                size: lightComponent.light?.distance ? lightComponent.light.distance * 0.1 : 1.0,
+                intensity: lightComponent.light?.intensity ?? 1.0,
+                color: lightComponent.light?.color ? new THREE.Vector3(lightComponent.light.color.r, lightComponent.light.color.g, lightComponent.light.color.b) : new THREE.Vector3(1, 1, 1)
+            });
+        }
+        // Fallback to default light if no lights found
+        if (lightSources.length === 0) {
+            console.log('⚠️ getAllLightSources() no lights found, using fallback light');
+            lightSources.push({
+                position: new THREE.Vector3(10, 10, 10),
+                size: 0.5,
+                intensity: 1.0,
+                color: new THREE.Vector3(1, 1, 1)
+            });
+        }
+        console.log(`🔆 getAllLightSources() found ${lightSources.length} light sources`);
+        return lightSources;
+    }
+    /**
+     * Gets the primary light source for lightmapping (backwards compatibility)
+     */
+    getPrimaryLight() {
+        const lightSources = this.getAllLightSources();
+        return lightSources[0].position;
+    }
+    /**
+     * Applies lightmap textures to all meshes in actors
+     */
+    applyLightmaps(actors, lightmapTexture) {
+        let appliedCount = 0;
+        for (const actor of actors) {
+            const meshes = this.getMeshesFromActor(actor);
+            for (const mesh of meshes) {
+                if (mesh.material) {
+                    const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+                    if (material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshLambertMaterial) {
+                        material.lightMap = lightmapTexture;
+                        material.lightMapIntensity = 2.5;
+                        material.lightMap.channel = 2;
+                        material.needsUpdate = true;
+                        appliedCount++;
+                    }
+                }
+            }
+        }
+        // Smart light management: hide only static lights, keep dynamic/mixed lights active
+        this.manageRuntimeLighting(true);
+    }
+    /**
+     * Manages runtime lighting based on lightmap state
+     * @param lightmapsActive Whether lightmaps are currently active
+     */
+    manageRuntimeLighting(lightmapsActive) {
+        const { staticLights, dynamicLights } = this.getLightsByType();
+        if (lightmapsActive) {
+            // Hide static lights (they're baked into lightmaps)
+            console.log('Lightmaps are active. Hiding static lights...');
+            staticLights.forEach(light => {
+                light.getLight().visible = false;
+            });
+            // Keep dynamic lights visible (for runtime effects)
+            dynamicLights.forEach(light => {
+                light.getLight().visible = true;
+            });
+        }
+        else {
+            console.log('Lightmaps are not active. Setting all lights to visible.');
+            // Show all lights when lightmaps are not active
+            [...staticLights, ...dynamicLights].forEach(light => {
+                light.getLight().visible = true;
+            });
+        }
+    }
+    /**
+     * Removes lightmaps from all actors
+     */
+    removeLightmaps() {
+        const actors = this.getStaticMeshActors();
+        for (const actor of actors) {
+            const meshes = this.getMeshesFromActor(actor);
+            for (const mesh of meshes) {
+                if (mesh.material) {
+                    const material = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+                    if (material instanceof THREE.MeshStandardMaterial || material instanceof THREE.MeshLambertMaterial) {
+                        material.lightMap = null;
+                        material.needsUpdate = true;
+                    }
+                }
+            }
+        }
+        // Restore all lights when lightmaps are removed
+        this.manageRuntimeLighting(false);
+        // Clean up textures and resources when removing lightmaps
+        this.cleanupTexturesAndResources();
+        console.log('Lightmaps removed and resources cleaned up');
+    }
+    /**
+     * Gets lights categorized by their usage type
+     * @returns Object containing arrays of static and dynamic lights
+     */
+    getLightsByType() {
+        const staticLights = [];
+        const dynamicLights = [];
+        // Get all actors in the world
+        const actors = this.world.getActors();
+        for (const actor of actors) {
+            // Get all light scene components from this actor
+            const directionalLights = actor.getComponents(DirectionalLightComponent);
+            const pointLights = actor.getComponents(PointLightComponent);
+            const spotLights = actor.getComponents(SpotLightComponent);
+            const rectAreaLights = actor.getComponents(RectAreaLightComponent);
+            const allLights = [...directionalLights, ...pointLights, ...spotLights, ...rectAreaLights];
+            for (const light of allLights) {
+                if (light.isLightmapBaked()) {
+                    staticLights.push(light);
+                }
+                else {
+                    dynamicLights.push(light);
+                }
+            }
+        }
+        return { staticLights, dynamicLights };
+    }
+    /**
+     * Exports the last baked lightmap data without creating files
+     * @param baseFileName Base filename for the exported files (without extension)
+     * @param options Export options
+     * @returns Promise resolving to the lightmap data that can be handled by the caller
+     */
+    async exportLightmapData(baseFileName, options = {}) {
+        if (!this.lastBakedTexture || !this.lastBakedRenderTarget || !this.lastBakeOptions || this.lastBakedActors.length === 0) {
+            throw new Error('No lightmap data to export. Bake lightmaps first.');
+        }
+        // Create mesh mappings based on current UV coordinates
+        const meshes = [];
+        for (const actor of this.lastBakedActors) {
+            meshes.push(...this.getMeshesFromActor(actor));
+        }
+        const meshMappings = createMeshMappings(this.lastBakedActors, meshes);
+        const exportData = {
+            texture: this.lastBakedTexture,
+            renderTarget: this.lastBakedRenderTarget,
+            bakingOptions: this.lastBakeOptions,
+            meshMappings: meshMappings,
+            actors: this.lastBakedActors,
+            uv2Data: undefined, // No longer storing UV2 data for export
+        };
+        return LightmapSerializer.exportLightmapData(exportData, { baseFileName, ...options }, this.renderer);
+    }
+    /**
+     * Imports and applies lightmap from provided file data
+     * @param lightmapJsonData The parsed lightmap metadata JSON
+     * @param textureData The binary texture data as ArrayBuffer
+     * @param options Import options
+     * @returns Promise resolving to the import result
+     */
+    async importLightmap(lightmapJsonData, textureData, options = {}) {
+        try {
+            // Ensure the lightmap manager is properly initialized before import
+            if (!this.atlas || !this.baker) {
+                options.onProgress?.('initializing', 5);
+                await this.initialize();
+            }
+            const importResult = await LightmapSerializer.importLightmap(lightmapJsonData, textureData, options);
+            // Apply the imported lightmap to matching actors
+            const meshActors = this.getStaticMeshActors();
+            // Debug: Check mesh counts per actor
+            const importMeshCounts = {};
+            const importTotalMeshes = [];
+            for (const actor of meshActors) {
+                const meshes = this.getMeshesFromActor(actor);
+                importMeshCounts[actor.uuid] = meshes.length;
+                importTotalMeshes.push(...meshes);
+            }
+            if (meshActors.length > 0) {
+                // Instead of restoring UV2 coordinates (which are inconsistent due to XAtlas),
+                // regenerate them using the same process as during baking
+                const allMeshes = [];
+                for (const actor of meshActors) {
+                    const actorMeshes = this.getMeshesFromActor(actor);
+                    const bakingMeshes = actorMeshes.filter(mesh => mesh.material && mesh.visible);
+                    allMeshes.push(...bakingMeshes);
+                }
+                if (allMeshes.length > 0 && this.baker) {
+                    // Regenerate UV2 coordinates using the same process as baking
+                    const deInterleavedMeshes = allMeshes.map(mesh => {
+                        const clonedGeometry = mesh.geometry.clone();
+                        deinterleaveGeometry(clonedGeometry);
+                        mesh.geometry = clonedGeometry;
+                        return mesh;
+                    });
+                    await this.baker.prepareMeshes(deInterleavedMeshes);
+                }
+                this.applyLightmaps(meshActors, importResult.texture);
+            }
+            // Store the imported data
+            this.lastBakedTexture = importResult.texture;
+            this.lastBakeOptions = importResult.bakingOptions;
+            this.lastBakedActors = meshActors;
+            options.onProgress?.('complete', 100);
+            return importResult;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (options.throwOnError !== false) {
+                // Default behavior: throw the error
+                throw new Error(`Failed to import lightmap: ${errorMessage}`);
+            }
+            else {
+                // Optional behavior: log and return null for graceful handling
+                console.warn('Failed to import lightmap:', errorMessage);
+                return null;
+            }
+        }
+    }
+    /**
+     * Gets the path where the lightmap would be saved for a given scene
+     * @param scenePath Path to the scene file
+     * @returns Path to the corresponding lightmap file
+     */
+    getLightmapPath(scenePath) {
+        return LightmapSerializer.getLightmapPath(scenePath);
+    }
+    /**
+     * Checks if lightmap data is available for export
+     * @returns True if lightmap data is ready for export
+     */
+    hasLightmapData() {
+        return this.lastBakedTexture !== null && this.lastBakeOptions !== null && this.lastBakedActors.length > 0;
+    }
+    /**
+     * Gets the last baked lightmap texture for debugging purposes
+     */
+    getLastBakedTexture() {
+        return this.lastBakedTexture;
+    }
+    /**
+     * Gets the lightmap baker instance for debugging purposes
+     */
+    getBaker() {
+        return this.baker;
+    }
+    /**
+     * Cleans up resources
+     */
+    dispose() {
+        // Use the comprehensive cleanup method
+        this.cleanupTexturesAndResources();
+        // Clear the atlas reference
+        this.atlas = null;
+        console.log('LightmapManager disposed');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LightmapManager.js","sourceRoot":"","sources":["../../../../src/render/lightmapping/LightmapManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,iDAAiD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAC9I,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAGlE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AA+B7D;;;;;;;;GAQG;AACH,MAAM,OAAO,eAAe;IAW1B,YACE,KAAY,EACZ,QAA6B,EAC7B,UAAkC,EAAE;QAb9B;;;;;WAAa;QACb;;;;;WAA8B;QAC9B;;;;;WAAgC;QAChC;;;;mBAA8B,IAAI;WAAC;QACnC;;;;mBAA8B,IAAI;WAAC;QACnC;;;;mBAAyC,IAAI;WAAC;QAC9C;;;;mBAAwD,IAAI;WAAC;QAC7D;;;;mBAA8C,IAAI;WAAC;QACnD;;;;mBAAgC,EAAE;WAAC;QAOzC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG;YACb,uBAAuB;YACvB,UAAU,EAAE,GAAG;YACf,KAAK,EAAE,EAAE;YACT,UAAU,EAAE,KAAK,CAAC,YAAY;YAC9B,kBAAkB,EAAE,IAAI;YACxB,oBAAoB,EAAE,KAAK;YAC3B,mBAAmB,EAAE,KAAK;YAC1B,eAAe,EAAE,IAAI;YACrB,kBAAkB,EAAE,GAAG;YACvB,2FAA2F;YAC3F,oEAAoE;YACpE,4BAA4B;YAC5B,iBAAiB,EAAE,KAAK;YACxB,SAAS,EAAE,IAAI;YACf,iBAAiB,EAAE,IAAI;YACvB,GAAG,OAAO;SACX,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,UAAU;QACrB,IAAI,CAAC;YACH,IAAI,CAAC,KAAK,GAAG,IAAI,aAAa,EAAE,CAAC;YACjC,IAAI,CAAC,KAAK,GAAG,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC9C,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC;QACnC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,wCAAwC,EAAE,KAAK,CAAC,CAAC;YAC9D,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,2BAA2B;QACjC,OAAO,CAAC,GAAG,CAAC,gEAAgE,CAAC,CAAC;QAE9E,0DAA0D;QAC1D,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;YAChD,IAAI,WAAW,EAAE,CAAC;gBAChB,IAAI,WAAW,CAAC,eAAe,EAAE,CAAC;oBAChC,WAAW,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;oBACtC,OAAO,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAC;gBACjD,CAAC;gBACD,IAAI,WAAW,CAAC,aAAa,EAAE,CAAC;oBAC9B,WAAW,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;oBACpC,OAAO,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;gBAC/C,CAAC;YACH,CAAC;YACD,wDAAwD;YACxD,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACvB,CAAC;QAED,6CAA6C;QAC7C,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,CAAC;YACrC,OAAO,CAAC,GAAG,CAAC,0CAA0C,CAAC,CAAC;YACxD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QACpC,CAAC;QAED,yGAAyG;QACzG,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,OAAO,CAAC,GAAG,CAAC,6CAA6C,CAAC,CAAC;YAC3D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC/B,CAAC;QAED,qDAAqD;QACrD,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpC,OAAO,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAC;QAC3D,CAAC;QAED,mBAAmB;QACnB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAE1B,sCAAsC;QACtC,IAAI,CAAC,KAAK,KAAK,IAAI,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAEhD,OAAO,CAAC,GAAG,CAAC,uDAAuD,CAAC,CAAC;IACvE,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,aAAa,CACxB,UAAwC,EAAE,EAC1C,UAAqC;QAErC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;QAC/E,CAAC;QAED,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QACpC,UAAU,EAAE,CAAC,WAAW,EAAE,CAAC,EAAE,iCAAiC,CAAC,CAAC;QAEhE,mEAAmE;QACnE,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAEnC,0CAA0C;QAC1C,oDAAoD;QAEpD,0CAA0C;QAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC9C,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;YAC5C,OAAO;QACT,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAC7D,mEAAmE;QACnE,MAAM,SAAS,GAAiB,EAAE,CAAC;QACnC,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;YAC/B,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAEnD,+EAA+E;YAC/E,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;gBAC7C,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,CAAC;YACvC,CAAC,CAAC,CAAC;YACH,SAAS,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC;QAClC,CAAC;QAED,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;YACjD,OAAO;QACT,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;QACvD,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;QACxC,MAAM,mBAAmB,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YAC/C,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YAC7C,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC;YAC/B,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;QAC7C,8CAA8C;QAC9C,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,EAAE,oDAAoD,CAAC,CAAC;QAChF,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;QAEpD,iBAAiB;QACjB,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;QACnC,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,EAAE,8BAA8B,CAAC,CAAC;QAC1D,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,mBAAmB,EAAE;YAC5C,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,UAAW;YAC1D,GAAG,OAAO,CAAC,YAAY;SACxB,CAAC,CAAC;QAEH,mCAAmC;QACnC,MAAM,WAAW,GAAwB;YACvC,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,UAAW;YAC1D,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,KAAM;YAC3C,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,UAAW;YAC1D,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAmB;YAClF,oBAAoB,EAAE,OAAO,CAAC,oBAAoB,IAAI,IAAI,CAAC,OAAO,CAAC,oBAAqB;YACxF,mBAAmB,EAAE,OAAO,CAAC,mBAAmB,IAAI,IAAI,CAAC,OAAO,CAAC,mBAAoB;YACrF,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,IAAI,CAAC,OAAO,CAAC,eAAgB;YACzE,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAmB;YAClF,YAAY,EAAE,OAAO,CAAC,YAAY,IAAI,IAAI,CAAC,kBAAkB,EAAE;SAChE,CAAC;QAGF,gBAAgB;QAChB,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE,EAAE,oBAAoB,CAAC,CAAC;QACjD,IAAI,eAAwC,CAAC;QAC7C,IAAI,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC;YACnC,qBAAqB;YACrB,OAAO,CAAC,GAAG,CAAC,2CAA2C,EAAE,WAAW,CAAC,CAAC;YACtE,eAAe,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,uBAAuB,CACxD,mBAAmB,EACnB,WAAW,EACX,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE;gBACtB,MAAM,QAAQ,GAAG,EAAE,GAAG,CAAC,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC;gBAClD,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,aAAa,OAAO,IAAI,UAAU,UAAU,CAAC,CAAC;YACjF,CAAC,CACF,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,2CAA2C;YAC3C,OAAO,CAAC,GAAG,CAAC,2CAA2C,EAAE,WAAW,CAAC,CAAC;YACtE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;YACpD,MAAM,OAAO,GAAG,WAAW,CAAC,kBAAkB,IAAI,IAAI,CAAC,OAAO,CAAC,kBAAkB,IAAI,GAAG,CAAC;YACzF,uDAAuD;YACvD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;gBACjC,MAAM,CAAC,MAAM,EAAE,CAAC;gBAChB,+BAA+B;gBAC/B,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC;oBACjB,MAAM,QAAQ,GAAG,EAAE,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;oBACzC,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,aAAa,CAAC,GAAG,CAAC,IAAI,OAAO,UAAU,CAAC,CAAC;gBAC5E,CAAC;YACH,CAAC;YACD,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC3C,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAE5B,2EAA2E;QAC3E,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAC,OAAO,CAAC;QAChD,IAAI,CAAC,qBAAqB,GAAG,eAAe,CAAC;QAC7C,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACnC,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC;QAElC,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC;QAClC,MAAM,QAAQ,GAAG,CAAC,OAAO,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC;QAE9C,UAAU,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,gCAAgC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAEtF,iDAAiD;QACjD,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YAC3B,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;YAClC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;QAC3D,CAAC;aAAK,CAAC;YACL,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,mBAAmB;QACxB,OAAO,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE;YAC7C,2EAA2E;YAC3E,MAAM,cAAc,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;YAEjE,oEAAoE;YACpE,OAAO,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;gBACzC,MAAM,cAAc,GAAG,aAAa,CAAC,iBAAiB,EAAE,CAAC;gBACzD,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,IAAI,iBAAiB,CAAC,MAAM,CAAC;gBAC1E,OAAO,UAAU,KAAK,iBAAiB,CAAC,MAAM,CAAC;YACjD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,6BAA6B,CAAC,KAAiB;QACrD,MAAM,cAAc,GAA0C,EAAE,CAAC;QAEjE,kDAAkD;QAClD,MAAM,cAAc,GAAG,CAAC,SAAc,EAAE,EAAE;YACxC,8CAA8C;YAC9C,IAAI,SAAS,YAAY,aAAa,IAAI,SAAS,YAAY,iBAAiB,EAAE,CAAC;gBACjF,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACjC,CAAC;YAED,iCAAiC;YACjC,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;gBACvB,KAAK,MAAM,KAAK,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;oBACvC,cAAc,CAAC,KAAK,CAAC,CAAC;gBACxB,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QAEF,4BAA4B;QAC5B,MAAM,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAC1C,IAAI,aAAa,EAAE,CAAC;YAClB,cAAc,CAAC,aAAa,CAAC,CAAC;QAChC,CAAC;QAED,iFAAiF;QACjF,IAAI,KAAK,YAAY,aAAa,EAAE,CAAC;YACnC,MAAM,aAAa,GAAG,KAAK,CAAC,gBAAgB,EAAE,CAAC;YAC/C,IAAI,aAAa,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC7D,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,kBAAkB,CAAC,KAAiB;QACzC,MAAM,MAAM,GAAiB,EAAE,CAAC;QAChC,MAAM,cAAc,GAAG,IAAI,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC;QACjE,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YAC3C,IAAI,aAAa,YAAY,iBAAiB,EAAE,CAAC;gBAC/C,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;gBACvC,IAAI,KAAK,EAAE,CAAC;oBACV,KAAK,CAAC,QAAQ,CAAC,CAAC,KAAqB,EAAE,EAAE;wBACvC,IAAI,KAAK,YAAY,KAAK,CAAC,IAAI,EAAE,CAAC;4BAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;wBACrB,CAAC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;QAED,6CAA6C;QAC7C,MAAM,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAC1C,IAAI,aAAa,YAAY,aAAa,EAAE,CAAC;YAC3C,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC;YACrC,IAAI,IAAI,EAAE,CAAC;gBACT,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACI,kBAAkB;QAMvB,MAAM,YAAY,GAKb,EAAE,CAAC;QAER,6BAA6B;QAC7B,MAAM,sBAAsB,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE,CACrE,KAAK,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC,MAAM,GAAG,CAAC,CAC1D,CAAC;QAEF,KAAK,MAAM,UAAU,IAAI,sBAAsB,EAAE,CAAC;YAChD,MAAM,cAAc,GAAG,UAAU,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9E,MAAM,aAAa,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC;YAEpD,YAAY,CAAC,IAAI,CAAC;gBAChB,QAAQ,EAAE,aAAa;gBACvB,IAAI,EAAE,GAAG;gBACT,SAAS,EAAG,cAAsB,CAAC,KAAK,EAAE,SAAS,IAAI,GAAG;gBAC1D,KAAK,EAAG,cAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAC5D,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACpC,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACpC,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CACtC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAC/B,CAAC,CAAC;QACL,CAAC;QAED,uBAAuB;QACvB,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAC/D,KAAK,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,MAAM,GAAG,CAAC,CACpD,CAAC;QAEF,KAAK,MAAM,UAAU,IAAI,gBAAgB,EAAE,CAAC;YAC1C,MAAM,cAAc,GAAG,UAAU,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;YACxE,MAAM,aAAa,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC;YAEpD,YAAY,CAAC,IAAI,CAAC;gBAChB,QAAQ,EAAE,aAAa;gBACvB,IAAI,EAAG,cAAsB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAE,cAAsB,CAAC,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG;gBAClG,SAAS,EAAG,cAAsB,CAAC,KAAK,EAAE,SAAS,IAAI,GAAG;gBAC1D,KAAK,EAAG,cAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAC5D,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACpC,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACpC,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CACtC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAC/B,CAAC,CAAC;QACL,CAAC;QAED,sBAAsB;QACtB,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAC9D,KAAK,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,MAAM,GAAG,CAAC,CACnD,CAAC;QAEF,KAAK,MAAM,UAAU,IAAI,eAAe,EAAE,CAAC;YACzC,MAAM,cAAc,GAAG,UAAU,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,MAAM,aAAa,GAAG,UAAU,CAAC,gBAAgB,EAAE,CAAC;YAEpD,YAAY,CAAC,IAAI,CAAC;gBAChB,QAAQ,EAAE,aAAa;gBACvB,IAAI,EAAG,cAAsB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAE,cAAsB,CAAC,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG;gBAClG,SAAS,EAAG,cAAsB,CAAC,KAAK,EAAE,SAAS,IAAI,GAAG;gBAC1D,KAAK,EAAG,cAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAC5D,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACpC,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACpC,cAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CACtC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAC/B,CAAC,CAAC;QACL,CAAC;QAED,+CAA+C;QAC/C,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,+DAA+D,CAAC,CAAC;YAC7E,YAAY,CAAC,IAAI,CAAC;gBAChB,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;gBACvC,IAAI,EAAE,GAAG;gBACT,SAAS,EAAE,GAAG;gBACd,KAAK,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAClC,CAAC,CAAC;QACL,CAAC;QAED,OAAO,CAAC,GAAG,CAAC,iCAAiC,YAAY,CAAC,MAAM,gBAAgB,CAAC,CAAC;QAClF,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,eAAe;QACpB,MAAM,YAAY,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC/C,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,MAAoB,EAAE,eAA8B;QACxE,IAAI,YAAY,GAAG,CAAC,CAAC;QAErB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAC9C,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;gBAC1B,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAClB,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;oBACjF,IAAI,QAAQ,YAAY,KAAK,CAAC,oBAAoB,IAAI,QAAQ,YAAY,KAAK,CAAC,mBAAmB,EAAE,CAAC;wBACpG,QAAQ,CAAC,QAAQ,GAAG,eAAe,CAAC;wBACpC,QAAQ,CAAC,iBAAiB,GAAG,GAAG,CAAC;wBACjC,QAAQ,CAAC,QAAQ,CAAC,OAAO,GAAG,CAAC,CAAC;wBAC9B,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC;wBAC5B,YAAY,EAAE,CAAC;oBACjB,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,oFAAoF;QACpF,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;OAGG;IACI,qBAAqB,CAAC,eAAwB;QACnD,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QAE/D,IAAI,eAAe,EAAE,CAAC;YACpB,oDAAoD;YACpD,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;YAC7D,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAC3B,KAAK,CAAC,QAAQ,EAAE,CAAC,OAAO,GAAG,KAAK,CAAC;YACnC,CAAC,CAAC,CAAC;YAEH,oDAAoD;YACpD,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAC5B,KAAK,CAAC,QAAQ,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC;YAClC,CAAC,CAAC,CAAC;QAGL,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,0DAA0D,CAAC,CAAC;YACxE,gDAAgD;YAChD,CAAC,GAAG,YAAY,EAAE,GAAG,aAAa,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBAClD,KAAK,CAAC,QAAQ,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC;YAClC,CAAC,CAAC,CAAC;QAGL,CAAC;IACH,CAAC;IAED;;OAEG;IACI,eAAe;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC1C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;YAC9C,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;gBAC1B,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAClB,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;oBACjF,IAAI,QAAQ,YAAY,KAAK,CAAC,oBAAoB,IAAI,QAAQ,YAAY,KAAK,CAAC,mBAAmB,EAAE,CAAC;wBACpG,QAAQ,CAAC,QAAQ,GAAG,IAAI,CAAC;wBACzB,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAC;oBAC9B,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,gDAAgD;QAChD,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAElC,0DAA0D;QAC1D,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAEnC,OAAO,CAAC,GAAG,CAAC,4CAA4C,CAAC,CAAC;IAC5D,CAAC;IAID;;;OAGG;IACI,eAAe;QACpB,MAAM,YAAY,GAA+B,EAAE,CAAC;QACpD,MAAM,aAAa,GAA+B,EAAE,CAAC;QAErD,8BAA8B;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC;QAEtC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,iDAAiD;YACjD,MAAM,iBAAiB,GAAG,KAAK,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC;YACzE,MAAM,WAAW,GAAG,KAAK,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;YAC7D,MAAM,UAAU,GAAG,KAAK,CAAC,aAAa,CAAC,kBAAkB,CAAC,CAAC;YAC3D,MAAM,cAAc,GAAG,KAAK,CAAC,aAAa,CAAC,sBAAsB,CAAC,CAAC;YAEnE,MAAM,SAAS,GAAG,CAAC,GAAG,iBAAiB,EAAE,GAAG,WAAW,EAAE,GAAG,UAAU,EAAE,GAAG,cAAc,CAAC,CAAC;YAE3F,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;gBAC9B,IAAI,KAAK,CAAC,eAAe,EAAE,EAAE,CAAC;oBAC5B,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC3B,CAAC;qBAAM,CAAC;oBACN,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,kBAAkB,CAAC,YAAqB,EAAE,UAA0C,EAAE;QACjG,IAAI,CAAC,IAAI,CAAC,gBAAgB,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,CAAC,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxH,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;QACvE,CAAC;QAED,uDAAuD;QACvD,MAAM,MAAM,GAAiB,EAAE,CAAC;QAChC,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;QACjD,CAAC;QACD,MAAM,YAAY,GAAG,kBAAkB,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;QAEtE,MAAM,UAAU,GAAuB;YACrC,OAAO,EAAE,IAAI,CAAC,gBAAgB;YAC9B,YAAY,EAAE,IAAI,CAAC,qBAAqB;YACxC,aAAa,EAAE,IAAI,CAAC,eAAe;YACnC,YAAY,EAAE,YAAY;YAC1B,MAAM,EAAE,IAAI,CAAC,eAAe;YAC5B,OAAO,EAAE,SAAS,EAAE,wCAAwC;SAC7D,CAAC;QAEF,OAAO,kBAAkB,CAAC,kBAAkB,CAAC,UAAU,EAAE,EAAE,YAAY,EAAE,GAAG,OAAO,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACxG,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,cAAc,CACzB,gBAAqB,EACrB,WAAwB,EACxB,UAII,EAAE;QAEN,IAAI,CAAC;YACH,oEAAoE;YACpE,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBAC/B,OAAO,CAAC,UAAU,EAAE,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;gBACxC,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;YAC1B,CAAC;YAED,MAAM,YAAY,GAAG,MAAM,kBAAkB,CAAC,cAAc,CAAC,gBAAgB,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC;YAErG,iDAAiD;YACjD,MAAM,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC9C,qCAAqC;YACrC,MAAM,gBAAgB,GAA2B,EAAE,CAAC;YACpD,MAAM,iBAAiB,GAAiB,EAAE,CAAC;YAC3C,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;gBAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;gBAC9C,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;gBAC7C,iBAAiB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;YACpC,CAAC;YAED,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC1B,+EAA+E;gBAC/E,0DAA0D;gBAC1D,MAAM,SAAS,GAAiB,EAAE,CAAC;gBACnC,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;oBAC/B,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;oBACnD,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;oBAC/E,SAAS,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC;gBAClC,CAAC;gBAED,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;oBACvC,8DAA8D;oBAC9D,MAAM,mBAAmB,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;wBAC/C,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;wBAC7C,oBAAoB,CAAC,cAAc,CAAC,CAAC;wBACrC,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC;wBAC/B,OAAO,IAAI,CAAC;oBACd,CAAC,CAAC,CAAC;oBACH,MAAM,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,mBAAmB,CAAC,CAAC;gBACtD,CAAC;gBAED,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;YACxD,CAAC;YAED,0BAA0B;YAC1B,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,OAAO,CAAC;YAC7C,IAAI,CAAC,eAAe,GAAG,YAAY,CAAC,aAAa,CAAC;YAClD,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC;YAElC,OAAO,CAAC,UAAU,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;YACtC,OAAO,YAAY,CAAC;QAEtB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC;YAE9E,IAAI,OAAO,CAAC,YAAY,KAAK,KAAK,EAAE,CAAC;gBACnC,oCAAoC;gBACpC,MAAM,IAAI,KAAK,CAAC,8BAA8B,YAAY,EAAE,CAAC,CAAC;YAChE,CAAC;iBAAM,CAAC;gBACN,+DAA+D;gBAC/D,OAAO,CAAC,IAAI,CAAC,4BAA4B,EAAE,YAAY,CAAC,CAAC;gBACzD,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;IAID;;;;OAIG;IACI,eAAe,CAAC,SAAiB;QACtC,OAAO,kBAAkB,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED;;;OAGG;IACI,eAAe;QACpB,OAAO,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,IAAI,CAAC,eAAe,KAAK,IAAI,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;IAC5G,CAAC;IAED;;OAEG;IACI,mBAAmB;QACxB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED;;OAEG;IACI,QAAQ;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,uCAAuC;QACvC,IAAI,CAAC,2BAA2B,EAAE,CAAC;QAEnC,4BAA4B;QAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;IAC1C,CAAC;CACF"}