math-exercises 3.0.215 → 3.0.217

package/lib/math/graphs/graph.js

@@ -0,0 +1,447 @@
+import { NodeComparator } from "../../tree/utilities/nodeComparator.js";
+import { random } from "../../utils/alea/random.js";
+import { shuffle } from "../../utils/alea/shuffle.js";
+import { splitIntoRandomChunks } from "../../utils/arrays/arrayChunks.js";
+import { zip } from "../../utils/arrays/arrayZip.js";
+import { Matrix, MatrixConstructor, } from "../matrices/matrix.js";
+export class GraphConstructor {
+    static randomConnected(nbVertices, isSimple = true, //simple === no loop A--A
+    isDirected = false, minDensity = 0.12, 
+    // maxDensity: number = 0.4,
+    poolVertexName = "ABCDEFGHIJKLM".split("")) {
+        const vertexNames = poolVertexName.slice(0, nbVertices);
+        const arrIndex = shuffle([...new Array(nbVertices).keys()]);
+        // console.log("arrArrIndex", arrArrIndex);
+        const coreChain = (() => {
+            if (arrIndex.length > 1) {
+                return zip(arrIndex.slice(0, -1), arrIndex.slice(1));
+            }
+            else {
+                if (isSimple) {
+                    return [];
+                }
+                else {
+                    const [indexSolo] = arrIndex;
+                    return [[indexSolo, indexSolo]];
+                }
+            }
+        })();
+        // console.log("arrCoreChain", arrCoreChain);
+        const coreNet = (() => {
+            const coreNetDirected = coreChain.reduce((acc, [startI, endI], i, coreChain) => {
+                if (i === 0) {
+                    acc.push([startI, endI]);
+                }
+                else {
+                    const [start0, _] = coreChain[0];
+                    const arrEndPrevious = coreChain.slice(0, i).map(([_, end]) => end);
+                    const arrEndAvailable = [start0, ...arrEndPrevious];
+                    const startIRandom = random(arrEndAvailable);
+                    acc.push([startIRandom, endI]);
+                }
+                return acc;
+            }, []);
+            if (isDirected) {
+                return coreNetDirected;
+            }
+            else {
+                const coreNetDirectedReversed = coreNetDirected.map(([startI, endI]) => [endI, startI]);
+                const coreNetSimple = [...coreNetDirected, ...coreNetDirectedReversed];
+                return coreNetSimple;
+            }
+        })();
+        // console.log("arrCoreNet", arrCoreNet);
+        const dictConnectionsCore = coreNet.reduce((acc, [startI, endI]) => {
+            if (!acc[startI]) {
+                acc[startI] = {};
+            }
+            acc[startI][endI] = true;
+            return acc;
+        }, {});
+        // console.log("dictConnectionsCore", dictConnectionsCore);
+        const [rows, cols] = [nbVertices, nbVertices];
+        const elts = [...Array(rows).keys()].map((i) => [...Array(cols).keys()].map((j) => (dictConnectionsCore[i]?.[j] ? 1 : 0).toTree()));
+        // console.log(
+        //   "elts",
+        //   elts.map((row) => row.map((elt) => elt.toTex())),
+        // );
+        //fill randomly
+        const mat = new Matrix(elts);
+        const graphSrc = new Graph(vertexNames, mat, isDirected);
+        const graphDensified = graphSrc.densifyUpTo(minDensity);
+        return graphDensified;
+    }
+    static random(nbVertices, isSimple = true, //simple === no loop A--A
+    isDirected = false, minDensity = 0.12, poolVertexName = "ABCDEFGHIJKLM".split(""), isConnected = true) {
+        if (isConnected) {
+            return this.randomConnected(nbVertices, isSimple, isDirected, minDensity, poolVertexName);
+        }
+        else {
+            const vertexNames = shuffle(poolVertexName.slice(0, nbVertices));
+            const minLengthChunk = nbVertices < 4 ? 1 : 2;
+            const arrVertexNamesChunk = splitIntoRandomChunks(vertexNames, 2, vertexNames.length - minLengthChunk);
+            const arrSubGraph = arrVertexNamesChunk.map((vertexNamesChunk) => this.randomConnected(vertexNamesChunk.length, isSimple, isDirected, minDensity, vertexNamesChunk));
+            return this.graphByMergingSimpleGraphs(arrSubGraph);
+        }
+    }
+    static randomChain(nbVertices, poolVertexName = "ABCDEFGHIJKLM".split(""), isDirected) {
+        if (nbVertices < 2) {
+            throw new Error("nbVertices < 2");
+        }
+        const vertexNames = poolVertexName.slice(0, nbVertices);
+        const arrIndex = shuffle([...new Array(nbVertices).keys()]);
+        // console.log("arrArrIndex", arrArrIndex);
+        const coreChain = zip(arrIndex.slice(0, -1), arrIndex.slice(1));
+        const dictConnectionsCore = coreChain.reduce((acc, [startI, endI]) => {
+            if (!acc[startI]) {
+                acc[startI] = {};
+            }
+            acc[startI][endI] = true;
+            return acc;
+        }, {});
+        // console.log("dictConnectionsCore", dictConnectionsCore);
+        const [rows, cols] = [nbVertices, nbVertices];
+        const elts = [...Array(rows).keys()].map((i) => [...Array(cols).keys()].map((j) => (dictConnectionsCore[i]?.[j] ? 1 : 0).toTree()));
+        const matDirected = new Matrix(elts);
+        const mat = isDirected ? matDirected : matDirected.symmetrized();
+        return new Graph(vertexNames, mat, isDirected);
+    }
+    // static randomWeighted(
+    //   nbVertices: number,
+    //   isDirected: boolean = false,
+    //   isConnected: boolean = true,
+    //   precision: number,
+    // ) {
+    //   const graphSimple = GraphConstructor.random(
+    //     nbVertices,
+    //     isDirected,
+    //     isConnected,
+    //   );
+    // }
+    // static randomValued(
+    //   nbVertices: number,
+    //   isDirected: boolean = false,
+    //   isConnected: boolean = true,
+    //   funcRandomValue: () => number,
+    // ) {
+    //   const graphSimple = GraphConstructor.random(
+    //     nbVertices,
+    //     isDirected,
+    //     isConnected,
+    //   );
+    //   const elementsValued = graphSimple.mat.elements.map((row) =>
+    //     row.map((elt) =>
+    //       NodeComparator.compareViaSub(elt, (0).toTree())
+    //         ? (0).toTree()
+    //         : funcRandomValue().toTree(),
+    //     ),
+    //   );
+    //   return new Graph(graphSimple.vertexNames, new Matrix(elementsValued));
+    // }
+    static graphByMergingSimpleGraphs(arrGraph) {
+        const isDirected = arrGraph.some((graph) => graph.isDirected);
+        const arrNameVertexSorted = arrGraph
+            .map((graph) => graph.vertexNames)
+            .reduce((acc, vertexNames) => {
+            acc = [...new Set([...acc, ...vertexNames])].toSorted((str1, str2) => str1.localeCompare(str2));
+            return acc;
+        }, []);
+        const arrDictConnections = arrGraph.map((graph) => graph.dictConnections());
+        const elementsMerged = arrNameVertexSorted.map(([nameVertexRow]) => arrNameVertexSorted.map(([nameVertexCol]) => arrDictConnections.reduce((acc, dict) => {
+            if (NodeComparator.isEqualViaSub(acc, (0).toTree())) {
+                if (dict[nameVertexRow]?.[nameVertexCol]) {
+                    acc = (1).toTree();
+                }
+            }
+            else {
+                //ignore
+            }
+            return acc;
+        }, (0).toTree())));
+        const matMerged = new Matrix(elementsMerged);
+        return new Graph(arrNameVertexSorted, matMerged, isDirected);
+    }
+    static graphByAddingRandomEdge(graph) {
+        const arrIJWithoutDiag = [...Array(graph.vertexNames.length).keys()]
+            .flatMap((i) => [...Array(graph.vertexNames.length).keys()].map((j) => [i, j]))
+            .filter(([i, j]) => i !== j);
+        const edgeIJNotExisting = shuffle(arrIJWithoutDiag).find(([i, j]) => NodeComparator.isEqualViaSub(graph.mat.elements[i][j], (0).toTree()));
+        if (edgeIJNotExisting) {
+            const [vertexNameStart, vertexNameEnd] = edgeIJNotExisting.map((index) => graph.vertexNames[index]);
+            const miniGraph = GraphConstructor.randomConnected(2, true, graph.isDirected, 0, [vertexNameStart, vertexNameEnd]);
+            return GraphConstructor.graphByMergingSimpleGraphs([graph, miniGraph]);
+        }
+        else {
+            return graph;
+        }
+    }
+    static fromIdentifiers(identifiers) {
+        const { vertexNames, matIds, isDirected } = identifiers;
+        const mat = MatrixConstructor.fromIdentifiers(matIds);
+        return new Graph(vertexNames, mat, isDirected);
+    }
+}
+export class Graph {
+    vertexNames;
+    mat;
+    isDirected;
+    constructor(vertexNames, mat, isDirected) {
+        this.vertexNames = vertexNames;
+        this.mat = mat;
+        this.isDirected = isDirected ?? !mat.isSymmetrical();
+    }
+    toIdentifiers() {
+        const graphIds = {
+            vertexNames: this.vertexNames,
+            matIds: this.mat.toIdentifiers(),
+            isDirected: this.isDirected,
+        };
+        return graphIds;
+    }
+    dictConnections() {
+        return Object.fromEntries(this.mat.elements.map((row, i) => {
+            const nameFrom = this.vertexNames[i];
+            const dictTo = Object.fromEntries(row.map((elt, j) => {
+                const nameTo = this.vertexNames[j];
+                const isConnection = !NodeComparator.isEqualViaSub(elt, (0).toTree());
+                return [nameTo, isConnection];
+            }));
+            return [nameFrom, dictTo];
+        }));
+    }
+    arrConnection() {
+        return Object.entries(this.dictConnections()).flatMap(([nameVertexStart, dict]) => Object.entries(dict).map(([nameVertexEnd, isConnection]) => [nameVertexStart, nameVertexEnd, isConnection]));
+    }
+    density() {
+        return this.mat.density();
+    }
+    densifyUpTo(minDensity) {
+        const { vertexNames, isDirected } = this;
+        let mat = this.mat;
+        let counter = -1;
+        while (mat.density() < minDensity && counter < 1000) {
+            counter++;
+            const graphPrev = new Graph(vertexNames, mat, isDirected);
+            const graph = GraphConstructor.graphByAddingRandomEdge(graphPrev);
+            mat = graph.mat;
+        }
+        return new Graph(vertexNames, mat, isDirected);
+    }
+    undirectedGraph() {
+        const graphReversed = new Graph(this.vertexNames, this.mat.transposed());
+        const graphUndirected = GraphConstructor.graphByMergingSimpleGraphs([
+            this,
+            graphReversed,
+        ]);
+        return graphUndirected;
+    }
+    isWeaklyConnected() {
+        const adjMatrix = (this.isDirected ? this.undirectedGraph() : this)
+            .adjacencyMatrix()
+            .elements.map((row) => row.map((elt) => elt.evaluate()));
+        //AI CODE (Edge) {
+        const n = adjMatrix.length;
+        // Validate adjacency matrix
+        if (n === 0)
+            return false;
+        for (const row of adjMatrix) {
+            if (row.length !== n) {
+                throw new Error("Invalid adjacency matrix: must be square.");
+            }
+        }
+        const visited = new Array(n).fill(false);
+        // DFS traversal
+        function dfs(node) {
+            visited[node] = true;
+            for (let neighbor = 0; neighbor < n; neighbor++) {
+                if (adjMatrix[node][neighbor] !== 0 && !visited[neighbor]) {
+                    dfs(neighbor);
+                }
+            }
+        }
+        // Start DFS from node 0
+        dfs(0);
+        // Check if all nodes were visited
+        return visited.every((v) => v);
+        //AI CODE (Edge) }
+    }
+    getWeaklyConnectedSubgraphCoveringChainsAsArrIndex() {
+        const adjMatrix = (this.isDirected ? this.undirectedGraph() : this)
+            .adjacencyMatrix()
+            .elements.map((row) => row.map((elt) => elt.evaluate()));
+        const n = adjMatrix.length;
+        const linked = (i, j) => i !== j &&
+            ((adjMatrix[i]?.[j] ?? 0) !== 0 || (adjMatrix[j]?.[i] ?? 0) !== 0);
+        // Voisinage non orienté
+        const neighbors = Array.from({ length: n }, (_, i) => {
+            const list = [];
+            for (let j = 0; j < n; j++)
+                if (linked(i, j))
+                    list.push(j);
+            return list;
+        });
+        // 1. Composantes connexes
+        const seen = new Array(n).fill(false);
+        const components = [];
+        for (let start = 0; start < n; start++) {
+            if (seen[start])
+                continue;
+            const component = [];
+            const stack = [start];
+            seen[start] = true;
+            while (stack.length > 0) {
+                const node = stack.pop();
+                component.push(node);
+                for (const nb of neighbors[node]) {
+                    if (!seen[nb]) {
+                        seen[nb] = true;
+                        stack.push(nb);
+                    }
+                }
+            }
+            components.push(component.sort((a, b) => a - b));
+        }
+        // 2. Chaîne couvrant une composante
+        const coveringChain = (component) => {
+            if (component.length === 1)
+                return [...component];
+            // Arbre couvrant en profondeur (donne des branches longues)
+            const tree = new Map(component.map((v) => [v, []]));
+            const inTree = new Set([component[0]]);
+            const grow = (u) => {
+                for (const v of neighbors[u]) {
+                    if (!inTree.has(v)) {
+                        inTree.add(v);
+                        tree.get(u).push(v);
+                        tree.get(v).push(u);
+                        grow(v);
+                    }
+                }
+            };
+            grow(component[0]);
+            // Sommet le plus éloigné (BFS dans l'arbre) + parents pour remonter la branche
+            const farthest = (src) => {
+                const parent = new Map([[src, -1]]);
+                const queue = [src];
+                for (let i = 0; i < queue.length; i++) {
+                    for (const v of tree.get(queue[i])) {
+                        if (!parent.has(v)) {
+                            parent.set(v, queue[i]);
+                            queue.push(v);
+                        }
+                    }
+                }
+                return { last: queue[queue.length - 1], parent };
+            };
+            // Diamètre de l'arbre : de a à b
+            const a = farthest(component[0]).last;
+            const { last: b, parent } = farthest(a);
+            const onDiameter = new Set();
+            for (let v = b; v !== -1; v = parent.get(v))
+                onDiameter.add(v);
+            // Parcours depuis a : les sous-arbres annexes d'abord (avec retour),
+            // la branche du diamètre en dernier (sans retour)
+            const chain = [];
+            const visit = (u, from) => {
+                chain.push(u);
+                const children = tree
+                    .get(u)
+                    .filter((v) => v !== from)
+                    .sort((x, y) => Number(onDiameter.has(x)) - Number(onDiameter.has(y)));
+                for (const child of children) {
+                    visit(child, u);
+                    if (!onDiameter.has(child))
+                        chain.push(u); // retour arrière
+                }
+            };
+            visit(a, -1);
+            // Normalisation : commencer par la plus petite extrémité
+            return chain[0] > chain[chain.length - 1] ? chain.reverse() : chain;
+        };
+        return components.map(coveringChain);
+    }
+    getSomePathsWithNbEdges(nbEdges, nbToFindIfPossible) {
+        const n = nbEdges;
+        const adjMatrix = this.adjacencyMatrix().elements.map((row) => row.map((elt) => elt.evaluate()));
+        const numVertices = adjMatrix.length;
+        const paths = [];
+        function dfs(currentPath) {
+            if (paths.length === nbToFindIfPossible)
+                return;
+            if (currentPath.length - 1 === n) {
+                paths.push([...currentPath]); // store a copy
+                return;
+            }
+            const last = currentPath[currentPath.length - 1];
+            const arrNeighborShuffled = shuffle([...Array(numVertices).keys()]);
+            arrNeighborShuffled.forEach((neighbor) => {
+                if (adjMatrix[last][neighbor] !== 0) {
+                    // edge exists
+                    currentPath.push(neighbor);
+                    dfs(currentPath);
+                    currentPath.pop();
+                }
+            });
+        }
+        const arrStartShuffled = shuffle([...Array(numVertices).keys()]);
+        arrStartShuffled.forEach((start) => {
+            dfs([start]);
+        });
+        return paths;
+    }
+    /**
+     *
+     * @param nameVertexTarget
+     * @returns [d, d-, d+]
+     */
+    getArrDegreeOfVertex(nameVertexTarget) {
+        if (this.isDirected) {
+            const dMinus = this.getArrVertexNameAdjacentXComing(nameVertexTarget, true).length;
+            const dPlus = this.getArrVertexNameAdjacentXComing(nameVertexTarget, false).length;
+            const d = dMinus + dPlus;
+            return [d, dMinus, dPlus];
+        }
+        else {
+            const dPlus = this.getArrVertexNameAdjacentXComing(nameVertexTarget, false).length;
+            return [dPlus, dPlus, dPlus];
+        }
+    }
+    getArrVertexNameAdjacent(nameVertexTarget) {
+        const arrNameVertexAdjacent = [
+            ...new Set([
+                ...this.getArrVertexNameAdjacentXComing(nameVertexTarget, true),
+                ...this.getArrVertexNameAdjacentXComing(nameVertexTarget, false),
+            ]),
+        ];
+        return arrNameVertexAdjacent;
+    }
+    getArrVertexNameAdjacentXComing(nameVertexTarget, isIncomingVertices) {
+        if (isIncomingVertices) {
+            const arrNameVertexAdjacentIncoming = Object.entries(this.dictConnections())
+                .filter(([_, dict]) => dict[nameVertexTarget])
+                .map(([nameVertex, _]) => nameVertex);
+            return arrNameVertexAdjacentIncoming;
+        }
+        else {
+            const arrNameVertexAdjacentOutgoing = Object.entries(this.dictConnections()[nameVertexTarget])
+                .filter(([_, isConnection]) => isConnection)
+                .map(([vertexName, _]) => vertexName);
+            return arrNameVertexAdjacentOutgoing;
+        }
+    }
+    isValidPath(arrNameVertex) {
+        const dictConnections = this.dictConnections();
+        return zip(arrNameVertex.slice(0, -1), arrNameVertex.slice(1)).every(([nameVertexStart, nameVertexEnd]) => dictConnections[nameVertexStart]?.[nameVertexEnd]);
+    }
+    adjacencyMatrix() {
+        const elementsQuantized = this.mat.elements.map((row) => row.map((elt) => NodeComparator.isEqualViaSub(elt, (0).toTree())
+            ? (0).toTree()
+            : (1).toTree()));
+        return new Matrix(elementsQuantized);
+    }
+    equals(graph2) {
+        const isSameVertex = () => zip(this.vertexNames, graph2.vertexNames).every(([nameVertex1, nameVertex2]) => nameVertex1 === nameVertex2);
+        const isSameMat = () => this.mat.equals(graph2.mat);
+        return isSameVertex() && isSameMat();
+    }
+}

package/lib/math/matrices/matrix.d.ts

@@ -1,13 +1,52 @@
-import { AlgebraicNode } from "../../tree/nodes/algebraicNode.js";
+import { AlgebraicNode, SimplifyOptions } from "../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor.js";
+import { SubstractNode } from "../../tree/nodes/operators/substractNode.js";
+import { RandintProps } from "../utils/random/randint.js";
+type MatrixConstructorOpts = {
+    allowIdentity?: boolean;
+    elementsOpts?: RandintProps;
+    adjacentAllowLoop?: boolean;
+    niceInversible?: boolean;
+};
 export declare abstract class MatrixConstructor {
-    static random(rows: number, cols: number): Matrix;
+    static random(rows: number, cols: number, opts?: MatrixConstructorOpts): Matrix;
+    static identity(order: number): Matrix;
+    static randomInversible(rows: number, cols: number, opts?: MatrixConstructorOpts): Matrix;
+    static fromIdentifiers(identifiers: MatrixIdentifiers): Matrix;
+    static emptyVarMatrix(nbRows: number, nbCols: number): Matrix;
+    static randomAdjacent(length: number, opts?: MatrixConstructorOpts): Matrix;
 }
+export type MatrixIdentifiers = {
+    id: "matrix";
+    elementsIds: NodeIdentifiers[][];
+};
 export declare class Matrix {
     elements: AlgebraicNode[][];
     rows: number;
     columns: number;
     constructor(elements: AlgebraicNode[][]);
-    determinant(): AlgebraicNode;
+    transposed(): Matrix;
+    isSymmetrical(): boolean;
+    symmetrized(): Matrix;
+    toIdentifiers(): MatrixIdentifiers;
+    determinant(): SubstractNode;
+    toInversed(): Matrix;
+    isIdentity(): boolean;
+    isTransition(): boolean;
+    inverse(): Matrix | undefined;
+    density(): number;
+    matForMapFunc(func: (elt: AlgebraicNode, i: number, j: number) => AlgebraicNode): Matrix;
+    times(k: AlgebraicNode): Matrix;
+    opposite(): Matrix;
+    isMatAdditionPossible(matPrime: Matrix): boolean;
+    add(matPrime: Matrix): Matrix;
+    substract(matPrime: Matrix): Matrix;
+    isMatProductPossible(matPrime: Matrix): boolean;
+    matrixProduct(matPrime: Matrix): Matrix;
+    power(exponent: number): Matrix;
+    equals(matPrime: Matrix): boolean;
     toTex(): string;
+    simplify(simplifyOpts?: SimplifyOptions): Matrix;
 }
+export {};
 //# sourceMappingURL=matrix.d.ts.map

package/lib/math/matrices/matrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAMzC;AACD,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAKvC,WAAW;IAUX,KAAK;CAUN"}
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/math/matrices/matrix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAK5E,OAAO,EAAW,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAEnE,KAAK,qBAAqB,GAAG;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AACF,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,qBAAqB;IActE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM;IAS7B,MAAM,CAAC,gBAAgB,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,qBAAqB;IAW9B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,iBAAiB;IAQrD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAQpD,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,qBAAqB;CAWnE;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,QAAQ,CAAC;IACb,WAAW,EAAE,eAAe,EAAE,EAAE,CAAC;CAClC,CAAC;AAEF,qBAAa,MAAM;IACjB,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,QAAQ,EAAE,aAAa,EAAE,EAAE;IAMvC,UAAU;IAIV,aAAa;IAQb,WAAW;IAIX,aAAa,IAAI,iBAAiB;IAQlC,WAAW;IASX,UAAU;IAaV,UAAU;IAcV,YAAY;IAgBZ,OAAO;IAgBP,OAAO;IAOP,aAAa,CACX,IAAI,EAAE,CAAC,GAAG,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,aAAa;IAQnE,KAAK,CAAC,CAAC,EAAE,aAAa;IAMtB,QAAQ;IAIR,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIhD,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM7B,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAInC,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI/C,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAmBvC,KAAK,CAAC,QAAQ,EAAE,MAAM;IAUtB,MAAM,CAAC,QAAQ,EAAE,MAAM;IAYvB,KAAK;IAML,QAAQ,CAAC,YAAY,CAAC,EAAE,eAAe;CAMxC"}