math-exercises 3.0.125 → 3.0.126

package/lib/exercises/math/calcul/ordering/compareA10N.js

@@ -0,0 +1,327 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getTexForA10N = (a10N) => {
+    const { a, n } = a10N;
+    return `${a.frenchify()} \\times 10^{${n}}`;
+};
+const getSciMultNodeForA10N = (a10N) => {
+    const { a, n } = a10N;
+    const sign = Math.sign(a);
+    const sciMultNodeA = getSciMultNodeForA(sign * a);
+    const factor = sign * sciMultNodeA.leftChild.evaluate();
+    const nodePower10 = sciMultNodeA.rightChild;
+    const exponent = nodePower10.rightChild.evaluate() + n;
+    return multiply(factor, power(10, exponent));
+};
+const getSciMultNodeForA = (a) => {
+    //a must be positive
+    const exponent = Math.floor(Math.log10(a));
+    const factor = round(frac(a, power(10, exponent)).evaluate(), 2);
+    const sciMultNode = multiply(factor, power(10, exponent));
+    return sciMultNode;
+};
+const compareFuncForA10N = (a10N1, a10N2) => {
+    const { a: a1, n: n1 } = a10N1;
+    const { a: a2, n: n2 } = a10N2;
+    const [sign1, sign2] = [a1, a2].map((a) => Math.sign(a));
+    if (sign1 !== sign2) {
+        return sign1 - sign2;
+    }
+    else {
+        const sign = sign1;
+        const [nodeSciA1, nodeSciA2] = [a1, a2].map((a) => getSciMultNodeForA(sign * a));
+        const [factorA1, factorA2] = [nodeSciA1, nodeSciA2].map((nodeSciA) => nodeSciA.leftChild.evaluate());
+        const [nA1, nA2] = [nodeSciA1, nodeSciA2].map((nodeSciA) => nodeSciA.rightChild.rightChild.evaluate());
+        const exponent1 = n1 + nA1;
+        const exponent2 = n2 + nA2;
+        if (exponent1 !== exponent2) {
+            return sign * (exponent1 - exponent2);
+        }
+        else {
+            return sign * (factorA1 - factorA2);
+        }
+    }
+};
+const getInstruction = (identifiers) => {
+    const { items } = identifiers;
+    return `Ranger par ordre croissant les nombres suivants :
+
+$$
+${items.map((item) => getTexForA10N(item)).join(" ; ")}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { signType } = identifiers;
+    return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
+Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
+${(() => {
+        switch (signType) {
+            case "positifs":
+                return `Ici, tous les nombres sont positifs, donc
+on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
+C'est un double tri.`;
+            case "négatifs":
+                return `Ici, tous les nombres sont négatifs, donc
+on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+C'est un double tri.`;
+            case "mélange":
+                return `Ici, il y a des nombres négatifs et des nombres positifs.
+On commence par les négatifs :
+On range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+Puis on range les positifs :
+On range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.`;
+        }
+    })()}
+`;
+};
+const getCorrection = (identifiers) => {
+    const { signType, items } = identifiers;
+    return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
+Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
+
+${items
+        .map((item) => `
+  
+$$
+${getTexForA10N(item)} = ${getSciMultNodeForA10N(item).toTex()}
+$$
+
+`)
+        .join("")}
+
+${(() => {
+        switch (signType) {
+            case "positifs": {
+                const positive = items.toSorted(compareFuncForA10N);
+                return `Ici, tous les nombres sont positifs, donc
+on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
+C'est un double tri.
+
+$$
+${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Conclusion :
+
+$$
+${positive.map((item) => getTexForA10N(item)).join("<")}
+$$
+
+`;
+            }
+            case "négatifs": {
+                const negative = items.toSorted(compareFuncForA10N);
+                return `Ici, tous les nombres sont négatifs, donc
+on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+C'est un double tri.
+
+$$
+${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Conclusion :
+
+$$
+${negative.map((item) => getTexForA10N(item)).join("<")}
+$$
+`;
+            }
+            case "mélange": {
+                const positive = items
+                    .filter(({ a }) => a >= 0)
+                    .toSorted(compareFuncForA10N);
+                const negative = items
+                    .filter(({ a }) => a < 0)
+                    .toSorted(compareFuncForA10N);
+                return `Ici, il y a des nombres négatifs et des nombres positifs.
+On commence par les négatifs :
+on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+
+$$
+${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Puis on range les positifs :
+on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
+
+$$
+${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Conclusion :
+
+$$
+${[...negative, ...positive].map((item) => getTexForA10N(item)).join("<")}
+$$
+`;
+            }
+        }
+    })()}
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    permute(items)
+        .slice(0, 5)
+        .forEach((permutedItems) => {
+        const arrayOfTex = permutedItems.map((item) => getTexForA10N(item));
+        tryToAddWrongProp(propositions, arrayOfTex.join("<"));
+        tryToAddWrongProp(propositions, arrayOfTex.join(">"));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { items } = identifiers;
+    const answer = items
+        .toSorted(compareFuncForA10N)
+        .map((item) => getTexForA10N(item))
+        .join("<");
+    return answer;
+};
+const isAnswerValid = (ans, { answer, items }) => {
+    const nbItems = items.length;
+    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split("<").map((tex) => parseAlgebraic(tex)));
+    return (ansNodes.length === nbItems &&
+        [...Array(nbItems).keys()].every((i) => ansNodes[i].equals(answerNodes[i])));
+};
+const getKeys = (identifiers) => {
+    const { items } = identifiers;
+    return [
+        "sup",
+        "inf",
+        ...items.map((item) => {
+            const tex = getTexForA10N(item);
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareA10NQuestion = (optsIn) => {
+    const opts = optsIn ? Object.assign(optsIn, optsDefault) : optsDefault;
+    const signType = random(opts.signTypes);
+    const nbCollisions = random(opts.nbCollisions);
+    const nbItems = 4;
+    let arrayOfA = [...Array(nbItems).keys()].map(() => {
+        const pow10 = random([0, 1, 2]);
+        const nbDigits = probaLawFlip([
+            [0, 0.5],
+            [1, 0.3],
+            [2, 0.2],
+        ]);
+        return round(randfloat(0, 10, 2, [10]) * Math.pow(10, pow10) +
+            randfloat(0, 1, nbDigits), 2);
+    });
+    switch (signType) {
+        case "négatifs":
+            arrayOfA = arrayOfA.map((a) => -1 * a);
+            break;
+        case "mélange":
+            {
+                const nbRandomSign = nbItems - 2;
+                const signs = shuffle([
+                    +1,
+                    -1,
+                    ...[...Array(nbRandomSign).keys()].map(() => (coinFlip() ? +1 : -1)),
+                ]);
+                arrayOfA = arrayOfA.map((a, i) => signs[i] * a);
+            }
+            break;
+        default:
+            break;
+    }
+    const nMin = -90;
+    const nMax = +90;
+    const combStep = 5;
+    const combOffset = randint(0, combStep);
+    const poolOfN = [...Array(nMax - nMin + 1).keys()]
+        .map((i) => i + nMin)
+        .filter((n) => n % combStep === combOffset);
+    const subPoolOfN = randomMany(poolOfN, nbItems - nbCollisions);
+    let arrayOfN = subPoolOfN;
+    for (let i = 0; i < nbCollisions; i++) {
+        arrayOfN.push(random(subPoolOfN) + random([-2, -1, 0, 1, 2]));
+    }
+    arrayOfN = shuffle(arrayOfN);
+    const items = [...Array(nbItems).keys()].map((i) => {
+        return {
+            a: arrayOfA[i],
+            n: arrayOfN[i],
+        };
+    });
+    return getQuestionFromIdentifiers({
+        signType,
+        items,
+    });
+};
+const optsDefault = {
+    signTypes: ["positifs", "négatifs", "mélange"],
+    nbCollisions: [0, 1, 2, 3],
+};
+const options = [
+    {
+        id: "signTypes",
+        label: "Signes des nombres",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["positifs", "négatifs", "mélange"],
+        defaultValue: optsDefault.signTypes,
+    },
+    {
+        id: "nbCollisions",
+        label: "Nombre de collisions",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [0, 1, 2, 3],
+        defaultValue: optsDefault.nbCollisions,
+    },
+];
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareA10N = {
+    id: "compareA10N",
+    label: "Comparer des nombres de la forme $a \\times 10^n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareA10NQuestion(opts), nb, 30),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.d.ts

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

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareABUsingQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareABUsingQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AAyRF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.js

@@ -0,0 +1,221 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { FunctionsIds, isFunctionNode, } from "../../../../tree/nodes/functions/functionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } 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 { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const randomOperatorReplacementDict = () => {
+    const operatorIds = [
+        OperatorIds.add,
+        OperatorIds.multiply,
+        OperatorIds.fraction,
+    ];
+    return Object.fromEntries(shuffle(operatorIds).map((opId, i) => [opId, operatorIds[i]]));
+};
+const randomFunctionReplacementDict = () => {
+    const functionIds = [FunctionsIds.sqrt, FunctionsIds.abs];
+    return Object.fromEntries(shuffle(functionIds).map((fId, i) => [fId, functionIds[i]]));
+};
+const nodeByReplacingOperations = (node, operatorReplacementDict, functionReplacementDict) => {
+    if (isOperatorNode(node)) {
+        const leftChild = nodeByReplacingOperations(node.leftChild, operatorReplacementDict, functionReplacementDict);
+        const rightChild = nodeByReplacingOperations(node.rightChild, operatorReplacementDict, functionReplacementDict);
+        const targetOperatorId = operatorReplacementDict[+node.id] ?? node.id;
+        switch (+targetOperatorId) {
+            case OperatorIds.add:
+                return add(leftChild, rightChild);
+            case OperatorIds.substract:
+                return substract(leftChild, rightChild);
+            case OperatorIds.multiply:
+                return multiply(leftChild, rightChild);
+            case OperatorIds.divide:
+            case OperatorIds.fraction:
+                return frac(leftChild, rightChild);
+            case OperatorIds.power:
+                return power(leftChild, rightChild);
+            default:
+                return add(leftChild, rightChild);
+        }
+    }
+    else if (isFunctionNode(node)) {
+        const child = nodeByReplacingOperations(node.child, operatorReplacementDict, functionReplacementDict);
+        const targetFunctionId = functionReplacementDict[+node.id] ?? node.id;
+        switch (+targetFunctionId) {
+            case FunctionsIds.sqrt:
+                return sqrt(child);
+            case FunctionsIds.abs:
+                return abs(child);
+            case FunctionsIds.opposite:
+            default:
+                return opposite(child);
+        }
+    }
+    else {
+        return node;
+    }
+};
+const nodeBySubstitutingX = (node, strVar) => {
+    return parseAlgebraic(node.toTex().replaceAll("{x}", `"${strVar}"`));
+};
+const getInstruction = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `Sachant que $\\frac{${B}}{${A}} > 1$,
+  
+comparer $${B}$ et $${A}$.;`;
+};
+const getHint = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `En partant de 
+
+$$
+\\frac{${B}}{${A}} > 1
+$$
+  
+essaie de te ramener à 
+
+$$
+${B} <(ou >) ${A}
+$$
+
+par des opérations que l'on effectue à droite et à gauche de l'inégalité.`;
+};
+const getCorrection = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `On a :
+
+$$
+\\frac{${B}}{${A}} > 1
+$$
+
+On multiplie par $${A}$ des deux côtés. $${A} > 0$ donc on ne renverse pas l'inégalité :
+
+$$
+${B} > ${A}
+$$
+`;
+};
+const getAnswer = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `${B} > ${A}`;
+};
+const isAnswerValid = (ans, { ...identifiers }) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    const compSymbol = ans.includes(">")
+        ? ">"
+        : ans.includes("<")
+            ? "<"
+            : undefined;
+    if (!compSymbol) {
+        return false;
+    }
+    else {
+        return (compSymbol === ">" ? [B, A] : [A, B]).every((tex, i) => tex === ans.split(compSymbol)[i]);
+    }
+};
+const getPropositions = (nbProps, { ...identifiers }) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    const propositions = [];
+    addValidProp(propositions, coinFlip() ? `${A}<${B}` : `${B}>${A}`);
+    tryToAddWrongProp(propositions, coinFlip() ? `${B}<${A}` : `${A}>${B}`);
+    return shuffleProps(propositions, nbProps);
+};
+const getKeys = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return [
+        "inf",
+        "sup",
+        ...[A, B].map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareABUsingQuotientQuestion = () => {
+    const nbNodes = 2;
+    const n = randint(2, 150);
+    const [s, t] = [0, 1].map(() => randint(1, 100));
+    const refNode = add(s, abs(multiply(t, "{x}")));
+    let orderedNodesAndEvaluations;
+    let isValidNodes = false;
+    while (!isValidNodes) {
+        const nodeInner = nodeBySubstitutingX(sqrt(add(1, "{x}")), `${n.frenchify()}`);
+        const nodes = [...Array(nbNodes).keys()].map(() => nodeBySubstitutingX(nodeByReplacingOperations(refNode, randomOperatorReplacementDict(), randomFunctionReplacementDict()), `{${nodeInner.toTex()}}`));
+        try {
+            const evaluations = nodes.map((node) => node.evaluate());
+            //discard impossible
+            if (evaluations.some((evaluation) => isNaN(evaluation) || evaluation <= 0)) {
+                isValidNodes = false;
+                continue;
+            }
+            //discard same
+            if (evaluations.some((evaluation, i) => evaluations.filter((_, j) => j !== i).includes(evaluation))) {
+                isValidNodes = false;
+                continue;
+            }
+            orderedNodesAndEvaluations = nodes
+                .map((node, i) => {
+                return { node, evaluation: evaluations[i] };
+            })
+                .toSorted(({ evaluation: evaluation1 }, { evaluation: evaluation2 }) => evaluation1 - evaluation2);
+            isValidNodes = true;
+        }
+        catch (_) {
+            continue;
+        }
+    }
+    const orderedNodeIds = orderedNodesAndEvaluations.map(({ node }) => node.toIdentifiers());
+    return getQuestionFromIdentifiers({ orderedNodeIds });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const compareABUsingQuotient = {
+    id: "compareABUsingQuotient",
+    label: "Comparer deux nombres strictement positifs par le calcul de leur quotient",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareABUsingQuotientQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts

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

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareFracABWithFracAPlusCBPlusC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8KF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAoBnE,CAAC"}