math-exercises 3.0.172 → 3.0.173

package/lib/exercises/math/sequences/geometric/sum/geometricComputeSumWithDots.js

@@ -0,0 +1,248 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } 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 { randint } from "../../../../../math/utils/random/randint.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 { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const strForValue = (v) => {
+    return v < 0 ? `(${v.frenchify()})` : `${v.frenchify()}`;
+};
+const valueForRank = (initial, reason, rank) => {
+    return initial * Math.pow(reason, rank);
+};
+const strSumWithDots = (initial, reason, firstRank, lowRankDots, highRankDots, lastRank) => {
+    const arrRankStart = [...Array(lowRankDots - firstRank).keys()].map((i) => i + firstRank);
+    const arrRankEnd = [...Array(lastRank - highRankDots).keys()].map((i) => i + highRankDots + 1);
+    const [arrValueStart, arrValueEnd] = [arrRankStart, arrRankEnd].map((arrRank) => arrRank.map((rank) => strForValue(valueForRank(initial, reason, rank))));
+    const [strStart, strEnd] = [arrValueStart, arrValueEnd].map((arrValue) => arrValue.join(" + "));
+    const strFlat = [strStart, strEnd].join(` + \\ldots + `);
+    const maxStrLength = 35;
+    if (strFlat.length < maxStrLength) {
+        return `
+
+$$
+${strFlat}
+$$
+
+`;
+    }
+    else {
+        return `
+
+$$
+${strStart}
+$$
+
+$$
++ \\ldots
+$$
+
+$$
++ \\ ${strEnd}
+$$
+
+`;
+    }
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, nbTerms, lowRankDots, highRankDots } = identifiers;
+    const lastRank = firstRank + nbTerms - 1;
+    return `Soit $u$ une suite géométrique. 
+
+Calculer la somme des premiers termes de $u$ ${isGiveCount
+        ? `(la somme contient en tout $${nbTerms.frenchify()}$ termes)`
+        : ""}: 
+
+${strSumWithDots(initial, reason, firstRank, lowRankDots, highRankDots, lastRank)}
+
+`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, nbTerms } = identifiers;
+    const firstValue = valueForRank(initial, reason, firstRank);
+    const nodeAnswer = multiply(firstValue, frac(substract(1, power(reason, nbTerms)), substract(1, reason)));
+    return nodeAnswer;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).evaluate().frenchify();
+};
+const getHint = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    return `La somme $S$ des $n$ premiers termes d'une suite géométrique s'obtient par la formule : 
+  
+$$
+S = {1^{\\text{er}}\\text{terme}} \\times \\frac{1 - q^n}{1 - q}
+$$
+
+${!isGiveCount
+        ? "Il te faut donc déterminer combien il y a de termes dans la somme donnée."
+        : ""}`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, nbTerms, reason } = identifiers;
+    const firstValue = valueForRank(initial, reason, firstRank);
+    const lastRank = firstRank + nbTerms - 1;
+    const lastValue = valueForRank(initial, reason, lastRank);
+    const answerNode = getAnswerNode(identifiers, opts);
+    return `La somme $S$ des $n$ premiers termes d'une suite géométrique s'obtient par la formule : 
+  
+$$
+S = {1^{\\text{er}}\\text{terme}} \\times \\frac{1 - q^n}{1 - q}
+$$
+
+On calcule la raison de la suite : 
+
+${alignTex([
+        [
+            "q",
+            "=",
+            `\\frac{u_{${(firstRank + 1).frenchify()}}}{u_{${firstRank.frenchify()}}}`,
+        ],
+        [
+            "q",
+            "=",
+            `\\frac{${strForValue(valueForRank(initial, reason, firstRank + 1))}}{${strForValue(valueForRank(initial, reason, firstRank))}}`,
+        ],
+        ["q", "=", `${reason.frenchify()}`],
+    ])}
+
+${(() => {
+        if (isGiveCount) {
+            return "";
+        }
+        else {
+            return `Il faut maintenant déterminer combien il y a de termes en tout.
+
+${alignTex([
+                [
+                    "\\text{dernier terme}",
+                    "=",
+                    `{1^{\\text{er}}\\text{terme}} \\times q^{n-1}`,
+                ],
+                [
+                    "\\lvert \\text{dernier terme} \\rvert",
+                    "=",
+                    `\\lvert {1^{\\text{er}}\\text{terme}} \\rvert \\times {\\lvert q \\rvert}^{n-1}`,
+                ],
+            ])}
+
+${alignTex([
+                [
+                    "n",
+                    "=",
+                    `\\frac{\\ln{\\lvert${strForValue(lastValue)}\\rvert} - \\ln{\\lvert${strForValue(firstValue)}\\rvert}}{\\ln{\\lvert${reason.frenchify()}\\rvert}} + 1`,
+                ],
+                ["n", "=", `${nbTerms.frenchify()}`],
+            ])}
+
+`;
+        }
+    })()}
+
+La somme des $${nbTerms}$ premiers termes de $u$ vaut donc :
+
+$$
+${answerNode.toTex({ forceParenthesis: true })} = ${answerNode
+        .evaluate()
+        .frenchify()}  
+$$`;
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (studentAns, { answer }) => {
+    try {
+        return numberVEA(studentAns, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const initial = randint(-9, 10, [0]);
+    const signReason = coinFlip() ? 1 : -1;
+    const reason = signReason * randint(2, 6);
+    const nbTerms = randint(7, 15);
+    const minRankDots = firstRank + 2;
+    const lastRank = firstRank + nbTerms - 1;
+    const lowRankDots = randint(minRankDots, Math.min(minRankDots + randint(1, 3), lastRank));
+    const highRankDots = randint(Math.max(lastRank - randint(1, 3), lowRankDots), lastRank);
+    const identifiers = {
+        initial,
+        reason,
+        nbTerms,
+        lowRankDots,
+        highRankDots,
+    };
+    return identifiers;
+};
+const getGeometricComputeSumWithDotsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {
+    isGiveCount: true,
+});
+const options = [
+    generatorOptionFirstTermRankOne,
+    {
+        id: "isGiveCount",
+        label: "Donner $n$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isGiveCount,
+    },
+];
+export const geometricComputeSumWithDots = {
+    id: "geometricComputeSumWithDots",
+    connector: "=",
+    label: "Calculer une somme donnée avec $\\ldots$ (suite géométrique)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricComputeSumWithDotsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/sequences/geometric/sum/geometricFirstTermsGeneralSum.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    firstRank: number;
+    firstValue: number;
+    reason: number;
+    nbTerms: number;
+};
+type Options = {
+    positiveReason: boolean;
+    firstRankOne: boolean;
+};
+export declare const geometricFirstTermsGeneralSum: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFirstTermsGeneralSum.d.ts.map

package/lib/exercises/math/sequences/geometric/sum/geometricFirstTermsGeneralSum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/sum/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAkBF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBxE,CAAC"}

package/lib/exercises/math/sequences/geometric/sum/geometricFirstTermsGeneralSum.js

@@ -0,0 +1,126 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.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 { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHint = () => {
+    return `On utilise la formule : 
+  
+$$
+S = \\text{premier terme} \\times \\frac{1-\\text{raison}^{\\text{nombre de termes}}}{1-\\text{raison}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { firstValue, nbTerms, reason } = identifiers;
+    return `On utilise la formule : 
+  
+$$
+S = \\text{premier terme} \\times \\frac{1-\\text{raison}^{\\text{nombre de termes}}}{1-\\text{raison}}
+$$
+
+Ici, la raison est $${reason}$, le premier terme est $${firstValue}$ et le nombre de termes est $${nbTerms}$.
+
+On a donc : 
+
+${alignTex([
+        [
+            "S",
+            "=",
+            multiply(firstValue, frac(substract(1, power(reason, nbTerms)), substract(1, reason))).toTex(),
+        ],
+        [
+            "",
+            "=",
+            multiply(firstValue, frac(substract(1, power(reason, nbTerms)).simplify({
+                calculatePowers: true,
+            }), substract(1, reason).simplify())).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getInstruction = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
+    return `Soit $u$ une suite géométrique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. 
+  
+Calculer la somme des $${nbTerms}$ premiers termes de $u$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstValue, reason, nbTerms } = identifiers;
+    const answer = (firstValue * (1 - Math.pow(reason, nbTerms))) / (1 - reason);
+    return answer.frenchify();
+};
+const getGeometricFirstTermsGeneralSumQuestion = (opts) => {
+    const firstRank = opts?.firstRankOne ? 1 : random([0, 1]);
+    const firstValue = randint(-9, 10, [0]);
+    const reason = opts?.positiveReason ? randint(2, 5) : randint(-5, 5, [0, 1]);
+    const nbTerms = randint(4, 9);
+    const identifiers = {
+        firstRank,
+        firstValue,
+        reason,
+        nbTerms,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, firstValue, reason }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fake = (firstValue *
+            (1 -
+                Math.pow(reason === -1 ? randint(2, 5) : reason, randint(3, 10)))) /
+            (1 - reason);
+        tryToAddWrongProp(propositions, fake.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const options = [
+    {
+        id: "positiveReason",
+        label: "Utiliser des raisons positives",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+    {
+        id: "firstRankOne",
+        label: "Toujours utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
+export const geometricFirstTermsGeneralSum = {
+    id: "geometricFirstTermsGeneralSum",
+    connector: "=",
+    label: "Somme des termes d'une suite géométrique (cas général)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFirstTermsGeneralSumQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    options,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/sum/geometricFirstTermsSum.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    raison: number;
+    final: number;
+};
+export declare const geometricFirstTermsSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFirstTermsSum.d.ts.map

package/lib/exercises/math/sequences/geometric/sum/geometricFirstTermsSum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/sum/geometricFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2FF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/math/sequences/geometric/sum/geometricFirstTermsSum.js

@@ -0,0 +1,91 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { raison, final } = identifiers;
+    return `Calculer la somme suivante : 
+  
+$$
+1 + ${raison} + ${raison}^2 + \\ldots + ${raison}^{${final}}
+$$`;
+};
+const getHint = () => {
+    return `On utilise la formule : 
+  
+$$
+1 + q + q^2 + \\ldots + q^n = \\frac{1-q^{n+1}}{1-q}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { raison, final } = identifiers;
+    return `On utilise la formule : 
+  
+$$
+1 + q + q^2 + \\ldots + q^n = \\frac{1-q^{n+1}}{1-q}
+$$
+
+Ici, $q = ${raison}$ et $n = ${final}$.
+
+On a donc : 
+
+${alignTex([
+        ["S", "=", `\\frac{1-${raison}^{${final}+1}}{1-${raison}}`],
+        ["", "=", `\\frac{${1 - raison ** (final + 1)}}{${1 - raison}}`],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getAnswer = (identifiers) => {
+    const { raison, final } = identifiers;
+    const answer = (raison ** (final + 1) - 1) / (raison - 1) + "";
+    return answer;
+};
+const getGeometricFirstTermsSumQuestion = () => {
+    const raison = randint(2, 8);
+    const final = randint(5, 10);
+    const identifiers = { raison, final };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, raison, final }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, (raison ** (final + 1) - 1).toString());
+    tryToAddWrongProp(propositions, ((raison ** final - 1) / (raison - 1)).toString());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = randint(1000, 10000) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const geometricFirstTermsSum = {
+    id: "geometricFirstTermsSum",
+    connector: "=",
+    label: "Somme des termes d'une suite géométrique",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getGeometricFirstTermsSumQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sequences/geometric/sum/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./geometricFirstTermsSum.js";
+export * from "./geometricFirstTermsGeneralSum.js";
+export * from "./geometricComputeSumWithDots.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/sum/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/sum/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/sequences/geometric/sum/index.js

@@ -0,0 +1,3 @@
+export * from "./geometricFirstTermsSum.js";
+export * from "./geometricFirstTermsGeneralSum.js";
+export * from "./geometricComputeSumWithDots.js";

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

@@ -0,0 +1,2 @@
+export * from "./seqArithmGeomRecurrenceFormulaUsage.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/seqArithmGeom/index.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./seqArithmGeomRecurrenceFormulaUsage.js";

package/lib/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    rank1: number;
+    value1: number;
+    coeffs: number[];
+    rankAsked: number;
+};
+type Options = OptionFirstTermRankOne & {
+    distanceOfRankAsked: string;
+};
+export declare const seqArithmGeomRecurrenceFormulaUsage: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=seqArithmGeomRecurrenceFormulaUsage.d.ts.map

package/lib/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seqArithmGeomRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AA8C3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoMF,KAAK,OAAO,GAAG,sBAAsB,GAAG;IAAE,mBAAmB,EAAE,MAAM,CAAA;CAAE,CAAC;AAkBxE,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}