math-exercises 3.0.179 → 3.0.181

package/lib/exercises/math/sequences/limits/sequenceLimitReading.js

@@ -1,163 +1,232 @@
-// import {
-//   Exercise,
-//   Proposition,
-//   QCMGenerator,
-//   QuestionGenerator,
-//   VEA,
-//   addValidProp,
-//   shuffleProps,
-//   GetAnswer,
-//   GetHint,
-//   GetCorrection,
-//   GetInstruction,
-//   GetKeys,
-//   GetGGBOptions,
-//   GetQuestionFromIdentifiers,
-//   propWhile,
-//   tryToAddWrongProp,
-// } from "../../../../exercises/exercise.js";
-// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-// import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
-// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-// import { Point } from "../../../../math/geometry/point.js";
-// import { AffineConstructor } from "../../../../math/polynomials/affine.js";
-// import { randint } from "../../../../math/utils/random/randint.js";
-// import {
-//   NodeIdentifiers,
-//   reifyAlgebraic,
-// } from "../../../../tree/nodes/nodeConstructor.js";
-// import { add } from "../../../../tree/nodes/operators/addNode.js";
-// import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
-// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-export {};
-// type Identifiers = {
-//   formula: NodeIdentifiers;
-//   type: number;
-// };
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer);
-//   tryToAddWrongProp(propositions, "\\text{Aucun}");
-//   propWhile(propositions, n, () => {
-//     throw Error("QCM not implemented");
-//   });
-//   return shuffleProps(propositions, n);
-// };
-// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
-//   const { formula, type } = identifiers;
-//   const u = reifyAlgebraic(formula);
-//   switch (type) {
-//     case 0:
-//     default: {
-//       const value = u.toDetailedEvaluation({ n: (100).toTree() }).evaluate();
-//       if (value > 0) return "+\\infty";
-//       return "-\\infty";
-//     }
-//   }
-// };
-// const getInstruction: GetInstruction<Identifiers> = () => {
-//   return `Ci-dessous est tracé le nuage de points représentant une suite $u$.
-// Quelle semble être la limite de la suite $u$ quand $n$ tend vers $+\\infty$ ? Si elle n'en a pas, on écrira "Aucun".`;
-// };
-// const getHint: GetHint<Identifiers> = () => {
-//   return `Observe les termes de la suite lorsque $n$ devient très grand. Si ces termes semblent se rapprocher d'une certaine valeur, alors on peut conjecturer que cette valeur est la limite de la suite. Cette valeur peut être $+\\infty$ ou $-\\infty$.`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return ``;
-// };
-// const getGGBOptions: GetGGBOptions<Identifiers> = (identifiers) => {
-//   const { formula } = identifiers;
-//   const u = reifyAlgebraic(formula);
-//   const values = Array.from({ length: 50 }).map((_, index) => {
-//     return u.toDetailedEvaluation({ n: index.toTree() }).evaluate();
-//   });
-//   const points = values.map((v, i) => new Point(`A_{${i}}`, i, v));
-//   const ggb = new GeogebraConstructor({
-//     commands: points.flatMap((e) =>
-//       e.toGGBCommand({
-//         showLabel: false,
-//         size: 3,
-//       }),
-//     ),
-//     lockedAxesRatio: false,
-//   });
-//   const yMin = Math.min(-1, Math.min(...values.slice(0, 10))) - 2;
-//   const yMax = Math.max(1, Math.max(...values.slice(0, 10))) + 2;
-//   return ggb.getOptions({
-//     coords: [-1, 10, yMin, yMax],
-//   });
-// };
-// const getKeys: GetKeys<Identifiers> = () => {
-//   return ["aucun"];
-// };
-// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
-//   try {
-//     if (answer.includes("\\infty")) return ans === answer;
-//     return numberVEA(ans, answer, undefined, 0.3);
-//   } catch (err) {
-//     return handleVEAError(err);
-//   }
-// };
-// const getSequenceLimitReadingQuestion: QuestionGenerator<Identifiers> = () => {
-//   const type = randint(10);
-//   let formula: NodeIdentifiers;
-//   switch (type) {
-//     case 0:
-//       formula = AffineConstructor.random(undefined, undefined, "n")
-//         .toTree()
-//         .toIdentifiers();
-//       break;
-//     case 1:
-//     default:
-//       {
-//         const k = randint(-10, 10);
-//         formula = add(frac(1, add("n", 1)), k).toIdentifiers();
-//       }
-//       break;
-//   }
-//   const identifiers: Identifiers = {
-//     formula,
-//     type,
-//   };
-//   //0: affine
-//   //1: 1/n+k
-//   //2: an+b/cn+d
-//   //3: exp
-//   //4:
-//   //styles:
-//   //exp, lineaire, alternée, exp décroissant, anarchique
-//   return getQuestionFromIdentifiers(identifiers);
-// };
-// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
-//   identifiers,
-// ) => {
-//   return {
-//     answer: getAnswer(identifiers),
-//     instruction: getInstruction(identifiers),
-//     keys: getKeys(identifiers),
-//     answerFormat: "tex",
-//     identifiers,
-//     hint: getHint(identifiers),
-//     correction: getCorrection(identifiers),
-//     ggbOptions: getGGBOptions(identifiers),
-//   };
-// };
-// export const sequenceLimitReading: Exercise<Identifiers> = {
-//   id: "sequenceLimitReading",
-//   label: "Conjecturer graphiquement la limite d'une suite",
-//   isSingleStep: true,
-//   generator: (nb, opts) =>
-//     getDistinctQuestions(() => getSequenceLimitReadingQuestion(opts), nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-//   isAnswerValid,
-//   subject: "Mathématiques",
-//   getHint,
-//   getCorrection,
-//   getInstruction,
-//   getAnswer,
-//   getGGBOptions,
-//   hasGeogebra: true,
-//   getQuestionFromIdentifiers,
-// };
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.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 { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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 { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "+\\infty");
+    tryToAddWrongProp(propositions, "-\\infty");
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-10, 10) + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return getLimit(identifiers);
+};
+const getInstruction = () => {
+    return `On considère une suite $u$ représentée graphiquement ci-dessous.
+    
+Quelle semble être la limite de la suite $u$ lorsque $n$ tend vers $+\\infty$ ?`;
+};
+const getHint = () => {
+    return `Observe les termes de la suite lorsque $n$ devient très grand. 
+    
+Si ces termes semblent se rapprocher autant que l'on veut d'une certaine valeur, alors on peut conjecturer que la suite admet une limite finie.
+    
+Si ces termes semblent devenir aussi grands ou aussi petits que l'on veut, alors on peut conjecturer que la suite admet une limite infinie.
+
+Sinon, on peut conjecturer que la suite n'a pas de limite.`;
+};
+const getLimit = (identifiers) => {
+    const { formulaIds, type } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    switch (type) {
+        case 0:
+            return round(formula.toDetailedEvaluation({ n: (10).toTree() }).evaluate(), 0).frenchify();
+        case 1:
+        default: {
+            const pos = formula.toDetailedEvaluation({ n: (10).toTree() }).evaluate() > 0;
+            return pos ? "+\\infty" : "-\\infty";
+        }
+    }
+};
+const getCorrection = (identifiers) => {
+    const { type } = identifiers;
+    const limit = getLimit(identifiers);
+    let corr = `On observe les termes de la suite lorsque $n$ devient très grand : c'est à dire qu'on observe les ordonnées des points qui ont une abscisse très grande.
+  
+`;
+    switch (type) {
+        case 0:
+            corr += `Les termes semblent se rapprocher autant que l'on veut de $${limit}$. On peut donc conjecturer que la suite $u$ a une limite finie : 
+    
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${limit}
+$$`;
+            break;
+        case 1:
+            corr += `Les termes semblent devenir aussi ${limit === "+\\infty" ? "grands" : "petits"} que l'on veut. On peut donc conjecturer que la suite $u$ a une limite infinie : 
+    
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${limit}
+$$`;
+            break;
+    }
+    return corr;
+};
+const getGGBOptions = (identifiers) => {
+    const { formulaIds } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    console.log(formula.toTex());
+    const points = Array.from({ length: 50 }).map((_, index) => {
+        return new Point(`A_{${index}}`, index, formula.toDetailedEvaluation({ n: index.toTree() }).evaluate());
+    });
+    const yMin = Math.min(Math.min(...points.slice(0, 10).map((p) => p.y.evaluate())) - 2, -2);
+    const yMax = Math.max(Math.max(...points.slice(0, 10).map((p) => p.y.evaluate())) + 2, 2);
+    const ggb = new GeogebraConstructor({
+        commands: points.flatMap((point) => point.toGGBCommand({
+            showLabel: false,
+            isFixed: true,
+            isSelectionnable: false,
+            size: 3,
+        })),
+        lockedAxesRatio: false,
+        gridDistance: false,
+    });
+    return ggb.getOptions({
+        coords: [-1, 15, yMin, yMax],
+    });
+};
+const getReadSequenceConvergencyTypeQuestion = () => {
+    const type = randint(0, 2);
+    //type0 limites finies :
+    //1/n+k , an+b/cn+d, q^n avec q<1, exp(-kx)
+    //type1 limites infinie :
+    //affine, trinom, q^n avec q>1, exp(kx)
+    //
+    let formulaIds;
+    switch (type) {
+        case 0: {
+            const subtype = randint(0, 4);
+            switch (subtype) {
+                case 0: {
+                    //1/(n+1)+k
+                    const k = randint(-5, 5);
+                    formulaIds = add(frac(1, add("n", 1)), k).toIdentifiers();
+                    break;
+                }
+                case 1: {
+                    //an+b/cn+d
+                    const c = randint(-5, 5, [0]);
+                    const a = c * randint(-5, 5, [0]);
+                    const b = randint(-5, 5, [0]);
+                    const d = doWhile(() => randint(-5, 5, [0]), (x) => c / a === x / b || (Math.floor(-x / c) === -x / c && -x / c > 0));
+                    formulaIds = frac(add(multiply(a, "n"), b), add(multiply(c, "n"), d)).toIdentifiers();
+                    break;
+                }
+                case 2: {
+                    //aq^n q<1
+                    const q = randfloat(0.1, 0.9, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, power(q, "n")).toIdentifiers();
+                    break;
+                }
+                case 3:
+                default: {
+                    //aexp(-kx)
+                    const k = randfloat(0.1, 0.9, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, exp(multiply(-k, "n"))).toIdentifiers();
+                    break;
+                }
+            }
+            break;
+        }
+        case 1:
+        default: {
+            const subtype = randint(0, 4);
+            switch (subtype) {
+                case 0: {
+                    //affine
+                    const affine = AffineConstructor.random(undefined, undefined, "n").toTree();
+                    formulaIds = affine.toIdentifiers();
+                    break;
+                }
+                case 1: {
+                    //trinom
+                    const trinom = TrinomConstructor.random(undefined, undefined, undefined, "n").toTree();
+                    formulaIds = trinom.toIdentifiers();
+                    break;
+                }
+                case 2: {
+                    //q^n
+                    const q = randfloat(1.1, 1.4, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, power(q, "n")).toIdentifiers();
+                    break;
+                }
+                case 3:
+                default: {
+                    //aexp(kx)
+                    const k = randfloat(1.1, 1.4, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, exp(multiply(k, "n"))).toIdentifiers();
+                    break;
+                }
+            }
+            break;
+        }
+    }
+    const identifiers = {
+        type,
+        formulaIds,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        if (answer.includes("\\infty"))
+            return ans === answer;
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const sequenceLimitReading = {
+    id: "sequenceLimitReading",
+    label: "Conjecturer graphiquement la limite d'une suite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadSequenceConvergencyTypeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    isAnswerValid,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/variations/genericSequenceVariations.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffs: number[];
+};
+export declare const genericSequenceVariations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=genericSequenceVariations.d.ts.map

package/lib/exercises/math/sequences/variations/genericSequenceVariations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genericSequenceVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/variations/genericSequenceVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA0HF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/sequences/variations/genericSequenceVariations.js

@@ -0,0 +1,122 @@
+import { shuffleProps, tryToAddWrongProp, addValidProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs, "n");
+    return `Soit $u$ la suite définie par :
+  
+$$
+u_n = ${u.toTree().toTex()}
+$$ 
+    
+En étudiant le signe de $u_{n+1}-u_n$, déterminer le sens de variations de $u$.`;
+};
+const getAnswer = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs, "n");
+    const [b, a] = u.coefficients.slice(1);
+    const root = Math.ceil((-a - b) / (2 * a));
+    const answer = root <= 0
+        ? a > 0
+            ? "Croissante"
+            : "Décroissante"
+        : `${a > 0 ? "Croissante" : "Décroissante"} à partir du rang $${root}$`;
+    return answer;
+};
+const getHint = () => {
+    return `Exprime $u_{n+1}$ en fonction de $n$, puis calcule $u_{n+1}-u_n$.
+  
+Ensuite, étudie le signe de ce résultat. Sur les intervalles où il est positif, la suite est croissante. Sur ceux où il est négatif, la suite est décroissante.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs, "n").toTree();
+    const unP1 = u.toDetailedEvaluation({ n: add("n", 1) });
+    const unP1Simp = unP1.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const diff = substract(unP1Simp, u).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const b = diff
+        .toDetailedEvaluation({ n: (0).toTree() })
+        .simplify()
+        .evaluate();
+    const a = substract(diff.toDetailedEvaluation({ n: (1).toTree() }), b)
+        .simplify()
+        .evaluate();
+    const aff = new Affine(a, b, "n");
+    return `On exprime $u_{n+1}$ : 
+  
+${alignTex([
+        ["u_{n+1}", "=", unP1.toTex()],
+        ["", "=", unP1Simp.toTex()],
+    ])}
+
+On a donc pour tout entier $n$ :
+
+$$
+u_{n+1}-u_n = ${diff.toTex()}
+$$
+
+On étudie le signe de $${diff.toTex()}$ : 
+
+$$
+${firstDegreeInequationResolutionTex(aff, "\\ge", (0).toTree())}
+$$
+
+On en conclut que $u$ est ${getAnswer(identifiers).toLocaleLowerCase()}.
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getGenericSequenceVariationsQuestion = () => {
+    const u = PolynomialConstructor.randomWithOrder(2, "n");
+    const identifiers = { coeffs: u.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const [b, a] = coeffs.slice(1);
+    const root = Math.ceil((-a - b) / (2 * a));
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Croissante", "raw");
+    tryToAddWrongProp(propositions, "Décroissante", "raw");
+    const fakeRoot = root <= 0 ? randint(1, 10) : root;
+    tryToAddWrongProp(propositions, `Croissante à partir du rang $${fakeRoot}$`, "raw");
+    tryToAddWrongProp(propositions, `Décroissante à partir du rang $${fakeRoot}$`, "raw");
+    return shuffleProps(propositions, n);
+};
+export const genericSequenceVariations = {
+    id: "genericSequenceVariations",
+    connector: "=",
+    label: "Déterminer le sens de variations d'une suite en étudiant la différence de deux termes",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getGenericSequenceVariationsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: "QCU",
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/variations/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./expressConsecutiveTermsDifference.js";
+export * from "./sequenceVariationFromTermsDifference.js";
+export * from "./genericSequenceVariations.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/variations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/variations/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/sequences/variations/index.js

@@ -1 +1,3 @@
 export * from "./expressConsecutiveTermsDifference.js";
+export * from "./sequenceVariationFromTermsDifference.js";
+export * from "./genericSequenceVariations.js";

package/lib/exercises/math/sequences/variations/sequenceVariationFromTermsDifference.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    diffIdentifiers: NodeIdentifiers;
+    type: number;
+};
+export declare const sequenceVariationFromTermsDifference: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequenceVariationFromTermsDifference.d.ts.map

package/lib/exercises/math/sequences/variations/sequenceVariationFromTermsDifference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceVariationFromTermsDifference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/variations/sequenceVariationFromTermsDifference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;CAEd,CAAC;AAmJF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAqBtE,CAAC"}