@directivegames/genesys.js 3.1.24

package/dist/src/physics/BasePhysicsEngine.js

@@ -0,0 +1,1227 @@
+/**
+ * BasePhysicsEngine supplies reusable logic for multiple physics backends.
+ *
+ * This class manages the collection of physics bodies associated with scene
+ * components and dispatches collision events back into Genesys. It defines a
+ * number of abstract `do*` methods which concrete engines implement to hook
+ * into their specific library. The engine also handles mesh simplification,
+ * terrain height field generation and character controller creation so derived
+ * classes only deal with low level data conversions.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Extend this class when adding support for a new physics library to inherit
+ *   consistent scene integration and body lifecycle handling.
+ * - Call `create` with `PhysicsOptions` to initialize and then `tick` each
+ *   frame to step the simulation.
+ * - Override methods like `doCreateBoxBody` or `doSetVectorParam` to translate
+ *   requests into library-specific calls.
+ * - Use `addComponent` to automatically determine body types from component
+ *   geometry or collision shapes.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import * as THREE from 'three';
+import { CollisionShapeComponent, CollisionShapeType } from '../components/CollisionShapeComponent.js';
+import { GLTFMeshComponent } from '../components/visual/GLTFMeshComponent.js';
+import { InstancedGltfMeshComponent } from '../components/visual/InstancedGltfMeshComponent.js';
+import { InstancedMeshComponent } from '../components/visual/InstancedMeshComponent.js';
+import { MeshComponent } from '../components/visual/MeshComponent.js';
+import { TerrainMeshComponent } from '../components/visual/TerrainMeshComponent.js';
+import { CollisionConfig } from '../systems/collision/CollisionConfig.js';
+import { CollisionMode } from '../systems/collision/CollisionTypes.js';
+import { ConsoleCommand } from '../systems/ConsoleManager.js';
+import { ensure } from '../utils/Utils.js';
+import { CollisionEventType } from './PhysicsEngine.js';
+import { CollisionMeshType, PhysicsMotionType } from './PhysicsTypes.js';
+export var JointType;
+(function (JointType) {
+    JointType["Spherical"] = "spherical";
+    JointType["Fixed"] = "fixed";
+    JointType["Revolute"] = "revolute";
+    JointType["Prismatic"] = "prismatic";
+})(JointType || (JointType = {}));
+export class BasePhysicsEngine {
+    constructor(gameWorld) {
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "bodies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "characterControllers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "joints", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        }); // Using string ID as key
+        Object.defineProperty(this, "directBodies", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        }); // Direct physics bodies by handle
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "nextJointId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "nextBodyId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        // Reference to the game world that owns this physics engine
+        Object.defineProperty(this, "gameWorld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "physicMeshesCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.gameWorld = gameWorld;
+        if (gameWorld) {
+            gameWorld?.consoleManager.addCommandHandler(this);
+        }
+    }
+    performHitTest(options) {
+        return []; // Override in derived class
+    }
+    debugPhysics(enable = '') {
+        // Use truthy value to enable debug visualization
+        if (enable === 'true' || enable === '1') {
+            this.setDebugRendererEnabled(true);
+        }
+        else {
+            this.setDebugRendererEnabled(false);
+        }
+        return 'Debug physics ' + (this.isDebugRendererEnabled() ? 'enabled' : 'disabled');
+    }
+    /**
+       * Initializes the physics engine with the specified options
+       * @param options Physics engine configuration options
+       * @returns Promise that resolves to true if initialization was successful
+       */
+    async create(options) {
+        if (!ensure(!this.initialized)) {
+            return false;
+        }
+        this.initialized = await this.doCreate(options);
+        this.options = options;
+        return this.initialized;
+    }
+    /**
+       * Get the physics engine options
+       * @returns Physics engine options
+       */
+    getOptions() {
+        return this.options;
+    }
+    /**
+       * Destroys the physics engine and cleans up resources
+       */
+    destroy() {
+        if (!this.initialized) {
+            return;
+        }
+        // Clean up all joints before destroying the physics world
+        for (const [jointId, jointRecord] of this.joints) {
+            this.doRemoveJoint(jointRecord);
+        }
+        this.joints.clear();
+        // Clean up all direct physics bodies
+        for (const [handle, record] of this.directBodies) {
+            this.doRemoveDirectBody(record);
+        }
+        this.directBodies.clear();
+        if (this.doDestroy()) {
+            this.initialized = false;
+        }
+        if (this.gameWorld) {
+            this.gameWorld?.consoleManager.removeCommandHandler(this);
+        }
+    }
+    /**
+       * Updates the physics simulation by one time step
+       * @param deltaTime Time elapsed since last tick in seconds
+       */
+    tick(deltaTime) {
+        if (!this.initialized) {
+            return;
+        }
+        // update component transform to the physics just before ticking
+        for (const component of this.bodies.keys()) {
+            component.syncToPhysics(this);
+        }
+        this.doTick(deltaTime);
+        this.processCollisionEvents();
+    }
+    cloneMesh(originalMesh) {
+        const clonedMesh = new THREE.Mesh(originalMesh.geometry.clone(), originalMesh.material);
+        return clonedMesh;
+    }
+    /**
+     * Processes a GLTF model to extract physics meshes with proper scaling and transforms
+     * @param model The GLTF scene model
+     * @returns Array of processed physics meshes. The meshes are always meshes at Identity, i.e. sitting at origin, no rotation, no scale
+     */
+    processGLTFModelForPhysics(model) {
+        // Collect all physics meshes
+        const physicsMeshes = [];
+        // we're now using the model template, so that means it is sitting at Identity, and we don't need to do any transforms to it.
+        // of course, while this saves the copy, we are expecting they NEVER get modified
+        model.traverse((object) => {
+            if (object instanceof THREE.Mesh) {
+                physicsMeshes.push(object);
+            }
+        });
+        return physicsMeshes;
+        // // alternative way is to clone all meshes, and apply the local to root transform to each mesh
+        // const worldToRootMatrix = model.matrixWorld.clone().invert();
+        // // Process all meshes in the cloned model
+        // model.traverse((object) => {
+        //   if (object instanceof THREE.Mesh) {
+        //     const physicsMesh = this.cloneMesh(object);
+        //     physicsMesh.matrixAutoUpdate = false;
+        //     // object local to world -> object local to root -> physics mesh is placed at Identity, so an extra `premultiply(Identity);` is omitted
+        //     const matrix = object.matrixWorld.clone().premultiply(worldToRootMatrix);
+        //     physicsMesh.matrix.copy(matrix);
+        //     physicsMesh.updateMatrixWorld(true);
+        //     physicsMeshes.push(physicsMesh);
+        //   }
+        // });
+        // // caching in this.physicMeshesCache
+        // return physicsMeshes;
+    }
+    /**
+     * Processes a model to extract physics mesh with proper scaling and transforms
+     * @param model The scene model
+     * @param worldScale The world scale to apply
+     * @returns Array of processed physics meshes. The meshes are always meshes at Identity, i.e. sitting at origin, no rotation, no scale
+     */
+    processModelForPhysics(mesh) {
+        const cacheKey = mesh.id;
+        if (this.physicMeshesCache.has(cacheKey)) {
+            return this.physicMeshesCache.get(cacheKey)[0];
+        }
+        const physicsMesh = this.cloneMesh(mesh);
+        physicsMesh.matrixAutoUpdate = false;
+        physicsMesh.matrix.copy(new THREE.Matrix4());
+        physicsMesh.updateMatrixWorld(true);
+        // cache it so we have the same physicsMesh always, which is good for cache of collider desc
+        this.physicMeshesCache.set(cacheKey, [physicsMesh]);
+        return physicsMesh;
+    }
+    /**
+       * Adds a scene component to the physics simulation
+       * @param component The scene component to add
+       * @returns The motion type assigned to the component, or null if addition failed
+       */
+    addComponent(component) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        if (!ensure(!this.bodies.has(component))) {
+            return null;
+        }
+        const physicsOptions = component.getPhysicsOptions();
+        const collisionConfig = CollisionConfig.getInstance();
+        const collisionProfile = collisionConfig.profiles.find(profile => profile.name === physicsOptions?.collisionProfile);
+        if (collisionProfile?.mode === CollisionMode.NoCollision) {
+            return null;
+        }
+        // FIXME: deprecate? Or should it be a combination of enabled and collisionProfile?
+        if (!physicsOptions?.enabled) {
+            return null;
+        }
+        let motionType = null;
+        const worldPos = new THREE.Vector3();
+        const worldQuat = new THREE.Quaternion();
+        const worldScale = new THREE.Vector3();
+        component.getWorldPosition(worldPos);
+        component.getWorldQuaternion(worldQuat);
+        component.getWorldScale(worldScale);
+        let records = [];
+        let record = null;
+        if (component instanceof (MeshComponent)) {
+            [record, motionType] = this.createMeshComponentRecord(component, physicsOptions, worldPos, worldQuat, worldScale);
+        }
+        else if (component instanceof (CollisionShapeComponent)) {
+            [record, motionType] = this.createCollisionShapeRecord(component, physicsOptions, worldPos, worldQuat, worldScale);
+        }
+        else if (component instanceof (TerrainMeshComponent)) {
+            [record, motionType] = this.createTerrainMeshRecord(component, physicsOptions, worldPos, worldQuat, worldScale);
+        }
+        else if (component instanceof (GLTFMeshComponent)) {
+            [record, motionType] = this.createGLTFMeshRecord(component, physicsOptions, worldPos, worldQuat, worldScale);
+        }
+        if (record) {
+            records.push(record);
+        }
+        if (component instanceof (InstancedGltfMeshComponent)) {
+            [records, motionType] = this.createInstancedGltfMeshRecord(component, physicsOptions, worldPos, worldQuat);
+        }
+        else if (component instanceof (InstancedMeshComponent)) {
+            [records, motionType] = this.createInstancedMeshRecord(component, physicsOptions, worldPos, worldQuat, worldScale);
+        }
+        if (records.length > 0) {
+            this.bodies.set(component, records);
+        }
+        return motionType;
+    }
+    /**
+     * Creates a physics record for a MeshComponent
+     * @param component The mesh component
+     * @param physicsOptions The physics options
+     * @param worldPos The world position
+     * @param worldQuat The world quaternion
+     * @param worldScale The world scale
+     * @returns [record, motionType] tuple
+     */
+    createMeshComponentRecord(component, physicsOptions, worldPos, worldQuat, worldScale) {
+        const mesh = component.getMesh();
+        if (!mesh) {
+            return [null, null];
+        }
+        const [records, motionType] = this.createMeshRecord(mesh, physicsOptions, [{ worldPos, worldQuat, worldScale }], component);
+        return [records.length > 0 ? records[0] : null, motionType];
+    }
+    /**
+     *
+     * @param mesh
+     * @param physicsOptions
+     * @param worldTransforms Array of world position, rotation, scale for each instance,
+     *                        NOTE: for voxels, it creates the voxels collision using the collisionData.voxels per transform.
+     *                        so be aware, most likely you only need to pass the component's transform
+     * @param context Optional context object for logging
+     * @returns
+     */
+    createMeshRecord(mesh, physicsOptions, worldTransforms, context) {
+        const records = [];
+        const motionType = physicsOptions?.motionType ?? PhysicsMotionType.Dynamic;
+        const geometry = mesh.geometry;
+        if (geometry instanceof (THREE.SphereGeometry) || geometry instanceof (THREE.DodecahedronGeometry) || geometry instanceof (THREE.IcosahedronGeometry)) {
+            // sphere
+            geometry.computeBoundingSphere();
+            for (const { worldPos, worldQuat, worldScale } of worldTransforms) {
+                // Apply world scale to radius
+                const scaleFactor = Math.max(worldScale.x, worldScale.y, worldScale.z);
+                const scaledRadius = geometry.boundingSphere.radius * scaleFactor;
+                const record = this.doCreateSphereBody({
+                    motionType,
+                    options: physicsOptions,
+                    worldPos,
+                    worldQuat,
+                    mass: this.calculateSphereMass(scaledRadius, physicsOptions?.density),
+                    center: geometry.boundingSphere.center,
+                    radius: scaledRadius,
+                });
+                records.push(record);
+            }
+        }
+        else if (geometry instanceof (THREE.CapsuleGeometry)) {
+            const capsuleParams = geometry.parameters;
+            for (const { worldPos, worldQuat, worldScale } of worldTransforms) {
+                // Apply world scale
+                const height = capsuleParams.height * worldScale.y;
+                const radius = capsuleParams.radius * Math.max(worldScale.x, worldScale.z);
+                const record = this.doCreateCapsuleBody({
+                    motionType,
+                    options: physicsOptions,
+                    worldPos,
+                    worldQuat,
+                    mass: this.calculateCapsuleMass(height, radius, physicsOptions?.density),
+                    height,
+                    radius,
+                });
+                records.push(record);
+            }
+        }
+        else if (geometry instanceof (THREE.ConeGeometry)) {
+            const coneParams = geometry.parameters;
+            for (const { worldPos, worldQuat, worldScale } of worldTransforms) {
+                // Apply world scale
+                const height = coneParams.height * worldScale.y;
+                const radius = coneParams.radius * Math.max(worldScale.x, worldScale.z);
+                const record = this.doCreateConeBody({
+                    motionType,
+                    options: physicsOptions,
+                    worldPos,
+                    worldQuat,
+                    mass: this.calculateConeMass(height, radius, physicsOptions?.density),
+                    height,
+                    radius,
+                });
+                records.push(record);
+            }
+        }
+        else if (geometry instanceof (THREE.CylinderGeometry)) {
+            const cylinderParams = geometry.parameters;
+            for (const { worldPos, worldQuat, worldScale } of worldTransforms) {
+                // Apply world scale
+                const height = cylinderParams.height * worldScale.y;
+                const radius = (cylinderParams.radiusTop + cylinderParams.radiusBottom) / 2 * Math.max(worldScale.x, worldScale.z);
+                const record = this.doCreateCylinderBody({
+                    motionType,
+                    options: physicsOptions,
+                    worldPos,
+                    worldQuat,
+                    mass: this.calculateCylinderMass(height, radius, physicsOptions?.density),
+                    height,
+                    radius,
+                });
+                records.push(record);
+            }
+        }
+        else if (physicsOptions?.collisionMeshType) {
+            // Use mesh collider for arbitrary geometry when collisionMeshType is specified
+            console.log('Using mesh collider for', context, 'with type', physicsOptions.collisionMeshType);
+            const isVoxelsCollision = physicsOptions.collisionMeshType === CollisionMeshType.Voxels;
+            if (isVoxelsCollision) {
+                const voxelsCollisionDesc = physicsOptions.collisionData?.voxels;
+                if (!voxelsCollisionDesc) {
+                    console.log('No voxel collision data provided, using default single voxel at origin. Either provide collisionData.voxels in constructor, or use `overridePhysicsOptions`/`replacePhysicsOptions` to set it later.');
+                }
+                if (worldTransforms.length > 1) {
+                    console.warn('Multiple transforms provided for voxel mesh collision, each transform will create a full voxel body based on `collisionData.voxels`.');
+                }
+                for (const { worldPos, worldQuat, worldScale } of worldTransforms) {
+                    const voxelSize = voxelsCollisionDesc?.voxelSize ?? new THREE.Vector3(1, 1, 1);
+                    const voxels = voxelsCollisionDesc?.coordinates ?? new Int32Array([0, 0, 0]);
+                    const voxelCount = voxels.length / 3;
+                    const mass = this.calculateBoxMass(voxelSize, physicsOptions?.density) * voxelCount;
+                    const record = this.doCreateVoxelBody({
+                        motionType,
+                        options: physicsOptions,
+                        worldPos,
+                        worldQuat,
+                        mass,
+                        voxels,
+                        voxelSize,
+                        offset: voxelsCollisionDesc?.offset,
+                    });
+                    records.push(record);
+                }
+            }
+            else {
+                // Non-Voxel, build the collision from the mesh geometry
+                const physicsMesh = this.processModelForPhysics(mesh);
+                const transforms = worldTransforms.map(t => ({ position: t.worldPos, rotation: t.worldQuat, scale: t.worldScale }));
+                // Now create the physics body at the component's world position/rotation
+                records.push(...this.doCreateMeshBodiesWithTransformOverrides({
+                    motionType,
+                    options: physicsOptions,
+                    worldPos: new THREE.Vector3(), // transforms will provide the position/rotation overrides
+                    worldQuat: new THREE.Quaternion(), // same as above
+                    mass: this.calculateMeshMass(physicsMesh.geometry, physicsOptions?.density),
+                    meshes: [physicsMesh],
+                }, transforms));
+            }
+        }
+        else {
+            // box
+            for (const { worldPos, worldQuat, worldScale } of worldTransforms) {
+                const size = new THREE.Vector3();
+                mesh.geometry.computeBoundingBox();
+                mesh.geometry.boundingBox.getSize(size);
+                // Apply world scale to size
+                size.multiply(worldScale);
+                const record = this.doCreateBoxBody({
+                    motionType,
+                    options: physicsOptions,
+                    worldPos,
+                    worldQuat,
+                    mass: this.calculateBoxMass(size, physicsOptions?.density),
+                    size,
+                });
+                records.push(record);
+            }
+        }
+        return [records, motionType];
+    }
+    /**
+     * Creates a physics record for a CollisionShapeComponent
+     * @param component The collision shape component
+     * @param physicsOptions The physics options
+     * @param worldPos The world position
+     * @param worldQuat The world quaternion
+     * @param worldScale The world scale
+     * @returns [record, motionType] tuple
+     */
+    createCollisionShapeRecord(component, physicsOptions, worldPos, worldQuat, worldScale) {
+        const motionType = physicsOptions?.motionType ?? PhysicsMotionType.Dynamic;
+        const shapeType = component.getShapeType();
+        let record;
+        if (shapeType === CollisionShapeType.Sphere) {
+            // For sphere, use the maximum scale component as radius
+            // CollisionShapeComponent creates unit-sized shapes that are scaled by the transform
+            const radius = Math.max(worldScale.x, worldScale.y, worldScale.z);
+            record = this.doCreateSphereBody({
+                motionType,
+                options: physicsOptions,
+                worldPos,
+                worldQuat,
+                mass: this.calculateSphereMass(radius, physicsOptions?.density),
+                center: new THREE.Vector3(0, 0, 0),
+                radius: radius,
+            });
+        }
+        else {
+            // Cube or default
+            // CollisionShapeComponent creates unit-sized shapes (1x1x1) that are scaled by the transform
+            // So the final size is simply the world scale
+            const size = worldScale.clone();
+            record = this.doCreateBoxBody({
+                motionType,
+                options: physicsOptions,
+                worldPos,
+                worldQuat,
+                mass: this.calculateBoxMass(size, physicsOptions?.density),
+                size,
+            });
+        }
+        return [record, motionType];
+    }
+    /**
+     * Creates a physics record for a TerrainMeshComponent
+     * @param component The terrain mesh component
+     * @param physicsOptions The physics options
+     * @param worldPos The world position
+     * @param worldQuat The world quaternion
+     * @param worldScale The world scale
+     * @returns [record, motionType] tuple
+     */
+    createTerrainMeshRecord(component, physicsOptions, worldPos, worldQuat, worldScale) {
+        const heightMap = component.getHeightMap();
+        // Apply world scale to terrain dimensions
+        const width = component.options.width * worldScale.x;
+        const depth = component.options.depth * worldScale.z;
+        const widthPixels = component.options.widthSegments + 1;
+        const depthPixels = component.options.depthSegments + 1;
+        const numPixels = widthPixels * depthPixels;
+        if (!ensure(heightMap)) {
+            return [null, null];
+        }
+        else if (!ensure(heightMap.length === numPixels)) {
+            return [null, null];
+        }
+        // Scale the height values
+        const scaledHeightMap = new Float32Array(heightMap.length);
+        for (let i = 0; i < heightMap.length; i++) {
+            scaledHeightMap[i] = heightMap[i] * worldScale.y;
+        }
+        const motionType = PhysicsMotionType.Static;
+        const record = this.doCreateHeightFieldBody({
+            motionType,
+            options: physicsOptions,
+            worldPos,
+            worldQuat,
+            mass: 0,
+            width,
+            depth,
+            widthPixels,
+            depthPixels,
+            heights: scaledHeightMap,
+        });
+        return [record, motionType];
+    }
+    /**
+     * Creates a physics record for a GLTFMeshComponent
+     * @param component The GLTF mesh component
+     * @param physicsOptions The physics options
+     * @param worldPos The world position
+     * @param worldQuat The world quaternion
+     * @param worldScale The world scale
+     * @returns [record, motionType] tuple
+     */
+    createGLTFMeshRecord(component, physicsOptions, worldPos, worldQuat, worldScale) {
+        // Only proceed if the model is loaded
+        if (!component.isModelLoaded()) {
+            return [null, null];
+        }
+        const motionType = physicsOptions?.motionType ?? PhysicsMotionType.Dynamic;
+        const model = component.getModelTemplate(); // use model template as that's the copy living in resource manager and making it easy for cache
+        let record = null;
+        const isVoxelsCollision = physicsOptions?.collisionMeshType === CollisionMeshType.Voxels;
+        if (isVoxelsCollision) {
+            const voxelsCollisionDesc = physicsOptions.collisionData?.voxels;
+            if (!voxelsCollisionDesc) {
+                console.log('No voxel collision data provided, using default single voxel at origin. Either provide collisionData.voxels in constructor, or use `overridePhysicsOptions`/`replacePhysicsOptions` to set it later.');
+            }
+            const voxelSize = voxelsCollisionDesc?.voxelSize ?? new THREE.Vector3(1, 1, 1);
+            const voxels = voxelsCollisionDesc?.coordinates ?? new Int32Array([0, 0, 0]);
+            const voxelCount = voxels.length / 3;
+            const mass = this.calculateBoxMass(voxelSize, physicsOptions?.density) * voxelCount;
+            record = this.doCreateVoxelBody({
+                motionType,
+                options: physicsOptions,
+                worldPos,
+                worldQuat,
+                mass,
+                voxels,
+                voxelSize,
+                offset: voxelsCollisionDesc?.offset,
+            });
+        }
+        else {
+            // Collect all meshes from the model and create a single combined physics body
+            if (model) {
+                // don't bother finding physics meshes for voxel collision, as it comes from the physicsOptions.collisionData provided by user
+                const physicsMeshes = this.processGLTFModelForPhysics(model);
+                // Create a single physics body for all meshes combined
+                if (physicsMeshes.length > 0) {
+                    record = this.doCreateMeshBody({
+                        motionType: motionType,
+                        options: physicsOptions,
+                        worldPos,
+                        worldQuat,
+                        mass: physicsMeshes.reduce((sum, mesh) => sum + this.calculateMeshMass(mesh.geometry, physicsOptions?.density), 0),
+                        meshes: physicsMeshes,
+                    }, worldScale);
+                    if (record) {
+                        // should contain only one record as there is only one worldPos and worldQuat
+                        console.log('Created combined physics body for GLTF model with', physicsMeshes.length, 'meshes');
+                    }
+                }
+            }
+        }
+        return [record, motionType];
+    }
+    /**
+     *
+     * @param component The instanced mesh component
+     * @param physicsOptions The physics options
+     * @param worldPos The world position
+     * @param worldQuat The world quaternion
+     * @param worldScale The world scale
+     * @returns
+     */
+    createInstancedMeshRecord(component, physicsOptions, worldPos, worldQuat, worldScale) {
+        let records = [];
+        const motionType = physicsOptions?.motionType ?? PhysicsMotionType.Dynamic;
+        const transforms = component.getInstancesTransforms(true);
+        const isVoxelsCollision = physicsOptions?.collisionMeshType === CollisionMeshType.Voxels;
+        const mesh = component.getInstancedMesh();
+        if (!mesh) {
+            return [[], null];
+        }
+        const instanceCount = component.getInstanceCount();
+        if (!instanceCount || instanceCount === 0) {
+            return [[], null];
+        }
+        const worldTransforms = isVoxelsCollision ? [{ worldPos, worldQuat, worldScale }] :
+            transforms.map(transform => ({
+                worldPos: transform.position ?? new THREE.Vector3(),
+                worldQuat: transform.rotation ? new THREE.Quaternion().setFromEuler(transform.rotation) : new THREE.Quaternion(),
+                worldScale: transform.scale ?? new THREE.Vector3(1, 1, 1)
+            }));
+        const [createdRecords,] = this.createMeshRecord(mesh, physicsOptions, worldTransforms, component);
+        records = createdRecords.filter(r => r !== null);
+        return [records, motionType];
+    }
+    /**
+     * Creates physics records for an InstancedGltfMeshComponent
+     * @param component The instanced GLTF mesh component
+     * @param physicsOptions The physics options
+     * @param worldScale The world scale
+     * @returns [records, motionType] tuple
+     */
+    createInstancedGltfMeshRecord(component, physicsOptions, worldPos, worldQuat) {
+        // Only proceed if the model is loaded (check if we have instanced meshes)
+        if (component.isLoading()) {
+            return [[], null];
+        }
+        const instancedMeshes = component.getInstancedMeshes();
+        if (!instancedMeshes || instancedMeshes.length === 0) {
+            return [[], null];
+        }
+        // Get the number of instances
+        const instanceCount = component.getInstanceCount();
+        if (!instanceCount || instanceCount === 0) {
+            return [[], null];
+        }
+        let records = [];
+        const motionType = physicsOptions?.motionType ?? PhysicsMotionType.Dynamic;
+        const isVoxelsCollision = physicsOptions?.collisionMeshType === CollisionMeshType.Voxels;
+        if (isVoxelsCollision) {
+            const voxelsCollisionDesc = physicsOptions.collisionData?.voxels;
+            if (!voxelsCollisionDesc) {
+                console.log('No voxel collision data provided, using default single voxel at origin. Either provide collisionData.voxels in constructor, or use `overridePhysicsOptions`/`replacePhysicsOptions` to set it later.');
+            }
+            const voxelSize = voxelsCollisionDesc?.voxelSize ?? new THREE.Vector3(1, 1, 1);
+            const voxels = voxelsCollisionDesc?.coordinates ?? new Int32Array([0, 0, 0]);
+            const voxelCount = voxels.length / 3;
+            const mass = this.calculateBoxMass(voxelSize, physicsOptions?.density) * voxelCount;
+            const record = this.doCreateVoxelBody({
+                motionType,
+                options: physicsOptions,
+                worldPos,
+                worldQuat,
+                mass,
+                voxels,
+                voxelSize,
+                offset: voxelsCollisionDesc?.offset,
+            });
+            if (record) {
+                records = [record];
+            }
+        }
+        else {
+            const model = component.getModelTemplate();
+            if (model) {
+                // Process the GLTF model to create physics meshes (same as regular GLTF)
+                const physicsMeshes = this.processGLTFModelForPhysics(model);
+                // Create physics bodies for the instances
+                if (physicsMeshes.length > 0) {
+                    const transforms = component.getInstancesTransforms(true);
+                    const paramTransforms = transforms.map(transform => ({
+                        position: transform.position ?? new THREE.Vector3(),
+                        rotation: transform.rotation ? new THREE.Quaternion().setFromEuler(transform.rotation) : new THREE.Quaternion(),
+                        scale: transform.scale ?? new THREE.Vector3(1, 1, 1)
+                    }));
+                    records = this.doCreateMeshBodiesWithTransformOverrides({
+                        motionType: motionType,
+                        options: physicsOptions,
+                        worldPos: paramTransforms[0].position,
+                        worldQuat: paramTransforms[0].rotation,
+                        // sum of all physicsMeshes
+                        mass: physicsMeshes.reduce((sum, mesh) => sum + this.calculateMeshMass(mesh.geometry, physicsOptions?.density), 0),
+                        meshes: physicsMeshes,
+                    }, paramTransforms);
+                }
+            }
+        }
+        return [records, motionType];
+    }
+    /**
+       * Removes a scene component from the physics simulation
+       * @param component The scene component to remove
+       */
+    removeComponent(component) {
+        if (!ensure(this.initialized)) {
+            return;
+        }
+        const records = this.bodies.get(component);
+        if (!records) {
+            return;
+        }
+        records.forEach((record) => {
+            this.doRemoveComponent(record);
+        });
+        this.bodies.delete(component);
+    }
+    /**
+       * Updates the transform (position/rotation) of a physics body
+       * @param component The primitive component whose transform should be updated
+       */
+    updateTransform(component) {
+        if (!ensure(this.initialized)) {
+            return;
+        }
+        const records = this.bodies.get(component);
+        if (!records) {
+            return;
+        }
+        records.forEach((record) => {
+            this.doUpdateTransform(component, record);
+        });
+    }
+    /**
+       * Gets a scalar physics parameter value for a component
+       * @param component The scene component to query
+       * @param param The scalar parameter to get
+       * @returns The parameter value or null if not found
+       */
+    getScalarParam(component, param) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        const records = this.bodies.get(component);
+        if (!records || records.length === 0) {
+            return null;
+        }
+        return this.doGetScalarParam(records[0], param);
+    }
+    /**
+       * Sets a scalar physics parameter value for a component
+       * @param component The scene component to modify
+       * @param param The scalar parameter to set
+       * @param value The new parameter value
+       * @returns True if the parameter was set successfully
+       */
+    setScalarParam(component, param, value) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        const records = this.bodies.get(component);
+        if (!records) {
+            return false;
+        }
+        return this.doSetScalarParam(records, param, value);
+    }
+    /**
+       * Gets a vector physics parameter value for a component
+       * @param component The scene component to query
+       * @param param The vector parameter to get
+       * @returns The parameter value array or null if not found
+       */
+    getVectorParam(component, param) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        const records = this.bodies.get(component);
+        if (!records || records.length === 0) {
+            return null;
+        }
+        return this.doGetVectorParam(records[0], param);
+    }
+    /**
+       * Sets a vector physics parameter value for a component
+       * @param component The scene component to modify
+       * @param param The vector parameter to set
+       * @param value The new parameter value array
+       * @returns True if the parameter was set successfully
+       */
+    setVectorParam(component, param, value) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        const records = this.bodies.get(component);
+        if (!records || records.length === 0) {
+            return false;
+        }
+        return records.reduce((acc, record) => acc && this.doSetVectorParam(record, param, value), true);
+    }
+    /**
+     * Clears a vector physics parameter value for a component
+     * @param component The scene component to modify
+     * @param param The vector parameter to clear
+     * @returns True if the parameter was cleared successfully
+     */
+    clearVectorParam(component, param) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        const records = this.bodies.get(component);
+        if (!records || records.length === 0) {
+            return false;
+        }
+        return records.reduce((acc, record) => acc && this.doClearVectorParam(record, param), true);
+    }
+    /**
+     * Create a character controller for a scene component
+     * @param movementComponent Component to create controller for
+     * @param options Character controller options
+     * @returns True if the character controller was created successfully, false otherwise
+     */
+    createCharacterController(movementComponent, options) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        if (!ensure(!this.characterControllers.has(movementComponent))) {
+            return false;
+        }
+        const record = this.doCreateCharacterController(options);
+        if (!record) {
+            return false;
+        }
+        this.characterControllers.set(movementComponent, record);
+        return true;
+    }
+    /**
+     * Remove a character controller for a scene component
+     * @param movementComponent Component to remove controller for
+     */
+    removeCharacterController(movementComponent) {
+        if (!ensure(this.initialized)) {
+            return;
+        }
+        const record = this.characterControllers.get(movementComponent);
+        if (!record) {
+            return;
+        }
+        if (this.doRemoveCharacterController(record)) {
+            this.characterControllers.delete(movementComponent);
+        }
+    }
+    /**
+     * Compute character movement for a scene component
+     * @param movementComponent Component to compute movement for
+     * @param componentToMove Component to move
+     * @param movement Movement vector [x, y, z]
+     */
+    computeCharacterMovement(movementComponent, componentToMove, movement, ignoreCollision) {
+        if (!ensure(this.initialized)) {
+            return { isGrounded: false };
+        }
+        const record = this.characterControllers.get(movementComponent);
+        if (!record) {
+            return { isGrounded: false };
+        }
+        const recordsToMove = this.bodies.get(componentToMove);
+        if (!recordsToMove || recordsToMove.length === 0) {
+            return { isGrounded: false };
+        }
+        // only handle recordsToMove[0] for now
+        return this.doComputeCharacterMovement(record, recordsToMove[0], movement, ignoreCollision);
+    }
+    /**
+     * Configure collision filtering between two components
+     * @param componentA First component
+     * @param componentB Second component
+     * @param ignore Whether componentA should ignore collisions with componentB
+     */
+    setComponentCollisionIgnore(componentA, componentB, ignore) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        const recordsA = this.bodies.get(componentA);
+        const recordsB = this.bodies.get(componentB);
+        if (!recordsA || !recordsB) {
+            return false;
+        }
+        let result = true;
+        for (const recordA of recordsA) {
+            for (const recordB of recordsB) {
+                result = result && this.doSetComponentCollisionIgnore(recordA, recordB, ignore);
+            }
+        }
+        return result;
+    }
+    /**
+     * Creates a joint between two physics bodies
+     * @param desc Joint description containing type, components, and connection points
+     * @returns Joint ID if successful, null if failed
+     */
+    createJoint(desc) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        const recordsA = this.bodies.get(desc.componentA);
+        const recordsB = this.bodies.get(desc.componentB);
+        if (!recordsA || !recordsB) {
+            console.error('Cannot create joint: one or both components not found in physics engine');
+            return null;
+        }
+        if (recordsA.length !== 1 || recordsB.length !== 1) {
+            console.error('Cannot create joint: one or both components have multiple or none body count');
+            return null;
+        }
+        const jointRecord = this.doCreateJoint(desc, recordsA[0], recordsB[0]);
+        if (!jointRecord) {
+            return null;
+        }
+        const jointId = `joint_${this.nextJointId++}`;
+        this.joints.set(jointId, jointRecord);
+        return jointId;
+    }
+    /**
+     * Removes a joint from the physics simulation
+     * @param jointId The joint ID returned from createJoint
+     * @returns True if the joint was successfully removed
+     */
+    removeJoint(jointId) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        const jointRecord = this.joints.get(jointId);
+        if (!jointRecord) {
+            return false;
+        }
+        if (this.doRemoveJoint(jointRecord)) {
+            this.joints.delete(jointId);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Gets all active joint IDs
+     * @returns Array of joint IDs
+     */
+    getActiveJoints() {
+        return Array.from(this.joints.keys());
+    }
+    /**
+     * Creates a joint directly from physics body records (for special cases like ragdoll)
+     * @param type Joint type
+     * @param recordA First physics body record
+     * @param recordB Second physics body record
+     * @param anchorA Anchor point on first body
+     * @param anchorB Anchor point on second body
+     * @param axis Optional axis for revolute/prismatic joints
+     * @returns Joint ID if successful, null if failed
+     */
+    createJointFromRecords(type, recordA, recordB, anchorA, anchorB, axis) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        const jointRecord = this.doCreateJointFromRecords(type, recordA, recordB, anchorA, anchorB, axis);
+        if (!jointRecord) {
+            return null;
+        }
+        const jointId = `joint_${this.nextJointId++}`;
+        this.joints.set(jointId, jointRecord);
+        return jointId;
+    }
+    // Direct physics body management methods (for special cases like ragdolls)
+    createPhysicsBody(desc) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        const record = this.doCreateDirectBody(desc);
+        if (!record) {
+            return null;
+        }
+        const handle = `body_${this.nextBodyId++}`;
+        this.directBodies.set(handle, record);
+        return handle;
+    }
+    removePhysicsBody(handle) {
+        if (!ensure(this.initialized)) {
+            return false;
+        }
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return false;
+        }
+        const success = this.doRemoveDirectBody(record);
+        if (success) {
+            this.directBodies.delete(handle);
+        }
+        return success;
+    }
+    isValidPhysicsBody(handle) {
+        return this.directBodies.has(handle);
+    }
+    getPhysicsBodyPosition(handle) {
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return null;
+        }
+        return this.doGetBodyPosition(record);
+    }
+    getPhysicsBodyRotation(handle) {
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return null;
+        }
+        return this.doGetBodyRotation(record);
+    }
+    setPhysicsBodyPosition(handle, position) {
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return false;
+        }
+        return this.doSetBodyPosition(record, position);
+    }
+    setPhysicsBodyRotation(handle, rotation) {
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return false;
+        }
+        return this.doSetBodyRotation(record, rotation);
+    }
+    applyImpulseToPhysicsBody(handle, impulse, worldSpace = true) {
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return false;
+        }
+        return this.doApplyBodyImpulse(record, impulse, worldSpace);
+    }
+    setPhysicsBodyEnabled(handle, enabled) {
+        const record = this.directBodies.get(handle);
+        if (!record) {
+            return false;
+        }
+        return this.doSetBodyEnabled(record, enabled);
+    }
+    createJointFromBodies(type, bodyA, bodyB, anchorA, anchorB, axis) {
+        if (!ensure(this.initialized)) {
+            return null;
+        }
+        const recordA = this.directBodies.get(bodyA);
+        const recordB = this.directBodies.get(bodyB);
+        if (!recordA || !recordB) {
+            return null;
+        }
+        const jointRecord = this.doCreateJointFromRecords(type, recordA, recordB, anchorA, anchorB, axis);
+        if (!jointRecord) {
+            return null;
+        }
+        const jointId = `joint_${this.nextJointId++}`;
+        this.joints.set(jointId, jointRecord);
+        return jointId;
+    }
+    //====================================================================================================
+    calculateBoxMass(size, density) {
+        const volume = size.x * size.y * size.z;
+        return volume * (density ?? 1);
+    }
+    calculateSphereMass(radius, density) {
+        const volume = (4 / 3) * Math.PI * radius * radius * radius;
+        return volume * (density ?? 1);
+    }
+    calculateCylinderMass(height, radius, density) {
+        const volume = Math.PI * radius * radius * height;
+        return volume * (density ?? 1);
+    }
+    calculateCapsuleMass(height, radius, density) {
+        // Capsule is a cylinder with two hemisphere caps
+        const cylinderVolume = Math.PI * radius * radius * height;
+        const hemisphereVolume = (2 / 3) * Math.PI * radius * radius * radius;
+        const volume = cylinderVolume + 2 * hemisphereVolume;
+        return volume * (density ?? 1);
+    }
+    calculateConeMass(height, radius, density) {
+        const volume = (1 / 3) * Math.PI * radius * radius * height;
+        return volume * (density ?? 1);
+    }
+    calculateMeshMass(geometry, density) {
+        // Approximate mass based on bounding box volume
+        geometry.computeBoundingBox();
+        const bbox = geometry.boundingBox;
+        if (!bbox) {
+            return 1; // default mass
+        }
+        const size = new THREE.Vector3();
+        bbox.getSize(size);
+        const volume = size.x * size.y * size.z;
+        return volume * (density ?? 1);
+    }
+    doCreateCharacterController(options) {
+        throw new Error('Not implemented');
+    }
+    doRemoveCharacterController(record) {
+        throw new Error('Not implemented');
+    }
+    doComputeCharacterMovement(record, recordToMove, movement, ignoreCollision) {
+        throw new Error('Not implemented');
+    }
+    doSetComponentCollisionIgnore(recordA, recordB, ignore) {
+        throw new Error('Not implemented');
+    }
+    /**
+   * Process any pending collision events in the physics system
+   * This is called internally by the tick method
+   */
+    processCollisionEvents() {
+        const events = this.getCollisionEvents();
+        for (const event of events) {
+            this.handleCollisionEvent(event);
+        }
+        // Clear the collision events after processing them
+        this.clearCollisionEvents();
+    }
+    /**
+   * Handles a single collision event by notifying the involved components
+   * @param event Collision event information
+   */
+    handleCollisionEvent(event) {
+        const componentA = event.componentA;
+        const componentB = event.componentB;
+        const eventA = {
+            thisComponent: componentA,
+            otherComponent: componentB,
+            thisPoint: event.pointA,
+            thisNormal: event.normalA,
+            otherPoint: event.pointB,
+            otherNormal: event.normalB,
+            relativeVelocity: event.relativeVelocity,
+        };
+        const eventB = {
+            thisComponent: componentB,
+            otherComponent: componentA,
+            thisPoint: event.pointB,
+            thisNormal: event.normalB,
+            otherPoint: event.pointA,
+            otherNormal: event.normalA,
+            relativeVelocity: event.relativeVelocity,
+        };
+        if (componentA && componentB) {
+            const actorA = componentA.getActor();
+            const actorB = componentB.getActor();
+            if (event.eventType === CollisionEventType.Started) {
+                if (event.isTriggerEvent) {
+                    // Component events
+                    componentA.onOverlapWith.invoke(componentA, componentB, eventA);
+                    componentB.onOverlapWith.invoke(componentB, componentA, eventB);
+                    // Actor events
+                    if (actorA && actorB)
+                        actorA.onOverlapWith.invoke(actorA, componentA, actorB, componentB, eventA);
+                    if (actorB && actorA)
+                        actorB.onOverlapWith.invoke(actorB, componentB, actorA, componentA, eventB);
+                }
+                else {
+                    // Component events
+                    componentA.onCollideWith.invoke(componentA, componentB, eventA);
+                    componentB.onCollideWith.invoke(componentB, componentA, eventB);
+                    // Actor events
+                    if (actorA && actorB)
+                        actorA.onCollideWith.invoke(actorA, componentA, actorB, componentB, eventA);
+                    if (actorB && actorA)
+                        actorB.onCollideWith.invoke(actorB, componentB, actorA, componentA, eventB);
+                }
+            }
+            else {
+                if (event.isTriggerEvent) {
+                    // Component events
+                    componentA.onStopOverlappingWith.invoke(componentA, componentB, eventA);
+                    componentB.onStopOverlappingWith.invoke(componentB, componentA, eventB);
+                    // Actor events
+                    if (actorA && actorB)
+                        actorA.onStopOverlappingWith.invoke(actorA, componentA, actorB, componentB, eventA);
+                    if (actorB && actorA)
+                        actorB.onStopOverlappingWith.invoke(actorB, componentB, actorA, componentA, eventB);
+                }
+                else {
+                    // Component events
+                    componentA.onStopCollidingWith.invoke(componentA, componentB, eventA);
+                    componentB.onStopCollidingWith.invoke(componentB, componentA, eventB);
+                    // Actor events
+                    if (actorA && actorB)
+                        actorA.onStopCollidingWith.invoke(actorA, componentA, actorB, componentB, eventA);
+                    if (actorB && actorA)
+                        actorB.onStopCollidingWith.invoke(actorB, componentB, actorA, componentA, eventB);
+                }
+            }
+        }
+    }
+}
+__decorate([
+    ConsoleCommand('debugphysics', 'Enable/disable physics debug visualization (usage: debugphysics <true | false>)'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], BasePhysicsEngine.prototype, "debugPhysics", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BasePhysicsEngine.js","sourceRoot":"","sources":["../../../src/physics/BasePhysicsEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;;;;;;;;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAEvG,OAAO,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAC9E,OAAO,EAAE,0BAA0B,EAAE,MAAM,oDAAoD,CAAC;AAChG,OAAO,EAAE,sBAAsB,EAAE,MAAM,gDAAgD,CAAC;AACxF,OAAO,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAwEzE,MAAM,CAAN,IAAY,SAKX;AALD,WAAY,SAAS;IACjB,oCAAuB,CAAA;IACvB,4BAAe,CAAA;IACf,kCAAqB,CAAA;IACrB,oCAAuB,CAAA;AAC3B,CAAC,EALW,SAAS,KAAT,SAAS,QAKpB;AAWD,MAAM,OAAgB,iBAAiB;IAerC,YAAY,SAAe;QAdjB;;;;mBAAuB,KAAK;WAAC;QAC7B;;;;mBAA6C,IAAI,GAAG,EAAE;WAAC;QACvD;;;;mBAAmF,IAAI,GAAG,EAAE;WAAC;QAC7F;;;;mBAAoC,IAAI,GAAG,EAAE;WAAC,CAAC,yBAAyB;QACxE;;;;mBAAqC,IAAI,GAAG,EAAE;WAAC,CAAC,kCAAkC;QAClF;;;;mBAAiC,IAAI;WAAC;QACxC;;;;mBAAsB,CAAC;WAAC;QACxB;;;;mBAAqB,CAAC;WAAC;QAE/B,4DAA4D;QAClD;;;;;WAAe;QAEf;;;;mBAA+C,IAAI,GAAG,EAAE;WAAC;QAGjE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,SAAS,EAAE,CAAC;YACd,SAAS,EAAE,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAEM,cAAc,CAAC,OAAuB;QAC3C,OAAO,EAAE,CAAC,CAAC,4BAA4B;IACzC,CAAC;IAGO,YAAY,CAAC,SAAiB,EAAE;QACtC,iDAAiD;QACjD,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;YACxC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,gBAAgB,GAAG,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IACrF,CAAC;IAGD;;;;SAIK;IACE,KAAK,CAAC,MAAM,CAAC,OAAuB;QACzC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC/B,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;SAGK;IACE,UAAU;QACf,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;SAEK;IACE,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,0DAA0D;QAC1D,KAAK,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACjD,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAEpB,qCAAqC;QACrC,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACjD,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAE1B,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACrB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QAC3B,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IAED;;;SAGK;IACE,IAAI,CAAC,SAAiB;QAC3B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO;QACT,CAAC;QAED,gEAAgE;QAChE,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YAC3C,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACvB,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEO,SAAS,CAAC,YAAwB;QACxC,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC,IAAI,CAC/B,YAAY,CAAC,QAAQ,CAAC,KAAK,EAAE,EAC7B,YAAY,CAAC,QAAQ,CACtB,CAAC;QACF,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;OAIG;IACK,0BAA0B,CAAC,KAAqB;QACtD,6BAA6B;QAC7B,MAAM,aAAa,GAAiB,EAAE,CAAC;QAEvC,6HAA6H;QAC7H,iFAAiF;QACjF,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE,EAAE;YACxB,IAAI,MAAM,YAAY,KAAK,CAAC,IAAI,EAAE,CAAC;gBACjC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,aAAa,CAAC;QAErB,gGAAgG;QAChG,gEAAgE;QAEhE,4CAA4C;QAC5C,+BAA+B;QAC/B,wCAAwC;QACxC,kDAAkD;QAElD,4CAA4C;QAC5C,8IAA8I;QAC9I,gFAAgF;QAChF,uCAAuC;QACvC,2CAA2C;QAE3C,uCAAuC;QACvC,MAAM;QACN,MAAM;QAEN,uCAAuC;QAEvC,wBAAwB;IAC1B,CAAC;IAED;;;;;OAKG;IACK,sBAAsB,CAAC,IAAgB;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC,CAAC,CAAC,CAAC;QAClD,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACzC,WAAW,CAAC,gBAAgB,GAAG,KAAK,CAAC;QACrC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC7C,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAEpC,4FAA4F;QAC5F,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;QAEpD,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;SAIK;IACE,YAAY,CAAC,SAA6B;QAC/C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,cAAc,GAAG,SAAS,CAAC,iBAAiB,EAAE,CAAC;QAErD,MAAM,eAAe,GAAG,eAAe,CAAC,WAAW,EAAE,CAAC;QACtD,MAAM,gBAAgB,GAAG,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,cAAc,EAAE,gBAAgB,CAAC,CAAC;QACrH,IAAI,gBAAgB,EAAE,IAAI,KAAK,aAAa,CAAC,WAAW,EAAE,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,mFAAmF;QACnF,IAAI,CAAC,cAAc,EAAE,OAAO,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,UAAU,GAA6B,IAAI,CAAC;QAChD,MAAM,QAAQ,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QACrC,MAAM,SAAS,GAAG,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;QACzC,MAAM,UAAU,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QACvC,SAAS,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACrC,SAAS,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;QACxC,SAAS,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAEpC,IAAI,OAAO,GAAc,EAAE,CAAC;QAC5B,IAAI,MAAM,GAAmB,IAAI,CAAC;QAClC,IAAI,SAAS,YAAW,CAAC,aAAa,CAAC,EAAE,CAAC;YACxC,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACpH,CAAC;aAAM,IAAI,SAAS,YAAW,CAAC,uBAAuB,CAAC,EAAE,CAAC;YACzD,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,0BAA0B,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACrH,CAAC;aAAM,IAAI,SAAS,YAAW,CAAC,oBAAoB,CAAC,EAAE,CAAC;YACtD,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAClH,CAAC;aAAM,IAAI,SAAS,YAAW,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACnD,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAC/G,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;QAED,IAAI,SAAS,YAAW,CAAC,0BAA0B,CAAC,EAAE,CAAC;YACrD,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,6BAA6B,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QAC7G,CAAC;aAAM,IAAI,SAAS,YAAW,CAAC,sBAAsB,CAAC,EAAE,CAAC;YACxD,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,yBAAyB,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACrH,CAAC;QAED,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;;;;;OAQG;IACO,yBAAyB,CACjC,SAAwB,EACxB,cAAmD,EACnD,QAAuB,EACvB,SAA2B,EAC3B,UAAyB;QAEzB,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACtB,CAAC;QAED,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,CAAC,EAAE,SAAS,CAAC,CAAC;QAC1H,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;;OASG;IACK,gBAAgB,CACtB,IAAgB,EAChB,cAAmD,EACnD,eAAoG,EACpG,OAAa;QAEb,MAAM,OAAO,GAAuB,EAAE,CAAC;QACvC,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,IAAI,iBAAiB,CAAC,OAAO,CAAC;QAE3E,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC/B,IAAI,QAAQ,YAAW,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,QAAQ,YAAW,CAAC,KAAK,CAAC,oBAAoB,CAAC,IAAI,QAAQ,YAAW,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC;YACnJ,SAAS;YACT,QAAQ,CAAC,qBAAqB,EAAE,CAAC;YACjC,KAAK,MAAM,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,IAAI,eAAe,EAAE,CAAC;gBAClE,8BAA8B;gBAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;gBACvE,MAAM,YAAY,GAAG,QAAQ,CAAC,cAAe,CAAC,MAAM,GAAG,WAAW,CAAC;gBACnE,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC;oBACrC,UAAU;oBACV,OAAO,EAAE,cAAe;oBACxB,QAAQ;oBACR,SAAS;oBACT,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,cAAc,EAAE,OAAO,CAAC;oBACrE,MAAM,EAAE,QAAQ,CAAC,cAAe,CAAC,MAAM;oBACvC,MAAM,EAAE,YAAY;iBACrB,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;aAAM,IAAI,QAAQ,YAAW,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE,CAAC;YACtD,MAAM,aAAa,GAAI,QAAkC,CAAC,UAAU,CAAC;YACrE,KAAK,MAAM,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,IAAI,eAAe,EAAE,CAAC;gBAClE,oBAAoB;gBAClB,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;gBACnD,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;gBAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC;oBACtC,UAAU;oBACV,OAAO,EAAE,cAAe;oBACxB,QAAQ;oBACR,SAAS;oBACT,IAAI,EAAE,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,CAAC;oBACxE,MAAM;oBACN,MAAM;iBACP,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;aAAM,IAAI,QAAQ,YAAW,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC;YACnD,MAAM,UAAU,GAAI,QAA+B,CAAC,UAAU,CAAC;YAC/D,KAAK,MAAM,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,IAAI,eAAe,EAAE,CAAC;gBAClE,oBAAoB;gBAClB,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;gBAChD,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;gBACxE,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC;oBACnC,UAAU;oBACV,OAAO,EAAE,cAAe;oBACxB,QAAQ;oBACR,SAAS;oBACT,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,CAAC;oBACrE,MAAM;oBACN,MAAM;iBACP,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;aAAM,IAAI,QAAQ,YAAW,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACvD,MAAM,cAAc,GAAI,QAAmC,CAAC,UAAU,CAAC;YACvE,KAAK,MAAM,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,IAAI,eAAe,EAAE,CAAC;gBAClE,oBAAoB;gBAClB,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC;gBACpD,MAAM,MAAM,GAAG,CAAC,cAAc,CAAC,SAAS,GAAG,cAAc,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;gBACnH,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC;oBACvC,UAAU;oBACV,OAAO,EAAE,cAAe;oBACxB,QAAQ;oBACR,SAAS;oBACT,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,CAAC;oBACzE,MAAM;oBACN,MAAM;iBACP,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;aAAM,IAAI,cAAc,EAAE,iBAAiB,EAAE,CAAC;YAC7C,+EAA+E;YAC/E,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE,OAAO,EAAE,WAAW,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;YAE/F,MAAM,iBAAiB,GAAG,cAAc,CAAC,iBAAiB,KAAK,iBAAiB,CAAC,MAAM,CAAC;YACxF,IAAI,iBAAiB,EAAE,CAAC;gBACtB,MAAM,mBAAmB,GAAmC,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC;gBACjG,IAAI,CAAC,mBAAmB,EAAE,CAAC;oBACzB,OAAO,CAAC,GAAG,CAAC,sMAAsM,CAAC,CAAC;gBACtN,CAAC;gBAED,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC/B,OAAO,CAAC,IAAI,CAAC,sIAAsI,CAAC,CAAC;gBACvJ,CAAC;gBAED,KAAK,MAAM,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,IAAI,eAAe,EAAE,CAAC;oBAChE,MAAM,SAAS,GAAG,mBAAmB,EAAE,SAAS,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBAC/E,MAAM,MAAM,GAA8B,mBAAmB,EAAE,WAAW,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;oBACxG,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;oBACrC,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC;oBACpF,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC;wBACpC,UAAU;wBACV,OAAO,EAAE,cAAe;wBACxB,QAAQ;wBACR,SAAS;wBACT,IAAI;wBACJ,MAAM;wBACN,SAAS;wBACT,MAAM,EAAE,mBAAmB,EAAE,MAAM;qBACpC,CAAC,CAAC;oBACH,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACvB,CAAC;YACH,CAAC;iBACK,CAAC;gBACL,wDAAwD;gBACxD,MAAM,WAAW,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;gBACtD,MAAM,UAAU,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAC,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,UAAU,EAAC,CAAC,CAAC,CAAC;gBAElH,yEAAyE;gBACzE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,wCAAwC,CAAC;oBAC5D,UAAU;oBACV,OAAO,EAAE,cAAe;oBACxB,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,0DAA0D;oBACzF,SAAS,EAAE,IAAI,KAAK,CAAC,UAAU,EAAE,EAAG,gBAAgB;oBACpD,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC;oBAC3E,MAAM,EAAE,CAAC,WAAW,CAAC;iBACtB,EAAE,UAAU,CAAC,CAAC,CAAC;YAClB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM;YACN,KAAK,MAAM,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,IAAI,eAAe,EAAE,CAAC;gBAChE,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBACjC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE,CAAC;gBACnC,IAAI,CAAC,QAAQ,CAAC,WAAY,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACzC,4BAA4B;gBAC5B,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;gBAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;oBAClC,UAAU;oBACV,OAAO,EAAE,cAAe;oBACxB,QAAQ;oBACR,SAAS;oBACT,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC;oBAC1D,IAAI;iBACL,CAAC,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;QAED,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;;;OAQG;IACO,0BAA0B,CAClC,SAAkC,EAClC,cAAmD,EACnD,QAAuB,EACvB,SAA2B,EAC3B,UAAyB;QAEzB,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,IAAI,iBAAiB,CAAC,OAAO,CAAC;QAC3E,MAAM,SAAS,GAAG,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3C,IAAI,MAAsB,CAAC;QAE3B,IAAI,SAAS,KAAK,kBAAkB,CAAC,MAAM,EAAE,CAAC;YAC5C,wDAAwD;YACxD,qFAAqF;YACrF,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;YAClE,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC;gBAC/B,UAAU;gBACV,OAAO,EAAE,cAAe;gBACxB,QAAQ;gBACR,SAAS;gBACT,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,CAAC;gBAC/D,MAAM,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAClC,MAAM,EAAE,MAAM;aACf,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,kBAAkB;YAClB,6FAA6F;YAC7F,8CAA8C;YAC9C,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC;YAEhC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC;gBAC5B,UAAU;gBACV,OAAO,EAAE,cAAe;gBACxB,QAAQ;gBACR,SAAS;gBACT,IAAI,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC;gBAC1D,IAAI;aACL,CAAC,CAAC;QACL,CAAC;QAED,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACO,uBAAuB,CAC/B,SAA+B,EAC/B,cAAmD,EACnD,QAAuB,EACvB,SAA2B,EAC3B,UAAyB;QAEzB,MAAM,SAAS,GAAG,SAAS,CAAC,YAAY,EAAE,CAAC;QAC3C,0CAA0C;QAC1C,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC;QACrD,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC;QACrD,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC,aAAa,GAAG,CAAC,CAAC;QACxD,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,CAAC,aAAa,GAAG,CAAC,CAAC;QACxD,MAAM,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;QAE5C,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YACvB,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACtB,CAAC;aAAM,IAAI,CAAC,MAAM,CAAC,SAAU,CAAC,MAAM,KAAK,SAAS,CAAC,EAAE,CAAC;YACpD,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACtB,CAAC;QAED,0BAA0B;QAC1B,MAAM,eAAe,GAAG,IAAI,YAAY,CAAC,SAAU,CAAC,MAAM,CAAC,CAAC;QAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3C,eAAe,CAAC,CAAC,CAAC,GAAG,SAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,UAAU,GAAG,iBAAiB,CAAC,MAAM,CAAC;QAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,uBAAuB,CAAC;YAC1C,UAAU;YACV,OAAO,EAAE,cAAe;YACxB,QAAQ;YACR,SAAS;YACT,IAAI,EAAE,CAAC;YACP,KAAK;YACL,KAAK;YACL,WAAW;YACX,WAAW;YACX,OAAO,EAAE,eAAe;SACzB,CAAC,CAAC;QAEH,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACO,oBAAoB,CAC5B,SAA4B,EAC5B,cAAuC,EACvC,QAAuB,EACvB,SAA2B,EAC3B,UAAyB;QAEzB,sCAAsC;QACtC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAAE,CAAC;YAC/B,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACtB,CAAC;QAED,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,IAAI,iBAAiB,CAAC,OAAO,CAAC;QAE3E,MAAM,KAAK,GAAG,SAAS,CAAC,gBAAgB,EAAE,CAAC,CAAE,gGAAgG;QAC7I,IAAI,MAAM,GAAmB,IAAI,CAAC;QAClC,MAAM,iBAAiB,GAAG,cAAc,EAAE,iBAAiB,KAAK,iBAAiB,CAAC,MAAM,CAAC;QACzF,IAAI,iBAAiB,EAAE,CAAC;YACtB,MAAM,mBAAmB,GAAmC,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC;YACjG,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBACzB,OAAO,CAAC,GAAG,CAAC,sMAAsM,CAAC,CAAC;YACtN,CAAC;YACD,MAAM,SAAS,GAAG,mBAAmB,EAAE,SAAS,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YAC/E,MAAM,MAAM,GAA8B,mBAAmB,EAAE,WAAW,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxG,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YACrC,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC;YACpF,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC;gBAC9B,UAAU;gBACV,OAAO,EAAE,cAAe;gBACxB,QAAQ;gBACR,SAAS;gBACT,IAAI;gBACJ,MAAM;gBACN,SAAS;gBACT,MAAM,EAAE,mBAAmB,EAAE,MAAM;aACpC,CAAC,CAAC;QACL,CAAC;aACI,CAAC;YACN,8EAA8E;YAC5E,IAAI,KAAK,EAAE,CAAC;gBACZ,8HAA8H;gBAC5H,MAAM,aAAa,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAC;gBAE7D,uDAAuD;gBACvD,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC;wBAC7B,UAAU,EAAE,UAAW;wBACvB,OAAO,EAAE,cAAe;wBACxB,QAAQ;wBACR,SAAS;wBACT,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;wBAClH,MAAM,EAAE,aAAa;qBACtB,EAAE,UAAU,CAAC,CAAC;oBAEf,IAAI,MAAM,EAAE,CAAC;wBACb,6EAA6E;wBAC3E,OAAO,CAAC,GAAG,CAAC,mDAAmD,EAAE,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;oBACnG,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACO,yBAAyB,CACjC,SAAiC,EACjC,cAAmD,EACnD,QAAuB,EACvB,SAA2B,EAC3B,UAAyB;QAEzB,IAAI,OAAO,GAAc,EAAE,CAAC;QAC5B,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,IAAI,iBAAiB,CAAC,OAAO,CAAC;QAC3E,MAAM,UAAU,GAAG,SAAS,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;QAC1D,MAAM,iBAAiB,GAAG,cAAc,EAAE,iBAAiB,KAAK,iBAAiB,CAAC,MAAM,CAAC;QACzF,MAAM,IAAI,GAAG,SAAS,CAAC,gBAAgB,EAAE,CAAC;QAC1C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,MAAM,aAAa,GAAG,SAAS,CAAC,gBAAgB,EAAE,CAAC;QACnD,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,CAAC,EAAE,CAAC;YAC1C,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,MAAM,eAAe,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAC,CAAC,CAAC,CAAC;YAC/E,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;gBAC3B,QAAQ,EAAE,SAAS,CAAC,QAAQ,IAAI,IAAI,KAAK,CAAC,OAAO,EAAE;gBACnD,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,UAAU,EAAE;gBAChH,UAAU,EAAE,SAAS,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;aAC1D,CAAC,CAAC,CAAC;QAEN,MAAM,CAAC,cAAc,EAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC;QACnG,OAAO,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAc,CAAC;QAE9D,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACO,6BAA6B,CACrC,SAAqC,EACrC,cAAmD,EACnD,QAAuB,EACvB,SAA2B;QAE3B,0EAA0E;QAC1E,IAAI,SAAS,CAAC,SAAS,EAAE,EAAE,CAAC;YAC1B,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,MAAM,eAAe,GAAG,SAAS,CAAC,kBAAkB,EAAE,CAAC;QACvD,IAAI,CAAC,eAAe,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrD,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,8BAA8B;QAC9B,MAAM,aAAa,GAAG,SAAS,CAAC,gBAAgB,EAAE,CAAC;QAEnD,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,CAAC,EAAE,CAAC;YAC1C,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACpB,CAAC;QAED,IAAI,OAAO,GAAc,EAAE,CAAC;QAC5B,MAAM,UAAU,GAAG,cAAc,EAAE,UAAU,IAAI,iBAAiB,CAAC,OAAO,CAAC;QAC3E,MAAM,iBAAiB,GAAG,cAAc,EAAE,iBAAiB,KAAK,iBAAiB,CAAC,MAAM,CAAC;QACzF,IAAI,iBAAiB,EAAE,CAAC;YACtB,MAAM,mBAAmB,GAAmC,cAAc,CAAC,aAAa,EAAE,MAAM,CAAC;YACjG,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBACzB,OAAO,CAAC,GAAG,CAAC,sMAAsM,CAAC,CAAC;YACtN,CAAC;YACD,MAAM,SAAS,GAAG,mBAAmB,EAAE,SAAS,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YAC/E,MAAM,MAAM,GAA8B,mBAAmB,EAAE,WAAW,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxG,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YACrC,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC;YACpF,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC;gBACpC,UAAU;gBACV,OAAO,EAAE,cAAe;gBACxB,QAAQ;gBACR,SAAS;gBACT,IAAI;gBACJ,MAAM;gBACN,SAAS;gBACT,MAAM,EAAE,mBAAmB,EAAE,MAAM;aACpC,CAAC,CAAC;YACH,IAAI,MAAM,EAAE,CAAC;gBACX,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;aACI,CAAC;YACJ,MAAM,KAAK,GAAG,SAAS,CAAC,gBAAgB,EAAE,CAAC;YAC3C,IAAI,KAAK,EAAE,CAAC;gBACZ,yEAAyE;gBACvE,MAAM,aAAa,GAAG,IAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAC;gBAE7D,0CAA0C;gBAC1C,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC7B,MAAM,UAAU,GAAG,SAAS,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;oBAC1D,MAAM,eAAe,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;wBACnD,QAAQ,EAAE,SAAS,CAAC,QAAQ,IAAI,IAAI,KAAK,CAAC,OAAO,EAAE;wBACnD,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,UAAU,EAAE;wBAC/G,KAAK,EAAE,SAAS,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;qBACrD,CAAC,CAAC,CAAC;oBAEJ,OAAO,GAAG,IAAI,CAAC,wCAAwC,CAAC;wBACtD,UAAU,EAAE,UAAW;wBACvB,OAAO,EAAE,cAAe;wBACxB,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,QAAQ;wBACrC,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,QAAQ;wBACtC,2BAA2B;wBAC3B,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;wBAClH,MAAM,EAAE,aAAa;qBACtB,EAAE,eAAe,CAAC,CAAC;gBACtB,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC/B,CAAC;IAED;;;SAGK;IACE,eAAe,CAAC,SAA6B;QAClD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QAED,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACzB,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAED;;;SAGK;IACE,eAAe,CAAC,SAA6B;QAClD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO;QACT,CAAC;QAED,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACzB,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;SAKK;IACE,cAAc,CAAC,SAA6B,EAAE,KAAyB;QAC5E,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;SAMK;IACE,cAAc,CAAC,SAA6B,EAAE,KAAyB,EAAE,KAAa;QAC3F,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IAED;;;;;SAKK;IACE,cAAc,CAAC,SAA6B,EAAE,KAAyB;QAC5E,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;SAMK;IACE,cAAc,CAAC,SAA6B,EAAE,KAAyB,EAAE,KAAkB;QAChG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;IACnG,CAAC;IAED;;;;;OAKG;IACI,gBAAgB,CAAC,SAA6B,EAAE,KAAyB;QAC9E,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACrC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC;IAC9F,CAAC;IAED;;;;;OAKG;IACI,yBAAyB,CAAC,iBAA4C,EAAE,OAAmC;QAChH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC;YAC/D,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,yBAAyB,CAAC,iBAA4C;QAC3E,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO;QACT,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7C,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACI,wBAAwB,CAAC,iBAA4C,EAAE,eAAmC,EAAE,QAAqB,EAAE,eAAwB;QAChK,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;QAC/B,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;QAC/B,CAAC;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QACvD,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjD,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;QAC/B,CAAC;QAED,uCAAuC;QACvC,OAAO,IAAI,CAAC,0BAA0B,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC;IAC9F,CAAC;IAED;;;;;OAKG;IACI,2BAA2B,CAAC,UAA8B,EAAE,UAA8B,EAAE,MAAe;QAChH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAE7C,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC3B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,MAAM,GAAG,IAAI,CAAC;QAClB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;gBAC/B,MAAM,GAAG,MAAM,IAAI,IAAI,CAAC,6BAA6B,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;YAClF,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,IAAe;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAClD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAElD,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC3B,OAAO,CAAC,KAAK,CAAC,yEAAyE,CAAC,CAAC;YACzF,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnD,OAAO,CAAC,KAAK,CAAC,8EAA8E,CAAC,CAAC;YAC9F,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACvE,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,SAAS,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACtC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,OAAe;QAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC7C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,CAAC;YACpC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC5B,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACI,eAAe;QACpB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;OASG;IACI,sBAAsB,CAC3B,IAAe,EACf,OAAgB,EAChB,OAAgB,EAChB,OAAsB,EACtB,OAAsB,EACtB,IAAoB;QAEpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAClG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,SAAS,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACtC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,2EAA2E;IAEpE,iBAAiB,CAAC,IAAqB;QAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,MAAM,GAAG,QAAQ,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;QAC3C,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,OAAO,MAAM,CAAC;IAChB,CAAC;IAEM,iBAAiB,CAAC,MAAc;QACrC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAEM,kBAAkB,CAAC,MAAc;QACtC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;IAEM,sBAAsB,CAAC,MAAc;QAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAEM,sBAAsB,CAAC,MAAc;QAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAEM,sBAAsB,CAAC,MAAc,EAAE,QAAuB;QACnE,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;IAEM,sBAAsB,CAAC,MAAc,EAAE,QAA0B;QACtE,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;IAEM,yBAAyB,CAAC,MAAc,EAAE,OAAsB,EAAE,aAAsB,IAAI;QACjG,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAC9D,CAAC;IAEM,qBAAqB,CAAC,MAAc,EAAE,OAAgB;QAC3D,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAEM,qBAAqB,CAC1B,IAAe,EACf,KAAa,EACb,KAAa,EACb,OAAsB,EACtB,OAAsB,EACtB,IAAoB;QAEpB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAE7C,IAAI,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAClG,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,OAAO,GAAG,SAAS,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;QAC9C,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACtC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,sGAAsG;IAE5F,gBAAgB,CAAC,IAAmB,EAAE,OAA2B;QACzE,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACxC,OAAO,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IAES,mBAAmB,CAAC,MAAc,EAAE,OAA2B;QACvE,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;QAC5D,OAAO,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IAES,qBAAqB,CAAC,MAAc,EAAE,MAAc,EAAE,OAA2B;QACzF,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;QAClD,OAAO,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IAES,oBAAoB,CAAC,MAAc,EAAE,MAAc,EAAE,OAA2B;QACxF,iDAAiD;QACjD,MAAM,cAAc,GAAG,IAAI,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;QAC1D,MAAM,gBAAgB,GAAG,CAAC,CAAC,GAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;QACpE,MAAM,MAAM,GAAG,cAAc,GAAG,CAAC,GAAG,gBAAgB,CAAC;QACrD,OAAO,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IAES,iBAAiB,CAAC,MAAc,EAAE,MAAc,EAAE,OAA2B;QACrF,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;QAC5D,OAAO,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IAES,iBAAiB,CAAC,QAA8B,EAAE,OAA2B;QACrF,gDAAgD;QAChD,QAAQ,CAAC,kBAAkB,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,QAAQ,CAAC,WAAW,CAAC;QAClC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,CAAC,CAAC,CAAC,eAAe;QAC3B,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACnB,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACxC,OAAO,MAAM,GAAG,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC;IACjC,CAAC;IAsBW,2BAA2B,CAAC,OAAmC;QACvE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IACS,2BAA2B,CAAC,MAAkC;QACtE,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IACS,0BAA0B,CAAC,MAAkC,EAAE,YAAqB,EAAE,QAAqB,EAAE,eAAwB;QAC7I,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IACS,6BAA6B,CAAC,OAAgB,EAAE,OAAgB,EAAE,MAAe;QACzF,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;IA2BD;;;KAGC;IACS,sBAAsB;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACzC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;QACD,mDAAmD;QACnD,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;;;KAGC;IACS,oBAAoB,CAAC,KAAwB;QACrD,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QACpC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAEpC,MAAM,MAAM,GAAmB;YAC7B,aAAa,EAAE,UAAU;YACzB,cAAc,EAAE,UAAU;YAC1B,SAAS,EAAE,KAAK,CAAC,MAAM;YACvB,UAAU,EAAE,KAAK,CAAC,OAAO;YACzB,UAAU,EAAE,KAAK,CAAC,MAAM;YACxB,WAAW,EAAE,KAAK,CAAC,OAAO;YAC1B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;SACzC,CAAC;QAEF,MAAM,MAAM,GAAmB;YAC7B,aAAa,EAAE,UAAU;YACzB,cAAc,EAAE,UAAU;YAC1B,SAAS,EAAE,KAAK,CAAC,MAAM;YACvB,UAAU,EAAE,KAAK,CAAC,OAAO;YACzB,UAAU,EAAE,KAAK,CAAC,MAAM;YACxB,WAAW,EAAE,KAAK,CAAC,OAAO;YAC1B,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;SACzC,CAAC;QAEF,IAAI,UAAU,IAAI,UAAU,EAAE,CAAC;YAC7B,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,CAAC;YAErC,IAAG,KAAK,CAAC,SAAS,KAAK,kBAAkB,CAAC,OAAO,EAAE,CAAC;gBAClD,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;oBACzB,mBAAmB;oBACnB,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAChE,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAChE,eAAe;oBACf,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAClG,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;gBACpG,CAAC;qBAAM,CAAC;oBACN,mBAAmB;oBACnB,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAChE,UAAU,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAChE,eAAe;oBACf,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAClG,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;gBACpG,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,KAAK,CAAC,cAAc,EAAE,CAAC;oBACzB,mBAAmB;oBACnB,UAAU,CAAC,qBAAqB,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBACxE,UAAU,CAAC,qBAAqB,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBACxE,eAAe;oBACf,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBAC1G,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;gBAC5G,CAAC;qBAAM,CAAC;oBACN,mBAAmB;oBACnB,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBACtE,UAAU,CAAC,mBAAmB,CAAC,MAAM,CAAC,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBACtE,eAAe;oBACf,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;oBACxG,IAAI,MAAM,IAAI,MAAM;wBAAE,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;gBAC1G,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;CAIJ;AArzCS;IADP,cAAc,CAAC,cAAc,EAAE,iFAAiF,CAAC;;;;qDASjH"}