math-exercises 3.0.198 → 3.0.200

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdUsingCalculator.js

@@ -0,0 +1,242 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, propWhile, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../../exercises/vea/numberVEA.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { InequationSymbol, } from "../../../../../math/inequations/inequation.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { mdTable } from "../../../../../utils/markdown/mdTable.js";
+const getArrPoint = (nodeInitial, nodeReason, firstRank) => {
+    const arrNodeTerm = [...Array(nbPoints).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        distributePowersOnFrac: true,
+    })
+        .simplify({ towardsDistribute: false }));
+    const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+        const nodeX = (firstRank + i).toTree();
+        return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+    });
+    return arrPoint;
+};
+const nbPoints = 15;
+const getInstruction = (identifiers) => {
+    const { nodeIdsValueThreshold, inegSymbol, firstRank, nodeIdsInitial, nodeIdsReason, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soit une suite géométrique $u$ de premier terme $u_{${firstRank}}=${nodeInitial.toTex()}$ et de raison $${nodeReason.toTex()}$.
+
+À l'aide de la calculatrice, déterminer le rang $N$, tel que pour tout $n \\geq N$, on a :
+
+$$
+u_{n} ${inegSymbol} ${nodeValueThreshold.toTex()}
+$$
+
+`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsInitial, nodeIdsReason, nodeIdsValueThreshold, firstRank, inegSymbol, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = getArrPoint(nodeInitial, nodeReason, firstRank);
+    const [pointValid, indexPointValid] = arrPoint
+        .map((point, i) => [point, i])
+        .find(([point, _i]) => {
+        const inequationNode = new InequationNode([point.y, nodeValueThreshold], inegSymbol);
+        return inequationNode.isVerified();
+    });
+    return { arrPoint, pointValid, indexPointValid };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).pointValid.x.toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsValueThreshold, nodeIdsInitial, nodeIdsReason, inegSymbol, firstRank, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Avec la calculatrice, à partir du menu, sélectionne le mode correspondant aux suites.
+Entre les paramètres de la suite : $u_{${firstRank}}=${nodeInitial.toTex()}$ et raison: $${nodeReason.toTex()}$.
+Demande d'afficher le tableau de valeurs.
+Cherche alors le rang du premier terme ${(() => {
+        switch (inegSymbol) {
+            case "\\ge":
+                return `supérieur ou égal`;
+            case ">":
+                return `supérieur`;
+            case "\\le":
+                return `inférieur ou égal`;
+            case "<":
+                return `inférieur`;
+        }
+    })()} à $${nodeValueThreshold.toTex()}$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsValueThreshold, nodeIdsInitial, nodeIdsReason, inegSymbol, firstRank, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const { arrPoint, pointValid, indexPointValid } = getAnswerStuff(identifiers);
+    function highlighted(str) {
+        return `{ \\color{green} ${str} }`;
+    }
+    return `On cherche le rang du premier terme ${(() => {
+        switch (inegSymbol) {
+            case "\\ge":
+                return `supérieur ou égal`;
+            case ">":
+                return `supérieur`;
+            case "\\le":
+                return `inférieur ou égal`;
+            case "<":
+                return `inférieur`;
+        }
+    })()} à $${nodeValueThreshold.toTex()}$.
+
+Avec la calculatrice, à partir du menu, on sélectionne le mode correspondant aux suites.
+On entre les paramètres de la suite : $u_{${firstRank}}=${nodeInitial.toTex()}$ et raison: $${nodeReason.toTex()}$.
+On demande d'afficher le tableau de valeurs.
+On obtient alors : 
+
+${mdTable([
+        ["n", "u_{n}"],
+        ...arrPoint.map((point, i) => i === indexPointValid
+            ? [point.x.toTex(), round(point.y.evaluate(), 2).frenchify()].map((tex) => highlighted(tex))
+            : [point.x.toTex(), round(point.y.evaluate(), 2).frenchify()]),
+    ], true)}
+
+Le rang recherché est $${pointValid.x.toTex()}$.
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const indexThreshold = randint(7, 15);
+        tryToAddWrongProp(propositions, indexThreshold.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getGeometricFindThresholdUsingCalculatorQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { isDivergent: _isDivergent, nodeInitialAbs, nodeReasonAbs, nodeValueThresholdAbs, inegSymbolAbs, } = (() => {
+        const isDivergent = coinFlip();
+        const { nodeInitialAbs, nodeReasonAbs } = (() => {
+            if (isDivergent) {
+                return {
+                    nodeInitialAbs: randfloat(1, 10, 1).toTree(),
+                    nodeReasonAbs: randfloat(2, 3, 1).toTree(),
+                };
+            }
+            else {
+                return {
+                    nodeInitialAbs: randfloat(1000, 2000, 0).toTree(),
+                    nodeReasonAbs: randfloat(0.5, 0.85, 1).toTree(),
+                };
+            }
+        })();
+        const arrPointAbs = getArrPoint(nodeInitialAbs, nodeReasonAbs, firstRank);
+        const { nodeValueThresholdAbs, inegSymbolAbs } = (() => {
+            const isValueThresholdEqualToTerm = coinFlip();
+            const nodeValueThresholdAbs = (() => {
+                const indexThresholdLow = randint(8, 14);
+                const progress = randfloat(0.3, 0.7, 1);
+                const [v1, v2] = [indexThresholdLow, indexThresholdLow + 1].map((index) => arrPointAbs[index].y.evaluate());
+                return round(v1 + (v2 - v1) * progress, 2).toTree();
+            })();
+            const inegSymbolAbs = (() => {
+                if (isDivergent) {
+                    return isValueThresholdEqualToTerm ? "\\ge" : random(["\\ge", ">"]);
+                }
+                else {
+                    return isValueThresholdEqualToTerm ? "\\le" : random(["\\le", "<"]);
+                }
+            })();
+            return { nodeValueThresholdAbs, inegSymbolAbs };
+        })();
+        return {
+            isDivergent,
+            nodeInitialAbs,
+            nodeReasonAbs,
+            nodeValueThresholdAbs,
+            inegSymbolAbs,
+        };
+    })();
+    const { nodeInitial, nodeReason, nodeValueThreshold, inegSymbol } = (() => {
+        const signInitial = coinFlip() ? +1 : -1;
+        const nodeInitial = multiply(signInitial, nodeInitialAbs).simplify({
+            towardsDistribute: true,
+        });
+        const nodeReason = nodeReasonAbs; //reason is always positive
+        const nodeValueThreshold = multiply(signInitial, nodeValueThresholdAbs).simplify({
+            towardsDistribute: true,
+        });
+        const inegSymbol = signInitial === +1
+            ? inegSymbolAbs
+            : new InequationSymbol(inegSymbolAbs).reversed();
+        return { nodeInitial, nodeReason, nodeValueThreshold, inegSymbol };
+    })();
+    const identifiers = {
+        firstRank,
+        nodeIdsInitial: nodeInitial.toIdentifiers(),
+        nodeIdsReason: nodeReason.toIdentifiers(),
+        nodeIdsValueThreshold: nodeValueThreshold.toIdentifiers(),
+        inegSymbol: inegSymbol,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {});
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindThresholdUsingCalculator = {
+    id: "geometricFindThresholdUsingCalculator",
+    label: "Déterminer un seuil d'une suite géométrique en utilisant la calculatrice",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindThresholdUsingCalculatorQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    isAnswerValid,
+    getAnswer,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/sequences/geometric/graph/geometricPlaceFirstPoints.js

@@ -20,7 +20,7 @@ const getInstruction = (identifiers) => {
     const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
     const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
     return `On considère une suite géométrique $u$ de premier rang $u_{${firstRank}}=${nodeInitial.toTex()}$ et de raison $${nodeReason.toTex()}$.
-Dans le repère ci-dessous, placer les points représentant les $${nbPoints}$ premiers termes de de $u$.`;
+Dans le repère ci-dessous, placer les points représentant les $${nbPoints}$ premiers termes de $u$.`;
 };
 const getAnswerStuff = (identifiers) => {
     const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
@@ -99,7 +99,7 @@ const isGGBAnswerValid = (ans, { ggbAnswer: _ggbAnswer, ...identifiers }) => {
     return points.every((p, i) => Math.abs(p.x - validPoints[i].x.evaluate()) < 0.4 &&
         Math.abs(p.y - validPoints[i].y.evaluate()) < 0.4);
 };
-const getPlaceFirstSequencePointsQuestion = (optsIn) => {
+const getGeometricPlaceFirstPointsQuestion = (optsIn) => {
     const opts = optsIn ?? optsDefault;
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     const typeSignReason = opts?.typeSignReason
@@ -172,8 +172,8 @@ export const geometricPlaceFirstPoints = {
     label: "Placer les premiers termes d'une suite géométrique dans un repère",
     isSingleStep: true,
     generator: (nb, opts) => 
-    // getDistinctQuestions(() => getPlaceFirstSequencePointsQuestion(opts), nb),
-    [...Array(nb).keys()].map(() => getPlaceFirstSequencePointsQuestion(opts)),
+    // getDistinctQuestions(() => getGeometricPlaceFirstPointsQuestion(opts), nb),
+    [...Array(nb).keys()].map(() => getGeometricPlaceFirstPointsQuestion(opts)),
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInitial: NodeIdentifiers;
+    nodeIdsReason: NodeIdentifiers;
+    firstRank: number;
+};
+type Options = OptionFirstTermRankOne;
+export declare const geometricSignOfReasonFromGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricSignOfReasonFromGraph.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricSignOfReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAM3D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,CAAC;IAChC,aAAa,EAAE,eAAe,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiKF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBzE,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.js

@@ -0,0 +1,161 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+const nbPoints = 4;
+const getArrPoint = (identifiers) => {
+    const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
+    const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrNodeTerm = [...Array(nbPoints).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        distributePowersOnFrac: true,
+    })
+        .simplify({ towardsDistribute: false }));
+    const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+        const nodeX = (firstRank + i).toTree();
+        return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+    });
+    return arrPoint;
+};
+const getInstruction = () => {
+    return `Dans le repère ci-dessous, on a placé les points représentant les $${nbPoints}$ premiers termes d'une suite géométrique $u$.
+Que peut-on en déduire quant au signe de sa raison ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsReason } = identifiers;
+    const nodeReason = NodeConstructor.fromIdentifiers(nodeIdsReason);
+    const indexAnswer = nodeReason.evaluate() > 0 ? 0 : 1;
+    return ["La raison est positive.", "La raison est négative."][indexAnswer];
+};
+const getHint = () => {
+    return `Dans le nuage de point qui représente la suite, l'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+
+
+Dans une suite géométrique, pour calculer le terme suivant, on multiplie par la raison. 
+Si la raison est positive, le signe sera conservé.
+Si la raison est négative, les deux termes seront de signes différents.`;
+};
+const getCorrection = (identifiers) => {
+    const answer = getAnswer(identifiers);
+    return `Dans le nuage de point qui représente la suite, l'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+
+Dans une suite géométrique, pour calculer le terme suivant, on multiplie par la raison.
+Si la raison est positive, le signe sera conservé.
+Si la raison est négative, les deux termes seront de signes différents.
+
+Ici, deux termes consécutifs sont toujours de ${answer === "La raison est positive." ? "même signe" : "signes opposés"}.
+Par conséquent, ${answer.toLocaleLowerCase()}.
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const arrPoint = getArrPoint(identifiers);
+    const values = arrPoint.map((point) => point.y.evaluate());
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...arrPoint.flatMap((point) => point.toGGBCommand({ color: `#000000`, showLabel: false })),
+        ],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    const yMin = Math.min(...values);
+    const yMax = Math.max(...values);
+    return ggb.getOptions({
+        coords: [-1, 6, Math.min(yMin, 0) - 1, Math.max(yMax, 1) + 1],
+    });
+};
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["La raison est positive.", "La raison est négative."].forEach((strYN) => {
+        if (strYN === answer) {
+            addValidProp(propositions, strYN, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, strYN, "raw");
+        }
+    });
+    return propositions;
+};
+const getGeometricSignOfReasonFromGraphQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const [nodeInitialAbs, nodeReasonAbs] = random([
+        //increasing
+        [(1).toTree(), (2).toTree()],
+        [(1).toTree(), frac(3, 2)],
+        [(1).toTree(), frac(4, 3)],
+        // [(1).toTree(), frac(5, 3)],
+        [frac(1, 2), (2).toTree()],
+        [frac(1, 2), frac(3, 2)],
+        [frac(1, 3), (3).toTree()],
+        [(2).toTree(), frac(3, 2)],
+        [(2).toTree(), frac(4, 3)],
+        //decreasing
+        [(8).toTree(), frac(1, 2)],
+        [(9).toTree(), frac(1, 3)],
+        [(9).toTree(), frac(2, 3)],
+        [(8).toTree(), frac(3, 4)],
+        // [(10).toTree(), frac(3, 5)],
+    ]);
+    const nodeInitial = (() => {
+        const sign = coinFlip() ? +1 : -1;
+        return multiply(sign, nodeInitialAbs).simplify({
+            towardsDistribute: true,
+        });
+    })();
+    const nodeReason = (() => {
+        const sign = coinFlip() ? +1 : -1;
+        return multiply(sign, nodeReasonAbs).simplify({
+            towardsDistribute: true,
+        });
+    })();
+    const identifiers = {
+        firstRank,
+        nodeIdsInitial: nodeInitial.toIdentifiers(),
+        nodeIdsReason: nodeReason.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {});
+const options = [generatorOptionFirstTermRankOne];
+export const geometricSignOfReasonFromGraph = {
+    id: "geometricSignOfReasonFromGraph",
+    label: "À partir d'un nuage de point d'une suite géométrique, retrouver le signe de sa raison",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricSignOfReasonFromGraphQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    answerType: "QCU",
+    getAnswer,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSets.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsSetA: NodeIdentifiers;
+    nodeIdsSetB: NodeIdentifiers;
+    isAskedACrossB: boolean;
+};
+export declare const findCardinalOfCartesianProductOfFiniteSets: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findCardinalOfCartesianProductOfFiniteSets.d.ts.map

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findCardinalOfCartesianProductOfFiniteSets.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsC7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,eAAe,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA8OF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAkB1E,CAAC"}