math-exercises 3.0.178 → 3.0.180

package/lib/exercises/math/derivation/variations/findExtremaFromFunctionExpression.js

@@ -0,0 +1,547 @@
+import { addValidProp, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { createNodeFPolynomialFromCoeffs, getAnswerStuffSolveSecondDegreePolynomial, getTexSolveSecondDegreeEquation, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { NodeUtils } from "../../../../tree/utilities/nodeUtils.js";
+const tryToSimplify = (node, simplifyOptions) => {
+    try {
+        return node.simplify(simplifyOptions);
+    }
+    catch (_) {
+        return node;
+    }
+};
+const getNodeFForTypeF = (typeF, typeRoots) => {
+    const isIntegerRoots = typeRoots === "entières";
+    switch (typeF) {
+        case "polynôme (degré $2$)": {
+            //f(x)=ax^2+bx+c
+            //f'(x)=2ax+b
+            //f'(x)=0 <=> x = -b/2a
+            if (isIntegerRoots) {
+                function getNiceBA() {
+                    const a = randint(-10, 11, [0]);
+                    const x = randint(-10, 11, [0]);
+                    const b = x * (2 * a);
+                    return [b, a];
+                }
+                const [b, a] = getNiceBA();
+                const [nodeB, nodeA] = [b, a].map((v) => v.toTree());
+                const nodeC = randint(-10, 11, [0]).toTree();
+                const nodeF = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                return nodeF;
+            }
+            else {
+                const nodeA = randint(-10, 11, [0]).toTree();
+                const nodeB = randint(-10, 11, [0]).toTree();
+                const nodeC = randint(-10, 11, [0]).toTree();
+                const nodeF = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                return nodeF;
+            }
+        }
+        case "polynôme (degré $3$)": {
+            //3ax^2+2bx+c=0
+            //delta = (2b)²-4(3a)(c) = 4b^2 - 12ac = 4(b^2 - 3ac)
+            //=> smooth if (b^2 - 3ac) = n^2
+            //             (b^2 - n^2) % 3 = 0
+            function getNiceCBA() {
+                let [c, b, a] = [];
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    b = randint(10, 100);
+                    const n = probaFlip(0.95) ? randint(1, b) : 0;
+                    const b2Minusn2 = b * b - n * n;
+                    isValid = b2Minusn2 % 3 === 0;
+                    if (isValid) {
+                        const ac = b2Minusn2 / 3;
+                        const arrDivisors = dividersOf(ac);
+                        a = random(arrDivisors);
+                        c = ac / a;
+                        //delta = 4n^2 => sqrt(delta) = 2n
+                        const x1 = (-(2 * b) - 2 * n) / (2 * (3 * a));
+                        const x2 = (-(2 * b) + 2 * n) / (2 * (3 * a));
+                        if (isIntegerRoots) {
+                            isValid = Number.isInteger(x1) && Number.isInteger(x2);
+                        }
+                    }
+                }
+                if (!isValid) {
+                    [c, b, a] = [1, 3, 3];
+                }
+                return [c, b, a];
+            }
+            const [c, b, a] = getNiceCBA();
+            const [nodeC, nodeB, nodeA] = [c, b, a].map((v) => v.toTree());
+            const nodeD = randint(-10, 10, [0]).toTree();
+            const nodeF = createNodeFPolynomialFromCoeffs([
+                nodeD,
+                nodeC,
+                nodeB,
+                nodeA,
+            ]);
+            return nodeF;
+        }
+        case "$\\frac{ax^2+bx+c}{dx+m}$": {
+            //f(x)=(ax^2+bx+c)/(dx+m)
+            //f'(x) = ((2ax+b)(dx+m)-(ax^2+bx+c)d)/((dx+m)^2)
+            //f'(x) = 0 <=>
+            //(2ad)x^2+(2am+bd)x+(bm)-(ad)x^2-(bd)x -(cd) = 0
+            //(ad)x^2+(2am)x+(bm-cd)=0
+            //delta = (2am)^2 - 4(ad)(bm-cd)
+            //=> smooth if bm-cd = 0
+            function getNiceMDCBA() {
+                let [m, d, c, b, a] = [];
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    b = randint(1, 30);
+                    m = randint(1, 30);
+                    const bm = b * m;
+                    const arrDivisors = dividersOf(bm);
+                    c = random(arrDivisors);
+                    d = bm / c;
+                    if (isIntegerRoots) {
+                        isValid = Number.isInteger(m / d);
+                    }
+                    else {
+                        isValid = true;
+                    }
+                    a = randint(-10, 11, [0]);
+                    return [m, d, c, b, a];
+                }
+                if (!isValid) {
+                    [m, d, c, b, a] = [19, 19, 2, 2, -8];
+                }
+                return [m, d, c, b, a];
+            }
+            const nodeF = (() => {
+                let nodeF;
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    const [m, d, c, b, a] = getNiceMDCBA();
+                    const [nodeM, nodeD, nodeC, nodeB, nodeA] = [m, d, c, b, a].map((v) => v.toTree());
+                    const nodeG = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                    const nodeH = createNodeFPolynomialFromCoeffs([nodeM, nodeD]);
+                    const { arrNodeX: arrNodeRootH } = getAnswerStuffSolveSecondDegreePolynomial(nodeH);
+                    isValid = arrNodeRootH.every((node) => Number.isInteger(node.evaluate()));
+                    nodeF = frac(nodeG, nodeH);
+                }
+                if (!isValid) {
+                    const [m, d, c, b, a] = [19, 19, 2, 2, -8];
+                    const [nodeM, nodeD, nodeC, nodeB, nodeA] = [m, d, c, b, a].map((v) => v.toTree());
+                    const nodeG = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                    const nodeH = createNodeFPolynomialFromCoeffs([nodeM, nodeD]);
+                    nodeF = frac(nodeG, nodeH);
+                }
+                return nodeF;
+            })();
+            return nodeF;
+        }
+        case "$\\frac{dx+m}{ax^2+bx+c}$": {
+            //f(x)=(ax^2+bx+c)/(dx+m)
+            //f'(x) = ((2ax+b)(dx+m)-(ax^2+bx+c)d)/((dx+m)^2)
+            //f'(x) = 0 <=>
+            //(2ad)x^2+(2am+bd)x+(bm)-(ad)x^2-(bd)x -(cd) = 0
+            //(ad)x^2+(2am)x+(bm-cd)=0
+            //delta = (2am)^2 - 4(ad)(bm-cd)
+            //=> smooth if bm-cd = 0
+            function getNiceMDCBA() {
+                let [m, d, c, b, a] = [];
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    b = randint(1, 30);
+                    m = randint(1, 30);
+                    const bm = b * m;
+                    const arrDivisors = dividersOf(bm);
+                    c = random(arrDivisors);
+                    d = bm / c;
+                    if (isIntegerRoots) {
+                        isValid = Number.isInteger(m / d);
+                    }
+                    else {
+                        isValid = true;
+                    }
+                    a = randint(-10, 11, [0]);
+                    return [m, d, c, b, a];
+                }
+                if (!isValid) {
+                    [m, d, c, b, a] = [19, 19, 2, 2, -8];
+                }
+                return [m, d, c, b, a];
+            }
+            const nodeF = (() => {
+                let nodeF;
+                let isValid = false;
+                let counter = -1;
+                while (!isValid && counter < 1000) {
+                    counter++;
+                    const [m, d, c, b, a] = getNiceMDCBA();
+                    const [nodeM, nodeD, nodeC, nodeB, nodeA] = [m, d, c, b, a].map((v) => v.toTree());
+                    const nodeG = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                    const nodeH = createNodeFPolynomialFromCoeffs([nodeM, nodeD]);
+                    const { arrNodeX: arrNodeRootH } = getAnswerStuffSolveSecondDegreePolynomial(nodeG);
+                    isValid = arrNodeRootH.every((node) => Number.isInteger(node.evaluate()));
+                    nodeF = frac(nodeH, nodeG);
+                }
+                if (!isValid) {
+                    const [m, d, c, b, a] = [19, 19, 2, 2, -8];
+                    const [nodeM, nodeD, nodeC, nodeB, nodeA] = [m, d, c, b, a].map((v) => v.toTree());
+                    const nodeG = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+                    const nodeH = createNodeFPolynomialFromCoeffs([nodeM, nodeD]);
+                    nodeF = frac(nodeH, nodeG);
+                }
+                return nodeF;
+            })();
+            return nodeF;
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getPrettyNode = (node) => {
+    if (isFractionNode(node)) {
+        const nodeNumSimplified = tryToSimplify(node.leftChild, {
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        const nodeDenSimplified = node.rightChild.simplify();
+        return frac(nodeNumSimplified, nodeDenSimplified);
+    }
+    else {
+        return node;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const [nodeF] = [nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeFPretty = getPrettyNode(nodeF);
+    const arrNodeXForbidden = (() => {
+        if (isFractionNode(nodeF)) {
+            const nodeDenum = nodeF.rightChild;
+            const { arrNodeX } = getAnswerStuffSolveSecondDegreePolynomial(nodeDenum);
+            return arrNodeX;
+        }
+        else {
+            return [];
+        }
+    })();
+    return `Soit $f$ une fonction telle que, pour tout $x$ réel${(() => {
+        if (arrNodeXForbidden.length > 0) {
+            return `, différent de ${arrNodeXForbidden
+                .map((node) => `$${node.toTex()}$`)
+                .join(" et de ")}`;
+        }
+        else {
+            return "";
+        }
+    })()} :
+
+$$
+f(x) = ${nodeFPretty.toTex()}
+$$
+  
+Déterminer les extremums locaux de $f$.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeFPretty = getPrettyNode(nodeF);
+    const nodeDerivativeRaw = nodeFPretty.derivative().simplify();
+    const nodeDerivativePretty = getPrettyNode(nodeDerivativeRaw);
+    const nodePolynomial = (() => {
+        if (isFractionNode(nodeDerivativePretty)) {
+            return nodeDerivativePretty.leftChild;
+        }
+        else {
+            return nodeDerivativePretty;
+        }
+    })();
+    return getAnswerStuffSolveSecondDegreePolynomial(nodePolynomial);
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeFPretty = getPrettyNode(nodeF);
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    const arrNodeValueFunction = arrNodeX.map((nodeX) => nodeBySubstitutingVar(nodeFPretty, nodeX, "x".toTree()).simplify());
+    return new EquationSolutionNode(new DiscreteSetNode(arrNodeValueFunction));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { typeF } = identifiers;
+    const strHintDerivative = (() => {
+        switch (typeF) {
+            case "polynôme (degré $2$)":
+                return `Soient $a$, $b$ et $c$ trois réels. La dérivée de $x \\mapsto ax^2+bx+c$ est $x \\mapsto 2ax+b$.`;
+            case "polynôme (degré $3$)":
+                return `Soient $a$, $b$, $c$ et $d$ quatre réels. La dérivée de $x \\mapsto ax^3+bx^2+cx+d$ est $x \\mapsto 3ax^2+2bx+c$.`;
+            case "$\\frac{ax^2+bx+c}{dx+m}$":
+                return `Soient $a$, $b$, $c$, $d$ et $m$ cinq réels. La dérivée de $x \\mapsto \\frac{ax^2+bx+c}{dx+m}$ est $x \\mapsto \\frac{(2ax+b)(dx+m)-(ax^2+bx+c)d}{(dx+m)^2}$.`;
+            case "$\\frac{dx+m}{ax^2+bx+c}$":
+                return `Soient $a$, $b$, $c$, $d$ et $m$ cinq réels. La dérivée de $x \\mapsto \\frac{dx+m}{ax^2+bx+c}$ est $x \\mapsto \\frac{d(ax^2+bx+c)-(dx+m)(2ax+b)}{(ax^2+bx+c)^2}$.`;
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    return `${strHintDerivative}
+
+Les extremums sont les images $f(x)$ des abscisses $x$ pour lesquelles $f'(x)=0$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const [nodeF] = [nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeFPretty = getPrettyNode(nodeF);
+    const nodeDerivativeRaw = nodeFPretty.derivative().simplify();
+    const nodeDerivativePretty = getPrettyNode(nodeDerivativeRaw);
+    const nodePolynomial = (() => {
+        if (isFractionNode(nodeDerivativePretty)) {
+            return nodeDerivativePretty.leftChild;
+        }
+        else {
+            return nodeDerivativePretty;
+        }
+    })();
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    return `Les abscisses recherchées sont les abscisses $a$ telles que $f'(a)=0$.
+  
+Pour $x$ appartenant à l'ensemble de dérivation de $f$, on calcule :
+
+${alignTex([
+        ...[
+            ...new Set([
+                tryToSimplify(nodeFPretty.derivative(), {}).toTex(),
+                nodeDerivativePretty.toTex(),
+            ]),
+        ].map((tex) => [`f'(x)`, "=", tex]),
+    ])}
+
+On résout $f'(x)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodePolynomial)}
+
+Les extremums sont donc : 
+
+${alignTex([
+        ...arrNodeX.flatMap((nodeX) => {
+            const nodeExtremum = nodeBySubstitutingVar(nodeFPretty, nodeX, "x".toTree());
+            return [
+                [`f(${nodeX.toTex()})`, "=", nodeExtremum.toTex()],
+                [``, "=", nodeExtremum.simplify().toTex()],
+            ];
+        }),
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { typeF, typeRoots } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(typeF, typeRoots);
+        if (isIdentifiersQCPassed(identifierWrong)) {
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["S", "equal", "varnothing", "lbrace", "semicolon", "rbrace"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, _optsIn) => {
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    const parsed = discreteSetParser(ans);
+    if (!parsed) {
+        return false;
+    }
+    const arrAns = parsed.elements;
+    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+};
+const createRandomIdentifiers = (typeF, typeRoots) => {
+    const nodeF = getNodeFForTypeF(typeF, typeRoots);
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+        typeRoots,
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isSolutionPrettyAndNotExploding = (identifiers) => {
+        try {
+            const arrNode = getAnswerNode(identifiers).solutionsSet.elements;
+            return arrNode.every((node) => NodeUtils.getDepth(node) < 2);
+        }
+        catch (_) {
+            return false;
+        }
+    };
+    return isSolutionPrettyAndNotExploding(identifiers);
+};
+const getFindExtremaFromFunctionExpressionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const typeRoots = random(arrayedOptions.typeRoots);
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(typeF, typeRoots);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        // console.log("will use identifiersDefault");
+        const identifiersDefault = {
+            nodeIdsF: {
+                id: 3,
+                leftChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 30,
+                        },
+                        rightChild: {
+                            id: 10,
+                            name: "x",
+                        },
+                    },
+                    rightChild: {
+                        id: 7,
+                        value: 10,
+                    },
+                },
+                rightChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 0,
+                        leftChild: {
+                            id: 2,
+                            leftChild: {
+                                id: 7,
+                                value: 6,
+                            },
+                            rightChild: {
+                                id: 5,
+                                leftChild: {
+                                    id: 10,
+                                    name: "x",
+                                },
+                                rightChild: {
+                                    id: 7,
+                                    value: 2,
+                                },
+                            },
+                        },
+                        rightChild: {
+                            id: 2,
+                            leftChild: {
+                                id: 7,
+                                value: 3,
+                            },
+                            rightChild: {
+                                id: 10,
+                                name: "x",
+                            },
+                        },
+                    },
+                    rightChild: {
+                        id: 7,
+                        value: 1,
+                    },
+                },
+            },
+            typeF: "$\\frac{dx+m}{ax^2+bx+c}$",
+            typeRoots: "entières",
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "polynôme (degré $2$)",
+        "polynôme (degré $3$)",
+        "$\\frac{ax^2+bx+c}{dx+m}$",
+        "$\\frac{dx+m}{ax^2+bx+c}$",
+    ],
+    typeRoots: ["entières", "rationnelles"],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "polynôme (degré $2$)",
+            "polynôme (degré $3$)",
+            "$\\frac{ax^2+bx+c}{dx+m}$",
+            "$\\frac{dx+m}{ax^2+bx+c}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+    {
+        id: "typeRoots",
+        label: "Type d'abscisses",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["entières", "rationnelles"],
+        defaultValue: arrayedOptsDefault.typeRoots,
+    },
+];
+export const findExtremaFromFunctionExpression = {
+    id: "findExtremaFromFunctionExpression",
+    connector: "=",
+    label: "Déterminer les abscisses des extremums locaux à partir de l'expression d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindExtremaFromFunctionExpressionQuestion(opts), nb),
+    options,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    pointIds: PointIdentifiers[];
+    nodeIdsAbscissa: NodeIdentifiers[];
+    typeF: string;
+};
+type Options = {
+    typeF: string;
+};
+export declare const plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts.map

package/lib/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/plausibleDerivativeGraphFromFunctionGraphByManipulatingPolynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6J7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAubF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,iEAAiE,EAAE,QAAQ,CACtF,WAAW,EACX,OAAO,CAuBR,CAAC"}