math-exercises 3.0.188 → 3.0.189

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationStandardDeviation.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationStandardDeviation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationStandardDeviation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationStandardDeviation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;CACvC,CAAC;AA6HF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAqB1E,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationStandardDeviation.js

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, sqrt(RationalConstructor.randomIrreductible(30).toTree())
+            .simplify()
+            .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getStandardDeviation().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Que vaut l'écart-type $\\sigma(X)$ de $X$ ?
+
+Donner la valeur exacte ou une valeur arrondie au centième.`);
+};
+const getHint = () => {
+    return `Dresse la loi de probabilité de $X$. Pour cela, détermine les valeurs possibles $x_i$ que peut prendre $X$, puis pour chaque valeur, calcule la probabilité $p_i$ associée.
+  
+Tu peux alors calculer l'espérance de $X$ par la formule : 
+
+$$
+E(X) = x_1\\times p_1 + \\ldots + x_n\\times p_n
+$$
+
+La variance $V(X)$ s'obtient par la formule :
+  
+$$
+V(X) = p_1(x_1-E(X))^2 + \\ldots + p_n(x_n-E(X))^2
+$$
+
+Et enfin, l'écart-type est la racine carrée de la variance : 
+
+$$
+\\sigma(X) = \\sqrt{V(X)}
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return `On dresse la loi de probabilité de $X$ : 
+  
+${va.getLawMdTable()}
+
+Puis on calcule l'espérance : 
+
+${alignTex([
+        ["E(X)", "=", va.getAverage().toTex()],
+        ["", "=", va.getAverage().simplify().toTex()],
+    ])}
+  
+Puis la variance : 
+
+${alignTex([
+        ["V(X)", "=", va.getVariance().toTex()],
+        ["", "=", va.getVariance().simplify().toTex()],
+    ])}
+
+Enfin, on en déduit l'écart type : 
+
+${alignTex([
+        ["\\sigma(X)", "=", "\\sqrt{V(X)}"],
+        ["", "=", va.getStandardDeviation().simplify().toTex()],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return rationalVEA(ans, answer) || parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationAverageQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    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),
+    };
+};
+export const randomVariableSituationStandardDeviation = {
+    id: "randomVariableSituationStandardDeviation",
+    connector: "=",
+    label: "Calculer l'écart-type $\\sigma(X)$ d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationValues.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationValues.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;CACvC,CAAC;AAuPF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationValues.js

@@ -0,0 +1,211 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return new DiscreteSetNode(va.xValues).simplify().toTex();
+};
+const getPropositions = (_n, { answer, params }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    switch (params.id) {
+        case "coin":
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), params.b.toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode(["\\text{Pile}".toTree(), "\\text{Face}".toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), (-params.b).toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), params.b.toTree()])
+                .simplify()
+                .toTex());
+            break;
+        case "urne":
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                "\\text{Blanche}".toTree(),
+                "\\text{Rouge}".toTree(),
+                "\\text{Noire}".toTree(),
+            ])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                params.b.toTree(),
+                params.r.toTree(),
+                params.n.toTree(),
+            ])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                params.gb.toTree(),
+                params.gr.toTree(),
+                (-params.gn).toTree(),
+            ])
+                .simplify()
+                .toTex());
+            break;
+        case "diceMultiple": {
+            const allValues = [...Array(params.n).keys()].map((i) => i + 1);
+            const multiples = [];
+            for (let i = 1; i < params.n; i++) {
+                if (i % params.winningMultiple === 0) {
+                    multiples.push(i);
+                }
+            }
+            tryToAddWrongProp(propositions, new DiscreteSetNode(multiples.map((m) => m.toTree()))
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode(allValues.map((v) => v.toTree()))
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.gain.toTree(), params.loss.toTree()])
+                .simplify()
+                .toTex());
+        }
+    }
+    return shuffle(propositions);
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Quel est l'ensemble des valeurs possibles pour $X$ ?`);
+};
+const getHint = (identifiers) => {
+    const { params } = identifiers;
+    switch (params.id) {
+        case "coin":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd des points) en fonction du résultat de ses lancers. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "urne":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la boule qu'il a tirée. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "diceMultiple":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la face obtenue. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "cards":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la carte qu'il a tirée. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        // case "diceSum":
+        //   return `Chaque dé peut valoir $1$, $2$, $3$ ou $4$. Cela créé donc $16$ résultats possibles, par exemple $1+1=2$, $3+4=7$, etc... Détermine tous les résultats possibles.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    switch (params.id) {
+        case "coin":
+            return `On liste toutes les issues possibles : 
+      
+- $2$ piles : le gain du joueur est alors $${multiply(2, params.a).toSimplificationTex()}$ points.
+- $1$ pile, $1$ face : le gain du joueur est alors $${substract(params.a, params.b).toSimplificationTex()}$ points.
+- $2$ faces: le gain du joueur est alors $${opposite(multiply(2, params.b)).toSimplificationTex()}$ points.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+        case "urne":
+            return `Le gain pour chaque tirage vaut : 
+
+- $${params.gb}$ si on tire une boule blanche ; 
+- $${params.gr}$ si on tire une boule rouge ;
+- $${params.gn}$ si on tire une boule noire.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case "diceMultiple":
+            return `Si on obtient un multiple de $${params.winningMultiple}$, on gagne $${params.gain}\\ €$, donc $X$ vaut $${params.gain}$ dans ce cas. Sinon, on perd $${params.loss}\\ €$, donc $X$ vaut $-${params.loss}$. 
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case "cards":
+            return `Le gain pour chaque tirage vaut : 
+
+- $${params.gAs}$ si on tire un as ; 
+- $${params.gFigure}$ si on tire une figure ;
+- $${params.gOther}$ si on tire une autre carte.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        //     case "diceSum": {
+        //       const results = [["\\ ", "1", "2", "3", "4"], ["1"], ["2"], ["3"], ["4"]];
+        //       for (let i = 1; i < 5; i++) {
+        //         for (let j = 1; j < 5; j++) {
+        //           results[i][j] = (i + j).frenchify();
+        //         }
+        //       }
+        //       return `Voici tous les résultats possibles en fonction du résultat de chaque dé :
+        // ${mdTable(results, true)}
+        // Les valeurs possibles pour $X$ sont donc :
+        // ${mdTable(getAnswerTable(identifiers), true)}`;
+        //     }
+    }
+};
+const getKeys = () => {
+    return ["lbrace", "semicolon", "rbrace"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationValuesQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    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),
+    };
+};
+export const randomVariableSituationValues = {
+    id: "randomVariableSituationValues",
+    label: "Donner l'ensemble des valeurs possibles d'une variable aléatoire avec contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationVariance.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationVariance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationVariance.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationVariance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;CACvC,CAAC;AA4GF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationVariance.js

@@ -0,0 +1,113 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductibleWithSign().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getVariance().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Que vaut la variance $V(X)$ de $X$ ?
+
+Donner la valeur exacte ou une valeur arrondie au centième.`);
+};
+const getHint = () => {
+    return `Dresse la loi de probabilité de $X$. Pour cela, détermine les valeurs possibles $x_i$ que peut prendre $X$, puis pour chaque valeur, calcule la probabilité $p_i$ associée.
+  
+Tu peux alors calculer l'espérance de $X$ par la formule : 
+
+$$
+E(X) = x_1\\times p_1 + \\ldots + x_n\\times p_n
+$$
+
+La variance $V(X)$ s'obtient par la formule :
+  
+$$
+V(X) = p_1(x_1-E(X))^2 + \\ldots + p_n(x_n-E(X))^2
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return `On dresse la loi de probabilité de $X$ : 
+  
+${va.getLawMdTable()}
+
+Puis on calcule l'espérance : 
+
+${alignTex([
+        ["E(X)", "=", va.getAverage().toTex()],
+        ["", "=", va.getAverage().simplify().toTex()],
+    ])}
+  
+Enfin, on calcule la variance : 
+
+${alignTex([
+        ["V(X)", "=", va.getVariance().toTex()],
+        ["", "=", va.getVariance().simplify().toTex()],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationAverageQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    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),
+    };
+};
+export const randomVariableSituationVariance = {
+    id: "randomVariableSituationVariance",
+    connector: "=",
+    label: "Calculer la variance $V(X)$ d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituations.d.ts

@@ -0,0 +1,41 @@
+import { RandomVariable } from "../../../../../math/probability/randomVariable.js";
+type UrneParams = {
+    b: number;
+    r: number;
+    n: number;
+    gb: number;
+    gr: number;
+    gn: number;
+};
+type CoinParams = {
+    b: number;
+    a: number;
+    n: number;
+};
+type DiceMultipleParams = {
+    n: number;
+    winningMultiple: number;
+    gain: number;
+    loss: number;
+};
+type CardsParams = {
+    gAs: number;
+    gFigure: number;
+    gOther: number;
+};
+export type RandomVariableSituationParams = (UrneParams & {
+    id: "urne";
+}) | (CoinParams & {
+    id: "coin";
+}) | (DiceMultipleParams & {
+    id: "diceMultiple";
+}) | (CardsParams & {
+    id: "cards";
+});
+export declare const getRandomVariableSituation: (params: RandomVariableSituationParams) => {
+    getContext: () => string;
+    getVA: () => RandomVariable;
+};
+export declare const buildRandomVariableSituation: () => RandomVariableSituationParams;
+export {};
+//# sourceMappingURL=randomVariableSituations.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituations.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAU1E,KAAK,UAAU,GAAG;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAsDF,KAAK,UAAU,GAAG;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmEF,KAAK,kBAAkB,GAAG;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkCF,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4BF,MAAM,MAAM,6BAA6B,GACrC,CAAC,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7B,CAAC,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7B,CAAC,kBAAkB,GAAG;IAAE,EAAE,EAAE,cAAc,CAAA;CAAE,CAAC,GAC7C,CAAC,WAAW,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAIpC,eAAO,MAAM,0BAA0B,GACrC,QAAQ,6BAA6B;;;CActC,CAAC;AAEF,eAAO,MAAM,4BAA4B,QACnC,6BAkBH,CAAC"}